DirectX基础学习系列4 颜色和光照

4.1颜色表示

RGB颜色：D3DCOLOR  可以用宏D3DCOLOR_ARGB(a,r,g,b)  D3DCOLOR_XRGB(255,r,g,b)

另外一种浮点表示：D3DCOLORVALUE，浮点类型，最小为0 最大为1

4.2顶点颜色

struct ColorVetex

{

float x, y,z;

D3DCOLOR color;

static const DWORD FVF;

}

const DWORD ColorVetex::FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE ;

4.3着色

两种着色方式：shading mode

1flat shading 平面着色：每个图元的像素都被赋予该图元的第一个顶点的颜色

2gourand shading ：各像素的颜色由着色的三个顶点颜色插值决定、

设置着色模式：Device->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_FLAT);

5 光照

5.1光照的组成

1环境光

2漫射光：特定方向，达到表面后均匀反射

3镜面光 ：特定方向，达到表面后严格向另外一个方向反射，形成在一定范围内可看的高亮区域，计算量很大

可以控制开关：Device->SetRenderState(D3DRS_SPECULARENABLE, TRUE);

5.2材质

材质允许定义对各种颜色光的反射比

typedef struct D3DMATERIAL9 {
    D3DCOLORVALUE Diffuse;
    D3DCOLORVALUE Ambient;
    D3DCOLORVALUE Specular;
    D3DCOLORVALUE Emissive;
    float Power;
} D3DMATERIAL9, *LPD3DMATERIAL9;

设置材质属性：HRESULT SetMaterial( CONST D3DMATERIAL9 * pMaterial );

5.3顶点法线

struct ColorVetex

{

float x, y,z;

float _nx,_ny,_nz ;

static const DWORD FVF;

}

const DWORD ColorVetex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL;

注意顶点向量的规范化：Device->SetRenderState(D3DRS_NORMALIZEENABLE, TRUE);

5.4 光源

DX支持的三种光源：点光源，方向光，聚光灯

typedef struct D3DLIGHT9 {
    D3DLIGHTTYPE Type;      //D3DLIGHT_POINT  D3DLIGHT_SPOT  D3DLIGHT_DIRECTIONAL
    D3DCOLORVALUE Diffuse;  //漫反射光颜色
    D3DCOLORVALUE Specular; //镜面反射光颜色
    D3DCOLORVALUE Ambient;  //环境光颜色
    D3DVECTOR Position;     //光源位置，方向光该参数无意义
    D3DVECTOR Direction;    //方向，点光源无意义
    float Range;    //最大光程，方向光无意义
    float Falloff;  //聚光灯从内到外的衰减程度
    float Attenuation0;
    float Attenuation1;
    float Attenuation2; //点光源和聚光灯随距离光强的衰减方式
    float Theta;   // 聚光灯内角
    float Phi;    // 聚光灯外角
} D3DLIGHT9, *LPD3DLIGHT;

光源设置完之后 需要注册，dx维护了一个光源列表

device->SetLight(0,&light);

注册完之后 可以进行控制

device->LightEnable();

5.5场景添加光源的方法：

1启用光照

2创建材质，设置材质

3创建光源，打开光源

4启用其余光源

代码：

#include "d3dUtility.h"

//

// Globals

//

IDirect3DDevice9* Device = 0; 

const int Width  = 640;

const int Height = 480;

IDirect3DVertexBuffer9* Pyramid = 0;

//

// Classes and Structures

//

struct Vertex

{

    Vertex(){}

    Vertex(float x, float y, float z, float nx, float ny, float nz)

    {

        _x  = x;  _y  = y;    _z  = z;

        _nx = nx; _ny = ny; _nz = nz;

    }

    float  _x,  _y,  _z;

    float _nx, _ny, _nz;

    static const DWORD FVF;

};

const DWORD Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL;

//

// Framework Functions

//

bool Setup()

{

    //

    // Turn on lighting.

    //

    Device->SetRenderState(D3DRS_LIGHTING, true);

    //

    // Create the vertex buffer for the pyramid.

    //

    Device->CreateVertexBuffer(

        12 * sizeof(Vertex), 

        D3DUSAGE_WRITEONLY,

        Vertex::FVF,

        D3DPOOL_MANAGED,

        &Pyramid,

        0);

    //

    // Fill the vertex buffer with pyramid data.

    //

    Vertex* v;

    Pyramid->Lock(0, 0, (void**)&v, 0);

    // front face

    v[0] = Vertex(-1.0f, 0.0f, -1.0f, 0.0f, 0.707f, -0.707f);

    v[1] = Vertex( 0.0f, 1.0f,  0.0f, 0.0f, 0.707f, -0.707f);

    v[2] = Vertex( 1.0f, 0.0f, -1.0f, 0.0f, 0.707f, -0.707f);

    // left face

    v[3] = Vertex(-1.0f, 0.0f,  1.0f, -0.707f, 0.707f, 0.0f);

    v[4] = Vertex( 0.0f, 1.0f,  0.0f, -0.707f, 0.707f, 0.0f);

    v[5] = Vertex(-1.0f, 0.0f, -1.0f, -0.707f, 0.707f, 0.0f);

    // right face

    v[6] = Vertex( 1.0f, 0.0f, -1.0f, 0.707f, 0.707f, 0.0f);

    v[7] = Vertex( 0.0f, 1.0f,  0.0f, 0.707f, 0.707f, 0.0f);

    v[8] = Vertex( 1.0f, 0.0f,  1.0f, 0.707f, 0.707f, 0.0f);

    // back face

    v[9]  = Vertex( 1.0f, 0.0f,  1.0f, 0.0f, 0.707f, 0.707f);

    v[10] = Vertex( 0.0f, 1.0f,  0.0f, 0.0f, 0.707f, 0.707f);

    v[11] = Vertex(-1.0f, 0.0f,  1.0f, 0.0f, 0.707f, 0.707f);

    Pyramid->Unlock();

    //

    // Create and set the material.

    //

    D3DMATERIAL9 mtrl;

    mtrl.Ambient  = d3d::WHITE;

    mtrl.Diffuse  = d3d::WHITE;

    mtrl.Specular = d3d::WHITE;

    mtrl.Emissive = d3d::BLACK;

    mtrl.Power    = 5.0f;

    Device->SetMaterial(&mtrl);

    //

    // Setup a directional light.

    //

    D3DLIGHT9 dir;

    ::ZeroMemory(&dir, sizeof(dir));

    dir.Type      = D3DLIGHT_DIRECTIONAL;

    dir.Diffuse   = d3d::RED;

    dir.Specular  = d3d::WHITE * 0.3f;

    dir.Ambient   = d3d::WHITE * 0.6f;

    dir.Direction = D3DXVECTOR3(1.0f, 0.0f, 0.0f);

    //

    // Set and Enable the light.

    //

    Device->SetLight(0, &dir);

    Device->LightEnable(0, true);

    //

    // Turn on specular lighting and instruct Direct3D

    // to renormalize normals.

    //

    Device->SetRenderState(D3DRS_NORMALIZENORMALS, true);

    Device->SetRenderState(D3DRS_SPECULARENABLE, false);

    //

    // Position and aim the camera.

    //

    D3DXVECTOR3 pos(0.0f, 1.0f, -3.0f);

    D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);

    D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);

    D3DXMATRIX V;

    D3DXMatrixLookAtLH(&V, &pos, &target, &up);

    Device->SetTransform(D3DTS_VIEW, &V);

    //

    // Set the projection matrix.

    //

    D3DXMATRIX proj;

    D3DXMatrixPerspectiveFovLH(

            &proj,

            D3DX_PI * 0.5f, // 90 - degree

            (float)Width / (float)Height,

            1.0f,

            1000.0f);

    Device->SetTransform(D3DTS_PROJECTION, &proj);

    return true;

}

void Cleanup()

{

    d3d::Release<IDirect3DVertexBuffer9*>(Pyramid);

}

bool Display(float timeDelta)

{

    if( Device )

    {

        // 

        // Update the scene: Rotate the pyramid.

        //

        D3DXMATRIX yRot;

        static float y = 0.0f;

        D3DXMatrixRotationY(&yRot, y);

        y += timeDelta;

        if( y >= 6.28f )

            y = 0.0f;

        Device->SetTransform(D3DTS_WORLD, &yRot);

        //

        // Draw the scene:

        //

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

        Device->BeginScene();

        Device->SetStreamSource(0, Pyramid, 0, sizeof(Vertex));

        Device->SetFVF(Vertex::FVF);

        Device->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 4);

        Device->EndScene();

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

    }

    return true;

}

//

// WndProc

//

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

{

    switch( msg )

    {

    case WM_DESTROY:

        ::PostQuitMessage(0);

        break;

    case WM_KEYDOWN:

        if( wParam == VK_ESCAPE )

            ::DestroyWindow(hwnd);

        break;

    }

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

}

//

// WinMain

//

int WINAPI WinMain(HINSTANCE hinstance,

                   HINSTANCE prevInstance, 

                   PSTR cmdLine,

                   int showCmd)

{

    if(!d3d::InitD3D(hinstance,

        Width, Height, true, D3DDEVTYPE_HAL, &Device))

    {

        ::MessageBox(0, "InitD3D() - FAILED", 0, 0);

        return 0;

    }

    if(!Setup())

    {

        ::MessageBox(0, "Setup() - FAILED", 0, 0);

        return 0;

    }

    d3d::EnterMsgLoop( Display );

    Cleanup();

    Device->Release();

    return 0;

}