[Game Math] Chapter 12. 원근 투영: 화면에 현실감을 부여하는 변환

class CameraObject
{
public:
    FORCEINLINE Matrix4x4 GetPerspectiveMatrix() const;

private:
    float _FOV = 60.f;  // 시야각
};

// 원근 투영 행렬 P를 생성한다. 
FORCEINLINE Matrix4x4 CameraObject::GetPerspectiveMatrix() const
{
    float invA = 1.f / _ViewportSize.AspectRatio();
    float d = 1.f / tanf(Math::Deg2Rad(_FOV) * 0.5f);

    return Matrix4x4(
        Vector4::UnitX * invA * d,
        Vector4::UnitY * d,
        Vector4(0.f, 0.f, -1.f, 0.f),
        Vector4(0.f, 0.f, 0, 1.f)
    );
}

// 게임 로직을 담당하는 함수
void SoftRenderer::Update3D(float InDeltaSeconds)
{
    // 게임 로직에서 사용하는 모듈 내 주요 레퍼런스
    GameEngine& g = Get3DGameEngine();
    const InputManager& input = g.GetInputManager();

    // 게임 로직의 로컬 변수
    static float moveSpeed = 500.f;
    static float fovSpeed = 100.f;  // 시야각 조절 속도
    static float minFOV = 15.f;     // 최소 시야각
    static float maxFOV = 150.f;    // 최대 시야각

    // 게임 로직에서 사용할 게임 오브젝트 레퍼런스
    GameObject& goPlayer = g.GetGameObject(PlayerGo);
    CameraObject& camera = g.GetMainCamera();
    TransformComponent& playerTransform = goPlayer.GetTransform();

    // 입력에 따른 플레이어 트랜스폼의 변경
    Vector3 inputVector = Vector3(input.GetAxis(InputAxis::XAxis), input.GetAxis(InputAxis::YAxis), input.GetAxis(InputAxis::ZAxis)).GetNormalize();
    playerTransform.AddPosition(inputVector * moveSpeed * InDeltaSeconds);

    // 입력에 따른 카메라 트랜스폼의 변경
    // deltaFOV로 시야각 변화량을 계산하고
    // 최소, 최댓값 사이로 시야각을 설정한다. 
    camera.SetLookAtRotation(playerTransform.GetPosition());
    float deltaFOV = input.GetAxis(InputAxis::WAxis) * fovSpeed * InDeltaSeconds;
    camera.SetFOV(Math::Clamp(camera.GetFOV() + deltaFOV, minFOV, maxFOV));
}


// 렌더링 로직을 담당하는 함수
void SoftRenderer::Render3D()
{
    // 렌더링 로직에서 사용하는 모듈 내 주요 레퍼런스
    const GameEngine& g = Get3DGameEngine();
    auto& r = GetRenderer();
    const CameraObject& mainCamera = g.GetMainCamera();

    // 배경에 기즈모 그리기
    DrawGizmo3D();

    // 렌더링 로직의 로컬 변수
    const Matrix4x4 vMatrix = mainCamera.GetViewMatrix();
    const Matrix4x4 pMatrix = mainCamera.GetPerspectiveMatrix();

    for (auto it = g.SceneBegin(); it != g.SceneEnd(); ++it)
    {
        const GameObject& gameObject = *(*it);
        if (!gameObject.HasMesh() || !gameObject.IsVisible())
        {
            continue;
        }

        // 렌더링에 필요한 게임 오브젝트의 주요 레퍼런스를 얻기
        const Mesh& mesh = g.GetMesh(gameObject.GetMeshKey());
        const TransformComponent& transform = gameObject.GetTransform();

        // 원근투영행렬 * 뷰행렬 * 모델링행렬
        // (1) 결과는 클립 좌표의 값이겠다. 
        Matrix4x4 finalMatrix = pMatrix * vMatrix * transform.GetModelingMatrix();

        // 메시 그리기
        DrawMesh3D(mesh, finalMatrix, gameObject.GetColor());

        if (gameObject == PlayerGo)
        {
            // 플레이어의 위치
            r.PushStatisticText("Player: " + transform.GetPosition().ToString());
        }
    }

    r.PushStatisticText("Camera: " + mainCamera.GetTransform().GetPosition().ToString());
    r.PushStatisticText("FOV : " + std::to_string(mainCamera.GetFOV()));
}

// 삼각형을 그리는 함수
void SoftRenderer::DrawTriangle3D(std::vector<Vertex3D>& InVertices, const LinearColor& InColor, FillMode InFillMode)
{
    auto& r = GetRenderer();
    const GameEngine& g = Get3DGameEngine();

    // (2) 클립 좌표를 NDC 좌표로 변경
    for (auto& v : InVertices)
    {
        // 무한 원점인 경우, 약간 보정해준다.
        if (v.Position.Z == 0.f) v.Position.Z = SMALL_NUMBER;
        
        float invZ = 1.f / v.Position.Z;
        v.Position.X *= invZ;
        v.Position.Y *= invZ;
        v.Position.Z *= invZ;
    }

    // 백페이스 컬링
    Vector3 edge1 = (InVertices[1].Position - InVertices[0].Position).ToVector3();
    Vector3 edge2 = (InVertices[2].Position - InVertices[0].Position).ToVector3();
    Vector3 faceNormal = -edge1.Cross(edge2);
    Vector3 viewDirection = Vector3::UnitZ;
    if (faceNormal.Dot(viewDirection) >= 0.f)
    {
        return;
    }

    // (3) NDC 좌표를 화면 좌표로 늘리기
    for (auto& v : InVertices)
    {
        v.Position.X *= _ScreenSize.X * 0.5f;
        v.Position.Y *= _ScreenSize.Y * 0.5f;
    }

    LinearColor finalColor = _WireframeColor;
    if (InColor != LinearColor::Error)
    {
        finalColor = InColor;
    }

    r.DrawLine(InVertices[0].Position, InVertices[1].Position, finalColor);
    r.DrawLine(InVertices[0].Position, InVertices[2].Position, finalColor);
    r.DrawLine(InVertices[1].Position, InVertices[2].Position, finalColor);
}

class CameraObject
{
public:
    FORCEINLINE Matrix4x4 GetPerspectiveMatrix() const;
    FORCEINLINE Matrix4x4 GetPerspectiveViewMatrix() const;
    
private:
    float _FOV = 60.f;
    float _NearZ = 5.5f;
    float _FarZ = 5000.f;
};

// 깊이 값을 계산하는 최종 원근 투영 행렬
FORCEINLINE Matrix4x4 CameraObject::GetPerspectiveMatrix() const
{
    // 투영 행렬. 깊이 값의 범위는 -1~1
    float invA = 1.f / _ViewportSize.AspectRatio();
    float d = 1.f / tanf(Math::Deg2Rad(_FOV) * 0.5f);

    // 근평면과 원평면에 반대 부호를 붙여서 계산
    float invNF = 1.f / (_NearZ - _FarZ);
    float k = (_FarZ + _NearZ) * invNF;
    float l = 2.f * _FarZ * _NearZ * invNF;
    return Matrix4x4(
        Vector4::UnitX * invA * d,
        Vector4::UnitY * d,
        Vector4(0.f, 0.f, k, -1.f),
        Vector4(0.f, 0.f, l, 0.f)
    );
}

// 원근투영 행렬과 뷰 행렬을 곱한 행렬
FORCEINLINE Matrix4x4 CameraObject::GetPerspectiveViewMatrix() const
{
    // 뷰 행렬 관련 요소
    Vector3 viewX, viewY, viewZ;
    GetViewAxes(viewX, viewY, viewZ);
    Vector3 pos = _Transform.GetPosition();
    float zPos = viewZ.Dot(pos);

    // 투영 행렬 관련 요소
    float invA = 1.f / _ViewportSize.AspectRatio();
    float d = 1.f / tanf(Math::Deg2Rad(_FOV) * 0.5f);
    float dx = invA * d;
    float invNF = 1.f / (_NearZ - _FarZ);
    float k = (_FarZ + _NearZ) * invNF;
    float l = 2.f * _FarZ * _NearZ * invNF;

    return Matrix4x4(
        Vector4(dx * viewX.X, d * viewY.X, k * viewZ.X, -viewZ.X),
        Vector4(dx * viewX.Y, d * viewY.Y, k * viewZ.Y, -viewZ.Y),
        Vector4(dx * viewX.Z, d * viewY.Z, k * viewZ.Z, -viewZ.Z),
        Vector4(-dx * viewX.Dot(pos), -d * viewY.Dot(pos), -k * zPos + l, zPos)
    );
}

// 렌더링 로직을 담당하는 함수
void SoftRenderer::Render3D()
{
    // 렌더링 로직에서 사용하는 모듈 내 주요 레퍼런스
    const GameEngine& g = Get3DGameEngine();
    auto& r = GetRenderer();
    const CameraObject& mainCamera = g.GetMainCamera();

    // 배경에 기즈모 그리기
    DrawGizmo3D();

    // 원근 투영 행렬 * 뷰행렬의 결과 행렬
    const Matrix4x4 pvMatrix = mainCamera.GetPerspectiveViewMatrix();

    for (auto it = g.SceneBegin(); it != g.SceneEnd(); ++it)
    {
        const GameObject& gameObject = *(*it);
        if (!gameObject.HasMesh() || !gameObject.IsVisible())
        {
            continue;
        }

        // 렌더링에 필요한 게임 오브젝트의 주요 레퍼런스를 얻기
        const Mesh& mesh = g.GetMesh(gameObject.GetMeshKey());
        const TransformComponent& transform = gameObject.GetTransform();

        // 원근 투영 행렬 * 뷰행렬 * 모델링 행렬
        Matrix4x4 finalMatrix = pvMatrix * transform.GetModelingMatrix();

        // 메시 그리기
        DrawMesh3D(mesh, finalMatrix, gameObject.GetColor());

        if (gameObject == PlayerGo)
        {
            // 플레이어 관련 정보 나타내기
            
            // 플레이어의 클립 좌표 구하기
            Vector4 clippedPos = pvMatrix * Vector4(transform.GetPosition());
            // 클립 좌표의 네번째 요소 -Vz
            float cameraDepth = clippedPos.W;
            // -Vz가 0인 경우 0이 되지 않도록 보완해주기
            if (cameraDepth == 0) cameraDepth = SMALL_NUMBER;
            
            // NDC의 깊이값 계산: 클립좌표의 세번째 요소 / 클립좌표의 네번째 요소
            float ndcZ = clippedPos.Z / cameraDepth;

            r.PushStatisticText("Player: " + transform.GetPosition().ToString());
            r.PushStatisticText("Depth: " + std::to_string(ndcZ));
            r.PushStatisticText("Distance: " + std::to_string(clippedPos.W));
        }
    }

    r.PushStatisticText("Camera: " + mainCamera.GetTransform().GetPosition().ToString());
    r.PushStatisticText("FOV : " + std::to_string(mainCamera.GetFOV()));
}

// 삼각형을 그리는 함수
void SoftRenderer::DrawTriangle3D(std::vector<Vertex3D>& InVertices, const LinearColor& InColor, FillMode InFillMode)
{
    //...

        // 두 점이 화면 밖을 벗어나는 경우 클리핑 처리
        lowerLeftPoint.X = Math::Max(0, lowerLeftPoint.X);
        lowerLeftPoint.Y = Math::Min(_ScreenSize.Y, lowerLeftPoint.Y);
        upperRightPoint.X = Math::Min(_ScreenSize.X, upperRightPoint.X);
        upperRightPoint.Y = Math::Max(0, upperRightPoint.Y);

        // 각 정점마다 보존된 뷰 공간의 z값: 1/z1, 1/z2, 1/z3
        float invZ0 = 1.f / InVertices[0].Position.W;
        float invZ1 = 1.f / InVertices[1].Position.W;
        float invZ2 = 1.f / InVertices[2].Position.W;

        // 삼각형 영역 내 모든 점을 점검하고 색칠
        for (int x = lowerLeftPoint.X; x <= upperRightPoint.X; ++x)
        {
            for (int y = upperRightPoint.Y; y <= lowerLeftPoint.Y; ++y)
            {
                ScreenPoint fragment = ScreenPoint(x, y);
                Vector2 pointToTest = fragment.ToCartesianCoordinate(_ScreenSize);
                Vector2 w = pointToTest - InVertices[0].Position.ToVector2();
                float wdotu = w.Dot(u);
                float wdotv = w.Dot(v);

                float s = (wdotv * udotv - wdotu * vdotv) * invDenominator;
                float t = (wdotu * udotv - wdotv * udotu) * invDenominator;
                float oneMinusST = 1.f - s - t;

                if (((s >= 0.f) && (s <= 1.f)) && ((t >= 0.f) && (t <= 1.f)) && ((oneMinusST >= 0.f) && (oneMinusST <= 1.f)))
                {
                    // 투영보정에 사용할 공통 분모: z'
                    float z = invZ0 * oneMinusST + invZ1 * s + invZ2 * t;
                    float invZ = 1.f / z;
                    
                    Vector2 targetUV = (
                        InVertices[0].UV * oneMinusST * invZ0 + // q1/z1
                        InVertices[1].UV * s * invZ1 +   // q2/z2
                        InVertices[2].UV * t * invZ2  // q3/z3
                    ) * invZ;
                    
                    r.DrawPoint(fragment, FragmentShader3D(mainTexture.GetSample(targetUV), LinearColor::White));
                }
            }
        }
}

// 삼각형을 그리는 함수
void SoftRenderer::DrawTriangle3D(std::vector<Vertex3D>& InVertices, const LinearColor& InColor, FillMode InFillMode)
{
    //...
    
    // 삼각형 영역 내 모든 점을 점검하고 색칠
    for (int x = lowerLeftPoint.X; x <= upperRightPoint.X; ++x)
    {
        for (int y = upperRightPoint.Y; y <= lowerLeftPoint.Y; ++y)
        {
            //...
        
            if (((s >= 0.f) && (s <= 1.f)) && ((t >= 0.f) && (t <= 1.f)) && ((oneMinusST >= 0.f) && (oneMinusST <= 1.f)))
            {
                //...

                // 깊이 버퍼 테스팅
                if (toggleDepthTesting)
                {
                    // 깊이 테스팅
                    float newDepth = InVertices[0].Position.Z * oneMinusST + InVertices[1].Position.Z * s + InVertices[2].Position.Z * t;
                    
                    float prevDepth = r.GetDepthBufferValue(fragment);
                    
                    if (newDepth < prevDepth)
                    {
                        // 픽셀을 처리하기 전 깊이 값을 버퍼에 보관
                        r.SetDepthBufferValue(fragment, newDepth);
                    }
                    else
                    {
                        // 이미 앞에 무언가 그려져있으므로 픽셀그리기는 생략
                        continue;
                    }
                }

                Vector2 targetUV = (InVertices[0].UV * oneMinusST * invZ0 + InVertices[1].UV * s * invZ1 + InVertices[2].UV * t * invZ2) * invZ;
                
                r.DrawPoint(fragment, FragmentShader3D(mainTexture.GetSample(targetUV), LinearColor::White));
            }
        }
    }
}

// 삼각형을 그리는 함수
void SoftRenderer::DrawTriangle3D(std::vector<Vertex3D>& InVertices, const LinearColor& InColor, FillMode InFillMode)
{
    auto& r = GetRenderer();
    const GameEngine& g = Get3DGameEngine();
    const CameraObject& mainCamera = g.GetMainCamera();

    // 카메라의 근평면과 원평면 값
    float n = mainCamera.GetNearZ();
    float f = mainCamera.GetFarZ();

    //...
    
    // 삼각형 영역 내 모든 점을 점검하고 색칠
    for (int x = lowerLeftPoint.X; x <= upperRightPoint.X; ++x)
    {
        for (int y = upperRightPoint.Y; y <= lowerLeftPoint.Y; ++y)
        {
            //...
            
            if (((s >= 0.f) && (s <= 1.f)) && ((t >= 0.f) && (t <= 1.f)) && ((oneMinusST >= 0.f) && (oneMinusST <= 1.f)))
            {
                //...
            
                if (IsDepthBufferDrawing())
                {
                    float grayScale = (newDepth + 1.f) * 0.5f;
                    if (useLinearVisualization)
                    {
                        // 카메라로부터의 거리에 따라 균일하게 증감하는 흑백 값으로 변환
                        grayScale = (invZ - n) / (f - n);
                    }

                    // 뎁스 버퍼 그리기
                    r.DrawPoint(fragment, LinearColor::White * grayScale);
                }
                else
                {
                    // 최종 보정보간된 UV 좌표
                    Vector2 targetUV = (InVertices[0].UV * oneMinusST * invZ0 + InVertices[1].UV * s * invZ1 + InVertices[2].UV * t * invZ2) * invZ;
                    r.DrawPoint(fragment, FragmentShader3D(mainTexture.GetSample(targetUV), LinearColor::White));
                }
            }
        }
    }
}