After adjusting the light intensity for any attenuation effects, the lighting engine computes how much of the remaining light reflects from a vertex, given the angle of the vertex normal and the direction of the incident light. The lighting engine skips to this step for directional lights because they do not attenuate over distance. The system considers two reflection types, diffuse and specular, and uses a different formula to determine how much light is reflected for each. After calculating the amounts of light reflected, Direct3D applies these new values to the diffuse and specular reflectance properties of the current material. The resulting color values are the diffuse and specular components that the rasterizer uses to produce Gouraud shading and specular highlighting.

Diffuse lighting is described by the following equation.

Diffuse Lighting = sum[Cd*Ld*(N.Ldir)*Atten*Spot]

The value for C_d is either:

• vertex color1, if DIFFUSEMATERIALSOURCE = D3DMCS_COLOR1, and the first vertex color is supplied in the vertex declaration.
• vertex color2, if DIFFUSEMATERIALSOURCE = D3DMCS_COLOR2, and the second vertex color is supplied in the vertex declaration.
• material diffuse color

Note     If either DIFFUSEMATERIALSOURCE option is used, and the vertex color is not provided, the material diffuse color is used.

To calculate the attenuation (Atten) or the spotlight characteristics (Spot), see Attenuation and Spotlight Factor (Direct3D 9).

Diffuse components are clamped to be from 0 to 255, after all lights are processed and interpolated separately. The resulting diffuse lighting value is a combination of the ambient, diffuse and emissive light values.

Example

In this example, the object is colored using the light diffuse color and a material diffuse color. The code is shown below.

D3DMATERIAL9 mtrl;
ZeroMemory( &mtrl, sizeof(mtrl) );

D3DLIGHT9 light;
ZeroMemory( &light, sizeof(light) );
light.Type = D3DLIGHT_DIRECTIONAL;

D3DXVECTOR3 vecDir;
vecDir = D3DXVECTOR3(0.5f, 0.0f, -0.5f);
D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecDir );

// set directional light diffuse color
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
m_pd3dDevice->SetLight( 0, &light );
m_pd3dDevice->LightEnable( 0, TRUE );

// if a material is used, SetRenderState must be used
// vertex color = light diffuse color * material diffuse color
mtrl.Diffuse.r = 0.75f;
mtrl.Diffuse.g = 0.0f;
mtrl.Diffuse.b = 0.0f;
mtrl.Diffuse.a = 0.0f;
m_pd3dDevice->SetMaterial( &mtrl );
m_pd3dDevice->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);

According to the equation, the resulting color for the object vertices is a combination of the material color and the light color.

These two images show the material color, which is gray, and the light color, which is bright red.

The resulting scene is shown below. The only object in the scene is a sphere. The diffuse lighting calculation takes the material and light diffuse color and modifies it by the angle between the light direction and the vertex normal using the dot product. As a result, the backside of the sphere gets darker as the surface of the sphere curves away from the light.

Combining the diffuse lighting with the ambient lighting from the previous example shades the entire surface of the object. The ambient light shades the entire surface and the diffuse light helps reveal the object's 3D shape.

Diffuse lighting is more intensive to calculate than ambient lighting. Because it depends on the vertex normals and light direction, you can see the objects geometry in 3D space, which produces a more realistic lighting than ambient lighting. You can use specular highlights to achieve a more realistic look.

Ambient lighting provides constant lighting for a scene. It lights all object vertices the same because it is not dependent on any other lighting factors such as vertex normals, light direction, light position, range, or attenuation. It is the fastest type of lighting but it produces the least realistic results. Direct3D contains a single global ambient light property that you can use without creating any light. Alternatively, you can set any light object to provide ambient lighting. The ambient lighting for a scene is described by the following equation.

环境光为场景提供了一种恒定不变的光照。环境光对所有物体的顶点的照明效果相同，因为它与其余光照因子，如顶点法向、光的方向、光的位置、范围或衰减等无关。环境光是最快的一种类型，但它提供的真实感最少。Direct3D 包含了一个全局的环境光属性，应用程序可以直接使用而无需创建任何光源。另外，应用程序也可以设定光源提供环境光照。场景中环境光的计算由以下公式描述。

Ambient Lighting = Ca*[Ga + sum(Atti*Spoti*Lai)] 

Where:

The value for C_a is either:

• vertex color1, if AMBIENTMATERIALSOURCE = D3DMCS_COLOR1, and the first vertex color is supplied in the vertex declaration.
• vertex color2, if AMBIENTMATERIALSOURCE = D3DMCS_COLOR2, and the second vertex color is supplied in vertex declaration.
• material ambient color.

Note    If either AMBIENTMATERIALSOURCE option is used, and the vertex color is not provided, then the material ambient color is used.
           m_pDevice9->SetRenderState(D3DRS_AMBIENTMATERIALSOURCE , D3DMCS_MATERIAL);

To use the material ambient color, use SetMaterial as shown in the example code below.

G_a is the global ambient color. It is set using SetRenderState(D3DRS_AMBIENT). There is one global ambient color in a Direct3D scene. This parameter is not associated with a Direct3D light object.

L_ai is the ambient color of the ith light in the scene. Each Direct3D light has a set of properties, one of which is the ambient color. The term, sum(L_ai) is a sum of all the ambient colors in the scene.

Ca的值可以是：

顶点颜色1，如果AMBIENTMATERIALSOURCE = D3DMCS_COLOR1，并且顶点声明中给出了第一个顶点的颜色。
顶点颜色2，如果AMBIENTMATERIALSOURCE = D3DMCS_COLOR2，并且顶点声明中给出了第二个顶点的颜色。
材质的环境反射色。

注意 如果使用了任何一种AMBIENTMATERIALSOURCE，但是没有提供顶点颜色，那么系统会使用材质的环境反射色。

要使用材质的环境反射色，按以下示例代码使用SetMaterial方法。

Ga为全局的环境反射色，通过SetRenderState(D3DRENDERSTATE_AMBIENT)设置。Direct3D场景中只有一个全局环境反射色，它与其余Direct3D光源无关。

Lai为场景中第i个光源的环境反射色。每个Direct3D光源都有一组属性，其中一个就是环境反射色。符号sum(Lai)表示场景中所有环境反射色的总和。

Example

In this example, the object is colored using the scene ambient light and a material ambient color.

#define GRAY_COLOR	0x00bfbfbf

// create material
D3DMATERIAL9 mtrl;
ZeroMemory(&mtrl, sizeof(mtrl));
mtrl.Ambient.r = 0.75f;
mtrl.Ambient.g = 0.0f;
mtrl.Ambient.b = 0.0f;
mtrl.Ambient.a = 0.0f;
m_pd3dDevice->SetMaterial(&mtrl);
m_pd3dDevice->SetRenderState(D3DRS_AMBIENT, GRAY_COLOR);

According to the equation, the resulting color for the object vertices is a combination of the material color and the light color.

These two images show the material color, which is gray, and the light color, which is bright red.

The resulting scene is shown below. The only object in the scene is a sphere. Ambient light lights all object vertices with the same color. It is not dependent on the vertex normal or the light direction. As a result, the sphere looks like a 2D circle because there is no difference in shading around the surface of the object.
渲染得到的场景如下所示。场景中唯一的物体是一个球体。环境光用相同的颜色对物体的所有顶点进行光照计算，它不依赖于顶点法向和光的方向。因此，球体看起来像是二维的圆，因为物体的表面没有明暗变化。

To give objects a more realistic look, apply diffuse or specular lighting in addition to ambient lighting.

用了dx9的多流，在nvida 8600gt 上确实能提高效率，不过不是很明显，高10%多点吧，可能我画的顶点还少，只有900个左右。
在nvida mx400上比没有使用流的差了很多（这个也不是dx9显卡，可能支持的不好），只有1半的fps，不过奇怪的是切换到全屏，fps就差不太多了，还是略低。
在nvida 6200 上窗口模式使用流fps 略低。但全屏时能高10%左右。
奇怪即使窗口不能独占设备，也不能相差这么大啊。
或许多流这个东西到了dx10显卡才被很好的支持吧。
越看越像opengl的机制. opengl1.0 开始的颜色、顶点、法线缓冲区都是分开的。

函数:
//采用32*32像素矩形图片。
//hotx,hoty 为点击的热点，即判断游标是否点中的点。
m_pDevice9->SetCursorProperties(hotx,hoty,surface);
m_pDevice9->ShowCursor(TRUE);
检测是否支持：
if(m_Caps.CursorCaps & D3DCURSORCAPS_COLOR)
{
  //_T("...支持高分辨率游标400\n")
}
else if(m_Caps.CursorCaps & D3DCURSORCAPS_LOWRES)
{
  //T("...支持高分辨率游标\n");
}
在dx2006 中不需要调用 SetCursorPosition 函数.dx会自动更新数据
注意事项:
1 传递给SetCursorProperties函数的 LPDIRECT3DSURFACE9 参数必须是 default  a8r8b8g8资源 :
LPDIRECT3DSURFACE9 surface;
m_pDevice9->CreateOffscreenPlainSurface(32,32,D3DFMT_A8R8G8B8,D3DPOOL_DEFAULT,&surface,NULL);
2 当使用dinput鼠标时不能设置独占模式 DISCL_EXCLUSIVE , 否则不能显示游标.
3 不管源图片多大最终是以32*32大小呈现
4 不需要修改 WM_SETCURSOR 消息。return false 就好。只需要在win32 和 dinput控制切换的时候调用
SetCursor(NULL);
m_pDevice9->ShowCursor(TRUE);
好处:
当硬件支持高分辨率鼠标时（基本都支持）。鼠标刷新不受图像刷新速度影响，即使你的图形fps<5,游标一样能快速移动。就像windows操作系统即使挂掉了，鼠标还是能移动

long long ago。。。
DIPROPDWORD property;
property.dwData = 16;
这个值基本上够用，但调试的时候会报 buffer overflow 的警告
所以调高其到255(最大可以调整到1023)。

在GetDeviceData() 之前如果设备丢失必须先 Acquire() 获取设备。
不然会有个警告
看了quake3 可以在GetDeviceData 前调用 Acquire一次， 无论设备是否丢失，这个函数不怎么影响效率。
当鼠标移动到NC区域，如标题栏，这时候也要卸载dinput鼠标，从dinput获得鼠标位置使用 PtInRect 判断是否在客户区域内，
但较慢的机器往往有几率不能判断出来，使得dinput鼠标没有卸载，这样拖动标题栏会没有反应。但很多时候又正常。
只能通过GetCursorPos 来获得鼠标位置再来判断是否出了客户区。

设置 dxcpl debug output level 为最大,出现大量下面的警告：
Direct3D9: (WARN) :Ignoring redundant SetRenderState。。。
说明某个SetRenderState 反复设置相同的值。如:
Direct3D9: (WARN) :Ignoring redundant SetRenderState - 24
反复设置 D3DRS_ALPHAREF 为相同值。
这样会降低效率。既然已经设置过了除非设置不同的值，否则就无需再设置了，应该减少的函数调用还是可以减少的。
检查dx内存泄漏可以用dcpl 中的 break on allocid 来观察，好像不行。
可以，往往一个资源未卸载导致一堆泄漏，从最后一个allocid 查起。有时看运气，跟运行时间也有关系。

debug 版本工程预处理定义加入 D3D_DEBUG_INFO
用的2006的dxcpl，里面的设置似乎只影响dx9程序，当在调试和运行版切换时，dx9库的程序效率下降，dx8的反倒没有什么变化。
几次忘掉这个事，以为那里错了，效率差了这么多，忙忙呼呼找上半天。

使用D3DSWAPEFFECT_DISCARD 才能支持全屏抗锯齿，但使用GetBackBuffer可能获得不到后台缓冲。用这个方法截屏就不行了。而且DISCARD 并不像某些书写的效率高，在我的8600GT 上还没有COPY效率好。
或者3D游戏多边形多起来才能体现效率吧，毕竟3D游戏都是需要抗锯齿给玩家选择的
主要是因为设置了puredevice才造成不能GetBackBuffer.但有些显卡又可以调用
DISCARD 是要用的。puredevice 也需要。截屏似乎用截屏键更有效，或者还有其他方法来实现

锁定纹理是指定区域是不需要除4 （压缩纹理是4*4块元素作为一个单位，如下面结构，即一个单位可以计算出16个像素值）。
typedef struct ddsColorBlock_s
{
    unsigned short          colors[ 2 ];
    unsigned char           row[ 4 ];
}
ddsColorBlock_t;
所以压缩纹理长度宽度必须是4的倍数。
dx9可能内部做了处理.使用LockRect是不需要自己对应到指定的块（如64,64 像素在压缩纹理文件中属于16*16 块的位置）.
//x,y 为像素位置
D3DLOCKED_RECT LockedRect;
RECT rt = {x,y,x+1,y+1};
pTex->LockRect(0,&LockedRect,&rt,D3DLOCK_READONLY);

//其实对于4*4 个像素，例如下面
{0,0}{1,0}{2,0}{3,0}
{0,1}{1,1}{2,1}{3,1}
{0,2}{1,2}{2,2}{3,2}
{0,3}{1,3}{2,3}{3,3}
LockedRect.pBits 内容是相同的即一个ddsColorBlock_t结构元素（解压这个结构即可获得上面的数据）

 
奇怪的问题。
我也同样向左上移动:字体显示就亮了些,特别是对于笔画粗的文字，也都细了。
D3DXMATRIX tmp;
D3DXMatrixOrthoOffCenterLH(&m_matProj,0,(float)m_iWidth,(float)m_iHeight,0,0.0f,1.0f);
D3DXMatrixTranslation(&tmp, -0.5f, -0.5f, 0.0f);
D3DXMatrixMultiply(&m_matProj, &tmp, &m_matProj);
不知道原因，如果有高手明白请不吝赐教。

重新编译了FreeType ，打开了freetype 对bytecode interpreter 的支持。修改ftoption.h
即使用字体本身的HINTING来读取小字体
#define TT_CONFIG_OPTION_BYTECODE_INTERPRETER
屏蔽了
/*#define TT_CONFIG_OPTION_UNPATENTED_HINTING*/

打开了对液晶显示器的支持
#define FT_CONFIG_OPTION_SUBPIXEL_RENDERING

上面的图显示的英文要比汉字暗一些。设置纹理操作为modulate2x
m_pDevice9->SetTextureStageState( 0,D3DTSS_ALPHAOP,D3DTOP_MODULATE2X );
提高alpha值。结果:
 

终于找到了原因，其实跟正交投影没有一点关系。主要是纹理滤波的问题，浪费了大量时间，不过也得到了不少，

if(!FT_Load_Glyph(m_FTFace,idx,FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP))
{
    FT_GlyphSlot glyph = m_FTFace->glyph;

    if (glyph->format == ft_glyph_format_outline)
    {

        if(m_bShadow)
        {
            //加粗文字
            FT_Outline_Embolden( &(glyph->outline), 260 );
        }
        if (!FT_Render_Glyph( glyph, m_bAntiAliased ?  FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO))
        {
          //更新到纹理中
        }
    }

}

//用粗体文字做底纹实现类似魔兽任务tips的文字
 

当"allocating vertex buffers_分配顶点缓存"时:

当使用 STATIC(这个是.net 情况，对于非.net版本dx是没有指定D3DUSAGE_DYNAMIC)标识分配顶点缓存时，这块缓存位于显存中。它的典型应用是只写一次并不被读回内存的情况。
只有当标志 D3DUSAGE_DYNAMIC被设置时 D3DUSAGE_WRITEONLY标志才有意义。
如果使用DYNAMIC标志创建缓存 (使用D3DUSAGE_DYNAMIC创建的缓存) ，并且D3DUSAGE_WRITEONLY 被使用，缓存被分配到显存中。

如果使用DYNAMIC标志创建缓存 (使用D3DUSAGE_DYNAMIC创建的缓存) ，并且D3DUSAGE_WRITEONLY 不被使用， 缓存被分配到AGP 缓存中。(CPU从AGP缓存中读取的速度比显存中快，但比内存慢，是个很好的折中)
如果没有足够的显存，顶点缓存被分配到AGP缓存中；如果AGP缓存也不够时，创建失败，除非使用POOL_ MANAGED 创建。在这种情况下，D3D的运行库会释放足够多的显存，用来创建顶点缓存，并在内存中保存创建的缓存的一个拷贝。那些被运行库释放的显存，在需要它们时可以从内存中复制到显存中。注意标志POOL_ MANAGED 并不被发送到驱动程序，因为这是D3D的附加的功能。

对于NV1X 系列的GPUs, 在进行多数据流渲染得时候，如果有一个顶点缓存位于AGP缓存中，所有的其他位于显存中的顶点缓存会被移动到AGP缓存中。 

当" locking vertex buffers_锁定顶点缓存"时:

如果顶点缓存的创建标志是POOL_DEFAULT: 

如果没有指定任何标志，程序将被暂停，因为它强制程序和GPU同步操作。->低效

如果指定D3DLOCK_NOOVERWRITE 标志，应用程序不会改变缓存区已存在的内容，运行库会在以后继续使用这块缓存。当应用程序调用这个函数时，驱动程序立即返回。->高效

如果指定D3DLOCK_DISCARD 标志，程序将会更新整个缓存的值，实际上是分配一块新的缓存，即驱动程序重命名它。->高效

[注解：因为CPU和GPU是异步的操作，所以当CPU通过系统总线和GPU同步时，需要等到GPU把当前的工作做完。例如，当GPU正在对一块缓存进行DMA操作时，但往往CPU并不对GPU操作的那块缓存进行操作，所以CPU可以和GPU一起工作。当不指定操作标志时，CPU等待GPU完成绘制工作才更新顶点缓存，所以低效。如果指定D3DLOCK_NOOVERWRITE，表示CPU只更新顶点缓存中剩余的缓存，不考虑是否有其他图形绘制是正在使用这个的缓冲区段绘制图形，强制更新那段缓存并返回，而不像默认参数0那样等待前面的绘制结束，而不更新已经写入的顶点值，所以在CPU写入的时候，GPU可以并行的对那些已经存在的顶点值进行DMA等操作，所以高效；如果使用D3DLOCK_DISCARD 标志，说明当前分配的缓存大小不够了，需要重新使用缓存，CPU对这些新分配的缓存区域进行写操作，GPU这时可能还在异步处理旧的缓存区，所以这种调用也是高效的。调用完毕，收回释放的缓存。]

来自 GameRes 说明了 Lock 的标志含义，我改了一部分内容。因为 D3DLOCK_NOOVERWRITE 和 D3DLOCK_DISCARD 是要经常使用的。越熟练越好
NOOVERWRITE 并不是不覆盖数据，如果2个三角形在缓存中地址相同。后面定点内容会覆盖前面的。而前面的三角形将不能画出来。

如果缓冲区开的足够大，render 几帧才能使用完这个缓冲。可以一直使用NOOVERWRITE 就可以。当不够使用时在从头开始使用这个顶点缓冲。如果足够大。开头的顶点基本确定已经画完（都是前几帧的图形顶点内容了。被覆盖也无所谓），如果缓冲很小lock时可以调用DISCARD,表示丢弃缓冲区内容（被丢弃的内容如果在使用中还可以被GPU继续使用。NOOVERWRITE 不会保留,所以速度更好）。如下使用开头的6个顶点画2个四边形。但该用NOOVERWRITE 将之后后面的四边形

   Quad->Lock(0, 6*sizeof(Vertex), (void**)&v, D3DLOCK_DISCARD);

   // quad built from two triangles, note texture coordinates:
   //v += 6;
   v[0] = Vertex(0.0f, 0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
   v[1] = Vertex(0.0f,  1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
   v[2] = Vertex( 1.0f,  1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);

   v[3] = Vertex(0.0f, 0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
   v[4] = Vertex( 1.0f,  1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
   v[5] = Vertex( 1.0f, 0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);

   Quad->Unlock();

   Device->SetTexture(0, Tex1);
   Device->SetStreamSource(0, Quad, 0, sizeof(Vertex));
   Device->SetFVF(Vertex::FVF);
   Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

   Quad->Lock(0, 6*sizeof(Vertex), (void**)&v, D3DLOCK_DISCARD);
     // quad built from two triangles, note texture coordinates:
   v[0] = Vertex(-1.0f, -1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
   v[1] = Vertex(-1.0f,  0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
   v[2] = Vertex( 0.0f,  0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);

   v[3] = Vertex(-1.0f, -1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
   v[4] = Vertex( 0.0f,  0.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);
   v[5] = Vertex( 0.0f, -1.0f, 1.25f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);

   Quad->Unlock();

   Device->SetTexture(0, Tex);
   Device->SetStreamSource(0, Quad, 0, sizeof(Vertex));
   Device->SetFVF(Vertex::FVF);
   Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

当使用 D3DLOCK_NOOVERWRITE  标志时，似乎Lock 使用偏移地址没什么意义.或许可以提高性能

使用 alpha Blend 必须激活 D3DRS_ALPHABLENDENABLE
m_pDevice9->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
而使用 SetTextureStageState  混合多纹理时必须关闭 D3DRS_ALPHABLENDENABLE .使用D3DRS_SRCBLEND 和 D3DRS_DESTBLEND 时候。当前纹理层的颜色操作也必须是默认的 D3DTA_MODULATE.
否者。。。。
m_pDevice9->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
m_pDevice9->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);
相当于 D3DTA_ADD (发光映射)
m_pDevice9->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_DESTCOLOR);
m_pDevice9->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR);
相当于 D3DTA_ADDSIGNED (细节映射)
m_pDevice9->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ZERO);
m_pDevice9->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCCOLOR);
相当于 D3DTA_MODULATE (黑暗映射)

因为我公司的破机器只能支持2个纹理层混合(尽管dx有8个纹理stage，但家里的nvdia 6200 才支持3个纹理，该换了)。所有当纹理过多时。2层混合后就要提交顶点。后面纹理采用SetRenderState 的办法和已经提交的纹理进行混合（当然后面的也可以是2个纹理混合的）
7个纹理，出了第一个是单层外。后面都是2层纹理一画。（法线贴图 + 2个火颜色混合 + 火和灯光混合）
m_pDevice9->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE); 
m_pDevice9->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_ONE);
m_pDevice9->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_ONE);

BindTexture(0,g_ptex1);         //火
DxUpdateTSS(0,0,NULL);        //设置纹理层0为默认 MODULATE 操作
DisableStage(2);                  //不使用纹理层2
BindTexture(1,g_ptex6);        //灯
DxUpdateTSS(1,RSS_TSS_COLOR_ADD,NULL);
m_pDevice9->SetStreamSource(0, g_pvbQuad1, 0, sizeof(Vertex));
m_pDevice9->SetFVF(Vertex::FVF);       
m_pDevice9->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

                                        
似乎 D3DCREATE_MULTITHREADED 也有些问题。我一直用多线程load free 纹理。一定时间后，最后屏幕上纹理消失了。奇怪的是跟踪进去。发现纹理指针还在。而且很不容易出现，有时放2个小时都不会出现。不过本来该避免这个参数，把load 文件放入了线程。而加载纹理放在主进程。

    D3DXVECTOR3 vLight;
    POINT kPoint;
    g_pDIMouse->GetAbsolutePos(&kPoint);
    // Create a vector from the cursor position (no Z axis for this, the mouse is in 2D)
    //主要记住如何用 鼠标坐标获得光照方向 L xy 范围在 -1 ~ 1 . 当然也可以调整成一个固定值
    vLight.x = ((2*(float)kPoint.x / (float)g_D3DSettings.m_nDeviceWidth) - 1);
    vLight.y = ((2*(float)kPoint.y / (float)g_D3DSettings.m_nDeviceHeight) - 1);
    vLight.z = 1.0f;
    // Normalize the vector. See the tutorial for more info! Normalization reduces the
    // magnitude of a vector to 1, but keeps the original direction. This makes it a
    // unit vector. Also see the Cheaters Guide to 3D Maths!
    // 归一化
    D3DXVec3Normalize( &vLight, &vLight );
    // Now that we have our light vector, we need to turn it back into a greyscale
    // RGB to use to modulate the texture with. Remember that we've normalized this
    // vector, so .x and .y will be between 0.0 and 1.0f (which is why we need to
    // * 127.0f and + 128.0f). Calculate it yourself, if vLight.x was 0.5f.
    DWORD r = (DWORD)(127.0f * vLight.x + 128.0f);
    DWORD g = (DWORD)(127.0f * vLight.y + 128.0f);
    DWORD b = (DWORD)(127.0f * vLight.z + 128.0f);
    DWORD dwFactor = D3DCOLOR_XRGB(r, g, b);
    // Set the texture factor to the rgb calculated above. For more info on the texture
    // factor and how it works with the D3DTA_TFACTOR state, refer to DirectX Basics
    // Series 3 tutorial 4.
    g_pDevice->SetRenderState(D3DRS_TEXTUREFACTOR, dwFactor);  (N * L)
    // Modulate the texture (the normal map) with the light vector (stored
    // above in the texture factor). From the SDK: "Modulate the components of each argument
    // as signed components, add their products; then replicate the sum to all color
    // channels, including alpha".
    g_pDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    g_pDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_DOTPRODUCT3 );
    g_pDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TFACTOR );
    // Set the texture to be the normal map
    g_pDevice->SetTexture( 0, g_pNormalMapTexture );
法线贴图使用 Phong 着色会好一些:
    m_pDevice9->SetRenderState(D3DRS_SHADEMODE,D3DSHADE_PHONG);
例子地址
http://www.thehavok.co.uk/scene/32bits/tutorials/directx/techniques/source/dot3dinput.zip

一般来说， 定位渲染通道瓶颈的方法就是改变渲染通道每个步骤的工作量, 如果吞吐量也改变了, 那个步骤就是瓶颈. 找到了瓶颈就要想办法消除瓶颈, 可以减少该步骤的工作量, 增加其他步骤的工作量.

一般在光栅化之前的瓶颈称作”transform bound”, 三角形设置处理后的瓶颈称作”fill bound”

定位瓶颈的办法

1. 改变帧缓冲或者渲染目标(Render Target)的颜色深度(16 到 32 位), 如果帧速改变了, 那么瓶颈应该在帧缓冲(RenderTarget)的填充率上.

2. 否则试试改变贴图大小和贴图过滤设置, 如果帧速变了,那么瓶颈应该是在贴图这里.

3. 否则改变分辨率.如果帧速改变了, 那么改变一下pixel shader的指令数量, 如果帧速变了, 那么瓶颈应该就是pixel shader. 否则瓶颈就在光栅化过程中.

4. 否则, 改变顶点格式的大小, 如果帧速改变了, 那么瓶颈应该在显卡带宽上.

5. 如果以上都不是, 那么瓶颈就在CPU这一边.

优化方法36条:

1. 尽量减少无用的顶点数据, 比如贴图坐标, 如果有Object使用2组有的使用1组, 那么不 要将他们放在一个vertex buffer中, 这样可以减少传输的数据量.

2. 使用多个streamsource, 比如SkinMesh渲染, 可以把顶点坐标和法线这些每一帧都要修改的数据放在一个动态VB中, 其它不需要修改的(如贴图坐标)放到一个静态VB中, 这样就减少了数据传输量.

3. 尽量使用16位的索引缓冲,避免32位的. 一方面浪费带宽, 一方面也不是所有的显卡都支持32位的索引缓冲.

4. 可以考虑使用vertex shader来计算静态VB中的数据.比如SkinMesh的顶点可以放到vectex shader中计算, 这样就可以避免每一帧都从AGP内存中向显存传送数据. 这样也可以使用静态VB了.

5. 坚决避免使用Draw**UP一族的函数来绘制多边形.

6. 在设计程序之前好好规划一下显卡内存的使用, 确保framebuffer, 贴图, 静态VB能够正好放入显卡的本地内存中.

7. 尽量使顶点格式大小是32字节的倍数.可以考虑使用压缩过的顶点格式然后用vertex shader去解. 或者留下冗余的部分, 使顶点大小刚好使32字节的倍数.

8. 顶点在顶点缓冲中的顺序尽量符合绘制的顺序, 考虑使用strips来代替list.

9. 如果可能尽量多的使用static vertex buffer代替dynamic vertex buffer

10. 动态VB使用DISCARD参数来lock更新, 使用NOOVERWRITE来添加.尽量不要使用不带参数的lock调用(0)

11. 尽量减少lock的次数, 有些东西并不一定非要每一帧都更新VB, 比如人物动画一般每秒钟更新30次VB基本上就够了.

12. 如果是因为需要绘制的顶点数据太多了可以考虑使用LOD, 但是现在的显卡的绘制能力都很强劲, 所以需要权衡一下LOD是否能够带来相应的好处, 如果过分的强化LOD很可能将瓶颈转移到CPU这边.

13. 避免过多的顶点计算,比如过多的光源, 过于复杂的光照计算(复杂的光照模型), 纹理自动生成的开启也会增加顶点的计算量. 如果贴图坐标变换矩阵不是单位矩阵, 也会造成顶点计算量的增加, 所以如果纹理变换已经结束, 记得要将纹理变换矩阵设为单位矩阵同时调整贴图坐标.

14. 避免Vertex shader指令数量太多或者分支过多, 尽量减少vertex shader的长度和复杂程度. 尽量使用swizzling代替mov

15. 如果图象质量方面的计算(pixel shader)范围很大, 并且很复杂, 可以考虑试试全屏反走样.说不定更快.

16. 尽量按照front – back的顺序来绘制.

17. 在shader中判断Z值可以避免绘制不可见的象素, 但是nvidia建议简单的shader不要这么做.(Don’t do this in a simple shader)

18. 如果可能, 尽量使用vertex shader来代替pixel shader.将计算从逐象素变成逐顶点.

19. 尽量降低贴图的大小.过大的贴图可能造成贴图cache过载, 从而导致贴图cache命中降低.过大的贴图会导致显存过载, 这时候贴图是从系统内存中取的.

20. 只要可能就用16位色的贴图, 如环境贴图或者shadow map.它们用32位色的贴图实在是浪费.

21. 考虑使用DXT 贴图压缩

22. 如果可能,使用简单的贴图过滤或者mip map, 除非必要否则尽量不要使用三线过滤和各项异性过滤. light map 和 环境贴图基本上都不需要使用它们.

23. 只有真正需要修改的贴图才使用Dynamic, 并且使用DISCRAD和WRITEONLY来lock

24. 太多的帧缓冲读写可以考虑关闭Z-Writes如有些多pass的渲染中的后续pass或者粒子系统等半透明几何物体（如果可以）

25. 可能的话尽量使用alpha test代替alpha blending

26. 如果不需要stencil buffer就尽量使用16位的Z buffer

27. 减小RenderTarget 贴图的大小, 如shadow map 环境贴图. 可能根本不需要那么大效果就很好.

28. Stencil 和 Z buffer 尽量一起clear. 他们本来就是一块缓冲.

29. 尽量减少渲染状态的切换, 尽量一次画尽可能多的多边形.（根据显卡性能决定最多画多少,不过一般再多也不会多到哪里去。 除非你根本不需要贴图和渲染状态的切换）

30. 尽量使用shader来代替Fixed Pipeline.

31. 尽量使用shader来实现来取代Multipass渲染效果.

32. 尽量优先先建立重要的资源, 如Render target, shaders, 贴图, VB, IB等等.以免显存过载的时候它们被创建到系统内存中.

33. 坚决不要在渲染循环中调用创建资源

34. 按照shader和贴图分组后再渲染.先按照shaders分组再按贴图.

35. Color Stencil Z buffer尽量在一次Clear调用中清除.

36. 一个Vertex buffer 的大小在2M-4M之间最好.

参考文档: http://developer.nvidia.com/view.asp?IO=gdc_pipeperf

lythm@citiz.net

//quake3 中的调整gamma 方法。对应配置参数 r_gamma 调整 gamma, overbrightbits 调整亮度，r_intensity 调整对比度

 D3DGAMMARAMP GammaRamp; 
 float r_gamma = 1.6f; //gamma值，范围0.6-3.0
 static WORD s_gammatable[256];
 int  inf;
 int  shift = 0;   //亮度校正。范围视色深而定24位色及以上最大为2,16位最大为1 

 int i = 0;
 for ( i = 0; i < 256; i++ ) {
  if ( r_gamma == 1 ) {
   inf = i;
  } else {
   // gamma 校正算法,正常显示器gamma情况如下面的 fig1 图所示，要调节gamma 就要取 1/gamma 做指数，
   //得到 fig2 图示曲线, 从而叠加获得剃度直线
   inf = 255 * pow ( i/255.0f, 1.0f /r_gamma ) + 0.5f;   
  }
  inf <<= shift;   //overbright,对gamma剃度校正。感觉有了gamma校正可以不用这个.类似于gamma校正中的亮度校正
  if (inf < 0) {
   inf = 0;
  }
  if (inf > 255) {
   inf = 255;
  }
  s_gammatable[i] = inf<<8 | inf;     //使 word 的高位字节和低位字节相同
 }

 for ( i = 1 ; i < 256 ; i++ )
 {
  if ( s_gammatable[i] < s_gammatable[i-1] )
  {
   s_gammatable[i] = s_gammatable[i-1];
  }
 }

 for(i=0;i<256;++i) {
  GammaRamp.red[i] = s_gammatable[i];
  GammaRamp.green[i] = s_gammatable[i];
  GammaRamp.blue[i] = s_gammatable[i];
 }

 // 下面这种相对不够细腻，只相当于 overbright
 //int Overbrighten = 2;
 //int val;

 //for(i=0;i<256;++i) {
 // val = 256 * min( 255, i*Overbrighten );
 // GammaRamp.red[i] = val;
 // GammaRamp.green[i] = val;
 // GammaRamp.blue[i] = val;
 //}

 pd3dDevice->SetGammaRamp( 0, D3DSGR_NO_CALIBRATION, &GammaRamp );
 Sleep( 200 ); //fix occasional gamma problem (Gamma won't change when told to)
 pd3dDevice->SetGammaRamp( 0, D3DSGR_NO_CALIBRATION, &GammaRamp );

还有对比度：需要调整的是载入的图片的象素值。
每次退出要恢复成 gamma 线性值:即
    for (int g = 0; g < 255; g++ )
    {
     s_oldHardwareGamma[0][g] = g << 8;
     s_oldHardwareGamma[1][g] = g << 8;
     s_oldHardwareGamma[2][g] = g << 8;
    }
然后设置 gamma,因为程序可能非正常退出如:崩溃,或者调试退出.恢复gamma函数没有调用,几次之后 开始读取得gamma变成了上次非正常退出后调整过的值.所以恢复成线性值才能恢复到最原始的状态

I'm sure you've all seen gamma correction before, but you might not know exactly how it works or why it is necessary. In this article, I'll try to explain both, as well as provide practical information on how to implement gamma correction in your apps.

Intuitively, you might think of gamma correction as some sort of image brightness adjustment. That's not entirely wrong, but to understand why gamma correction is necessary, you need to look a little further. More precisely, you'll need to look inside your computer's display.

Chances are that your monitor is based on a cathode ray tube (CRT). A CRT uses an electron beam to make the phosphor coating inside the tube emit light. The brightness of a pixel is changed by varying the voltage of the electron beam as it touches that pixel. Unfortunately, the relation between CRT voltage and pixel brightness isn't linear. It looks something more like this:

This non-linearity effect is called gamma. Unfortunately, it causes the image displayed on your computer screen to be different from the image that is actually in memory. What you really want to see is a nice linear mapping between voltage and brightness. In other words: the graph above should be a straight line.

That's why you should perform gamma correction. Gamma correction is performed by remapping the colors in the image as such: 

The gamma-corrected color ramp can be calculated by raising the original color values to some power:

The exponent to use is the so-called "gamma value", which you can see in paint programs that support gamma correction. The gamma value should be user-configurable, of course.

You've probably already noticed: by using the gamma-corrected color ramp, you can cancel out the gamma effect of your monitor, resulting in a correct display of the image:

This leaves one thing to be discussed: how to implement gamma correction. If you're just working with bitmap images, you can perform it manually for each pixel. This being an OpenGL site and all, I suspect that this isn't really what you want to do. Luckily, you can ask your graphics card to perform the correction for you (in real-time, of course). To this effect, you can use the GetDeviceGammaRamp() and SetDeviceGammaRamp() API calls. I've written a small OpenGL demo that illustrates the use of these functions. Download it here.

That's all there's to it! Gamma correction is easy enough to understand and implement - and especially for games with dark environments, it can make a huge difference. Gamma correction will allow users to adjust the image brightness to suit their monitor, allowing them to see your game or application as you intended them to see it.

用MFC 对话框写了一个调整 Gamma 的程序,没有使用directx 函数，替代的是操作系统的函数。下载地址
http://www.91files.com/?2LKXQ8ZGOX9C8MEKN34X
参考网址:
http://www.cameraunion.net/forum/showthread.php?threadid=179245http://bbs.photoshopcn.com/archiver/tid-376356.html
http://www.delphi3d.net/articles/viewarticle.php?article=gamma.htm