* 修改摄像机为左手坐标系

* ps shader一点点容错
+ 添加第11章比较基础的部分。绘制墙、镜子、地板

Author: BlueRoom

Chapter 11 Stenciling/Core/Graphics/Camera.cpp

@@ -19,62 +19,36 @@ using namespace Math;
 
 void BaseCamera::SetLookDirection( Vector3 forward, Vector3 up )
 {
-    // Given, but ensure normalization
+    // 计算前方
     Scalar forwardLenSq = LengthSquare(forward);
-    forward = Select(forward * RecipSqrt(forwardLenSq), -Vector3(kZUnitVector), forwardLenSq < Scalar(0.000001f));
+    forward = Select(forward * RecipSqrt(forwardLenSq), Vector3(kZUnitVector), forwardLenSq < Scalar(0.000001f));
 
-    // Deduce a valid, orthogonal right vector
-    Vector3 right = Cross(forward, up);
+    // 根据提供的上和前方，计算右方
+    Vector3 right = Cross(up, forward);
     Scalar rightLenSq = LengthSquare(right);
-    right = Select(right * RecipSqrt(rightLenSq), Quaternion(Vector3(kYUnitVector), -XM_PIDIV2) * forward, rightLenSq < Scalar(0.000001f));
+    right = Select(right * RecipSqrt(rightLenSq), Cross(Vector3(kYUnitVector), forward), rightLenSq < Scalar(0.000001f));
 
-    // Compute actual up vector
-    up = Cross(right, forward);
+    // 正交化，计算实际的上方
+    up = Cross(forward, right);
 
-    // Finish constructing basis
-    m_Basis = Matrix3(right, up, -forward);
+    // 计算摄像机的转换矩阵
+    m_Basis = Matrix3(right, up, forward);
     m_CameraToWorld.SetRotation(Quaternion(m_Basis));
 }
 
 void BaseCamera::Update()
 {
-    m_PreviousViewProjMatrix = m_ViewProjMatrix;
-
+    // 计算视角变换矩阵，还没有看懂 m_CameraToWorld
     m_ViewMatrix = Matrix4(~m_CameraToWorld);
+    
+    // Matrix4中的*重载，故意反着写的。所以这里反着乘
+    // 计算视角投影转换矩阵。这样拿到世界矩阵再乘以这个值就可以算出最终的投影坐标了
     m_ViewProjMatrix = m_ProjMatrix * m_ViewMatrix;
-    m_ReprojectMatrix = m_PreviousViewProjMatrix * Invert(GetViewProjMatrix());
-
-    m_FrustumVS = Frustum( m_ProjMatrix );
-    m_FrustumWS = m_CameraToWorld * m_FrustumVS;
 }
 
-
 void Camera::UpdateProjMatrix( void )
 {
-    float Y = 1.0f / std::tanf( m_VerticalFOV * 0.5f );
-    float X = Y * m_AspectRatio;
+    DirectX::XMMATRIX mat = XMMatrixPerspectiveFovLH(m_VerticalFOV, m_AspectRatio, m_NearClip, m_FarClip);
 
-    float Q1, Q2;
-
-    // ReverseZ puts far plane at Z=0 and near plane at Z=1.  This is never a bad idea, and it's
-    // actually a great idea with F32 depth buffers to redistribute precision more evenly across
-    // the entire range.  It requires clearing Z to 0.0f and using a GREATER variant depth test.
-    // Some care must also be done to properly reconstruct linear W in a pixel shader from hyperbolic Z.
-    if (m_ReverseZ)
-    {
-        Q1 = m_NearClip / (m_FarClip - m_NearClip);
-        Q2 = Q1 * m_FarClip;
-    }
-    else
-    {
-        Q1 = m_FarClip / (m_NearClip - m_FarClip);
-        Q2 = Q1 * m_NearClip;
-    }
-
-    SetProjMatrix( Matrix4(
-        Vector4( X, 0.0f, 0.0f, 0.0f ),
-        Vector4( 0.0f, Y, 0.0f, 0.0f ),
-        Vector4( 0.0f, 0.0f, Q1, -1.0f ),
-        Vector4( 0.0f, 0.0f, Q2, 0.0f )
-        ) );
-}
+    SetProjMatrix(Matrix4(mat));
+}

Chapter 11 Stenciling/Core/Graphics/Camera.h

@@ -45,9 +45,6 @@ namespace Math
         const Matrix4& GetViewMatrix() const { return m_ViewMatrix; }
         const Matrix4& GetProjMatrix() const { return m_ProjMatrix; }
         const Matrix4& GetViewProjMatrix() const { return m_ViewProjMatrix; }
-        const Matrix4& GetReprojectionMatrix() const { return m_ReprojectMatrix; }
-        const Frustum& GetViewSpaceFrustum() const { return m_FrustumVS; }
-        const Frustum& GetWorldSpaceFrustum() const { return m_FrustumWS; }
 
     protected:
 
@@ -60,29 +57,19 @@ namespace Math
         // Redundant data cached for faster lookups.
         Matrix3 m_Basis;
 
-        // Transforms homogeneous coordinates from world space to view space.  In this case, view space is defined as +X is
-        // to the right, +Y is up, and -Z is forward.  This has to match what the projection matrix expects, but you might
-        // also need to know what the convention is if you work in view space in a shader.
+        // 0 矩阵变换
+        // 1. 渲染目标从模型坐标系转到世界坐标系--->世界变换矩阵
+        // 2. 再从世界坐标系转到视角坐标系--->视角变换矩阵 m_ViewMatrix
+        // 3. 从视角坐标系转换到投影坐标系--->投影变换矩阵 m_ProjMatrix
+
+        // 世界坐标系转换到视角坐标系
         Matrix4 m_ViewMatrix;        // i.e. "World-to-View" matrix
 
-        // The projection matrix transforms view space to clip space.  Once division by W has occurred, the final coordinates
-        // can be transformed by the viewport matrix to screen space.  The projection matrix is determined by the screen aspect 
-        // and camera field of view.  A projection matrix can also be orthographic.  In that case, field of view would be defined
-        // in linear units, not angles.
+        // 视角坐标系转到投影坐标系
         Matrix4 m_ProjMatrix;        // i.e. "View-to-Projection" matrix
 
-        // A concatenation of the view and projection matrices.
+        // 从世界坐标系直接转换到投影坐标系
         Matrix4 m_ViewProjMatrix;    // i.e.  "World-To-Projection" matrix.
-
-        // The view-projection matrix from the previous frame
-        Matrix4 m_PreviousViewProjMatrix;
-
-        // Projects a clip-space coordinate to the previous frame (useful for temporal effects).
-        Matrix4 m_ReprojectMatrix;
-
-        Frustum m_FrustumVS;        // View-space view frustum
-        Frustum m_FrustumWS;        // World-space view frustum
-
     };
 
     class Camera : public BaseCamera
@@ -91,16 +78,14 @@ namespace Math
         Camera();
 
         // Controls the view-to-projection matrix
-        void SetPerspectiveMatrix( float verticalFovRadians, float aspectHeightOverWidth, float nearZClip, float farZClip );
+        void SetPerspectiveMatrix( float verticalFovRadians, float aspectWidthOverHeight, float nearZClip, float farZClip );
         void SetFOV( float verticalFovInRadians ) { m_VerticalFOV = verticalFovInRadians; UpdateProjMatrix(); }
-        void SetAspectRatio( float heightOverWidth ) { m_AspectRatio = heightOverWidth; UpdateProjMatrix(); }
+        void SetAspectRatio( float widthOverHeight) { m_AspectRatio = widthOverHeight; UpdateProjMatrix(); }
         void SetZRange( float nearZ, float farZ) { m_NearClip = nearZ; m_FarClip = farZ; UpdateProjMatrix(); }
-        void ReverseZ( bool enable ) { m_ReverseZ = enable; UpdateProjMatrix(); }
 
         float GetFOV() const { return m_VerticalFOV; }
         float GetNearClip() const { return m_NearClip; }
         float GetFarClip() const { return m_FarClip; }
-        float GetClearDepth() const { return m_ReverseZ ? 0.0f : 1.0f; }
 
     private:
 
@@ -110,7 +95,6 @@ namespace Math
         float m_AspectRatio;
         float m_NearClip;
         float m_FarClip;
-        bool m_ReverseZ;                // Invert near and far clip distances so that Z=0 is the far plane
     };
 
     inline void BaseCamera::SetEyeAtUp( Vector3 eye, Vector3 at, Vector3 up )
@@ -137,21 +121,19 @@ namespace Math
         m_Basis = Matrix3(m_CameraToWorld.GetRotation());
     }
 
-    inline Camera::Camera() : m_ReverseZ(true)
+    inline Camera::Camera()
     {
-        SetPerspectiveMatrix( XM_PIDIV4, 9.0f / 16.0f, 1.0f, 1000.0f );
+        SetPerspectiveMatrix( XM_PIDIV4, 16.0f / 9.0f, 1.0f, 1000.0f );
     }
 
-    inline void Camera::SetPerspectiveMatrix( float verticalFovRadians, float aspectHeightOverWidth, float nearZClip, float farZClip )
+    inline void Camera::SetPerspectiveMatrix( float verticalFovRadians, float aspectWidthOverHeight, float nearZClip, float farZClip )
     {
         m_VerticalFOV = verticalFovRadians;
-        m_AspectRatio = aspectHeightOverWidth;
+        m_AspectRatio = aspectWidthOverHeight;
         m_NearClip = nearZClip;
         m_FarClip = farZClip;
 
         UpdateProjMatrix();
-
-        m_PreviousViewProjMatrix = m_ViewProjMatrix;
     }
 
 } // namespace Math

Chapter 11 Stenciling/Core/Shaders/defaultPS.hlsl

@@ -51,6 +51,7 @@ cbuffer cbMaterial : register(b2)
 {
     float4 gDiffuseAlbedo;
     float3 gFresnelR0;
+    float  gPad;
     float  gRoughness;
 };
 
@@ -93,7 +94,7 @@ float4 main(VertexOut pin) : SV_Target0
     float4 litColor = ambient + directLight;
 
     // 雾，如果雾的颜色alpha为0，则不处理
-    if (gFogColor.a > 0)
+    if (gFogColor.a > 0.01)
     {
         float fogAmount = saturate((distToEye - gFogStart) / gFogRange);
         litColor = lerp(litColor, gFogColor, fogAmount);