HLSL效果框架实例之高斯模糊

代码已经上传至git hub 见：https://github.com/Jeromecen/GaussianBlur

实例目的

1.提供了一个完整的fx框架编写Shader可运行程序,解决掉了编写过程中遇到的所有问题。验证了在FX框架可以不用GetParameterByName获取句柄的，直接用字符串作为句柄即可。
2.对高斯模糊图片提供了一个思路，就是高斯过滤矩阵通过程序设置给Shader,相比在Shader中做高斯运算性能更高
或者相比在Shader中写死高斯过滤矩阵，但是这样会不够灵活。
3.合理使用GPU Shader可以有效的提高图形程序性能，运用GPU强大的并行大量数据计算能力，简单随意测试了下CPU降低了大概10%。

调试错误和经验总结

//1).获取效果文件，hlsl注意fx要是asscii格式，不能是utf8格式
//2).结构体不能VS_OUTPUT outData = VS_OUTPUT(0);而是直接VS_OUTPUT outData就好了。
//3).顶点着色器输入输出都要float4类型，且像素着色器不能输入顶点，因为已经是在光栅化阶段了。
// 顶点着色器的输入
//struct VS_INPUT
//{
//    float4 POS : POSITION;
//    float2 UV : TEXCOORD0;
//};
顶点着色器的输出
//struct VS_OUTPUT
//{
//    float4 POS : POSITION;
//    float2 UV : TEXCOORD0;
//};
// 4).纹理需要用Sampler正确，不能用texture代替sampler,或者输入texture当sampler来用的方式
// 5).alpha融合需要注意，否则会导致渲染层次有问题，融合结果

// 6).渲染框架要正确，无论是固定管线还是着色器，每帧的Clear,BeginSecne,渲染设置顶点格式/顶点数据/索引数据/Draw函数，EndScene
// 都是要首先正确的。
// 7).对于顶点部分:
// 顶点位置要正确，索引下标要正确，还有世界视图投影变换，特别是索引如果是拷贝的那么很容易什么都不提交PIX也看不到原因
// 8). 对于像素部分：颜色没有出来，可能是光照没有关闭又没有设置材质，也可能是纹理缺失或者设置错误，alpha融合和各种融合情况
// 9).注意视口外裁剪不可见，背面剔除，深度剔除，模板过滤，导致物体绘制不出来。
// 10).要使用上述思维进行代码分析，errorBuffer/Control panel/#define D3D_DEBUG_INFO/PIX来调试分析,反复对比注释提高理论查找问题
// 如果有N卡用NVIDIA Nsight，GPA分析问题和性能更好。
// 11).图像异常：UV坐标没对，PIX传入都没对，那么是UV相关设置出了问题，最后对比发现是顶点声明出了问题：
//D3DVERTEXELEMENT9 Decl_Element [] =
//{
//    {eBlurDT_Pos, 0, D3DDECLTYPE_FLOAT4,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION, 0},
//    {eBlurDT_UV, 0, D3DDECLTYPE_FLOAT2,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_TEXCOORD, 0},
//    D3DDECL_END()
//};
//而不是：
    //D3DVERTEXELEMENT9 Decl_Element [] =
    //{
    //    {0, 0, D3DDECLTYPE_FLOAT4,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION, 0},
    //    {0, 16, D3DDECLTYPE_FLOAT2,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_TEXCOORD, 0},
    //    D3DDECL_END()
    //};

源码

blur.fx

// Globals
// 纹理
texture BlurTex;

// 世界视图投影矩阵
matrix WorldViewProj;

// 纹理大小
float2    TexSize;
// 高斯过滤矩阵，暂时用3x3的
float3x3 ArrayGaussianFilter;

sampler BlurSampler = sampler_state
{
    Texture = <BlurTex>;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    MipFilter = LINEAR;
};
//
// Structures
// 顶点着色器的输入
struct VS_INPUT
{
    float4 POS : POSITION;
    float2 UV : TEXCOORD0;
};
// 顶点着色器的输出
struct VS_OUTPUT
{
    float4 POS : POSITION;
    float2 UV : TEXCOORD0;
};

VS_OUTPUT VS_Main( VS_INPUT input )
{
    VS_OUTPUT outData;    
    outData.POS = mul( input.POS, WorldViewProj);
    outData.UV = input.UV;
    return outData;
}

// 像素着色器的输入
struct PS_INPUT
{
     float2 UV : TEXCOORD0;
};
// 像素着色器的输出
struct PS_OUTPUT
{
    vector diffuse : COLOR0;
};


//用来做滤波操作的函数
float4 dip_filter3(float3x3 _filter , sampler2D _image, float2 _xy, float2 texSize)

{
     //纹理坐标采样的偏移
     float2 _filter_pos_delta[3][3] =

     {

        { float2(-1.0 , -1.0) , float2(0,-1.0), float2(1.0 , -1.0) },

        { float2( -1.0 , 0.0) , float2(0.0, 0.0), float2(1.0 ,  0.0) },

        { float2( -1.0 , 1.0) , float2(0, 1.0), float2(1.0 ,  1.0) },

     };

     //最终的输出颜色
     float4 final_color = float4(0.0,0.0,0.0,1.0f);
     //对图像做滤波操作

     for(int i = 0 ; i < 3 ; i++ )

     {
         for(int j = 0 ; j < 3 ; j++ )

         {

              //计算采样点，得到当前像素附近的像素的坐标
              float2 _xy_new = float2(_xy.x + _filter_pos_delta[i][j].x ,

                                  _xy.y + _filter_pos_delta[i][j].y);

              float2 _uv_new = float2(_xy_new.x/texSize.x , _xy_new.y/texSize.y);

              //采样并乘以滤波器权重，然后累加
              final_color += tex2D( _image, _uv_new ) * _filter[i][j];

         }
     }

     return final_color;
}

PS_OUTPUT PS_Main( PS_INPUT input)
{

   PS_OUTPUT output;
   float2  intXY = float2(input.UV.x * TexSize.x , input.UV.y * TexSize.y);
   //用于模糊操作的滤波器
   // output.diffuse = tex2D(BlurSampler, input.UV);
   output.diffuse = dip_filter3( ArrayGaussianFilter , BlurSampler , intXY, TexSize);
   return output;
}

// 效果框架
technique BurTechnique
{
    pass P0
    {
        // 状态设置
        Lighting      = false;
        // 编译
        vertexShader = compile vs_2_0 VS_Main();  
        
        AlphaBlendEnable = false;
        StencilEnable = false;
        pixelShader = compile ps_2_0 PS_Main();
    }
}

d3dUtility.h

/*LPDIRECT3D9等加入*/
//#define D3D_DEBUG_INFO

#include <d3d9.h>
#include <d3dx9.h>
#include <time.h>
#include <tchar.h>

/*D3DXMATRIX加入*/
#include <d3dx9math.h>
/*LPDIRECT3D9等加入*/
#pragma comment(lib,"d3d9.lib")
/*D3DXMatrixPerspectiveFovLH加入*/
#pragma comment(lib,"d3dx9.lib")
// 媒体相关的库，用于抵挡的游戏音频和游戏手柄
#pragma comment(lib, "winmm.lib")
// 工程属性->清单工具->输入输出->嵌入清单->是改为否
#include <d3dx9.h>
#include <string>
#include <limits>

namespace d3d
{
	//
	// Init
	//
	bool InitD3D(
		HINSTANCE hInstance,       // [in] Application instance.
		int width, int height,     // [in] Backbuffer dimensions.
		bool windowed,             // [in] Windowed (true)or full screen (false).
		D3DDEVTYPE deviceType,     // [in] HAL or REF
		IDirect3DDevice9** device);// [out]The created device.

	int EnterMsgLoop( 
		bool (*ptr_display)(float timeDelta));

	LRESULT CALLBACK WndProc(
		HWND hwnd,
		UINT msg, 
		WPARAM wParam,
		LPARAM lParam);

	//
	// Cleanup
	//
	template<class T> void Release(T t)
	{
		if( t )
		{
			t->Release();
			t = 0;
		}
	}
		
	template<class T> void Delete(T t)
	{
		if( t )
		{
			delete t;
			t = 0;
		}
	}
} 

d3dUtility.cpp

#include "d3dUtility.h"

// vertex formats
const DWORD d3d::Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;


bool d3d::InitD3D(
    HINSTANCE hInstance,
    int width, int height,
    bool windowed,
    D3DDEVTYPE deviceType,
    IDirect3DDevice9** device)
{
    //
    // Create the main application window.
    //

    WNDCLASS wc;

    wc.style         = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   = (WNDPROC)d3d::WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = hInstance;
    wc.hIcon         = LoadIcon(0, IDI_APPLICATION);
    wc.hCursor       = LoadCursor(0, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName  = 0;
    wc.lpszClassName = "Direct3D9App";

    if( !RegisterClass(&wc) )
    {
        ::MessageBox(0, "RegisterClass() - FAILED", 0, 0);
        return false;
    }
        
    HWND hwnd = 0;
    hwnd = ::CreateWindow("Direct3D9App", "Direct3D9App",
        WS_EX_TOPMOST,
        0, 0, width, height,
        0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/);

    if( !hwnd )
    {
        ::MessageBox(0, "CreateWindow() - FAILED", 0, 0);
        return false;
    }

    ::ShowWindow(hwnd, SW_SHOW);
    ::UpdateWindow(hwnd);

    //
    // Init D3D:
    //

    HRESULT hr = 0;

    // Step 1: Create the IDirect3D9 object.

    IDirect3D9* d3d9 = 0;
    d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

    if( !d3d9 )
    {
        ::MessageBox(0, "Direct3DCreate9() - FAILED", 0, 0);
        return false;
    }

    // Step 2: Check for hardware vp.

    D3DCAPS9 caps;
    d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);

    int vp = 0;
    if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
        vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else
        vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

    // Step 3: Fill out the D3DPRESENT_PARAMETERS structure.
 
    D3DPRESENT_PARAMETERS d3dpp;
    d3dpp.BackBufferWidth            = width;
    d3dpp.BackBufferHeight           = height;
    d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
    d3dpp.BackBufferCount            = 1;
    d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
    d3dpp.MultiSampleQuality         = 0;
    d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow              = hwnd;
    d3dpp.Windowed                   = windowed;
    d3dpp.EnableAutoDepthStencil     = true;
    d3dpp.AutoDepthStencilFormat     = D3DFMT_D24S8;
    d3dpp.Flags                      = 0;
    d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
    d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;

    // Step 4: Create the device.

    hr = d3d9->CreateDevice(
        D3DADAPTER_DEFAULT, // primary adapter
        deviceType,         // device type
        hwnd,               // window associated with device
        vp,                 // vertex processing
        &d3dpp,             // present parameters
        device);            // return created device

    if( FAILED(hr) )
    {
        // try again using a 16-bit depth buffer
        d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
        
        hr = d3d9->CreateDevice(
            D3DADAPTER_DEFAULT,
            deviceType,
            hwnd,
            vp,
            &d3dpp,
            device);

        if( FAILED(hr) )
        {
            d3d9->Release(); // done with d3d9 object
            ::MessageBox(0, "CreateDevice() - FAILED", 0, 0);
            return false;
        }
    }

    d3d9->Release(); // done with d3d9 object
    
    return true;
}

int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )
{
    MSG msg;
    ::ZeroMemory(&msg, sizeof(MSG));

    static float lastTime = (float)timeGetTime();

    while(msg.message != WM_QUIT)
    {
        if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
        {
            ::TranslateMessage(&msg);
            ::DispatchMessage(&msg);
        }
        else
        {    
            float currTime  = (float)timeGetTime();
            float timeDelta = (currTime - lastTime)*0.001f;

            ptr_display(timeDelta);

            lastTime = currTime;
        }
    }
    return msg.wParam;
}

GaussianBlur.h

#ifndef _GAUSSIANBLUR_H_
#define _GAUSSIANBLUR_H_
class CGaussianBlur
{
public:
	CGaussianBlur(){};
	~CGaussianBlur(){};
	// 计算高斯权值
	void CalculateGaussianFilter(int nLength, float rho);
	float* GetFilter3();
	float* GetFilter4();
	float GaussianFilter3[9];
private:
	// 参数高斯权值
	float GetGaussianDistribution( float x, float y, float rho );
	// 是否接近0
	inline bool FEqual(float fValue1, float fValue2 );

	// 高斯模糊矩阵，提供3x3的和4x4的
	
	float GaussianFilter4[16];
};
#endif

GaussianBlur.cpp

#include "GaussianBlur.h"
#include <math.h>
#include <float.h>
static const int N_FilterLength3 = 3;
static const int N_FilterLength4 = 4;

bool CGaussianBlur::FEqual(float fValue1, float fValue2 )
{
	if( fabs(fValue1 - fValue2) < FLT_EPSILON )
	{
		return true;
	}
	else
	{
		return false;
	}
}

float CGaussianBlur::GetGaussianDistribution( float x, float y, float rho )
{
	float g = 1.0f / sqrt( 2.0f * 3.141592654f * rho * rho );
	return g * exp( -(x * x + y * y) / (2 * rho * rho) );
}

void CGaussianBlur::CalculateGaussianFilter(int nLength, float rho)
{
	int nSideLength = (int)floor(nLength * 0.5f);
	int nIndex = 0;
	float fTotalWeight = 0;
	for( int j = -nSideLength; j <= nSideLength ; j++ )
	{
		for( int i = -nSideLength; i <= nSideLength; i++ )
		{
			if( nLength == N_FilterLength3 )
			{
				GaussianFilter3[nIndex] = GetGaussianDistribution(i, j, rho);
				fTotalWeight += GaussianFilter3[nIndex];
			}
			else if( nLength == N_FilterLength4 )
			{
				GaussianFilter4[nIndex] = GetGaussianDistribution(i, j, rho);
				fTotalWeight += GaussianFilter4[nIndex];
			}
			else
			{
				// ERROR Log
				return;
			}

			nIndex++;
		}
	}

	// 避免除0
	if( FEqual( fTotalWeight, 0.0f) )
	{
		// ERROR Log
		return;
	}

	nIndex = 0;
	// 归一化一下
	for( int i = 0; i < nLength; i++ )
	{
		for( int j = 0; j < nLength; j++ )
		{
			if( nLength == N_FilterLength3 )
			{
				GaussianFilter3[nIndex] = GaussianFilter3[nIndex] / fTotalWeight;
			}
			else if( nLength == N_FilterLength4 )
			{
				GaussianFilter4[nIndex] = GaussianFilter4[nIndex] / fTotalWeight;
			}
			nIndex++;
		}
	}
}

float* CGaussianBlur::GetFilter3()
{
	return GaussianFilter3;
}

float* CGaussianBlur::GetFilter4()
{
	return GaussianFilter4;
}

Blur.cpp

#include "d3dUtility.h"
#include "GaussianBlur.h"

LPDIRECT3DDEVICE9 Device = NULL;
LPD3DXEFFECT BlurTexEffect = NULL;
LPDIRECT3DVERTEXDECLARATION9 VT_DECL = NULL;
LPDIRECT3DVERTEXBUFFER9 VB_Pos = NULL;
LPDIRECT3DVERTEXBUFFER9 VB_UV = NULL;
LPDIRECT3DINDEXBUFFER9 IB = NULL;

D3DXHANDLE WorldViewProjectHandle  = NULL;
D3DXHANDLE BlurTechHandle = NULL;
CGaussianBlur g_BlurFilter;

LPDIRECT3DTEXTURE9 TexObj = NULL;

const int Width  = 640;
const int Height = 480;
// 模糊的顶点数和索引缓存数
static const int N_Blur_Vertex_Count = 4;
static const int N_Blur_Index_Count = 6;
static bool g_bChangeFilter = false;

// 顶点声明的数据流索引
enum BlurVertexDeclType
{
	eBlurDT_Pos,
	eBlurDT_UV
};

//struct tagTextureVertex
//{
//	float x, y, z;
//	float u, v;
//
//	tagTextureVertex(float ax, float ay, float az, float au, float av )
//	{
//		x = ax; y = ay; z = az;
//		u = au; v = av;
//	}
//	static const DWORD FVF;
//};
//
//const DWORD tagTextureVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX1;

bool Setup()
{
	// 顶点声明
	 D3DVERTEXELEMENT9 Decl_Element [] = 
	 { 
		 {eBlurDT_Pos, 0, D3DDECLTYPE_FLOAT4,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION, 0},
		 {eBlurDT_UV, 0, D3DDECLTYPE_FLOAT2,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_TEXCOORD, 0},
		 D3DDECL_END()
	 };

	if( FAILED(Device->CreateVertexDeclaration(Decl_Element,&VT_DECL) ) )
	{
		return false;
	}
	/* Device->CreateVertexBuffer( 4 * sizeof( tagTextureVertex ),
								 D3DUSAGE_WRITEONLY, 
								tagTextureVertex::FVF, 
								D3DPOOL_MANAGED,
								&VB_Pos,
								0
								);*/
	// 顶点位置
	if( FAILED( Device->CreateVertexBuffer(4 * sizeof(D3DXVECTOR4), D3DUSAGE_WRITEONLY,
                                         0, D3DPOOL_MANAGED, &VB_Pos, 0) ) )
	{
		return false;
	}
	D3DXVECTOR4 *pPos = NULL;
	if( FAILED (VB_Pos->Lock(0, 0, (void**)&pPos, 0) ) )
	{
		return false;
	}

	//tagTextureVertex *pPos = (tagTextureVertex*)VertexData;
	float fHalfWidth = Width * 0.5f;
	float fHalfHeight = Height * 0.5f;
	pPos[0] = D3DXVECTOR4(-1.0f, -1.0f, 1.0f,  1.0f);
	pPos[1] = D3DXVECTOR4(-1.0f, 1.0f, 1.0f, 1.0f);
	pPos[2] = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
	pPos[3] = D3DXVECTOR4(1.0f, -1.0f, 1.0f, 1.0f);
	/*pPos[0] = tagTextureVertex(-1.0f,  -1.0f,1.0f,  0.0f, 1.0f);
	pPos[1] = tagTextureVertex(-1.0f,  1.0f,  1.0f, 0.0f, 0.0f);
	pPos[2] = tagTextureVertex( 1.0f,   1.0f,  1.0f,1.0f, 0.0f);
	pPos[3] = tagTextureVertex( 1.0f,  -1.0f, 1.0f, 1.0f, 1.0f);*/
	VB_Pos->Unlock();

	 顶点UV
	if( FAILED( Device->CreateVertexBuffer(4 * sizeof(D3DXVECTOR2), D3DUSAGE_WRITEONLY,
                     0, D3DPOOL_MANAGED, &VB_UV, 0) ) )
	{
		return false;
	}
	D3DXVECTOR2 *UV_Data = NULL;
	if( FAILED( VB_UV->Lock(0,0,(void**)&UV_Data, 0)) )
	{
		return false;
	}
	UV_Data[0] = D3DXVECTOR2(0.0f, 1.0f);
	UV_Data[1] = D3DXVECTOR2(0.0f, 0.0f);
	UV_Data[2] = D3DXVECTOR2(1.0f, 0.0f);
	UV_Data[3] = D3DXVECTOR2(1.0f, 1.0f);
	VB_UV->Unlock();

	// 索引缓存
	if( FAILED( Device->CreateIndexBuffer( 6 * sizeof( WORD ), D3DUSAGE_WRITEONLY, 
                     D3DFMT_INDEX16, D3DPOOL_MANAGED, &IB, 0) ) )
	{
		return false;
	}
	WORD *IB_Buffer = NULL;
	if( FAILED( IB->Lock(0,0, (void**)&IB_Buffer, 0) ) )
	{
		return false;
	}
	IB_Buffer[0] = 0;IB_Buffer[1] = 1;IB_Buffer[2] = 2;
	IB_Buffer[3] = 0;IB_Buffer[4] = 2;IB_Buffer[5] = 3;
	IB->Unlock();

	// 纹理对象设置进去就好了
	
	D3DXIMAGE_INFO imageInfo;
	D3DXCreateTextureFromFileEx(
		Device,
		"crate.png",
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		0,
		D3DFMT_UNKNOWN,
		D3DPOOL_MANAGED,
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		0,
		&imageInfo,
		NULL,
		&TexObj);

	/*Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);*/

	ID3DXBuffer* errorBuffer = 0;
	if( FAILED( D3DXCreateEffectFromFile(
		Device,
		"blur.fx",
		0,                // no preprocessor definitions
		0,                // no ID3DXInclude interface
		D3DXSHADER_DEBUG, // compile flags
		0,                // don't share parameters
		&BlurTexEffect,
		&errorBuffer) ) )
	{
		if( errorBuffer )
		{
			::MessageBox(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
			d3d::Release<ID3DXBuffer*>(errorBuffer);
		}
		return false;
	}

	// output any error messages
	//D3DXHANDLE TextureHandle =  BlurTexEffect->GetParameterByName(0, "BlurTex");
	BlurTexEffect->SetTexture(/*TextureHandle*/"BlurTex", TexObj);
	if ( TexObj != NULL )
	{
		TexObj->Release();
		TexObj = NULL;
	}
	FLOAT texSize[2] = {imageInfo.Width * 1.0f, imageInfo.Height * 1.0f};
	D3DXHANDLE TextureSizeHandle =  BlurTexEffect->GetParameterByName(0, "TexSize");
	BlurTexEffect->SetFloatArray(/*TextureSizeHandle*/"TexSize", texSize, 2);

	D3DXMATRIX W, P;
	D3DXMatrixIdentity(&W);
	//Device->SetTransform(D3DTS_WORLD, &W);
	
	D3DXVECTOR3 position( 0.0f, 0.0f, -2.0f );
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
	D3DXMATRIX V;
	D3DXMatrixLookAtLH(&V, &position, &target, &up);

	//Device->SetTransform(D3DTS_VIEW, &V);
	/*D3DXMatrixLookAtLH(&V, &position, &target, &up);
	Device->SetTransform(D3DTS_PROJECTION, &V);*/
	Device->SetRenderState( D3DRS_LIGHTING, FALSE);

	D3DXMatrixPerspectiveFovLH(
		&P,	D3DX_PI * 0.25f, // 45 - degree
		(float)Width / (float)Height,
		1.0f, 1000.0f);
	//D3DXMatrixOrthoLH(&P, float(Width), float(Height), 1.0f, 1000.0f);
	//Device->SetTransform(D3DTS_PROJECTION, &P);

	D3DXMATRIX worldViewProj = W * V * P;
	D3DXHANDLE MatrixHandle =  BlurTexEffect->GetParameterByName(0, "WorldViewProj");
	BlurTexEffect->SetMatrix(/*MatrixHandle*/"WorldViewProj", &worldViewProj);

	if( !g_bChangeFilter )
	{
		g_BlurFilter.CalculateGaussianFilter(3, 8.5f);
	}
	//float* fArray9 = g_BlurFilter.GetFilter3();
	D3DXHANDLE filterHandle =  BlurTexEffect->GetParameterByName(0, "ArrayGaussianFilter");
	BlurTexEffect->SetFloatArray(/*filterHandle*/"ArrayGaussianFilter", 
                                  g_BlurFilter.GaussianFilter3, 9);

	BlurTechHandle = BlurTexEffect->GetTechniqueByName("BurTechnique");

	return true;
}

void Cleanup()
{
	d3d::Release<LPD3DXEFFECT>(BlurTexEffect);
	d3d::Release<LPDIRECT3DVERTEXBUFFER9>(VB_Pos);
	d3d::Release<LPDIRECT3DVERTEXBUFFER9>(VB_UV);
	d3d::Release<LPDIRECT3DINDEXBUFFER9>(IB);
	d3d::Release<LPDIRECT3DDEVICE9>(Device);
}

bool Display(float timeDelta)
{
	if( Device == NULL || VB_Pos == NULL || VB_UV == NULL || IB == NULL )
	{
		return false;
	}
	Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
	Device->BeginScene();
	Device->SetVertexDeclaration(VT_DECL);
	Device->SetStreamSource(eBlurDT_Pos, VB_Pos, 0, sizeof(D3DXVECTOR4));
	Device->SetStreamSource(eBlurDT_UV, VB_UV, 0, sizeof(D3DXVECTOR2));
	Device->SetIndices(IB);
	/*Device->SetFVF(tagTextureVertex::FVF);
	Device->SetStreamSource(0, VB_Pos, 0, sizeof( tagTextureVertex ));*/

	//Device->SetTexture(0, TexObj);
	
	BlurTexEffect->SetTechnique("BurTechnique"/*BlurTechHandle*/);
	UINT numPasses = 0;
	BlurTexEffect->Begin(&numPasses, 0);
	for( int i = 0; i <  numPasses; i++ )
	{
		BlurTexEffect->BeginPass(i);
		BlurTexEffect->CommitChanges();
		// 绘制
		Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4,0, 2);

		BlurTexEffect->EndPass();
	}
	//Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4,0, 2);
	BlurTexEffect->End();

	Device->EndScene();
	Device->Present(0, 0, 0, 0);

	return true;
}

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	switch( msg )
	{
	case WM_DESTROY:
		::PostQuitMessage(0);
		break;

	case WM_KEYDOWN:
		if( wParam == VK_ESCAPE )
			::DestroyWindow(hwnd);

		break;
	}
	return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
	HINSTANCE prevInstance, 
	PSTR cmdLine,
	int showCmd)
{
	if(!d3d::InitD3D(hinstance,
		Width, Height, true, D3DDEVTYPE_HAL, &Device))
	{
		::MessageBox(0, "InitD3D() - FAILED", 0, 0);
		return 0;
	}

	if(!Setup())
	{
		::MessageBox(0, "Setup() - FAILED", 0, 0);
		return 0;
	}

	d3d::EnterMsgLoop( Display );

	Cleanup();

	Device->Release();

	return 0;
}