[Game Math] Chapter 17. 캐릭터: 게임에 생기를 불어넣는 기술

enum class MeshType : UINT32
{
    Normal = 0,
    Skinned
};

class Bone
{
private:
    std::size_t _Hash = 0;
    std::string _Name;
    Transform _Transform;
    Transform _Bindpose;
};

struct Weight
{
    std::vector<std::string> Bones; // 어떤 본들이 
    std::vector<float> Values;      // 얼마나 영향을 주는지 
};

bool GameEngine::LoadResources()
{
    // 사각 메시
    // ...

    // 스킨드 메시로 설정한다. 
    quadMesh.SetMeshType(MeshType::Skinned);

    auto& bones = quadMesh.GetBones();
    auto& connectedBones = quadMesh.GetConnectedBones();
    auto& weights = quadMesh.GetWeights();

    // 본 정보를 설정한다. 
    bones = {
        {"left", Bone("left", Transform(Vector3(-1.f, 0.f, 0.f) * halfSize))},
        {"right", Bone("right", Transform(Vector3(1.f, 0.f, 0.f) * halfSize))}
    };
    // 4개의 정점은 본이 각각 1개씩 연결되어 있다. 
    connectedBones = { 1, 1, 1, 1 };
    // 정점마다의 본 이름과 가중치를 설정한다. 
    weights = {
        { {"left"}, {1.f} },
        { {"left"}, {1.f} },
        { {"right"}, {1.f} },
        { {"right"}, {1.f} }
    };
    
    // ...
}

// 애니메이션 로직 : 본의 위치를 설정
void SoftRenderer::LateUpdate3D(float InDeltaSeconds)
{
    GameEngine& g = Get3DGameEngine();

    static float duration = 3.f;
    static float elapsedTime = 0.f;

    // 애니메이션을 위한 커브 생성
    // 시간에 따라 [0, 1]범위의 사인 파형을 생성하고 본을 움직이는 데 사용한다.  
    // (키프레임 데이터를 대체하기 위해 간단하게 sin 곡선을 사용했다.)
    
    // elapsedTime은 시간에 따라 0~3의 값이 나온다. 
    elapsedTime = Math::Clamp(elapsedTime + InDeltaSeconds, 0.f, duration);
    if (elapsedTime == duration)
    {
        elapsedTime = 0.f;
    }
    // 0~360 사이의 값으로 대응시킨다. 
    float sinParam = elapsedTime / duration * Math::TwoPI ;
    // -1~1 사이의 sin 결과 값을 0~1 사이의 값으로 대응시킨다. 
    float sinWave = (sinf(sinParam) + 1.f) * 0.5f;

    // 스킨드 메시가 아니면 종료한다. 
    GameObject& goPlayer = g.GetGameObject(PlayerGo);
    Mesh& m = g.GetMesh(goPlayer.GetMeshKey());
    if (!m.IsSkinnedMesh()) 
    {
        return;
    }

    const std::string leftBoneName("left");
    const std::string rightBoneName("right");
    Transform& leftBoneTransform = m.GetBone(leftBoneName).GetTransform();
    Transform& rightBoneTransform = m.GetBone(rightBoneName).GetTransform();

    // 기준 위치에서 추가로 움직인 본의 위치를 계산한다. 
    Vector3 deltaLeftPosition = Vector3::UnitX * -sinWave;
    Vector3 deltaRightPosition = Vector3::UnitX * sinWave;

    // 본의 바인드 포즈(최초 위치)를 기준으로 변경된 위치를 더해서 최종 위치를 계산한다. 
    leftBonePosition = m.GetBindPose(leftBoneName).GetPosition() + deltaLeftPosition;
    rightBonePosition = m.GetBindPose(rightBoneName).GetPosition() + deltaRightPosition;

    // 최종 위치를 설정한다. 
    leftBoneTransform.SetPosition(leftBonePosition);
    rightBoneTransform.SetPosition(rightBonePosition);
}

// 메시를 그리는 함수
void SoftRenderer::DrawMesh3D(const Mesh& InMesh, const Matrix4x4& InMatrix, const LinearColor& InColor)
{
    size_t vertexCount = InMesh.GetVertices().size();
    size_t indexCount = InMesh.GetIndices().size();
    size_t triangleCount = indexCount / 3;

    std::vector<Vertex3D> vertices(vertexCount);
    std::vector<size_t> indice(InMesh.GetIndices());
    for (size_t vi = 0; vi < vertexCount; ++vi)
    {
        vertices[vi].Position = Vector4(InMesh.GetVertices()[vi]);

        // 정점 변환 전에, 본의 움직임을 반영한다. 
        if (InMesh.IsSkinnedMesh())
        {
            Vector4 totalPosition = Vector4::Zero;
            Weight w = InMesh.GetWeights()[vi];
            
            // 메시에 연결된 본의 개수에 따라 반복
            for (size_t wi = 0; wi < InMesh.GetConnectedBones()[vi]; ++wi)
            {
                std::string boneName = w.Bones[wi];
                if (InMesh.HasBone(boneName) == false) continue;
                
                const Transform& boneTransform = InMesh.GetBone(boneName).GetTransform();
                
                // 본 - 바인드포즈 = 바인드 포즈로부터의 상대적 위치 
                Vector3 deltaPosition = boneTransform.GetPosition() - InMesh.GetBindPose(boneName).GetPosition();
                
                // 상대적 위치에 웨이트 값을 적용시킨다. 
                totalDeltaPosition += deltaPosition * w.Values[wi];
            }

            // 정점 위치에 반영한다. 
            vertices[vi].Position += Vector4(totalDeltaPosition, false);
        }

        if (InMesh.HasColor())
        {
            vertices[vi].Color = InMesh.GetColors()[vi];
        }

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

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

    // 삼각형 별로 그리기
    // ....
}

class TransformComponent
{
public:
    bool SetRoot();
    TransformComponent& GetRoot();
    bool SetParent(TransformComponent& InTransform);
    
private:
    // 부모와 자식 목록을 보관한다. 
    TransformComponent* _ParentPtr = nullptr;
    std::vector<TransformComponent*> _ChildrenPtr;

    // 매번 월드 트랜스폼을 로컬 트랜스폼으로 계산해 주기 보다는 
    // 두 가지 트랜스폼을 모두 보관해 놓으면 좋겠다. 
    Transform _LocalTransform;
    Transform _WorldTransform;
};

// 로컬 트랜스폼 -> 월드 트랜스폼
FORCEINLINE constexpr Transform Transform::LocalToWorld(const Transform& InParentWorldTransform) const
{
    Transform result;
    
    // 크기
    result.SetScale(InParentWorldTransform.GetScale() * GetScale());
    
    // 회전
    result.SetRotation(InParentWorldTransform.GetRotation() * GetRotation());
    
    // 이동 
    result.SetPosition(InParentWorldTransform.GetPosition() + InParentWorldTransform.GetRotation() * (InParentWorldTransform.GetScale() * GetPosition()));
    
    return result;
}

FORCEINLINE constexpr Transform Transform::Inverse() const
{
    Vector3 reciprocalScale = Vector3::Zero;
    Transform result;

    // 크기 
    // 트랜스폼 크기 값에 0이 있을 수도 있으므로
    // 이럴 때는 안전하게 역수로 구성된 벡터를 사용한다. 
    if (!Math::EqualsInTolerance(Scale.X, 0.f)) reciprocalScale.X = 1.f / Scale.X;
    if (!Math::EqualsInTolerance(Scale.Y, 0.f)) reciprocalScale.Y = 1.f / Scale.Y;
    if (!Math::EqualsInTolerance(Scale.Z, 0.f)) reciprocalScale.Z = 1.f / Scale.Z;
    result.SetScale(reciprocalScale);
    
    // 회전 
    result.SetRotation(Rotation.Inverse());
    
    // 이동 
    result.SetPosition(result.GetScale() * (result.GetRotation() * -Position));
    
    return result;
}

// 월드 트랜스폼 -> 로컬 트랜스폼
FORCEINLINE constexpr Transform Transform::WorldToLocal(const Transform& InParentWorldTransform) const
{
    // 부모 트랜스폼의 역변환 구하기 
    Transform invParent = InParentWorldTransform.Inverse();
    Transform result;

    // 크기 
    result.SetScale(invParent.GetScale() * GetScale());
    
    // 회전 
    result.SetRotation(invParent.GetRotation() * GetRotation());
    
    // 이동 
    result.SetPosition(invParent.GetPosition() + (invParent.GetRotation() * (invParent.GetScale() * GetPosition())));
    
    return result;
}

// 메시를 그리는 함수
void SoftRenderer::DrawMesh3D(const Mesh& InMesh, const Matrix4x4& InMatrix, const LinearColor& InColor)
{
    size_t vertexCount = InMesh.GetVertices().size();
    size_t indexCount = InMesh.GetIndices().size();
    size_t triangleCount = indexCount / 3;

    std::vector<Vertex3D> vertices(vertexCount);
    std::vector<size_t> indice(InMesh.GetIndices());
    for (size_t vi = 0; vi < vertexCount; ++vi)
    {
        vertices[vi].Position = Vector4(InMesh.GetVertices()[vi]);

        // 정점 변환 전에, 본의 움직임을 반영한다. 
        if (InMesh.IsSkinnedMesh())
        {
            Vector4 totalPosition = Vector4::Zero;
            Weight w = InMesh.GetWeights()[vi];
            
            // 해당 정점에 연결된 본의 개수에 따라 반복한다. 
            for (size_t wi = 0; wi < InMesh.GetConnectedBones()[vi]; ++wi)
            {
                std::string boneName = w.Bones[wi];
                if (InMesh.HasBone(boneName) == false) continue;
                
                const Bone& b = InMesh.GetBone(boneName);
                const Transform& t = b.GetTransform().GetWorldTransform();
                const Transform& bindPose = b.GetBindPose();
                
                // 바인드 포즈를 중심으로 본의 로컬 트랜스폼을 계산한다.
                Transform boneLocal = t.WorldToLocal(bindPose);
                
                // 바인드 포즈를 중심으로 정점의 로컬 좌표를 얻는다. 
                Vector3 localPosition = bindPose.WorldToLocalVector(vertices[vi].Position.ToVector3());
                
                // 본의 로컬 트랜스폼 행렬 * 정점의 로컬 좌표 = 바인드포즈에서 변화된 좌표 계산
                Vector3 skinnedLocalPosition = boneLocal.GetMatrix() * localPosition;
                
                // 바인드 포즈의 행렬 * 바인드포즈에서 변화된 좌표 = 모델링 공간으로 되돌리기 
                Vector3 skinnedWorldPosition = bindPose.GetMatrix() * skinnedLocalPosition;
                
                // 가중치를 반영한 후, 최종 위치에 누적시킨다. 
                totalPosition += Vector4(skinnedWorldPosition, true) * w.Values[wi];
            }

            // 정점 위치에 반영한다. 
            vertices[vi].Position = totalPosition;
        }

        if (InMesh.HasColor())
        {
            vertices[vi].Color = InMesh.GetColors()[vi];
        }

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

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

    // 삼각형 별로 그리기
    // ...
}