+ shapes with light

添加shapes示例的光照效果。因为miniengine自带动态广告（HDR，LDR），所以颜色要亮一些。
可以直接把渲染内容渲染到交换连的缓冲区，就与d3d12book一致了

Author: [email protected]

Chapter 8 Lighting/Chapter 8 Lighting.vcxproj

@@ -174,6 +174,7 @@
     <ClInclude Include="Core\SystemTime.h" />
     <ClInclude Include="Core\Utility.h" />
     <ClInclude Include="Core\VectorMath.h" />
+    <ClInclude Include="d3dUtil.h" />
     <ClInclude Include="GameApp.h" />
     <ClInclude Include="GeometryGenerator.h" />
     <ClInclude Include="Waves.h" />
@@ -323,6 +324,11 @@
     <FxCompile Include="Core\Shaders\GenerateMipsLinearOddCS.hlsl" />
     <FxCompile Include="Core\Shaders\GenerateMipsLinearOddXCS.hlsl" />
     <FxCompile Include="Core\Shaders\GenerateMipsLinearOddYCS.hlsl" />
+    <None Include="Core\Shaders\LightingUtil.hlsl">
+      <EntryPointName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+      </EntryPointName>
+      <FileType>Document</FileType>
+    </None>
     <FxCompile Include="Core\Shaders\LinearizeDepthCS.hlsl" />
     <FxCompile Include="Core\Shaders\MagnifyPixelsPS.hlsl">
       <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Pixel</ShaderType>

Chapter 8 Lighting/Chapter 8 Lighting.vcxproj.filters

@@ -317,6 +317,9 @@
     <ClInclude Include="Waves.h">
       <Filter>源文件</Filter>
     </ClInclude>
+    <ClInclude Include="d3dUtil.h">
+      <Filter>源文件</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Text Include="Core\readme\readme_command.txt">
@@ -411,6 +414,9 @@
     <None Include="Core\Shaders\TextRS.hlsli">
       <Filter>Shaders\Text</Filter>
     </None>
+    <None Include="Core\Shaders\LightingUtil.hlsl">
+      <Filter>Shaders\default</Filter>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <FxCompile Include="Core\Shaders\Bitonic32InnerSortCS.hlsl">

Chapter 8 Lighting/Core/Shaders/LightingUtil.hlsl

@@ -0,0 +1,170 @@
+//***************************************************************************************
+// LightingUtil.hlsl by Frank Luna (C) 2015 All Rights Reserved.
+//
+// Contains API for shader lighting.
+//***************************************************************************************
+
+#define MaxLights 16
+
+struct Light
+{
+    float3 Strength;
+    float FalloffStart; // point/spot light only
+    float3 Direction;   // directional/spot light only
+    float FalloffEnd;   // point/spot light only
+    float3 Position;    // point light only
+    float SpotPower;    // spot light only
+};
+
+struct Material
+{
+    float4 DiffuseAlbedo;
+    float3 FresnelR0;
+    float Shininess;
+};
+
+float CalcAttenuation(float d, float falloffStart, float falloffEnd)
+{
+    // Linear falloff.
+    return saturate((falloffEnd-d) / (falloffEnd - falloffStart));
+}
+
+// Schlick gives an approximation to Fresnel reflectance (see pg. 233 "Real-Time Rendering 3rd Ed.").
+// R0 = ( (n-1)/(n+1) )^2, where n is the index of refraction.
+float3 SchlickFresnel(float3 R0, float3 normal, float3 lightVec)
+{
+    float cosIncidentAngle = saturate(dot(normal, lightVec));
+
+    float f0 = 1.0f - cosIncidentAngle;
+    float3 reflectPercent = R0 + (1.0f - R0)*(f0*f0*f0*f0*f0);
+
+    return reflectPercent;
+}
+
+float3 BlinnPhong(float3 lightStrength, float3 lightVec, float3 normal, float3 toEye, Material mat)
+{
+    const float m = mat.Shininess * 256.0f;
+    float3 halfVec = normalize(toEye + lightVec);
+
+    float roughnessFactor = (m + 8.0f)*pow(max(dot(halfVec, normal), 0.0f), m) / 8.0f;
+    float3 fresnelFactor = SchlickFresnel(mat.FresnelR0, halfVec, lightVec);
+
+    float3 specAlbedo = fresnelFactor*roughnessFactor;
+
+    // Our spec formula goes outside [0,1] range, but we are 
+    // doing LDR rendering.  So scale it down a bit.
+    specAlbedo = specAlbedo / (specAlbedo + 1.0f);
+
+    return (mat.DiffuseAlbedo.rgb + specAlbedo) * lightStrength;
+}
+
+//---------------------------------------------------------------------------------------
+// Evaluates the lighting equation for directional lights.
+//---------------------------------------------------------------------------------------
+float3 ComputeDirectionalLight(Light L, Material mat, float3 normal, float3 toEye)
+{
+    // The light vector aims opposite the direction the light rays travel.
+    float3 lightVec = -L.Direction;
+
+    // Scale light down by Lambert's cosine law.
+    float ndotl = max(dot(lightVec, normal), 0.0f);
+    float3 lightStrength = L.Strength * ndotl;
+
+    return BlinnPhong(lightStrength, lightVec, normal, toEye, mat);
+}
+
+//---------------------------------------------------------------------------------------
+// Evaluates the lighting equation for point lights.
+//---------------------------------------------------------------------------------------
+float3 ComputePointLight(Light L, Material mat, float3 pos, float3 normal, float3 toEye)
+{
+    // The vector from the surface to the light.
+    float3 lightVec = L.Position - pos;
+
+    // The distance from surface to light.
+    float d = length(lightVec);
+
+    // Range test.
+    if(d > L.FalloffEnd)
+        return 0.0f;
+
+    // Normalize the light vector.
+    lightVec /= d;
+
+    // Scale light down by Lambert's cosine law.
+    float ndotl = max(dot(lightVec, normal), 0.0f);
+    float3 lightStrength = L.Strength * ndotl;
+
+    // Attenuate light by distance.
+    float att = CalcAttenuation(d, L.FalloffStart, L.FalloffEnd);
+    lightStrength *= att;
+
+    return BlinnPhong(lightStrength, lightVec, normal, toEye, mat);
+}
+
+//---------------------------------------------------------------------------------------
+// Evaluates the lighting equation for spot lights.
+//---------------------------------------------------------------------------------------
+float3 ComputeSpotLight(Light L, Material mat, float3 pos, float3 normal, float3 toEye)
+{
+    // The vector from the surface to the light.
+    float3 lightVec = L.Position - pos;
+
+    // The distance from surface to light.
+    float d = length(lightVec);
+
+    // Range test.
+    if(d > L.FalloffEnd)
+        return 0.0f;
+
+    // Normalize the light vector.
+    lightVec /= d;
+
+    // Scale light down by Lambert's cosine law.
+    float ndotl = max(dot(lightVec, normal), 0.0f);
+    float3 lightStrength = L.Strength * ndotl;
+
+    // Attenuate light by distance.
+    float att = CalcAttenuation(d, L.FalloffStart, L.FalloffEnd);
+    lightStrength *= att;
+
+    // Scale by spotlight
+    float spotFactor = pow(max(dot(-lightVec, L.Direction), 0.0f), L.SpotPower);
+    lightStrength *= spotFactor;
+
+    return BlinnPhong(lightStrength, lightVec, normal, toEye, mat);
+}
+
+float4 ComputeLighting(Light gLights[MaxLights], Material mat,
+                       float3 pos, float3 normal, float3 toEye,
+                       float3 shadowFactor)
+{
+    float3 result = 0.0f;
+
+    int i = 0;
+
+#if (NUM_DIR_LIGHTS > 0)
+    for(i = 0; i < NUM_DIR_LIGHTS; ++i)
+    {
+        result += shadowFactor[i] * ComputeDirectionalLight(gLights[i], mat, normal, toEye);
+    }
+#endif
+
+#if (NUM_POINT_LIGHTS > 0)
+    for(i = NUM_DIR_LIGHTS; i < NUM_DIR_LIGHTS+NUM_POINT_LIGHTS; ++i)
+    {
+        result += ComputePointLight(gLights[i], mat, pos, normal, toEye);
+    }
+#endif
+
+#if (NUM_SPOT_LIGHTS > 0)
+    for(i = NUM_DIR_LIGHTS + NUM_POINT_LIGHTS; i < NUM_DIR_LIGHTS + NUM_POINT_LIGHTS + NUM_SPOT_LIGHTS; ++i)
+    {
+        result += ComputeSpotLight(gLights[i], mat, pos, normal, toEye);
+    }
+#endif 
+
+    return float4(result, 0.0f);
+}
+
+

Chapter 8 Lighting/Core/Shaders/defaultPS.hlsl

@@ -1,10 +1,78 @@
+//***************************************************************************************
+// Default.hlsl by Frank Luna (C) 2015 All Rights Reserved.
+//
+// Default shader, currently supports lighting.
+//***************************************************************************************
+
+// Defaults for number of lights.
+#ifndef NUM_DIR_LIGHTS
+#define NUM_DIR_LIGHTS 3
+#endif
+
+#ifndef NUM_POINT_LIGHTS
+#define NUM_POINT_LIGHTS 0
+#endif
+
+#ifndef NUM_SPOT_LIGHTS
+#define NUM_SPOT_LIGHTS 0
+#endif
+
+// Include structures and functions for lighting.
+#include "LightingUtil.hlsl"
+
+// Constant data that varies per frame.
+
+// Constant data that varies per material.
+cbuffer cbPass : register(b1)
+{
+    float4x4 gViewProj;
+    float3 gEyePosW;
+    float cbPerObjectPad1;
+    float4 gAmbientLight;
+
+    // Indices [0, NUM_DIR_LIGHTS) are directional lights;
+    // indices [NUM_DIR_LIGHTS, NUM_DIR_LIGHTS+NUM_POINT_LIGHTS) are point lights;
+    // indices [NUM_DIR_LIGHTS+NUM_POINT_LIGHTS, NUM_DIR_LIGHTS+NUM_POINT_LIGHT+NUM_SPOT_LIGHTS)
+    // are spot lights for a maximum of MaxLights per object.
+    Light gLights[MaxLights];
+};
+
+cbuffer cbMaterial : register(b2)
+{
+    float4 gDiffuseAlbedo;
+    float3 gFresnelR0;
+    float  gRoughness;
+};
+
+
 struct VertexOut
 {
-    float4 PosH  : SV_POSITION;
-    float4 Color : COLOR;
+    float4 PosH    : SV_POSITION;
+    float3 PosW    : POSITION;
+    float3 NormalW : NORMAL;
 };
 
 float4 main(VertexOut pin) : SV_Target0
 {
-    return pin.Color;
+    // Interpolating normal can unnormalize it, so renormalize it.
+    pin.NormalW = normalize(pin.NormalW);
+
+    // Vector from point being lit to eye. 
+    float3 toEyeW = normalize(gEyePosW - pin.PosW);
+
+    // Indirect lighting.
+    float4 ambient = gAmbientLight * gDiffuseAlbedo;
+
+    const float shininess = 1.0f - gRoughness;
+    Material mat = { gDiffuseAlbedo, gFresnelR0, shininess };
+    float3 shadowFactor = 1.0f;
+    float4 directLight = ComputeLighting(gLights, mat, pin.PosW,
+        pin.NormalW, toEyeW, shadowFactor);
+
+    float4 litColor = ambient + directLight;
+
+    // Common convention to take alpha from diffuse material.
+    litColor.a = gDiffuseAlbedo.a;
+
+    return litColor;
 }

Chapter 8 Lighting/Core/Shaders/defaultVS.hlsl

@@ -11,27 +11,29 @@ cbuffer PassConstants : register(b1)
 struct VertexIn
 {
     float3 PosL  : POSITION;
-    float4 Color : COLOR;
+    float3 NormalL : NORMAL;
 };
 
 struct VertexOut
 {
-    float4 PosH  : SV_POSITION;
-    float4 Color : COLOR;
+    float4 PosH    : SV_POSITION;
+    float3 PosW    : POSITION;
+    float3 NormalW : NORMAL;
 };
 
 VertexOut main(VertexIn vin)
 {
-    VertexOut vout;
+    VertexOut vout = (VertexOut)0.0f;
 
     // Transform to world space.
-    float4 posW = mul(float4(vin.PosL, 1.0), modelToWorld);
+    float4 posW = mul(float4(vin.PosL, 1.0f), modelToWorld);
+    vout.PosW = posW.xyz;
+
+    // Assumes nonuniform scaling; otherwise, need to use inverse-transpose of world matrix.
+    vout.NormalW = mul(vin.NormalL, (float3x3)modelToWorld);
 
     // Transform to homogeneous clip space.
     vout.PosH = mul(posW, gViewProj);
 
-    // Just pass vertex color into the pixel shader.
-    vout.Color = vin.Color;
-
     return vout;
 }

Chapter 8 Lighting/GameApp.h

@@ -6,6 +6,7 @@
 #include "PipelineState.h"
 #include "Camera.h"
 #include "Waves.h"
+#include "d3dUtil.h"
 
 class RootSignature;
 class StructuredBuffer;
@@ -32,12 +33,17 @@ class GameApp : public GameCore::IGameApp
         int indexCount;
         int startIndex;
         int baseVertex;
+        XMFLOAT4 diffuseAlbedo;
+        XMFLOAT3 fresnelR0;
+        float roughness;
     };
     void buildShapesData();
+    void buildSkull();
     void renderShapes(GraphicsContext& gfxContext);
 
     void buildLandAndWaves();
     float GetHillsHeight(float x, float z) const;
+    XMFLOAT3 GetHillsNormal(float x, float z) const;
     void renderLandAndWaves(GraphicsContext& gfxContext);
     void UpdateWaves(float deltaT);
 
@@ -46,7 +52,7 @@ class GameApp : public GameCore::IGameApp
     struct Vertex
     {
         XMFLOAT3 Pos;
-        XMFLOAT4 Color;
+        XMFLOAT3 Normal;
     };
 
     RootSignature m_RootSignature;
@@ -60,6 +66,11 @@ class GameApp : public GameCore::IGameApp
     StructuredBuffer m_VertexBuffer;
     ByteAddressBuffer m_IndexBuffer;
     std::vector<renderItem> m_vecShapes;
+    // skull
+    StructuredBuffer m_VertexBufferSkull;
+    ByteAddressBuffer m_IndexBufferSkull;
+    renderItem m_skull;
+
     // land and waves
     StructuredBuffer m_VertexBufferLand;
     ByteAddressBuffer m_IndexBufferLand;