DirectX3D游戏开发六 场景光照的实现

    欢迎来到EasyLiu的博客！

    参考：directxtutorial.com DirectX.9.0.3D游戏开发编程基础

    我们之前讲的简单的3D场景都是没有光照的，但是这个和实际的环境是由很大的差距的。在这一节课我们就讲一下怎样为场景添加光照，增强所绘场景的真实感。

    自然界的光照是很复杂的，各种反射、折射等等，游戏中的光照都是尽可能去模拟真实的世界，达到逼真的效果，但是和现实世界还是有差距的！

光的种类
    在Direct3D光照模型中，光源发出的光由三种类型的光组成。
    1、环境光：这种类型的光经由其余物体的表面反射达到物体表面，并照亮整个场景。
    2、漫反射光：这种类型的光沿着特定的方向传播。当它达到某一表面的时候将沿着各个方向均匀反射。由于漫反射的特性，无论从哪个方位观察，表面亮度均相同，所以采用该模型时，无需考虑观察者的位置。这样，漫反射光方程中，只需要考虑光的传播方向以及表面的朝向。表面的朝向就涉及到顶点法线的计算。
    3、镜面光：这种类型的光也沿着特定的方向传播。当它达到某一表面的时候将严格的朝另外一个方向反射。镜面光可用于模拟物体上的高亮点，例如当光线照射到一个抛光的表面所形成的高亮照射。镜面光与其他类型的光相比，计算了要大得多，在Direct3D中镜面光默认是关闭的，开启的方法如下：

g_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, TRUE);

    当然还有一个自发光属性，通过对物体材质Emissive属性设置来实现，使之看起来好像可以自己发光

    材质
    材质就是物体的质地。Direct3D中通过材质定义物体表面对各种颜色光的反射比例，在Direct3D中用结构体D3DMATERIAL9来表示材质：

typedef struct _D3DMATERIAL9 {
D3DCOLORVALUE   Diffuse;        /* Diffuse color RGBA */
D3DCOLORVALUE   Ambient;        /* Ambient color RGB */
D3DCOLORVALUE   Specular;       /* Specular 'shininess' */
D3DCOLORVALUE   Emissive;       /* Emissive color RGB */
float           Power;          /* Sharpness if specular highlight */
} D3DMATERIAL9;

其中，Diffuse,Ambient,Specular分别表示材质表面对漫反射光、环境光以及镜面光的反射率，Emissive表示物体的自发光，Power表示镜面高光点的锐度。

    Direct3D中使用函数SetMaterial对材质进行设置：

g_pd3dDevice->SetMaterial(&mtrl);

    举个例子来说明材质的设置：   

// Set up a material. The material here just has the diffuse and ambient
// colors set to yellow. Note that only one material can be used at a time.
D3DMATERIAL9 mtrl;
ZeroMemory(&mtrl, sizeof(D3DMATERIAL9));
//漫反射光
mtrl.Diffuse.r  = 1.0f;
mtrl.Diffuse.g  = 1.0f;
mtrl.Diffuse.b  = 0.0f;
mtrl.Diffuse.a  = 1.0f;
//环境光
mtrl.Ambient.r = 1.0f;
mtrl.Ambient.g = 0.0f;
mtrl.Ambient.b = 0.0f;
mtrl.Ambient.a = 1.0f;
//镜面反射光
mtrl.Specular.r = 1.0f;
mtrl.Specular.g = 1.0f;
mtrl.Specular.b = 1.0f;
mtrl.Specular.a = 1.0f;
mtrl.Power = 25.0f;
//自发光
//mtrl.Emissive.r = 0.3f;
//mtrl.Emissive.g = 1.0f;
//mtrl.Emissive.b = 0.6f;
//mtrl.Emissive.a = 1.0f;
//设置材质
g_pd3dDevice->SetMaterial(&mtrl);
//使能镜面光
g_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, TRUE);

光源
    Direct3D支持三种类型的光源：点光源、方向光和聚光灯，如下所示：
    


    光源用结构D3DLIGHT9来表示：
    

typedef struct _D3DLIGHT9 {
D3DLIGHTTYPE    Type;            /* Type of light source */
D3DCOLORVALUE   Diffuse;         /* Diffuse color of light */
D3DCOLORVALUE   Specular;        /* Specular color of light */
D3DCOLORVALUE   Ambient;         /* Ambient color of light */
D3DVECTOR       Position;         /* Position in world space */
D3DVECTOR       Direction;        /* Direction in world space */
float           Range;            /* Cutoff range */
float           Falloff;          /* Falloff */
float           Attenuation0;     /* Constant attenuation */
float           Attenuation1;     /* Linear attenuation */
float           Attenuation2;     /* Quadratic attenuation */
float           Theta;            /* Inner angle of spotlight cone */
float           Phi;              /* Outer angle of spotlight cone */
} D3DLIGHT9;

   点光源

    点光源具有颜色与位置属性，没有方向。光照强度会随着距光源中心的距离变大衰减。在具体应用中，可以利用点光源来模拟电灯或精灵。在Direct3D中设置点光源的方式如下：
    

D3DLIGHT9 light;
ZeroMemory(&light, sizeof(D3DLIGHT9));
light.Type = D3DLIGHT_POINT;
light.Position = D3DXVECTOR3(1.0f,1.0f,1.0f);
//漫反射光
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
light.Range = 10.0f;
light.Attenuation0 = 1.0f;
g_pd3dDevice->SetLight(0, &light);//对光源进行注册
g_pd3dDevice->LightEnable(0, TRUE);//使能光照
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE);

    聚光灯

   聚光灯具有颜色、方向和位置。聚光灯由内锥与外锥组成，光照强度由内锥到外锥逐渐衰减。在应用中可以模拟探照灯。由于聚光灯计算量比较大，所以尽量少使用。D3D中设置光源方式如下：
    

<span style="font-size:18px;">D3DLIGHT9 light;
ZeroMemory(&light, sizeof(D3DLIGHT9));
light.Type = D3DLIGHT_SPOT;
light.Position = D3DXVECTOR3(0.0f,0.0f,0.0f);
light.Direction = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
//漫反射光
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
light.Range = 100.0f;
light.Phi = D3DX_PI / 4.0f;
light.Theta = D3DX_PI / 8.f;
light.Falloff = 1.0f;
g_pd3dDevice->SetLight(0, &light);//对光源进行注册
g_pd3dDevice->LightEnable(0, TRUE);//使能光照
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE);</span><span style="font-size:24px;">
</span>

方向光
    方向光具有颜色、方向属性，没有位置。方向光不存在范围，所以，计算量在所以光源中最小。在应用中可以模拟太阳光。在D3D中设置光源的方式如下：
    

D3DXVECTOR3 vecDir;
D3DLIGHT9 light;
ZeroMemory(&light, sizeof(D3DLIGHT9));
//类型：
light.Type = D3DLIGHT_DIRECTIONAL;
//漫反射光
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
//镜面光
light.Specular.r = 1.0f;
light.Specular.g = 1.0f;
light.Specular.b = 1.0f;
light.Specular.a = 1.0f;
//光的方向
vecDir = D3DXVECTOR3(cosf(timeGetTime() / 350.0f),  //光的方向为原点(0,0,0)指向这个点的方向：两点确定一条直线
1.0f,
sinf(timeGetTime() / 350.0f));
//归一化方向
D3DXVec3Normalize((D3DXVECTOR3*)&light.Direction, &vecDir);
//light.Range = 1000.0f; //对于方向光无意义
g_pd3dDevice->SetLight(0, &light);//对光源进行注册
g_pd3dDevice->LightEnable(0, TRUE);//使能光照
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE);

    例子的运行效果如下：
    


    源代码main.c如下：
    

//-----------------------------------------------------------------------------
// File: Lights.cpp
//
// Desc: Rendering 3D geometry is much more interesting when dynamic lighting
//       is added to the scene. To use lighting in D3D, you must create one or
//       lights, setup a material, and make sure your geometry contains surface
//       normals. Lights may have a position, a color, and be of a certain type
//       such as directional (light comes from one direction), point (light
//       comes from a specific x,y,z coordinate and radiates in all directions)
//       or spotlight. Materials describe the surface of your geometry,
//       specifically, how it gets lit (diffuse color, ambient color, etc.).
//       Surface normals are part of a vertex, and are needed for the D3D's
//       internal lighting calculations.
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#pragma comment(lib,"winmm.lib")

#include <Windows.h>
#include <mmsystem.h>
#include <d3dx9.h>
#pragma warning( disable : 4996 ) // disable deprecated warning
#include <strsafe.h>
#pragma warning( default : 4996 )

// define the screen resolution
const  int  SCREEN_WIDTH = 800;
const  int  SCREEN_HEIGHT =800;

//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D9             g_pD3D = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL; // Buffer to hold vertices

// A structure for our custom vertex type. We added a normal, and omitted the
// color (which is provided by the material)
struct CUSTOMVERTEX
{
D3DXVECTOR3 position; // The 3D position for the vertex
D3DXVECTOR3 normal;   // The surface normal for the vertex 法线：因为使用了光照，所以不需要自定义每个顶点的颜色
};

// Our custom FVF, which describes our custom vertex structure
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_NORMAL)

//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D(HWND hWnd)
{
// Create the D3D object.
if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
return E_FAIL;

// Set up the structure used to create the D3DDevice. Since we are now
// using more complex geometry, we will create a device with a zbuffer.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
d3dpp.BackBufferWidth = SCREEN_WIDTH;
d3dpp.BackBufferHeight = SCREEN_HEIGHT;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

//fill D3DCAPS9 struct with the capabilities of the primary display adapter
D3DCAPS9 caps;
g_pD3D->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
//can we use hardware vertex processing?
DWORD vp = 0;
if (caps.DevCaps&D3DDEVCAPS_HWTRANSFORMANDLIGHT)
{
//yes,support hardware vertex processing
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
}
else
{
//no,
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}

// Create the D3DDevice
if (FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
vp,
&d3dpp, &g_pd3dDevice)))
{
return E_FAIL;
}

// Turn off culling
g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);

// Turn on the zbuffer
g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

return S_OK;
}

//-----------------------------------------------------------------------------
// Name: InitGeometry()
// Desc: Creates the scene geometry
//-----------------------------------------------------------------------------
HRESULT InitGeometry()
{
// Create the vertex buffer.
if (FAILED(g_pd3dDevice->CreateVertexBuffer(100 * 2 * sizeof(CUSTOMVERTEX),
0, D3DFVF_CUSTOMVERTEX,
D3DPOOL_DEFAULT, &g_pVB, NULL)))
{
return E_FAIL;
}

// Fill the vertex buffer. We are algorithmically generating a cylinder
// here, including the normals, which are used for lighting.
CUSTOMVERTEX* pVertices;
if (FAILED(g_pVB->Lock(0, 0, (void**)&pVertices, 0)))
return E_FAIL;
for (DWORD i = 0; i < 100; i++)
{
FLOAT theta = (2 * D3DX_PI * i) / (100 - 1);
pVertices[2 * i + 0].position = D3DXVECTOR3(sinf(theta), -1.0f, cosf(theta));
pVertices[2 * i + 0].normal = D3DXVECTOR3(sinf(theta), 0.0f, cosf(theta));
pVertices[2 * i + 1].position = D3DXVECTOR3(sinf(theta), 1.0f, cosf(theta));
pVertices[2 * i + 1].normal = D3DXVECTOR3(sinf(theta), 0.0f, cosf(theta));
}
g_pVB->Unlock();

return S_OK;
}

//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if (g_pVB != NULL)
g_pVB->Release();

if (g_pd3dDevice != NULL)
g_pd3dDevice->Release();

if (g_pD3D != NULL)
g_pD3D->Release();
}

//-----------------------------------------------------------------------------
// Name: SetupMatrices()
// Desc: Sets up the world, view, and projection transform matrices.
//-----------------------------------------------------------------------------
VOID SetupMatrices()
{
// Set up world matrix
D3DXMATRIXA16 matWorld;
D3DXMatrixIdentity(&matWorld);
D3DXMatrixRotationX(&matWorld, timeGetTime() / 500.0f);
g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

// Set up our view matrix. A view matrix can be defined given an eye point,
// a point to lookat, and a direction for which way is up. Here, we set the
// eye five units back along the z-axis and up three units, look at the
// origin, and define "up" to be in the y-direction.
D3DXVECTOR3 vEyePt(0.0f, 3.0f, -5.0f);
D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
D3DXMATRIXA16 matView;
D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);

// For the projection matrix, we set up a perspective transform (which
// transforms geometry from 3D view space to 2D viewport space, with
// a perspective divide making objects smaller in the distance). To build
// a perpsective transform, we need the field of view (1/4 pi is common),
// the aspect ratio, and the near and far clipping planes (which define at
// what distances geometry should be no longer be rendered).
D3DXMATRIXA16 matProj;
D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 4, (FLOAT)SCREEN_WIDTH / (FLOAT)SCREEN_HEIGHT, 1.0f, 100.0f);
g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);
}

//-----------------------------------------------------------------------------
// Name: SetupLights()
// Desc: Sets up the lights and materials for the scene.
//-----------------------------------------------------------------------------
VOID SetupLights()
{
// Set up a material. The material here just has the diffuse and ambient
// colors set to yellow. Note that only one material can be used at a time.
D3DMATERIAL9 mtrl;
ZeroMemory(&mtrl, sizeof(D3DMATERIAL9));
//漫反射光
mtrl.Diffuse.r  = 1.0f;
mtrl.Diffuse.g  = 1.0f;
mtrl.Diffuse.b  = 0.0f;
mtrl.Diffuse.a  = 1.0f;
//环境光
mtrl.Ambient.r = 1.0f;
mtrl.Ambient.g = 0.0f;
mtrl.Ambient.b = 0.0f;
mtrl.Ambient.a = 1.0f;
//镜面反射光
mtrl.Specular.r = 1.0f;
mtrl.Specular.g = 1.0f;
mtrl.Specular.b = 1.0f;
mtrl.Specular.a = 1.0f;
mtrl.Power = 25.0f;
//自发光
//mtrl.Emissive.r = 0.3f;
//mtrl.Emissive.g = 1.0f;
//mtrl.Emissive.b = 0.6f;
//mtrl.Emissive.a = 1.0f;
//设置材质
g_pd3dDevice->SetMaterial(&mtrl);
//使能镜面光
g_pd3dDevice->SetRenderState(D3DRS_SPECULARENABLE, TRUE);
// Set up a white, directional light, with an oscillating direction.
// Note that many lights may be active at a time (but each one slows down
// the rendering of our scene). However, here we are just using one. Also,
// we need to set the D3DRS_LIGHTING renderstate to enable lighting
D3DXVECTOR3 vecDir;
D3DLIGHT9 light;
ZeroMemory(&light, sizeof(D3DLIGHT9));
//类型：
light.Type = D3DLIGHT_DIRECTIONAL;
//漫反射光
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
//镜面光
light.Specular.r = 1.0f;
light.Specular.g = 1.0f;
light.Specular.b = 1.0f;
light.Specular.a = 1.0f;
/*
D3DLIGHT9 light;
ZeroMemory(&light, sizeof(D3DLIGHT9));
light.Type = D3DLIGHT_SPOT;
light.Position = D3DXVECTOR3(0.0f,0.0f,0.0f);
light.Direction = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
//漫反射光
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
light.Diffuse.a = 1.0f;
light.Range = 100.0f;
light.Phi = D3DX_PI / 4.0f;
light.Theta = D3DX_PI / 8.f;
light.Falloff = 1.0f;
g_pd3dDevice->SetLight(0, &light);//对光源进行注册
g_pd3dDevice->LightEnable(0, TRUE);//使能光照
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE);
*/

//光的方向
vecDir = D3DXVECTOR3(cosf(timeGetTime() / 350.0f),  //光的方向为原点(0,0,0)指向这个点的方向：两点确定一条直线
1.0f,
sinf(timeGetTime() / 350.0f));
//归一化方向
D3DXVec3Normalize((D3DXVECTOR3*)&light.Direction, &vecDir);
light.Range = 1000.0f;
g_pd3dDevice->SetLight(0, &light);//对光源进行注册
g_pd3dDevice->LightEnable(0, TRUE);//使能光照
g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, TRUE);

// 打开环境光
g_pd3dDevice->SetRenderState(D3DRS_AMBIENT, 0x00202020);
}

//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
// Clear the backbuffer and the zbuffer
g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
D3DCOLOR_XRGB(0, 0, 255), 1.0f, 0);

// Begin the scene
if (SUCCEEDED(g_pd3dDevice->BeginScene()))
{
// Setup the lights and materials
SetupLights();

// Setup the world, view, and projection matrices
SetupMatrices();

// Render the vertex buffer contents
g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2 * 100 - 2);

// End the scene
g_pd3dDevice->EndScene();
}

// Present the backbuffer contents to the display
g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}

//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: The window's message handler
//-----------------------------------------------------------------------------
LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_DESTROY:
Cleanup();
PostQuitMessage(0);
return 0;
}

return DefWindowProc(hWnd, msg, wParam, lParam);
}

//-----------------------------------------------------------------------------
// Name: WinMain()
// Desc: The application's entry point
//-----------------------------------------------------------------------------
INT WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, INT)
{
UNREFERENCED_PARAMETER(hInst);

// Register the window class
WNDCLASSEX wc =
{
sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L,
GetModuleHandle(NULL), NULL, LoadCursor(NULL,IDC_CROSS), NULL, NULL,
L"D3D Tutorial", NULL
};
RegisterClassEx(&wc);

// Create the application's window
HWND hWnd = CreateWindow(L"D3D Tutorial", L"D3D Tutorial 04: Lights",
WS_DLGFRAME|WS_SYSMENU, 100, 100, SCREEN_WIDTH, SCREEN_HEIGHT,
NULL, NULL, wc.hInstance, NULL);

// Initialize Direct3D
if (SUCCEEDED(InitD3D(hWnd)))
{
// Create the geometry
if (SUCCEEDED(InitGeometry()))
{
// Show the window
ShowWindow(hWnd, SW_SHOWDEFAULT);
UpdateWindow(hWnd);

// Enter the message loop
MSG msg;
ZeroMemory(&msg, sizeof(msg));
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
Render();
}
}
}

UnregisterClass(L"D3D Tutorial", wc.hInstance);
return 0;
}