[Game Math] Chapter 9. 게임 엔진: 콘텐츠를 만드는 기술

class TransformComponent
{
    // 회전하면 로컬 축을 갱신한다. 
    void SetRotation(float InDegree) { _Rotation = InDegree; Update(); }
    void AddRotation(float InDegree) { _Rotation += InDegree; Update(); }
    // ...
    
private:
    Vector2 _Position = Vector2::Zero;
    Vector2 _Rotation = 0.f;
    Vector2 _Scale = Vector2::One;

    Vector2 _Right = Vector2::UnityX;  // e1
    Vector2 _Up    = Vector2::UnityY;  // e2
};

// 열벡터를 사용해서 모델링 행렬을 만든다. 
FORCEINLINE Matrix3x3 TransformComponent::GetModelingMatrix() const
{
    return Matrix3x3(
        Vector3(_Scale.X * _Right.X, _Scale.X * _Right.Y, 0.f),
        Vector3(_ScaleY. * _Up.X,    _ScaleY. * _Up.Y,    0.f),
        Vector3(_Position.X,         _Position.Y,         1.f)
    );
}

// sin cos함수를 이용해서 현재 회전 정보에 맞는 로컬 축 벡터를 갱신한다. 
FORCEINLINE void TransformComponent::Update()
{
    float sin, cos;
    Math::GetSinCos(sin, cos, _Rotation); // 발생한 회전의 sin, cos 값을 얻는다. 
    
    _Right = Vector2(cos, sin);  // e1
    _Up    = Vector2(-sin, cos); // e2
}

// 1. 리소스 로딩 단계

// 메시
const std::size_t GameEngine::QuadMesh = std::hash<std::string>()("SM_Quad");

// 텍스처
const std::size_t GameEngine::BaseTexture = std::hash<std::string>()("Base");
const std::string GameEngine::CharacterTexturePath("CKMan.png");


bool GameEngine::LoadResources()
{
    // 사각형 메시 데이터 객체를 생성하고 QuadMesh 키를 부여한다. 
    Mesh& quadMesh = CreateMesh(GameEngine::QuadMesh);

    constexpr float squareHalfSize = 0.5f;
    constexpr int vertexCount = 4;
    constexpr int triangleCount = 2;
    constexpr int indexCount = triangleCount * 3;

    auto& v = quadMesh.GetVertices(); // 정점 버퍼
    auto& i = quadMesh.GetIndices();  // 인덱스 버퍼
    auto& uv = quadMesh.GetUVs();     // UV 값

    v = {
        Vector2(-squareHalfSize, -squareHalfSize),
        Vector2(-squareHalfSize, squareHalfSize),
        Vector2(squareHalfSize, squareHalfSize),
        Vector2(squareHalfSize, -squareHalfSize)
    };

    uv = {
        Vector2(0.125f, 0.75f),
        Vector2(0.125f, 0.875f),
        Vector2(0.25f, 0.875f),
        Vector2(0.25f, 0.75f)
    };

    i = {
        0, 2, 1, 0, 3, 2
    };

    // 텍스처 객체를 생성하고 BaseTexture 키를 부여한다. 
    Texture& baseTexture = CreateTexture(GameEngine::BaseTexture, GameEngine::CharacterTexturePath);
    
    // ...
}

// 2. 씬 구축 단계

// 게임 오브젝트 목록
static const std::string PlayerGo("Player");

// 최초 씬 로딩을 담당하는 함수
void SoftRenderer::LoadScene2D()
{
    // 최초 씬 로딩에서 사용하는 모듈 내 주요 레퍼런스
    auto& g = Get2DGameEngine();

    // 플레이어의 생성과 설정
    constexpr float playerScale = 30.f;
    GameObject& goPlayer = g.CreateNewGameObject(PlayerGo);  // 게임 오브젝트를 생성한다. 
    goPlayer.SetMesh(GameEngine::QuadMesh);  // 메시 키를 설정한다. 
    goPlayer.GetTransform().SetScale(Vector2::One * playerScale);  // 최초 트랜스폼을 설정한다. 
    goPlayer.SetColor(LinearColor::Red);

    // 100개의 배경 게임 오브젝트 생성과 설정
    char name[64];
    constexpr float squareScale = 20.f;
    std::mt19937 generator(0);
    std::uniform_real_distribution<float> dist(-1000.f, 1000.f);
    for (int i = 0; i < 100; ++i)
    {
        std::snprintf(name, sizeof(name), "GameObject%d", i);
        GameObject& newGo = g.CreateNewGameObject(name);
        newGo.GetTransform().SetPosition(Vector2(dist(generator), dist(generator)));
        newGo.GetTransform().SetScale(Vector2::One * squareScale);
        newGo.SetMesh(GameEngine::QuadMesh);
        newGo.SetColor(LinearColor::Blue);
    }
}

// 3. 게임 로직 단계

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

    // 게임 로직의 로컬 변수
    static float moveSpeed = 200.f;
    static float rotateSpeed = 180.f;
    static float scaleMin = 15.f;
    static float scaleMax = 30.f;
    static float scaleSpeed = 180.f;

    // 플레이어에 대한 주요 레퍼런스
    GameObject& goPlayer = g.GetGameObject(PlayerGo);
    TransformComponent& transform = goPlayer.GetTransform();

    // 입력에 따른 플레이어 위치와 크기의 변경
    float newScale = Math::Clamp(transform.GetScale().X + scaleSpeed * input.GetAxis(InputAxis::ZAxis) * InDeltaSeconds, scaleMin, scaleMax);
    transform.SetScale(Vector2::One * newScale);
    transform.AddRotation(input.GetAxis(InputAxis::XAxis) * rotateSpeed * InDeltaSeconds);
    transform.AddPosition(transform.GetLocalY() * input.GetAxis(InputAxis::YAxis) * moveSpeed * InDeltaSeconds);
}

// 4. 렌더링 로직 단계

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

    // 배경에 격자 그리기
    DrawGizmo2D();

    // 렌더링 로직의 로컬 변수
    size_t totalObjectCount = g.GetScene().size();

    // 씬을 구성하는 모든 게임 오브젝트의 순회
    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();
        Matrix3x3 finalMatrix = transform.GetModelingMatrix();

        // 게임 오브젝트의 렌더링 수행 - 다음 절의 렌더링 파이프라인의 시작.
        DrawMesh2D(mesh, finalMatrix, gameObject.GetColor());

        // 플레이어의 정보를 화면에 출력
        if (gameObject == PlayerGo)
        {
            r.PushStatisticText("Player Position : " + transform.GetPosition().ToString());
            r.PushStatisticText("Player Rotation : " + std::to_string(transform.GetRotation()) + " (deg)");
            r.PushStatisticText("Player Scale : " + std::to_string(transform.GetScale().X));
        }
    }
}

// 1. 정점 변환과 처리

// 메시를 그리는 함수
void SoftRenderer::DrawMesh2D(const class DD::Mesh& InMesh, const Matrix3x3& InMatrix, const LinearColor& InColor)
{
    // 메시의 구조를 파악하기 위한 로컬 변수
    size_t vertexCount = InMesh.GetVertices().size();
    size_t indexCount = InMesh.GetIndices().size();
    size_t triangleCount = indexCount / 3;

    // 메시 정보를 렌더러가 사용할 정점 버퍼와 인덱스 버퍼로 변환
    std::vector<Vertex2D> vertices(vertexCount);
    std::vector<size_t> indice(InMesh.GetIndices());
    for (size_t vi = 0; vi < vertexCount; ++vi)
    {
        vertices[vi].Position = InMesh.GetVertices()[vi];
        if (InMesh.HasColor())
        {
            vertices[vi].Color = InMesh.GetColors()[vi];
        }

        if (InMesh.HasUV())
        {
            vertices[vi].UV = InMesh.GetUVs()[vi];
        }
    }

    // 정점 변환 진행!!
    VertexShader2D(vertices, InMatrix);

    // 그리기모드 설정
    FillMode fm = FillMode::None;
    if (InMesh.HasColor())
    {
        fm |= FillMode::Color;
    }
    if (InMesh.HasUV())
    {
        fm |= FillMode::Texture;
    }

    // 메시를 삼각형으로 쪼개서 각각 그리기
    for (int ti = 0; ti < triangleCount; ++ti)
    {
        int bi0 = ti * 3, bi1 = ti * 3 + 1, bi2 = ti * 3 + 2;
        std::vector<Vertex2D> tvs = { vertices[indice[bi0]] , vertices[indice[bi1]] , vertices[indice[bi2]] };
        
        // 2. 픽셀화
        DrawTriangle2D(tvs, InColor, fm);
    }
}

// 정점 셰이더

FORCEINLINE void VertexShader2D(std::vector<Vertex2D>& InVertices, const Matrix3x3& InMatrix)
{
    // 위치 값에 최종 행렬을 적용해 변환
    for (Vertex2D& v : InVertices)
    {
        v.Position = InMatrix * v.Position;
    }
}

// 2. 픽셀화와 픽셀 처리

// 삼각형을 그리는 함수
void SoftRenderer::DrawTriangle2D(std::vector<DD::Vertex2D>& InVertices, const LinearColor& InColor, FillMode InFillMode)
{
    // 렌더링 로직에서 사용하는 모듈 내 주요 레퍼런스
    auto& r = GetRenderer();
    const GameEngine& g = Get2DGameEngine();
    const Texture& texture = g.GetTexture(GameEngine::BaseTexture);

    if (IsWireframeDrawing())
    {
        // 와이어 프레임 모드
    }
    else
    {
        // ... 삼각형 칠하기
        
        // 삼각형 영역 내 모든 점을 점검하고 색칠
        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;
                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)))
                {
                    Vector2 targetUV = InVertices[0].UV * oneMinusST + InVertices[1].UV * s + InVertices[2].UV * t;
                    
                    // 색상 결정 진행!!
                    r.DrawPoint(fragment, FragmentShader2D(texture.GetSample(targetUV), LinearColor::White));
                }
            }
        }
    }
}

// 픽셀 셰이더 (단순하게 흰색을 합성해서 고유의 색을 표현하도록 함)

FORCEINLINE LinearColor FragmentShader2D(LinearColor& InColor, const LinearColor& InColorParam)
{
    return InColor * InColorParam;
}

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

    // 게임 로직의 로컬 변수
    static float moveSpeed = 200.f;
    static float rotateSpeed = 180.f;
    static float scaleMin = 15.f;
    static float scaleMax = 30.f;
    static float scaleSpeed = 180.f;
    static float minDistance = 1.f; // 플레이어와 카메라의 위치가 일치할 최소거리
    static float lerpSpeed = 2.f; // 플레이어가 카메라를 쫒아가는 속도

    // 플레이어에 대한 주요 레퍼런스
    GameObject& goPlayer = g.GetGameObject(PlayerGo);
    TransformComponent& transform = goPlayer.GetTransform();

    // 입력에 따른 플레이어 위치와 크기의 변경
    transform.AddPosition(Vector2(input.GetAxis(InputAxis::XAxis), input.GetAxis(InputAxis::YAxis)).GetNormalize() * moveSpeed * InDeltaSeconds);
    float newScale = Math::Clamp(transform.GetScale().X + scaleSpeed * input.GetAxis(InputAxis::ZAxis) * InDeltaSeconds, scaleMin, scaleMax);
    transform.SetScale(Vector2::One * newScale);
    transform.AddRotation(input.GetAxis(InputAxis::WAxis) * rotateSpeed * InDeltaSeconds);

    // 플레이어를 따라다니는 카메라의 트랜스폼
    TransformComponent& cameraTransform = g.GetMainCamera().GetTransform();
    Vector2 playerPos = transform.GetPosition();
    Vector2 cameraPos = cameraTransform.GetPosition();
    if ((playerPos - cameraPos).SizeSquared() < minDistance * minDistance)
    {
        // 최소거리보다 작으면 플레이어 위치로 간다. 
        cameraTransform.SetPosition(playerPos);
    }
    else // 최소거리보다 크면 서서히 이동한다. 
    {
        float ratio = Math::Clamp(lerpSpeed * InDeltaSeconds, 0.f, 1.f);
        Vector2 newCameraPos = cameraPos + (playerPos - cameraPos) * ratio;
        cameraTransform.SetPosition(newCameraPos);
    }
}

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

    // 배경에 격자 그리기
    DrawGizmo2D();

    // 렌더링 로직의 로컬 변수
    size_t totalObjectCount = g.GetScene().size();
    Matrix3x3 viewMatrix = g.GetMainCamera().GetViewMatrix(); // 뷰 행렬

    // 씬을 구성하는 모든 게임 오브젝트의 순회
    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();
        Matrix3x3 finalMatrix = viewMatrix * transform.GetModelingMatrix(); // 뷰행렬 * 모델링 행렬으로 VM을 구한다 

        // 게임 오브젝트의 렌더링 수행
        DrawMesh2D(mesh, finalMatrix, gameObject.GetColor());
        
        // 플레이어의 정보를 화면에 출력
        if (gameObject == PlayerGo)
        {
            r.PushStatisticText("Player Position : " + transform.GetPosition().ToString());
            r.PushStatisticText("Player Rotation : " + std::to_string(transform.GetRotation()) + " (deg)");
            r.PushStatisticText("Player Scale : " + std::to_string(transform.GetScale().X));
        }
    }
}