博客园_独酌逸醉

此博客已经作废，不再更新

2012-04-30T01:31:00Z

大家好，我的博客已搬至 www.keepsimply.org 。另外喜欢音乐的朋友可以去我的音乐博客去( www.yuehun.in )听歌。

本文链接

Direct3D 初涉: 光照

2011-11-23T15:42:00Z

1. 光照的组成
在 Direct3D 的光照模型中，光源发出的光由以下 3 种分量或者 3 种类型的光组成：
(1) 环境光(Ambient Light)：光经其他表面反射到达物体表面，并照亮整个场景。个人理解：白天阴天的时候为什么还能看见物体？环境光！
(2) 漫射光(Diffuse Light)：光沿着特定的方向传播。当它到达某一表面时，将沿着各个方向均匀反射。无论从那个方向来看，表面亮度均相同，所以采用该模型时，无须考虑观察者的位置。
(3) 镜面光(Specular Light)：光沿特定方向传播。当此类光到达一个表面时，将严格地沿着另一个方向反射，从而形成只能在一定角度范围内才能观察到的高亮度照射。相对前两种光照类型，镜面光的计算量要大的多，因此默认情况下 Direct3D 不进行镜面反射计算；如果想启动镜面光，必须将绘制状态 D3DRS_SPECULARENABLE 设为 true 。

每种类型的光都可用结构 D3DCOLORVALUE 或 D3DXCOLOR 来表示，这些类型描述了光线的颜色( Alpha 值被忽略)。

2. 材质
在现实世界中，我们所看到的物体颜色是由该物体所反射的光的颜色决定的(物体对光进行的部分吸收)。例如：我的显示器边缘是黑色的，这是由于它吸收了所有非黑色的光，所以它显示为黑色。
Direct3D 通过定义物体的材质(materials)来模拟同样的现象。允许我们定义物体表面对各种颜色光的反射比例。在代码中使用结构 D3DMATERIAL9 来表示。Direct3D 使用 SetMaterial 来设定当前材质。

当物体能收吸收所有的光时，它将显示为黑色；当物体能反射所有的光时，它将显示为白色。

3. 顶点法线
面法线是一个描述多边形朝向的向量。顶点法线描述构成多边形各个顶点的法线。 Direct3D 需要知道顶点的法线方向，以确定光线到达表示时的入射角。

4. 光源
Direct3D 支持三种类型的光源：
(1) 点光源(Point lights)，在世界坐标系位置固定，并且向所有的方向发射光线。
(2) 方向光(Directional lights)，没有位置信息，发射的光线平行地沿着某一特定的方向传播。
(3) 聚光灯(Spot lights)，和手电筒类似，有位置信息，其发射的光线成锥形，沿着特定的方向传播。
在程序代码中，光源用结构 D3DLIGHT9 来表示。

5. 例程(Lighting)
(1) 将光照和颜色整合到框架中，将 DrawColorTriangle 中的GlobalColorConstant.h 添加到框架中。
(2) 新建文件 GlobalMtrlConstant.h ，保存常用材质的常量。

#ifndef __GLOBALMTRLCONSTANCE_H
#define GLOBALMTRLCONSTANCE_H__

D3DMATERIAL9 InitMtrl(D3DXCOLOR ambient, D3DXCOLOR diffuse, D3XCOLOR specular,
D3DXCOLOR emissive, float power)
{
D3DMATRIAL9 mtrl;
mtrl.Ambient = ambient;
mtrl.Diffuse = diffuse;
mtrl.Specular = specular;
mtrl.Emissive = emissive;
mtrl.Power = p;
return mtrl;
}

const D3DMATERIAL9 WHITE_MTRL = InitMtrl(WHITE, WHITE, WHITE, BLACK, 8.0f);
const D3DMATERIAL9 RED_MTRL = InitMtrl(RED, RED, RED, BLACK, 8.0f);
const D3DMATERIAL9 GREEN_MTRL = InitMtrl(GREEN, GREEN, GREEN, BLACK, 8.0f);
const D3DMATERIAL9 BLUE_MTRL = InitMtrl(BLUE, BLUE, BLUE, BLACK, 8.0f)
const D3DMATERIAL9 YELLOW_MTRL = InitMtrl(YELLOW, YELLOW, YELLOW, BLACK, 8.0f);

#endif /* __GLOBALMTRLCONSTANCE_H /
(3) 新建工程 Lighting ，将框架代码拷贝到新工程中(以下在 Lighting 上操作)。
(4) 新建文件 NormalVertex.h，添加法线顶点的定义。

#ifndef NORMALVERTEX_H
#define NORMALVERTEX_H__

struct NormalVertex
{
public:
NormalVertex()
{
}

NormalVertex(float x, float y, float z, float nx, float ny, float nz)
{
m_x = x; m_y = y; m_z = z;
m_nx = nx; m_ny = ny; m_nz = nz;
}

public:
float m_x, m_y, m_z;
float m_nx, m_ny, m_nz;
static const DWORD FVF;
};

const DWORD NormalVertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL;

#endif / __NORMALVERTEX_H__ /
(5) 向 Direct3DFrame 类中添加成员变量，保存金字塔的定点数据。
IDirect3DVertexBuffer9 m_pyramid; // 金字塔顶点缓存
(6) 在 Setup 中添加场景光照和其他操作

bool Direct3DFrame::Setup()
{
// 启用光照
m_device->SetRenderState(D3DRS_LIGHTING, true);

// 创建顶点缓存，并指定构成金字塔的三角形单元的顶点，顶点法线预先计算好
m_device->CreateVertexBuffer(
12 * sizeof(NormalVertex),
D3DUSAGE_WRITEONLY,
NormalVertex::FVF,
D3DPOOL_MANAGED,
&m_pyramid,
0);

NormalVertex* nv;
m_pyramid->Lock(0, 0, (void**)&nv, 0);

// font face
nv[0] = NormalVertex(-1.0f, 0.0f, -1.0f, 0.0f, 0.707f, -0.707f);
nv[1] = NormalVertex( 0.0f, 1.0f, 0.0f, 0.0f, 0.707f, -0.707f);
nv[2] = NormalVertex( 1.0f, 0.0f, -1.0f, 0.0f, 0.707f, -0.707f);

// left face
nv[3] = NormalVertex(-1.0f, 0.0f, 1.0f, -0.707f, 0.707f, 0.0f);
nv[4] = NormalVertex( 0.0f, 1.0f, 0.0f, -0.707f, 0.707f, 0.0f);
nv[5] = NormalVertex(-1.0f, 0.0f, -1.0f, -0.707f, 0.707f, 0.0f);

// right face
nv[6] = NormalVertex( 1.0f, 0.0f, -1.0f, 0.707f, 0.707f, 0.0f);
nv[7] = NormalVertex( 0.0f, 1.0f, 0.0f, 0.707f, 0.707f, 0.0f);
nv[8] = NormalVertex( 1.0f, 0.0f, 1.0f, 0.707f, 0.707f, 0.0f);

// back face
nv[9] = NormalVertex( 1.0f, 0.0f, 1.0f, 0.0f, 0.707f, 0.707f);
nv[10] = NormalVertex( 0.0f, 1.0f, 0.0f, 0.0f, 0.707f, 0.707f);
nv[11] = NormalVertex(-1.0f, 0.0f, 1.0f, 0.0f, 0.707f, 0.707f);

m_pyramid->Unlock();

// 设置物体材质
D3DMATERIAL9 mtrl;
mtrl.Ambient = WHITE;
mtrl.Diffuse = WHITE;
mtrl.Specular = WHITE;
mtrl.Emissive = BLACK;
mtrl.Power = 0.5f;

m_device->SetMaterial(&mtrl);

// 创建并启用光源
D3DLIGHT9 dir;
::ZeroMemory(&dir, sizeof(dir));
dir.Type = D3DLIGHT_DIRECTIONAL;
dir.Diffuse = WHITE;
dir.Specular = WHITE * 0.3f;
dir.Ambient = WHITE * 0.6f;
dir.Direction = D3DXVECTOR3(1.0f, 0.0f, 0.0f);

m_device->SetLight(0, &dir);
m_device->LightEnable(0, true);

// 重新规范化法向量，启用镜面光
m_device->SetRenderState(D3DRS_NORMALIZENORMALS, true);
m_device->SetRenderState(D3DRS_SPECULARENABLE, true);

D3DXVECTOR3 position(0.0f, 0.0f, -2.5f);
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX v;
D3DXMatrixLookAtLH(&v, &position, &target, &up);

m_device->SetTransform(D3DTS_VIEW, &v);

// Set the projection matrix.
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI * 0.5f, // 90 - degree
(float)m_width / (float)m_height,
1.0f,
1000.0f);
m_device->SetTransform(D3DTS_PROJECTION, &proj);

return true;
}
(7) 在 Display 添加代码，使金字塔显示和旋转起来

bool Direct3DFrame::Display(float timeDelta)
{
if (m_device) {
D3DXMATRIX yRot;
D3DXMatrixRotationY(&yRot, m_yRotAngle);
m_yRotAngle += timeDelta;

if( m_yRotAngle >= 6.28f ) {
m_yRotAngle = 0.0f;
}

m_device->SetTransform(D3DTS_WORLD, &yRot);

m_device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
m_device->BeginScene();

m_device->SetStreamSource(0, m_pyramid, 0, sizeof(NormalVertex));
m_device->SetFVF(NormalVertex::FVF);
m_device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 4);

m_device->EndScene();
m_device->Present(0, 0, 0, 0);
}
return true;
}

(8) 在 Cleanup 中释放资源(在以后的博客中不再提示)。
运行后效果图：

//
本文由独酌逸醉原创，转载请注明博客链接，谢谢！
小弟初学 Direct3D，文章中如果存在错误，烦请指证，不胜感激！
参考书籍：《DirectX 9.0 3D 游戏开发编程基础》
时间：2011.11.23
//

本文链接

Direct3D 初涉: 颜色

2011-11-21T13:58:00Z

1. 颜色表示
在 Direct3D 中。颜色用 RGB 三元组表示。RGB 数据可用两种不同的结构来保存。第一种是 D3DCOLOR ，它实际上与 DWORD 类型完全相同(由 typedef 定义)，共有 32 位。 D3DCOLOR 类型中各位被分成 8 位项(section)，每项存储了一种颜色分量的亮度值(Alpha,,R,G,B)。每项均占一个字节，所以每个分量的亮度值范围都在[0,255]区间内，接近 0 值表示最小值，接近 255 的值表示高度值。

Direct3D 提供了宏 D3DCOLOR_ARGB 帮助我们完成将颜色分量值，安插到 D3DCOLOR 类型的合适位置上。也可以使用 D3DCOLOR_XRGB 宏来代替 D3DCOLOR_ARGB，两者很相似，D3DCOLOR_XRGB 不接受 Alpha 参数(将 Alpha 分量设为 0xff(255) )。

在 Direct3D 中，存储颜色的数据的另一种结构是 D3DCOLORVALUE 。在该结构中，我们使用单精度浮点数来度量每个颜色分量的亮度值。亮度范围为(0~1)。

我们可以利用 D3DXCOLOR 代替 D3DCOLORVALUE，前者不但包含了与后者相同的数据成员，而且还提供了一组有用的构造函数和重载运算符，为颜色的运算提供了便利。

2. 顶点颜色
图元的颜色由构成该图元的顶点的颜色所决定。所以，我们必须为顶点数据结构添加一个表示颜色的数据成员。

3. 着色
在光栅化过程中，需要对多边形进行着色(shading)。着色规定了如何利用顶点的颜色来计算构成图元的像素的颜色。目前，我们使用两种着色模式(shading mode)：
(1) 平面着色 (flat shading)。每个图元的每个像素都被一致地赋予该图元的第一个顶点所指定的颜色。即使用平面着色时，如果第一个顶点是红色的，那么其他顶点的颜色值将被忽略。平面着色容易使物体呈现出“块状”，这是因为各颜色之间没有平滑地过度。
(2) Gouraud 着色 (Gouraud Shading)。图元中个像素的颜色值由各顶点的颜色线性插值得到。各个颜色之间的平滑的过度，因此Gouraud 着色也称平滑着色(smooth shading)。

4. 例程(DrawColorTriangle)
在 Direct3D 初涉：Direct3D 框架的搭建的框架上添加代码。
(1) 新建头文件 GlobalColorConstant.h ，添加一些颜色全局常量：
#ifndef __GLOBALCOLOR_CONSTANT_H
#define GLOBALCOLOR_CONSTANT_H__

const D3DXCOLOR WHITE ( D3DCOLOR_XRGB(255, 255, 255) );
const D3DXCOLOR BLACK ( D3DCOLOR_XRGB( 0, 0, 0) );
const D3DXCOLOR RED ( D3DCOLOR_XRGB(255, 0, 0) );
const D3DXCOLOR GREEN ( D3DCOLOR_XRGB( 0, 255, 0) );
const D3DXCOLOR BLUE ( D3DCOLOR_XRGB( 0, 0, 255) );
const D3DXCOLOR YELLW ( D3DCOLOR_XRGB(255, 255, 0) );
const D3DXCOLOR CYAN ( D3DCOLOR_XRGB( 0, 255, 255) );
const D3DXCOLOR MAGENTA( D3DCOLOR_XRGB(255, 0, 255) );

#endif /* __GLOBALCOLOR_CONSTANT_H /

(2) 新建头文件 ColorVertex.h 添加有色顶点的结构体定义：
#ifndef COLORVERTEX_H
#define COLORVERTEX_H__

struct ColorVertex
{
public:
ColorVertex(float x, float y, float z, D3DCOLOR color)
{
m_x = x; m_y = y; m_z = z;
m_color = color;
}

public:
static const DWORD FVF;

private:
float m_x;
float m_y;
float m_z;
D3DCOLOR m_color;
};
const DWORD ColorVertex::FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;

#endif / __COLORVERTEX_H__ /

(3)在 Direct3DFrame 类中添加代码：
D3DXMATRIX m_worldMatrix; // 存储所要绘制三角形的世界变换矩阵
IDirect3DVertexBuffer9 m_triangle; // 保存三角形数据的定点缓存

(4) Setup 方法创建了一个顶点缓存，并用所要绘制的三角形中带有颜色信息的顶点对该缓存进行填充。该三角形第 1 个顶点的颜色为红色，第 2 个顶点的颜色为绿色，第 3 个顶点为蓝色。在本例的最后，将光照禁用。

bool Direct3DFrame::Setup()
{
// Create the vertex buffer.
m_device->CreateVertexBuffer(
3sizeof(ColorVertex),
D3DUSAGE_WRITEONLY,
ColorVertex::FVF,
D3DPOOL_MANAGED,
&m_triangle,
0);

// Fill the buffer with the triangle data.
ColorVertex v;
m_triangle->Lock(0, 0, (void**)&v, 0);

v[0] = ColorVertex(-1.0f, 0.0f, 2.0f, RED);
v[1] = ColorVertex( 0.0f, 1.0f, 2.0f, GREEN);
v[2] = ColorVertex( 1.0f, 0.0f, 2.0f, BLUE);

m_triangle->Unlock();

// Set the projection matrix.
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI * 0.5f,
(float)m_width / (float)m_height,
1.0f,
1000.0f);
m_device->SetTransform(D3DTS_PROJECTION, &proj);

// Turn off lighting.
m_device->SetRenderState(D3DRS_LIGHTING, false);

return true;
}

(5) Display 函数在两个不同的位置以两种不同的着色模式分别绘制 Triangle。每个三角形位置由世界变换矩阵 World 来控制。

bool Direct3DFrame::Display(float timeDelta)
{
if (m_device) {
m_device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);

m_device->BeginScene();

m_device->SetFVF(ColorVertex::FVF);
m_device->SetStreamSource(0, m_triangle, 0, sizeof(ColorVertex));

// draw the triangle to the left with flat shading
D3DXMatrixTranslation(&m_worldMatrix, -1.25f, 0.0f, 0.0f);
m_device->SetTransform(D3DTS_WORLD, &m_worldMatrix);
m_device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);
m_device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

// draw the triangle to the right with gouraud shading
D3DXMatrixTranslation(&m_worldMatrix, 1.25f, 0.0f, 0.0f);
m_device->SetTransform(D3DTS_WORLD, &m_worldMatrix);
m_device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD);
m_device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);

m_device->EndScene();
m_device->Present(0, 0, 0, 0);
}

return true;
}

(6) 在 Cleanup 中释放资源
void Direct3DFrame::Cleanup()
{
m_device->Release();
m_triangle->Release();
}
运行后截图：

//
本文由独酌逸醉原创，转载请注明博客链接，谢谢！
小弟初学 Direct3D，文章中如果存在错误，烦请指证，不胜感激！
参考书籍：《DirectX 9.0 3D 游戏开发编程基础》
时间：2011.11.21
//

本文链接

Direct3D 初涉： Direct3D 中的绘制

2011-11-20T10:21:00Z

1. 顶点缓存和索引缓存(vertex/index buffer)
一个顶点缓存是一个包含顶点数据的连续内存空间；一个索引缓存是包含索引数据的连续内存空间。顶点缓存和索引缓存可以被放置到显存(video memory)中。进行绘制时，使用显存中的数据将获得比使用系统内存中的数据(Array)快得多的速度。

1.1 创建
顶点缓存用接口 IDirect3DVertexBuffer9 表示，用CreateVertexBuffer 创建；索引缓存用 IDirect3DIndexBuffer9 表示，用 CreateIndexBuffer 创建。
*静态缓存与动态缓存
创建缓存时，如果未使用标记 D3DUSAGE_DYNAMIC ，则称所创建的缓存为静态缓存(static buffer)。静态缓存一般被放置在显存中，以保证存储于其中的数据得到最高效的处理。然而，静态缓存是以牺牲对静态缓存读写操作的速度为代价的，这是因为访问显存的速度本身就很慢。基于上述原因，我们用静态缓存来存储静态数据(那些不需要经常修改或访问的数据)。静态缓存必须在应用程序初始化时用几何体的数据进行填充。
创建缓存时，如果使用了标记 D3DUSAGE_DYNAMIC ，则称所创建的缓存为动态缓存(dynamic buffer)。动态缓存一般放置在 AGP(Accelerated Graphics Port) 存储区中，其内容可被迅速更新。动态缓存中数据的处理速度不像静态缓存那样快，这是因为在绘制之前数据必须传输到显存中。但动态缓存的突出优点是其更新速度相当快(快速的 CPU 写操作)。所以，如果您需要频繁更新缓存中的内容，该缓存应设置为动态的。
对显存和 AGP 存储区进行读操作非常慢。所以，如果您需要在程序中运行时读取几何数据，最好在系统内存中保留一份副本，然后需要时对其进行读操作。

1.2访问顶点缓存
使用 Lock 方法来获取指向缓存内容的指针。访问完毕之后，必须对缓存进行解锁(unlock)操作。

1.3 获取顶点缓存和索引缓存的信息
使用 GetDesc 方法来获取顶点缓存(D3DVERTEXBUFFER_DESC)和索引缓存(D3DINDEXBUFFER_DESC)的信息。

2. 绘制状态

绘制状态(render state)，几何体的绘制方式。使用 SetRenderState 来指定绘制状态。

3. 绘制的准备工作

3.1 指定数据流输入源。将顶点缓存和数据流进行链接，实质上是将几何体的信息传输到绘制流水线中。使用 SetStreamSource 方法来设置输入源。

3.2 设置顶点格式。指定(SetFVF)后续绘制调用中使用的顶点格式。

3.3 设置索引缓存。如果我们想使用索引缓存，必须对后续绘制操作中所要使用的索引缓存进行设置(SetIndices)。任意时刻只允许使用一个索引缓存，索引如果您要用一个不同的索引缓存绘制物体时，必须进行切换。

4. 使用顶点缓存和索引缓存进行绘制

使用 DrawPrimitive 或 DrawIndexedPrimitive 方法将待绘制几何体的信息通过绘制流水线传输。这两个方法从顶点数据流中获取顶点信息，并从当前设定的索引缓存中提取索引信息。所有的绘制方法都必须在 BeginScene 和 EndScene 构成的方法对之间进行调用。

5. D3DX 几何体

在代码中通过创建三角形单元来构建 3D 物体是非常繁琐的。 D3DX 库提供了一些用于生成简单 3D 几何体的网格数据的方法。

D3DXCreateBox

D3DXCreateSphere

D3DXCreateCylinder

D3DXCreateTeapot

D3DXCreatePolygon

D3DXCreateTorus

这六个方法类似，都使用了 D3DX 网格数据结构 ID3DXMesh 和 ID3DXBuffer 接口。使用这些方法生成网格数据后，用 DrawSubSet 函数对其进行绘制。网格使用完毕后必须进行释放(Release)。

6. 例程(DrawCube)
例程框架请看：Direct3D 初涉：Direct3D 框架的搭建
在 Direct3DFrame 类中添加两个变量，保存立方体的顶点和索引数据：
IDirect3DVertexBuffer9*  m_vb;  // 顶点缓存
IDirect3DIndexBuffer9*   m_ib;  // 索引缓存
在构造函数中初始化为空：
this->m_vb = NULL;
this->m_ib = NULL;
定义顶点结构和该结构的灵活顶点格式。添加一个新文件 Vertex.h ，文件内容如下：

#ifndef __VERTEX_H
#define VERTEX_H__

struct Vertex
{
Vertex(){}
Vertex(float x, float y, float z)
{
m_x = x;
m_y = y;
m_z = z;
}

float m_x;
float m_y;
float m_z;
static const DWORD FVF;
};

const DWORD Vertex::FVF = D3DFVF_XYZ;

#endif /* __VERTEX_H_ /

在 Setup 函数中创建顶点缓存和索引缓存，然后对缓存进行锁定，将构成立方体的顶点数据以及构成立方体的三角形单元的索引数据分别写入顶点缓存和索引缓存。然后将摄像机沿 Z 轴负方向平移几个单位，以使绘制在世界坐标系原点的立方体处于摄像机的视场内。然后再实施投影变换。最终，将填充模式的绘制状态设为线框模式。

bool Direct3DFrame::Setup()
{
m_device->CreateVertexBuffer(
8 sizeof(Vertex),
D3DUSAGE_WRITEONLY,
Vertex::FVF,
D3DPOOL_MANAGED,
&m_vb,
0);

m_device->CreateIndexBuffer(
36 * sizeof(WORD),
D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16,
D3DPOOL_MANAGED,
&m_ib,
0);

// define unique vertices:
Vertex* vertices;
m_vb->Lock(0, 0, (void**)&vertices, 0);

// vertices of a unit cube
vertices[0] = Vertex(-1.0f, -1.0f, -1.0f);
vertices[1] = Vertex(-1.0f, 1.0f, -1.0f);
vertices[2] = Vertex( 1.0f, 1.0f, -1.0f);
vertices[3] = Vertex( 1.0f, -1.0f, -1.0f);
vertices[4] = Vertex(-1.0f, -1.0f, 1.0f);
vertices[5] = Vertex(-1.0f, 1.0f, 1.0f);
vertices[6] = Vertex( 1.0f, 1.0f, 1.0f);
vertices[7] = Vertex( 1.0f, -1.0f, 1.0f);

m_vb->Unlock();

// define the triangles of the cube:
WORD* indices = 0;
m_ib->Lock(0, 0, (void**)&indices, 0);

// front side
indices[0] = 0; indices[1] = 1; indices[2] = 2;
indices[3] = 0; indices[4] = 2; indices[5] = 3;

// back side
indices[6] = 4; indices[7] = 6; indices[8] = 5;
indices[9] = 4; indices[10] = 7; indices[11] = 6;

// left side
indices[12] = 4; indices[13] = 5; indices[14] = 1;
indices[15] = 4; indices[16] = 1; indices[17] = 0;

// right side
indices[18] = 3; indices[19] = 2; indices[20] = 6;
indices[21] = 3; indices[22] = 6; indices[23] = 7;

// top
indices[24] = 1; indices[25] = 5; indices[26] = 6;
indices[27] = 1; indices[28] = 6; indices[29] = 2;

// bottom
indices[30] = 4; indices[31] = 0; indices[32] = 3;
indices[33] = 4; indices[34] = 3; indices[35] = 7;

m_ib->Unlock();

D3DXVECTOR3 position(0.0f, 0.0f, -5.0f);
D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
D3DXMATRIX v;
D3DXMatrixLookAtLH(&v, &position, &target, &up);

m_device->SetTransform(D3DTS_VIEW, &v);

//
// Set the projection matrix.
//
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj,
D3DX_PI * 0.5f, // 90 - degree
(float)m_width / (float)m_height,
1.0f,
1000.0f);
m_device->SetTransform(D3DTS_PROJECTION, &proj);

//
// Switch to wireframe mode.
//
m_device->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
return true;
}

Display 方法有两项任务：更新场景和绘制场景。想让立方体旋转起来，必须在程序生成的每帧图像中给旋转角一定的增量，从而指定立方体的旋转方式。通过更新每帧图像中立方体的角度，立方体在每帧图像中被微微地旋转，从而产生转动的视觉效果。

bool Direct3DFrame::Display(float timeDelta)
{
if (m_device) {
//
// spin the cube:
//
D3DXMATRIX rx, ry;

// rotate 45 degrees on x-axis
D3DXMatrixRotationX(&rx, 3.14f / 4.0f);

// incremement y-rotation angle each frame
D3DXMatrixRotationY(&ry, m_yRotAngle);
m_yRotAngle += timeDelta;

// reset angle to zero when angle reaches 2PI
if( m_yRotAngle >= 6.28f ) {
m_yRotAngle = 0.0f;
}

// combine x- and y-axis rotation transformations.
D3DXMATRIX p = rx ry;

m_device->SetTransform(D3DTS_WORLD, &p);

//
// draw the scene:
//
m_device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
m_device->BeginScene();

m_device->SetStreamSource(0, m_vb, 0, sizeof(Vertex));
m_device->SetIndices(m_ib);
m_device->SetFVF(Vertex::FVF);

// Draw cube.
m_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);

m_device->EndScene();
m_device->Present(0, 0, 0, 0);
}

return true;
}

m_yRotAngle 表示旋转角度，在 Direct3DFrame 中添加定义，在构造函数中初始化为 0.0f 。
在 Cleanup 中添加内存清理：
    m_vb->Release();
   m_ib->Release();
   m_device->Release();
运行效果：

//
本文由独酌逸醉原创，转载请注明博客链接，谢谢！
小弟初学 Direct3D，文章中如果存在错误，烦请指证，不胜感激！
参考书籍：《DirectX 9.0 3D 游戏开发编程基础》
时间：2011.11.20
//

本文链接

Direct3D 初涉：绘制流水线

2011-11-15T14:46:00Z

绘制流水线(rendering pipeline)：从 3D 场景到 2D 场景，必须实施的一系列运算。

局部坐标系->世界坐标系->观察坐标系->背面消隐->光照->裁剪->投影->视口坐标系->光栅化

1. 局部坐标系(local space)

局部坐标系(local space)或者建模坐标系(modeling space)，是用于建立构成物体的三角形单元列表的坐标系。采用局部坐标系的优势体现在它可以简化建模过程。

个人理解：局部坐标系即以物体本身建模，假如你要为一个茶壶建模，那么局部坐标系的原点可以为茶壶中心；再如你要为一个球体建模，那么局部坐标系的原点可以为球的中心。

2. 世界坐标系 (world space)

将所有建立在局部坐标系上的物体组织在一起构成世界坐标系。将局部坐标系变换到世界坐标系中，称为世界变换(world transform)。

Direct3D 通过 IDirect3DDevice9::SetTransform 方法进行变换。

3. 观察坐标系

为了简化运算，我们将摄像头变换至世界坐标系的原点，并将其旋转，使摄像机的光轴与世界坐标系 z 轴方向一致。(个人理解：也就是相当于人站在坐标原点向 z 轴方向看) 这种变换称为取景变换(view space transformation)，变换后的几何体位于观察坐标系(view space)中。

Direct3D 由 D3DXMatrixLookAtLH 函数计算得到。

4. 背面消隐

每个多边形都有两个侧面，其中一个侧面标记为正面(front side)，另一个侧面标记为背面(back side)。通常多边形的背面是不可见的，这是由于场景中的多数物体都是封闭体。正面朝向的多边形称为正面朝向(front facing)多边形，正面偏离摄像机的多边形称为背面朝向(back facing)多边形。

正面朝向多边形遮挡了位于其后面的背面朝向多边形。 Direct3D 利用这一点将背面朝向的多边形加以剔除，这称为背面消隐。

为了实现背面消隐，Direct3D 需要区分哪些多边形是正面朝向的，哪些多边形是背面朝向的。默认状态下，Direct3D 认为顶点排列顺序为顺时针(观察坐标系中)的三角形单元是正面朝向的，顶点排列顺序是逆时针(观察坐标系中)的三角形单元式背面朝向的。

如果由于某些原因默认的消隐方式不能满足应用的要求，我们可通过修改绘制状态(render state) D3DRS_CULLMODE 来达到目的。

5. 光照

光源是在世界坐标系中定义的，但必须经过取景变换至观察坐标系方可使用。在观察坐标系中，光源照亮了场景中的物体，从而可以获得较为逼真的显示效果。

6. 裁剪

将位于视域体以外的几何体剔除掉，这个过程称为裁剪(clipping)。个人理解：类似于用人的眼睛看外界事物，有些物体可以完全被看见(我面前的显示器)，有些物体完全看不见(我背后的门)，有些物体可以看到一部分(我右边的床，我只能看到床头)。

7. 投影

在观察坐标系中，我们的任务是获取 3D 场景的 2D 表示。从 n 维变换为 n-1 维的过程称为投影。实现投影的方式有很多，我们只对其中一种感兴趣，即透视投影(perspective projection)。透视投影会产生“透视缩短”(foreshortenning)的视觉效果，即近大远小。

Direct3D 使用 D3DXMatrixPerspectiveFovLH 来创建一个投影矩阵。

8. 视口变换

视口变换(view port transform) 的任务是将顶点坐标从投影窗口转换到屏幕的一个矩形区域，该矩形区域称为视口(viewport)。个人理解：视口就是电脑桌面上的窗体而已。

Direct3D ，视口用结构 D3DVIEWPORT9 来表示。

9. 光栅化

顶点坐标变换为屏幕坐标后，我们就有了一个 2D 三角形单元的列表。光栅化(rasterization)的任务是为了绘制每个三角形单元，如何计算构成三角形单元的每个像素的颜色值。

光栅化过程的计算量非常大，我们应借助专用图形卡的加速功能。光栅化的最终结果是现实屏幕上的一幅 2D 图像。

/*******************************************************/

** 本文由独酌逸醉原创，转载请注明博客链接，谢谢！

** 小弟初学 Direct3D，文章中如果存在错误，烦请指证，不胜感激！

** 参考书籍：《DirectX 9.0 3D 游戏开发编程基础》

** 时间：2011.11.15

/*******************************************************/

本文链接

Direct3D 初涉： Direct3D 框架的搭建

2011-10-27T16:22:00Z

《DirectX 9.0 3D 游戏开发编程基础》一书中在第 II 部分第一章初始化 Direct3D 中提供了一个DirectX 框架（所谓框架，只是一个支撑，在这个支撑下，可以添加代码实现相应的操作），但是整体感觉比较乱（不知道您是否有这种感觉？）。我将Direct3D 初始化、资源设置与清除、显示等操作全部封装到一个类中，希望可以让代码不再杂乱，便于理解。

Direct3D 的初始化过程可分解为如下步骤：

（1）获取接口 IDirect3D9 的指针。该接口用于获取系统中物理硬件设备的信息并创建接口 IDirect3DDevce9 ，该接口是一个 C++ 对象，代表了我们用来显示 3D 图形的物理硬件设备。

（2）检查设备性能（D3DCAPS9），判断主显卡（primary display adapter 或者 primary graphics card ）是否支持硬件顶点运算。为了创建接口 IDirect3DDevice9，我们必须明确显卡是否支持该功能。

（3）初始化 D3DPRESENT_PARAMETERS 结构的一个实例。该结构由许多数据成员组成，我们可以通过这些变量来指定即将创建接口 IDirect3DDevice9 的特性。

（4）利用已初始化的 D3DPRESENT_PARAMETER 结构创建 IDirect3DDevice9 对象（一个 C++ 对象代表了我们用来显示 3D 图形的物理硬件设备）。

源代码分为三个文件：Direct3DFrame 类的头文件(Direct3DFrame.h)与源文件(Direct3DFrame.cpp)，WinMain所在源文件(WinMain.cpp)。以下是代码：

// file.Direct3DFrame.h

#pragma once
#include <d3d9.h>
#include <d3dx9.h>

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

// Direct3D 框架类，完成 Direct3D 的初始化等操作
class Direct3DFrame
{
public:
Direct3DFrame(
LPCWSTR wndName,
HINSTANCE hInstance,
int width, int height,
bool windowed,
D3DDEVTYPE deviceType);

~Direct3DFrame(void);

public:
bool InitD3D();
// Setup() 设置资源，Cleanup() 清除资源
bool Setup();
void Cleanup();
bool Display(float timeDelta);

public:
static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg,
WPARAM wParam, LPARAM lParam);
int EnterMsgLoop();

private:
bool CreateWin32Window(HWND& hWnd);

private:
LPCWSTR m_wndName; // 窗口名称
HINSTANCE m_hInstance; // 应用程序实例句柄
int m_width; // 后台缓冲大小
int m_height;
bool m_windowed; // 窗口模式 (true) 或者全屏模式 (false)
D3DDEVTYPE m_deviceType; // HAL or REF
IDirect3DDevice9* m_device;
};

// file. Direct3DFrame.cpp

#include "Direct3DFrame.h"

Direct3DFrame::Direct3DFrame(
LPCWSTR wndName,
HINSTANCE hInstance,
int width, int height,
bool windowed,
D3DDEVTYPE deviceType)
{
m_wndName = wndName;
m_hInstance = hInstance;
m_width = width;
m_height = height;
m_windowed = windowed;
m_deviceType = deviceType;
this->m_device = NULL;
}

Direct3DFrame::~Direct3DFrame(void)
{
}

bool Direct3DFrame::InitD3D()
{
HWND hWnd;
if (!CreateWin32Window(hWnd)) {
return false;
}

// ---- Init D3D:

HRESULT hr = 0;

// Step 1: Create the IDirect3D9 object.
/* IDirect3D9 用途:
* (1) 设置枚举 ( device enumeration )
* ->指获取系统中可用的每块图形卡的性能、显示模式(display mode)、格式及其他信息
* (2) 创建 IDirect3DDevice9 类型
*/
IDirect3D9* d3d9 = NULL;
d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

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

// Step 2: Check for hardare vp.
D3DCAPS9 caps;
d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, m_deviceType, &caps);

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

// Step3 : Fill out the D3DPRESENT_PARAMETERS structure.
D3DPRESENT_PARAMETERS d3dpp;
d3dpp.BackBufferWidth = m_width;
d3dpp.BackBufferHeight = m_height;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality = 0;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hWnd;
d3dpp.Windowed = m_windowed;
d3dpp.EnableAutoDepthStencil = true;
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
m_deviceType, // device type
hWnd, // window assocated with device
vp, // vertex processing
&d3dpp, // present parameters
&m_device); // return created device

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

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

d3d9->Release(); // done with d3d9 object

return true;
}

LRESULT CALLBACK Direct3DFrame::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);
}

bool Direct3DFrame::CreateWin32Window(HWND& hWnd)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = m_hInstance;
wc.hIcon = LoadIcon(0, IDI_APPLICATION);
wc.hCursor = LoadCursor(0, IDC_ARROW);
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = m_wndName;

if (!RegisterClass(&wc)) {
::MessageBox(0, TEXT("RegisterClass() - FAILED"), 0, 0);
return false;
}

hWnd = ::CreateWindow(m_wndName, m_wndName,
WS_OVERLAPPEDWINDOW^WS_MAXIMIZEBOX , 0, 0, m_width, m_height,
0, 0, m_hInstance, 0);

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

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

return true;
}

bool Direct3DFrame::Display(float timeDelta)
{
if (m_device) {
// Instruct the device to set each pixel on the back buffer black -
// D3DCLEAR_TARGET: 0x00000000 (black) - and to set each pixel on
// the depth buffer to a value of 1.0 - D3DCLEAR_ZBUFFER: 1.0f
m_device->Clear(
0, // pRect 数组中矩形数目
0, // 所要执行清除操作的屏幕矩形数组，选择性清除区域
D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, // 指定要清除的表面
0x00000000, // 指定将绘制目标设置为何种颜色
1.0f, // 深度缓存所要设置的值
0); // 模板缓存所要设定的值

// 提交后台缓存
m_device->Present(0, 0, 0, 0);
}

return true;
}

int Direct3DFrame::EnterMsgLoop()
{
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;
this->Display(timeDelta);
lastTime = currTime;
}
}

return msg.wParam;
}

bool Direct3DFrame::Setup()
{
return true;
}

void Direct3DFrame::Cleanup()
{
m_device->Release();
}

// file.WinMain.cpp

#include "Direct3DFrame.h"

int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE prevInstance,
PSTR cmdLine,
int showCmd)
{
Direct3DFrame d3dFrame(TEXT("Direct3DFrame"), hInstance,
640, 480, true, D3DDEVTYPE_HAL);

if (!d3dFrame.InitD3D()) {
::MessageBox(0, TEXT("InitD3D() - FAILED"), 0, 0);
return 0;
}

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

d3dFrame.EnterMsgLoop();
d3dFrame.Cleanup();

return 0;
}

运行后截图：

知识点：

1. HAL 与 REF （Direct3D 和图形设备之间的中间环节）

HAL(Hardware Abstraction Layer，硬件抽象层)，指示设备完成某些操作的设备相关的代码集，按照这种方式，Direct3D 就可不必了解设备的具体细节，其规范（specification）的制定便可独立于具体的硬件。

REF(Reference Rasterizer Deivce)，以软件运算的方式完全支持 Direct3D API。借助 REF 设备，可在代码中使用那些不为当前硬件所支持的特性，并对这些特性进行测试。REF 速度十分缓慢，在测试以外的其他场合都很不实用。

在程序代码中，使用 D3DDEVTYPE 枚举类型来标识 HAL 设备与 REF 设备。HAL 设备使用 D3DDEVTYPE_HAL ，REF 设备用 D3DDEVTYPE_REF 来指定。

2. 顶点运算、检验硬件顶点运算

在 Direct3D 中，可用两种不同的方式进行顶点运算(Vertex Processing), 即软件顶点运算 (software vertex process) 和硬件顶点运算 (hardare vertex processing)。软件顶点运算总是会被支持的，所以总是可以使用的。而硬件顶点运算只有得到图形卡的支持方可使用。应该优先使用硬件顶点运算，因为如果使用硬件专有的加速功能，程序的执行速度将会比软件运算方式快得多。而且，在硬件中进行顶点运算，可以不占用资源，也就意味着 CPU 可被解放出来进行其他运算。

创建一个代表主显卡的 IDirect3DDevice9 类型对象时，必须指定使用该对象进行顶点运算的类型。如果可以，我们希望使用硬件顶点运算，但是由于并非所有的显卡都支持硬件顶点运算，我们必须首先检查图形卡是否支持该类型的运算。

使用 GetDeviceCaps 方法来检查设备性能。

3. D3DPRESENT_PARAMETERS 结构

4. IDirect3DDevice9::Clear 方法

/*******************************************************/

** 本文由独酌逸醉原创，转载请注明博客链接，谢谢！

** 小弟初学 Direct3D，文章中如果存在错误，烦请指证，不胜感激！

** 参考书籍：《DirectX 9.0 3D 游戏开发编程基础》

** 时间：2011.10.28

/*******************************************************/

本文链接

Direct3D 初涉：必备的数学基础

2011-10-11T13:31:00Z

1. 齐次坐标齐次坐标的理解——BigCoder

2. 为什么Direct3D要采用四维坐标？矩阵运算------四维齐次空间 —— Guymon

3. 向量的数量积与向量积
数量积
向量积

未完待续……

/*******************************************************/
* 本文由独酌逸醉整理，部分内容来源于互联网
* 转载请注明博客链接，谢谢！
* 时间：2011.10.10
/*******************************************************/

本文链接

Unicode 与 ANSI 字符串转换

2011-10-10T09:56:00Z

如果你经常在 Windows 平台下写程序的话，我相信你一定会遇到 Unicode 与 ANSI 字符串之间的转换（string <-> CString之类的）。

要想实现 Unicode 和 ANSI 之间的转换，我之前的一篇文章中简单的介绍了一下：VS 系列 CString 转 string 方法，其实文中的方法是我蒙出来的，简单有效，至于原理我也不甚明了。大部分人使用的是以下两种函数来实现两者的转换：

（1） ANSI -> Unicode

int MultiByteToWideChar(
__in UINT CodePage, // 标识了与多字节关联的一个代码页值
__in DWORD dwFlags, // 允许我们进行额外的控制，它会影响带变音符号（比如重音）的字符。但是一般情况下不适用，赋为 0 即可。
__in LPCSTR lpMultiByteStr, // 参数指定要转换的字符串
__in int cbMultiByte, // 指定要转换串长度的长度（字节数），如果参数值是-1，函数便可自动判断源字符串的长度
__out LPWSTR lpWideCharStr, // 指定转换后Unicode版本的字符串内存地址
__in int cchWideChar // 指定 lpWideCharStr 缓冲区的最大长度。
// 如果传入0，函数不会进行转换，而是返回一个宽字符数（包括终止字符'\0'），
// 只有当缓冲区能够容纳该数量的宽字符时，转换才会成功。
);

转换步骤：

（1）调用 MultiByteToWideChar，为 pWideCharStr 参数传入 NULL，为cchWideChar 参数传入 0，为 cbMultiByte 参数传入 -1 。

（2）分配一块足以容纳转换后的 Unicode 字符串的内容。它的大小是上一个 MultiByteToWideChar 调用的返回值乘以 sizeof(wchar_t) 。

（3）再次调用MultiByteToWideChar，这一次将缓冲区地址作为 pWideCharStr 参数的值传入，将第一次 MultiByteToWideChar 调用的返回值乘以 sizeof(wchar_t) 后得到大小作为 cchWideChar 参数的值传入。

（4）使用转换后的字符串

（5）释放 Unicode 字符串占用的内存块。

示例代码：

/*
* Subject: Convert ANSI to Unicode
* IDE: Visual Studio 2008
* Auther: http://www.cnblogs.com/chinazhangjie
* Mail: chinajiezhang@gmail.com
* Date:2011/10/10
*/

#include <stdio.h>
#include <windows.h>

int main()
{
char *pANSI = "ANSI to Unicode, ANSI 转换到 Unicode";
wchar_t *pUnicode = NULL;
int nWideCharLen = 0;

// step.1
nWideCharLen = MultiByteToWideChar(CP_ACP, 0, pANSI, -1, NULL, 0);
printf("nWideCharLen = %d\n", nWideCharLen);

// step.2
pUnicode = (wchar_t*)malloc(nWideCharLen * sizeof(wchar_t));

// step.3
MultiByteToWideChar(CP_ACP, 0, pANSI, -1, pUnicode, nWideCharLen * sizeof(wchar_t));

// step.4
MessageBoxW(NULL, pUnicode, TEXT("Unicode"), 0);

// step.5
free(pUnicode);

return 0;
}

（2） Unicode->ANSI

int WideCharToMultiByte(
__in UINT CodePage, // 标志了要与新转换的字符串关联的代码页
__in DWORD dwFlags, // 制定额外的转换控制，一般不需要进行这种程度的控制，而为 dwFlag 传入 0
__in LPCWSTR lpWideCharStr, // 指定要转换的字符串的内存地址
__in int cchWideChar, // 指出该字符串的长度，如果传入 -1 ，则由函数来判断字符串的长度
__out LPSTR lpMultiByteStr, // 转换后的缓冲区
__in int cbMultiByte, // 指定 lpMultiByteStr 缓冲区的最大大小（字节数），如果传入 0 ，函数返回该目标缓冲区需要的大小
__in LPCSTR lpDefaultChar,
__out LPBOOL lpUsedDefaultChar // 宽字符字符串中，如果至少有一个字符不能转换为对应的多字节形式，函数就会把这个变量设为 TRUE 。如果所有字符都能成功转换，就会把这个变量设为 FALSE。通常将此函数传入 NULL 值。
);

只有一个字符在 uCodePage 制定的代码页中没有对应的表示时，WideCharToMultiByte 才会使用后两个参数。在遇到一个不能转换的字符时，函数便使用 pDefaultChar 参数指向的字符。如果这个参数指向为 NULL ，函数就会使用一个默认的字符。这个默认的值通常是一个问号。这对文件操作是非常危险的，因为问号是一个通配符。

转换步骤和 ANSI -> Unicode 相似，故不做赘述。

示例代码：

/*
* Subject: Convert Unicode to ANSI
* IDE: Visual Studio 2008
* Auther: http://www.cnblogs.com/chinazhangjie
* Mail: chinajiezhang@gmail.com
* Date:2011/10/10
*/

#include <stdio.h>
#include <windows.h>

int main()
{
wchar_t *pUnicode = TEXT("Convert Unicode to ANSI, Unicode 转换为 ANSI");
char *pANSI = NULL;
int nByte = 0;

// step.1
nByte = WideCharToMultiByte(CP_ACP, 0, pUnicode, -1, NULL, 0, NULL, NULL);

// step.2
pANSI = (char*)malloc(nByte);

// step.3
WideCharToMultiByte(CP_ACP, 0, pUnicode, -1, pANSI, nByte, NULL, NULL);

// step.4
printf_s("ANSI = %s\n", pANSI);

// step.5
free(pANSI);

return 0;
}

/*******************************************************/
* 本文由独酌逸醉原创，转载请注明博客链接，谢谢！
* 参考书籍：《Windows核心编程（第5版）》
* 时间：2011.10.10
/*******************************************************/

本文链接

MFC 框架技术简单研讨

2011-09-19T16:45:00Z

引：

这篇博客是根据昨天的我们团队技术研讨会，我所讲的部分的内容（这句话读起来好纠结啊），由幻灯片改变而成的。因为我们团队在界面设计上缺陷很大，而我想对强一些（当然是我们团队之中了，我们都是大学生，所以我也强不到哪儿去）。为什么不直接讲MFC技术，而要简单讲框架。原因如下：个人认为MFC难学难用在于你不了解MFC的架构，如果你稍微有一些了解的话，用起来也就没那么复杂了。框架类型的东西往往如此，为程序员隐藏了太多的细节，通常都是知其然而不知其所以然。我准备了好长时间，但是讲解效果不好。意料之外，情理之中。一来看框架就要看源码，一个框架源码的复杂程度可想而知；二来大家都关心一些实用的技术，表面性东西，比如怎么实现窗口透明之类的技术，而不愿意花费时间在框架性东西上。这是一件很悲剧的事情……，我们园子里有大牛，当然我相信有很多学生，我想告诉大家的是学技术要专一要往深里学，不要浮躁，踏踏实实的。废话都多了……

我要写一点声明，上面废话可以不看，声明一定要看。

（1）博客参考了侯俊杰老师的《深入浅出MFC》，我用的是Visual Studio 2008，在源码上有一些不同。我学习了他分析问题的方法，在一些我自己搞不定的问题上，我摘了他书的原话。

（2）除本文之外，其他链接跳转文章是我直接从wps doc中直接复制过去，难免有一些失真。我本想一点一点校正格式，但是由于文章比较长，所以格式上会有一些混乱。这一点请大家见谅。

（3）小弟才疏学浅。如果看到本文的您是高手的话，您一定会发现文章的很多错误，希望您给我指出来。言辞表达不正，也欢迎您斧正。

（4）文章由幻灯片改编，衔接可能不流畅。

（4）本文为独酌逸醉原创，如果您需要转载的话，一定要标明文章参考了侯俊杰先生的《深入浅出MFC》，我个人事小。

正文：

第一讲 Win32 App 和 MFC Framework

Win32 App 程序生与死：
（1）注册窗口
（2）创建窗口
（3）显示并更新窗口
（4）消息循环( WM_QUIT 结束循环)
（5）退出

实例代码：

#include <windows.h>

ATOM RegisterWndClass( HINSTANCE hInstance , LPCWSTR className);
LRESULT CALLBACK WindowProc(HWND ,UINT, WPARAM, LPARAM);

/* WinMain parameters:
* hInstance : A handle to the current instance of the application.
* hPrevInstance : A handle to the previous instance of the application.
* This parameter is always NULL. ...
* lpCmdLine : The command line for the application, excluding（不包括） the program name.
* To retrieve（获取） the entire（全部） command line, use the GetCommandLine function.
* nCmdShow : Controls how the window is to be shown. eg. SW_HIDE, SW_MAXIMIZE
*
* return value: If the function succeeds, terminating when it receives a WM_QUIT message,
* it should return the exit value contained in that message's wParam parameter.
* If the function terminates before entering the message loop,
* it should return zero.
*/
int CALLBACK WinMain(
__in HINSTANCE hInstance,
__in HINSTANCE hPrevInstance,
__in LPSTR lpCmdLine,
__in int nCmdShow )
{
// （1）注册窗口
LPCWSTR className = TEXT("FirstWnd");
if (!RegisterWndClass(hInstance, className)) {
::MessageBox(NULL, TEXT("Register class failed"),
TEXT("Error"), MB_OK | MB_ICONEXCLAMATION);
return 0;
}

// （2）创建窗口
HWND hWnd; // 窗口句柄
hWnd = CreateWindow(
className, // 窗口类名称
TEXT("A simple Win32 Application"), // 窗口标题
WS_OVERLAPPEDWINDOW, // 窗口风格
100, // 窗口位置的 x 坐标， CW_USEDEFAULT
100, // 窗口位置的 y 坐标， CW_USEDEFAULT
400, // 窗口的宽度， CW_USEDEFAULT
300, // 窗口的高度， CW_USEDEFAULT
NULL, // 父窗口句柄
NULL, // 菜单句柄
hInstance, // 应用程序句柄
NULL); // 窗口创建数据指针， WM_CREATE lParam
if (!hWnd) {
::MessageBox(NULL, TEXT("Register class failed"),
TEXT("Error"), MB_OK | MB_ICONEXCLAMATION);
return 0;
}

// （3）显示并更新窗口
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);

// （4）进入消息循环
MSG msg;
// 如果 msg 消息为 WM_QUIT ， GetMessage 返回为 0 ，退出循环
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}

// 程序结束
return msg.wParam;
}

// 注册窗口
ATOM RegisterWndClass( HINSTANCE hInstance , LPCWSTR className)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS; //
wc.lpfnWndProc = (WNDPROC)WindowProc; // A pointer to the window procedure.
wc.cbClsExtra = 0; //
wc.cbWndExtra = 0; //
wc.hInstance = hInstance; //
wc.hIcon = LoadIcon( hInstance, IDI_APPLICATION ); // A handle to the class icon.
wc.hCursor = LoadCursor( NULL, IDC_ARROW ); // A handle to the class cursor.
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); // A handle to the class background brush.
wc.lpszMenuName = NULL; // The resource name of the class menu,
wc.lpszClassName = className; // A pointer to a null-terminated string or is an atom.
return RegisterClass( &wc );
}

// 窗口过程
LRESULT CALLBACK WindowProc(
__in HWND hWnd, // A handle to the window.
__in UINT uMsg, // The message.
__in WPARAM wParam, // Additional message information
__in LPARAM lParam // Additional message information
)
{
HDC hDC;
PAINTSTRUCT ps;

switch (uMsg)
{
case WM_PAINT:
hDC = BeginPaint(hWnd, &ps);
RECT rc;
rc.bottom = 100;
rc.left = 100;
rc.right = 300;
rc.top = 400;
::SetTextColor(hDC, RGB(255, 0, 0));
SetBkMode(hDC, TRANSPARENT);
::TextOut(hDC, 30, 30, TEXT("This is my first Win32 App !"),
strlen("This is my first Win32 App !"));
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
MessageBox(NULL, TEXT("Window will be closed"), TEXT("Message"), MB_OK);
PostQuitMessage(0);
break;
case WM_LBUTTONDOWN:
MessageBox(NULL, TEXT("left button down"), TEXT("Message"), MB_OK);
break;
default:
break;
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}

思考：

1. Console App 入口点是 main ； Win32 App 入口点是 WinMain ；那么 MFC 入口点在哪里？
2. 相对简洁的 Win32 App ，复杂的 MFC Framework 强大在哪里？
3. 大量的虚函数、复杂的宏，或者说 MFC Framework 背着我们用户做了哪些事情？

第二讲 MFC 六大关键技术

2.1 MFC 程序的初始化过程
2.2 RTTI（运行时类型识别）
2.3 Dynamic Creation（动态创建）

C++动态创建对象的困难在于，无法在程序执行期间，根据动态获得的一个类名称，要求程序产生一个对象。
在 RTTI 中，CRuntimeClass 对象记录了类的 CreateObject 函数，在程序执行期间获得类名称，遍历链表找到名称匹配项，调用 CreateObject ，产生新对象。

C++ 动态类型相关
（1） typeid 运算子
（2）宏 [ RTTI ]
（3）模板实参演绎 [STL iterator_traits]
C++在动态对象创建上一直是一个缺陷，据我说知，C# 有一项技术支持（反射）。
2.4 Persistence（永久保存）机制

Persistence：将对象永久保留下来（写入文件），Persistence 机制，也就是Serialize（数据读写）。

Persistence 简介

（1） MFC 提供 CObList 、CDWordArray 等类来支持 Persistence 。
（2） MFC 利用
DECLARE_SERIAL/IMPLIMENT_SERIAL
两个宏来实现 Persistence 机制。
（3）个人觉得，Persistence 只不过限定了一种文件格式来存储。普通程序员也可以很快设定一种文件格式来存储，不用受框架的限制，灵活性高且调试方便。
2.5 Message Mapping（消息映射）与Command Routing（命令传递）

Windows 程序本质系事借着消息来维持脉动（消息驱动），并以 WM_ 开头的常量开表示。
消息循着 Application Framework 规定的路线，游走于各个对象之间，直到找到它的归宿（消息处理函数）。找不到的话，Framework 最终把它交给 :DefWindowProc 函数处理。

MFC 消息分类

命令消息（WM_COMMAND）：“使用者命令程序做些操作”。凡是 UI 对象产生的消息都是这种命令消息，可能来自菜单或者加速键或工具栏按钮，并且都以 WM_COMMAND 呈现。SDK 程序主要靠 wParam 识别之，MFC 程序则主要靠菜单项的识别码（ menu ID）识别——其实两者是一样的。
凡是派生自 CCmdTarget 的类，都由资格接受命令消息。

标准消息：除 WM_COMMAND 之外，任何以 WM_ 开头的都算这一类，均可接受此消息。
Control Notification：由控件产生，为的是向父类窗口通知某种情况。例如当你在 ListBox 上选择其中一个项目，ListBox 就会产生 LBN_SELCHANGE 传送给父窗口。这类消息是以 WM_COMMAND 形式呈现。

第三讲 MFC 多线程技术简介

MFC 线程分类：Work Thread，UI Thread
区别：Work Thread 没有消息循环
UI Thread 有自己的消息和队列循环
Work Thread：通常用来执行后台计算和维护任务，如冗长的计算过程，打印机的后台打印等
UI Thread：一般用于处理独立于其他线程执行之外的用户输入，响应用户及系统所产生的事件和消息等。

4.1 Work Thread的创建

CWinThread*
AfxBeginThread(AFX_THREADPROC       pfnThreadProc,
                      LPVOID pParam,
                      nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES   lpSecurityAttrs=NULL);
线程函数类型：
UINT ExecutingFunction(LPVOID pParam);

4.2 UI Thread的创建

CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
                      int nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

具体请看：多线程编程之二——MFC中的多线程开发

第五讲 MFC 常用技术

略（幻灯片中讲了一些，但是比较杂碎，就不在这里列出来了……）

<本文完>

2011-09-20

本文链接

MFC RTTI 探究

2011-09-19T16:37:00Z

MFC RTTI 探究

张杰

2011-09-17

声明

本文由张杰原创，参考了侯俊杰先生的《深入浅出MFC》，源码摘自 Microsoft Visual Studio 9.0\VC。

个人能力有限，文章必定存在很多错误。我的邮箱是：chinajiezhang@gmail.com chinajiezhang@163.com 欢迎您来邮件斧正。当然您也可以加我 msn: chinazhangjie@hotmail.com 交流。

本文可供传播、交流、学习使用，但请不要用于商业用途。转载请标明此声明，谢谢您的合作。

DECLARE_DYNCREATE 和 IMPLEMENT_DYNCREATE

查看DECLARE_DYNCREATE 定义（c:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include\afx.h）：

#define DECLARE_DYNCREATE(class_name) \

DECLARE_DYNAMIC(class_name) \

static CObject* PASCAL CreateObject();

查看DECLARE_DYNAMIC定义（c:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include\afx.h）：

#define DECLARE_DYNAMIC(class_name) \

protected: \

static CRuntimeClass* PASCAL _GetBaseClass(); \

public: \

static const CRuntimeClass class##class_name; \

static CRuntimeClass* PASCAL GetThisClass(); \

virtual CRuntimeClass* GetRuntimeClass() const; \

不再有宏了，我们找个例子将代码展开看看效果（创建 MFC 单文档，命名为：FirstMFCDemo）：

在FirstMFCDemoDoc.h下有行代码：

DECLARE_DYNCREATE(CFirstMFCDemoDoc)

展开代码为：

protected:

static CRuntimeClass* PASCAL _GetBaseClass();

public:

static const CRuntimeClass classCFirstMFCDemoDoc;

static CRuntimeClass* PASCAL GetThisClass();

virtual CRuntimeClass* GetRuntimeClass() const;

static CObject* PASCAL CreateObject();

先不管代码的具体含义，把 IMPLEMENT_DYNCREATE 宏定义看了再说（c:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include\afx.h）：

#define IMPLEMENT_DYNCREATE(class_name, base_class_name) \

CObject* PASCAL class_name::CreateObject() \

{ return new class_name; } \

IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, 0xFFFF, \

class_name::CreateObject, NULL)

继续查看IMPLEMENT_RUNTIMECLASS定义（c:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include\afx.h）：

#define IMPLEMENT_RUNTIMECLASS(class_name, base_class_name, wSchema, pfnNew, class_init) \

CRuntimeClass* PASCAL class_name::_GetBaseClass() \

{ return RUNTIME_CLASS(base_class_name); } \

AFX_COMDAT const CRuntimeClass class_name::class##class_name = { \

#class_name, sizeof(class class_name), wSchema, pfnNew, \

&class_name::_GetBaseClass, NULL, class_init }; \

CRuntimeClass* PASCAL class_name::GetThisClass() \

{ return _RUNTIME_CLASS(class_name); } \

CRuntimeClass* class_name::GetRuntimeClass() const \

{ return _RUNTIME_CLASS(class_name); }

查看RUNTIME_CLASS和_RUNTIME_CLASS宏定义：

#define RUNTIME_CLASS(class_name) \

(class_name::GetThisClass())

#define _RUNTIME_CLASS(class_name) \

((CRuntimeClass*)(&class_name::class##class_name))

在 FirstMFCDemoDoc.cpp 找到代码：

IMPLEMENT_DYNCREATE(CFirstMFCDemoDoc, CDocument)

展开后为：

CObject* PASCAL CFirstMFCDemoDoc::CreateObject() \

{ return new CFirstMFCDemoDoc; } \

CRuntimeClass* PASCAL CFirstMFCDemoDoc::_GetBaseClass() \

{ return CDocument::GetThisClass(); } \

AFX_COMDAT const CRuntimeClass CFirstMFCDemoDoc::classCFirstMFCDemoDoc = {

#CFirstMFCDemoDoc, sizeof(class CFirstMFCDemoDoc), 0xFFFF, CFirstMFCDemoDoc::CreateObject, \

&CFirstMFCDemoDoc::_GetBaseClass, NULL, NULL }; \

CRuntimeClass* PASCAL CFirstMFCDemoDoc::GetThisClass() \

{ return (CRuntimeClass*)(&CFirstMFCDemoDoc::classCFirstMFCDemoDoc); } \

CRuntimeClass* CFirstMFCDemoDoc::GetRuntimeClass() const \

{ return (CRuntimeClass*)(&CFirstMFCDemoDoc::classCFirstMFCDemoDoc); }

好乱的团代码啊，我们来理理：

DECLARE_DYNCREATE 和 IMPLEMENT_DYNCREATE为类 CFirstMFCDemoDoc 添加了3个静态函数1个虚函数1静态CRuntimeClass 类型常量，以及代码实现体。分别为：

public:

virtual

CObject* PASCAL CFirstMFCDemoDoc::CreateObject()

{

return new CFirstMFCDemoDoc;

}

protected:

static

CRuntimeClass* PASCAL CFirstMFCDemoDoc::_GetBaseClass()

{

return CDocument::GetThisClass();

}

static

AFX_COMDAT const CRuntimeClass

CFirstMFCDemoDoc::classCFirstMFCDemoDoc = {

#CFirstMFCDemoDoc,

sizeof(class CFirstMFCDemoDoc),

0xFFFF,

CFirstMFCDemoDoc::CreateObject,

&CFirstMFCDemoDoc::_GetBaseClass,

NULL,

NULL

};

CRuntimeClass* PASCAL CFirstMFCDemoDoc::GetThisClass()

{

return(CRuntimeClass*)(&CFirstMFCDemoDoc::classCFirstMFCDemoDoc);

}

CRuntimeClass* CFirstMFCDemoDoc::GetRuntimeClass() const

{

return(CRuntimeClass*)(&CFirstMFCDemoDoc::classCFirstMFCDemoDoc);

}

想要知道这些代码到底在干什么，就必须了解 CRunTimeClass 是干什么的？废话不说，直接上 CRuntimeClass 源码（c:\Program Files\Microsoft Visual Studio 9.0\VC\atlmfc\include\afx.h）：

struct CRuntimeClass

{

// Attributes

LPCSTR m_lpszClassName;

int m_nObjectSize;

UINT m_wSchema; // schema number of the loaded class

CObject* (PASCAL* m_pfnCreateObject)(); // NULL => abstract class

#ifdef _AFXDLL

CRuntimeClass* (PASCAL* m_pfnGetBaseClass)();

#else

CRuntimeClass* m_pBaseClass;

#endif

// Operations

CObject* CreateObject();

BOOL IsDerivedFrom(const CRuntimeClass* pBaseClass) const;

// dynamic name lookup and creation

static CRuntimeClass* PASCAL FromName(LPCSTR lpszClassName);

static CRuntimeClass* PASCAL FromName(LPCWSTR lpszClassName);

static CObject* PASCAL CreateObject(LPCSTR lpszClassName);

static CObject* PASCAL CreateObject(LPCWSTR lpszClassName);

// Implementation

void Store(CArchive& ar) const;

static CRuntimeClass* PASCAL Load(CArchive& ar, UINT* pwSchemaNum);

// CRuntimeClass objects linked together in simple list

CRuntimeClass* m_pNextClass; // linked list of registered classes

const AFX_CLASSINIT* m_pClassInit;

};

查看 AFX_CLASSINIT 类型定义：

struct AFX_CLASSINIT

{ AFX_CLASSINIT(CRuntimeClass* pNewClass) { AfxClassInit(pNewClass); } };

继续查看 AfxClassInit 定义：

void AFXAPI AfxClassInit(CRuntimeClass* pNewClass)

{

AFX_MODULE_STATE* pModuleState = AfxGetModuleState();

AfxLockGlobals(CRIT_RUNTIMECLASSLIST);

pModuleState->m_classList.AddHead(pNewClass);

AfxUnlockGlobals(CRIT_RUNTIMECLASSLIST);

}

由此看出，AFX_CLASSINIT结构完成了链表的链接操作，我们不做深究。

MFC 每个类基本都有一个 CRuntimeClass 类型的对象，这些对象构成了一个链表。链表的头是谁呢？答案是CObject，它是MFC所有类的祖先类。这个链表记录了类的名称、链表的Next指针、类的基类指针等等操作。我们可以用这些记录来比较，以达到 RTTI 的能力。

我百度了几张图片（事实上，这是《深入浅出MFC》中的图片，至少长的很像，O(∩_∩)O~），便于理解 RTTI ：

好吧，就讲到这里了。能力有限，再深也就看你们的了。

本文链接

博客园_独酌逸醉

此博客已经作废，不再更新

Direct3D 初涉: 光照

3. 顶点法线面法线是一个描述多边形朝向的向量。顶点法线描述构成多边形各个顶点的法线。 Direct3D 需要知道顶点的法线方向，以确定光线到达表示时的入射角。

Direct3D 初涉: 颜色

2. 顶点颜色图元的颜色由构成该图元的顶点的颜色所决定。所以，我们必须为顶点数据结构添加一个表示颜色的数据成员。

Direct3D 初涉： Direct3D 中的绘制

1.2访问顶点缓存使用 Lock 方法来获取指向缓存内容的指针。访问完毕之后，必须对缓存进行解锁(unlock)操作。

1.3 获取顶点缓存和索引缓存的信息使用 GetDesc 方法来获取顶点缓存(D3DVERTEXBUFFER_DESC)和索引缓存(D3DINDEXBUFFER_DESC)的信息。

2. 绘制状态 绘制状态(render state)，几何体的绘制方式。使用 SetRenderState 来指定绘制状态。

Direct3D 初涉：绘制流水线

Direct3D 初涉： Direct3D 框架的搭建

Direct3D 初涉： 必备的数学基础

Unicode 与 ANSI 字符串转换

MFC 框架技术简单研讨

MFC RTTI 探究

3. 顶点法线
面法线是一个描述多边形朝向的向量。顶点法线描述构成多边形各个顶点的法线。 Direct3D 需要知道顶点的法线方向，以确定光线到达表示时的入射角。

2. 顶点颜色
图元的颜色由构成该图元的顶点的颜色所决定。所以，我们必须为顶点数据结构添加一个表示颜色的数据成员。

1.2访问顶点缓存
使用 Lock 方法来获取指向缓存内容的指针。访问完毕之后，必须对缓存进行解锁(unlock)操作。

1.3 获取顶点缓存和索引缓存的信息
使用 GetDesc 方法来获取顶点缓存(D3DVERTEXBUFFER_DESC)和索引缓存(D3DINDEXBUFFER_DESC)的信息。

2. 绘制状态

绘制状态(render state)，几何体的绘制方式。使用 SetRenderState 来指定绘制状态。

Direct3D 初涉：必备的数学基础