博客园_风色の年代

SilverXna初体验：通用键盘输入设备

2011-12-13T12:29:00Z

继承上一节的设计思路，本节我们来补全SilverXna键盘输入设备的实现。

首先依然是常量和枚举定义：

/*-------------------------------------

代码清单：InputTypes.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Microsoft.Xna.Framework.Input
{
    // 鼠标设备动作
    public enum MouseAction
    {
        None,

        MouseLeftButtonDown,
        MouseLeftButtonUp,
        MouseRightButtonDown,
        MouseRightButtonUp,

        LostMouseCapture,
        MouseEnter,
        MouseLeave,
        MouseMove,

        MouseWheel
    }

    // 键盘设备动作
    public enum KeyboardAction
    {
        None,

        KeyDown,
        KeyUp
    }

    // 鼠标键状态
    public enum ButtonState
    {
        Released = 0,
        Pressed = 1
    }

    // 键盘键状态
    public enum KeyState
    {
        Up = 0,
        Down = 1
    }

    // 鼠标设备委托定义
    public delegate void MouseButtonHandler(MouseAction act, MouseButtonEventArgs e);
    public delegate void MouseCommonHandler(MouseAction act, MouseEventArgs e);
    public delegate void MouseWheelHandler(MouseAction act, MouseWheelEventArgs e);

    // 键盘设备委托定义
    public delegate void KeyboardHandler(KeyboardAction act, KeyEventArgs e);
}

接下来是键盘设备状态的定义，思路仿前一节的MouseState，参看Xna内部的定义亦可：

/*-------------------------------------

代码清单：KeyboardState.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Microsoft.Xna.Framework.Input
{
    /// <summary>
    /// 键盘设备状态
    /// </summary>
    public class KeyboardState
    {
        // 键位状态缓冲数组
        KeyState[] _KeyStateBuffer;

        // 构造函数
        public KeyboardState(KeyState[] KeyStateBuffer)
        {
            _KeyStateBuffer = KeyStateBuffer;
        }

        // 获得单键状态
        public KeyState this[Key key]
        {
            get
            {
                return _KeyStateBuffer[(int)key];
            }
        }

        // 检测单键是否按下
        public bool IsKeyDown(Key key)
        {
            return _KeyStateBuffer[(int)key] == KeyState.Down;
        }

        // 检测单键是否弹起
        public bool IsKeyUp(Key key)
        {
            return _KeyStateBuffer[(int)key] == KeyState.Up;
        }

        // 重载 != 运算符
        public static bool operator !=(KeyboardState a, KeyboardState b)
        {
            return !(a == b);
        }

        // 重载 == 运算符
        public static bool operator ==(KeyboardState a, KeyboardState b)
        {
            return a._KeyStateBuffer == b._KeyStateBuffer;
        }
    }
}

之后我们收集Silverlight控件的键盘响应事件，还原键盘设备输入状态即可。

Silverlight控件通用的键盘事件只有键位按下与弹起两种，因此实现起来相对简单。我们只需侦听并存储256个键位全部的按下和弹起状态即可。

/*-------------------------------------

代码清单：KeyboardInput.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Microsoft.Xna.Framework.Input
{
    public class KeyboardInput
    {
        // 256个键位状态
        static KeyState[] _KeyStateBuffer = new KeyState[256];

        // 监听根容器
        static UIElement _Handle;
        static public UIElement Handle
        { get { return _Handle; } }

        // 键盘事件定义
        static public event KeyboardHandler KeyboardEvent;

        // 初始化键盘输入设备
        static public void InitDevice(UIElement handle)
        {
            _Handle = handle;
            _Handle.KeyDown += new KeyEventHandler(_Handle_KeyDown);
            _Handle.KeyUp += new KeyEventHandler(_Handle_KeyUp);
        }

        // 获得键盘设备状态
        static public KeyboardState GetState()
        {
            return new KeyboardState((KeyState[])_KeyStateBuffer.Clone());
        }

        // 设备内置键位按下事件处理
        static void _Handle_KeyDown(object sender, KeyEventArgs e)
        {
            // 重置键位状态
            int KeyIndex = (int)e.Key;
            _KeyStateBuffer[KeyIndex] = KeyState.Down;
            // 支持外链键位按下事件
            if (KeyboardEvent != null)
                KeyboardEvent.Invoke(KeyboardAction.KeyDown, e);
        }

        // 设备内置键位弹起事件
        static void _Handle_KeyUp(object sender, KeyEventArgs e)
        {
            // 重置键位状态
            int KeyIndex = (int)e.Key;
            _KeyStateBuffer[KeyIndex] = KeyState.Up;
            // 支持外链键位弹起事件
            if (KeyboardEvent != null)
                KeyboardEvent.Invoke(KeyboardAction.KeyUp, e);
        }
    }
}

思路上完全仿上一节的MouseInput。然后我们将Silverlight默认根容器捆绑给构建好的键盘输入设备。

/*-------------------------------------

代码清单：MainPage.xaml.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace SilverXna
{
    public partial class MainPage : UserControl
    {
        Game _Game;
        public MainPage()
        {
            InitializeComponent();
            _Game = new Game(_GameSurface);
            // 初始化键盘、鼠标输入设备
            KeyboardInput.InitDevice(this);
            MouseInput.InitDevice(this);
        }
    }
}

最后是我们的主体代码：

/*-------------------------------------

代码清单：Game.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using System.Windows.Media.Animation;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.IO;

namespace SilverXna
{
    public class Game : SilverGame
    {
        SpriteBatch _SpriteBatch;
        Texture2D texture;

        public Game(DrawingSurface GameSurface)
            : base(GameSurface)
        { }

        public override void Initialize()
        {
            base.Initialize();
        }

        public override void LoadContent()
        {
            _SpriteBatch = new SpriteBatch(this);

            Stream imageStream = Content.OpenResourceStream("SilverXna","Content/SLXNA.png");
            texture = Content.LoadTexture2D(imageStream);
            base.LoadContent();
        }

        public override void UnloadContent()
        {
            base.UnloadContent();
        }

        Vector2 pos = new Vector2(100, 100);
        public override void Update(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            // 获得鼠标设备状态
            MouseState mouseState = MouseInput.GetState();
            // 更新纹理位置到鼠标左键单击点
            if (mouseState.LeftButton == ButtonState.Pressed)
            {
                pos = new Vector2((float)mouseState.X, (float)mouseState.Y);
            }
            // 获得键盘设备状态
            KeyboardState keyboardState = KeyboardInput.GetState();
            // 如果D键按下，则纹理向右移动一个像素
            if (keyboardState.IsKeyDown(Key.D))
            {
                pos = new Vector2(pos.X+1, pos.Y);
            }
            base.Update(DeltaTime, TotalTime);
        }

        public override void Draw(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, new Color(100, 149, 237, 255), 1.0f, 0);

            _SpriteBatch.Begin(BlendState.AlphaBlend);
            _SpriteBatch.Draw(texture, pos, new Color(255, 255, 255, 255));
            _SpriteBatch.End();

            base.Draw(DeltaTime, TotalTime);
        }
    }
}

D键按下时，纹理会缓慢右移。当然，如果大家高兴的话，还可以自行实现W、A、S键的位移效果。

以上两节没有太多的难点，但却充当着重要的基础作用，建议大家自行理解并掌握。

以上，谢谢 ^ ^

本文链接

SilverXna初体验：通用鼠标输入设备

2011-12-12T14:15:00Z

游戏中每一个逻辑实体都是一个小型的状态机，它们在游戏主循环的驱动之下不停的变换自身状态，游戏世界大千万物盛衰轮回由此产生。

习惯了Xna架构的程序员大都习惯这样定义一个生命体：

Class Being

{

public Being(){} // 构造函数

public bool Init(){} // 初始化

public void Update(){} // 逻辑驱动

public void Draw(){} // 渲染驱动

public void Dispose(){} // 释放对象

}

我们在Update中单独处理有关该生命体针对外部输入设备的响应动作，或者由update分离出一个

bool HandleInput(){}

方法来处理所有的输入设备响应。这样一来生命体之间则彼此独立，互不侵犯。

Silverlight中没有为我们提供必要的输入设备封装，而如果依赖于Sliverlight控件本身的应用特性，则我们将不得不把整个游戏世界绝大部分输入处理耦合到Sliverlight根容器中。——这显然不符合我们的要求。

在Xna中，我们可以很方便的使用

MouseState mousestate = Mouse.GetState();
KeyboardState keystate = Keyboard.GetState();

来获取鼠标和键盘设备状态。而封装相应的GUI时，则必须在此基础上人为的构建诸如控件的单击事件、拖动事件等等。——这个过程其实很繁琐。

而相对的，收集控件各个事件反推输入设备状态，却是一个相对容易的过程。

本节，我们就以这种思路构建一个通用于Xna状态机与Sliverlight事件响应二重机制的鼠标输入设备。

思路其实很简单。首先，声明通用枚举：

    // 鼠标设备动作
    public enum MouseAction
    {
        None,

        MouseLeftButtonDown,
        MouseLeftButtonUp,
        MouseRightButtonDown,
        MouseRightButtonUp,

        LostMouseCapture,
        MouseEnter,
        MouseLeave,
        MouseMove,

        MouseWheel
    }
    // 鼠标键状态
    public enum ButtonState
    {
        Released = 0,
        Pressed = 1
    }
    // 鼠标设备委托定义
    public delegate void MouseButtonHandler(MouseAction act, MouseButtonEventArgs e);
    public delegate void MouseCommonHandler(MouseAction act, MouseEventArgs e);
    public delegate void MouseWheelHandler(MouseAction act, MouseWheelEventArgs e);

比较好理解。接下来是一个可以容纳全部鼠标设备状态信息的类实体MouseState，我们可以完全仿Xna内部定义：

/*-------------------------------------

代码清单：MouseState.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Microsoft.Xna.Framework.Input
{
    /// <summary>
    /// 鼠标设备状态
    /// </summary>
    public class MouseState
    {
        // 横坐标
        double _X;
        public double X
        { get { return _X; } }

        // 纵坐标
        double _Y;
        public double Y
        { get { return _Y; } }

        // 滚轮位移
        int _ScrollWheel;
        public int ScrollWheel
        { get { return _ScrollWheel; } }

        // 左键状态(按下/弹起)
        ButtonState _LeftButton;
        public ButtonState LeftButton
        { get { return _LeftButton; } }

        // 右键状态(按下/弹起)
        ButtonState _RightButton;
        public ButtonState RightButton
        { get { return _RightButton; } }

        // 鼠标状态构造函数
        public MouseState(double x, double y, int scrollWheel, ButtonState leftButton, ButtonState rightButton)
        {
            _X = x;
            _Y = y;
            _ScrollWheel = scrollWheel;
            _LeftButton = leftButton;
            _RightButton = rightButton;
        }

        // 重载 != 运算符
        public static bool operator !=(MouseState left, MouseState right)
        {
            return !(left == right);
        }

        // 重载 == 运算符
        public static bool operator ==(MouseState left, MouseState right)
        {
            return left._X == right._X &&
                left._Y == right._Y &&
                left._ScrollWheel == right._ScrollWheel &&
                left._LeftButton == right._LeftButton &&
                left._RightButton == right._RightButton;
        }
    }
}

之后就是最关键的一环了：如何通过控件的应用事件还原得到鼠标设备状态信息。

Silverlight中，各类控件通用的鼠标事件无外乎9种：鼠标左键按下、鼠标左键弹起、鼠标右键按下、鼠标右键弹起、丢失鼠标、鼠标进入、鼠标离开、鼠标移动、滚轮移动。

只要我们针对这9种事件分别处理，即可还原得到鼠标设备的全部状态信息：

/*-------------------------------------

代码清单：MouseInput.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace Microsoft.Xna.Framework.Input
{
    /// <summary>
    /// 鼠标输入设备
    /// </summary>
    public class MouseInput
    {
        // 侦听根容器
        static UIElement _Handle;
        static public UIElement Handle
        { get { return _Handle; } }

        // Button类事件
        static public event MouseButtonHandler MouseButtonEvent;
        // Common类事件
        static public event MouseCommonHandler MouseCommonEvent;
        // Wheel类事件
        static public event MouseWheelHandler MouseWheelEvent;

        // 鼠标左键状态
        static ButtonState _LeftButton;
        // 鼠标右键状态
        static ButtonState _RightButton;
        // 鼠标横坐标
        static double _PosX;
        // 鼠标纵坐标
        static double _PosY;
        // 滚轮移动位移
        static int _ScrollWheel;

        // 鼠标输入设备初始化
        static public void InitDevice(UIElement handle)
        {
            _Handle = handle;

            // Button类事件响应：
            // 左键按下
            _Handle.MouseLeftButtonDown += new MouseButtonEventHandler(_Handle_MouseLeftButtonDown);
            // 左键弹起
            _Handle.MouseLeftButtonUp += new MouseButtonEventHandler(_Handle_MouseLeftButtonUp);
            // 右键按下
            _Handle.MouseRightButtonDown += new MouseButtonEventHandler(_Handle_MouseRightButtonDown);
            // 右键弹起
            _Handle.MouseRightButtonUp += new MouseButtonEventHandler(_Handle_MouseRightButtonUp);

            // Common类事件相应：
            // 丢失鼠标
            _Handle.LostMouseCapture += new MouseEventHandler(_Handle_LostMouseCapture);
            // 鼠标进入
            _Handle.MouseEnter += new MouseEventHandler(_Handle_MouseEnter);
            // 鼠标离开
            _Handle.MouseLeave += new MouseEventHandler(_Handle_MouseLeave);
            // 鼠标移动
            _Handle.MouseMove += new MouseEventHandler(_Handle_MouseMove);

            // Wheel类事件相应
            _Handle.MouseWheel += new MouseWheelEventHandler(_Handle_MouseWheel);
        }

        // 获得鼠标设备状态
        static public MouseState GetState()
        {
            return new MouseState(_PosX, _PosY, _ScrollWheel, _LeftButton, _RightButton);
        }

        // 设备内置左键按下事件处理
        static void _Handle_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            // 左键状态置为按下
            _LeftButton = ButtonState.Pressed;
            // 支持外链左键按下事件
            if (MouseButtonEvent != null)
                MouseButtonEvent.Invoke(MouseAction.MouseLeftButtonDown, e);
        }

        // 设备内置左键弹起事件处理
        static void _Handle_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            // 左键状态置为弹起
            _LeftButton = ButtonState.Released;
            // 支持外链左键弹起事件
            if (MouseButtonEvent != null)
                MouseButtonEvent.Invoke(MouseAction.MouseLeftButtonUp, e);
        }

        // 设备内置右键按下事件处理
        static void _Handle_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
        {
            // 右键状态置为按下
            _RightButton = ButtonState.Pressed;
            // 支持外链右键按下事件
            if (MouseButtonEvent != null)
                MouseButtonEvent.Invoke(MouseAction.MouseRightButtonDown, e);
        }

        // 设备内置右键弹起事件处理
        static void _Handle_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
        {
            // 右键状态置为弹起
            _RightButton = ButtonState.Released;
            // 支持外链右键弹起事件
            if (MouseButtonEvent != null)
                MouseButtonEvent.Invoke(MouseAction.MouseRightButtonUp, e);
        }

        // 设备内置鼠标丢失事件处理
        static void _Handle_LostMouseCapture(object sender, MouseEventArgs e)
        {
            // 支持外链鼠标丢失事件
            if (MouseCommonEvent != null)
                MouseCommonEvent.Invoke(MouseAction.LostMouseCapture, e);
        }

        // 设备内置鼠标进入事件处理
        static void _Handle_MouseEnter(object sender, MouseEventArgs e)
        {
            // 支持外链鼠标进入事件
            if (MouseCommonEvent != null)
                MouseCommonEvent.Invoke(MouseAction.MouseEnter, e);
        }

        // 设备内置鼠标离开事件处理
        static void _Handle_MouseLeave(object sender, MouseEventArgs e)
        {
            // 支持外链鼠标离开事件
            if (MouseCommonEvent != null)
                MouseCommonEvent.Invoke(MouseAction.MouseLeave, e);
        }

        // 设备内置鼠标移动事件处理
        static void _Handle_MouseMove(object sender, MouseEventArgs e)
        {
            // 获取鼠标位置
            System.Windows.Point pos = e.GetPosition(_Handle);
            // 更新设备横坐标
            _PosX = pos.X;
            // 更新设备纵坐标
            _PosY = pos.Y;
            // 支持外链鼠标移动事件
            if (MouseCommonEvent != null)
                MouseCommonEvent.Invoke(MouseAction.MouseMove, e);
        }

        // 设备内置鼠标滚轮事件
        static void _Handle_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            // 更新滚轮位移
            _ScrollWheel = e.Delta;
            // 支持外链鼠标滚轮事件
            if (MouseWheelEvent != null)
                MouseWheelEvent.Invoke(MouseAction.MouseWheel, e);
        }
    }
}

之后，我们便可如Xna一样，通过调用GetState()方法即时获得鼠标设备状态信息。

除此之外，该类的设计依然保留了Silverlight事件响应的特性。原本9种事件被重新归为3类，以静态化方式提供全局事件注册。——这样做无疑是有意义的，即使在任何一个小型的子类甚至子容器中，我们都可以随时注册并侦听根容器的全部事件。

接下来我们将Silverlight工程默认生成的根容器注册给刚刚构建好的鼠标输入设备：

/*-------------------------------------

代码清单：MainPage.xaml.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace SilverXna
{
    public partial class MainPage : UserControl
    {
        Game _Game;
        public MainPage()
        {
            InitializeComponent();
            _Game = new Game(_GameSurface);
            // 初始化鼠标输入设备
            MouseInput.InitDevice(this);
        }
    }
}

最后是主体代码：

/*-------------------------------------

代码清单：Game.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using System.Windows.Media.Animation;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.IO;

namespace SilverXna
{
    public class Game : SilverGame
    {
        SpriteBatch _SpriteBatch;
        Texture2D texture;

        public Game(DrawingSurface GameSurface)
            : base(GameSurface)
        { }

        public override void Initialize()
        {
            base.Initialize();
        }

        public override void LoadContent()
        {
            _SpriteBatch = new SpriteBatch(this);

            Stream imageStream = Content.OpenResourceStream("SilverXna","Content/SLXNA.png");
            texture = Content.LoadTexture2D(imageStream);
            base.LoadContent();
        }

        public override void UnloadContent()
        {
            base.UnloadContent();
        }

        Vector2 pos = new Vector2(100, 100);
        public override void Update(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            // 获得鼠标设备状态
            MouseState mouseState = MouseInput.GetState();
            // 更新纹理位置到鼠标左键单击点
            if (mouseState.LeftButton == ButtonState.Pressed)
            {
                pos = new Vector2((float)mouseState.X, (float)mouseState.Y);
            }
            base.Update(DeltaTime, TotalTime);
        }

        public override void Draw(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, new Color(100, 149, 237, 255), 1.0f, 0);

            _SpriteBatch.Begin(BlendState.AlphaBlend);
            _SpriteBatch.Draw(texture, pos, new Color(255, 255, 255, 255));
            _SpriteBatch.End();

            base.Draw(DeltaTime, TotalTime);
        }
    }
}

单击鼠标左键，纹理会自动移动到相应的位置。按住鼠标左键不放，则呈现拖动效果。大家不妨一试~

以上，谢谢 ^ ^

本文链接

每日一思，淡然行事。

2011-09-21T03:52:00Z

★古之所谓豪杰之士者，必有过人之节，人情有所不能忍者。匹夫见辱，拔剑而起，挺身而斗，此不足为勇也。天下有大勇者，卒然临之而不惊，无故加之而不怒，此其所挟持者甚大，而其志甚远也。 (http://www.m1905.com/vod/388475.shtml#flv)

★不要诋毁别人，因为不论所说真假，都是在自毁形象。

★生人面前不必刻意勉强自己，朋友面前亦不必刻意模仿别人。顺从心意，做真正的自己就好了 ^ ^

★不要让愤怒和仇恨蒙蔽自己理智的双眼。在伤害别人的同时，我们也在间接的伤害自己。

★不要对没有人生观和价值观的人寄予厚望，否则最终的结果只能是希望越高、失望越大

★人，必要时要学着放开羁绊、宽恕自己。与其永远的沉沦于过去，不如敞开心胸、面对未来。待到后来时，往事不过过眼云烟。

★人都是具备相当潜质的，所谓“做不到”很多时候只是我们在做之前的消极判断而已。

★每个人都在自己的生活中扮演主角，同时每个人都没有权利强迫他人成为自己的配角。

★人，可以恩怨分明，但决不可锱铢必较。一颗正直的心就当胸怀大志。

★行事之前，必定要明确其中的前因后果，方向失准很可能会引发所有人都不愿意看到的结局！

★武断绝不会与果断等同，具有远见卓识的人势必以善于借鉴他人的意见和建议为始。

★不要与小人斤斤计较，凡事自有公论。否则，在众人眼里，你跟他也只会变成半斤八两。

★解封自我心灵的首要步骤，应当先找回曾经的自我。

本文链接

Direct3D轮回：判断物体是否进入视野——外接体VS视截体

2011-09-16T08:48:00Z

对于尺寸较大甚至于无限尺寸的游戏场景，我们不可能要求设备每时每刻绘制场景内的所有物体，那样做没有任何意义，只会让3D设备吃不消。

理想情况下，我们只要绘制场景中进入我们视野的物体就够了~

我们在3D场景中的视野范围由Direct3D流水线中的摄影变换和投影变换共同决定。它的形状就好象一个被截去了顶端部分的四棱锥，因此，我们称其为“视截体”或“视域体”。

就如下图所示：

假如物体的某一部分进入这个视截体当中，我们就认为该物体已经进入了我们的视野，而后对其绘制即可。

但是如何来判断物体的某一部分是否与视截体相交呢？当然，遍历物体的所有顶点加以判断是最精确的做法，但不可行，因为性能上会受不了。

这里我们引入外接体的概念：外接体是一种具备标准形状且刚好可以容纳目标物体的最小体积单位。常见的有外接盒(长方体)、外接球、圆柱外接体、胶囊外接体等。其中最为常用的是外接盒和外接球。

它们的形状如下图所示：

通过判断外接体是否位于视野中从而断定物体是否可见。这种做法可以极大的改善性能，且在精确度上不会出现太大的偏差，是一种十分可行的方案。

下面，我们来看如何构造D3D中的外接体对象。

首先声明一个外接体基类CBoundingVolume：

/*-------------------------------------

代码清单：BoundingVolume.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "D3DInit.h"

#pragma once

// 外接体基类
class CBoundingVolume
{
public:
    CBoundingVolume(void);
    virtual ~CBoundingVolume(void);
public:
    virtual bool IsPointInside(D3DXVECTOR3 pos) = 0; // 单点检测
};

/*-------------------------------------

代码清单：BoundingVolume.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "BoundingVolume.h"

CBoundingVolume::CBoundingVolume(void)
{
}

CBoundingVolume::~CBoundingVolume(void)
{
}

它只是一种标准，且提供了一些规则以供子类重写。之后我们就可以在其基础上派上具体形状的子类了。

首先来看外接盒：

/*-------------------------------------

代码清单：BoundingBox.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#pragma once
#include "boundingvolume.h"

class CBoundingBox :
    public CBoundingVolume
{
public:
    CBoundingBox(void);
    CBoundingBox(D3DXVECTOR3 min,    // 外接盒最小坐标
                 D3DXVECTOR3 max);   // 外接盒最大坐标
    ~CBoundingBox(void);
public:
    D3DXVECTOR3 GetMin(){return m_Min;}
    void        SetMin(D3DXVECTOR3 min){m_Min = min;}
    D3DXVECTOR3 GetMax(){return m_Max;}
    void        SetMax(D3DXVECTOR3 max){m_Max = max;}
public:
    virtual bool IsPointInside(D3DXVECTOR3 pos);  // 单点检测
    static  bool ComputeBoundingBox(CBoundingBox* pOut, D3DXVECTOR3* pVertexBuffer, DWORD NumVertices, DWORD dwStride); //计算外接盒(静态、通用)
private:
    D3DXVECTOR3 m_Min;
    D3DXVECTOR3 m_Max;
};

/*-------------------------------------

代码清单：BoundingBox.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "BoundingBox.h"

CBoundingBox::CBoundingBox(void) : m_Min(D3DXVECTOR3_ZERO), m_Max(D3DXVECTOR3_ZERO)
{
}

CBoundingBox::CBoundingBox(D3DXVECTOR3 min, D3DXVECTOR3 max) : m_Min(min), m_Max(max)
{
}

CBoundingBox::~CBoundingBox(void)
{
}

bool CBoundingBox::ComputeBoundingBox(CBoundingBox* pOut, D3DXVECTOR3* pVertexBuffer, DWORD NumVertices, DWORD dwStride)
{
    D3DXVECTOR3 min = D3DXVECTOR3_ZERO;
    D3DXVECTOR3 max = D3DXVECTOR3_ZERO;
    if(FAILED(D3DXComputeBoundingBox(pVertexBuffer, NumVertices, dwStride, &min, &max)))
        return false;
    pOut = new CBoundingBox(min,max);
    return true;
}

bool CBoundingBox::IsPointInside(D3DXVECTOR3 pos)
{
    return pos.x >= m_Min.x && pos.y >= m_Min.y && pos.z >= m_Min.z &&
        pos.x <= m_Max.x && pos.y <= m_Max.y && pos.z <= m_Max.z;
}

对于一个长方体，我们没有必要知道全部8个顶点的坐标，而只需要知道其中的两个就可以了——xyz最小和最大的最小坐标和最大坐标。至于其他点，高等数学中的组合即可求得~

CBoundingBox重写了基类的单点检测方法，同时对外提供两种构造外接盒的方法：第一种直接传入两个关键坐标即可获得；第二种通过调用D3DAPI来实现，只需令其获知某物体的所有顶点信息即可，无需受制于某种专有的数据格式，便捷、通用。具体可参看代码。

然后是外接球的构建：

/*-------------------------------------

代码清单：BoundingSphere.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#pragma once
#include "boundingvolume.h"

class CBoundingSphere :
    public CBoundingVolume
{
public:
    CBoundingSphere(void);
    CBoundingSphere(D3DXVECTOR3 center,   // 外接球球心
                    float radius);        // 外接球半径
    ~CBoundingSphere(void);
public:
    D3DXVECTOR3 GetCenter(){return m_Center;}
    void        SetCenter(D3DXVECTOR3 center){m_Center = center;}
    float       GetRadius(){return m_Radius;}
    void        SetRadius(float radius){m_Radius = radius;}
public:
    virtual bool IsPointInside(D3DXVECTOR3 pos);  // 单点检测
    static  bool ComputeBoundingSphere(CBoundingSphere* pOut, D3DXVECTOR3* pVertexBuffer, DWORD NumVertices, DWORD dwStride); // 计算外接球(静态、通用)
private:
    D3DXVECTOR3 m_Center;
    float       m_Radius;
};

/*-------------------------------------

代码清单：BoundingSphere.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "BoundingSphere.h"

CBoundingSphere::CBoundingSphere(void) : m_Center(D3DXVECTOR3_ZERO), m_Radius(0.0f)
{
}

CBoundingSphere::CBoundingSphere(D3DXVECTOR3 center, float radius) : m_Center(center), m_Radius(radius)
{
}

CBoundingSphere::~CBoundingSphere(void)
{
}

bool CBoundingSphere::ComputeBoundingSphere(CBoundingSphere* pOut, D3DXVECTOR3 *pVertexBuffer, DWORD NumVertices, DWORD dwStride)
{
    D3DXVECTOR3 center = D3DXVECTOR3_ZERO;
    float radius = 0.0f;
    if(FAILED(D3DXComputeBoundingSphere(pVertexBuffer, NumVertices, dwStride, &center, &radius)))
        return false;
    pOut = new CBoundingSphere(center,radius);
    return true;
}

bool CBoundingSphere::IsPointInside(D3DXVECTOR3 pos)
{
    D3DXVECTOR3 distance = this->m_Center - pos;
    return sqrt(pow(distance.x,2) + pow(distance.y,2) + pow(distance.z,2)) <= this->m_Radius;
}

同样的，我们只需知道球心和半径即可描述该外接球。

CBoundingSphere同样提供单点检测和两种构造外接球的方法，同CBoundingBox类似，原理非常简单。

有了具体的外接盒、外接球，接下来我们来看视截体对象的构建方法。视截体可以理解为外接体的一种特殊类型，因此我们令CBoundingFrustum继承自CBoundingVolume即可：

/*-------------------------------------

代码清单：BoundingFrustum.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#pragma once
#include "boundingvolume.h"
#include "BoundingBox.h"
#include "BoundingSphere.h"

class CBoundingFrustum :
    public CBoundingVolume
{
public:
    CBoundingFrustum(void);
    ~CBoundingFrustum(void);
public:
    void Update(D3DXMATRIX Matrix);  // 更新视截体
    void Release(){};                // 释放视截体（可以不执行）
public:
    bool Contains(CBoundingBox* pBoundingBox);        // 判断外接盒是否被视截体包含
    bool Contains(CBoundingSphere* pBoundingSphere);  // 判断外接球是否被视截体包含
    virtual bool IsPointInside(D3DXVECTOR3 pos);      // 判断某一点是否位于视截体内
public:
    D3DXPLANE  GetNear()  {return m_planes[0];}       // 获得近、远、左、右、上、下六个平面
    D3DXPLANE  GetFar()   {return m_planes[1];}
    D3DXPLANE  GetLeft()  {return m_planes[2];}
    D3DXPLANE  GetRight() {return m_planes[3];}
    D3DXPLANE  GetTop()   {return m_planes[4];}
    D3DXPLANE  GetButtom(){return m_planes[5];}
    D3DXMATRIX GetMatrix(){return m_Matrix;}          // 获得视截体摄影·投影变换矩阵
private:
    D3DXPLANE   m_planes[6]; // 视截体六个平面
    D3DXMATRIX  m_Matrix;    // 视截体摄影·投影变换矩阵
};

/*-------------------------------------

代码清单：BoundingFrustum.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "BoundingFrustum.h"

CBoundingFrustum::CBoundingFrustum(void)
{
}

CBoundingFrustum::~CBoundingFrustum(void)
{
}

bool CBoundingFrustum::IsPointInside(D3DXVECTOR3 pos)
{
    for(int i=0;i<6;i++)
    {
        // 如果该点位于视截体六个面中任何一个面外，则判定为不被包含
        if( D3DXPlaneDotCoord(&m_planes[i], &pos) < 0.0f )
            return FALSE;
    }
    return TRUE;
}

bool CBoundingFrustum::Contains(CBoundingBox* pBoundingBox)
{
    D3DXVECTOR3 vertex[8];
    D3DXVECTOR3 min = pBoundingBox->GetMin();
    D3DXVECTOR3 max = pBoundingBox->GetMax();

    vertex[0] = min;
    vertex[1] = D3DXVECTOR3(max.x,min.y,min.z);
    vertex[2] = D3DXVECTOR3(min.x,max.y,min.z);
    vertex[3] = D3DXVECTOR3(min.x,min.y,max.z);
    vertex[4] = D3DXVECTOR3(max.x,max.y,min.z);
    vertex[5] = D3DXVECTOR3(min.x,max.y,max.z);
    vertex[6] = D3DXVECTOR3(max.x,min.y,max.z);
    vertex[7] = max;

    for (int i=0;i<8;i++)
    {
        // 如果外接盒的任何一个顶点位于视截体中，则判定为被包含
        if(IsPointInside(vertex[i]))
            return true;
    }
    return false;
}

bool CBoundingFrustum::Contains(CBoundingSphere* pBoundingSphere)
{
    for(int i=0;i<6;i++)
    {
        // 如果外接球球心位于视截体六个面中任何一个面外且其距离大于半径，则判定为不被包含
        if( D3DXPlaneDotCoord(&m_planes[i],&pBoundingSphere->GetCenter()) < -pBoundingSphere->GetRadius())
            return FALSE;
    }
    return TRUE;
}

void CBoundingFrustum::Update(D3DXMATRIX Matrix)
{
    // 更新视截体六个平面
    m_Matrix = Matrix;
    // 近平面
    m_planes[0].a = Matrix._14 + Matrix._13;
    m_planes[0].b = Matrix._24 + Matrix._23;
    m_planes[0].c = Matrix._34 + Matrix._33;
    m_planes[0].d = Matrix._44 + Matrix._43;
    D3DXPlaneNormalize(&m_planes[0], &m_planes[0]);  //所得平面要执行单位化，以利于后期计算
    // 远平面
    m_planes[1].a = Matrix._14 - Matrix._13;
    m_planes[1].b = Matrix._24 - Matrix._23;
    m_planes[1].c = Matrix._34 - Matrix._33;
    m_planes[1].d = Matrix._44 - Matrix._43;
    D3DXPlaneNormalize(&m_planes[1], &m_planes[1]);
    // 左平面
    m_planes[2].a = Matrix._14 - Matrix._11;
    m_planes[2].b = Matrix._24 - Matrix._21;
    m_planes[2].c = Matrix._34 - Matrix._31;
    m_planes[2].d = Matrix._44 - Matrix._41;
    D3DXPlaneNormalize(&m_planes[2], &m_planes[2]);
    // 右平面
    m_planes[3].a = Matrix._14 + Matrix._11;
    m_planes[3].b = Matrix._24 + Matrix._21;
    m_planes[3].c = Matrix._34 + Matrix._31;
    m_planes[3].d = Matrix._44 + Matrix._41;
    D3DXPlaneNormalize(&m_planes[3], &m_planes[3]);
    // 上平面
    m_planes[4].a = Matrix._14 - Matrix._12;
    m_planes[4].b = Matrix._24 - Matrix._22;
    m_planes[4].c = Matrix._34 - Matrix._32;
    m_planes[4].d = Matrix._44 - Matrix._42;
    D3DXPlaneNormalize(&m_planes[4], &m_planes[4]);
    // 下平面
    m_planes[5].a = Matrix._14 + Matrix._12;
    m_planes[5].b = Matrix._24 + Matrix._22;
    m_planes[5].c = Matrix._34 + Matrix._32;
    m_planes[5].d = Matrix._44 + Matrix._42;
    D3DXPlaneNormalize(&m_planes[5], &m_planes[5]);
}

与外接球及外接盒不同，我们需要六个平面来描述一个视截体。

我们通过传入摄影*投影矩阵来Update视截体的六个平面，除单点检测之外，同时提供重载的Contains函数判断其与外接盒或者外接球的包容关系，你也可以自行重载该方法，从而提供针对于其他形状外接体的判别机制。

其中的原理细节，大家可参看网友 laizhishen 的原创文章：http://hi.baidu.com/laizhishen/blog/item/3d206d209cca9c54ac34de46.html

至此我们仅需获得某物体对应的外接体，就可利用视截体进一步判断该物体是否可见、是否有必要绘制。

为观察可视化效果，我们来丰富CSimpleXMesh类的功能，使其具备加载并渲染.X model外接体的能力：

/*-------------------------------------

代码清单：SimpleXMesh.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "D3DInit.h"
#include "BoundingSphere.h"
#include "BoundingBox.h"

#pragma once

class CSimpleXMesh
{
public:
    CSimpleXMesh(void);
    ~CSimpleXMesh(void);
public:
    bool LoadXMesh(TCHAR* szXFileName);        // 加载.X网格
    void DrawXMesh();                          // 绘制.X网格
    void DrawXMesh(D3DXVECTOR3 pos);
    void DrawXMesh(D3DXMATRIX trans);
    void DrawXMeshSubset(int index);           // 绘制.X网格子集
    void Release();                            // 释放.X网格
public:
    bool LoadXMeshWithBoundingSphere(TCHAR* szXFileName);  // 加载.X网格(携带外接球)
    bool LoadXMeshWithBoundingBox(TCHAR* szXFileName);     // 加载.X网格(携带外接盒)
    void DrawXMeshWithBoundingBox();                       // 绘制.X网格(携带外接盒)
    void DrawXMeshWithBoundingSphere();                    // 绘制.X网格(携带外接球)
public:
    CBoundingBox*    GetBoundingBox()   {return m_pBoundingBox;}     // 获得外接盒
    CBoundingSphere* GetBoundingSphere(){return m_pBoundingSphere;}  // 获得外接球
public:
    DWORD        GetMaterialNum()           {return m_dwMaterials;}                     // 获得网格材质数
    D3DMATERIAL9 GetMaterial(int index)     {return m_pD3DMaterialArray[index];}        // 获得网格材质
    IDirect3DTexture9* GetTexture(int index){return m_ppDirect3DTextureArray[index];}   // 获得网格纹理
private:
    bool ComputeBoundingSphere();              // 计算外接球
    bool ComputeBoundingBox();                 // 计算外接盒
private:
    ID3DXBuffer* m_pAdjacencyBuffer;               // 邻接三角形信息缓冲区
    ID3DXBuffer* m_pMaterialBuffer;                // 材质缓冲区
    D3DMATERIAL9 *m_pD3DMaterialArray;             // 材质数组
    IDirect3DTexture9 **m_ppDirect3DTextureArray;  // 纹理数组
    DWORD m_dwMaterials;                           // 材质数
    ID3DXMesh* m_pD3DXMesh;                        // .X网格对象指针
private:
    CBoundingBox* m_pBoundingBox;               // 外接盒
    CBoundingSphere* m_pBoundingSphere;         // 外接球
    ID3DXMesh* m_pBoundingBoxMesh;              // 外接盒网格
    ID3DXMesh* m_pBoundingSphereMesh;           // 外接球网格
};

/*-------------------------------------

代码清单：SimpleXMesh.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "SimpleXMesh.h"
#include "D3DGame.h"

extern IDirect3DDevice9 *g_pD3DDevice;

CSimpleXMesh::CSimpleXMesh(void):m_pAdjacencyBuffer(NULL),
                                 m_pMaterialBuffer(NULL),
                                 m_pD3DMaterialArray(NULL),
                                 m_ppDirect3DTextureArray(NULL),
                                 m_dwMaterials(0),
                                 m_pD3DXMesh(NULL),
                                 m_pBoundingBox(NULL),
                                 m_pBoundingSphere(NULL),
                                 m_pBoundingBoxMesh(NULL),
                                 m_pBoundingSphereMesh(NULL)
{

}

CSimpleXMesh::~CSimpleXMesh(void)
{

}

bool CSimpleXMesh::LoadXMesh(TCHAR* szXFileName)
{
    // 加载X网格
    if(FAILED(D3DXLoadMeshFromX(
        szXFileName,                            //.X文件名
        D3DXMESH_MANAGED,                       //内存托管模式
        g_pD3DDevice,                           //Direct3D设备
        &m_pAdjacencyBuffer,                    //邻接三角形信息缓冲区指针
        &m_pMaterialBuffer,                     //材质缓冲区指针
        0,                                      //特效缓冲区指针，由于没有用到特效，我们在这里置0即可
        &m_dwMaterials,                         //材质数
        &m_pD3DXMesh                            //得到的X网格
        ))){
            return false;
    }
    // 错误判断
    if(m_pMaterialBuffer==NULL || m_dwMaterials==0)
        return false;
    // 获得材质缓冲区指针
    D3DXMATERIAL* pD3DXMaterial=(D3DXMATERIAL*)m_pMaterialBuffer->GetBufferPointer();
    if(pD3DXMaterial!=NULL){
        // 初始化材质数组
        m_pD3DMaterialArray=new D3DMATERIAL9[m_dwMaterials];
        // 初始化纹理数组
        m_ppDirect3DTextureArray=new IDirect3DTexture9*[m_dwMaterials];
        // 遍历材质缓冲区，填充材质及纹理数组
        for(DWORD i=0;i<m_dwMaterials;i++){
            m_pD3DMaterialArray[i]=pD3DXMaterial[i].MatD3D;
            if(pD3DXMaterial[i].pTextureFilename!=NULL)
            {
                if(FAILED(D3DXCreateTextureFromFile(g_pD3DDevice,pD3DXMaterial[i].pTextureFilename,&m_ppDirect3DTextureArray[i]))){
                    m_ppDirect3DTextureArray[i]=NULL;
                }
            }
            else
            {
                m_ppDirect3DTextureArray[i]=NULL;
            }
        }
    }
    // 网格数据优化
    m_pD3DXMesh->OptimizeInplace(
        D3DXMESHOPT_COMPACT  |
        D3DXMESHOPT_ATTRSORT |
        D3DXMESHOPT_VERTEXCACHE,                           //优化模式，具体参看SDK
        (DWORD*)m_pAdjacencyBuffer->GetBufferPointer(),    //邻接三角形信息缓冲区指针
        NULL, NULL, NULL);                                 //参看SDK

    // 有效数据已经填充到材质及纹理数组，释放材质缓冲区
    m_pMaterialBuffer->Release();
    // 网格数据优化完毕，释放邻接三角形信息缓冲区
    m_pAdjacencyBuffer->Release();
    // 当然，这两个缓冲区的释放放到最后的Release函数里也没有问题 ^ ^
    return true;
}

bool CSimpleXMesh::LoadXMeshWithBoundingBox(TCHAR* szXFileName)
{
    return LoadXMesh(szXFileName)&&ComputeBoundingBox();
}

bool CSimpleXMesh::LoadXMeshWithBoundingSphere(TCHAR *szXFileName)
{
    return LoadXMesh(szXFileName)&&ComputeBoundingSphere();
}

void CSimpleXMesh::DrawXMesh()
{
    // 绘制X网格
    for(DWORD i=0;i<m_dwMaterials;i++)
    {
        g_pD3DDevice->SetMaterial(&m_pD3DMaterialArray[i]);
        g_pD3DDevice->SetTexture(0,m_ppDirect3DTextureArray[i]);
        m_pD3DXMesh->DrawSubset(i);
    }
}

void CSimpleXMesh::DrawXMesh(D3DXVECTOR3 pos)
{
    D3DXMATRIX matWorld;
    g_pD3DDevice->GetTransform(D3DTS_WORLD,&matWorld);
    D3DXMATRIX newMatWorld;
    D3DXMatrixTranslation(&newMatWorld,pos.x,pos.y,pos.z);
    g_pD3DDevice->SetTransform(D3DTS_WORLD,&newMatWorld);
    DrawXMesh();
    g_pD3DDevice->SetTransform(D3DTS_WORLD,&matWorld);
}

void CSimpleXMesh::DrawXMesh(D3DXMATRIX trans)
{
    D3DXMATRIX matWorld;
    g_pD3DDevice->GetTransform(D3DTS_WORLD,&matWorld);
    g_pD3DDevice->SetTransform(D3DTS_WORLD,&trans);
    DrawXMesh();
    g_pD3DDevice->SetTransform(D3DTS_WORLD,&matWorld);
}

void CSimpleXMesh::DrawXMeshSubset(int index)
{
    m_pD3DXMesh->DrawSubset(index);
}

void CSimpleXMesh::DrawXMeshWithBoundingBox()
{
    DrawXMesh();
    // 生成半透明材质
    D3DMATERIAL9 blue;
    D3DCOLORVALUE blueColor;
    blueColor.a = 1.0f;
    blueColor.r = 0.0f;
    blueColor.g = 0.0f;
    blueColor.b = 1.0f;
    blue.Ambient  = blueColor;
    blue.Diffuse  = blueColor;
    blue.Specular = blueColor;
    blue.Power    = 20;
    blue.Diffuse.a = 0.10f;
    g_pD3DDevice->SetMaterial(&blue);
    g_pD3DDevice->SetTexture(0, 0);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
    g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    // 绘制外接盒网格
    if(m_pBoundingBoxMesh)
        m_pBoundingBoxMesh->DrawSubset(0);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
}

void CSimpleXMesh::DrawXMeshWithBoundingSphere()
{
    DrawXMesh();
    // 生成半透明材质
    D3DMATERIAL9 green;
    D3DCOLORVALUE greenColor;
    greenColor.a = 1.0f;
    greenColor.r = 0.0f;
    greenColor.g = 1.0f;
    greenColor.b = 0.0f;
    green.Ambient  = greenColor;
    green.Diffuse  = greenColor;
    green.Specular = greenColor;
    green.Power    = 20;
    green.Diffuse.a = 0.10f;
    g_pD3DDevice->SetMaterial(&green);
    g_pD3DDevice->SetTexture(0, 0);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
    g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    // 绘制外接球网格
    if(m_pBoundingSphereMesh)
        m_pBoundingSphereMesh->DrawSubset(0);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
}

bool CSimpleXMesh::ComputeBoundingSphere()
{
    HRESULT hr = 0;
    BYTE* v = 0;
    D3DXVECTOR3 center; float radius;
    // 计算得到外接球球心及半径
    m_pD3DXMesh->LockVertexBuffer(0, (void**)&v);
    hr = D3DXComputeBoundingSphere(
        (D3DXVECTOR3*)v,
        m_pD3DXMesh->GetNumVertices(),
        D3DXGetFVFVertexSize(m_pD3DXMesh->GetFVF()),
        &center,
        &radius);
    m_pD3DXMesh->UnlockVertexBuffer();
    if( FAILED(hr) )
        return false;
    // 生成外接球
    m_pBoundingSphere = new CBoundingSphere(center,radius);
    // 生成外接球网格
    hr = D3DXCreateSphere(g_pD3DDevice,
        m_pBoundingSphere->GetRadius(),
        20,20,&m_pBoundingSphereMesh,0);
    if( FAILED(hr) )
        return false;
    return true;
}

bool CSimpleXMesh::ComputeBoundingBox()
{
    HRESULT hr = 0;
    BYTE* v = 0;
    D3DXVECTOR3 min; D3DXVECTOR3 max;
    // 计算得到外接盒最大坐标与最小坐标
    m_pD3DXMesh->LockVertexBuffer(0, (void**)&v);
    hr = D3DXComputeBoundingBox(
        (D3DXVECTOR3*)v,
        m_pD3DXMesh->GetNumVertices(),
        D3DXGetFVFVertexSize(m_pD3DXMesh->GetFVF()),
        &min,
        &max);
    m_pD3DXMesh->UnlockVertexBuffer();
    if( FAILED(hr) )
        return false;
    // 生成外接盒
    m_pBoundingBox = new CBoundingBox(min,max);
    // 生成外接盒网格
    hr = D3DXCreateBox(g_pD3DDevice,
        m_pBoundingBox->GetMax().x - m_pBoundingBox->GetMin().x,
        m_pBoundingBox->GetMax().y - m_pBoundingBox->GetMin().y,
        m_pBoundingBox->GetMax().z - m_pBoundingBox->GetMin().z,
        &m_pBoundingBoxMesh, 0);
    if( FAILED(hr) )
        return false;
    return true;
}

void CSimpleXMesh::Release(){
    // 释放纹理数组
    for(DWORD i=0;i<m_dwMaterials;i++){
        ReleaseCOM(m_ppDirect3DTextureArray[i]);
    }
    delete[] m_ppDirect3DTextureArray;
    // 释放材质数组
    delete[] m_pD3DMaterialArray;
    // 释放网格对象
    ReleaseCOM(m_pD3DXMesh);
    if(m_pBoundingBox != NULL)
        delete m_pBoundingBox;
    if(m_pBoundingSphere != NULL)
        delete m_pBoundingSphere;
}

最后是主体代码和效果图：

/*-------------------------------------

代码清单：D3DGame.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DGame.h"
#include "D3DSprite.h"
#include "SpriteBatch.h"
#include "D3DFont.h"
#include "D3DCamera.h"
#include "BaseTerrain.h"
#include "SimpleXMesh.h"
#include "BoundingFrustum.h"
#include "BoundingSphere.h"
#include <stdio.h>
#include <time.h>

//---通用全局变量

HINSTANCE  g_hInst;
HWND       g_hWnd;
D3DXMATRIX g_matWorld;
D3DXMATRIX g_matProjection;
D3DPRESENT_PARAMETERS g_D3DPP;

//---D3D全局变量

IDirect3D9       *g_pD3D           = NULL;
IDirect3DDevice9 *g_pD3DDevice     = NULL;
CMouseInput      *g_pMouseInput    = NULL;
CKeyboardInput   *g_pKeyboardInput = NULL;
CD3DSprite       *g_pSprite        = NULL;
CD3DCamera       *g_pD3DCamera     = NULL;
CBaseTerrain     *g_pBaseTerrain   = NULL;
CSpriteBatch     *g_pSpriteBatch   = NULL;
CD3DFont         *g_pFont          = NULL;
CD3DFont         *g_pFont2         = NULL;
CSimpleXMesh     *g_pMesh          = NULL;
CBoundingFrustum *g_pBoundingFrustum = NULL;

//---全局函数
D3DLIGHT9 InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color);  // 初始化光源
void      BeginEffect();  // 开启光照特效(固定功能流水线)
void      EndEffect();    // 关闭光照特效(固定功能流水线)

void Initialize(HINSTANCE hInst, HWND hWnd)
{
    g_hInst = hInst;
    g_hWnd  = hWnd;
    InitD3D(&g_pD3D, &g_pD3DDevice, g_D3DPP, g_matProjection, hWnd);
    g_pMouseInput = new CMouseInput;
    g_pMouseInput->Initialize(hInst,hWnd);
    g_pKeyboardInput = new CKeyboardInput;
    g_pKeyboardInput->Initialize(hInst,hWnd);
    srand(time(0));
}

void LoadContent()
{
    g_pD3DCamera = new CD3DCamera;
    g_pSprite = new CD3DSprite(g_pD3DDevice);
    // 声明并加载两种不同的字体
    g_pFont = new CD3DFont(g_pD3DDevice,&g_D3DPP);
    g_pFont->LoadFont("宋体",8);
    g_pFont2 = new CD3DFont(g_pD3DDevice,&g_D3DPP);
    g_pFont2->LoadFont("隶书",16);
    // 声明并加载模型极其外接球
    g_pMesh = new CSimpleXMesh;
    g_pMesh->LoadXMeshWithBoundingSphere("bigship1.x");
    // 声明视截体
    g_pBoundingFrustum = new CBoundingFrustum;
}

void Update(CGameTime* gameTime)
{
    // 统计FPS
    gameTime->CalcFPS();
    g_pMouseInput->GetState();
    g_pKeyboardInput->GetState();
    g_pD3DCamera->Update();
    // 更新视截体
    g_pBoundingFrustum->Update(g_pD3DCamera->GetViewMatrix() * g_matProjection);
}

void Draw(CGameTime* gameTime)
{
    bool isInView;
    g_pD3DDevice->SetTransform(D3DTS_VIEW,&g_pD3DCamera->GetViewMatrix());
    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);
    if(SUCCEEDED(g_pD3DDevice->BeginScene()))
    {
        // 判断Model是否位于视野中
        isInView = g_pBoundingFrustum->Contains(g_pMesh->GetBoundingSphere());
        // 如果Model位于视野中则绘制，否则不予绘制
        if(isInView)
        {
            BeginEffect();
            g_pMesh->DrawXMeshWithBoundingSphere();
            EndEffect();
        }
        // 开启Sprite绘制
        g_pSprite->Begin(D3DXSPRITE_ALPHABLEND);
        // 显示FPS
        g_pSprite->DrawText(g_pFont, gameTime->ShowFPS(), D3DXVECTOR2(100,100), D3DXCOLOR_WHITE);
        if(isInView)
            g_pSprite->DrawText(g_pFont2, "飞船可见！", D3DXVECTOR2(100,150), D3DXCOLOR_BLUE);
        else
            g_pSprite->DrawText(g_pFont2, "飞船不可见！", D3DXVECTOR2(100,150), D3DXCOLOR_RED);
        // 结束Sprite绘制
        g_pSprite->End();
        g_pD3DDevice->EndScene();
    }
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}

void UnloadContent()
{
    ReleaseCOM(g_pBoundingFrustum);
    ReleaseCOM(g_pMesh);
    ReleaseCOM(g_pFont2);
    ReleaseCOM(g_pFont);
    ReleaseCOM(g_pSprite);
}

void Dispose()
{
    ReleaseCOM(g_pKeyboardInput);
    ReleaseCOM(g_pMouseInput);
    ReleaseCOM(g_pD3DDevice);
    ReleaseCOM(g_pD3D);
}

D3DLIGHT9 InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color)
{
    D3DLIGHT9 light;
    ::ZeroMemory(&light, sizeof(light));
    light.Type      = D3DLIGHT_DIRECTIONAL;
    light.Ambient   = *color * 0.4f;
    light.Diffuse   = *color;
    light.Specular  = *color * 0.6f;
    light.Direction = *direction;
    return light;
}

void BeginEffect()
{
    D3DXVECTOR3 dir(-1.0f, -1.0f, 1.0f);
    D3DXCOLOR col(1.0f, 1.0f, 1.0f, 1.0f);
    D3DLIGHT9 light = InitDirectionalLight(&dir, &col);
    g_pD3DDevice->SetLight(0, &light);
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING,         TRUE);
    g_pD3DDevice->LightEnable(0, true);
    g_pD3DDevice->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_SPECULARENABLE,   TRUE);
}

void EndEffect()
{
    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING,         FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_NORMALIZENORMALS, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_SPECULARENABLE,   FALSE);
}

以上，谢谢 ^ ^

本文链接

Direct3D轮回：文字显示及FPS效率统计

2011-09-14T02:46:00Z

组成一个完整游戏的元素大体来说其实只有两种：图形和字体。

前几节涉及的内容大都为图形元素，本节我们来看如何在Direct3D中实现简单的字体绘制~

Direct3D中的文字绘制主要依赖于ID3DXFont接口对象。我们事先构造一个D3DXFONT_DESC结构体，详细描述所要生成字体的信息，而后调用D3DXCreateFontIndirect函数即可获得ID3DXFont接口对象。

那么接下来依然是以人性化接口为目的的二次封装~

/*-------------------------------------

代码清单：D3DFont.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "D3DInit.h"

#pragma once

class CD3DFont
{
public:
    CD3DFont(IDirect3DDevice9 *pDevice, D3DPRESENT_PARAMETERS* pD3DPP);
    ~CD3DFont(void);
public:
    bool LoadFont(char *fontName, UINT fontSize);    // 加载字体
    void Release();                                  // 释放字体
public:
    ID3DXFont* GetFontHandle(){return m_pFont;}      // 获得字体句柄
    RECT       GetFontArea(){return m_FontArea;}     // 获得字体默认有效区域(屏幕区域)
private:
    IDirect3DDevice9* m_pDevice;                     // 3D设备
    ID3DXFont* m_pFont;                              // 字体对象
    RECT m_FontArea;                                 // 字体默认有效区域
};

/*-------------------------------------

代码清单：D3DFont.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DFont.h"

CD3DFont::CD3DFont(IDirect3DDevice9 *pDevice, D3DPRESENT_PARAMETERS* pD3DPP) : m_pDevice(pDevice), m_pFont(NULL)
{
    m_FontArea.left = 0;
    m_FontArea.top = 0;
    m_FontArea.right = pD3DPP->BackBufferWidth;
    m_FontArea.bottom = pD3DPP->BackBufferHeight;
}

CD3DFont::~CD3DFont(void)
{
}

bool CD3DFont::LoadFont(char *fontName, UINT fontSize)
{
    // 生成D3DXFONT_DESC结构体并初始化
    D3DXFONT_DESC d3dxFont;
    ZeroMemory(&d3dxFont,sizeof(d3dxFont));
    _tcscpy(d3dxFont.FaceName,fontName);
    d3dxFont.Width = fontSize;
    d3dxFont.Height = fontSize * 2;
    d3dxFont.Weight = 100;
    d3dxFont.Italic = false;
    d3dxFont.CharSet = DEFAULT_CHARSET;
    // 创建字体对象
    if(FAILED(D3DXCreateFontIndirect(m_pDevice,&d3dxFont,&m_pFont))){
        return false;
    }
    return true;
}

void CD3DFont::Release()
{
    ReleaseCOM(m_pFont);
}

接下来，为我们先前构造的CD3DSprite添加几个重载函数，赋予其绘制字体的能力：

D3DSprite.h

public:
    void DrawText(
        CD3DFont* pFont,                     // 字体对象
        char *szString,                      // 文字内容
        RECT &DesRect,                       // 目标区域
        DWORD AlignFormat,                   // 对齐格式
        D3DCOLOR Color);                     // 字体颜色
    void DrawText(
        CD3DFont* pFont,
        char *szString,
        RECT &DesRect,
        D3DCOLOR Color = D3DXCOLOR_WHITE);
    void DrawText(
        CD3DFont *pFont,
        char *szString,
        D3DXVECTOR2 &Pos,                    // 字体位置
        D3DCOLOR Color = D3DXCOLOR_WHITE);

D3DSprite.cpp

void CD3DSprite::DrawText(CD3DFont *pFont, char *szString, RECT &DesRect, D3DCOLOR Color)
{
    DrawText(pFont, szString, DesRect, DT_TOP|DT_LEFT, Color);
}

void CD3DSprite::DrawText(CD3DFont *pFont, char *szString, D3DXVECTOR2 &Pos, D3DCOLOR Color)
{
    RECT DesRect;
    DesRect.left = Pos.x;
    DesRect.top = Pos.y;
    DesRect.right = pFont->GetFontArea().right;
    DesRect.bottom = pFont->GetFontArea().bottom;
    DrawText(pFont, szString, DesRect, Color);
}

void CD3DSprite::DrawText(CD3DFont* pFont, char *szString, RECT &DesRect, DWORD AlignFormat, D3DCOLOR Color)
{
    pFont->GetFontHandle()->DrawText(m_pSprite, szString, -1, &DesRect, AlignFormat, Color);
}

看到这里，大家可能会觉得奇怪。由第三个重载函数我们不难看出：最终的DrawText调用方依然是ID3DXFont接口对象，那么为什么我们要将字体绘制的功能封装到CD3DSprite对象中呢？

由DirectX说明文档可知，ID3DXFont.DrawText函数的第一个参数是一个宿主ID3DXSprite接口对象，尽管允许其为空，但要想实现更高效率的字体绘制，则我们需要指定一个专属的ID3DXSprite接口对象。

从Xna的SpriteBatch对象封装的手法上，我们可以略微看出端倪，尽管巧合的几率更大些，但各种因素促使我们有理由这么做~

实现字体绘制功能之后，我们再来实现一个可以统计游戏运行效率的计时装置。

FPS 即 Frames Per Second(每秒传输帧数)，是我们用于测算游戏运行效率的通用标准。如果游戏在执行密集型计算或大批量渲染时，FPS值依然能达到一个正常标准(通常为60帧/s)，则说明我们的游戏运行效率良好。

下面就来看这个游戏计时器的实现及使用方法：

/*-------------------------------------

代码清单：GameTime.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include <stdio.h>
#include "mmsystem.h"

#pragma once

class CGameTime
{
public:
    CGameTime(void);
    ~CGameTime(void);
public:
    void Start();     // 游戏计时器启动
    void Tick();      // 游戏计时器心跳(每次Update时调用一次)
    void Stop();      // 游戏计时器停止
public:
    float GetTotalTicks()     {return m_totalTicks;}          // 获得系统启动时间
    float GetTotalGameTime()  {return m_totalGameTime;}       // 获得游戏运作时间
    float GetElapsedGameTime(){return m_elapsedGameTime;}     // 获得单帧时间差
public:
    void  CalcFPS();                                          // 计算FPS(每次Update时调用一次)(需显式调用，默认不执行)
    char* ShowFPS()           {return m_strFPS;}              // 显示FPS(字符串)
    float GetFPS()            {return m_FPS;}                 // 获得FPS(float数值)
private:
    float m_totalTicks;          // 系统启动时间
    float m_totalGameTime;       // 游戏运作时间
    float m_elapsedGameTime;     // 单帧运作时间
    float m_previousTicks;       // 前次时间戳
    float m_startTicks;          // 启动时间戳
    DWORD m_FrameCnt;            // 帧总数(计算FPS辅助变量)
    float m_TimeElapsed;         // 消耗时间(计算FPS辅助变量)
    float m_FPS;                 // FPS值
    char  m_strFPS[13];          // FPS串
};

/*-------------------------------------

代码清单：GameTime.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "GameTime.h"

#pragma comment(lib, "winmm.lib")

CGameTime::CGameTime(void) : m_totalTicks(0.0f),
                             m_totalGameTime(0.0f),
                             m_elapsedGameTime(0.0f),
                             m_previousTicks(0.0f),
                             m_startTicks(0.0f),
                             m_FrameCnt(0),
                             m_TimeElapsed(0.0f),
                             m_FPS(0.0f)
{
    // 初始FPS串
    char* strFPS = "FPS:0000000\0";
    memcpy(m_strFPS,strFPS,13);
}

CGameTime::~CGameTime(void)
{
}

void CGameTime::Start()
{
    // 计时器启动时先捕捉起始时间戳及前次时间戳
    m_startTicks = (float)timeGetTime();
    m_previousTicks = m_startTicks;
}

void CGameTime::Tick()
{
    // 每次心跳时更新系统时间戳
    m_totalTicks = (float)timeGetTime();
    // 单帧时间差 = 系统时间戳 - 前次时间戳
    m_elapsedGameTime = m_totalTicks - m_previousTicks;
    // 游戏运作时间 = 系统时间戳 - 起始时间戳
    m_totalGameTime = m_totalTicks - m_startTicks;
    // 更新前次时间戳
    m_previousTicks = m_totalTicks;
}

void CGameTime::Stop()
{
    // 计时器停止时全部变量归0
    m_totalTicks = 0.0f;
    m_totalGameTime = 0.0f;
    m_elapsedGameTime = 0.0f;
    m_previousTicks = 0.0f;
    m_startTicks = 0.0f;
    m_FrameCnt = 0;
    m_TimeElapsed = 0.0f;
    m_FPS = 0.0f;
}

void CGameTime::CalcFPS()
{
    // 帧数递增
    m_FrameCnt++;
    // 累计时间递增
    m_TimeElapsed += m_elapsedGameTime;
    // 当累计时间超过1秒时
    if(m_TimeElapsed >= 1000.0f)
    {
        // FPS测算
        m_FPS = (float)m_FrameCnt * 1000.0f / m_TimeElapsed;
        sprintf(&m_strFPS[4], "%f", m_FPS);
        m_strFPS[12] = '\0';
        // 处理累计时间及帧数
        m_TimeElapsed -= 1000.0f;
        m_FrameCnt    = 0;
    }
}

很显然，CGameTime的Start和Stop是超越了游戏主循环的，而这部分对CD3DGame而言是透明的，我们需要将CGameTime部分相关代码放置到Win32App的默认代码中：

int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);

     // TODO: 在此放置代码。
    MSG msg;
    HACCEL hAccelTable;

    // 初始化全局字符串
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_KEN3DGAME, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);

    // 执行应用程序初始化:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }

    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_KEN3DGAME));

    LoadContent();
    ZeroMemory(&msg, sizeof(MSG));

    // 声明游戏计时器对象，该对象随入口方法的结束而自动释放(生命周期终止)
    CGameTime GameTime;
    // 计时器随主循环的启动而启动
    GameTime.Start();
    while(msg.message != WM_QUIT) {
        if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        // 计时器心跳
        GameTime.Tick();
        Update(&GameTime);
        Draw(&GameTime);
    }
    // 计时器随主循环的停止而停止
    GameTime.Stop();
    UnloadContent();
    Dispose();

    return (int) msg.wParam;
}

以上为变更之后的Win32入口函数。我们可以看到CD3DGame的Update和Draw函数参数不再是单纯的float值，而是功能完整的游戏计数器指针。

接下来，我们来看CD3DGame主体代码：

如下效果图：

可能大家会有疑问：只绘制了缪缪几行文字，简单统计一下数据，为什么FPS只有60帧左右呢？

DirectX9.0及之后版本在原有基础上做了改进，我们可以通过D3DPRESENT_PARAMETERS.PresentationInterval认为的控制3D设备的刷新行为。

其中，D3DPRESENT_INTERVAL_IMMEDIATE代表即时刷新；D3DPRESENT_INTERVAL_ONE代表屏幕刷新率标准；D3DPRESENT_INTERVAL_DEFAULT为默认方式，与D3DPRESENT_INTERVAL_ONE接近但FPS稍低。

如我们所知，超出显示器刷新频率的刷新标准没有实际意义，而且会空耗D3D设备性能。因此，如果不是效率极端测试，不建议用D3DPRESENT_INTERVAL_IMMEDIATE，只需用D3DPRESENT_INTERVAL_ONE即可。

除去以上三种标准，剩余的还有D3DPRESENT_INTERVAL_TWO、D3DPRESENT_INTERVAL_THREE、D3DPRESENT_INTERVAL_FOUR，它们不太常用，而且使用方式也不像前三种那样单纯，大家感兴趣可自行翻看DX帮助文档，在此不再赘述。

由于ID3DXFont底层是基于Gdi的，因此虽然功能强大，但却在效率上不被看好。不过由于游戏大都以图形元素为主要表现形式，而文字大都为辅助作用，因此在一般情况下上述方法应该是够用的。

以上，谢谢 ^ ^

本文链接

SilverXna初体验：SpriteBatch和基本的内容管道

2011-09-03T11:39:00Z

昨天，各大IT网站纷纷刊登了Silverlight5 RC发布的消息。于是，第一时间到官网载了安装包，更新了本地的Silverlight5 Beta版本~

Silverlight5 RC的发布无疑是具有里程碑意义的，Xna3D API也在原有Beta版本基础上作了进一步扩展。

新增了BasicEffect、RenderTarget等Shader常用功能，上一节提到的Xna 3D数学库也被划入到Sliverlight原生资源当中，无需再从外部引用。

不过，目前SilverXna中的一系列绘制函数依然停留在顶点级，缺乏诸如SpriteBatch、ContentManager、Model等必要高级机制的支持。

曾一度感觉无奈，直到看过trcj兄编写的ElGameEngine之后才恍然大悟：所谓3D，只要显卡能画三角形(硬件加速)，支持矩阵运算(顶点着色)，支持纹理采样(像素着色)，再给几个API其实就够用了。

本节，我们来自行实现SpriteBatch的相关功能，以供SilverXna中简单的2D图形绘制之用~

熟知3DGraphy机制的人应该都知道，3D领域中的2D，其实只是3D图元绘制的一种特例：两个三角形对接构成一个矩形表面，而后由目标纹理采样得到各点颜色。至于顶点运算的部分，世界矩阵及摄影矩阵固定使用单位矩阵，投影矩阵采用正交投影替代原有的透视投影即可。

大家还记得Direct3D轮回《为D3D量身定做SpriteBatch》一文吗？它其实就是对2D图形原理的一个很好的说明~

下面，我们就把Direct3D中的代码搬到Silverlight里，得到SilverXna专用的SpriteBatch对象~

由于Xna已经彻底舍弃了固定功能流水线(完全硬件加速)，而SpriteBatch的绘制并不需要用到BasicEffect中的诸多功能，因此我们不妨自己来编写Shader。

Silverlight5 RC初步支持了效果框架，BasicEffect使用过程中对于EffectTechniquehe和Pass的解析均是标准而到位的。

不过，由Effect的定义来推断，我们似乎还不能随心所欲的引入外部的.fx到Silverlight。以下依然沿用Beta版的做法~

编写顶点着色器：

/*-------------------------------------

代码清单：SpriteBatch.vs.hlsl
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

// 世界·摄影·投影变换矩阵
float4x4 WorldViewProj : register(c0);

// 顶点着色器输入结构
struct VertexData
{
  float3 Position : POSITION;  // 位置
  float4 Color : COLOR;        // 颜色
  float2 UV : TEXCOORD;        // 纹理坐标
};

// 顶点着色器输出结构
struct VertexShaderOutput
{
  float4 Position : POSITION;
  float4 Color : COLOR0;
  float2 UV : TEXCOORD0;
};

VertexShaderOutput main(VertexData vertex)
{
  VertexShaderOutput output;
  output.Position = mul(float4(vertex.Position,1), WorldViewProj); // 顶点位置变换
  output.Color = vertex.Color; // 传递颜色
  output.UV = vertex.UV;       // 传递纹理坐标
  return output;
}

编写像素着色器：

/*-------------------------------------

代码清单：SpriteBatch.ps.hlsl
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

// 目标纹理及采样器
texture cubeTexture : register(t0);
sampler cubeSampler = sampler_state
{
    texture = <cubeTexture>;
};

// 像素着色器输入结构
struct VertexShaderOutput
{
  float4 Color : COLOR0;
  float2 UV : TEXCOORD0;
};

float4 main(VertexShaderOutput vertex) : COLOR
{
  return vertex.Color *= tex2D(cubeSampler, vertex.UV).rgba; // 返回颜色
}

接下来，我们要使用DirectX命令行工具对其进行编译，得到顶点着色器及像素着色器可用的二进制文件~

微软Silverlight5官方实例中为我们封装了两个批处理文件，可用于x64和x86机型顶点着色器及像素着色器的编译生成~

>> 点击下载：

CompileShaders.bat.rar

执行相应的批处理文件：

则我们将得到3个新文件：

SpriteBatch.vs（顶点着色器）

SpriteBatch.ps（像素着色器）

hlslcomplog.txt（编译日志）

我们将得到的SpriteBatch.vs和SpriteBatch.ps引入工程，而后将其属性设置为Resource即可~

完成Shader之后就可以开始着手编写SpriteBatch主体代码了~

首先是顶点结构定义：

    public struct VertexPositionColorTexture
    {
        public Vector3 _Position; // 位置
        public Color _Color;       // 颜色
        public Vector2 _UV;        // 纹理坐标
// 构造函数
        public VertexPositionColorTexture(Vector3 position, Color color, Vector2 uv)
        {
            _Position = position;
            _Color = color;
            _UV = uv;
        }
// 顶点声明
        public static readonly VertexDeclaration VertexDeclaration = new VertexDeclaration(
            new VertexElement(0, VertexElementFormat.Vector3, VertexElementUsage.Position, 0),
            new VertexElement(12, VertexElementFormat.Color, VertexElementUsage.Color, 0),
            new VertexElement(16, VertexElementFormat.Vector2, VertexElementUsage.TextureCoordinate, 0)
            );
    }

接下来是SpriteBatch的编写：

/*-------------------------------------

代码清单：SpriteBatch.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media.Animation;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.IO;

namespace Microsoft.Xna.Framework.Graphics
{
    public class SpriteBatch
    {
        struct SpriteNode
        {
            public Rectangle _DesRect;        // 目标区域
            public Rectangle _SurRect;        // 纹理区域
            public float _layerDepth;         // 深度(Z坐标)
            public Color _Color;              // 色相

            public SpriteNode(Rectangle DesRect, Rectangle SurRect, float layerDepth, Color Color)
            {
                _DesRect = DesRect;
                _SurRect = SurRect;
                _layerDepth = layerDepth;
                _Color = Color;
            }
        }

        Texture2D _ActiveTexture;                       // 活动纹理
        VertexShader _VertexShader;                     // 顶点着色器
        PixelShader _PixelShader;                       // 像素着色器

        Matrix _ViewMatrix;                             // 摄影矩阵
        Matrix _ProjMatrix;                             // 投影矩阵

        List<SpriteNode> _SpriteNodeList;               // 精灵节点列表

        SilverGame _SilverGame;                         // SilverGame实体
        public SilverGame SilverGame
        { get { return _SilverGame; } }

        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="game">SilverGame实体对象</param>
        public SpriteBatch(SilverGame game)
        {
            _SilverGame = game;
            _SpriteNodeList = new List<SpriteNode>();
            // 加载SpriteBatch顶点着色器及像素着色器
            Stream shaderStream = Application.GetResourceStream(new Uri(@"SilverXna.Game.Library;component/SpriteBatch/SpriteBatch.vs", UriKind.Relative)).Stream;
            _VertexShader = VertexShader.FromStream(_SilverGame.GraphicsDevice, shaderStream);
            shaderStream = Application.GetResourceStream(new Uri(@"SilverXna.Game.Library;component/SpriteBatch/SpriteBatch.ps", UriKind.Relative)).Stream;
            _PixelShader = PixelShader.FromStream(_SilverGame.GraphicsDevice, shaderStream);
        }

        /// <summary>
        /// 开始绘制
        /// </summary>
        /// <param name="SpriteBlendMode">Blend模式</param>
        public void Begin(BlendState SpriteBlendMode)
        {
            Begin(SpriteBlendMode, _PixelShader);
        }

        /// <summary>
        /// 开始绘制
        /// </summary>
        /// <param name="SpriteBlendMode">Blend模式</param>
        /// <param name="pixelShader">像素着色器</param>
        public void Begin(BlendState SpriteBlendMode, PixelShader pixelShader)
        {
            // 得到摄影坐标
            _ViewMatrix = Matrix.Identity;
            // 得到投影坐标
            _ProjMatrix = Matrix.CreateOrthographicOffCenter(0, _SilverGame.ActualSize.X, _SilverGame.ActualSize.Y, 0, 0, 1);
            Matrix viewprojMatrix = _ViewMatrix * _ProjMatrix;
            // 设置Blend模式
            _SilverGame.GraphicsDevice.BlendState = SpriteBlendMode;
            // 设置顶点着色器
            _SilverGame.GraphicsDevice.SetVertexShader(_VertexShader);
            // 传入世界·摄影·投影矩阵参数(世界矩阵默认为单位矩阵)
            _SilverGame.GraphicsDevice.SetVertexShaderConstantFloat4(0, ref viewprojMatrix);
            // 设置像素着色器
            _SilverGame.GraphicsDevice.SetPixelShader(pixelShader);
        }

        /// <summary>
        /// 结束绘制
        /// </summary>
        public void End()
        {
            // 结束之前Flush一次全部精灵节点
            Flush();
        }

        /// <summary>
        /// 单帧投递
        /// </summary>
        /// <param name="DesRect">目标区域</param>
        /// <param name="SurRect">纹理区域</param>
        /// <param name="layerDepth">深度坐标</param>
        /// <param name="Color">颜色值</param>
        private void PostFrame(Rectangle DesRect, Rectangle SurRect, float layerDepth, Color Color)
        {
            // 新增精灵节点
            _SpriteNodeList.Add(new SpriteNode(DesRect, SurRect, layerDepth, Color));
        }

        /// <summary>
        /// 合并当前全部精灵节点的顶点缓冲及索引缓冲，一次性完成绘制
        /// </summary>
        private void Flush()
        {
            // 异常判别
            if (_SpriteNodeList == null || _ActiveTexture == null || _SpriteNodeList.Count == 0)
            {
                return;
            }
            // 生成顶点缓冲数组
            var vb = new VertexPositionColorTexture[_SpriteNodeList.Count * 4];
            // 生成索引缓冲数组
            var ib = new UInt16[_SpriteNodeList.Count * 6];
            int i = 0;
            foreach (SpriteNode node in _SpriteNodeList)
            {
                // 将纹理区域折合成uv坐标
                float Txcrd_LU_u = node._SurRect.Left / _ActiveTexture.Width;
                float Txcrd_LU_v = node._SurRect.Top / _ActiveTexture.Height;

                float Txcrd_RU_u = node._SurRect.Right / _ActiveTexture.Width;
                float Txcrd_RU_v = node._SurRect.Top / _ActiveTexture.Height;

                float Txcrd_RD_u = node._SurRect.Right / _ActiveTexture.Width;
                float Txcrd_RD_v = node._SurRect.Bottom / _ActiveTexture.Height;

                float Txcrd_LD_u = node._SurRect.Left / _ActiveTexture.Width;
                float Txcrd_LD_v = node._SurRect.Bottom / _ActiveTexture.Height;

                // 填充顶点缓冲区数据
                vb[i * 4] = new VertexPositionColorTexture(new Vector3(node._DesRect.Left, node._DesRect.Top, node._layerDepth), node._Color, new Vector2(Txcrd_LU_u, Txcrd_LU_v));
                vb[i * 4 + 1] = new VertexPositionColorTexture(new Vector3(node._DesRect.Right, node._DesRect.Top, node._layerDepth), node._Color, new Vector2(Txcrd_RU_u, Txcrd_RU_v));
                vb[i * 4 + 2] = new VertexPositionColorTexture(new Vector3(node._DesRect.Right, node._DesRect.Bottom, node._layerDepth), node._Color, new Vector2(Txcrd_RD_u, Txcrd_RD_v));
                vb[i * 4 + 3] = new VertexPositionColorTexture(new Vector3(node._DesRect.Left, node._DesRect.Bottom, node._layerDepth), node._Color, new Vector2(Txcrd_LD_u, Txcrd_LD_v));

                // 填充索引缓冲区数据
                ib[i * 6] = (UInt16)(i * 4);
                ib[i * 6 + 1] = (UInt16)(i * 4 + 1);
                ib[i * 6 + 2] = (UInt16)(i * 4 + 2);
                ib[i * 6 + 3] = (UInt16)(i * 4);
                ib[i * 6 + 4] = (UInt16)(i * 4 + 2);
                ib[i * 6 + 5] = (UInt16)(i * 4 + 3);

                i++;
            }

            // 顶点缓冲、索引缓冲赋值
            VertexBuffer _VertexBuffer = new VertexBuffer(_SilverGame.GraphicsDevice, VertexPositionColorTexture.VertexDeclaration, vb.Length, BufferUsage.WriteOnly);
            _VertexBuffer.SetData(0, vb, 0, vb.Length, 0);
            IndexBuffer _IndexBuffer = new IndexBuffer(_SilverGame.GraphicsDevice, IndexElementSize.SixteenBits, ib.Length, BufferUsage.WriteOnly);
            _IndexBuffer.SetData(0, ib, 0, ib.Length);

            // 设置活动纹理
            _SilverGame.GraphicsDevice.Textures[0] = _ActiveTexture;
            // 设置顶点缓冲
            _SilverGame.GraphicsDevice.SetVertexBuffer(_VertexBuffer);
            // 设置索引缓冲
            _SilverGame.GraphicsDevice.Indices = _IndexBuffer;
            // 三角形绘制
            _SilverGame.GraphicsDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, vb.Length, 0, ib.Length / 3);
            // 精灵节点清空
            _SpriteNodeList.Clear();
        }

        public void Draw(Texture2D texture, Rectangle destinationRectangle, Rectangle sourceRectangle, float layerDepth, Color color)
        {
            // 异常判断
            if (texture == null)
                return;
            // _ActiveTexture第一次赋值
            if (_ActiveTexture == null)
                _ActiveTexture = texture;
            // 如果当前纹理与活动纹理不同
            if (_ActiveTexture != texture)
            {
                // 则Flush一次先前的全部节点
                Flush();
                // 更新活动纹理
                _ActiveTexture = texture;
            }
            // 投递本帧
            PostFrame(destinationRectangle, sourceRectangle, layerDepth, color);
        }

        // 一系列重载的Draw函数

        public void Draw(Texture2D texture, Rectangle destinationRectangle, Rectangle sourceRectangle, Color color)
        {
            Draw(texture, destinationRectangle, sourceRectangle, 0, color);
        }

        public void Draw(Texture2D texture, Rectangle destinationRectangle, Color color)
        {
            Draw(texture, destinationRectangle, new Rectangle(0, 0, texture.Width, texture.Height), color);
        }

        public void Draw(Texture2D texture, Vector2 position, Color color)
        {
            Draw(texture, new Rectangle((int)position.X, (int)position.Y, texture.Width, texture.Height), new Rectangle(0, 0, texture.Width, texture.Height), color);
        }
    }
}

因为是纯粹的3D硬件加速，所以跟传统Silverlight应用层面的Image相比，其优势是不言而喻的。这一点园友黯淡的橘子已在其博文中给出了相关证明，大家可以参看他的文章~

我们简单的封装一下Silverlight资源加载的相关方法，构成一个内容管道的雏形，以便于后续功能扩展之用~

/*-------------------------------------

代码清单：ContentManager.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.IO;

namespace Microsoft.Xna.Framework.Content
{
    public class ContentManager
    {
        // SilverGame主体对象
        SilverGame _SilverGame;
        public SilverGame SilverGame
        {
            get
            {
                return _SilverGame;
            }
        }

        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="game"></param>
        public ContentManager(SilverGame game)
        {
            _SilverGame = game;
        }

        /// <summary>
        /// 打开资源流
        /// </summary>
        /// <param name="uri">相对Uri</param>
        /// <returns>资源流</returns>
        public Stream OpenResourceStream(Uri uri)
        {
            return Application.GetResourceStream(uri).Stream;
        }

        /// <summary>
        /// 打开资源流
        /// </summary>
        /// <param name="ProjectName">工程名</param>
        /// <param name="uri">相对Uri(字符串形式)</param>
        /// <returns>资源流</returns>
        public Stream OpenResourceStream(string ProjectName, string uri)
        {
            return Application.GetResourceStream(new Uri(ProjectName + @";component/" + uri, UriKind.Relative)).Stream;
        }

        /// <summary>
        /// 加载Texture2D
        /// </summary>
        /// <param name="stream">资源流</param>
        /// <returns>所得Texture2D</returns>
        public Texture2D LoadTexture2D(Stream stream)
        {
            Texture2D texture;
            var image = new BitmapImage();
            image.SetSource(stream);
            texture = new Texture2D(_SilverGame.GraphicsDevice, image.PixelWidth, image.PixelHeight, false, SurfaceFormat.Color);
            image.CopyTo(texture);
            return texture;
        }

        /// <summary>
        /// 加载顶点着色器
        /// </summary>
        /// <param name="stream">资源流</param>
        /// <returns>所得顶点着色器</returns>
        public VertexShader LoadVertexShader(Stream stream)
        {
            VertexShader vertexShader;
            vertexShader = VertexShader.FromStream(_SilverGame.GraphicsDevice, stream);
            return vertexShader;
        }

        /// <summary>
        /// 加载像素着色器
        /// </summary>
        /// <param name="stream">资源流</param>
        /// <returns>所得像素着色器</returns>
        public PixelShader LoadPixelShader(Stream stream)
        {
            PixelShader pixelShader;
            pixelShader = PixelShader.FromStream(_SilverGame.GraphicsDevice, stream);
            return pixelShader;
        }
    }
}

这里的ContentManager只是一个雏形，肯定是没办法跟Xna原生态的ContentManager相提并论的 ^ ^

我们在SilverGame基类中声明一个ContentManager对象，以便令全部的子类持有这个对象：

SilverGame.cs

        ContentManager _Content;
        public ContentManager Content
        { get { return _Content; } }
        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="GameSurface">所关联的渲染表面</param>
        public SilverGame(DrawingSurface GameSurface)
        {
            _GameSurface = GameSurface;
            _Content = new ContentManager(this);
            _ActualSize = new Vector2((float)_GameSurface.ActualWidth, (float)_GameSurface.ActualHeight);
            // 自动为渲染表面关联必要的事件
            _GameSurface.Loaded += new RoutedEventHandler(_GameSurface_Loaded);
            _GameSurface.Unloaded += new RoutedEventHandler(_GameSurface_Unloaded);
            _GameSurface.Draw += new EventHandler<DrawEventArgs>(_GameSurface_Draw);
            _GameSurface.SizeChanged += new SizeChangedEventHandler(_GameSurface_SizeChanged);
            // 虚函数调用——初始化
            this.Initialize();
        }

然后是主体代码：

/*-------------------------------------

代码清单：Game.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media.Imaging;
using System.Windows.Media.Animation;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.IO;

namespace SilverXna
{
    public class Game : SilverGame
    {
        SpriteBatch _SpriteBatch;
        Texture2D texture;

        public Game(DrawingSurface GameSurface)
            : base(GameSurface)
        { }

        public override void Initialize()
        {
            base.Initialize();
        }

        public override void LoadContent()
        {
            _SpriteBatch = new SpriteBatch(this);

            Stream imageStream = Content.OpenResourceStream("SilverXna","Content/SLXNA.png");
            texture = Content.LoadTexture2D(imageStream);
            base.LoadContent();
        }

        public override void UnloadContent()
        {
            base.UnloadContent();
        }

        public override void Update(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            base.Update(DeltaTime, TotalTime);
        }

        public override void Draw(TimeSpan DeltaTime, TimeSpan TotalTime)
        {
            GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, new Color(100, 149, 237, 255), 1.0f, 0);

            _SpriteBatch.Begin(BlendState.AlphaBlend);
            _SpriteBatch.Draw(texture, new Vector2(100, 100), new Color(255, 255, 255, 255));
            _SpriteBatch.End();

            base.Draw(DeltaTime, TotalTime);
        }
    }
}

SpriteBatch的用法跟原生态的Xna环境下的用法是一模一样的，相关绘制方法可以在现有基础上随意重载扩展，并且兼容Shazzam全部的ps特效，你只需借助Content对象Load得到相应的PixelShader，而后传入SpriteBatch重载的Begin函数中即可 ^ ^

最后是效果图：

虽然目前Silverlight5 RC版本下的Xna框架还不够尽善尽美，但我们看到的是光明的前景，未来值得期待 ^ ^

以上，谢谢~

=============================================

>> Silverlight5 RC资源下载及工具包语言版本冲突问题的解决方法：

http://space.cnblogs.com/group/topic/49727/

本文链接

SilverXna初体验：基本游戏框架——古老的三段式

2011-09-01T13:42:00Z

今年上半年，微软Silverlight5 Beta发布，随之而来的是更多的惊喜与更加亮眼的新特性。

其中最令我在意的一点便是针对Xna 3D API的支持，虽然目前Silverlight5 Beta版中的Xna还只是完整Xna框架中的一个轻量子集，但自此之后web3D已再不是遥不可及的抽象概念~

本节我们就以一个古老的三段式框架为例，看Silverlight如何帮我们将Xna实实在在的嵌入到网页中 ^ ^

Silverlight中Xna 3D API的调用，以硬件加速为起始，以DrawingSurface为基础容器，因此我们首先要做的便是对这两者的显示支持。

1.在宿主网页中添加硬件加速支持。只需在Silverlight插件标签内嵌入如下代码即可 ^ ^

2.Silverlight主页面MainPage.xaml中添加一个DrawingSurface元素。

之后，只需为我们的_GameSurface注册一个Draw事件，便可在其函数体中获取3D设备并进行绘制了，相应方法的调用几乎跟Xna环境下一模一样。就好像下面这样：

void _GameSurface_Draw(object sender, DrawEventArgs e)
{
    // 清空渲染表面
    e.GraphicsDevice.Clear(ClearOptions.Target | ClearOptions.DepthBuffer,
         Color.Transparent, 1.0f, 0);

    // 绘制图形
    e.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

    // 强制重绘
    e.InvalidateSurface();
}

用过Xna的朋友，看上面的代码是不是感觉挺眼熟？呵呵~

这里，为提高代码的重用性，我们仿Xna下的Game类，创建一个专属于Silverlight环境的SilverGame~

/*-------------------------------------

代码清单：SilverGame.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Silverlight;

namespace Microsoft.Xna.Framework
{
    public class SilverGame
    {
        /// <summary>
        /// 初始GraphicsDeviceManager
        /// </summary>
        public GraphicsDeviceManager Graphics
        {
            get
            {
                return GraphicsDeviceManager.Current;
            }
        }

        /// <summary>
        /// Xna3D图形设备GraphicsDevice
        /// </summary>
        GraphicsDevice _GraphicsDevice;
        public GraphicsDevice GraphicsDevice
        {
            get
            {
                if (_GraphicsDevice == null)
                    return GraphicsDeviceManager.Current.GraphicsDevice;
                else
                    return _GraphicsDevice;
            }
            set
            {
                _GraphicsDevice = value;
            }
        }

        /// <summary>
        /// 渲染表面尺寸
        /// </summary>
        Vector2 _ActualSize;
        public Vector2 ActualSize
        {
            get
            {
                return _ActualSize;
            }
            set
            {
                _ActualSize = value;
            }
        }

        /// <summary>
        /// 渲染表面DrawingSurface
        /// </summary>
        DrawingSurface _GameSurface;
        public DrawingSurface GameSurface
        { get { return _GameSurface; } }

        /// <summary>
        /// 重置GraphicsDevice
        /// </summary>
        /// <param name="graphicsDevice"></param>
        void ResetDevice(GraphicsDevice graphicsDevice)
        { _GraphicsDevice = graphicsDevice; }

        /// <summary>
        /// 重置渲染表面尺寸
        /// </summary>
        /// <param name="actualSize"></param>
        void ResetActualSize(Vector2 actualSize)
        { _ActualSize = actualSize; }

        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="GameSurface">所关联的渲染表面</param>
        public SilverGame(DrawingSurface GameSurface)
        {
            _GameSurface = GameSurface;

            _ActualSize = new Vector2((float)_GameSurface.ActualWidth, (float)_GameSurface.ActualHeight);
            // 自动为渲染表面关联必要的事件
            _GameSurface.Loaded += new RoutedEventHandler(_GameSurface_Loaded);
            _GameSurface.Unloaded += new RoutedEventHandler(_GameSurface_Unloaded);
            _GameSurface.Draw += new EventHandler<DrawEventArgs>(_GameSurface_Draw);
            _GameSurface.SizeChanged += new SizeChangedEventHandler(_GameSurface_SizeChanged);
            // 虚函数调用——初始化
            this.Initialize();
        }

        void _GameSurface_Loaded(object sender, RoutedEventArgs e)
        {
            // 虚函数调用——加载资源
            this.LoadContent();
        }

        void _GameSurface_Unloaded(object sender, RoutedEventArgs e)
        {
            // 虚函数调用——释放资源
            this.UnloadContent();
        }

        void _GameSurface_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            // 渲染表面大小改变时自动重置其尺寸
            Size s = e.NewSize;
            this.ResetActualSize(new Vector2((float)s.Width, (float)s.Height));
        }

        void _GameSurface_Draw(object sender, DrawEventArgs args)
        {
            // 重置图形设备
            this.ResetDevice(args.GraphicsDevice);
            // 虚函数调用——更新
            this.Update(args.DeltaTime, args.TotalTime);
            // 虚函数调用——渲染
            this.Draw(args.DeltaTime, args.TotalTime);
            // 强制重绘
            args.InvalidateSurface();
        }

        //----一系列虚函数，供子类重写----//

        public virtual void Initialize()
        { }

        public virtual void LoadContent()
        { }

        public virtual void UnloadContent()
        { }

        public virtual void Update(TimeSpan DeltaTime, TimeSpan TotalTime)
        { }

        public virtual void Draw(TimeSpan DeltaTime, TimeSpan TotalTime)
        { }
    }
}

功能上还相当简单，不过没关系，后续我们会以它为基础，为整个工程添枝加叶 ^ ^

值得一提的是，SilverGame中对于已持有的Xna3D设备GraphicsDevice的处理方式。

工程构建之初，Silverlight体系会自动提供一个静态的图形设备，用于加载或生成诸如特效、纹理等资源，我们可以通过GraphicsDeviceManager.Current.GraphicsDevice获得。

而绘制过程中，处于DrawingSurface内部安全机制考虑，我们必须使用从事件体DrawEventArgs中获取的GraphicsDevice引用进行图形绘，如果此时再使用原来的静态设备进行绘制，将被视作非法操作~

SilverGame的处理方式使得这一过程对外透明化，用户通过GraphicsDevice属性获取到的图形设备将永远是合法的图形设备 ^ ^

SilverGame构建完毕之后，是工程范例的第三步：

3.引入SilverGame类，在此基础上派生其子类Game，作为游戏的主逻辑框架。

与标准的Xna工程同样的处理手法，呵呵~ 之后是最后一步：

4.派生子类与主页面中的DrawingSurface进行关联~

/*-------------------------------------

代码清单：MainPage.xaml.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Silverlight;

namespace SilverXna
{
    public partial class MainPage : UserControl
    {
        Game _Game;
        public MainPage()
        {
            InitializeComponent();
            _Game = new Game(_GameSurface);
        }
    }
}

这样，一个无限复用的SilverXna框架就诞生了。结构仿Xna工程框架，古老而经典的三段式 ^ ^

来看效果：

久违了的那片蓝色，只不过宿主窗口已不再WinForm，而是实实在在的WebPage ^ ^

(注：如果看不到效果，请执行右击--->Silverlight配置--->权限--->允许站点权限即可)

最后再提醒大家一点，SilverXna工程中用到的一系列3D数据类型，需要微软官方提供的数学库最为基本支撑，后续的范例默认情况下都需要首先对其引入~

>> 以下点击下载：

http://files.cnblogs.com/kenkao/Microsoft.Xna.Framework.Math.rar

>> Silverlight5 Beta环境搭建资源及微软官方范例下载：

http://space.cnblogs.com/group/topic/47416/

以上，谢谢 ^ ^

==========================================================

后记：

Silverlight5 RC版于同一天发布，惊喜来的太快，令人措手不及 ^ ^

以下是本节SilverGame对象的更新版本：

/*-------------------------------------

代码清单：SilverGame.cs
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Graphics;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;

namespace Microsoft.Xna.Framework
{
    public class SilverGame
    {
        /// <summary>
        /// 初始GraphicsDeviceManager
        /// </summary>
        public GraphicsDeviceManager Graphics
        {
            get
            {
                return GraphicsDeviceManager.Current;
            }
        }

        /// <summary>
        /// Xna3D图形设备GraphicsDevice
        /// </summary>
        GraphicsDevice _GraphicsDevice;
        public GraphicsDevice GraphicsDevice
        {
            get
            {
                return GraphicsDeviceManager.Current.GraphicsDevice;
            }
            set
            {
                _GraphicsDevice = value;
            }
        }

        ContentManager _Content;
        public ContentManager Content
        { get { return _Content; } }

        /// <summary>
        /// 渲染表面尺寸
        /// </summary>
        Vector2 _ActualSize;
        public Vector2 ActualSize
        {
            get
            {
                return _ActualSize;
            }
            set
            {
                _ActualSize = value;
            }
        }

        /// <summary>
        /// 渲染表面DrawingSurface
        /// </summary>
        DrawingSurface _GameSurface;
        public DrawingSurface GameSurface
        { get { return _GameSurface; } }

        /// <summary>
        /// 重置渲染表面尺寸
        /// </summary>
        /// <param name="actualSize"></param>
        void ResetActualSize(Vector2 actualSize)
        { _ActualSize = actualSize; }

        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="GameSurface">所关联的渲染表面</param>
        public SilverGame(DrawingSurface GameSurface)
        {
            _GameSurface = GameSurface;
            _Content = new ContentManager(this);
            _ActualSize = new Vector2((float)_GameSurface.ActualWidth, (float)_GameSurface.ActualHeight);
            // 自动为渲染表面关联必要的事件
            _GameSurface.Loaded += new RoutedEventHandler(_GameSurface_Loaded);
            _GameSurface.Unloaded += new RoutedEventHandler(_GameSurface_Unloaded);
            _GameSurface.Draw += new EventHandler<DrawEventArgs>(_GameSurface_Draw);
            _GameSurface.SizeChanged += new SizeChangedEventHandler(_GameSurface_SizeChanged);
            // 虚函数调用——初始化
            this.Initialize();
        }

        void _GameSurface_Loaded(object sender, RoutedEventArgs e)
        {
            // 虚函数调用——加载资源
            this.LoadContent();
        }

        void _GameSurface_Unloaded(object sender, RoutedEventArgs e)
        {
            // 虚函数调用——释放资源
            this.UnloadContent();
        }

        void _GameSurface_SizeChanged(object sender, SizeChangedEventArgs e)
        {
            // 渲染表面大小改变时自动重置其尺寸
            Size s = e.NewSize;
            this.ResetActualSize(new Vector2((float)s.Width, (float)s.Height));
        }

        void _GameSurface_Draw(object sender, DrawEventArgs args)
        {
            // 虚函数调用——更新
            this.Update(args.DeltaTime, args.TotalTime);
            // 虚函数调用——渲染
            this.Draw(args.DeltaTime, args.TotalTime);
            // 强制重绘
            args.InvalidateSurface();
        }

        //----一系列虚函数，供子类重写----//

        public virtual void Initialize()
        { }

        public virtual void LoadContent()
        { }

        public virtual void UnloadContent()
        { }

        public virtual void Update(TimeSpan DeltaTime, TimeSpan TotalTime)
        { }

        public virtual void Draw(TimeSpan DeltaTime, TimeSpan TotalTime)
        { }
    }
}

更新说明：

1.原有的基于DrawingSurface的GraphicsDevice安全机制消除，统一由GraphicsDeviceManager.Current.GraphicsDevice获取即可。

2.片尾列出的dll库无需再从外部引用，直接由Silverlight系统环境即可找到该程序集。

3.命名空间有变动，取消了Microsoft.Xna.Framework.Silverlight明明空间，添加了System.Windows.Xna程序集。

4.其他变动请参见Silverlight RC官方的最新说明文档~

本文链接

Direct3D轮回：游戏特效之全屏泛光(Bloom)

2011-08-25T12:40:00Z

Bloom，又称“全屏泛光”，是大名鼎鼎的虚幻3游戏引擎中最通用的后期特效技术~

Bloom特效的实现主要依赖于PostProcess框架，即实时绘制当前场景到一后台渲染表面，而后针对其对应贴图进行像素级渲染~

大家还记得我们之前实现的水面效果中的反射和折射贴图吗？此即为PostProcess的典型应用，与Bloom特效有异曲同工之妙。

下面，我们就来揭秘这个Bloom特效的实现流程~

本节我们实现的Bloom特效，在流程上总共分为4步：

1.提取原场景贴图中的亮色；

2.针对提取贴图进行横向模糊；

3.在横向模糊基础上进行纵向模糊；

4.所得贴图与原场景贴图叠加得最终效果图。

所用到的Shader主要有三个，分别对应如上4个步骤中的第1步、第2、3步和第4步。我们来看源代码：

/*-------------------------------------

代码清单：BloomExtract.fx
来自：http://create.msdn.com/en-US/ (AppHub)

-------------------------------------*/

// 提取原始场景贴图中明亮的部分
// 这是应用全屏泛光效果的第一步

sampler TextureSampler : register(s0);

float BloomThreshold;

float4 ThePixelShader(float2 texCoord : TEXCOORD0) : COLOR0
{
    // 提取原有像素颜色
    float4 c = tex2D(TextureSampler, texCoord);

    // 在BloomThreshold参数基础上筛选较明亮的像素
    return saturate((c - BloomThreshold) / (1 - BloomThreshold));

}

technique BloomExtract
{
    pass Pass1
    {
        PixelShader = compile ps_2_0 ThePixelShader();
    }
}

/*-------------------------------------

代码清单：GaussianBlur.fx
来自：http://create.msdn.com/en-US/ (AppHub)

-------------------------------------*/

// 高斯模糊过滤
// 这个特效要应用两次，一次为横向模糊，另一次为横向模糊基础上的纵向模糊，以减少算法上的时间复杂度
// 这是应用Bloom特效的中间步骤

sampler TextureSampler : register(s0);

#define SAMPLE_COUNT 15

// 偏移数组
float2 SampleOffsets[SAMPLE_COUNT];
// 权重数组
float SampleWeights[SAMPLE_COUNT];

float4 ThePixelShader(float2 texCoord : TEXCOORD0) : COLOR0
{
    float4 c = 0;

    // 按偏移及权重数组叠加周围颜色值到该像素
    // 相对原理，即可理解为该像素颜色按特定权重发散到周围偏移像素
    for (int i = 0; i < SAMPLE_COUNT; i++)
    {
        c += tex2D(TextureSampler, texCoord + SampleOffsets[i]) * SampleWeights[i];
    }

    return c;
}

technique GaussianBlur
{
    pass Pass1
    {
        PixelShader = compile ps_2_0 ThePixelShader();
    }
}

/*-------------------------------------

代码清单：BloomCombine.fx
来自：http://create.msdn.com/en-US/ (AppHub)

-------------------------------------*/

// 按照特定比例混合原始场景贴图及高斯模糊贴图，产生泛光效果
// 这是全屏泛光特效的最后一步

// 模糊场景纹理采样器
sampler BloomSampler : register(s0);

// 原始场景纹理及采样器定义
texture BaseTexture;
sampler BaseSampler = sampler_state
{
    Texture   = (BaseTexture);
    MinFilter = Linear;
    MagFilter = Linear;
    MipFilter = Point;
    AddressU  = Clamp;
    AddressV  = Clamp;
};

float BloomIntensity;
float BaseIntensity;

float BloomSaturation;
float BaseSaturation;

// 减缓颜色的饱和度
float4 AdjustSaturation(float4 color, float saturation)
{
    // 人眼更喜欢绿光，因此选取0.3, 0.59, 0.11三个值
    float grey = dot(color, float3(0.3, 0.59, 0.11));
    return lerp(grey, color, saturation);
}

float4 ThePixelShader(float2 texCoord : TEXCOORD0) : COLOR0
{
    // 提取原始场景贴图及模糊场景贴图的像素颜色
    float4 bloom = tex2D(BloomSampler, texCoord);
    float4 base = tex2D(BaseSampler, texCoord);

    // 柔化原有像素颜色
    bloom = AdjustSaturation(bloom, BloomSaturation) * BloomIntensity;
    base = AdjustSaturation(base, BaseSaturation) * BaseIntensity;

    // 结合模糊像素值微调原始像素值
    base *= (1 - saturate(bloom));

    // 叠加原始场景贴图及模糊场景贴图，即在原有像素基础上叠加模糊后的像素，实现发光效果
    return base + bloom;
}

technique BloomCombine
{
    pass Pass1
    {
        PixelShader = compile ps_2_0 ThePixelShader();
    }
}

三个Shader均来自于微软WP7开发者俱乐部，如有引用，敬请标明AppHub字样及其站点网址：http://create.msdn.com/en-US/，以示对作者原创版权的尊重！

具备相应的Shader之后，下面我们来看如何运用他们来实现Bloom特效的四个关键步骤~

因为最终的效果贴图本质上是一张与屏幕大小相同的纹理，因此，我们使用原来构建的CSpriteBatch进行绘制。而CSpriteBatch提供的接口是针对于CTexture2D的，所以我们首先要增强并完善CTexture2D类的功能~

以下提供两个函数，使得CTexture2D可以直接产生渲染贴图，并允许获取其后台渲染表面：

bool CTexture2D::CreateRenderTarget(UINT SizeX, UINT SizeY)
{
    // 创建渲染贴图
    HRESULT hr;
    hr = D3DXCreateTexture(g_pD3DDevice, SizeX, SizeY, 1,
        D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pTexture);
    if(FAILED(hr))
        return false;
    m_Width  = SizeX;
    m_Height = SizeY;
    m_SurRect.top    = 0;
    m_SurRect.left   = 0;
    m_SurRect.right  = m_Width;
    m_SurRect.bottom = m_Height;
    return true;
}

bool CTexture2D::GetRenderSurface(IDirect3DSurface9** pOutSurface)
{
    // 获得贴图的渲染表面
    HRESULT hr;
    hr = m_pTexture->GetSurfaceLevel(0, pOutSurface);
    if(FAILED(hr))
        return false;
    else
        return true;
}

之后，就可以着手构建我们的CBloomEffect效果类了：

/*-------------------------------------

代码清单：BloomEffect.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "D3DEffect.h"
#include "Texture2D.h"

#pragma once

// Bloom参数体
typedef struct _BloomParam
{
    char*  _Name;              // Bloom特效名称
    float  _BloomThreshold;    // 饱和度
    float  _BlurAmount;        // 模糊程度
    float  _BloomIntensity;    // 模糊剧烈度
    float  _BaseIntensity;     // 原始剧烈度
    float  _BloomSaturation;   // 模糊饱和度
    float  _BaseSaturation;    // 原始饱和度
    _BloomParam(){}
    _BloomParam(char* name, float bloomThreshold, float blurAmount,
        float bloomIntensity, float baseIntensity,
        float bloomSaturation, float baseSaturation)
    {
        _Name = name;  _BloomThreshold = bloomThreshold; _BlurAmount = blurAmount;
        _BloomIntensity = bloomIntensity;   _BaseIntensity = baseIntensity;
        _BloomSaturation = bloomSaturation; _BaseSaturation = baseSaturation;
    }

}BloomParam;

class CBloomEffect
{
public:
    CBloomEffect(void);
    ~CBloomEffect(void);
public:
    void Create();       // 创建Bloom特效
    void Release();      // 释放Bloom特效
    void DrawScene();    // 场景绘制
    void Begin();        // 开启Bloom
    void End();          // 关闭Bloom
public:
    void        SetParam(BloomParam* pParam){m_pParam = pParam;}  // 参数体设置
    BloomParam* GetParam()                  {return m_pParam;}    // 参数体获取
private:
    void PostScene();                   // Bloom场景投递
    void PostSurface(                   // 应用特效投递贴图到特定缓存表面，本质就是将一个贴图应用Shader之后的效果写入另一个贴图
         CTexture2D* pTexture,          // 后台纹理
         IDirect3DSurface9* pSurface,   // 渲染表面
         CD3DEffect* pEffect);          // 目标特效
    bool LoadContent();                 // 加载内容
    bool GetSurfaces();                 // 获取渲染表面
private:
    float ComputeGaussian(float n);                 // 计算高斯模糊参数
    void  SetBlurEffectParam(float dx, float dy);   // 计算偏移数组及权重数组
private:
    CD3DEffect* m_pBloomExtractEffect;  // Bloom依次用到的三个特效
    CD3DEffect* m_pGaussianBlurEffect;
    CD3DEffect* m_pBloomCombineEffect;
private:
    CTexture2D*        m_pResolveTarget;   // 原始贴图
    CTexture2D*        m_pTexture1;        // 模糊贴图
    CTexture2D*        m_pTexture2;        // 临时模糊贴图
    IDirect3DSurface9* m_pResolveSurface;  // 原始贴图渲染表面
    IDirect3DSurface9* m_pSurface1;        // 模糊贴图渲染表面
    IDirect3DSurface9* m_pSurface2;        // 临时贴图渲染表面
    IDirect3DSurface9* m_pOriSurface;      // 初始渲染表面
private:
    BloomParam* m_pParam;                  // Bloom参数体
};

/*-------------------------------------

代码清单：BloomEffect.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "BloomEffect.h"
#include "D3DGame.h"
#include "SpriteBatch.h"
#include <math.h>

extern IDirect3DDevice9*     g_pD3DDevice;
extern CSpriteBatch*         g_pSpriteBatch;
extern D3DPRESENT_PARAMETERS g_D3DPP;

CBloomEffect::CBloomEffect(void)
{
}

CBloomEffect::~CBloomEffect(void)
{
}

void CBloomEffect::Release()
{
    ReleaseCOM(m_pBloomExtractEffect);
    ReleaseCOM(m_pBloomCombineEffect);
    ReleaseCOM(m_pGaussianBlurEffect);

    ReleaseCOM(m_pTexture1);
    ReleaseCOM(m_pTexture2);
    ReleaseCOM(m_pSurface1);
    ReleaseCOM(m_pSurface2);
}

void CBloomEffect::Create()
{
    if(!LoadContent())
        Release();
}

bool CBloomEffect::LoadContent()
{
    // 初始化并加载特效
    m_pBloomExtractEffect = new CD3DEffect;
    m_pBloomCombineEffect = new CD3DEffect;
    m_pGaussianBlurEffect = new CD3DEffect;

    if( !m_pBloomExtractEffect->LoadEffect("BloomExtract.fx")||
        !m_pBloomCombineEffect->LoadEffect("BloomCombine.fx")||
        !m_pGaussianBlurEffect->LoadEffect("GaussianBlur.fx"))
    {
        return false;
    }

    // 获得渲染表面
    if(!GetSurfaces())
    {
        return false;
    }

    return true;
}

bool CBloomEffect::GetSurfaces()
{
    // 初始化纹理并获得渲染表面
    m_pResolveTarget = new CTexture2D;
    m_pTexture1 = new CTexture2D;
    m_pTexture2 = new CTexture2D;

    if( !m_pResolveTarget->CreateRenderTarget(g_D3DPP.BackBufferWidth,g_D3DPP.BackBufferHeight)||
        !m_pResolveTarget->GetRenderSurface(&m_pResolveSurface))
    {
        return false;
    }

    if( !m_pTexture1->CreateRenderTarget(g_D3DPP.BackBufferWidth,g_D3DPP.BackBufferHeight)||
        !m_pTexture1->GetRenderSurface(&m_pSurface1))
    {
        return false;
    }

    if( !m_pTexture2->CreateRenderTarget(g_D3DPP.BackBufferWidth,g_D3DPP.BackBufferHeight)||
        !m_pTexture2->GetRenderSurface(&m_pSurface2))
    {
        return false;
    }

    return true;
}

void CBloomEffect::Begin()
{
    // 暂存原始渲染表面
    g_pD3DDevice->GetRenderTarget(0, &m_pOriSurface);
    // 设定后台渲染表面
    g_pD3DDevice->SetRenderTarget(0, m_pResolveSurface);
    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);
}

// Begin及End之间绘制原始场景，则得到原始场景贴图m_pResolveTarget

void CBloomEffect::End()
{
    // 绘制后台场景
    PostScene();
    // 还原渲染表面
    g_pD3DDevice->SetRenderTarget(0, m_pOriSurface);
}

void CBloomEffect::PostSurface(CTexture2D* pTexture, IDirect3DSurface9* pSurface, CD3DEffect* pEffect)
{
    // 设定后台渲染表面
    g_pD3DDevice->SetRenderTarget(0, pSurface);
    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);

    // 应用特效绘制纹理到后台渲染表面
    g_pSpriteBatch->Begin(SPRITEBLENDMODE_NONE, pEffect);
    g_pSpriteBatch->Draw(pTexture, D3DXVECTOR2_ZERO);
    g_pSpriteBatch->End();
}

void CBloomEffect::PostScene()
{
    // Bloom第1步：
    m_pBloomExtractEffect->GetEffect()->SetFloat("BloomThreshold",m_pParam->_BloomThreshold);
    PostSurface(m_pResolveTarget,m_pSurface1,m_pBloomExtractEffect);

    // Bloom第2步：
    SetBlurEffectParam(1.0f / (float)g_D3DPP.BackBufferWidth, 0);
    PostSurface(m_pTexture1,m_pSurface2,m_pGaussianBlurEffect);

    // Bloom第3步：
    SetBlurEffectParam(0, 1.0f / (float)g_D3DPP.BackBufferHeight);
    PostSurface(m_pTexture2,m_pSurface1,m_pGaussianBlurEffect);
}

void CBloomEffect::DrawScene()
{
    // 设定BloomCombine特效参数，控制原始场景m_pResolveTarget及模糊场景m_pTexture1的混合比例
    m_pBloomCombineEffect->GetEffect()->SetFloat("BloomIntensity",m_pParam->_BloomIntensity);
    m_pBloomCombineEffect->GetEffect()->SetFloat("BaseIntensity",m_pParam->_BaseIntensity);
    m_pBloomCombineEffect->GetEffect()->SetFloat("BloomSaturation",m_pParam->_BloomSaturation);
    m_pBloomCombineEffect->GetEffect()->SetFloat("BaseSaturation",m_pParam->_BaseSaturation);

    m_pBloomCombineEffect->GetEffect()->SetTexture("BaseTexture",m_pResolveTarget->GetTexture());

    // Bloom第4步：
    g_pSpriteBatch->Begin(SPRITEBLENDMODE_NONE, m_pBloomCombineEffect);
    g_pSpriteBatch->Draw(m_pTexture1, D3DXVECTOR2_ZERO);
    g_pSpriteBatch->End();
}

void CBloomEffect::SetBlurEffectParam(float dx, float dy)
{
    // 按场景尺寸计算偏移数组及权重数组(高斯模糊固定计算公式)
    D3DXHANDLE weightsParameter, offsetsParameter;
    int sampleCount = 15;

    weightsParameter = m_pGaussianBlurEffect->GetEffect()->GetParameterByName(0,"SampleWeights");
    offsetsParameter = m_pGaussianBlurEffect->GetEffect()->GetParameterByName(0,"SampleOffsets");

    float sampleWeights[15];
    float sampleOffsets[30];

    sampleWeights[0] = ComputeGaussian(0);
    sampleOffsets[0] = 0.0f;
    sampleOffsets[1] = 0.0f;

    float totalWeights = sampleWeights[0];

    for (int i = 0; i < sampleCount / 2; i++)
    {
        float weight = ComputeGaussian(i + 1);
        sampleWeights[i * 2 + 1] = weight;
        sampleWeights[i * 2 + 2] = weight;
        totalWeights += weight * 2;

        float sampleOffset = i * 2 + 1.5f;
        D3DXVECTOR2 delta = D3DXVECTOR2(dx, dy) * sampleOffset;

        sampleOffsets[i * 4 + 1] = delta.x;
        sampleOffsets[i * 4 + 2] = delta.y;
        sampleOffsets[i * 4 + 3] = -delta.x;
        sampleOffsets[i * 4 + 4] = -delta.y;
    }

    for (int i = 0; i < sampleCount; i++)
    {
        sampleWeights[i] /= totalWeights;
    }

    // 将计算结果传递到GaussianBlur特效
    m_pGaussianBlurEffect->GetEffect()->SetFloatArray(weightsParameter,sampleWeights,sampleCount);
    m_pGaussianBlurEffect->GetEffect()->SetFloatArray(offsetsParameter,sampleOffsets,sampleCount*2);
}

float CBloomEffect::ComputeGaussian(float n)
{
    // 高斯参数计算公式
    float theta = m_pParam->_BlurAmount;
    return (float)((1.0 / sqrt(2 * MATH_PI * theta)) *
        exp(-(n * n) / (2 * theta * theta)));
}

该类共产生了3个渲染表面，并在渲染过程中发生了相互叠加，嗯…有点混乱…

我们不妨来看一看每个步骤所得到的渲染效果，而后再针对4个步骤进行分析。如下是我在渲染过程中提取的效果图：

有了这个流程图，大家的思路是不是清晰了一些呢？下面，大家结合这个流程图来分析各个步骤：

第一步：

应用BloomExtract特效提取原始场景贴图m_pResolveTarget中较明亮的颜色绘制到m_pTexture1贴图中(m_pResolveTarget--->m_pTexture1)

第二步：

应用GaussianBlur特效，在m_pTexture1贴图基础上进行横向高斯模糊到m_pTexture2贴图(m_pTexture1--->m_pTexture2)

第三步：

再次应用GaussianBlur特效，在横向模糊之后的m_pTexture2贴图基础上进行纵向高斯模糊，得到最终的模糊贴图m_pTexture1(m_pTexture2--->m_pTexture1)

注意：此时，m_pTexture1贴图即为最终的模糊效果贴图

如果大家不明白高斯模糊的内部原理，可以参看老师为大家翻译的这篇文章：http://shiba.hpe.sh.cn/jiaoyanzu/WULI/showArticle.aspx?articleId=518&classId=4

第四步：

应用BloomCombine特效，叠加原始场景贴图m_pResolveTarget及两次模糊之后的场景贴图m_pTexture1，从而实现发光效果(m_pResolveTarget+m_pTexture1)

怎么样？大家明白了吗？呵呵~

我们来看主体代码：

/*-------------------------------------

代码清单：D3DGame.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DGame.h"
#include "D3DCamera.h"
#include "D3DEffect.h"
#include "CoordCross.h"
#include "SimpleXMesh.h"
#include "Texture2D.h"
#include "Skybox.h"
#include "SpriteBatch.h"
#include "BaseTerrain.h"
#include "Water.h"
#include "PlantCollect.h"
#include "LensFlare.h"
#include "D3DFog.h"
#include "BloomEffect.h"
#include <stdio.h>
#include <time.h>

//---通用全局变量

HINSTANCE  g_hInst;
HWND       g_hWnd;
D3DXMATRIX g_matWorld;
D3DXMATRIX g_matProjection;
D3DPRESENT_PARAMETERS g_D3DPP;

//---D3D全局变量

IDirect3D9       *g_pD3D           = NULL;
IDirect3DDevice9 *g_pD3DDevice     = NULL;
CMouseInput      *g_pMouseInput    = NULL;
CKeyboardInput   *g_pKeyboardInput = NULL;
CD3DCamera       *g_pD3DCamera     = NULL;
CSpriteBatch     *g_pSpriteBatch   = NULL;
CSkybox          *g_pSkybox        = NULL;
CBaseTerrain     *g_pBaseTerrain   = NULL;
CWater           *g_pWater         = NULL;
CPlantCollect    *g_pPlant         = NULL;
CSimpleXMesh     *g_pMesh          = NULL;
CLensFlare       *g_pFlare         = NULL;
CBloomEffect     *g_pBloom         = NULL;

// Bloom参数体数组及全局索引
int              g_bloomParamIndex = 0;
BloomParam       g_BloomParams[6]={
    BloomParam("Default",     0.25f,  4,   1.25f, 1,    1,       1),
    BloomParam("Soft",        0,      3,   1,     1,    1,       1),
    BloomParam("Desaturated", 0.5f,   8,   2,     1,    0,       1),
    BloomParam("Saturated",   0.25f,  4,   2,     1,    2,       0),
    BloomParam("Blurry",      0,      2,   1,     0.1f, 1,       1),
    BloomParam("Subtle",      0.5f,   2,   1,     1,    1,       1)
};

// 场景绘制
void DrawScene(bool isReflect,bool isRefract);

void Initialize(HINSTANCE hInst, HWND hWnd)
{
    g_hInst = hInst;
    g_hWnd  = hWnd;
    InitD3D(&g_pD3D, &g_pD3DDevice, g_D3DPP, g_matProjection, hWnd);
    g_pMouseInput = new CMouseInput;
    g_pMouseInput->Initialize(hInst,hWnd);
    g_pKeyboardInput = new CKeyboardInput;
    g_pKeyboardInput->Initialize(hInst,hWnd);
    g_pD3DCamera = new CD3DCamera;
    g_pSpriteBatch = new CSpriteBatch(g_pD3DDevice);
    srand(time(0));
}

CTexture2D* debugTexture = NULL;

void LoadContent()
{
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(600.0f,0.0f,600.0f));

    g_pSkybox = new CSkybox;
    g_pSkybox->Create("Skybox_0.JPG","Skybox_1.JPG","Skybox_2.JPG"
        ,"Skybox_3.JPG","Skybox_4.JPG","Skybox_5.JPG");

    g_pBaseTerrain = new CBaseTerrain;
    g_pBaseTerrain->Create(128,128,10,"HeightData_128x128.raw","Grass.dds");

    g_pWater = new CWater;
    g_pWater->Create(1280,1280,0.0f,0.0f,40.0f);

    g_pPlant = new CPlantCollect;
    g_pPlant->Create(60,90,15);

    g_pMesh = new CSimpleXMesh;
    g_pMesh->LoadXMesh("WindMill.x");

    g_pFlare = new CLensFlare;
    g_pFlare->Create(D3DXVECTOR3(-1600,700,600),D3DXVECTOR2(800,600));

    //ResetFog(D3DFOGTYPE_PIXEL,D3DFOG_EXP2,D3DXCOLOR_WHITE,0.001f);

    // 创建并初始化Bloom特效
    g_pBloom = new CBloomEffect;
    g_pBloom->Create();
}

void Update(float gameTick)
{
    g_pMouseInput->GetState();
    g_pKeyboardInput->GetState();

    // 更新摄影机高度
    D3DXVECTOR3 CameraPos = g_pD3DCamera->GetCameraPos();
    float roleHeight = 25.0f;
    float Ty = g_pBaseTerrain->GetExactHeightAt(CameraPos.x,CameraPos.z) + roleHeight;
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(
        CameraPos.x,
        Ty,
        CameraPos.z));

    g_pD3DCamera->Update();

    if(g_pKeyboardInput->IsJustKeyDown(DIK_SPACE))
    {
        g_bloomParamIndex++;
        if(g_bloomParamIndex>=6)
            g_bloomParamIndex = 0;
    }
    g_pBloom->SetParam(&g_BloomParams[g_bloomParamIndex]);

}

void Draw(float gameTick)
{
    g_pD3DDevice->GetTransform(D3DTS_WORLD, &g_matWorld);
    g_pD3DDevice->SetTransform(D3DTS_VIEW,  &g_pD3DCamera->GetViewMatrix());
    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);
    if(SUCCEEDED(g_pD3DDevice->BeginScene()))
    {
        //BeginFog(g_pD3DDevice);

        g_pWater->BeginReflect();
        DrawScene(true,false);
        g_pWater->EndReflect();

        g_pWater->BeginRefract();
        DrawScene(false,true);
        g_pWater->EndRefract();

        // 开启Bloom
        g_pBloom->Begin();

        // 绘制实时场景到Bloom原始后台表面
        DrawScene(false,false);
        g_pWater->Draw(gameTick);
        g_pPlant->Draw(gameTick);

        // 结束Bloom，并触发Bloom前三个步骤
        g_pBloom->End();

        // 触发Bloom第四个步骤，而后进行Bloom渲染
        g_pBloom->DrawScene();

        g_pFlare->Draw();

        //EndFog(g_pD3DDevice);

        g_pD3DDevice->EndScene();
    }
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}

void DrawScene(bool isReflect,bool isRefract)
{
    g_pSkybox->Draw(isReflect,isRefract);
    g_pBaseTerrain->Draw();

    D3DXMATRIX scalTrans;
    D3DXMatrixScaling(&scalTrans,5.0f,5.0f,5.0f);
    D3DXMATRIX movTrans;
    D3DXMatrixTranslation(&movTrans,366,g_pBaseTerrain->GetExactHeightAt(366,190)-5.0f,190);
    g_pMesh->DrawXMesh(scalTrans * movTrans);
}

void UnloadContent()
{
    ReleaseCOM(g_pBloom);
    ReleaseCOM(g_pMesh);
    ReleaseCOM(g_pFlare);
    ReleaseCOM(g_pPlant);
    ReleaseCOM(g_pWater);
    ReleaseCOM(g_pBaseTerrain);
    ReleaseCOM(g_pSkybox);
}

void Dispose()
{
    ReleaseCOM(g_pSpriteBatch);
    ReleaseCOM(g_pD3DCamera);
    ReleaseCOM(g_pKeyboardInput);
    ReleaseCOM(g_pMouseInput);
    ReleaseCOM(g_pD3DDevice);
    ReleaseCOM(g_pD3D);
}

对Bloom参数体各个成员变量数值进行交叉组合，则我们可以得到一系列不同的Bloom效果：

还在羡慕那些专业游戏中美轮美奂的后期特效吗？现在我们也有能力实现了~ 大家赶快动手尝试一下吧 ^ ^

以上，谢谢~

本文链接

Direct3D轮回：游戏特效之风动、雾化

2011-08-14T01:56:00Z

风动和雾化都是相对而言比较简单的游戏特效，实现起来甚至比我们前一节提到的晴天光晕还要简单~

大家还记得上上节中我们为陆地种植的那片植被吗？现在我们在场景中加入风的效果，让草儿动起来 ^ ^

首先，我们来实现一个风动效果的Shader：

/*-------------------------------------

代码清单：Wind.fx
来自：http://www.cnblogs.com/kenkao/

-------------------------------------*/

uniform matrix  wvp;                              // 世界·摄影·投影变换
uniform texture tex;                              // 活动纹理
uniform float   time;                             // 全局时间
        float3  winddir = {1.0f, -1.0f, -1.0f};   // 默认风向

sampler TexSampler = sampler_state
{
    Texture   = <tex>;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    MipFilter = LINEAR;
};

struct VS_INPUT
{
    float4 position : POSITION;
    float2 texcoord : TEXCOORD;
};

struct VS_OUTPUT
{
    float4 position : POSITION;
    float2 texcoord : TEXCOORD0;
    float4 color    : COLOR;
};

struct PS_INPUT
{
    float4 color    : COLOR;
    float2 texcoord : TEXCOORD;
};

struct PS_OUTPUT
{
    float4 color : COLOR;
};

VS_OUTPUT WindVS(VS_INPUT input)
{
    VS_OUTPUT output = (VS_OUTPUT)0;
    output.position = mul(input.position,wvp);
    if(input.texcoord.y < 0.1)
        output.position += cos(time)/2;        // 整个Shader唯一起作用的代码——顶点位置随全局时间呈现余弦波动，借以虚拟“风动”效果 ^_^
    output.texcoord = input.texcoord;
    output.color = 1.0f;
    return output;
}

PS_OUTPUT WindPS(PS_INPUT input)
{
    PS_OUTPUT output = (PS_OUTPUT)0;
    output.color = 1.2 * input.color * tex2D(TexSampler, input.texcoord);
    return output;
}

technique WindTech
{
    pass P0
    {
        VertexShader = compile vs_2_0 WindVS();
        PixelShader  = compile ps_2_0 WindPS();
        AlphaRef = 150;
        AlphaTestEnable = TRUE;
        AlphaFunc = GREATEREQUAL;
        CullMode = NONE;
    }
}

原理非常简单，只有一句代码起到了实质性的作用，它使得所有效果应用顶点随时间呈现余弦状波动效果。

而其他所有的代码其实就相当于一个没有任何特效的固定管线~

下面我们应用它来改造原有的CPlantCollect类，其实也就是在其初始化时加载风动特效，而后绘制所有植被节点时应用之即可~

/*-------------------------------------

代码清单：PlantCollect.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/
bool CPlantCollect::LoadContent()
{
    // 创建纹理
    HRESULT hr = D3DXCreateTextureFromFile(g_pD3DDevice,"grass.png",&m_pGrassTexture);
    if(FAILED(hr))
        return false;

    // 加载风动效果
    m_pWindEffect = new CD3DEffect;
    if(!m_pWindEffect->LoadEffect("Wind.fx"))
        return false;

    m_hWindWVP  = m_pWindEffect->GetEffect()->GetParameterByName(0,"wvp");
    m_hWindTime = m_pWindEffect->GetEffect()->GetParameterByName(0,"time");
    m_pWindEffect->GetEffect()->SetTechnique("WindTech");
    m_pWindEffect->GetEffect()->SetTexture("tex",m_pGrassTexture);

    return true;
}
void CPlantCollect::Draw(float gameTick)
{
    // 禁用背面剔除
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

    // 启用Alpha通道
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
    g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

    // 开启Alpha检测
    g_pD3DDevice->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL);
    g_pD3DDevice->SetRenderState(D3DRS_ALPHAREF, 150);

    // 设置纹理、顶点缓冲区、索引缓冲区及顶点格式
    if(!m_pWindEffect)
        g_pD3DDevice->SetTexture(0,m_pGrassTexture);
    g_pD3DDevice->SetStreamSource(0, m_pVB, 0, sizeof(VertexPositionTex));
    g_pD3DDevice->SetIndices(m_pIB);
    g_pD3DDevice->SetFVF(VertexPositionTex::FVF);

    // 如果风动特效存在，则设置相应参数并开启特效
    if(m_pWindEffect)
    {
        D3DXMATRIX matWorld;
        g_pD3DDevice->GetTransform(D3DTS_WORLD,&matWorld);
        D3DXMATRIX matView;
        g_pD3DDevice->GetTransform(D3DTS_VIEW,&matView);
        D3DXMATRIX matProj;
        g_pD3DDevice->GetTransform(D3DTS_PROJECTION,&matProj);
        m_pWindEffect->GetEffect()->SetMatrix(m_hWindWVP,&(matWorld*matView*matProj));
        m_pWindEffect->GetEffect()->SetFloat(m_hWindTime,gameTick/500.0f);

        UINT NumPasses;
        m_pWindEffect->BeginEffect(NumPasses);
        m_pWindEffect->GetEffect()->BeginPass(0);
    }

    // 绘制顶点
    g_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, m_vertexNum, 0, m_indexNum/3);

    if(m_pWindEffect)
    {
        m_pWindEffect->GetEffect()->EndPass();
        m_pWindEffect->EndEffect();
    }

    // 关闭Alpha检测
    g_pD3DDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

    // 禁用Alpha通道
    g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);

    // 重用背面剔除
    g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
}

当然，不要忘记当对象Release时调用ReleaseCOM(m_pWindEffect)释放掉风动效果就可以了 ^ ^

风动效果通过截图表现不出来，建议大家在前几节的基础上自己动手尝试一下，感觉会非常不错~

之后我们来看D3D中雾化效果的实现。

雾化特效是D3D设备自身携带的一种效果，我们只需打开几个状态开关并设置一下相应的参数即可~

我们新建一个CD3DFog类，不过因为雾化特性来自于D3D本身，因此直接写成全局函数就可以了 ^ ^

/*-------------------------------------

代码清单：D3DFog.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "D3DInit.h"

// 雾化类型枚举
typedef enum _D3DFOGTYPE
{
    D3DFOGTYPE_NONE = 0,      // 无雾化效果
    D3DFOGTYPE_VERTEX = 140,  // 顶点雾化
    D3DFOGTYPE_PIXEL = 35     // 像素雾化
}D3DFOGTYPE;

// 重置雾化特效
void ResetFog( D3DFOGTYPE FogType,   // 雾化类型
               D3DFOGMODE FogMode,   // 雾化模式
               D3DCOLOR FogColor,    // 雾化颜色
               float Param0,         // 参数零
               float Param1 = 0.0f   // 参数一
               );

void BeginFog(IDirect3DDevice9 *pD3DDevice);  // 开启雾化
void EndFog(IDirect3DDevice9 *pD3DDevice);    // 关闭雾化

/*-------------------------------------

代码清单：D3DFog.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DFog.h"

D3DFOGTYPE  g_FogType  = D3DFOGTYPE_VERTEX;  // 默认雾化类型为顶点雾化
D3DFOGMODE  g_FogMode  = D3DFOG_LINEAR;      // 默认雾化模式为线性模式
D3DCOLOR    g_FogColor = D3DXCOLOR_WHITE;    // 默认雾化颜色为白色
float       g_FogStart = 0.0f;               // 默认线性雾化起始深度为0.0f
float       g_FogEnd   = 100.0f;             // 默认线性雾化终止深度为100.0f
float       g_FogDensity = 0.0f;             // 默认指数雾化参数为0.0f

void ResetFog(D3DFOGTYPE FogType, D3DFOGMODE FogMode, D3DCOLOR FogColor, float Param0, float Param1)
{
    g_FogType = FogType;
    g_FogMode = FogMode;
    g_FogColor = FogColor;
    // 如果雾化类型为线性雾化，则参数零、参数一分别代表线性雾化的起始与终止深度
    if(g_FogMode == D3DFOG_LINEAR)
    {
        g_FogStart = Param0;
        g_FogEnd   = Param1;
    }
    // 如果雾化类型为指数雾化，则参数零代表指数参数，参数一无效
    else
        g_FogDensity = Param0;
}

void BeginFog(IDirect3DDevice9 *pD3DDevice)
{
    if(pD3DDevice && g_FogType != D3DFOGTYPE_NONE && g_FogMode != D3DFOG_NONE)
    {
        // 开启雾化
        pD3DDevice->SetRenderState(D3DRS_FOGENABLE, TRUE);
        // 设置雾化颜色
        pD3DDevice->SetRenderState(D3DRS_FOGCOLOR, g_FogColor);
        // 设置雾化类型
        pD3DDevice->SetRenderState((D3DRENDERSTATETYPE)g_FogType, g_FogMode);
        // 设置雾化参数
        if (g_FogMode == D3DFOG_LINEAR)
        {
            pD3DDevice->SetRenderState(D3DRS_FOGSTART, *(DWORD*)&g_FogStart);
            pD3DDevice->SetRenderState(D3DRS_FOGEND, *(DWORD*)&g_FogEnd);
        }
        else
            pD3DDevice->SetRenderState(D3DRS_FOGDENSITY, *(DWORD*)&g_FogDensity);
    }
}

void EndFog(IDirect3DDevice9 *pD3DDevice)
{
    if(pD3DDevice && g_FogMode != D3DFOG_NONE)
    {
        // 结束雾化
        pD3DDevice->SetRenderState(D3DRS_FOGENABLE, FALSE);
    }
}

这里值得一提的是代码中提到的雾化类型及雾化模式。

雾化类型主要分顶点级和像素级。顶点级雾化仅针对于各顶点，比较省性能，但不够精确；像素级雾化针对所有像素，效果与顶点级雾化相反。

雾化模式则主要分为线性雾化、一次指数雾化及二次指数雾化，用以控制雾化效果由近及远、有稀薄到厚重的变换过程。以下是三种雾化模式相应的计算公式：

如下为主体代码：

/*-------------------------------------

代码清单：D3DGame.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DGame.h"
#include "D3DCamera.h"
#include "D3DEffect.h"
#include "CoordCross.h"
#include "SimpleXMesh.h"
#include "Texture2D.h"
#include "D3DSprite.h"
#include "Skybox.h"
#include "SpriteBatch.h"
#include "BaseTerrain.h"
#include "Water.h"
#include "PlantCollect.h"
#include "LensFlare.h"
#include "D3DFog.h"
#include <stdio.h>
#include <time.h>

//---通用全局变量

HINSTANCE  g_hInst;
HWND       g_hWnd;
D3DXMATRIX g_matWorld;
D3DXMATRIX g_matProjection;
D3DPRESENT_PARAMETERS g_D3DPP;

//---D3D全局变量

IDirect3D9       *g_pD3D           = NULL;
IDirect3DDevice9 *g_pD3DDevice     = NULL;
CMouseInput      *g_pMouseInput    = NULL;
CKeyboardInput   *g_pKeyboardInput = NULL;
CD3DCamera       *g_pD3DCamera     = NULL;
CSpriteBatch     *g_pSpriteBatch   = NULL;
CSkybox          *g_pSkybox        = NULL;
CBaseTerrain     *g_pBaseTerrain   = NULL;
CWater           *g_pWater         = NULL;
CPlantCollect    *g_pPlant         = NULL;
CSimpleXMesh     *g_pMesh          = NULL;
CLensFlare       *g_pFlare         = NULL;

// 场景绘制
void DrawScene(bool isReflect,bool isRefract);

void Initialize(HINSTANCE hInst, HWND hWnd)
{
    g_hInst = hInst;
    g_hWnd  = hWnd;
    InitD3D(&g_pD3D, &g_pD3DDevice, g_D3DPP, g_matProjection, hWnd);
    g_pMouseInput = new CMouseInput;
    g_pMouseInput->Initialize(hInst,hWnd);
    g_pKeyboardInput = new CKeyboardInput;
    g_pKeyboardInput->Initialize(hInst,hWnd);
    g_pD3DCamera = new CD3DCamera;
    g_pSpriteBatch = new CSpriteBatch(g_pD3DDevice);
    srand(time(0));
}

CTexture2D* debugTexture = NULL;

void LoadContent()
{
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(600.0f,0.0f,600.0f));

    g_pSkybox = new CSkybox;
    g_pSkybox->Create("Skybox_0.JPG","Skybox_1.JPG","Skybox_2.JPG"
        ,"Skybox_3.JPG","Skybox_4.JPG","Skybox_5.JPG");

    g_pBaseTerrain = new CBaseTerrain;
    g_pBaseTerrain->Create(128,128,10,"HeightData_128x128.raw","Grass.dds");

    g_pWater = new CWater;
    g_pWater->Create(1280,1280,0.0f,0.0f,40.0f);

    g_pPlant = new CPlantCollect;
    g_pPlant->Create(60,90,15);

    g_pMesh = new CSimpleXMesh;
    g_pMesh->LoadXMesh("WindMill.x");

    g_pFlare = new CLensFlare;
    g_pFlare->Create(D3DXVECTOR3(-1600,700,600),D3DXVECTOR2(800,600));

    ResetFog(D3DFOGTYPE_PIXEL,D3DFOG_EXP2,D3DXCOLOR_WHITE,0.001f);
}

void Update(float gameTick)
{
    g_pMouseInput->GetState();
    g_pKeyboardInput->GetState();

    // 更新摄影机高度
    D3DXVECTOR3 CameraPos = g_pD3DCamera->GetCameraPos();
    float roleHeight = 25.0f;
    float Ty = g_pBaseTerrain->GetExactHeightAt(CameraPos.x,CameraPos.z) + roleHeight;
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(
        CameraPos.x,
        Ty,
        CameraPos.z));

    g_pD3DCamera->Update();
}

void Draw(float gameTick)
{
    g_pD3DDevice->GetTransform(D3DTS_WORLD, &g_matWorld);
    g_pD3DDevice->SetTransform(D3DTS_VIEW,  &g_pD3DCamera->GetViewMatrix());
    if(SUCCEEDED(g_pD3DDevice->BeginScene()))
    {
        BeginFog(g_pD3DDevice);

        g_pWater->BeginReflect();
        DrawScene(true,false);
        g_pWater->EndReflect();

        g_pWater->BeginRefract();
        DrawScene(false,true);
        g_pWater->EndRefract();

        g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);
        DrawScene(false,false);
        g_pWater->Draw(gameTick);
        g_pPlant->Draw(gameTick);
        g_pFlare->Draw();

        EndFog(g_pD3DDevice);

        g_pD3DDevice->EndScene();
    }
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}

void DrawScene(bool isReflect,bool isRefract)
{
    g_pSkybox->Draw(isReflect,isRefract);
    g_pBaseTerrain->Draw();

    D3DXMATRIX scalTrans;
    D3DXMatrixScaling(&scalTrans,5.0f,5.0f,5.0f);
    D3DXMATRIX movTrans;
    D3DXMatrixTranslation(&movTrans,366,g_pBaseTerrain->GetExactHeightAt(366,190)-5.0f,190);
    g_pMesh->DrawXMesh(scalTrans * movTrans);
}

void UnloadContent()
{
    ReleaseCOM(g_pFlare);
    ReleaseCOM(g_pPlant);
    ReleaseCOM(g_pWater);
    ReleaseCOM(g_pBaseTerrain);
    ReleaseCOM(g_pSkybox);
}

void Dispose()
{
    ReleaseCOM(g_pSpriteBatch);
    ReleaseCOM(g_pD3DCamera);
    ReleaseCOM(g_pKeyboardInput);
    ReleaseCOM(g_pMouseInput);
    ReleaseCOM(g_pD3DDevice);
    ReleaseCOM(g_pD3D);
}

最后是效果图：

配合合适的纹理，近处的景色与远处的天空完全浑然一体~

想到一句图形学领域的至理名言：Everything can be faked~ 不正是这样吗？呵呵~

以上，谢谢~

本文链接

Direct3D轮回：游戏特效之晴天光晕

2011-08-07T03:15:00Z

基本的场景元素具备之后，本节我们来为已构建的场景新增一些特殊效果~

玩过摄影的朋友应该都知道，当我们把镜头对准某一发光体的时候，会有光晕现象产生，这种光晕现象也称作“镜头眩光”。

在晴天的场景中实现这样一个光晕特效，往往会有意想不到的效果~

晴天光晕特效实现的原理其实挺简单，它可以由一个主光晕加一系列镜头七彩光环组成。主光晕以光源为中心，镜头光环则散列在由光源及镜头中心决定的直线上~

其效果大致如图所示：

下面，我们来着手实现这样一个效果~

首先还是要准备素材：

glow.png

flare1.png

flare2.png

flare3.png

其中，glow为主光晕素材，透明底色、半透明主色，由于我的blog背景的关系，看不太明显，大家可以右击另存为，放大看一下效果。一系列flare则为黑底、大小各异的光环~

由于最终是以2D精灵的形式绘制各个光晕素材，因此需要借助于之前构建的CSpriteBatch。

下面，我们为之前构建的CSpriteBatch新增一些功能：

1>定义blend模式

#define SPRITEBLENDMODE_NONE 0
#define SPRITEBLENDMODE_ALPHABLEND 1
#define SPRITEBLENDMODE_ADDITIVE 2

SPRITEBLENDMODE_NONE代表没有blend状态；

SPRITEBLENDMODE_ALPHABLEND模式开启Alpha通道，支持半透明绘制，这里用于主光晕的绘制；

SPRITEBLENDMODE_ADDITIVE模式则采用叠加的方式，将精灵的各个像素颜色直接与背景各像素颜色叠加，镜头光环采用这种方式绘制可以达到非常好的效果。

2>ALPHABLEND模式的实现

m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

开启Alpha通道的常规程序，没什么可说的~

3>ADDITIVE模式的实现

m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);

该模式下，我们直接将D3DRS_DESTBLEND渲染状态置为D3DBLEND_ONE，代表背景不丢失，前景直接与其叠加即可~

各模式仅仅改变设备即时的渲染状态，因此，我们只需在原有基础上完善CSpriteBatch的Begin与End函数即可：

void CSpriteBatch::Begin(DWORD Flags, CD3DEffect* pD3DEffect)
{
    m_Flags = Flags;
    // 获得原始状态
    m_pDevice->GetTransform(D3DTS_VIEW,       &m_OriViewMatrix);
    m_pDevice->GetTransform(D3DTS_PROJECTION, &m_OriProjMatrix);
    // 设置单位摄影矩阵及正交投影矩阵
    m_pDevice->SetTransform(D3DTS_VIEW,       &m_ViewMatrix);
    m_pDevice->SetTransform(D3DTS_PROJECTION, &m_ProjMatrix);
    // 如果存在特效则应用之
    if(pD3DEffect)
    {
        this->m_pD3DEffect=pD3DEffect;
        m_pD3DEffect->BeginEffect(m_NumPasses);
    }
    // 如果是ALPHABLEND模式
    if(Flags == SPRITEBLENDMODE_ALPHABLEND)
    {
        m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
        m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
    }
    // 如果是ADDITIVE模式
    else if(Flags == SPRITEBLENDMODE_ADDITIVE)
    {
        m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
        m_pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        m_pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);
    }
}
void CSpriteBatch::End()
{
    // 结束绘制之前Flush一次全部节点
    Flush();
    // 禁用Alpha通道
    if(m_Flags!=SPRITEBLENDMODE_NONE)
        m_pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
    // 如果存在特效则结束之
    if(m_pD3DEffect)
        m_pD3DEffect->EndEffect();
    // 还原原始摄影矩阵及投影矩阵
    m_pDevice->SetTransform(D3DTS_VIEW,       &m_OriViewMatrix);
    m_pDevice->SetTransform(D3DTS_PROJECTION, &m_OriProjMatrix);
}

4>新增重载Draw函数

void CSpriteBatch::Draw(CTexture2D* pTexture,const D3DXVECTOR2& Pos,const D3DXVECTOR2& Origin,const float& Scale,D3DCOLOR Color,const float& layerDepth)
{
D3DXVECTOR2 offset = Origin * Scale;
RECT rect;
rect.left = Pos.x - offset.x;
rect.top = Pos.y - offset.y;
rect.right = rect.left + pTexture->GetWidth() * Scale;
rect.bottom = rect.top + pTexture->GetHeight() * Scale;
Draw(pTexture,rect,Color,layerDepth);
}

结合自身的需要，我们新增这样一个重载的Draw函数。两个陌生的参数Origin与Scale分别代表精灵的原始中心(默认为左上角)与缩放比率，该函数的构建思想参照了Xna4.0下SpriteBatch的实现。

准备工作做完了，下面我们来着手完成这个CLensFlare对象的构建：

/*-------------------------------------

代码清单：LensFlare.h
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "SpriteBatch.h"

#pragma once

// 光晕节点
struct FlareNode{
    float       _Position; // 位置(以镜头中心为原点)
    float       _Scale;     // 缩放比率
    D3DXCOLOR   _Color;     // 色相
    CTexture2D* _pTexture; // 纹理指针
    FlareNode(){}
    FlareNode(float Position, float Scale, D3DXCOLOR Color, CTexture2D* pTexture){
        _Position = Position;  _Scale = Scale;  _Color = Color;  _pTexture = pTexture;
    };
};

class CLensFlare
{
public:
    CLensFlare(void);
    ~CLensFlare(void);
public:
    bool Create(                            // 创建光晕
        D3DXVECTOR3 lightPos,               // 光源位置(绝对)
        D3DXVECTOR2 viewPortSize);          // 视口尺寸
    void Draw();                            // 绘制光晕
    void Release();                         // 释放资源
private:
    void CalRelativeLightPos(int &iCoordX,
        int &iCoordY, int &iCoordW);        // 计算光源的相对位置
    bool LoadContent();                     // 加载纹理
    bool IsVisible();                       // 光源是否可见
private:
    CTexture2D* m_pFlareTex1;               // 光晕纹理一
    CTexture2D* m_pFlareTex2;               // 光晕纹理二
    CTexture2D* m_pFlareTex3;               // 光晕纹理三
    CTexture2D* m_pGlowTex;                 // 主光晕纹理
private:
    D3DXVECTOR3 m_lightPosition;            // 光源位置(绝对)
    D3DXVECTOR2 m_relativeLightPos;         // 光源位置(相对)
    D3DXVECTOR2 m_viewPortCenter;           // 视口尺寸
    FlareNode   m_FlareNodes[10];           // 光晕节点列表
    float       m_occlusionAlpha;           // 光源Alpha系数
};

/*-------------------------------------

代码清单：LensFlare.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "LensFlare.h"
#include "D3DGame.h"
#include "SpriteBatch.h"
#include "D3DCamera.h"

extern IDirect3DDevice9 *g_pD3DDevice;
extern CSpriteBatch     *g_pSpriteBatch;
extern CD3DCamera       *g_pD3DCamera;

extern D3DXMATRIX       g_matWorld;
extern D3DXMATRIX       g_matProjection;

CLensFlare::CLensFlare(void) : m_pFlareTex1(NULL),
                               m_pFlareTex2(NULL),
                               m_pFlareTex3(NULL),
                               m_pGlowTex(NULL),
                               m_lightPosition(D3DXVECTOR3_ZERO),
                               m_relativeLightPos(D3DXVECTOR2_ZERO),
                               m_viewPortCenter(D3DXVECTOR2(400,300)),
                               m_occlusionAlpha(0.0f)
{

}

CLensFlare::~CLensFlare(void)
{
}

void CLensFlare::Release()
{
    ReleaseCOM(m_pFlareTex1);
    ReleaseCOM(m_pFlareTex2);
    ReleaseCOM(m_pFlareTex3);
    ReleaseCOM(m_pGlowTex);
}

bool CLensFlare::Create(D3DXVECTOR3 lightPos, D3DXVECTOR2 viewPortSize)
{
    // 获得光源位置与视口中心位置
    m_lightPosition  = lightPos;
    m_viewPortCenter = D3DXVECTOR2(viewPortSize.x/2, viewPortSize.y/2);

    if(!LoadContent())
    {
        Release();
        return false;
    }
    return true;
}

bool CLensFlare::LoadContent()
{
    // 加载纹理
    m_pFlareTex1 = new CTexture2D;
    m_pFlareTex2 = new CTexture2D;
    m_pFlareTex3 = new CTexture2D;
    m_pGlowTex   = new CTexture2D;

    if( !m_pFlareTex1->LoadTexture("flare1.png")||
        !m_pFlareTex2->LoadTexture("flare2.png")||
        !m_pFlareTex3->LoadTexture("flare3.png")||
        !m_pGlowTex  ->LoadTexture("glow.png"  ))
        return false;

    // 初始化一系列光晕节点，并赋予不同的位置、缩放比率与颜色
    int i = 0;
    m_FlareNodes[i++] = FlareNode(-0.5f, 0.7f, D3DCOLOR_XRGB( 50,  25,  50), m_pFlareTex1);
    m_FlareNodes[i++] = FlareNode( 0.3f, 0.4f, D3DCOLOR_XRGB(100, 225, 200), m_pFlareTex1);
    m_FlareNodes[i++] = FlareNode( 1.2f, 1.0f, D3DCOLOR_XRGB(100,  50,  50), m_pFlareTex1);
    m_FlareNodes[i++] = FlareNode( 1.5f, 1.5f, D3DCOLOR_XRGB( 50, 100,  50), m_pFlareTex1);

    m_FlareNodes[i++] = FlareNode(-0.3f, 0.7f, D3DCOLOR_XRGB(200,  50,  50), m_pFlareTex2);
    m_FlareNodes[i++] = FlareNode( 0.6f, 0.9f, D3DCOLOR_XRGB( 50, 100,  50), m_pFlareTex2);
    m_FlareNodes[i++] = FlareNode( 0.7f, 0.4f, D3DCOLOR_XRGB( 50, 200, 200), m_pFlareTex2);

    m_FlareNodes[i++] = FlareNode(-0.7f, 0.7f, D3DCOLOR_XRGB( 50, 100,  25), m_pFlareTex3);
    m_FlareNodes[i++] = FlareNode( 0.0f, 0.6f, D3DCOLOR_XRGB( 25,  25,  25), m_pFlareTex3);
    m_FlareNodes[i++] = FlareNode( 2.0f, 1.4f, D3DCOLOR_XRGB( 25,  50, 100), m_pFlareTex3);

    return true;
}

void CLensFlare::CalRelativeLightPos(int &iCoordX, int &iCoordY, int &iCoordW)
{
    // 计算光源在2D屏幕中的相对位置，固定公式
    D3DXMATRIX matWorld, matView, matConcat, matViewportScale;
    D3DXVECTOR4 vResult;

    matViewportScale = D3DXMATRIX(
        m_viewPortCenter.x, 0, 0, 0,
        0, -m_viewPortCenter.y, 0, 0,
        0, 0, 1, 0,
        m_viewPortCenter.x, m_viewPortCenter.y, 0, 1
        );

    matView = g_pD3DCamera->GetViewMatrix();
    D3DXMatrixIdentity(&matWorld);
    matConcat = matWorld;
    matConcat *= matView;
    matConcat *= g_matProjection;
    matConcat *= matViewportScale;

    D3DXVECTOR3 resultLightPos = m_lightPosition + g_pD3DCamera->GetCameraPos();
    D3DXVec3Transform(&vResult, &resultLightPos, &matConcat);

    iCoordX = vResult.x/vResult.w;
    iCoordY = vResult.y/vResult.w;
    iCoordW = vResult.w;
}

bool CLensFlare::IsVisible()
{
    // 判断光源是否可见(目前仅粗略判断)
    int X,Y,W = 0;
    CalRelativeLightPos(X,Y,W);
    if( W > 0.0f &&
        X >= -100 && X < m_viewPortCenter.x * 2 + 100 &&
        Y >= -100 && Y < m_viewPortCenter.y * 2 + 100 )
    {
        m_relativeLightPos.x = X;
        m_relativeLightPos.y = Y;
        m_occlusionAlpha     = W;
        return true;
    }
    else
        return false;
}

void CLensFlare::Draw()
{
    if(IsVisible())
    {
        // 以ALPHABLEND模式绘制主光晕
        g_pSpriteBatch->Begin(SPRITEBLENDMODE_ALPHABLEND);
        D3DXCOLOR color = D3DCOLOR_COLORVALUE(1, 1, 1, m_occlusionAlpha);
        D3DXVECTOR2 glowOrigin = D3DXVECTOR2(m_pGlowTex->GetWidth(),m_pGlowTex->GetHeight())/2;
        float scale = 400 * 2 / m_pGlowTex->GetWidth();
        g_pSpriteBatch -> Draw(m_pGlowTex,m_relativeLightPos,glowOrigin,scale);
        g_pSpriteBatch->End();

        // 以ADDITIVE模式绘制其他镜头光晕
        g_pSpriteBatch->Begin(SPRITEBLENDMODE_ADDITIVE);

        // 镜头中心与光源2D屏幕位置作差得到相应的倾斜向量
        D3DXVECTOR2 flareVector = m_viewPortCenter - m_relativeLightPos;
        for(int i=0;i<10;i++)
        {
            D3DXVECTOR2 flarePos = m_relativeLightPos + flareVector * m_FlareNodes[i]._Position;
            D3DXVECTOR2 flareOrgin = D3DXVECTOR2(m_FlareNodes[i]._pTexture->GetWidth(),m_FlareNodes[i]._pTexture->GetHeight())/2;
            g_pSpriteBatch->Draw(m_FlareNodes[i]._pTexture,flarePos,flareOrgin,m_FlareNodes[i]._Scale,m_FlareNodes[i]._Color);
        }
        g_pSpriteBatch->End();
    }
}

值得留意的是CalRelativeLightPos函数的计算过程，这是由3D位置推导2D屏幕位置的固定计算公式，建议大家一定要记住~

下面看主体代码：

/*-------------------------------------

代码清单：D3DGame.cpp
来自：http://www.cnblogs.com/kenkao

-------------------------------------*/

#include "StdAfx.h"
#include "D3DGame.h"
#include "D3DCamera.h"
#include "D3DEffect.h"
#include "CoordCross.h"
#include "SimpleXMesh.h"
#include "Texture2D.h"
#include "D3DSprite.h"
#include "Skybox.h"
#include "SpriteBatch.h"
#include "BaseTerrain.h"
#include "Water.h"
#include "PlantCollect.h"
#include "LensFlare.h"
#include <stdio.h>
#include <time.h>

//---通用全局变量

HINSTANCE  g_hInst;
HWND       g_hWnd;
D3DXMATRIX g_matWorld;
D3DXMATRIX g_matProjection;
D3DPRESENT_PARAMETERS g_D3DPP;

//---D3D全局变量

IDirect3D9       *g_pD3D           = NULL;
IDirect3DDevice9 *g_pD3DDevice     = NULL;
CMouseInput      *g_pMouseInput    = NULL;
CKeyboardInput   *g_pKeyboardInput = NULL;
CD3DCamera       *g_pD3DCamera     = NULL;
CSpriteBatch     *g_pSpriteBatch   = NULL;
CSkybox          *g_pSkybox        = NULL;
CBaseTerrain     *g_pBaseTerrain   = NULL;
CWater           *g_pWater         = NULL;
CPlantCollect    *g_pPlant         = NULL;
CSimpleXMesh     *g_pMesh          = NULL;
CLensFlare       *g_pFlare         = NULL;

// 场景绘制
void DrawScene(bool isReflect,bool isRefract);

void Initialize(HINSTANCE hInst, HWND hWnd)
{
    g_hInst = hInst;
    g_hWnd  = hWnd;
    InitD3D(&g_pD3D, &g_pD3DDevice, g_D3DPP, g_matProjection, hWnd);
    g_pMouseInput = new CMouseInput;
    g_pMouseInput->Initialize(hInst,hWnd);
    g_pKeyboardInput = new CKeyboardInput;
    g_pKeyboardInput->Initialize(hInst,hWnd);
    g_pD3DCamera = new CD3DCamera;
    g_pSpriteBatch = new CSpriteBatch(g_pD3DDevice);
    srand(time(0));
}

CTexture2D* debugTexture = NULL;

void LoadContent()
{
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(600.0f,0.0f,600.0f));

    g_pSkybox = new CSkybox;
    g_pSkybox->Create("Skybox_0.JPG","Skybox_1.JPG","Skybox_2.JPG"
        ,"Skybox_3.JPG","Skybox_4.JPG","Skybox_5.JPG");

    g_pBaseTerrain = new CBaseTerrain;
    g_pBaseTerrain->Create(128,128,10,"HeightData_128x128.raw","Grass.dds");

    g_pWater = new CWater;
    g_pWater->Create(1280,1280,0.0f,0.0f,40.0f);

    g_pPlant = new CPlantCollect;
    g_pPlant->Create(60,90,15);

    g_pMesh = new CSimpleXMesh;
    g_pMesh->LoadXMesh("WindMill.x");

    g_pFlare = new CLensFlare;
    g_pFlare->Create(D3DXVECTOR3(-1600,700,600),D3DXVECTOR2(800,600));
}

void Update(float gameTick)
{
    g_pMouseInput->GetState();
    g_pKeyboardInput->GetState();

    // 更新摄影机高度
    D3DXVECTOR3 CameraPos = g_pD3DCamera->GetCameraPos();
    float roleHeight = 25.0f;
    float Ty = g_pBaseTerrain->GetExactHeightAt(CameraPos.x,CameraPos.z) + roleHeight;
    g_pD3DCamera->SetCameraPos(D3DXVECTOR3(
        CameraPos.x,
        Ty,
        CameraPos.z));

    g_pD3DCamera->Update();
}

void Draw(float gameTick)
{
    g_pD3DDevice->GetTransform(D3DTS_WORLD, &g_matWorld);
    g_pD3DDevice->SetTransform(D3DTS_VIEW,  &g_pD3DCamera->GetViewMatrix());
    if(SUCCEEDED(g_pD3DDevice->BeginScene()))
    {
        g_pWater->BeginReflect();
        DrawScene(true,false);
        g_pWater->EndReflect();

        g_pWater->BeginRefract();
        DrawScene(false,true);
        g_pWater->EndRefract();

        g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(100,149,237,255), 1.0f, 0);
        DrawScene(false,false);
        g_pWater->Draw(gameTick);
        g_pPlant->Draw(gameTick);
        // 绘制镜头光晕
        g_pFlare->Draw();
        g_pD3DDevice->EndScene();
    }
    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}

void DrawScene(bool isReflect,bool isRefract)
{
    g_pSkybox->Draw(isReflect,isRefract);
    g_pBaseTerrain->Draw();

    D3DXMATRIX scalTrans;
    D3DXMatrixScaling(&scalTrans,5.0f,5.0f,5.0f);
    D3DXMATRIX movTrans;
    D3DXMatrixTranslation(&movTrans,366,g_pBaseTerrain->GetExactHeightAt(366,190)-5.0f,190);
    g_pMesh->DrawXMesh(scalTrans * movTrans);
}

void UnloadContent()
{
    ReleaseCOM(g_pFlare);
    ReleaseCOM(g_pPlant);
    ReleaseCOM(g_pWater);
    ReleaseCOM(g_pBaseTerrain);
    ReleaseCOM(g_pSkybox);
}

void Dispose()
{
    ReleaseCOM(g_pSpriteBatch);
    ReleaseCOM(g_pD3DCamera);
    ReleaseCOM(g_pKeyboardInput);
    ReleaseCOM(g_pMouseInput);
    ReleaseCOM(g_pD3DDevice);
    ReleaseCOM(g_pD3D);
}

最后是效果图：

是否有一种身临其境的感觉呢？呵呵~

最后需要顺带一提的是，镜头光晕应当仅在光源可见时才进行绘制。而本节中实现的CLensFlare类下的IsVisible方法还存在很大的瑕疵，并不能精确判断光源的可见性。

D3D中要精确实现光源的可见性判断，常规的做法应当是采用“遮挡查询”机制，相关内容后续有时间的话会为大家做更进一步的讲解~

以上，谢谢~

本文链接