DirectX 10 教程6：漫反射光照

本教程中，我们介绍如何使用不同的光照照亮3D模型，本教程基于上一个教程并进行了适当的修改。

我们要实现的漫反射光照的类型叫做单向光。单向光类似于照亮地球的太阳光。这个光源距离很远，基于光线方向你就可以获取照射在物体上的光强。但是，与环境光照(我们以后会介绍)不同，单向光不会照亮光线不能到达的部分。

我首先介绍单向光的原因在于很容易调整它的可视效果，而且光照方程要比点光源、聚光灯简单地多。

在DirectX 10中实现漫反射光照是在顶点和像素着色器中实现的。漫反射光照只需使用光线方向和多边形的法线信息即可。光线方向是一个自定义的矢量，你可以使用多边形的三个顶点计算法线矢量。本教程中我们还要在光照方程中定义光源的颜色。

框架

本教程中我们将创建一个叫做LightClass的新类代表场景中的光源。LightClass只是保存了光的方向和颜色。我们还使用LightShaderClass替代了TextureShaderClass，这个类处理模型上的光照。现在的框架如下图所示：

我们首先讨论HLSL light shader，你会发现这个shader不过是上一个教程的texture shader的升级版本。

Light.fx

// Filename: light.fx

 
 
/
// GLOBALS //
/
matrix worldMatrix;
matrix viewMatrix;
matrix projectionMatrix;
Texture2D shaderTexture;

与上一个教程的texture shader相比第一个不同在于添加了两个全局变量保存了漫反射颜色和光线方向，在这个shader被调用前必须在LightClass中定义这两个变量。

float4 diffuseColor;
float3 lightDirection;
 
 
///
// SAMPLE STATES //
///
SamplerState SampleType
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

两个结构体包含了一个float3类型的法线矢量。法线矢量用于根据法线与光线方向的夹角计算光照强度。

//
// TYPEDEFS //
//
struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
};
 
struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
    float3 normal : NORMAL;
};
 
 

// Vertex Shader

PixelInputType LightVertexShader(VertexInputType input)
{
    PixelInputType output;
     
     
    // Change the position vector to be 4 units for proper matrix calculations.
    input.position.w = 1.0f;
 
    // Calculate the position of the vertex against the world, view, and projection matrices.
    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
     
    // Store the texture coordinates for the pixel shader.
    output.tex = input.tex;

法线矢量被转换到世界空间并进行归一化操作。

    // Calculate the normal vector against the world matrix only.
    output.normal = mul(input.normal, (float3x3)worldMatrix);
     
    // Normalize the normal vector.
    output.normal = normalize(output.normal);
 
    return output;
}
 
 

// Pixel Shader

float4 LightPixelShader(PixelInputType input) : SV_Target
{
    float4 textureColor;
    float3 lightDir;
    float lightIntensity;
    float4 color;
 
 
    // Sample the pixel color from the texture using the sampler at this texture coordinate location.
    textureColor = shaderTexture.Sample(SampleType, input.tex);

下面的代码实现了漫反射光照方程，光照强度值等于法线矢量和光线方向矢量的点乘。

// Invert the light direction for calculations.
lightDir = -lightDirection;
 
// Calculate the amount of light on this pixel.
lightIntensity = saturate(dot(input.normal, lightDir));

最后，将光源的颜色和纹理像素的颜色组合在一起构成最终的颜色。

    // Determine the final amount of diffuse color based on the diffuse color combined with
 
the light intensity.
    color = saturate(diffuseColor * lightIntensity);
 
    // Multiply the texture pixel and the final diffuse color to get the final pixel color result.
    color = color * textureColor;
 
    return color;
}

除了顶点和像素着色器程序的名称，Technique保持不变。

// Technique

technique10 LightTechnique
{
    pass pass0
    {
        SetVertexShader(CompileShader(vs_4_0, LightVertexShader()));
        SetPixelShader(CompileShader(ps_4_0, LightPixelShader()));
        SetGeometryShader(NULL);
    }
}

Lightshaderclass.h

新的LightShaderClass类似于上一个教程的TextureShaderClass，只不过加入了些处理光照的代码。

//
#include <d3d10.h>
#include <d3dx10math.h>
#include <fstream>
using namespace std;
 
 

// Class name: LightShaderClass

class LightShaderClass
{
public:
    LightShaderClass();
    LightShaderClass(const LightShaderClass&);
    ~LightShaderClass();
 
    bool Initialize(ID3D10Device*, HWND);
    void Shutdown();
    void Render(ID3D10Device*, int, D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D10ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4);
 
private:
    bool InitializeShader(ID3D10Device*, HWND, WCHAR*);
    void ShutdownShader();
    void OutputShaderErrorMessage(ID3D10Blob*, HWND, WCHAR*);
 
    void SetShaderParameters(D3DXMATRIX, D3DXMATRIX, D3DXMATRIX, ID3D10ShaderResourceView*, D3DXVECTOR3, D3DXVECTOR4);
    void RenderShader(ID3D10Device*, int);
 
private:
    ID3D10Effect* m_effect;
    ID3D10EffectTechnique* m_technique;
    ID3D10InputLayout* m_layout;
 
    ID3D10EffectMatrixVariable* m_worldMatrixPtr;
    ID3D10EffectMatrixVariable* m_viewMatrixPtr;
    ID3D10EffectMatrixVariable* m_projectionMatrixPtr;
    ID3D10EffectShaderResourceVariable* m_texturePtr;

多了两个私有变量表示光线的方向和颜色，用于设置HLSL shader中两个对应的全局变量。

    ID3D10EffectVectorVariable* m_lightDirectionPtr;
    ID3D10EffectVectorVariable* m_diffuseColorPtr;
};
 
#endif

Lightshaderclass.cpp

// Filename: lightshaderclass.cpp

#include "lightshaderclass.h"
 
 
LightShaderClass::LightShaderClass()
{
    m_effect = 0;
    m_technique = 0;
    m_layout = 0;
 
    m_worldMatrixPtr = 0;
    m_viewMatrixPtr = 0;
    m_projectionMatrixPtr = 0;
    m_texturePtr = 0;

构造函数中将光照变量设置为null。

    m_lightDirectionPtr = 0;
    m_diffuseColorPtr = 0;
}
 
 
LightShaderClass::LightShaderClass(const LightShaderClass& other)
{
}
 
 
LightShaderClass::~LightShaderClass()
{
}
 
 
bool LightShaderClass::Initialize(ID3D10Device* device, HWND hwnd)
{
    bool result;

新的light.fx文件名称作为InitializeShader方法的一个参数。

    // Initialize the shader that will be used to draw the triangle.
    result = InitializeShader(device, hwnd, L"../Engine/light.fx");
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
void LightShaderClass::Shutdown()
{
    // Shutdown the shader effect.
    ShutdownShader();
 
    return;
}

Render方法的参数包含光线方向和光源漫反射颜色。这两个变量会发送到SetShaderParameters方法并进一步设置到shader中。

void LightShaderClass::Render(ID3D10Device* device, int indexCount, D3DXMATRIX worldMatrix,
 
D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix,
                              ID3D10ShaderResourceView* texture, D3DXVECTOR3 lightDirection,
 
D3DXVECTOR4 diffuseColor)
{
    // Set the shader parameters that it will use for rendering.
    SetShaderParameters(worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, diffuseColor);
 
    // Now render the prepared buffers with the shader.
    RenderShader(device, indexCount);
 
    return;
}
 
 
bool LightShaderClass::InitializeShader(ID3D10Device* device, HWND hwnd, WCHAR* filename)
{
    HRESULT result;
    ID3D10Blob* errorMessage;

polygonLayout变量现在有三个元素而不是上一个教程的两个，多出的一个是法线向量。

D3D10_INPUT_ELEMENT_DESC polygonLayout[3];
    unsigned int numElements;
    D3D10_PASS_DESC passDesc;
 
 
    // Initialize the error message.
    errorMessage = 0;
 
    // Load the shader in from the file.
    result = D3DX10CreateEffectFromFile(filename, NULL, NULL, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
                                        device, NULL, NULL, &m_effect, &errorMessage,
 
NULL);
    if(FAILED(result))
    {
        // If the shader failed to compile it should have writen something to the error message.
        if(errorMessage)
        {
            OutputShaderErrorMessage(errorMessage, hwnd, filename);
        }
        // If there was nothing in the error message then it simply could not find the shader file itself.
        else
        {
            MessageBox(hwnd, filename, L"Missing Shader File", MB_OK);
        }
 
        return false;
    }

Technique的名称修改为LightTechnique，匹配HLSL中的变化。

// Get a pointer to the technique inside the shader.
m_technique = m_effect->GetTechniqueByName("LightTechnique");
if(!m_technique)
{
    return false;
}
 
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
 
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;

InitializeShader方法中最主要的变化就是在polygonLayout中添加了法线矢量用于光照计算。语义名称为NORMAL，格式为DXGI_FORMAT_R32G32B32_FLOAT处理3个浮点数用于法线的x，y和z分量。这样layout就与HLSL顶点着色器的输入相匹配。

    polygonLayout[2].SemanticName = "NORMAL";
    polygonLayout[2].SemanticIndex = 0;
    polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
    polygonLayout[2].InputSlot = 0;
    polygonLayout[2].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
    polygonLayout[2].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
    polygonLayout[2].InstanceDataStepRate = 0;
 
    // Get a count of the elements in the layout.
    numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
 
    // Get the description of the first pass described in the shader technique.
    m_technique->GetPassByIndex(0)->GetDesc(&passDesc);
 
    // Create the input layout.
    result = device->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize,
 
&m_layout);
    if(FAILED(result))
    {
        return false;
    }
 
    // Get pointers to the three matrices inside the shader so we can update them from this class.
    m_worldMatrixPtr = m_effect->GetVariableByName("worldMatrix")->AsMatrix();
    m_viewMatrixPtr = m_effect->GetVariableByName("viewMatrix")->AsMatrix();
    m_projectionMatrixPtr = m_effect->GetVariableByName("projectionMatrix")->AsMatrix();
 
    // Get pointer to the texture resource inside the shader.
    m_texturePtr = m_effect->GetVariableByName("shaderTexture")->AsShaderResource();

这个方法中还添加了光源变量的指针。HLSL light shader需要光线方向和漫反射颜色矢量，通过添加两个指向lightDirection和diffuseColor变量的指针就可以在shader中设置这两个值。

    // Get pointers to the light direction and diffuse color variables inside the shader.
    m_lightDirectionPtr = m_effect->GetVariableByName("lightDirection")->AsVector();
    m_diffuseColorPtr = m_effect->GetVariableByName("diffuseColor")->AsVector();
 
    return true;
}
 
 
void LightShaderClass::ShutdownShader()
{

在ShutdownShader方法中释放这两个新的指针。

// Release the light pointers.
    m_lightDirectionPtr = 0;
    m_diffuseColorPtr = 0;
 
    // Release the pointer to the texture in the shader file.
    m_texturePtr = 0;
 
    // Release the pointers to the matrices inside the shader.
    m_worldMatrixPtr = 0;
    m_viewMatrixPtr = 0;
    m_projectionMatrixPtr = 0;
 
    // Release the pointer to the shader layout.
    if(m_layout)
    {
        m_layout->Release();
        m_layout = 0;
    }
 
    // Release the pointer to the shader technique.
    m_technique = 0;
 
    // Release the pointer to the shader.
    if(m_effect)
    {
        m_effect->Release();
        m_effect = 0;
    }
 
    return;
}
 
 
void LightShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND hwnd, WCHAR* shaderFilename)
{
    char* compileErrors;
    unsigned long bufferSize, i;
    ofstream fout;
 
 
    // Get a pointer to the error message text buffer.
    compileErrors = (char*)(errorMessage->GetBufferPointer());
 
    // Get the length of the message.
    bufferSize = errorMessage->GetBufferSize();
 
    // Open a file to write the error message to.
    fout.open("shader-error.txt");
 
    // Write out the error message.
    for(i=0; i<bufferSize; i++)
    {
        fout << compileErrors[i];
    }
 
    // Close the file.
    fout.close();
 
    // Release the error message.
    errorMessage->Release();
    errorMessage = 0;
 
    // Pop a message up on the screen to notify the user to check the text file for compile errors.
    MessageBox(hwnd, L"Error compiling shader.  Check shader-error.txt for message.", shaderFilename, MB_OK);
 
    return;
}

SetShaderParameters的参数现在包含了lightDirection和diffuseColor。然后使用新的m_lightDirectionPtr和m_diffuseColorPtr指针设置到shader中。

void LightShaderClass::SetShaderParameters(D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix,
 
D3DXMATRIX projectionMatrix,
                                           ID3D10ShaderResourceView* texture, D3DXVECTOR3
 
lightDirection, D3DXVECTOR4 diffuseColor)
{
    // Set the world matrix variable inside the shader.
    m_worldMatrixPtr->SetMatrix((float*)&worldMatrix);
 
    // Set the view matrix variable inside the shader.
    m_viewMatrixPtr->SetMatrix((float*)&viewMatrix);
 
    // Set the projection matrix variable inside the shader.
    m_projectionMatrixPtr->SetMatrix((float*)&projectionMatrix);
 
    // Bind the texture.
    m_texturePtr->SetResource(texture);
 
    // Set the direction of the light inside the shader.
    m_lightDirectionPtr->SetFloatVector((float*)&lightDirection);
 
    // Set the diffuse color of the light inside the shader.
    m_diffuseColorPtr->SetFloatVector((float*)&diffuseColor);
 
    return;
}
 
 
void LightShaderClass::RenderShader(ID3D10Device* device, int indexCount)
{
    D3D10_TECHNIQUE_DESC techniqueDesc;
    unsigned int i;
     
 
    // Set the input layout.
    device->IASetInputLayout(m_layout);
 
    // Get the description structure of the technique from inside the shader so it can be used for rendering.
    m_technique->GetDesc(&techniqueDesc);
 
    // Go through each pass in the technique (should be just one currently) and render the triangles.
    for(i=0; i<techniqueDesc.Passes; ++i)
    {
        m_technique->GetPassByIndex(i)->Apply(0);
        device->DrawIndexed(indexCount, 0, 0);
    }
 
    return;
}

Modelclass.h

ModelClass只添加了一点用于处理光照分量的代码。

// Filename: modelclass.h

#ifndef _MODELCLASS_H_
#define _MODELCLASS_H_
 
 
///
// MY CLASS INCLUDES //
///
#include "textureclass.h"
 
 

// Class name: ModelClass

class ModelClass
{
private:

VertexType结构中多了一个normal矢量用于光照的计算。

    struct VertexType
    {
        D3DXVECTOR3 position;
        D3DXVECTOR2 texture;
        D3DXVECTOR3 normal;
    };
 
public:
    ModelClass();
    ModelClass(const ModelClass&);
    ~ModelClass();
 
    bool Initialize(ID3D10Device*, WCHAR*);
    void Shutdown();
    void Render(ID3D10Device*);
 
    int GetIndexCount();
    ID3D10ShaderResourceView* GetTexture();
 
private:
    bool InitializeBuffers(ID3D10Device*);
    void ShutdownBuffers();
    void RenderBuffers(ID3D10Device*);
 
    bool LoadTexture(ID3D10Device*, WCHAR*);
    void ReleaseTexture();
 
private:
    ID3D10Buffer *m_vertexBuffer, *m_indexBuffer;
    int m_vertexCount, m_indexCount;
    TextureClass* m_Texture;
};
 
#endif

Modelclass.cpp

// Filename: modelclass.cpp

#include "modelclass.h"
 
 
ModelClass::ModelClass()
{
    m_vertexBuffer = 0;
    m_indexBuffer = 0;
    m_Texture = 0;
}
 
 
ModelClass::ModelClass(const ModelClass& other)
{
}
 
 
ModelClass::~ModelClass()
{
}
 
 
bool ModelClass::Initialize(ID3D10Device* device, WCHAR* textureFilename)
{
    bool result;
 
 
    // Initialize the vertex and index buffer that hold the geometry for the triangle.
    result = InitializeBuffers(device);
    if(!result)
    {
        return false;
    }
 
    // Load the texture for this model.
    result = LoadTexture(device, textureFilename);
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
void ModelClass::Shutdown()
{
    // Release the model texture.
    ReleaseTexture();
 
    // Release the vertex and index buffers.
    ShutdownBuffers();
 
    return;
}
 
 
void ModelClass::Render(ID3D10Device* device)
{
    // Put the vertex and index buffers on the graphics pipeline to prepare them for drawing.
    RenderBuffers(device);
 
    return;
}
 
 
int ModelClass::GetIndexCount()
{
    return m_indexCount;
}
 
 
ID3D10ShaderResourceView* ModelClass::GetTexture()
{
    return m_Texture->GetTexture();
}
 
 
bool ModelClass::InitializeBuffers(ID3D10Device* device)
{
    VertexType* vertices;
    unsigned long* indices;
    D3D10_BUFFER_DESC vertexBufferDesc, indexBufferDesc;
    D3D10_SUBRESOURCE_DATA vertexData, indexData;
    HRESULT result;
 
     
    // Set the number of vertices in the vertex array.
    m_vertexCount = 3;
 
    // Set the number of indices in the index array.
    m_indexCount = 3;
 
    // Create the vertex array.
    vertices = new VertexType[m_vertexCount];
    if(!vertices)
    {
        return false;
    }
 
    // Create the index array.
    indices = new unsigned long[m_indexCount];
    if(!indices)
    {
        return false;
    }

InitializeBuffers方法唯一的改变就在于下面的顶点设置。每个顶点都包含一个用于光照计算的法线矢量。法线就是垂直于多边形表面的矢量，出于简化的考虑，我将法线的Z分量都设置为-1.0f，即法线都指向观察者。

  

 // Load the vertex array with data.
    vertices[0].position = D3DXVECTOR3(-1.0f, -1.0f, 0.0f);  // Bottom left.
    vertices[0].texture = D3DXVECTOR2(0.0f, 1.0f);
    vertices[0].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f);
 
    vertices[1].position = D3DXVECTOR3(0.0f, 1.0f, 0.0f);  // Top middle.
    vertices[1].texture = D3DXVECTOR2(0.5f, 0.0f);
    vertices[1].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f);
 
    vertices[2].position = D3DXVECTOR3(1.0f, -1.0f, 0.0f);  // Bottom right.
    vertices[2].texture = D3DXVECTOR2(1.0f, 1.0f);
    vertices[2].normal = D3DXVECTOR3(0.0f, 0.0f, -1.0f);
 
    // Load the index array with data.
    indices[0] = 0;  // Bottom left.
    indices[1] = 1;  // Top middle.
    indices[2] = 2;  // Bottom right.
 
    // Set up the description of the vertex buffer.
    vertexBufferDesc.Usage = D3D10_USAGE_DEFAULT;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_vertexCount;
    vertexBufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = 0;
    vertexBufferDesc.MiscFlags = 0;
 
    // Give the subresource structure a pointer to the vertex data.
    vertexData.pSysMem = vertices;
 
    // Now finally create the vertex buffer.
    result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // Set up the description of the index buffer.
    indexBufferDesc.Usage = D3D10_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_indexCount;
    indexBufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;
 
    // Give the subresource structure a pointer to the index data.
    indexData.pSysMem = indices;
 
    // Create the index buffer.
    result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
    if(FAILED(result))
    {
        return false;
    }
 
    // Release the arrays now that the vertex and index buffers have been created and loaded.
    delete [] vertices;
    vertices = 0;
 
    delete [] indices;
    indices = 0;
 
    return true;
}
 
 
void ModelClass::ShutdownBuffers()
{
    // Release the index buffer.
    if(m_indexBuffer)
    {
        m_indexBuffer->Release();
        m_indexBuffer = 0;
    }
 
    // Release the vertex buffer.
    if(m_vertexBuffer)
    {
        m_vertexBuffer->Release();
        m_vertexBuffer = 0;
    }
 
    return;
}
 
 
void ModelClass::RenderBuffers(ID3D10Device* device)
{
    unsigned int stride;
    unsigned int offset;
 
 
    // Set vertex buffer stride and offset.
    stride = sizeof(VertexType);
    offset = 0;
     
    // Set the vertex buffer to active in the input assembler so it can be rendered.
    device->IASetVertexBuffers(0, 1, &m_vertexBuffer, &stride, &offset);
 
    // Set the index buffer to active in the input assembler so it can be rendered.
    device->IASetIndexBuffer(m_indexBuffer, DXGI_FORMAT_R32_UINT, 0);
 
    // Set the type of primitive that should be rendered from this vertex buffer, in this case triangles.
    device->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
 
    return;
}
 
 
bool ModelClass::LoadTexture(ID3D10Device* device, WCHAR* filename)
{
    bool result;
 
 
    // Create the texture object.
    m_Texture = new TextureClass;
    if(!m_Texture)
    {
        return false;
    }
 
    // Initialize the texture object.
    result = m_Texture->Initialize(device, filename);
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
void ModelClass::ReleaseTexture()
{
    // Release the texture object.
    if(m_Texture)
    {
        m_Texture->Shutdown();
        delete m_Texture;
        m_Texture = 0;
    }
 
    return;
}

Lightclass.h

新的Lightclass非常简单，只是用来保存光线方向和光源颜色。

// Filename: lightclass.h

#ifndef _LIGHTCLASS_H_
#define _LIGHTCLASS_H_
 
 
//
// INCLUDES //
//
#include <d3dx10math.h>
 
 

// Class name: LightClass

class LightClass
{
public:
    LightClass();
    LightClass(const LightClass&);
    ~LightClass();
 
    void SetDiffuseColor(float, float, float, float);
    void SetDirection(float, float, float);
 
    D3DXVECTOR4 GetDiffuseColor();
    D3DXVECTOR3 GetDirection();
 
private:
    D3DXVECTOR4 m_diffuseColor;
    D3DXVECTOR3 m_direction;
};
 
#endif

Lightclass.cpp

// Filename: lightclass.cpp

#include "lightclass.h"
 
 
LightClass::LightClass()
{
}
 
 
LightClass::LightClass(const LightClass& other)
{
}
 
 
LightClass::~LightClass()
{
}
 
 
void LightClass::SetDiffuseColor(float red, float green, float blue, float alpha)
{
    m_diffuseColor = D3DXVECTOR4(red, green, blue, alpha);
    return;
}
 
 
void LightClass::SetDirection(float x, float y, float z)
{
    m_direction = D3DXVECTOR3(x, y, z);
    return;
}
 
 
D3DXVECTOR4 LightClass::GetDiffuseColor()
{
    return m_diffuseColor;
}
 
 
D3DXVECTOR3 LightClass::GetDirection()
{
    return m_direction;
}

Graphicsclass.h

// Filename: graphicsclass.h

#ifndef _GRAPHICSCLASS_H_
#define _GRAPHICSCLASS_H_
 
 
///
// MY CLASS INCLUDES //
///
#include "d3dclass.h"
#include "cameraclass.h"
#include "modelclass.h"

GraphicsClass新包含了LightShaderClass和LightClass。

#include "lightshaderclass.h"
#include "lightclass.h"
 
 
/
// GLOBALS //
/
const bool FULL_SCREEN = true;
const bool VSYNC_ENABLED = true;
const float SCREEN_DEPTH = 1000.0f;
const float SCREEN_NEAR = 0.1f;
 
 

// Class name: GraphicsClass

class GraphicsClass
{
public:
    GraphicsClass();
    GraphicsClass(const GraphicsClass&);
    ~GraphicsClass();
 
    bool Initialize(int, int, HWND);
    void Shutdown();
    bool Frame();
 
private:

Render包含了一个float参数。

    bool Render(float);
 
private:
    D3DClass* m_D3D;
    CameraClass* m_Camera;
    ModelClass* m_Model;

新添了两个私有变量对应light shader和light对象。

    LightShaderClass* m_LightShader;
    LightClass* m_Light;
};
 
#endif

Graphicsclass.cpp

// Filename: graphicsclass.cpp

#include "graphicsclass.h"
 
 
GraphicsClass::GraphicsClass()
{
    m_D3D = 0;
    m_Camera = 0;
    m_Model = 0;

在构造函数中将light shader和light对象设置为null。

    m_LightShader = 0;
    m_Light = 0;
}
 
 
GraphicsClass::GraphicsClass(const GraphicsClass& other)
{
}
 
 
GraphicsClass::~GraphicsClass()
{
}
 
 
bool GraphicsClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
    bool result;
 
 
    // Create the Direct3D object.
    m_D3D = new D3DClass;
    if(!m_D3D)
    {
        return false;
    }
 
    // Initialize the Direct3D object.
    result = m_D3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize Direct3D.", L"Error", MB_OK);
        return false;
    }
 
    // Create the camera object.
    m_Camera = new CameraClass;
    if(!m_Camera)
    {
        return false;
    }
 
    // Set the initial position of the camera.
    m_Camera->SetPosition(0.0f, 0.0f, -10.0f);
     
    // Create the model object.
    m_Model = new ModelClass;
    if(!m_Model)
    {
        return false;
    }
 
    // Initialize the model object.
    result = m_Model->Initialize(m_D3D->GetDevice(), L"../Engine/data/seafloor.dds");
    if(!result)
    {
        MessageBox(hwnd, L"Could not initialize the model object.", L"Error", MB_OK);
        return false;
    }

下面的代码创建并初始化light shader对象。

// Create the light shader object.
m_LightShader = new LightShaderClass;
if(!m_LightShader)
{
    return false;
}
 
// Initialize the light shader object.
result = m_LightShader->Initialize(m_D3D->GetDevice(), hwnd);
if(!result)
{
    MessageBox(hwnd, L"Could not initialize the light shader object.", L"Error", MB_OK);
    return false;
}

下面的代码创建light对象

// Create the light object.
m_Light = new LightClass;
if(!m_Light)
{
    return false;
}

光线的颜色设置为紫色，方向为Z轴方向。

    // Initialize the light object.
    m_Light->SetDiffuseColor(1.0f, 0.0f, 1.0f, 1.0f);
    m_Light->SetDirection(1.0f, 0.0f, 1.0f);
 
    return true;
}
 
 
void GraphicsClass::Shutdown()
{

Shutdown方法中释放新的light和light shader对象。

    // Release the light object.
    if(m_Light)
    {
        delete m_Light;
        m_Light = 0;
    }
 
    // Release the light shader object.
    if(m_LightShader)
    {
        m_LightShader->Shutdown();
        delete m_LightShader;
        m_LightShader = 0;
    }
 
    // Release the model object.
    if(m_Model)
    {
        m_Model->Shutdown();
        delete m_Model;
        m_Model = 0;
    }
 
    // Release the camera object.
    if(m_Camera)
    {
        delete m_Camera;
        m_Camera = 0;
    }
 
    // Release the D3D object.
    if(m_D3D)
    {
        m_D3D->Shutdown();
        delete m_D3D;
        m_D3D = 0;
    }
 
    return;
}
 
 
bool GraphicsClass::Frame()
{
    bool result;

我们添加了一个新的静态变量保存模型的旋转量，这个值会传递到Render方法。

    static float rotation = 0.0f;
 
 
    // Update the rotation variable each frame.
    rotation += (float)D3DX_PI * 0.01f;
    if(rotation > 360.0f)
    {
        rotation -= 360.0f;
    }
 
    // Render the graphics scene.
    result = Render(rotation);
    if(!result)
    {
        return false;
    }
 
    return true;
}
 
 
bool GraphicsClass::Render(float rotation)
{
    D3DXMATRIX worldMatrix, viewMatrix, projectionMatrix;
 
 
    // Clear the buffers to begin the scene.
    m_D3D->BeginScene(0.0f, 0.0f, 0.0f, 1.0f);
 
    // Generate the view matrix based on the camera's position.
    m_Camera->Render();
 
    // Get the world, view, and projection matrices from the camera and d3d objects.
    m_Camera->GetViewMatrix(viewMatrix);
    m_D3D->GetWorldMatrix(worldMatrix);
    m_D3D->GetProjectionMatrix(projectionMatrix);

这里我们通过rotation值更新世界矩阵，这样屏幕上显示的三角形就会绕Y轴旋转。

>    // Rotate the world matrix by the rotation value so that the triangle will spin.
    D3DXMatrixRotationY(&worldMatrix, rotation);
 
    // Put the model vertex and index buffers on the graphics pipeline to prepare them for drawing.
    m_Model->Render(m_D3D->GetDevice());

在这里调用light shader绘制三角形。Light对象将光线方向和光源颜色作为Render方法的参数，这样shader就可以访问到这些变量。

    // Render the model using the light shader.
    m_LightShader->Render(m_D3D->GetDevice(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model-
 
>GetTexture(),
                          m_Light->GetDirection(), m_Light->GetDiffuseColor());
     
    // Present the rendered scene to the screen.
    m_D3D->EndScene();
 
    return true;
}

总结

我们对代码进行了一点修改就实现了基本的单向光照。你需要理解法线的概念以及为什么光照计算需要用到法线信息。注意三角形的背面不会被照亮，因为在D3Dclass中开启了背面剔除。

练习

1．编译代码在屏幕上显示一个旋转的三角形，被紫色的光照亮。按下escape退出程序。

2．在像素着色器代码中注释掉“color = color * textureColor;”，你会发现shaderTexture不再被使用，在屏幕上显示的是一个没有纹理的但有光照的三角形。

3．在GraphicsClass中的m_Light->SetDiffuseColor代码中，将光源颜色变为绿色。

4．改变光线方向或改变三角形旋转的速度。

文件下载