DirectX11 光照实现

光照实现

1. 光照结构体

在LightHelper.h文件中，我们定义了一些的结构体来表示平行光、点光或聚光灯。

结构体成员组成如下：

1．Ambient：由光源发射的环境光的数量。

2．Diffuse：由光源发射的漫反射光的数量。

3．Specular：由光源发射的高光的数量。

4．Direction：灯光方向。

5．Position：灯光位置。

6．Range：光照范围（离开光源的距离大于这个值的点不会被照亮）。

7．Attenuation：按照（a0、a1和a2）的顺序存储3个衰减常量。衰减常量只用于点和聚光灯，用于控制光强随距离衰减的程度。

8．Spot：该指数用于控制聚光灯的圆锥体区域大小；这个值只用于聚光灯。

“pad”变量的必要性和“packing”格式已经在上一篇博文中讨论过了，如果不知道什么意思，请务必回顾上一篇博文。

下面是各种光源的结构体定义：

struct DirectionalLight
{
DirectionalLight() { ZeroMemory(this, sizeof(this)); }

XMFLOAT4 Ambient;
XMFLOAT4 Diffuse;
XMFLOAT4 Specular;
XMFLOAT3 Direction;
float Pad; // 占位最后一个float，这样我们就可以设置光源数组了。
};

struct PointLight
{
PointLight() { ZeroMemory(this, sizeof(this)); }

XMFLOAT4 Ambient;
XMFLOAT4 Diffuse;
XMFLOAT4 Specular;

// 打包到4D矢量: (Position, Range)
XMFLOAT3 Position;
float Range;

// 打包到4D矢量: (A0, A1, A2, Pad)
XMFLOAT3 Att;
float Pad; // 占位最后一个float，，这样我们就可以设置光源数组了。
};

struct SpotLight
{
SpotLight() { ZeroMemory(this, sizeof(this)); }

XMFLOAT4 Ambient;
XMFLOAT4 Diffuse;
XMFLOAT4 Specular;

// 打包到4D矢量: (Position, Range)
XMFLOAT3 Position;
float Range;

// 打包到4D矢量: (Direction, Spot)
XMFLOAT3 Direction;
float Spot;

// 打包到4D矢量: (Att, Pad)
XMFLOAT3 Att;
float Pad; // 占位最后一个float，，这样我们就可以设置光源数组了。
};

定义在LightHelper.fx文件中的结构体镜像了上面的结构体：

struct DirectionalLight
{
float4 Ambient;
float4 Diffuse;
float4 Specular;
float3 Direction;
float pad;
};

struct PointLight
{
float4 Ambient;
float4 Diffuse;
float4 Specular;

float3 Position;
float Range;

float3 Att;
float pad;
};

struct SpotLight
{
float4 Ambient;
float4 Diffuse;
float4 Specular;

float3 Position;
float Range;

float3 Direction;
float Spot;

float3 Att;
float pad;
};

2. 实现平行光

下面的HLSL函数根据给出的材质、平行光源、表面法线和由表面指向观察点的矢量，输出光照后的表面颜色。

void ComputeDirectionalLight(Material mat, DirectionalLight L,
float3 normal, float3 toEye,
out float4 ambient,
out float4 diffuse,
out float4 spec)
{
// 初始化输出的变量
ambient = float4(0.0f, 0.0f, 0.0f, 0.0f);
diffuse = float4(0.0f, 0.0f, 0.0f, 0.0f);
spec    = float4(0.0f, 0.0f, 0.0f, 0.0f);

// 光照矢量与光线的传播方向相反
float3 lightVec = -L.Direction;

// 添加环境光
ambient = mat.Ambient * L.Ambient;

// 添加漫反射和镜面光
float diffuseFactor = dot(lightVec, normal);

// Flatten避免动态分支
[flatten]
if( diffuseFactor > 0.0f )
{
float3 v         = reflect(-lightVec, normal);
float specFactor = pow(max(dot(v, toEye), 0.0f), mat.Specular.w);

diffuse = diffuseFactor * mat.Diffuse * L.Diffuse;
spec    = specFactor * mat.Specular * L.Specular;
}
}

其中，使用的HLSL内置函数有：dot、reflect、pow和max，它们分别用来计算向量点积、向量反射、乘方和取最大值。读者可以在附录B中找到大部分HLSL内置函数的描述，以及有关HLSL语法的快速入门。另外还有一件事情需要注意，那就是当两个向量使用*运算符相乘时，实际执行的是分量乘法。

注意：PC上的HLSL函数总是内联的，调用函数或传递参数不会有性能损失。

3. 实现点光

下面的HLSL函数根据给出的材质、点光源、表面位置、表面法线和表面点到观察点的的矢量信息，输出光照后的表面颜色。

void ComputePointLight(Material mat, PointLight L, float3 pos, float3 normal, float3 toEye,
out float4 ambient, out float4 diffuse, out float4 spec)
{
// 初始化输出变量
ambient = float4(0.0f, 0.0f, 0.0f, 0.0f);
diffuse = float4(0.0f, 0.0f, 0.0f, 0.0f);
spec    = float4(0.0f, 0.0f, 0.0f, 0.0f);

// 表面指向光源的矢量
float3 lightVec = L.Position - pos;

// 表面离光源的距离
float d = length(lightVec);

// 范围测试
if( d > L.Range )
return;

// 光源向量归一化
lightVec /= d;

// 环境光项
ambient = mat.Ambient * L.Ambient;

// 添加漫反射和镜面反射项，所提供的表面是在该光线的位置射出的直线。

float diffuseFactor = dot(lightVec, normal);

// Flatten避免动态分支
[flatten]
if( diffuseFactor > 0.0f )
{
float3 v         = reflect(-lightVec, normal);
float specFactor = pow(max(dot(v, toEye), 0.0f), mat.Specular.w);

diffuse = diffuseFactor * mat.Diffuse * L.Diffuse;
spec    = specFactor * mat.Specular * L.Specular;
}

// 衰减
float att = 1.0f / dot(L.Att, float3(1.0f, d, d*d));

diffuse *= att;
spec    *= att;
}

4. 实现聚光灯

下面的HLSL函数根据给出的材质、聚光灯、表面位置、表面法线、表面点指向观察点位置的矢量信息，输出光照后的表面颜色：

void ComputeSpotLight(Material mat, SpotLight L, float3 pos, float3 normal, float3 toEye,
out float4 ambient, out float4 diffuse, out float4 spec)
{
// 初始化输出变量.
ambient = float4(0.0f, 0.0f, 0.0f, 0.0f);
diffuse = float4(0.0f, 0.0f, 0.0f, 0.0f);
spec    = float4(0.0f, 0.0f, 0.0f, 0.0f);

// 从表面指向光源的光照矢量
float3 lightVec = L.Position - pos;

// 表面离开光源的距离
float d = length(lightVec);

// Range test.
if( d > L.Range )
return;

// 规范化光照矢量
lightVec /= d;

// 计算环境光
ambient = mat.Ambient * L.Ambient;

// 计算漫反射和镜面光，所提供的表面是在该光线的位置射出的直线。

float diffuseFactor = dot(lightVec, normal);

// Flatten避免动态分支
[flatten]
if( diffuseFactor > 0.0f )
{
float3 v         = reflect(-lightVec, normal);
float specFactor = pow(max(dot(v, toEye), 0.0f), mat.Specular.w);

diffuse = diffuseFactor * mat.Diffuse * L.Diffuse;
spec    = specFactor * mat.Specular * L.Specular;
}

// 通过聚光灯因子缩放和衰减
float spot = pow(max(dot(-lightVec, L.Direction), 0.0f), L.Spot);

// 通过聚光灯因子缩放和衰减
float att = spot / dot(L.Att, float3(1.0f, d, d*d));

ambient *= spot;
diffuse *= att;
spec    *= att;
}