[번역] 튜토리얼 38 : Skeletal Animation with Assimp

원본 : https://ogldev.org/www/tutorial38/tutorial38.html

배경

마침내 수백만명의 독자들이 요구해온 튜토리얼. 스키닝으로도 알려진 골격 애니메이션으로, Assimp 라이브러리를 사용합니다.

 

골격 애니메이션은 사실 두 부분으로 이루어진 과정입니다.

첫 번째는 아티스트가 실행하고 두 번째는 프로그래머인 사용자(또는 작성한 엔진)가 실행합니다.

첫 번째 부분은 모델링 소프트웨어 내부에서 발생하며 리깅이라고 합니다.

여기서 일어나는 일은 아티스트가 mesh 아래 뼈(skeleton)의 골격(bones)을 정의하는 것입니다.

mesh는 물체의 피부(인간이든 괴물이든 무엇이든)를 나타내며 skeleton은 실제 세계에서 실제 움직임을 모방하는 방식으로 mesh를 움직이는데 사용됩니다.

이 작업은 각 정점을 하나 이상의 뼈에 할당하여 수행됩니다.

정점이 뼈에 할당되면 뼈가 이동할 때 정점에 미치는 영향의 양을 결정하는 가중치가 정의됩니다.

일반적인 방법은 모든 가중치의 합을 (정점당) 1로 만드는 것입니다.

예를 들어, 꼭짓점이 두 뼈 사이에 정확히 위치한다면 우리는 뼈가 꼭짓점에 미치는 영향이 같을 것으로 예상하기 때문에 각 뼈에 0.5의 가중치를 할당하고 싶을 것입니다. 그러나 꼭짓점이 완전히 단일 뼈의 영향 범위 내에 있는 경우 가중치는 1이 됩니다(뼈가 정점의 움직임을 자율적으로 제어함).

 

블렌더에서 생성된 골격 구조의 예는 다음과 같습니다:

 

우리가 위에서 본 것은 사실 애니메이션의 중요한 부분입니다. 아티스트는 골격 구조를 연결하고 각 애니메이션 유형("walk","run","die" 등)에 대한 키 프레임 세트를 정의합니다.

키 프레임에는 애니메이션 경로를 따라 임계점에 있는 모든 뼈의 변환이 포함되어 있습니다.

그래픽 엔진은 키 프레임의 변환 사이를 보간하여 키 프레임 간의 부드러운 움직임을 만듭니다.

 

골격 애니메이션에 사용되는 골격 구조는 종종 계층 구조입니다.

이것은 skeleton이 자식/부모 관계를 가지고 있으므로 skeleton tree가 생성된다는 것을 의미합니다.

root bone을 제외한 모든 뼈에는 부모가 하나씩 있습니다.

예를 들어, 인체의 경우 팔, 다리, 손가락 뼈와 같은 자식 뼈를 다음 단계로 하여 등뼈를 root로 지정할 수 있습니다.

부모의 뼈가 움직이면 모든 자식 뼈들도 움직이지만, 자식의 뼈가 움직이면 부모는 움직이지 않습니다(우리의 손가락은 손을 움직이지 않고도 움직일 수 있지만, 손이 움직이면 모든 손가락이 움직입니다). 실질적인 관점에서 이것은 우리가 뼈의 변형을 처리할 때 그것을 그것으로부터 root로 이끄는 모든 부모 뼈의 변형과 결합할 필요가 있다는 것을 의미합니다.

 

더 이상 조작에 대해 논의하지 않을 것입니다. 그것은 그래픽 프로그래머의 영역 밖에 있는 복잡한 주제입니다. 모델링 소프트웨어는 예술가가 이 일을 할 수 있도록 도와주는 고급 도구를 가지고 있으며 당신은 멋집 mesh와 skeleton을 만들기 위해 훌륭한 예술가가 되어야 합니다. skeletal 애니메이션을 만들기 위해 그래픽 엔진이 무엇을 해야 하는지 알아보겠습니다.

 

첫 번재 단계는 정점 버퍼를 정점별 골격 정보로 보강하는 것입니다.

몇 가지 옵션을 사용할 수 있지만 우리가 하려는 것은 매우 간단합니다.

각 꼭짓점에 대해 각 슬롯에 골격 ID와 가중치가 포함된 슬롯 배열을 추가합니다.

우리의 삶을 더 단순하게 만들기 위해 우리는 4개의 슬롯이 있는 배열을 사용할 것입니다.

이것은 4개 이상의 뼈에 의해 영향을 받을 수 있는 정점이 없다는 것을 의미합니다.

골격이 더 많은 모델을 로드하려면 배열 크기를 조정해야 하지만 이 튜토리얼 데모에 포함된 Doom 3 모델의 경우 골격 4개로 충분합니다. 그래서 우리의 새로운 꼭짓점 구조는 다음과 같이 보일 것입니다.

 

 

bone ID는 bone 변환 배열의 인덱스입니다.

이러한 변환은 WVP 행렬 앞의 위치와 정규에 적용됩니다(즉, 정점을 "bone space"에서 로컬 공간으로 변환).

가중치는 여러 뼈의 변환을 하나의 변환으로 결합하는 데 사용되며, 어떤 경우에도 총 가중치는 정확히 1(모델링 소프트웨어의 책임)이어야 합니다. 일반적으로 애니메이션 키 프레임 사이를 보간하고 모든 프레임의 골격 변환 배열을 업데이트합니다.

 

뼈 변형의 배열이 만들어지는 방법은 대개 까다로운 부분입니다.

변환은 계층 구조(즉, 트리)로 설정되며 일반적인 방법은 트리의 모든 노트에 스케일링 벡터, 회전 쿼터 및 변환 벡터를 갖는 것입니다.

실제로 각 노드에는 이러한 항목의 배열이 포함되어 있습니다. 배열의 모든 항목에는 타임스탬프가 있어야합니다. 응용 프로그램 시간이 타임스탬프 중 하나와 정확히 일치하는 경우는 드물기 때문에 응용 프로그램의 시점에 대한 정확한 변환을 얻으려면 코드가 스케일링/회전/번역을 보간할 수 있어야 합니다.

우리는 현재의 뼈에서 root까지 각 노드에 대해 동일한 프로세스를 수행하고 이 변환 체인을 함께 곱하여 최종 결과를 얻습니다. 각 골격에 대해 이 작업을 수행한 다음 쉐이더를 업데이트합니다.

 

지금까지 우리가 이야기한 모든 것은 꽤 일반적이었습니다.

하지만 이것은 Assimp의 골격 애니메이션에 대한 튜토리얼 입니다.

그래서 우리는 그 라이브러리에 다시 들어가서 어떻게 스키닝을 할 수 있는지 볼 필요가 있습니다.

Assimip의 좋은 점은 여러 형식의 골격 정보 로드를 지원한다는 것입니다.

나쁜점은 쉐이더에 필요한 골격 변환을 생성하기 위해 생성되는 데이터 구조에 대해 여전히 상당한 작업이 필요하다는 것입니다.

 

정점 수준의 뼈 정보부터 시작해보겠습니다. 다음은 Assimp 데이터 구조의 관련 부분입니다:

 

 

아마 Assimp에 대한 튜토리얼에서 기억하시겠지만, 모든 것이 aiScene 클래스(매쉬 파일을 가져올 때 받는 개체)에 포함되어 있습니다. aiScene에는 aiMesh 개체의 배열이 포함되어 있습니다. aiMesh는 모델의 일부이며 위치, 정규 텍스처 좌표 등과 같은 정점 수준의 항목을 포함합니다. 이제 aiMesh에는 aiBone 객체의 배열도 포함되어 있습니다.

놀랄 것도 없이, aiBone은 mesh의 골격에 있는 하나의 뼈를 나타냅니다. 각 골격에는 골격 계층 구조(아래 참조), 정점 가중치 배열 및 4x4 오프셋 행렬에서 찾을 수 있는 이름이 있습니다. 이 행렬이 필요한 이유는 정점이 일반적인 로컬 공간에 저장되기 때문입니다. 이는 골격 애니메이션이 지원되지 않더라도 기존 코드 기반이 모델을 로드하고 올바르게 렌더링할 수 있음을 의미합니다. 그러나 계층 구조의 뼈 변환은 뼈 공간에서 작동합니다.(그리고 모든 뼈는 고유한 공간을 가지고 있습니다. 이것이 우리가 함께 변환을 곱해야 하는 이유입니다). 오프셋 매트릭스의 작업은 매쉬의 국소 공간에서 정점 위치를 특정 뼈의 공간으로 이동시키는 것입니다.

 

정점 가중치 배열은 사물들이 흥미로워지기 시작하는 곳입니다.

이 배열의 각 항목에는 aiMesh의 정점 배열에 대한 인덱스(꼭짓점이 동일한 길이를 가진 여러 배열에 걸쳐 분산됨)와 가중치가 포함됩니다. 모든 꼭짓점 가중치의 합은 1이어야 하지만 이를 찾으려면 모든 뼈를 통과하고 각 특정 꼭짓점에 대한 일종의 목록으로 가중치를 누적해야 합니다.

 

정점 수준에서 골격 정보를 구축한 후 골격 변환 계층 구조를 처리하고 쉐이더에 로드할 최종 변환을 생성해야 합니다. 다음 그림에는 관련 데이터 구조가 표시되어 있습니다:

 

 

다시, 우리는 aiScene에서 시작합니다. aiScene 개체에는 노드 계층 구조(즉, 트리)의 루트인 aiNode 클래스의 개체에 대한 포인터가 포함되어 있습니다. 트리의 각 노드에는 부모에 대한 포인터와 자식에 대한 포인터 배열이 있습니다. 이것은 우리가 tree를 편리하게 왔다갔다 할 수 있게 해줍니다.

또한 노드는 노드 공간에서 부모 공간으로 변환하는 변환 행렬을 전달합니다. 마지막으로 노드에 이름이 있을 수도 있고 없을 수도 있습니다. 노드가 계층에서 골격을 나타내는 경우 노드 이름이 골격 이름과 일치해야 합니다. 그러나 노드에 이름이 없는 경우(즉, 대응하는 골격이 없음) 노드의 역할은 단순히 모델을 분해하고 중간 변환을 배치하는 것을 돕는 것입니다.

 

퍼즐의 마지막 조각은 aiScene 객체에도 저장된 aiAnimation 배열입니다. 단일 aiAnimation 객체는 "walk", "run", "shoot" 등과 같은 일련의 애니메이션 프레임을 나타냅니다. 프레임 사이를 보간함으로써 애니메이션 이름과 일치하는 원하는 시각적 효과를 얻을 수 있습니다. 애니메이션에는 눈금의 지속 시간과 초당 눈금 수(예: 100개의 눈금과 25개의 눈금은 4초의 애니메이션을 나타냄)가 있어 애니메이션이 모든 하드웨어에서 동일하게 보이도록 진행 시간을 조정할 수 있습니다. 또한 이 애니메이션에는 채널이라고 하는 aiNodeAnim 객체의 배열이 있습니다. 각각의 채널은 사실 모든 변형이 있는 뼈입니다. 채널에는 계층 구조의 노드 중 하나와 세 개의 변환 배열과 일치해야 하는 이름이 포함되어 있습니다.

 

특정 시점의 최종 뼈 변환을 계산하기 위해서는 이 세 배열에서 각각 시간과 일치하는 두 개의 항목을 찾고 그 사이를 보간해야 합니다. 그런 다음 변환을 하나의 행렬로 결합해야 합니다. 이 작업을 수행한 후에는 계층 구조에서 해당 노드를 찾아 상위 노드로 이동해야 합니다. 그러면 부모에 해당하는 채널이 필요하고 동일한 보간 과정을 수행해야 합니다. 우리는 두 변환을 함께 곱하고 계층의 root에 도달할 때까지 계속합니다.

Source Walthru

(mesh.cpp:75)

bool Mesh::LoadMesh(const string& Filename)
{
    // Release the previously loaded mesh (if it exists)
    Clear();

    // Create the VAO
    glGenVertexArrays(1, &m_VAO);
    glBindVertexArray(m_VAO);

    // Create the buffers for the vertices attributes
    glGenBuffers(ARRAY_SIZE_IN_ELEMENTS(m_Buffers), m_Buffers);

    bool Ret = false;

    m_pScene = m_Importer.ReadFile(Filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals |
                                    aiProcess_FlipUVs);

    if (m_pScene) {
       m_GlobalInverseTransform = m_pScene->mRootNode->mTransformation;
       m_GlobalInverseTransform = m_GlobalInverseTransform.Inverse();
       Ret = InitFromScene(m_pScene, Filename);
    }
    else {
       printf("Error parsing '%s': '%s'\n", Filename.c_str(), m_Importer.GetErrorString());
    }

    // Make sure the VAO is not changed from the outside
    glBindVertexArray(0);

    return Ret;
}

다음은 매쉬 클래스의 업데이트된 진입점으로, 변경 사항은 굵은 글씨로 표시됩니다. 우리가 주목해야 할 몇 가지 변화가 있습니다. 하나는 임포터와 aiScene 개체가 이제 변수를 쌓지 않고 클래스 멤버가 된다는 것입니다. 그 이유는 런타임 중에 우리는 aiScene 객체로 다시 돌아갈 것이기 때문에 수입자와 장면의 범위를 모두 확장해야 합니다. 실제 게임에서는 필요한 것을 복사하여 최적화된 형식으로 저장하고 싶을 수 있지만 교육적인 목적을 위해서는 이것으로 충분합니다.

 

두 번째 변경 사항은 계층 구조의 루트에 대한 변환 행렬이 추출되고 역방향으로 저장된다는 것입니다. 우리는 앞으로 더 멀리서 그것을 사용할 것입니다. 행렬 역코드가 Assimp 라이브러리에서 Matrix4f 클래스로 복사되었습니다.

 

(mesh.h:69)

struct VertexBoneData
{
    uint IDs[NUM_BONES_PER_VERTEX];
    float Weights[NUM_BONES_PER_VERTEX];
}

(mesh.cpp:107)

bool Mesh::InitFromScene(const aiScene* pScene, const string& Filename)
{
    ...
    vector<VertexBoneData> Bones;
    ...
    Bones.resize(NumVertices);
    ...
    glBindBuffer(GL_ARRAY_BUFFER, m_Buffers[BONE_VB]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Bones[0]) * Bones.size(), &Bones[0], GL_STATIC_DRAW);
    glEnableVertexAttribArray(BONE_ID_LOCATION);
    glVertexAttribIPointer(BONE_ID_LOCATION, 4, GL_INT, sizeof(VertexBoneData), (const GLvoid*)0);
    glEnableVertexAttribArray(BONE_WEIGHT_LOCATION);
    glVertexAttribPointer(BONE_WEIGHT_LOCATION, 4, GL_FLOAT, GL_FALSE, sizeof(VertexBoneData), (const GLvoid*)16);
    ...
}

위의 구조는 꼭짓점 수준에서 우리가 필요로 하는 모든 것을 포함하고 있습니다. 기본적으로 4개의 뼈(뼈당 ID 및 무게)를 저장할 수 있는 충분한 저장 공간이 있습니다.

VertexBoneData는 쉐이더에 쉽게 전달할 수 있도록 그렇게 구성되었습니다. 우리는 이미 위치 0, 1, 2에 각각 위치, 텍스처 좌표 및 일반 경계를 확보했습니다. 따라서 위치 3에서 골격 ID를 바인딩하고 위치 4에서 가중치를 바인딩하도록 VAO를 구성합니다. 우리가 glVertexAttribute를 사용한다는 것을 주목하는 것도 매우 중요합니다. ID를 바인딩할 glVertexAttributePointer가 아닌 IPointer입니다. 이 점에 주의하십시오. 그렇지 않으면 쉐이더에 손상된 데이터가 표시됩니다.

 

(mesh.cpp:213)

void Mesh::LoadBones(uint MeshIndex, const aiMesh* pMesh, vector& Bones)
{
    for (uint i = 0 ; i < pMesh->mNumBones ; i++) {
        uint BoneIndex = 0;
        string BoneName(pMesh->mBones[i]->mName.data);

        if (m_BoneMapping.find(BoneName) == m_BoneMapping.end()) {
            BoneIndex = m_NumBones;
            m_NumBones++;
            BoneInfo bi;
            m_BoneInfo.push_back(bi);
        }
        else {
            BoneIndex = m_BoneMapping[BoneName];
        }

        m_BoneMapping[BoneName] = BoneIndex;
        m_BoneInfo[BoneIndex].BoneOffset = pMesh->mBones[i]->mOffsetMatrix;

        for (uint j = 0 ; j < pMesh->mBones[i]->mNumWeights ; j++) {
            uint VertexID = m_Entries[MeshIndex].BaseVertex + pMesh->mBones[i]->mWeights[j].mVertexId;
            float Weight = pMesh->mBones[i]->mWeights[j].mWeight;
            Bones[VertexID].AddBoneData(BoneIndex, Weight);
        }
    }
}

위의 함수는 단일 aiMesh 개체에 대한 정점 골격 정보를 로드합니다. Mesh::InitMesh()에서 호출됩니다. 이 함수는 VertexBoneData 구조를 채우는 것 외에도 골격 이름과 골격 ID(이 함수에 의해 관리되는 실행중인 인덱스) 사이의 맵을 업데이트하고 골격 ID를 기반으로 벡터에 오프셋 행렬을 저장합니다. 정점 ID가 계산되는 방법을 기록합니다. 정점 ID는 단일 매쉬와 관련이 있고 모든 매쉬를 단일 벡터에 저장하기 때문에 현재 aiMesh의 기본 정점 ID를 mWeights 배열의 정점 ID에 추가하여 절대 정점 ID를 얻습니다.

 

(mesh.cpp:29)

void Mesh::VertexBoneData::AddBoneData(uint BoneID, float Weight)
{
    for (uint i = 0 ; i < ARRAY_SIZE_IN_ELEMENTS(IDs) ; i++) {
        if (Weights[i] == 0.0) {
            IDs[i] = BoneID;
            Weights[i] = Weight;
            return;
        }
    }

    // should never get here - more bones than we have space for
    assert(0);
}

이 유틸리티 함수는 VertexBoneData 구조에서 빈 슬롯을 찾아 골격 ID와 가중치를 배치합니다. 일부 정점은 4개 미만의 뼈에 의해 영향을 받지만 존재하지 않는 뼈의 무게가 0으로 유지되기 때문에(VertexBoneData 생성자 참조), 이는 모든 뼈 수에 대해 동일한 가중치 계산을 사용할 수 있습니다.

 

 (mesh.cpp:473)

Matrix4f Mesh::BoneTransform(float TimeInSeconds, vector<Matrix4f>& Transforms)
{
    Matrix4f Identity;
    Identity.InitIdentity();

    float TicksPerSecond = m_pScene->mAnimations[0]->mTicksPerSecond != 0 ?
                            m_pScene->mAnimations[0]->mTicksPerSecond : 25.0f;
    float TimeInTicks = TimeInSeconds * TicksPerSecond;
    float AnimationTime = fmod(TimeInTicks, m_pScene->mAnimations[0]->mDuration);

    ReadNodeHierarchy(AnimationTime, m_pScene->mRootNode, Identity);

    Transforms.resize(m_NumBones);

    for (uint i = 0 ; i < m_NumBones ; i++) {
        Transforms[i] = m_BoneInfo[i].FinalTransformation;
    }
}

앞서 본 정점 수준의 골격 정보 로드는 매쉬가 시작 중에 로드될 때 한 번만 수행됩니다. 이제 우리는 매 프레임마다 쉐이더에 들어가는 뼈 변형을 계산하는 두 번재 부분으로 넘어갑니다. 위의 기능은 이 활동의 시작점입니다. 호출자는 현재 시간을 초 단위로 보고하고(분수일 수 있음), 업데이트해야하는 행렬의 벡터를 제공합니다. 우리는 애니메이션 주기 내에서 상대적인 시간을 찾고 노드 계층 구조를 처리합니다. 결과는 호출자에게 반환되는 일련의 변환입니다.

 

(mesh.cpp:428)

void Mesh::ReadNodeHierarchy(float AnimationTime, const aiNode* pNode, const Matrix4f& ParentTransform)
{
    string NodeName(pNode->mName.data);

    const aiAnimation* pAnimation = m_pScene->mAnimations[0];

    Matrix4f NodeTransformation(pNode->mTransformation);

    const aiNodeAnim* pNodeAnim = FindNodeAnim(pAnimation, NodeName);

    if (pNodeAnim) {
        // Interpolate scaling and generate scaling transformation matrix
        aiVector3D Scaling;
        CalcInterpolatedScaling(Scaling, AnimationTime, pNodeAnim);
        Matrix4f ScalingM;
        ScalingM.InitScaleTransform(Scaling.x, Scaling.y, Scaling.z);

        // Interpolate rotation and generate rotation transformation matrix
        aiQuaternion RotationQ;
        CalcInterpolatedRotation(RotationQ, AnimationTime, pNodeAnim);
        Matrix4f RotationM = Matrix4f(RotationQ.GetMatrix());

        // Interpolate translation and generate translation transformation matrix
        aiVector3D Translation;
        CalcInterpolatedPosition(Translation, AnimationTime, pNodeAnim);
        Matrix4f TranslationM;
        TranslationM.InitTranslationTransform(Translation.x, Translation.y, Translation.z);

        // Combine the above transformations
        NodeTransformation = TranslationM * RotationM * ScalingM;
    }

    Matrix4f GlobalTransformation = ParentTransform * NodeTransformation;

    if (m_BoneMapping.find(NodeName) != m_BoneMapping.end()) {
        uint BoneIndex = m_BoneMapping[NodeName];
        m_BoneInfo[BoneIndex].FinalTransformation = m_GlobalInverseTransform * GlobalTransformation *
                                                    m_BoneInfo[BoneIndex].BoneOffset;
    }

    for (uint i = 0 ; i < pNode->mNumChildren ; i++) {
        ReadNodeHierarchy(AnimationTime, pNode->mChildren[i], GlobalTransformation);
    }
}

이 함수는 노드 트리를 통과하고 지정된 애니메이션 시간에 따라 각 노드/본에 대한 최종 변환을 생성합니다. 매쉬가 하나의 애니메이션 시퀀스만 가지고 있다고 가정한다는 점에서 제한적입니다.

여러 애니메이션을 지원하려면 애니메이션 이름을 말하고 m_pScene->mAnimations[] 배열에서 검색해야 합니다. 위의 코드는 우리가 사용하는 데모 매쉬에 충분합니다.

 

노드 변환은 노드의 mTransformation 멤버에서 초기화됩니다. 만약 노드가 뼈와 일치하지 않는다면 그것이 뼈의 최종변환입니다. 그렇게 되면 생성한 행렬로 덮어씁니다. 이 작업은 다음과 같이 수행됩니다. 먼저 애니메이션의 채널 배열에서 노드 이름을 검색합니다. 그런 다음 애니메이션 시간을 기반으로 스케일링 벡터, 회전 쿼터 및 변환 벡터를 보간합니다. 우리는 그것들을 하나의 행렬로 결합하고 매개 변수로 얻은 행렬(GlobablTransformation)로 곱합니다.

이 함수는 재귀적이며 글로벌 변환 매개 변수가 ID 매트릭스인 root 노드에 대해 호출됩니다. 각 노드는 모든 자식에 대해 이 함수를 재귀적으로 호출하고 자체 변환을 전역 변환으로 전달합니다. 처음부터 끝까지 모든 노드에서 통합된 변환 체임을 얻을 수 있습니다.

 

m_BoneMapping 배열은 노드 이름을 생성하는 인덱스에 매핑하고 이 인덱스를 최종 변환이 저장되는 m_BoneInfo 배열의 항목으로 사용합니다. 최종 변환은 다음과 같이 계산됩니다. 우리는 로컬 공간 위치에서 정점을 노드 공간으로 가져오는 노드 오프셋 행렬로 시작합니다. 그런 다음 모든 노드 부모의 결합된 변환과 애니메이션 시간에 따라 노드에 대해 계산한 특정 변환을 곱합니다.

 

여기서는 Assimp 코드를 사용하여 수학 문제를 처리합니다. 나는 그것을 우리만의 코드 베이스로 복제하는 것이 의미가 없다고 생각해서 그냥 Assimp를 사용했습니다.

 

(mesh.cpp:387)

void Mesh::CalcInterpolatedRotation(aiQuaternion& Out, float AnimationTime, const aiNodeAnim* pNodeAnim)
{
    // we need at least two values to interpolate...
    if (pNodeAnim->mNumRotationKeys == 1) {
        Out = pNodeAnim->mRotationKeys[0].mValue;
        return;
    }

    uint RotationIndex = FindRotation(AnimationTime, pNodeAnim);
    uint NextRotationIndex = (RotationIndex + 1);
    assert(NextRotationIndex < pNodeAnim->mNumRotationKeys);
    float DeltaTime = pNodeAnim->mRotationKeys[NextRotationIndex].mTime - pNodeAnim->mRotationKeys[RotationIndex].mTime;
    float Factor = (AnimationTime - (float)pNodeAnim->mRotationKeys[RotationIndex].mTime) / DeltaTime;
    assert(Factor >= 0.0f && Factor <= 1.0f);
    const aiQuaternion& StartRotationQ = pNodeAnim->mRotationKeys[RotationIndex].mValue;
    const aiQuaternion& EndRotationQ = pNodeAnim->mRotationKeys[NextRotationIndex].mValue;
    aiQuaternion::Interpolate(Out, StartRotationQ, EndRotationQ, Factor);
    Out = Out.Normalize();
}

이 방법은 애니메이션 시간을 기준으로 지정된 채널의 회전쿼터를 보간합니다(채널에 키 쿼터 배열이 포함되어 있음). 먼저 필요한 애니메이션 시간 직전의 핵심 쿼터의 인덱스를 찾습니다. 애니메이션 시간에서 이전 키까지의 거리와 해당 키와 다음 키 사이의 거리 사이의 비율을 계산합니다. 우리는 그 요소를 사용하여 이 두 키 사이를 보간해야 합니다. 우리는 Assimp 코드를 사용하여 보간을 수행하고 결과를 정규화합니다. 위치 및 스케일링에 대한 해당 방법은 매우 유사하므로 여기서는 인용하지 않습니다.

 

(mesh.cpp:335)

uint Mesh::FindRotation(float AnimationTime, const aiNodeAnim* pNodeAnim)
{
    assert(pNodeAnim->mNumRotationKeys > 0);

    for (uint i = 0 ; i < pNodeAnim->mNumRotationKeys - 1 ; i++) {
        if (AnimationTime < (float)pNodeAnim->mRotationKeys[i + 1].mTime) {
            return i;
        }
    }

    assert(0);
}

이 유틸리티 방법은 애니메이션 시간 직전의 키 회전을 찾습니다. N 키 회전이 있으면 결과는 0에서 N-2가 될 수 있습니다. 애니메이션 시간은 항상 채널의 지속 시간 내에 포함되므로 마지막 키(N-1)는 유효한 결과가 될 수 없습니다.

 

(skihnning.vs)

#version 330

layout (location = 0) in vec3 Position;
layout (location = 1) in vec2 TexCoord;
layout (location = 2) in vec3 Normal;
layout (location = 3) in ivec4 BoneIDs;
layout (location = 4) in vec4 Weights;

out vec2 TexCoord0;
out vec3 Normal0;
out vec3 WorldPos0;

const int MAX_BONES = 200;

uniform mat4 gWVP;
uniform mat4 gWorld;
uniform mat4 gBones[MAX_BONES];

void main()
{
    mat4 BoneTransform = gBones[BoneIDs[0]] * Weights[0];
    BoneTransform += gBones[BoneIDs[1]] * Weights[1];
    BoneTransform += gBones[BoneIDs[2]] * Weights[2];
    BoneTransform += gBones[BoneIDs[3]] * Weights[3];

    vec4 PosL = BoneTransform * vec4(Position, 1.0);
    gl_Position = gWVP * PosL;
    TexCoord0 = TexCoord;
    vec4 NormalL = BoneTransform * vec4(Normal, 0.0);
    Normal0 = (gWorld * NormalL).xyz;
    WorldPos0 = (gWorld * PosL).xyz;
}

이제 매쉬 클래스의 변경 작업을 마쳤으므로 쉐이더 수준에서 수행해야 할 작업을 살펴보겠습니다.

먼저 VSInput 구조에 골격 ID 및 가중치 배열을 추가했습니다.

다음으로, 골격 변환을 포함하는 새로운 균일 배열이 있습니다. 쉐이더 자체에서 우리는 정점의 뼈 변환 행렬과 가중치의 조합으로 최종 뼈 변환을 계산합니다. 이 최종 행렬은 위치와 노말을 골격 공간에서 로컬 공간으로 변환하는데 사용됩니다. 여기서 부터 모든 것이 동일합니다.

 

(tutorial38.cpp:140)

float RunningTime = (float)((double)GetCurrentTimeMillis() - (double)m_startTime) / 1000.0f;

m_mesh.BoneTransform(RunningTime, Transforms);

for (uint i = 0 ; i < Transforms.size() ; i++) {
    m_pEffect->SetBoneTransform(i, Transforms[i]);
}

우리가 마지막으로 해야 할 일은 이 모든 것들을 애플리케이션 코드에 통합하는 것입니다.

이 작업은 위의 간단한 코드로 수행됩니다. 이 작업은 위의 간단한 코드로 수행됩니다.

GetCurrentTimeMillis() 함수는 응용 프로그램 시작 이후의 시간을 밀리초 단위로 반환합니다(분수를 수용하려면 부동 소수점을 참고하십시오).

 

모든 작업을 올바르게 수행한 경우 최종 결과는 이것과 유사합니다.

 

소스 코드 주소 : https://github.com/emeiri/ogldev/tree/master/tutorial28_youtube