C++博客-李锦俊(mybios)的blog-随笔分类-Direct3D

Ogre 的渲染到纹理的关键的3个步骤

李锦俊(mybios) — Thu, 27 Dec 2007 13:06:00 GMT

好久没写技术的东西了。现在辗转间又回到了深圳工作，还是做我喜欢的游戏开发。奉献点东西给大家。

1、创建渲染目标纹理，关键要指定TU_RENDERTARGET参数，在创建这个渲染目标纹理的过程中，Ogre会自动调用 Root::getSingleton().getRenderSystem()->attachRenderTarget把这个纹理添加到Root的渲染目标中，也就是说每帧都会渲染到这个纹理。
TexturePtr texture = TextureManager::getSingleton().createManual( "RttTex",
ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, TEX_TYPE_2D,
512, 512, 0, PF_R8G8B8, TU_RENDERTARGET );

2、获得渲染目标，有了渲染目标，才能给目标指定视口和摄像机
RenderTarget *rttTex = texture->getBuffer()->getRenderTarget();

3、给这个渲染目标指定摄像机，做了这步骤之后，每帧更新时就会把这个摄像机看到的东西渲染到texture中
Viewport *v = rttTex->addViewport( mReflectCam );

4、OK！

如果本文对你的开发有所帮助，并且你手头恰好有零钱。

不如打赏我一杯咖啡，鼓励我继续分享优秀的文章。

李锦俊(mybios) 2007-12-27 21:06 发表评论

硬件兼容性的陷阱，DrawIndexedPrimitiveUP的用法

李锦俊(mybios) — Mon, 25 Dec 2006 07:11:00 GMT

好好的一个程序，在我的电脑（ELSA X800 256M显卡）上运行一切正常，拿到别的电脑（845G内置显卡）上。啊。花屏～～赶快调试，幸好公司的电脑也有这种内置显卡的电脑。赶快用远程调试。谁知这一调试，就花了我整整一个上午。。。赶快写下来。。。

最终排差的原因是DrawIndexedPrimitiveUP最后一个参数VertexStreamZeroStride ，这个参数是用来指定顶点所占的字节数。我自作聪明的把顶点结构后增加了一个自己用的数据，如：正常的顶点结构
struct CUSTOMVERTEX
{
FLOAT x, y, z,rhw;
DWORD color;
float u,v;
};

我改了之后的顶点结构：
struct CUSTOMVERTEX
{
FLOAT x, y, z,rhw;
DWORD color;
float u,v;
DWORD dwMyData; // 用来保存我自己用的数据
};

结果，在我的显卡上一切正常，这个数据也有用，然后DrawIndexedPrimitiveUP的时候，也会根据最后的参数sizeof(CUSTOMVERTEX)顺利的读取相应的顶点。但是，拿到845G的内置显卡上就死活花屏。后来终于知道是这个原因，于是解决办法就是把dwMyData去掉，放到顶点结构外面去。

顺便说说DrawIndexedPrimitiveUP的用法：
HRESULT DrawIndexedPrimitiveUP(
D3DPRIMITIVETYPEPrimitiveType, // 图原的类型
UINTMinVertexIndex, // 指定0
UINTNumVertices, // 指定需要渲染的顶点的数量（如一个矩形可以由4个顶点组成，然后通过顶点索引来达到渲染2个三角形的效果，那么这里就应该填写4，而不是6）
UINTPrimitiveCount, // 要渲染的图原的数量（如一个矩形，由两个三角形组成，就应该填写2）
CONST void *pIndexData, // 索引数据指针
D3DFORMATIndexDataFormat, // 索引数据格式，一般为D3DFMT_INDEX16或D3DFMT_INDEX32
CONST void*pVertexStreamZeroData, // 顶点数据指针
UINTVertexStreamZeroStride // 顶点大小一般为sizeof(顶点结构)
);

记得默认情况下渲染三角形的顺序是逆时针的（初学者经常范这个错误，本来想渲染一个矩形，结果一个三角形顺时间、另一个三角形逆时针，结果渲染出来只看到一个三角形了，被背面剔除掉了）。

李锦俊(mybios) 2006-12-25 15:11 发表评论

顶点声明

李锦俊(mybios) — Sat, 02 Dec 2006 08:42:00 GMT

摘要: 顶点声明从概念上讲，顶点声明是对顶点直接内存访问（DMA）以及图形流水线的 tessellator 引擎进行编程的一种方法。顶点声明简要地表示了数据的布局及 ... 阅读全文

李锦俊(mybios) 2006-12-02 16:42 发表评论

【转贴】DXUT编程指南(四):通过DXUT使用设备

李锦俊(mybios) — Wed, 22 Nov 2006 03:35:00 GMT

通过DXUT使用设备
DirectX设备的创建在DXUT中得到了改进。你可以让你的应用程序直接创建设备而其它有框架提供的特征仍然可用。
创建设备
 选择最佳的设备设置
修改可用的设备设置
降为软件顶点处理
使用你自己的设备

创建设备
典型地，你将通过标准的Direct3D方法创建设备
HRESULT CreateDevice(
    UINT                  Adapter,
    D3DDEVTYPE            DeviceType,
    HWND                  hFocusWindow,
    DWORD                 BehaviorFlags,
    D3DPRESENT_PARAMETERS *pPresentationParameters,
    IDirect3DDevice9      **ppReturnedDeviceInterface
);
这个方法需要有效的适配器，设备类型(HAL or REF),窗口句柄，行为标志(software/hardware vertex processing 和其它驱动标志)，以及呈现参数(presentation parameters).此外，D3DPRESENT_PARAMETER结构体还拥有大量的成员指定后备缓冲区，多重采样设定，交换效果，窗口模式，深度模版缓冲，刷新率，呈现间隔，以及呈现标志。
为所有这些参数选择有效的设定是具有挑战性的。框架通过DXUTCreateDevice函数简化了这一选择过程。
HRESULT DXUTCreateDevice(
    UINT AdapterOrdinal = D3DADAPTER_DEFAULT,
    BOOL bWindowed       = TRUE,
    INT nSuggestedWidth = 640,
    INT nSuggestedHeight = 480,
    LPDXUTCALLBACKISDEVICEACCEPTABLE pCallbackIsDeviceAcceptable     = NULL,
    LPDXUTCALLBACKMODIFYDEVICESETTINGS pCallbackModifyDeviceSettings = NULL
);
最基本的用法是全部使用缺省参数调用：
DXUTCreateDevice();
通过这样的调用框架使用缺省设置创建一个在大多数情况下可用的设备。缺省的设置如下：

Direct3D Creation Flag	Description	Default Value from DXUTCreateDevice
AdapterFormat parameter of CheckDeviceFormat	Adapter surface format.	Desktop display mode, or D3DFMT_X8R8G8B8 if the desktop display mode is less than 32 bits.
Adapter parameter of IDirect3D9::CreateDevice	Display adapter ordinal.	D3DADAPTER_DEFAULT
D3DPRESENT_PARAMETERS. BackBufferCount	Number of back buffers.	2, indicating triple buffering.
D3DPRESENT_PARAMETERS. BackBufferFormat	Back buffer format.	Desktop display mode, or D3DFMT_X8R8G8B8 if the desktop display mode is less than 32 bits.
D3DPRESENT_PARAMETERS. AutoDepthStencilFormat	Depth format of the automatic depth-stencil surface that the device will create.	D3DFMT_D16 if the backbuffer format is 16 bits or less, or D3DFMT_D32 otherwise.
The DeviceType parameter of IDirect3D9::CreateDevice	Enumerated type of the device.	D3DDEVTYPE_HAL if available, otherwise D3DDEVTYPE_REF or failure code if neither is available.
D3DPRESENT_PARAMETERS. MultiSampleQuality	Quality level.	MultiSampleQuality = 0, indicating multisampling is disabled.
D3DPRESENT_PARAMETERS. Flags	Presentation parameters flags.	D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL
D3DPRESENT_PARAMETERS. PresentationInterval	Presentation interval.	D3DPRESENT_INTERVAL_IMMEDIATE for windowed mode, or D3DPRESENT_INTERVAL_DEFAULT for full-screen mode.
D3DPRESENT_PARAMETERS. FullScreen_RefreshRateInHz	Rate at which the display adapter refreshes the screen.	0, indicating windowed mode.
D3DPRESENT_PARAMETERS. BackBufferWidth and .BackBufferHeight	Display mode resolution.	640 x 480 pixels for windowed mode, or the desktop resolution for full-screen mode.
D3DPRESENT_PARAMETERS. AutoDepthStencilFormat	Stencil format of the automatic depth-stencil surface that the device will create.	D3DFMT_D16 if the backbuffer format is 16 bits or less, or D3DFMT_D32 otherwise.
D3DPRESENT_PARAMETERS. SwapEffect	Swap effect.	D3DSWAPEFFECT_DISCARD
BehaviorFlags parameter of IDirect3D9::CreateDevice	Vertex processing flags.	D3DCREATE_HARDWARE_VERTEXPROCESSING if supported, otherwise D3DCREATE_SOFTWARE_VERTEXPROCESSING.
D3DPRESENT_PARAMETERS. Windowed	Windowed or full-screen mode.	true, indicating windowed mode.
hFocusWindow parameter of CreateDevice	Handle to the created window (see Using Application Windows with DXUT).	hWndFocus parameter of DXUTSetWindow
D3DPRESENT_PARAMETERS. hDeviceWindow	Handle to the device window.	hWndDeviceFullScreen or hWndDeviceWindowed parameters of DXUTSetWindow
D3DPRESENT_PARAMETERS. EnableAutoDepthStencil	Depth-stencil buffer creation flag.	true.

应用程序可以通过参数传递给CreateDevice来更多的控制设备的创建，这将比使用缺省的方式更好。例如，你可以通过nSuggestedWidth and nSuggestedHeight参数改变窗口的尺寸。
DXUTCreateDevice(
    D3DADAPTER_DEFAULT,
    false,
    1024,
    786,
    NULL,
    NULL,
    NULL
);
要得到更多的控制权，应用程序可以使用这两个可选的回调函数，LPDXUTCALLBACKISDEVICEACCEPTABLE and LPDXUTCALLBACKMODIFYDEVICESETTINGS.

选择最佳的设备设置
你可以使用IsDeviceAcceptable回调函数帮助框架为你的应用程序选择最佳的设备设置，就像下面的代码：
bool CALLBACK IsDeviceAcceptable(
D3DCAPS9*     pCaps,
D3DFORMAT     AdapterFormat,
D3DFORMAT     BackBufferFormat,
bool          bWindowed,
void*         pUserContext )
{
    // TODO: return true for acceptable settings and false otherwise.
    return true;
}
这个回调函数的模型基于LPDXUTCALLBACKISDEVICEACCEPTABLE原型(This callback function is modeled on the prototype LPDXUTCALLBACKISDEVICEACCEPTABLE)，框架为每个唯一的以下5个设置的有效组合调用这个函数一次：
D3DDEVTYPE DeviceType;
UINT       AdapterOrdinal;
D3DFORMAT AdapterFormat;
D3DFORMAT BackBufferFormat;
bool       Windowed;
注意适配器序号和设备类型没有直接的传入回调函数，而是分别作为D3DCAPS9结构体的成员。
通过这个回调函数，应用程序可以拒绝任何它不支持的或不想要的组合。例如，应用程序可以使用下面的代码拒绝16bits的后备缓冲区格式和所有至少不能支持像素着色器PS_2_0的设备：
bool CALLBACK IsDeviceAcceptable(
    D3DCAPS9*     pCaps,
    D3DFORMAT     AdapterFormat,
    D3DFORMAT     BackBufferFormat,
    bool          bWindowed )
{
    if( pCaps->PixelShaderVersion < D3DPS_VERSION(2,0) )
     return false;
    if( BackBufferFormat == D3DFMT_X1R5G5B5 || BackBufferFormat == D3DFMT_R5G6B5 )
        return false;
    return true;
}

为每个唯一的组合调用回调函数后，框架排列剩下的可用组合，并选择它们当中最好的。排名较高的如下：
D3DDEVTYPE_HAL，获取硬件加速
如果应用程序以全屏模式显示，框架更趋向于使用匹配桌面格式的适配器格式，这样可以在全屏与窗口之间快速切换。例外的是，如果桌面显示模式小于32位，框架更趋向于D3DFMT_X8R8G8B8.
匹配适配器格式的后备缓冲区格式
在选择了这些排名高的组合后，要创建设备，行为标志和呈现参数仍然是需要的。对于这些设置,Direct3D使用上面表中的缺省值。

修改可用的设备设置
应用程序可以通过使用第二个可选的回调函数修改对框架可用的设置，这个函数是ModifyDeviceSettings:
bool CALLBACK ModifyDeviceSettings(
    DXUTDeviceSettings* pDeviceSettings,
    const D3DCAPS9*     pCaps )
{
    // TODO: Include device creation requirements here.
    // 返回真创建设备返回False保持当前设置
    return true;
}
这个函数是基于原型LPDXUTCALLBACKMODIFYDEVICESETTINGS的。DXUTDeviceSettings结构体被框架定义为：
struct DXUTDeviceSettings
{
    UINT       AdapterOrdinal;
    D3DDEVTYPE DeviceType;
    D3DFORMAT AdapterFormat;
    DWORD      BehaviorFlags;
    D3DPRESENT_PARAMETERS pp;
};

这个结构体包含了创建设备所需要的所有东西，除了窗口句柄,它被假定为先前创建的窗口的句柄。框架用有效的数据填充这个结构体，然后允许应用程序通过ModifyDeviceSettings回调函数改变设备创建的选择。
在这个回调函数中，应用程序可以在DXUTDeviceSettings结构体中改变行为标志以及呈现参数,乃至结构体中任何其它的东西。如果应用程序在回调函数中什么都不改变，设备会成功的创建。然而，对设备创建设置的任何改变都需要被设备支持，否则可能会导致设备创建失败。
比如，如果应用程序需要一个D3DFMT_D24S8的深度模板缓冲区格式，就必须验证设备是否支持，就像下面的代码：
bool CALLBACK ModifyDeviceSettings(
    DXUTDeviceSettings* pDeviceSettings,
    const D3DCAPS9*     pCaps )
{
    IDirect3D9* pD3D = DXUTGetD3DObject();
    if( SUCCEEDED( pD3D->CheckDeviceFormat(
         pDeviceSettings->AdapterOrdinal,
         pDeviceSettings->DeviceType,
         pDeviceSettings->AdapterFormat,
         D3DUSAGE_DEPTHSTENCIL,
         D3DRTYPE_SURFACE,
         D3DFMT_D24S8 ) ) )
    {
     if( SUCCEEDED( pD3D->CheckDepthStencilMatch(
             pDeviceSettings->AdapterOrdinal,
             pDeviceSettings->DeviceType,
             pDeviceSettings->AdapterFormat,
             pDeviceSettings->pp.BackBufferFormat,
             D3DFMT_D24S8 ) ) )
    {
         pDeviceSettings->pp.AutoDepthStencilFormat = D3DFMT_D24S8;
    }
    }

    return true;
}

候选的方案是，回调函数可以使用框架的CD3DEnumeration 对象验证D3DFMT_D24S8是否被支持：
bool CALLBACK ModifyDeviceSettings(
    DXUTDeviceSettings* pDeviceSettings,
    const D3DCAPS9*     pCaps )
{
    CD3DEnumeration *pEnum = DXUTGetEnumeration();
    CD3DEnumDeviceSettingsCombo *pCombo;

    pCombo = pEnum->GetDeviceSettingsCombo( pDeviceSettings );

    if( pCombo->depthStencilFormatList.Contains( D3DFMT_D24S8 ) )
        pDeviceSettings->pp.AutoDepthStencilFormat = D3DFMT_D24S8;

    return true;
}

应用程序修改了设备的设置后，框架就会用新的设置创建设备。
DirectX April 2005 SDK Update中的更新，ModifyDeviceSettings 回调函数返回了一个bool值。如果应用程序返回true框架继续正常的创建设备。如果返回false框架不改变设备并且保持当前的设备，如果已经有一个存在的话。这允许应用程序能够拒绝框架将设备改变到程序不能使用的请求。例如，在多监视器的缺省配置下，在监视器之间拖动窗口会导致框架改变设备。然而，如果应用程序不能使用其它的设备的话，它应当可以拒绝改变，并继续使用当前的设备。

回降到软件顶点处理
如果你设置一个Direct3D设备到支持像素处理却不支持顶点处理的硬件，你会因此需要改变行为标志。为了确保正确地降到软件顶点处理，谨防你不能拒绝一个基于IsDeviceAcceptable回调函数中顶点着色器版本的设备，并确保行为标志在ModifyDeviceSettings 回调函数中被正确调整。这儿有一个例子演示怎样做这些事情。
bool CALLBACK ModifyDeviceSettings( DXUTDeviceSettings* pDeviceSettings,
                                    const D3DCAPS9* pCaps )
{
    // If device doesn't support HW T&L or doesn't support 1.1 vertex
    // shaders in HW, then switch to SWVP.
    if( (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) == 0 ||
         pCaps->VertexShaderVersion < D3DVS_VERSION(1,1) )
    {
        pDeviceSettings->BehaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }

    else
    {
        pDeviceSettings->BehaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    }

    return true;
}

使用你自己的设备
你没有必要依赖于框架来创建Direct3D设备。应用程序自己可以创建设备并将他传递给框架使用。就像应用程序可以覆盖框架的window creation 设置。简单的使用你想要的设置创建一个设备，然后调用 DXUTSetDevice函数让框架在你的设备上渲染。
注意：如果应用程序创建了不依赖于框架的设备，那么应用程序也必须在主循环执行完以后亲自的通过cleanup 释放设备接口。
另请参阅
通过DXUT作更高级的设备选择

李锦俊(mybios) 2006-11-22 11:35 发表评论

【转贴】EffectFramework

李锦俊(mybios) — Mon, 20 Nov 2006 08:54:00 GMT

Effect Framework

摘要

本文简要介绍了在DirectX 9 SDK中提供的Effect Framework支持，以及DirectX FX文件结构和Microsoft Hight Level Shading Language的基本知识。本文假定读者对DirectX Graphics有一定了解，并正在学习DirectX Effect Framework。希望能够与各位读者共同探讨、切磋。

简介

Effect的起源

在计算机3维场景中，物体表面的材质代表了其光学特性。最简单的材质可以表现为Diffuse颜色，Specular颜色，Emissive颜色等信息的集合；而为了表现物体表面的细节，可以在材质中加入一张纹理——这些就构成了最基本的材质信息。在以前的Direct3D程序中，这些信息可以直接传送给设备，由设备自动根据它们来计算物体表面的光学效果。但是，仅仅有这些基本的材质信息，已经不足以满足游戏制作者的要求和游戏玩家的要求了——他们希望场景中的材质更加复杂，具有更多的细节，更加逼真。

在Direct3D中，除了材质的概念，还存在一个渲染状态（Render State）的概念。在Direct3D Device中存在很多的渲染状态，它们可以在Direct3D进行渲染时控制渲染的流程和效果，从而实现某些带有特效的材质。程序员可以通过IDirect3DDevice*::SetRenderState()方法来设置这些状态。所有的渲染状态都是一些特定的数值。对状态的设置可以通过硬编码完成，即在程序中调用SetRenderState()方法，将设置什么样的状态“写死”在程序里，但是这样做的缺点就是太不灵活了——如果想要实现一种新的渲染状态，就需要修改程序代码。所以更好的一种方法是将为了实现某一种特效材质的一些渲染状态值记录到一个“效果文件”中，通过在程序运行时读取该文件，从中分析出这些值，并将它们作为参数调用SetRenderState()。这样，要想实现一种新的特效，只需修改“效果文件”而不用更改代码。

Direct3D SDK是通过Effect Framework来支持这种机制的。而前面所述的“效果文件”在Direct3D中是以*.fx文件存在的。在fx文件中保存了为实现某一特效的渲染状态，包括状态名称和它们的对应值。所以在9.0以前版本的DirectX中就已经有Effect Framework和FX文件了，早期的Effect Framework仅仅是为了实现对渲染状态进行控制。但是随着计算机显示硬件技术的发展，图形处理单元（GPU）正在重复CPU所走过的路——新一代的GPU已经具有了可编程特性，程序员可以通过对GPU编写一段程序来控制其渲染的输出效果。这种程序一般称为Shader程序。目前的Shader程序分成两种，Vertex Shader和Pixel Shader。Vertex Shader主要用于对3维网格模型的每一个顶点进行处理，而Pixel Shader主要用于对要绘制到屏幕上的每一个象素进行处理。通过Shader，程序员可以制作出相当丰富的实时渲染效果。

同CPU一样，对GPU编程也是借助一定的编程语言来进行的。在DirectX 8中，对GPU的编程是通过一种类似于汇编的语言进行的。而在DirectX 9中，使用了一种类似于C语言的高级语言——Microsoft High Level Shading Language (HLSL) 。

无论使用什么语言对GPU编程，都需要把编译好的Shader程序输送到显卡去。Direct3D Device可以通过SetVertexShader()和SetPixelShader()来向显卡输送Shader程序。然而，由于Shader和材质具有十分紧密的关系——一般来说，一个Shader就是为了实现一种特殊的材质——最好是能够将Shader程序与材质进行整合。所以，在DirectX 8和DirectX 9中，原来的Effect Framework发生了扩充——在原来的基础上加入了对Shader程序的支持。程序员可以把Vertex Shader和Pixel Shader程序以函数的方式直接书写在FX文件中。

.FX文件

FX文件中的内容大致可以分成几部分：

预编译标志
变量表
结构定义
函数
Technique

预编译标志：预编译标志包括

#define
#elif
#else
#endif
#error
#if
#ifdef
#ifndef
#include
#line
#pragma
#undef

其中最常用到的是#include和#define，同C语言中的意义很相似：用#include可以在一个FX文件中引入另外一个或多个文件。#define可以定义FX文件中的宏替换。例如：

#include "helper_Funcs.fx"      //引入一个名为helper_funcs.fx的fx文件
#include "public_variables.fh" //引入一个名为public_variables.fh的文件
#define MATRICES_COUNT 25      //定义宏MATRICES_COUNT为25
#define VSHADER VShader_2_0    //定义宏VSHADER为VShader_2_0

#include带来的好处和C中也是一样的－您可以在一个头文件中定义一些公有变量、函数等，在其他文件中引用它们－就不用写很多遍了。例如：

文件public.fh:

mat4x4 matWorldViewProj; // 4x4世界－视－投影变换矩阵
float3 lightPosisiton;   // 三维光源位置向量
float4 lightColor;       // 光源的颜色
float time;              // 当前时间

//定义一个名为VS_OUTPUT的结构。关于结构体定义，下文中会有介绍

struct VS_INPUT
{
    float4 LocalPos : POSITION;
    float3 Normal : NORMAL;
    float4 Color : COLOR;
    float2 Texcoord : TEXCOORD0;
};

struct VS_OUTPUT
{
    float4 WorldPos : POSITION;
    float4 Color : COLOR;
    float2 Texcoord : TEXCOORD0;
};

//定义一个名为CaculateWorldPosition的函数。关于函数定义，下文中会有介绍

float3 CaculateWorldPosition( float4 LocalPos )
{
return mul( LocalPos, matWorldViewProj);
}

这样，当我们在另外一个文件中include这个头文件时，上面所有的定义都可以直接使用了。

文件client.fx:

#include "public.fh"

VS_OUTPUT VS_main( VS_INPUT In ) // 可以直接使用结构体定义VS_OUTPUT和VS_INPUT
{
    VS_OUTPUT Out = 0;
    Out.WorldPos = CaculateWorldPosition( In.LocalPos ); // 可以直接使用函数
    Out.Color = In.Color;
    Out.Texcoord = In.Texcoord;
}

这样不仅可以复用代码，还可以使变量名、结构体、函数名的定义统一。

而#define不仅仅可以使某些常量具有比较有意义的名称，通过与#ifdef，#ifndef, #else, #endif等结合使用，还可以用来根据一些配置控制编译过程。

变量表

每个FX文件都可以有若干参数变量，通过Effect Framework可以在程序中识别出这些参数的类型、名称和用途，这样就可以将程序中的一些参数输送到Effect中去，从而更加灵活的控制效果。参数的类型很多，可以是int, float, matrix, texture等等。例如：

matrix matWorld; //定义一个名为matWorld的矩阵类型参数变量
float time; //定义一个名为time的浮点类型参数变量
texture texDiffuse; //定义一个名为texDiffuse的纹理类型参数变量

另外，每个变量还有前缀修饰符、Semantic、Annotation等，限于篇幅，在这里不再赘述，具体的介绍请参考DirectX C++帮助文档的DirectX Graphics > Reference > HLSL Shader Reference > Variable Declaration Syntax条目。

结构定义

在FX文件中可以定义结构体，这些结构体一般用于Shader函数的参数和返回值。结构体的定义与C语言方式及其类似，例如：

struct VS_OUTPUT //结构名称
{
    float4 Pos : POSITION; //成员变量。
    float4 Color : COLOR;
    float2 Texcoord : TEXCOORD0;
};

上面每个成员变量后面的标识符是该变量的semantic，HLSL编译器根据这个标识符来确定该变量的用处。不一定非得是结构体成员变量才有semantic，一般来说Shader的输入输出参数变量都可以有semantic。

函数

函数部分是在Effect Framework加入了对Vertex Shader和Pixel Shader的扩充后才加入到FX文件中的。FX文件中的函数的内容可以用汇编形式书写，也可以用HLSL编写。目前一般都是使用HLSL。用这种语言书写的函数与C语言函数十分类似，可以说，只要学过C语言，书写Shader函数就绰绰有余了。在同一个fx文件中可以定义很多函数，在函数中也可以互相调用，但是最终Shader程序的入口将在fx文件的Technique部分中指定。对于哪个函数是Vertex shader函数，哪个是Pixel shader函数，也是在Technique中指定的。关于Technique，将在下文中介绍。例子：

float4 CalcDiffuseColor( float3 Normal )
{
float4 Color; ...//用于实现该函数功能的多条语句
return Color;
}

VS_OUTPUT Vertex_Shader( float4 InPos : POSITION,
                         float3 InNor : NORMAL,
                         float3 InTexcoord : TEXCOORD )
{
    VS_OUTPUT Out; ...//用于实现该函数功能的多条语句
    Out.Color = CalcDiffuseColor(InNor); //函数调用
    return Out;
}

正如上文中所说，Shader程序分为两种：Vertex shader和Pixel shader。在fx函数中就有两种相应的函数：Vertex shader函数和Pixel Shader函数。Vertex shader函数的输入参数是网格模型中的每一个顶点数据，其输出是经过该函数特殊处理的顶点数据；而Pixel Shader函数的输入，则是经过硬件光栅化过程后经过插值的Vertex shader输出结果。至于Pixel shader的输出，一般就是经过该函数计算得到的一个颜色值，即要画到后备缓冲中一个象素上的颜色值。但是这个“颜色值”有时并不一定代表颜色。而且对于支持多RenderTarget的硬件，Pixel shader还可以有多个输出，分别对应不同的RenderTarget。

technique

technique是FX文件的主体，是真正设置各种渲染状态的地方，也是指定所使用的Shader程序入口的地方。在理解Technique前首先要理解Pass的概念。Pass是Technique的组成部分，一个Pass就代表了绘制时的一遍。通常为了达到一种效果，仅仅绘制一遍网格模型是不够的，需要向framebuffer中多次绘制，并利用设置渲染状态中的BlendState进行Alpha混合。这就是经常提到的“Muli-pass Rendering”。但是随着硬件越来越强大，Shader程序的功能越来越强，目前的趋势是所有的特效材质都将可以用越来越少个Pass来完成。一个technique中，可以存在一个或多个Pass，但是至少要有一个Pass时该technique才会起实际作用。当存在多个pass时，默认情况下在渲染时将会按照pass在文件中的前后顺序作为渲染时的前后顺序。technique和Pass中的内容都是以大括号括起来。

technique的例子：

technique Tec_Shader_1_X //定义一个名为Tec_Shader_1_X的technique
{
    pass P0 //一个名为P0的pass
    {
        VertexShader = compile vs_1_1 Vertex_Shader(); //设置Vertex Shader程序入口函数
        PixelShader = compile ps_1_1 Pixel_Shader();   //设置Pixel Shader程序入口函数
        AlphaBlendEnable= true;                        //设置渲染状态
        SrcBlend = SrcAlpha;
        DestBlend = InvSrcAlpha;
        ... //其他设置
    }
    pass P1 //一个名为P1的pass
    {
        ...
    }
}

ID3DXEffect接口

上面介绍了很多fx文件相关内容，但是在程序中如何读取和分析这些fx文件呢？在程序中对于读取fx文件，控制渲染状态、设置Shader程序等工作都是通过D3DX库中的ID3DXEffect接口来实现的。ID3DXEffect接口提供了大量的方法，基本上分为几个方面：

获得Effect参数变量信息
设置Effect参数变量
获得technique信息
设置当前使用的technique
开始和结束使用当前的technique
执行一个pass（渲染绘制遍）

ID3DXEffect接口的创建：通过D3DX库中的D3DXCreateEffectFromFile()函数，可以根据一个指定的文件的内容来创建一个ID3DXEffect接口。在该函数执行成功后，所创建的接口中就包含了文件里所对应的所有内容，包括参数变量表、Shader程序、technique和pass等。

ID3DXEffect接口的使用：通过该接口的方法可以获得FX文件中的所有信息，并设置参数变量和当前的technique。所有的参数变量、technique、pass、shader等等都有自己的名称，根据这些名称，通过调用ID3DXEffect::GetParameterByName()、ID3DXEffect::GetTechniqueByName()和ID3DXEffect::GetPassByName()等方法就可以获得这些对象的句柄，从而在调用 ID3DXEFFECT::Set***()进行设置时使用句柄而不是字符串进行索引来提高效率。

通过ID3DXEffect::GetParameterDesc()、ID3DXEffect::GetTechniqueDesc()和GetPassDecs等方法可以获得关于指定对象的所有细节描述信息。 D3DX库中定义了一个D3DXPARAMETER_DESC结构来专门表示参数的类型。通过ID3DXEffect::GetParameterDesc()方法，可以为一个参数获得这样一个结构的数据。

typedef struct _D3DXPARAMETER_DESC
{
    LPCSTR Name;               //参数变量名
    LPCSTR Semantic;           //参数变量的Semantic
    D3DXPARAMETER_CLASS Class; //参数变量的类别，可以是标量、矢量、矩阵、对象和结构
    D3DXPARAMETER_TYPE Type;   //参数变量的类型
    UINT Rows;                 //数组型参数的行数
    UINT Columns;              //数组型参数的列数
    UINT Elements;             //数组中的元素个数
    UINT Annotations;          //参数变量的Annotation个数
    UINT StructMembers;        //结构型参数变量成员的个数
    DWORD Flags;               //参数属性
    UINT Bytes;                //参数大小，以字节记
} D3DXPARAMETER_DESC;

其中的参数类型可以有下列几种：

typedef enum _D3DXPARAMETER_TYPE
{
    D3DXPT_VOID, //Void型指针
    D3DXPT_BOOL, //Bool型
    D3DXPT_INT, //整型
    D3DXPT_FLOAT, //浮点型
    D3DXPT_STRING, //字符串
    D3DXPT_TEXTURE, //纹理
    D3DXPT_TEXTURE1D, //一维纹理
    D3DXPT_TEXTURE2D, //二维纹理
    D3DXPT_TEXTURE3D, //三维纹理
    D3DXPT_TEXTURECUBE, //立方体环境纹理
    D3DXPT_SAMPLER, //纹理取样器
    D3DXPT_SAMPLER1D, //一维纹理取样器
    D3DXPT_SAMPLER2D, //二维纹理取样器
    D3DXPT_SAMPLER3D, //三维纹理取样器
    D3DXPT_SAMPLERCUBE, //立方体环境纹理取样器
    D3DXPT_PIXELSHADER, //Pixel Shader程序
    D3DXPT_VERTEXSHADER, //Vertex Shader程序
    D3DXPT_PIXELFRAGMENT, //Pixel Shader片断
    D3DXPT_VERTEXFRAGMENT, //Vertex Shader片断
    D3DXPT_FORCE_DWORD = 0x7fffffff
} D3DXPARAMETER_TYPE;

而真正要让Effect起作用，需要在绘制网格模型前后调用ID3DXEffect::BeginPass()和EndPass方法。在调用这两个函数之前和之后，还需调用ID3DXEffect::Begin()和 ID3DXEffect::End()方法来界定此次Effect设置的起止。大致的形式如下：

LPD3DXEffect pd3dEffect； //ID3DXEffect接口指针
... //初始化该指针
... //程序中的其他部分
...

UINT numPasses; //用于接受当前所使用的technique中的pass个数
pd3dEffect->Begin( & numPasses, 0 ) //开始使用当前的technique
for( UINT iPass = 0; iPass < numPasses; iPass ++ )
{
    //遍历所有的pass
    pd3dEffect->BeginPass( iPass ); //调用BeginPass
    DrawMesh();                     //然后进行模型的绘制。
    pd3dEffect->EndPass();          //调用EndPass
}
pd3dEffect->End();                  //不要忘记结束当前technique

3DS MAX对DirectX 9 Shader Material的支持；Effect数据获取和导出

在FX文件中的参数，大部分都是用来调整FX文件所指定的Effect的一些细节，例如，一种带有凹凸纹理的效果，可能在FX中就有一个参数控制着凹凸不平的程度。而这些参数是需要由美工来调整的。另外，美工也需要有一个途径能够将FX文件定义的Effect赋予到一个模型或它的一部分上去。同时美工也应该能够实时的预览该Effect在模型上的实际效果。在以前，实现这些要求只能通过自制效果预览器、模型编辑器或者为DCC软件编写插件来完成。这对于小的工作组和工期较短的项目来说是非常困难的。幸运的是，目前的DCC软件已经开始为游戏制作提供丰富的支持功能。通过DCC软件自身就可以预览到实时Effect的效果，并调整其参数。在《龙的传说》这个项目中，我们使用3DS MAX 6.0来作为模型建立工具和Shader预览工具。

在3DS MAX 6.0中，新加入了一种材质类型——DirectX 9 Shader材质。这种材质是基于FX文件的。一个FX文件就可以代表一种材质。它可以同MAX中的其他材质一样赋予到模型上。在MAX的Viewport中可以实时地观察到FX文件中设计的效果。通过为FX中的参数设置特定的Semantic，可以将这些参数与MAX中的场景信息联系起来，如摄像机位置、世界变换矩阵等。对于控制Effect效果的一些本地参数，可以通过为它们添加特定的Annotation，使MAX能够直接识别这些参数并在用户界面中显示它们的名称和调节控件。对应不同类型的参数，MAX可以为它们生成不同的调节控件。这样，这种材质就和MAX的其他材质一样，可以更改纹理等等的参数了。对于美工来说，通过这种用户界面就可以调整该FX材质的参数达到最好的效果。

但是美工所调整的结果必须要能够保存下来才有意义。这个工作就得由程序员来完成了。要保存3DS MAX中编辑的所有内容，需要为3DS MAX编写文件导出插件，将其内部数据保存在特定格式的文件中。在《龙的传说》这个项目中，我们使用Microsoft DirectX .X 文件。如果从头开始写导出插件，工作量是相当大的；幸运的是，在Microsoft DirectX SDK Extra中提供了一个能够导出模型和3DS MAX标准材质到X文件的插件源代码。通过修改该源代码，可以使它能够导出DirectX 9 Shader材质。在3DS MAX 6 SDK中新增加了一个IDxMaterial接口，通过查询一个IMaterial接口是否为IDxMaterial接口，就可以确定该材质是否为DirectX 9 Shader材质。通过IDxMaterial接口可以获得该材质对应的FX文件的文件名，以及其参数信息。这样就可以将它们导出了。

.X文件中对Effect的支持；EffectInstance和EffectDefault

Microsoft DirectX .X文件的格式是基于模板的、可扩展的文件格式。通过为其制定新的模板，就可以在其中加入新的内容。一般的.X文件中的内容有三维场景的物体层级关系、网格模型几何数据、材质信息、动画信息等。在DirectX的众多X文件模板中有一个模板是专门用来代表Effect的实例的。当一个FX文件的参数被美工加以调整从而具备一些特定的值之后，该 FX文件和这些参数值的集合就形成了一个Effect实例。该模板的定义如下：

template EffectInstance
{
    < E331F7E4-0559-4cc2-8E99-1CEC1657928F >
    STRING EffectFilename;
    [ ... ]
}

其中， EffectFilename代表了该Effect实例中的FX文件名， [ ... ]代表在其中可以插入任何X文件模板对应的数据。这样就可以代表任何类型的参数值。

然而要想让Direct3D程序能够识别[ ... ]中的内容，需要使用X文件模板中的EffectParam系列模板，包括EffectParamDWord, EffectParamFlaots, EffectParamString。通过这三种模板对应的数据，所有类型的Effect参数值都可以被记录在X文件中。

最后，EffectInstance数据需要被放置在Material数据中才可以被识别。

Material模板：

template Material
{
    < 3D82AB4D-62DA-11CF-AB39-0020AF71E433 >
    ColorRGBA faceColor;
    FLOAT power;
    ColorRGB specularColor;
    ColorRGB emissiveColor;
    [...]
}

前面的一些颜色模板表明在Material数据中这些颜色信息是必须有的，而最后的[ ... ]则代表可以插入任何X文件模板对应的数据。我们的EffectInstance数据就可以放置在这里。

举一个简单的例子：

Material { //材质
    0.500000;0.500000;0.500000;1.000000;; //faceColor
    0.000000; //power
    0.900000;0.900000;0.900000;; //specularColor
    0.000000;0.000000;0.000000;; //emissiveColor
    EffectInstance
    {                            //[...]，这里是EffectInstance
        "SkyboxNew01.fx";        //fx文件的文件名。通过D3DXCreateEffectFromFile()可以
                                 //建立该文件对应的D3DXEffect对象
        //下面是EffectInstance中的[...]
        EffectParamString
        {                        //EffectParamString，即字符串型参数值
            "TexCloudTop";       //参数的名称，通过该名称调用ID3DXEffect::GetXXXByName()方法
                                 //可以得到与fx文件中对应的参数。
            "DarkClouds01.jpg"; //参数的值
        }
        EffectParamString
        {                        //同上
            "TexCloudBottom";
            "DarkClouds02.jpg";
        }
        EffectParamFloats
        {                       //EffectParamFloats，即浮点数组型参数值
            "Brightness";       //参数名称
            1;                  //浮点数组大小
            0.500000;           //值
        }
    }
}

当我们在程序中调用D3DXLoadMeshFromX()或D3DXLoadMeshHierarchyFromX()时，就可以通过其LPD3DXBUFFER *ppEffectInstances参数来接收到网格所用的所有EffectInstance的信息。

在程序中，对应于X文件中的EffectInstance模板和EffectParam系列模板，有两个结构体用来代表Effect数据：

typedef struct _D3DXEFFECTINSTANCE
{ //EffectInstance
    LPSTR pEffectFilename; //fx文件名
    DWORD NumDefaults; //参数个数
    LPD3DXEFFECTDEFAULT pDefaults; //参数数组
} D3DXEFFECTINSTANCE, *LPD3DXEFFECTINSTANCE;

typedef struct _D3DXEFFECTDEFAULT
{ //EffectDefault，即EffectParam
    LPSTR pParamName;           //参数名
    D3DXEFFECTDEFAULTTYPE Type; //参数类型
    DWORD NumBytes;             //参数大小，以字节记
    LPVOID pValue;              //指向参数的值的指针
} D3DXEFFECTDEFAULT, *LPD3DXEFFECTDEFAULT;

需要注意的是，从文件中得到的参数类型只有以下几种：
typedef enum _D3DXEFFECTDEFAULTTYPE
{
    D3DXEDT_STRING = 1, //字符串
    D3DXEDT_FLOATS = 2, //浮点数组
    D3DXEDT_DWORD = 3, //长整型
    D3DXEDT_FORCE_DWORD = 0x7fffffff //此值不使用
} D3DXEFFECTDEFAULTTYPE;

在调用了D3DXLoadMeshFromX()和D3DXLoadMeshHierarchyFromX()之后，X文件中的所有Effect数据信息就以上述结构体的形式放置在ppEffectInstances中了。另外，在从3DS MAX导出参数到X文件时，对于整型和浮点数组型的变量，它们的值将直接导出到X文件中去；而对于所有的纹理贴图文件参数，导出的仅仅是该文件的文件名。所以在程序中需要再根据这些文件名来建立纹理对象。在《龙的传说》中，我们使用一个自定义的CEffectInstance类来处理将文件名转换为纹理对象的过程。一般来说，建立一个完整的CEffectInstance的过程如下：

根据D3DXEFFECTINSTANCE结构中的pEffectFilename字符串寻找对应的FX文件;
根据该FX文件建立ID3DXEffect，并将指针保存在CEffectInstance中;
根据D3DXEFFECTINSTANCE结构中的pDefaults设置CEffectInstance中的参数信息：

对于长整型和浮点数组，直接拷贝；
对于字符串，首先调用ID3DXEffect接口中的GetParameterByName()和GetParameterDesc()方法，得到该参数的类型；然后进一步判断：

如果确实是字符串参数，则直接拷贝
如果是纹理参数，则将该字符串作为纹理文件名建立纹理对象，并将指针保存在CEffectInstance中。

而在最新推出的DirectX 9 SDK Summer 2004中，通过ID3DXEffect::BeginParameterBlock()和ID3DXEffect::EndParameterBlock()方法，我们可以将Effect参数设置过程统一绑定到一个ParamBlock句柄上。这样，在调用ID3DXEffect::Begin()之前就可以直接使用ID3DXEffect::ApplyParameterBlock()方法来设置所有被绑定的参数值。例如：

[以前的做法]：

在读取参数时：获得每一个参数的句柄

hParam1 = pEffect->GetParameterByName( NULL, "LightPos" );
hParam2 = pEffect->GetParameterByName( NULL, "LightColor" );
...

在实时绘制时：分别设置每一个参数

pEffect->SetValue( hParam1, value1 );
pEffect->SetValue( hParam2, value2 );
...
pEffect->Begin();
// 绘制
...

[在DirectX 9 SDK Summer 2004中的做法]：

在读取参数时：绑定所有参数设置到同一句柄

hParam1 = pEffect->GetParameterByName( NULL, "LightPos" );
hParam2 = pEffect->GetParameterByName( NULL, "LightColor" );
...
pEffect->BeginParameterBlock(); // 开始绑定
pEffect->SetValue( hParam, value1 );
pEffect->SetValue( hParam, value2 );
...
hParamBlock = pEffect->EndParameterBlock(); // 结束绑定，返回句柄

在实时绘制时：统一设置绑定值

pEffect->ApplyParameterBlock( hParamBlock );
pEffect->Begin;
// 绘制
...

这样不仅简化了在读取时对参数的分析过程，而且提高了实际绘制时参数设置过程的效率。

总结

以上就是一些对于在DirectX 9.0中对Effect Framework的使用的简要介绍。总之，使用Effect来替代以前的标准材质是目前实时图形领域的发展趋势。通过Effect Framework，程序员和美工可以为实时三维程序实现多种多样的材质效果和视觉效果。由于内容实在太多，限于篇幅，本文只是对Effect Framework中相关概念的一个总体概括和简要介绍，所以显得有些晦涩。在以后的文章中，将分批对这个Framework以及在其之上进行工作的流程进行比较详细的介绍。

李锦俊(mybios) 2006-11-20 16:54 发表评论

【转贴】渲染状态管理

李锦俊(mybios) — Sat, 18 Nov 2006 14:34:00 GMT

　　提高3D图形程序的性能是个很大的课题。图形程序的优化大致可以分成两大任务，一是要有好的场景管理程序，能快速剔除不可见多边形，并根据对象距相机远近选择合适的细节（LOD）；二是要有好的渲染程序，能快速渲染送入渲染管线的可见多边形。
　　我们知道，使用OpenGL或Direct3D渲染图形时，首先要设置渲染状态，渲染状态用于控制渲染器的渲染行为。应用程序可以通过改变渲染状态来控制OpenGL或Direct3D的渲染行为。比如设置Vertex/Fragment Program、绑定纹理、打开深度测试、设置雾效等。
　　改变渲染状态对于显卡而言是比较耗时的操作，而如果能合理管理渲染状态，避免多余的状态切换，将明显提升图形程序性能。这篇文章将讨论渲染状态的管理。

文档目录：
　　基本思想
　　实际问题
　　渲染脚本

文档内容：

基本思想
　　我们考虑一个典型的游戏场景，包含人、动物、植物、建筑、交通工具、武器等。稍微分析一下就会发现，实际上场景里很多对象的渲染状态是一样的，比如所有的人和动物的渲染状态一般都一样，所有的植物渲染状态也一样，同样建筑、交通工具、武器也是如此。我们可以把具有相同的渲染状态的对象归为一组，然后分组渲染，对每组对象只需要在渲染前设置一次渲染状态，并且还可以保存当前的渲染状态，设置渲染状态时只需改变和当前状态不一样的状态。这样可以大大减少多余的状态切换。下面的代码段演示了这种方法：

// 渲染状态组链表，由场景管理程序填充
RenderStateGroupList groupList;
// 当前渲染状态
RenderState curState;

……

// 遍历链表中的每个组
RenderStateGroup *group = groupList.GetFirst();
while ( group != NULL )
{
   // 设置该组的渲染状态
   RenderState *state = group->GetRenderState();
   state->ApplyRenderState( curState );

   // 该渲染状态组的对象链表
   RenderableObjectList *objList = group->GetRenderableObjectList();
   // 遍历对象链表的每个对象
   RenderableObject *obj = objList->GetFirst();
   while ( obj != NULL )
   {
      // 渲染对象
      obj->Render();

      obj = objList->GetNext();
   }

   group = groupList.GetNext();
}

//其中RenderState类的ApplyRenderState方法形如：
void RenderState::ApplyRenderState( RenderState &curState )
{
   // 深度测试
   if ( depthTest != curState.depthTest )
   {
      SetDepthTest( depthTest );
      curState.depthTest = depthTest;
   }

   // Alpha测试
   if ( alphaTest != curState.alphaTest )
   {
      SetAlphaTest( alphaTest );
      curState.alphaTest = alphaTest;
   }

   // 其它渲染状态
   ……
}

　　这些分组的渲染状态一般被称为Material或Shader。这里Material不同于OpenGL和Direct3D里面用于光照的材质，Shader也不同于OpenGL里面的Vertex/Fragment Program和Direct3D里面的Vertex/Pixel Shader。而是指封装了的显卡渲染图形需要的状态（也包括了OpenGL和Direct3D原来的Material和Shader）。

　　从字面上看，Material（材质）更侧重于对象表面外观属性的描述，而Shader（这个词实在不好用中文表示）则有用程序控制对象表面外观的含义。由于显卡可编程管线的引入，渲染状态中包含了Vertex/Fragment Program，这些小程序可以控制物体的渲染，所以我觉得将封装的渲染状态称为Shader更合适。这篇文章也将称之为Shader。

　　上面的代码段只是简单的演示了渲染状态管理的基本思路，实际上渲染状态的管理需要考虑很多问题。
渲染状态管理的问题
　

　消耗时间问题
　　改变渲染状态时，不同的状态消耗的时间并不一样，甚至在不同条件下改变渲染状态消耗的时间也不一样。比如绑定纹理是一个很耗时的操作，而当纹理已经在显卡的纹理缓存中时，速度就会非常快。而且随着硬件和软件的发展，一些很耗时的渲染状态的消耗时间可能会有减少。因此并没有一个准确的消耗时间的数据。

　　虽然消耗时间无法量化，情况不同消耗的时间也不一样，但一般来说下面这些状态切换是比较消耗时间的：

Vertex/Fragment Program模式和固定管线模式的切换（FF，Fixed Function Pipeline）

Vertex/Fragment Program本身程序的切换

改变Vertex/Fragment Program常量

纹理切换

顶点和索引缓存（Vertex & Index Buffers）切换

　　有时需要根据消耗时间的多少来做折衷，下面将会遇到这种情况。

　渲染状态分类
　　实际场景中，往往会出现这样的情况，一类对象其它渲染状态都一样，只是纹理和顶点、索引数据不同。比如场景中的人，只是身材、长相、服装等不同，也就是说只有纹理、顶点、索引数据不同，而其它如Vertex/Fragment Program、深度测试等渲染状态都一样。相反，一般不会存在纹理和顶点、索引数据相同，而其他渲染状态不同的情况。我们可以把纹理、顶点、索引数据不归入到Shader中，这样场景中所有的人都可以用一个Shader来渲染，然后在这个Shader下对纹理进行分组排序，相同纹理的人放在一起渲染。
　多道渲染（Multipass Rendering）
　　有些比较复杂的图形效果，在低档显卡上需要渲染多次，每次渲染一种效果，然后用GL_BLEND合成为最终效果。这种方法叫多道渲染Multipass Rendering，渲染一次就是一个pass。比如做逐像素凹凸光照，需要计算环境光、漫射光凹凸效果、高光凹凸效果，在NV20显卡上只需要1个pass，而在NV10显卡上则需要3个pass。Shader应该支持多道渲染，即一个Shader应该分别包含每个pass的渲染状态。

不同的pass往往渲染状态和纹理都不同，而顶点、索引数据是一样的。这带来一个问题：是以对象为单位渲染，一次渲染一个对象的所有pass，然后渲染下一个对象；还是以pass为单位渲染，第一次渲染所有对象的第一个pass，第二次渲染所有对象的第二个pass。下面的程序段演示了这两种方式：

  以对象为单位渲染

// 渲染状态组链表，由场景管理程序填充
ShaderGroupList groupList;

……

// 遍历链表中的每个组
ShaderGroup *group = groupList.GetFirst();
while ( group != NULL )
{
   Shader *shader = group->GetShader();

   RenderableObjectList *objList = group->GetRenderableObjectList();

   // 遍历相同Shader的每个对象
   RenderableObject *obj = objList->GetFirst();
   while ( obj != NULL )
   {
      // 获取shader的pass数
      int iNumPasses = shader->GetPassNum();
      for ( int i = 0; i < iNumPasses; i++ )
{
// 设置shader第i个pass的渲染状态
shader->ApplyPass( i );
         // 渲染对象
         obj->Render();
      }

      obj = objList->GetNext();
   }

   group = groupList->GetNext();
}


以pass为单位渲染

// 渲染状态组链表，由场景管理程序填充
ShaderGroupList groupList;

……

for ( int i = 0; i < MAX_PASSES_NUM; i++ )
{
// 遍历链表中的每个组
ShaderGroup *group = groupList.GetFirst();
while ( group != NULL )
{
Shader *shader = group->GetShader();
      int iNumPasses = shader->GetPassNum();
      // 如果shader的pass数小于循环次数，跳过此shader
      if( i >= iNumPasses )
      {
         group = groupList->GetNext();
         continue;
      }

      // 设置shader第i个pass的渲染状态
      shader->ApplyPass( i );

      RenderableObjectList *objList =
         group->GetRenderableObjectList();

      // 遍历相同Shader的每个对象
      RenderableObject *obj = objList->GetFirst();
      while ( obj != NULL )
      {
         obj->Render();

         obj = objList->GetNext();
      }

      group = groupList->GetNext();
   }
}


　　这两种方式各有什么优缺点呢？

　　以对象为单位渲染，渲染一个对象的第一个pass后，马上紧接着渲染这个对象的第二个pass，而每个pass的顶点和索引数据是相同的，因此第一个pass将顶点和索引数据送入显卡后，显卡Cache中已经有了这个对象顶点和索引数据，后续pass不必重新将顶点和索引数据拷到显卡，因此速度会非常快。而问题是每个pass的渲染状态都不同，这使得实际上每次渲染都要设置新的渲染状态，会产生大量的多余渲染状态切换。

　　以pass为单位渲染则正好相反，以Shader分组，相同Shader的对象一起渲染，可以只在这组开始时设置一次渲染状态，相比以对象为单位，大大减少了渲染状态切换。可是每次渲染的对象不同，因此每次都要将对象的顶点和索引数据拷贝到显卡，会消耗不少时间。
　　可见想减少渲染状态切换就要频繁拷贝顶点索引数据，而想减少拷贝顶点索引数据又不得不增加渲染状态切换。鱼与熊掌不可兼得 :-(
　　由于硬件条件和场景数据的情况比较复杂，具体哪种方法效率较高并没有定式，两种方法都有人使用，具体选用那种方法需要在实际环境测试后才能知道。

　多光源问题
待续……

　阴影问题
待续……

　

渲染脚本
　　现在很多图形程序都会自己定义一种脚本文件来描述Shader。

　　比如较早的OGRE（Object-oriented Graphics Rendering Engine，面向对象图形渲染引擎）的Material脚本，Quake3的Shader脚本，以及刚问世不久的Direct3D的Effect File，nVIDIA的CgFX脚本（文件格式与Direct3D Effect File兼容），ATI RenderMonkey使用的xml格式的脚本。OGRE Material和Quake3 Shader这两种脚本比较有历史了，不支持可编程渲染管线。而后面三种比较新的脚本都支持可编程渲染管线。

脚本  特性  范例
OGRE Material 封装各种渲染状态，不支持可编程渲染管线  >>>>
Quake3 Shader 封装渲染状态，支持一些特效，不支持可编程渲染管线  >>>>
Direct3D Effect File 封装渲染状态，支持multipass，支持可编程渲染管线  >>>>
nVIDIA CgFX脚本封装渲染状态，支持multipass，支持可编程渲染管线  >>>>
ATI RenderMonkey脚本封装渲染状态，支持multipass，支持可编程渲染管线  >>>>

　　使用脚本来控制渲染有很多好处：

可以非常方便的修改一个物体的外观而不需重新编写或编译程序

可以用外围工具以所见即所得的方式来创建、修改脚本文件（类似ATI RenderMonkey的工作方式），便于美工、关卡设计人员设定对象外观，建立外围工具与图形引擎的联系

可以在渲染时将相同外观属性及渲染状态的对象（也就是Shader相同的对象）归为一组，然后分组渲染，对每组对象只需要在渲染前设置一次渲染状态，大大减少了多余的状态切换

李锦俊(mybios) 2006-11-18 22:34 发表评论

【转贴】谈论 Direct3D10特性预览

李锦俊(mybios) — Sat, 18 Nov 2006 01:14:00 GMT

引用

Direct3D10特性预览
将我在GameResBlog的老文章重新贴回来，发现写的还是很有味道，嘿嘿～～

刚拿到DirectX Dec2005 SDK，发现竟然有D3D10的文档和例子，速研究了一下，以下只是个人的读书笔记，仅作参考
1.去掉了固定管线
文档里列出了用DX10特性模拟的一些固定管线的操作，MS那么大度把DX都开源了(^O^)。
2.去掉了以前版本DX的设备能力检查(CAPS)
为DX10和Windows Vista提供的显示硬件必须满足DX10的所有硬件特性。这样对于开发者就比较可以放心的使用各种硬件特性了，很类似Console平台
的开发。
3.状态对象(State Object)
"从100多个渲染状态中解脱出来吧!"
D3D10对渲染状态这个概念进行淡化，一方面使用全Shader化的架构使得状态的前后设置和互相影响对渲染成功率降低到最少
另外对API架构也更为简洁，另一方面对一些关键渲染状态进行封装和分类。主要分类有:

Input Layout Object 输入层对象
这个东西很类似D3D9里的顶点声明，也就是对用户输入数据进行整合和系统化

Rasterizer Object 光栅化对象
这部分主要控制光栅器的行为：填充模式(FILL_MODE),剔除模式(CULL_MODE),多采样,DepthBias等等

DepthStencil Object 深度缓冲对象
主要控制深度缓冲的行为，像Z-buffer Enable之类的

Blend Object 混合对象
设置象素混合的方法，类似AlphaBlend SrcAlpha ,DestAlpha等等

Sampler Object 采样器对象
设置纹理采样状态，包括过滤器和MipMap

4.新的资源访问模式和资源视图(View)概念
如果对比D3D9的Shader使用代码和D3D10的类似代码会发现一个不同。
D3D9 Shader需要对纹理进行操作时，需要将纹理设置到Shader就可以了，而D3D10里没有那么简单，设置前必须将
各种资源整合后为资源创建一个视图，再提交给Shader访问。这种操作在环境贴图里是很有好处的。对于CubeMap的6张纹理
就可以采用一个视图设置到设备，而自己要访问每张贴图只要轻松访问视图就可以了，也就是说把资源规整和集成化。
5.新的可编程图形层(Stage)-几何Shader(Geometry Shader)
原来的VS和PS只是对逐个顶点或象素进行处理，而新的GS可以对每个顶点或象素的临近顶点设置Shader。也就是可以对批量几何进行处理
GS的用途有:
点精灵
动态粒子系统
皮毛系统
卷积阴影
单Pass渲染到球形贴图
逐多边形材质交换
逐多边形材质设置

6.设备的创建要求对ViewPort进行设置
D3D9里无需对ViewPort进行设置就可以进行渲染，而且默认的RenderTarget就是后备缓冲
而在D3D10里，这个过程变得更为自主化。取出后备缓冲的格式，将RenderTarget设置为屏幕
这让人感到D3D10设计更趋向于成熟的引擎设计。
7.流输出层(Stream Output State)
这个层的功能是将VS和GS处理完成的数据输出给用户，由用户进行处理后再反馈给管线继续处理

8.多边形拓扑结构从绘制代码分离
现在可以单独设置拓扑结构
g_pd3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
和使用Draw函数绘制了，很类似OpenGL

9.严格的设备对象创建时间验证
这里的设备对象就是从设备创建出来的资源。为了减少CPU占用，D3D10重新设计了硬件资源调用调度，所有的设备对象都用面向对象的方法被设备
管理。这种设计方法避免了在渲染期的资源创建操作。

10.去掉BeginScene和EndScene
这个对于图形API确实多余

Dec2005 sdk里提供的文档让人很快想到这只是一个过渡版本
在DXUT的Mesh.Create函数中可以看到一个很有趣的现象：
创建D3D9对象，使用D3DX9里的载入X模型文件的函数载入X文件
将D3D9的模型数据转成D3D10的类型。这样做无非是在告诉我们一个
这样的信息，D3D10很有可能提供一种新的模型格式来作为研究使用
。Vista的图形系统Avalon从一些视频上分析，使用了大量的XML，所以
新的模型格式很有可能使用XML，并且X格式的解析接口确实不方便。而
XML的分析器可以由第三方提供。使得更多的研究人员能更方便的使用
这种新格式。
顺便提供一些缩写对应的含义,这些在一些函数前缀会出现
IA-Input Assembler State
SO-Stream Output State
OM-Output Merger State
VS-Vertex Shader
PS-Pixel Shader
GS-Geometry Shader
Powered by Davy.xu
msn:sunicdavy@sina.com

李锦俊(mybios) 2006-11-18 09:14 发表评论

【转贴】DXUT 框架函数介绍

李锦俊(mybios) — Sat, 18 Nov 2006 01:08:00 GMT

引用

DirectX SDK 2006学习笔记1——框架

友情提醒：所谓的框架是指SDK目录下\Samples\C++\Common路径下的DXUT系列函数包装。学习框架的前提是必须有足够的Windows API，GUI编程经验，必须熟悉Windows的消息机制，回调机制，最好有万行左右的C/C++编程经验。MFC在这里没有任何用处。另外我觉得最好在看程序之前对于D3D的所有概念有点了解，什么是vertex，texture，matrix，lighting，mesh等等，以及相关的数学概念。这些都可以在网上找到中文翻译，帮助你快速入门。

　　DXSDK2006和2003版的比起来更新了不少东西，比如DirectX10，还有Managed

DirectX等等。不过我关心的还是D3D9。除了个别接口的更改之外，DXSDK2006还提供了一套图形控件的类库，它的界面还是很漂亮的：）如图：

　　学习一个框架还是从它的入口学习比较方便，否则容易迷失在无穷无尽的API和层层包装之中。DXSDK2006的框架和2003版的DX9.0c框架有很大的不同。首先是2003版的框架中提供了一个CD3DApplication类，这个类对于初始化，清除，以及游戏窗口的创建，游戏主循环进行了包装。这是一个不错的类，不知道为什么在2006版中去掉了。不过不要紧，2006版的框架中提供的一些C包装函数已经足够了。在看这些函数之前，我们还是先来看看SDK目录下\Samples\C++ \Direct3D\Tutorials中有些什么吧。Tut01_CreateDevice是创建框架，这个程序不用框架，研究一下有助于了解D3D的大致工作流程。下面是winmain函数中的一部分。

// Initialize Direct3D

if( SUCCEEDED( InitD3D( hWnd ) ) )

{

// Show the window

ShowWindow( hWnd, SW_SHOWDEFAULT );

UpdateWindow( hWnd );

// Enter the message loop

MSGmsg;

while( GetMessage( &msg, NULL, 0, 0 ) )

{

TranslateMessage( &msg );

DispatchMessage( &msg );

}

　　在消息循环之前有个初始化设备的函数InitD3D( hWnd )，其代码如下：

HRESULTInitD3D( HWNDhWnd )

{

if( NULL == ( g_pD3D = Direct3DCreate9( D3D_SDK_VERSION ) ) )

returnE_FAIL;

D3DPRESENT_PARAMETERSd3dpp;

ZeroMemory( &d3dpp, sizeof(d3dpp) );

d3dpp.Windowed = TRUE;

d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;

d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT,

D3DDEVTYPE_HAL,hWnd,

D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp,

&g_pd3dDevice ) ) )

{

returnE_FAIL;

}

returnS_OK;

}

主要是调用Direct3DCreate9和g_pD3D->CreateDevice这两个函数。查看DXSDK文档中关于D3DPRESENT_PARAMETERS的定义，大致了解一下。

接下来要关心的就是消息循环了，在回调函数MsgProc中处理了两个消息，一个是WM_DESTROY，里面调用了Cleanup函数，另一个是WM_PAINT函数，里面调用了Render函数。Cleanup函数很简单，就是调用D3D对象及其设备对象的Release函数释放资源，而Render函数就是D3D中最重要的函数了。

VOIDRender()

{

if( NULL==g_pd3dDevice)

return;

// Clear the backbuffer to a blue color

g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );

// Begin the scene

if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )

{

// Rendering of scene objects can happen here

// End the scene

g_pd3dDevice->EndScene();

}

// Present the backbuffer contents to the display

g_pd3dDevice->Present( NULL, NULL, NULL, NULL);

}

　　主要调用的函数有BeginScene, EndScene和Present函数。

对D3D应用程序有了大概了解之后就可以看空框架程序了。这个程序可以在Samples\C++\Direct3D\EmptyProject中找到。

　　从WinMain中的调用可以看到，框架首先设定一堆回调函数，很多事情的是在用户自己写的回调函数中实现。从DXUTInit开始，程序开始调用框架内的API来完成初始化——创建窗口——创建设备——主消息循环——退出等一系列操作。调查Common目录下DXUT.cpp文件就可以发现DXUTInit函数干了以下几件事情

① 设定开始调用这个函数的标志符

② InitCommonControls

③ 保存当前的sticky/toggle/filter键

④ 通过事先导入winmm.dll的方法timeBeginPeriod来确保调用Sleep的准确性

⑤ 设定一些标志附，读取命令行参数

⑥ 检查版本

⑦ 获得D3D对象指针。值得一提的是框架中大部分全局变量是通过类DXUTState的静态变量state的get/set方法得到的。这些get/set方法是用宏定义的，里面调用了加锁和解锁，因此保证了全局变量设定的线程安全。这些全局性的变量包括D3D对象指针，D3D设备对象指针，BackBufferSurfaceDesc，DeviceCaps，窗口HINSTANCE，窗口句柄HWND，焦点句柄HWNDFocus，全屏设备句柄，窗口设备句柄，窗口客户端矩形，模式切换时窗口客户端矩形，模式切换时全屏客户端矩形，Time，ElapsedTime，FPS数，窗口标题，设备数据DeviceStats，以及是否暂停渲染，时间是否暂停，窗口是否激活等标志，一些窗口事件等等。这些都可以通过DXUTGETXXX/DXUTSETXXX/DXUTISXXX系列包装函数获得。

⑧ 通过DXUT_Dynamic_Direct3DCreate9创建D3D对象。很多D3D底层API都是通过动态的方式加载的，这样有利于效率的提高。

⑨ 重设全局时钟

⑩ 设定DXUTInited为true。很多DXUT系列的函数都喜欢在入口设定一个开始调这个函数的标志，在出口设定一个这个函数已经被调过的标志，这样可以在以后再次调用这个函数的时候了解当前什么工作已经做了，什么工作没做需要补做。我想这个主要是用来防止函数重入问题的吧。其他函数中的这一对函数就不再提了

　　呼~第一个函数大致看完了，接下来是DXUTCreateWindow函数。什么？要问DXUTSetCursorSettings为什么被无视？因为这个函数不重要。DXUTCreateWindow的工作大致是这样的

① 判断关于设备的CallBack有没有设定好

② 判断DXUTInit()有没有被调用成功（注意不是有没有调用）。

③ 获得焦点句柄，因为窗口还没有创建，所以这个句柄应该是NULL

④ 设定HInstance

⑤ 设定窗口类

⑥ 注册窗口类

⑦ 设定窗口位置和大小。好长一段代码，汗

⑧ 创建窗口。终于。。。

⑨ 设定窗口焦点句柄，全屏设备句柄，窗口设备句柄

　　接下来的函数是DXUTCreateDevice。这个函数就是用来选择最优设备并创建的。

① 设定参数中的回调函数和上下文，以备后用

② 检查窗口是否被成功创建，否则再调用一次DXUTCreateWindow

③ 枚举所有可能的显示模式。枚举过程非常复杂，用到了CD3DEnumeration中的一些包装函数，这些设备信息包括分辨率，颜色位深等等。这里会用到DXUTCreateDevice传进来的参数IsDeviceAcceptable

④ 如果命令行设定过显示模式，那么将刚才得到的信息覆盖。

⑤ 采用某种权重的算法找出最优显示模式（DXUTFindValidDeviceSettings）

⑥ 切换设备。这里用到了DXUTCreateDevice传进来的参数ModifyDeviceSettings。切换设备时要考虑很多问题：比如需要暂时忽略WM_SIZE消息；只有在第一次创建设备的时候才用命令行参数；按照需要调用DXUTCreate3DEnvironment和DXUTReset3DEnvironment；分全屏和窗口设备重设；重设完了根据需要处理WM_SIZE消息；显示窗口，允许WM_SIZE消息等等

　　最后是DXUTMainLoop。

① 检查是否有重入问题

② 设定进入主循环标志

③ 检查设备是否已经被成功创建，没创建的话用默认参数创建一次

④ 检查前面三个函数是否成功调用。汗，又是检查

⑤ 处理窗口消息，注意只有在没有消息处理的时候才调用DXUTRender3DEnvironment()

⑥ 在消息循环退出之后清除加速表。应该是类似SHIFT+X这种键盘加速表的清除吧

⑦ 更改主循环标志

　　还是有必要看一下主消息循环中的DXUTRender3DEnvironment

① 检查设备是否丢失

② 在窗口模式下检查桌面分辨率位深设定，以便重设设备

③ 尝试重设设备DXUTReset3DEnvironment

④ 判断上次渲染到现在时间(elapsed time)决定是否要进行渲染

⑤ 调用用户的FrameMove函数

⑥ 调用用户的FrameRender函数

⑦ 调用Present函数

⑧ 更新当前Frame

⑨ 根据命令行检查是否需要关闭应用程序

　　主函数看完之后，剩下的就是一些回调函数了。要正确使用这些回调函数，除了知道它们的作用之外，还需要知道这些函数是何时被调用的。下面是调用顺序

程序启动：InitApp →MsgProc →IsDeviceAcceptable →ModifyDeviceSettings → OnCreateDevice →OnResetDevice → 渲染主循环
渲染主循环：OnFrameMove → OnFrameRender
改变设备：ModifyDeviceSettings → OnLostDevice →根据需要调用OnDestroyDevice → OnResetDevice → 渲染主循环
程序退出：OnLostDevice →OnDestroyDevice

　　下面是各函数的作用：

InitApp	初始化一些图形控件和GUI的消息处理函数
OnCreateDevice	创建设备时的回调函数，用于创建D3DPOOL_MANAGED资源
OnResetDevice	重设设备时的回调函数，用于创建D3DPOOL_DEFAULT资源
OnFrameMove	动画实现处，常用于矩阵转换等操作
OnFrameRender	渲染实现处，常用于渲染场景
OnLostDevice	设备丢失时的回调函数，释放由OnResetDevice创建的资源
OnDestroyDevice	设备析构时的回调函数，释放由OnCreateDevice创建的资源
IsDeviceAcceptable	创建设备时用来对所有可用设备进行过滤的函数
ModifyDeviceSettings	更改设备时的回调函数，用于实现更改设备时所需做的其他操作
MsgProc	安排各空件处理消息的顺序
OnGUIEvent	程序控件绑定的消息处理回调函数

　　以上函数均可以更换名字，这里只是用框架默认的函数名字。

李锦俊(mybios) 2006-11-18 09:08 发表评论

【转贴】DXUT 框架入门 2

李锦俊(mybios) — Sat, 18 Nov 2006 01:02:00 GMT

摘要: 这章主要介绍一下DXUT 里面的GUI元素。要在图形界面中添加GUI元素，首先要定义一个DialogResourceManager对象用来管理对话框资源。DialogResourceManager 管理渲染时状态、Sprite控制批量显示更新、对话框字体、纹理等等。CDXUTDialog 相当于MFC里面的对话框，作为各种控件资源的容器。CD3DSettingsDlg 是一个ms已经写好的对话框类... 阅读全文

李锦俊(mybios) 2006-11-18 09:02 发表评论

【转贴】DXUT 框架入门 1

李锦俊(mybios) — Sat, 18 Nov 2006 01:01:00 GMT

CD3DApplication 框架类已经光荣的退役了，取而代之的是DXUT*系列函数。在这篇文章中将要简单介绍DXUT框架的应用。

最近的directx 下载地址，这里面包含了64位操作系统库以及directx10等等，directx10 的程序例子只能运行在windows vista 上面。尽管可以编译，但缺少directx3d10 运行库. 在安装sdk之后，别忘记安装Redist目录中最新的directx运行库。

在vc.net->tools->options中配置头文件以及库文件地址。

使用dxut框架进行directx设计时，拷贝directx sdk 安装目录\Samples\C++\中的Common文件内容到你的程序目录下(如下图)。

创建一个名为dxut 的windows apllication 空工程,然后在vc solution explorer 中项目下加入common目录(添加存在文件，注意dxsound两个文件没有加入)，然后添加一个源文件main.cpp

然后在vc solution explorer 中项目上点右键进入项目属性页(property pages)加入附加的common目录作为附加头文件搜索目录,同样在属性页的 linker->input->addtional dependencies 中加入 dxerr.lib dxguid.lib d3dx9.lib d3d9.lib winmm.lib comctl32.lib 等链接库

main.cpp 源文件内容如下：

#include < dxstdafx.h >
// --------------------------------------------------------------------------------------
// 当Directx3D设备被创建后，这个回调函数马上被调用，因为D3DPOOL_MANAGED资源在设备被销毁后
// 需要重新装载,这里是最佳创建D3DPOOL_MANAGED资源的地方，创建的资源应在 OnDestroyDevice
// 函数中销毁。
// --------------------------------------------------------------------------------------
HRESULT CALLBACK OnCreateDevice( IDirect3DDevice9 * pd3dDevice, const D3DSURFACE_DESC * pBackBufferSurfaceDesc, void * pUserContext )
{
return S_OK;
}
// --------------------------------------------------------------------------------------
// 当direct3d设备被复位后，这个函数立即被调用，这里最好放置D3DPOOL_DEFAULT 资源代码，因为这
// 这些资源在设备丢失后需要重新装载。在这里创建的资源应该在OnLostDevice 函数中释放
// --------------------------------------------------------------------------------------
HRESULT CALLBACK OnResetDevice( IDirect3DDevice9 * pd3dDevice, const D3DSURFACE_DESC * pBackBufferSurfaceDesc, void * pUserContext )
{
return S_OK;
}
// --------------------------------------------------------------------------------------
// 在Direct3D设备进入lost状态后在IDirect3DDevice9::Reset 调用之前调用此函数，在OnResetDevice
// 中创建的资源必须在这里释放，通常包括所有的D3DPOOL_DEFAULT 资源，
// --------------------------------------------------------------------------------------
void CALLBACK OnLostDevice( void * pUserContext )
{

}
// --------------------------------------------------------------------------------------
// 这个回调函数在每帧的开始被调用，这个在你的程序中用来处理场景更新最好的位置，但不能包含实际的
// 场景渲染调用，渲染工作应该放在OnFrameRender 回调函数中。常用于矩阵转换、摄像机等操作。
// --------------------------------------------------------------------------------------
void CALLBACK OnFrameMove( IDirect3DDevice9 * pd3dDevice, double fTime, float fElapsedTime, void * pUserContext )
{
}
// --------------------------------------------------------------------------------------
// 此回调函数在每Frame最后被调用，在场景上执行所有的渲染调用，当窗口需要重绘（处理WM_PAINT消
// 息）时此函数也会被调用（此时不调用OnFrameMove），在此函数返回后，DXUT将调用
// IDirect3DDevice9::Present 来显示翻转链中下一个缓冲区内容。
// --------------------------------------------------------------------------------------
void CALLBACK OnFrameRender( IDirect3DDevice9 * pd3dDevice, double fTime, float fElapsedTime, void * pUserContext )
{
HRESULT hr;
V( pd3dDevice -> Clear( 0 , NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB( 0 , 0 , 0 , 0 ), 1.0f , 0 ) );
if (SUCCEEDED(pd3dDevice -> BeginScene()))
{
// 更新图像
pd3dDevice -> EndScene();
}
}
// --------------------------------------------------------------------------------------
// 此回调函数在direct3d设备被销毁时调用，通常发生在程序终止，在OnCreateDevice 中创建的资源，要
// 在这里释放，通常包含所有的D3DPOOL_MANAGED资源
// IDirect3DDevice9::Present 来显示翻转链中下一个缓冲区内容。
// --------------------------------------------------------------------------------------
void CALLBACK OnDestroyDevice( void * pUserContext )
{

}
INT WINAPI WinMain( HINSTANCE, HINSTANCE, LPSTR, int )
{
// 设置回调函数，这些函数允许DXUT通知应用程序更换设备，用户输入和窗口消息。
// 回调函数是可选的，因此你要做的仅是设置你感兴趣的事件的回调函数。
DXUTSetCallbackDeviceCreated( OnCreateDevice );
DXUTSetCallbackDeviceReset( OnResetDevice );
DXUTSetCallbackDeviceLost( OnLostDevice );
DXUTSetCallbackDeviceDestroyed( OnDestroyDevice );
DXUTSetCallbackFrameRender( OnFrameRender );
DXUTSetCallbackFrameMove( OnFrameMove );

// 初始化DXUT并创建想要的Win32窗口和应用程序的Direct3D设备。调用这些
// 可选函数中的每一个，此外它们允许你设置几个选项来控制框架的行为。
DXUTInit( TRUE, TRUE, TRUE );
// directx 编码是unicode环境，所以字符串之前要加 L 。
DXUTCreateWindow( L " Welcome to topameng.spaces.live.com " );
DXUTCreateDevice( D3DADAPTER_DEFAULT, TRUE, 640 , 480 );
// 通过DXUT来处理消息循环并分派渲染调用。当在空闲时间和处理窗口消息的
// 时间间隔时，框架将调用OnFrameMove和OnFrameRender回调函数。
DXUTMainLoop();
return DXUTGetExitCode();
}

direct3d Memory Pools（内存池）
表面和其它一些D3D资源被放在多种内存池中。内存池的种类由D3DPOOL枚举类型的一个成员来指定。它可以为下列几种：
1．D3DPOOL_DEFAULT——表示D3D将根据资源的类型和用途把它们放在最合适的地方。这有可能是显存、AGP内存或者系统内存中。值得注意的是，这种内存池中的资源必须要在IDirect3DDevice9::Reset被调用之前消毁掉，然后必须重新初始化。
2．D3DPOOL_MANAGED——资源将由D3D管理并且按设备的需要来指定放在显存还是放在AGP内存中，同时备份这些资源到系统内存中。当应用程序访问和改变资源，也会对系统内存造成影响。
3．D3DPOOL_SYSTEMMEM——指定资源放在系统内存中。
4．D3DPOOL_SCRATCH——规定资源放在系统内存中，它与D3DPOOL_SYSTEMMEM不同之处在于使用这个参数使图形设备不能访问本内存池的资源，但资源可以被复制出去。

也可以打开direct sdk 安装目录Samples\C++\Direct3D\EmptyProject 例子，基本和上面是相同的

李锦俊(mybios) 2006-11-18 09:01 发表评论

【原创翻译】开启Direct3D调试模式！

李锦俊(mybios) — Fri, 17 Nov 2006 07:14:00 GMT

声明：此文章翻译自DirectX 9.0C OCT 2006 SDK的Direct3D For C++帮助文档的Enabling Direct3D Debug Information主题，前面部分有些没有翻译的。

在#include 语句前面加上以下这条语句即可：

#define D3D_DEBUG_INFO

关闭调试时查看D3D Device对象的情况

开启调试时查看D3D对象的情况

为外部调试使用调用堆栈

当 Direct3D 调试模式开启之后，你可以在任何时候查看对象的调用堆栈。这会导致你的程序非常慢，但是可以使用此功能检查资源泄漏（内存泄漏的一种）。开启调用堆栈，设置这个注册表键值为1即可：

\\HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Direct3D\\
D3D9Debugging\\EnableCreationStack

开启D3D调试模式，然后重建你的工程，系统将会给你访问这个附加的变量：
LPCWSTR CreationCallStack;

这个变量存储着每次创建对象时的调用堆栈。这会导致你的程序非常慢，但是可以使用此功能检查资源泄漏。

李锦俊(mybios) 2006-11-17 15:14 发表评论

【原创】把D3D画面渲染到桌面！不用创建任何窗口

李锦俊(mybios) — Fri, 17 Nov 2006 06:54:00 GMT

其实这个很简单，只是创建设备的时候那个hwnd有点不一样！
可能有人就会说，用GetDesktopWindows()获得桌面的句柄不就行了？那就错了！这样会没有效果的！正确的代码如下：

    HWND hWnd = FindWindowEx(GetDesktopWindow() , 0 , " Progman " , " Program Manager " );
    hWnd = FindWindowEx(hWnd , 0 , " SHELLDLL_DefView " , 0 );
    hWnd = FindWindowEx(hWnd , 0 , " SysListView32 " , " FolderView " );
     // 初始化 D3D 设备
    InitD3D(hWnd);

是不是很简单！哈哈。

显示的时候，如果想渲染在桌面的一角，则可以这样写：

// 显示在左上角，128×128宽
        RECT rect;
        rect.left = 0;
        rect.right = 128;
        rect.top = 0;
        rect.bottom = 128;
        // 显示
        g_pd3dDevice->Present(0 , &rect , 0 , 0);

李锦俊(mybios) 2006-11-17 14:54 发表评论

【原创】今天参照转贴的渲染到纹理做了一个例子，效果还不错，哈哈

李锦俊(mybios) — Fri, 17 Nov 2006 01:18:00 GMT

摘要:

代码里面写了详尽的注释！点击这里下载工程（使用VS2003 ＋ OCT 2006 DirectSDK 编译）
请看考这里【转贴】Render to Texture（渲染到纹理）

阅读全文

李锦俊(mybios) 2006-11-17 09:18 发表评论

【转贴】Render to Texture（渲染到纹理）

李锦俊(mybios) — Thu, 16 Nov 2006 15:58:00 GMT

·内容
　　渲染到纹理是D3D中的一项高级技术。一方面，它很简单，另一方面它很强大并能产生很多特殊效果。比如说发光效果，环境映射，阴影映射，都可以通过它来实现。渲染到纹理只是渲染到表面的一个延伸。我们只需再加些东西就可以了。首先，我们要创造一个纹理，并且做好一些防范措施。第二步我们就可以把适当的场景渲染到我们创建的纹理上了。然后，我们把这个纹理用在最后的渲染上。

·main.cpp
　　首先我们得声明所需要的对象。当然我们需要一张用来渲染的纹理。此外，我们还需要两个Surface对象。一个是用来存储后台缓冲区，一个用来当纹理的渲染对象。后面我再详细介绍它们。另外我们还需要两个矩阵，一个是用来当纹理的投影矩阵，另一个是存储原来的矩阵。

LPDIRECT3DTEXTURE9 pRenderTexture = NULL;
LPDIRECT3DSURFACE9 pRenderSurface = NULL,pBackBuffer = NULL;
D3DXMATRIX matProjection,matOldProjection;

　　现在我们来创建纹理。前两个参数是纹理的宽度和高度，第三个参数是纹理的多级渐进纹理序列参数，在这里是设为1，第四个参数非常重要而且必须设为D3DUSAGE_RENDERTARGET，表明我们所创建的纹理是用来渲染的。剩下的参数就是指纹理格式，顶点缓冲区的内存位置，和一个指向纹理的指针。当纹理是用来当渲染对象时，顶点缓冲区的内存位置必须设为D3D_DEFAILT。

g_App.GetDevice()->CreateTexture(256,256,1,D3DUSAGE_RENDERTARGET,D3DFMT_R5G6B5,D3DPOOL_DEFAULT,&pRenderTexture,NULL);

　　为了访问纹理内存对象，我们需要一个Surface对象，因为D3D中的纹理是用这样的一个Surface来存储纹理数据的。为了得到纹理表面的Surface,我们需要调用方法GetSurfaceLevel() 。第一个参数我们设为0，第二个参数为一个指向surface对象的指针。

pRenderTexture->GetSurfaceLevel(0,&pRenderSurface);

下一步就是创建一个适合纹理维数的投影矩阵，因为纹理的横纵比和后台缓冲区的不一样。

D3DXMatrixPerspectiveFovLH(&matProjection,D3DX_PI / 4.0f,1,1,100);

在我们的循环渲染之前，我们必须保存后台缓冲区和它的投影矩阵。

g_App.GetDevice()->GetTransform(D3DTS_PROJECTION,&matOldProjection);
g_App.GetDevice()->GetRenderTarget(0,&pBackBuffer);

　　渲染循环函数可以分为两个部分。第一部分是渲染到纹理的过程。因此，渲染对象必须设为纹理表面。然后我们就可以把东西渲染到这个对象上了。渲染到另一个表面上和正常地渲染到后台缓冲区差不多。只有一点不同，那就是先不调用Prensent（）函数，因为纹理上的内容并不需要显示在屏幕上。象平时一样，我们先要重置表面颜色缓冲区，并且调用BeginSence()和EndSence()方法。为了能够适当的渲染，我们必须设置和纹理表面相符的投影矩阵。否则最后的图象可能被扭曲

//render-to-texture
g_App.GetDevice()->SetRenderTarget(0,pRenderSurface); //set new render target
g_App.GetDevice()->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(100,100,100),1.0f,0); //clear texture
g_App.GetDevice()->BeginScene();

g_App.GetDevice()->SetTexture(0,pPyramideTexture);

D3DXMatrixRotationY(&matRotationY,fRotation);
D3DXMatrixTranslation(&matTranslation,0.0f,0.0f,5.0f);
g_App.GetDevice()->SetTransform(D3DTS_WORLD,&(matRotationY * matTranslation));
g_App.GetDevice()->SetTransform(D3DTS_PROJECTION,&matProjection); //set projection matrix

g_App.GetDevice()->SetStreamSource(0,pTriangleVB,0,sizeof(D3DVERTEX));
g_App.GetDevice()->DrawPrimitive(D3DPT_TRIANGLELIST,0,4);

g_App.GetDevice()->EndScene();

　　渲染循环的第二部分就是渲染最后场景的过程（也就是显示到屏幕上的过程）。渲染对象重新设为后台缓冲区，投影矩阵重新设为原来的投影矩阵。由于纹理已经准备好了，所以它和纹理层0相关联。

//render scene with texture
g_App.GetDevice()->SetRenderTarget(0,pBackBuffer); //set back buffer
g_App.GetDevice()->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(0,0,0),1.0f,0);
g_App.GetDevice()->BeginScene();

g_App.GetDevice()->SetTexture(0,pRenderTexture); //set rendered texture

g_App.GetDevice()->SetTransform(D3DTS_WORLD,&matTranslation);
g_App.GetDevice()->SetTransform(D3DTS_PROJECTION,&matOldProjection); //restore projection matrix

g_App.GetDevice()->SetStreamSource(0,pQuadVB,0,sizeof(D3DVERTEX));
g_App.GetDevice()->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);

g_App.GetDevice()->EndScene();
g_App.GetDevice()->Present(NULL,NULL,NULL,NULL);

最后我们通过调用Release()方法释放Surface对象。

pRenderSurface->Release();
pRenderSurface = NULL;

pBackBuffer->Release();
pBackBuffer = NULL;

　　渲染到纹理能让你做很多事情，但是你必须注意一些限制。首先深度缓冲区必须总是大于或等于渲染对象的大小。此外，渲染对象和深度缓冲区的格式必须一致。

李锦俊(mybios) 2006-11-16 23:58 发表评论

【转贴】Shader Model 3 Using Vertex Texture 顶点纹理白皮书中文版

李锦俊(mybios) — Thu, 16 Nov 2006 15:57:00 GMT

摘要: Shader Model 3 Using Vertex Texture 顶点纹理白皮书中文版 ... 阅读全文

李锦俊(mybios) 2006-11-16 23:57 发表评论

【转贴】那是什么鬼东西? Pick!!就是物件拾取！

李锦俊(mybios) — Thu, 16 Nov 2006 11:57:00 GMT

摘要: 第九集那是什么鬼东西想起第一次面对StarCraft的主界面, 看到旋转的星球, 晃着脑袋的卫星, … , 那是什么? 想知道, 简单, 把鼠标移上去, 它会告诉你的Who am I. ... 阅读全文

李锦俊(mybios) 2006-11-16 19:57 发表评论

【转贴】泛型粒子系统的设计

李锦俊(mybios) — Thu, 16 Nov 2006 11:53:00 GMT

摘要: 摘要：本文阐述了如何利用 C++ 的 Template 开发出方便组装，适合各种应用的　　泛型粒子系统，开发过程中使用到了 Boost.Mpl 和 Boost.Random 。 ... 阅读全文

李锦俊(mybios) 2006-11-16 19:53 发表评论

【转贴】多重纹理的应用

李锦俊(mybios) — Thu, 16 Nov 2006 08:33:00 GMT

摘要: 多重纹理的混合会产生很多漂亮的效果, 这里我们来实现其中最基础的几种效果, dark & light mapping, detail mapping, glow mapping. 无奈于硬件(TNT2 32M 显卡)和模型的不足, 这集的例子只能为game7中... 阅读全文

李锦俊(mybios) 2006-11-16 16:33 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 06 纹理贴图以及纹理坐标变换（纹理动画）

李锦俊(mybios) — Thu, 16 Nov 2006 03:15:00 GMT

摘要: 1 #include < D3DX9.h > 2 #include < string > 3 typedef std:: ... 阅读全文

李锦俊(mybios) 2006-11-16 11:15 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 05 光照系统

李锦俊(mybios) — Thu, 16 Nov 2006 03:09:00 GMT

摘要: 1 #include < D3DX9.h > 2 #include < string > 3 typedef std:: ... 阅读全文

李锦俊(mybios) 2006-11-16 11:09 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 04 矩阵变换

李锦俊(mybios) — Thu, 16 Nov 2006 03:03:00 GMT

摘要: 1 #include < D3DX9.h > 2 #include < string > 3 typedef std:: ... 阅读全文

李锦俊(mybios) 2006-11-16 11:03 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 03 使用索引缓冲区

李锦俊(mybios) — Thu, 16 Nov 2006 02:59:00 GMT

摘要: 渲染之前记得g_pd3dDevice->SetIndices(g_pIB);而且要用g_pd3dDevice->DrawIndexedPrimitive来渲染索引缓冲区 1 #include < D3DX9.h > 2 ... 阅读全文

李锦俊(mybios) 2006-11-16 10:59 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 02 创建顶点缓冲区容易犯错的地方

李锦俊(mybios) — Thu, 16 Nov 2006 02:47:00 GMT

摘要: 13行，#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZRHW | D3DFVF_DIFFUSE)是使用变换过的顶点格式，意思是在执行渲染流水线的过程中，不作顶点变换。换言之，可以直接用屏幕象素的单位大小来定义顶点的坐标。再换言之，就是说用这种顶点格式，可以简单的实现Overlay（不知道怎么翻译这个单词） 1 #inclu... 阅读全文

李锦俊(mybios) 2006-11-16 10:47 发表评论

【原创】《DirectX 9 3D 图形程序设计》 Tutorial 01 容易犯错的地方

李锦俊(mybios) — Thu, 16 Nov 2006 02:38:00 GMT

手写Tutorial 01例子是创建Windows窗口，并创建D3D设备。

97行，PeekMessage(&msg , 0 , 0 , 0 , PM_REMOVE)第二个参数如果改成PeekMessage(&msg , hWnd , 0 , 0 , PM_REMOVE)就会出现无法退出程序的问题！请注意！

44行，g_pd3dDevice->Present(0 , 0 , 0 , 0);这句话千万不要漏掉哦！否则就会显示花瓶！

  1#include <d3dx9.h>
  2
  3#define SAFE_RELEASE(o) {if(o){o->Release();o=0;}}
  4
  5LPDIRECT3D9 g_pD3D = 0;
  6LPDIRECT3DDEVICE9 g_pd3dDevice = 0;
  7
  8// 创建D3D设备
  9HRESULT InitD3D(HWND hWnd)
10{
11    // 创建D3D SDK
12    if(NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
13        return E_FAIL;
14
15
16    D3DPRESENT_PARAMETERS d3dpp;
17    memset(&d3dpp , 0 , sizeof(d3dpp));
18    d3dpp.Windowed = true;
19    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
20    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
21
22    RECT rect;
23    GetClientRect(hWnd , &rect);
24    d3dpp.BackBufferWidth = rect.right - rect.left;
25    d3dpp.BackBufferHeight = rect.bottom - rect.top;
26
27    if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT
28        , D3DDEVTYPE_HAL
29        , hWnd
30        , D3DCREATE_HARDWARE_VERTEXPROCESSING
31        , &d3dpp , &g_pd3dDevice
32        )))
33        return E_FAIL;
34
35    return S_OK;
36}
37
38// 渲染
39void Render()
40{
41    // 清空成蓝色
42    g_pd3dDevice->Clear(0 , 0 , D3DCLEAR_TARGET , D3DCOLOR_XRGB(0 , 0 , 255) , 1.0f , 0);
43    // 显示
44    g_pd3dDevice->Present(0 , 0 , 0 , 0);
45}
46
47// 清除占有的内存
48void CleanUp()
49{
50    SAFE_RELEASE(g_pD3D);
51}
52
53// 消息处理
54LRESULT WINAPI MsgProc(HWND hWnd , UINT message , WPARAM wParam , LPARAM lParam)
55{
56    switch(message)
57    {
58    case WM_DESTROY:
59        CleanUp();
60        PostQuitMessage(0);
61        return 0;
62        break;
63    default:
64        break;
65    }
66    return DefWindowProc(hWnd, message , wParam , lParam);
67}
68
69// Windows入口
70int WINAPI WinMain(IN HINSTANCE hInstance, IN HINSTANCE hPrevInstance, IN LPSTR lpCmdLine, IN int nShowCmd)
71{
72    WNDCLASS wndClass;
73    memset(&wndClass , 0 , sizeof(wndClass));
74    wndClass.hInstance = hInstance;
75    wndClass.lpszClassName = "Tutorial01";
76    wndClass.style = 0;
77    wndClass.lpfnWndProc = MsgProc;
78    // 注册窗口类
79    RegisterClass(&wndClass);
80
81    // 创建窗口
82    HWND hWnd = CreateWindow("Tutorial01" , "Tutorial01 : CreateDevice" , WS_OVERLAPPEDWINDOW
83        , 0 , 0 , 512 , 512 , GetDesktopWindow()
84        , 0 , wndClass.hInstance , 0);
85
86    // 显示窗口
87    ShowWindow(hWnd , SW_SHOWDEFAULT);
88    UpdateWindow(hWnd);
89
90    if(SUCCEEDED(InitD3D(hWnd)))
91    {
92        // 消息循环
93        MSG msg;
94        memset(&msg , 0 , sizeof(msg));
95        while(msg.message != WM_QUIT)
96        {
97            if(PeekMessage(&msg , 0 , 0 , 0 , PM_REMOVE))
98            {
99                DispatchMessage(&msg);
100                TranslateMessage(&msg);
101            }
102            else
103            {
104                Render();
105            }
106        }
107    }
108
109    CleanUp();
110    UnregisterClass("Tutorial01" , wndClass.hInstance);
111    return 0;
112}
113
114
115

李锦俊(mybios) 2006-11-16 10:38 发表评论