KiTFOx's Notepad 📝

원본 : 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

원본 : http://www.opengl-tutorial.org/kr/intermediate-tutorials/tutorial-16-shadow-mapping/

튜토리얼 15에서는 정적 조명을 포함하는 라이트 맵을 만드는 방법을 배웠습니다.

아주 멋진 그림자를 만들어내기는 하지만, 애니메이션 모델은 다루지 않습니다.

Shadow Map은 현재(2016년 기준) 동적 Shadow를 만드는 방법입니다. 이 방법의 좋은 점은 작업을 시작하기에 꽤 쉽다는 것입니다. 나쁜점은 제대로 작업 하기가 매우 어렵다는 것입니다.

이 튜토리얼에서는 먼저 기본 알고리즘을 소개하고 단점을 확인한 다음 몇 가지 기술을 구현하여 더 나은 결과를 얻을 것입니다. Shadow Map을 작성할 당시(2012년)에는 여전히 많은 연구가 진행 중인 주제이기 때문에 필요에 따라 자체 Shadow Map을 더욱 개선할 수 있는 몇 가지 방법을 알려드리겠습니다.

기본 Shadowmap

기본 Shadow Map 알고리즘은 두 개의 패스로 구성됩니다.

먼저, 장면은 빛의 관점에서 렌더링됩니다. 각 fragment의 깊이만 계산됩니다.

그런 다음 씬(scene)이 평소와 같이 렌더링되지만 추가 테스트를 통해 현재 조각이 그림자에 표시됩니다.

"그림자 속에 있는 물체" 테스트는 사실 매우 간단합니다.

현재 샘플이 동일한 점에서 그림자 맵보다 빛에서 멀리 떨어져 있으면 씬(scene)에 빛에 더 가까운 개체가 포함되어 있음을 의미합니다.

즉, 현재 fragment는 그림자에 있습니다.

다음 이미지는 원리를 이해하는 데 도움이 될 수 있습니다.

Shadowmap 렌더링하기

이 튜토리얼에서는 directional lights(모든 광선이 평행하다고 간주될 수 있을 정도로 멀리 떨어져 있는 조명)만 고려합니다. 따라서 Shadow Map 렌더링은 직교 투영 행렬을 사용하여 수행됩니다. 직교 행렬은 원근법이 고려되지 않는다는 점을 제외하고는 일반적인 원근법 투영 행렬과 같습니다. 물체는 카메라 가까이에 있는 멀리있든 동일하게 보입니다.

렌더 대상 및 MVP 매트릭스 설정

튜토리얼 14부터는 쉐이더에서 나중에 액세스하기 위해 장면을 텍스처로 렌더링하는 방법을 배웠습니다.

여기서는 Shadow Map을 포함하기 위해 1024x1024 16비트 depth 텍스처를 사용합니다.

Shadow Map에는 일반적으로 16비트로 충분합니다. 이 값들을 자유롭게 시험해보세요. 나중에 샘플링해야 하므로 depth 렌더 버퍼가 아닌 depth 텍스처를 사용합니다.

// The framebuffer, which regroups 0, 1, or more textures, and 0 or 1 depth buffer.
 GLuint FramebufferName = 0;
 glGenFramebuffers(1, &FramebufferName);
 glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);

 // Depth texture. Slower than a depth buffer, but you can sample it later in your shader
 GLuint depthTexture;
 glGenTextures(1, &depthTexture);
 glBindTexture(GL_TEXTURE_2D, depthTexture);
 glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT16, 1024, 1024, 0,GL_DEPTH_COMPONENT, GL_FLOAT, 0);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

 glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthTexture, 0);

 glDrawBuffer(GL_NONE); // No color buffer is drawn to.

 // Always check that our framebuffer is ok
 if(glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
 return false;

빛의 관점에서 장면을 렌더링하는 데 사용되는 MVP 매트릭스는 다음과 같이 계산됩니다:

• Projection 행렬은 X,Y 및 Z 축에서 각각 축 정렬 상자(-10, 10), (-10,10), (-10, 20)의 모든 것을 포함하는 직교 행렬입니다. 이러한 값은 전체 *가시적인* 장면을 항상 볼 수 있도록 만들어졌으며, 이에 대한 자세한 내용은 추가 진행 섹션을 참조하십시오.
• View 행렬은 카메라 공간에서 조명 방향이 -Z가 되도록 월드를 회전시킵니다(튜토리얼 3 참조)
• Model 행렬은 원하는 대로 사용할 수 있습니다.

glm::vec3 lightInvDir = glm::vec3(0.5f,2,2);

 // Compute the MVP matrix from the light's point of view
 glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10,10,-10,10,-10,20);
 glm::mat4 depthViewMatrix = glm::lookAt(lightInvDir, glm::vec3(0,0,0), glm::vec3(0,1,0));
 glm::mat4 depthModelMatrix = glm::mat4(1.0);
 glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;

 // Send our transformation to the currently bound shader,
 // in the "MVP" uniform
 glUniformMatrix4fv(depthMatrixID, 1, GL_FALSE, &depthMVP[0][0])

쉐이더

이 패스 동안 사용되는 쉐이더는 매우 간단합니다. vertex 쉐이더는 균질 좌표에서 정점의 위치를 간단히 계산하는 통과 쉐이더입니다:

#version 330 core

// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;

// Values that stay constant for the whole mesh.
uniform mat4 depthMVP;

void main(){
 gl_Position =  depthMVP * vec4(vertexPosition_modelspace,1);
}

fragment 쉐이더는 단순하기 때문에 fragment의 깊이를 위치 0(즉, 깊이 텍스처)에 기록하기만 하면 됩니다.

#version 330 core

// Ouput data
layout(location = 0) out float fragmentdepth;

void main(){
    // Not really needed, OpenGL does it anyway
    fragmentdepth = gl_FragCoord.z;
}

Shadow Map을 렌더링하는 속도는 일반적으로 일반 렌더링보다 두 배 이상 빠릅니다. 깊이와 색상 대신 정밀도가 낮은 깊이만 기록되기 때문입니다. 메모리 대역폭은 GPU에서 가장 큰 성능 문제입니다.

결과

결과 텍스처는 다음과 같습니다.

어두운 색상은 작은 z를 의미합니다. 따라서 벽의 오른쪽 상단 모서리가 카메라 근처에 있습니다.

반대로 흰색은 z=1(동일한 좌표)을 의미하므로 매우 멀리 떨어져 있습니다.

Shadowmap 사용하기

기본 쉐이더

이제 평소의 쉐이더로 돌아갑니다. 계산하는 각 fragment에 대해 Shadow Map 뒤에 있는지 여부를 테스트해야 합니다.

이를 위해 Shadow Map을 만들 때 사용한 공간과 동일한 공간에서 현재 fragment의 위치를 계산해야 합니다. 따라서 일반적인 MVP 행렬로 한 번 변환하고 깊이 MVP 행렬로 한 번 변환해야 합니다.

하지만 약간의 속임수가 있습니다. 정점 위치에 깊이를 곱하면 MVP는 [-1,1]에 있는 균일한 좌표를 제공하지만 텍스처 샘플링은 [0,1]에서 수행해야 합니다.

예를 들어, 화면 중앙에 있는 fragment는 균일한 좌표로 (0,0)에 있을 것입니다. 그러나 질감 중간은 샘플링해야 하므로 UV는 (0.5,05)이어야 합니다.

이것은 fragment shader에서 직접 fetch 좌표를 조정하여 해결할 수 있지만, 단순히 좌표를 2(대각선 : [-1.1] -> [-0.5,0.5])로 나누고 변환하는 행렬(아래 행 : [-0.5,0.5]->[0,1])을 곱하는 것이 더 효율적입니다.

glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
glm::mat4 depthBiasMVP = biasMatrix*depthMVP;

이제 vertex 쉐이더를 작성할 수 있습니다. 이전과 동일하지만 1:1이 아닌 2개의 위치를 출력합니다:

• gl_Position 은 현재 카메라에서 볼 수 있는 정점의 위치입니다.
• ShadowCoord는 마지막 카메라(빛)에서 볼 수 있는 정점의 위치입니다.

// Output position of the vertex, in clip space : MVP * position
gl_Position =  MVP * vec4(vertexPosition_modelspace,1);

// Same, but with the light's view matrix
ShadowCoord = DepthBiasMVP * vec4(vertexPosition_modelspace,1);

그런 다음 fragment 쉐이더는 매우 간단합니다:

• texture(shadowMap, ShadowCoord.xy).z 는 빛과 가장 가까운 빛을 차단하는 폐색자 사이의 거리입니다.
• ShadowCoord.z는 빛과 현재 fragment 사이의 거리입니다.

...따라서 현재 fragment가 가장 가까운 폐색자보다 멀리 있으면, 이것은 우리가 (해당 가장 가까운 폐색자의) 그림자에 있다는 것을 의미합니다.

float visibility = 1.0;
if ( texture( shadowMap, ShadowCoord.xy ).z  <  ShadowCoord.z){
    visibility = 0.5;
}

우리는 이 지식을 이용하여 음영을 수정해야 합니다. 물론 주변 색상은 수정되지 않습니다. 생활 속의 목적은 우리가 그림자 속에 있을 때도 들어오는 빛을 가짜로 만드는 것이기 때문입니다(또는 모든 것이 순수한 검은색일 것입니다)

color =
 // Ambient : simulates indirect lighting
 MaterialAmbientColor +
 // Diffuse : "color" of the object
 visibility * MaterialDiffuseColor * LightColor * LightPower * cosTheta+
 // Specular : reflective highlight, like a mirror
 visibility * MaterialSpecularColor * LightColor * LightPower * pow(cosAlpha,5);

결과 - 쉐도우 아크네

다음은 현재 코드의 결과입니다. 분명히, 아이디어는 뛰어나지만 , 품질은 받아들일 수 없습니다.

이 이미지의 각 문제를 살펴보겠습니다.

코드에는 ShadowMap과 ShadowMap_simple의 두 가지 프로젝트가 있으며, 둘 중 더 마음에 드는 것으로 시작하세요.

간단한 버전은 위의 이미지만큼 품질이 좋지 않지만 이해하기가 더 쉽습니다.

문제점들

Shadow acne

가장 명백한 문제점은 shadow acne이다:

이 현상은 간단한 이미지로 쉽게 설명할 수 있습니다:

이에 대한 일반적인 "수정"은 error margin을 추가하는 것입니다. 현재 fragment의 depth(다시말해, 빛 공간)가 라이트맵 값에서 정말 멀리 떨어져 있는 경우에만 음영 처리합니다. 편향을 추가하여 이를 수행합니다:

float bias = 0.005;
float visibility = 1.0;
if ( texture( shadowMap, ShadowCoord.xy ).z  <  ShadowCoord.z-bias){
    visibility = 0.5;
}

결과물은 훨씬 나아집니다:

하지만, 여러분은 우리의 편견 때문에 땅과 벽 사이의 인공물이 더 나빠졌다는 것을 알아차릴 수 있습니다.

게다가, 0.005의 편향은 땅에서는 너무 많이 보이지만, 곡면에서는 충분하지 않습니다: 몇몇 인공물들은 실린더와 구에 남아 있습니다.

일반적인 접근 방식은 기울기에 따라 치우침을 수정하는 것입니다:

float bias = 0.005*tan(acos(cosTheta)); // cosTheta is dot( n,l ), clamped between 0 and 1
bias = clamp(bias, 0,0.01);

Shadow acne는 이제, 구부러진 표면에서도 사라졌습니다.

지오메트리에 따라 작동하거나 작동하지 않을 수 있는 또 다른 방법은 ShadowMap에서 뒷면만 렌더링하는 것입니다. 이것은 우리가 두꺼운 벽을 가진 특별한 기하학적 구조(다음 섹션 - Peter Panning 참조)를 갖도록 강요하지만, 적어도 acne는 그림자에 있는 표면에 있을 것입니다.

ShadowMap을 렌더링할 때 전면 삼각형을 잘라냅니다.

        // We don't use bias in the shader, but instead we draw back faces,
        // which are already separated from the front faces by a small distance
        // (if your geometry is made this way)
        glCullFace(GL_FRONT); // Cull front-facing triangles -> draw only back-facing triangles

그리고 씬(scene)을 렌더링할 때는 정상적으로 렌더링합니다(뒷면 절단)

         glCullFace(GL_BACK); // Cull back-facing triangles -> draw only front-facing triangles

이 방법은 편향 외에도 코드에 사용됩니다.

Peter Panning

우리는 더 이상 Shadow acne가 없지만, 여전히 잘못된 음영의 땅을 가지고 있고, 벽을 날아다니는 것처럼 보이게 합니다(이후 "피터 패닝"이라는 용어). 사실, 편향(bias)을 더하는 것은 상황을 더 악화시켰습니다.

이것은 매우 쉽게 고칠 수 있습니다. 얇은 기하학적 구조를 피하기만 하면 됩니다. 두 가지 이점이 있습니다.

• 먼저, 피터 패닝을 해결합니다. 기하학이 여러분의 편견보다 더 깊다면, 여러분은 준비가 다 된 것입니다.
• 두 번째로, 라이트맵을 렌더링할 때 후면 절단 기능을 설정할 수 있습니다. 왜냐하면 이제 벽의 다각형이 빛을 향하고 있기 때문입니다. 이 다각형은 뒷면 절단 기능을 사용하여 렌더링되지 않을 수 있습니다.

단점은 렌더링할 삼각형이 더 많다는 것입니다(프레임당 두 번!)

Aliasing

이 두 가지 방법에도 불구하고, 여러분은 그림자의 경계에 여전히 앨리어싱이 있다는 것을 알아차릴 것입니다. 즉, 한 픽셀은 흰색이고 다음 픽셀은 검은색입니다. 그 사이에 매끄러운 전환이 없습니다.

PCF

이를 개선하는 가장 쉬운 방법은 ShadowMap의 샘플러 유형을 Sampler2D 쉐이더로 변경하는 것입니다.

결과적으로 ShadowMap을 한 번 샘플링하면 하드웨어가 실제로 인접한 텍셀도 샘플링하고 모든 텍셀에 대해 비교를 수행하며 비교 결과의 이중 선형 필터링과 함께 [0,1]의 부동 소수점을 반환합니다.

예를 들어, 0.5는 두 개의 표본이 그림자에 있고 두 개의 표본이 빛에 있다는 것을 의미합니다.

필터링된 깊이 맵의 단일 샘플링과 동일하지 않습니다! 비교는 항상 true 또는 false를 반환합니다. PCF는 4 "true 또는 false"의 보간값을 제공합니다.

보시다시피 그림자 테두리는 매끄럽지만 그림자 맵의 텍스처는 여전히 보입니다.

Poisson Sampling

이 문제를 해결하는 쉬운 방법은 쉐도우 맵을 한 번이 아니라 N번 샘플링하는 것입니다. PCF와 함께 사용하면 N이 작더라도 매우 좋은 결과를 얻을 수 있습니다. 샘플 4개에 대한 코드는 다음과 같습니다:

for (int i=0;i<4;i++){
  if ( texture( shadowMap, ShadowCoord.xy + poissonDisk[i]/700.0 ).z  <  ShadowCoord.z-bias ){
    visibility-=0.2;
  }
}

poissonDisk는 예를 들어 다음과 같이 정의된 상수 배열입니다:

vec2 poissonDisk[4] = vec2[](
  vec2( -0.94201624, -0.39906216 ),
  vec2( 0.94558609, -0.76890725 ),
  vec2( -0.094184101, -0.92938870 ),
  vec2( 0.34495938, 0.29387760 )
);

이 방법은 통과할 쉐도우 맵 샘플 수에 따라 생성된 fragment가 다소 어두워집니다.

700.0 상수는 표본이 "확산"되는 정도를 정의합니다. 너무 적게 퍼뜨리면 다시 앨리어싱이 발생하고, 너무 많이 퍼뜨리면 밴딩이 발생합니다.*(이 스크린샷은 더 극적인 효과를 위해 PCF를 사용하지 않고 대신 16개의 샘플을 사용합니다.*

Stratified Poisson Sampling

픽셀마다 다른 샘플을 선택하여 이 밴딩을 제거할 수 있습니다.

두 가지 주요 방법이 있습니다 : Stratified Poisson 또는 Rotated Poisson

Stratified는 서로 다른 표본을 선택합니다. Rotated는 항상 같은 것을 사용하지만 랜덤 회전을 사용하여 서로 다르게 보입니다. 이 튜토리얼에서는 Stratified 버전만 설명하겠습니다.

이전 버전과의 유일한 차이점은 랜덤 인덱스로 poissonDisk를 인덱싱한다는 것입니다:

    for (int i=0;i<4;i++){
        int index = // A random number between 0 and 15, different for each pixel (and each i !)
        visibility -= 0.2*(1.0-texture( shadowMap, vec3(ShadowCoord.xy + poissonDisk[index]/700.0,  (ShadowCoord.z-bias)/ShadowCoord.w) ));
    }

다음과 같은 코드로 난수를 생성할 수 있으며,[0,1]에서 난수를 반환합니다:

    float dot_product = dot(seed4, vec4(12.9898,78.233,45.164,94.673));
    return fract(sin(dot_product) * 43758.5453);

우리의 경우 seed4는 i(4개의 서로 다른 위치에서 샘플을 채취할 수 있도록)와 ...의 조합이 됩니다.

gl_FragCord(화면의 픽셀 위치)또는 Position_worldspace를 사용할 수 있습니다.

        //  - A random sample, based on the pixel's screen location.
        //    No banding, but the shadow moves with the camera, which looks weird.
        int index = int(16.0*random(gl_FragCoord.xyy, i))%16;
        //  - A random sample, based on the pixel's position in world space.
        //    The position is rounded to the millimeter to avoid too much aliasing
        //int index = int(16.0*random(floor(Position_worldspace.xyz*1000.0), i))%16;

이렇게 하면 위의 그림과 같은 패턴이 사라지고 시각적 노이즈가 사라집니다.

그럼에도 불구하고 잘 수행된 노이즈는 종종 이러한 패턴보다 덜 불쾌합니다.

세 가지 구현에 대한 예는 tutorial16/ShadowMapping.fragmentshader 를 참조하십시오.

더 나아가기

이 모든 방법에도 불구하고, 우리의 그림자를 개선할 수 있는 많은 방법들이 있습니다.

가장 일반적인 것은 다음과 같습니다.

Early bailing

각 fragment에 대해 16개의 표본을 추출하는 대신(다시 말하면 많은 양) 4개의 멀리 있는 표본을 추출합니다.

만약 그들 모두가 빛이나 그림자 속에 있다면, 여러분은 16개의 샘플 모두가 같은 결과를 냈을 것이라고 생각할 수 있습니다: Early bailing. 만약 어떤 것들이 다르다면, 여러분은 아마도 그림자 경계에 있을 것이기 대문에 16개의 샘플이 필요합니다.

Spot lights

스포트라이트를 다루는 데는 변경 사항이 거의 필요하지 않습니다. 가장 확실한 것은 직교 투용 행렬을 원근 투영 행렬로 변경하는 것입니다.

glm::vec3 lightPos(5, 20, 20);
glm::mat4 depthProjectionMatrix = glm::perspective<float>(glm::radians(45.0f), 1.0f, 2.0f, 50.0f);
glm::mat4 depthViewMatrix = glm::lookAt(lightPos, lightPos-lightInvDir, glm::vec3(0,1,0));

같은 것이지만, orthographic frustum 대신에 perspective frustum을 사용합니다.

texture2Dproj 를 사용하여 원근 분할을 합니다.(자습서4- 행렬의 각주 참조)

두번째 단계는 쉐이더의 관점에서 고려하는 것입니다.(자습서 4- 행렬의 각주 참조). 간단히 말해서, 투시 투영 행렬은 실제로 어떤 투시도 하지 않습니다. 이 작업은 하드웨어에서 예상 좌표를 w로 나누어 수행합니다.

여기서, 우리는 쉐이더의 변형을 모방하기 때문에, 우리는 우리 자신을 분할하는 관점을 해야 합니다. 참고로, orthographic 행렬은 항상 w=1의 균질 벡터를 생성하므로 원근법을 생성하지 않습니다).

GLSL에서 이를 수행하는 방법이 있습니다. 두 번째줄은 내장 textureProj 함수를 사용하지만 두 방법 모두 정확하게 동일한 결과를 생성합니다.

if ( texture( shadowMap, (ShadowCoord.xy/ShadowCoord.w) ).z  <  (ShadowCoord.z-bias)/ShadowCoord.w )
if ( textureProj( shadowMap, ShadowCoord.xyw ).z  <  (ShadowCoord.z-bias)/ShadowCoord.w )

Point lights

동일하지만 depth 규브 맵을 사용합니다. 큐브 맵은 큐브의 각 면에 하나씩 있는 6개의 텍스처 세트입니다. 또한 표준 UV 좌표를 사용하지 않고 방향을 나타내는 3D 벡터를 사용하여 액세스 할 수 있습니다.

깊이는 공간의 모든 방향에 대해 저장되므로 점광 주위에 그림자가 드리울 수 있습니다.

여러개의 빛 혼합

알고리즘은 여러 개의 조명을 처리하지만 각 조명은 그림자 맵을 생성하기 위해 장면을 추가로 렌더링해야 합니다. Shadow를 적용할 때 엄청난 메모리가 필요하며 대역폭이 매우 빠르게 제한될 수 있습니다.

자동 빛 frustum

이 튜토리얼에서는 전체 장면을 포함하도록 손으로 만든 빛 frustum입니다. 이 제한된 예제에서는 이 작업이 작동하지만 이 작업은 피해야 합니다.

만약 당신의 지도가 1Km x 1Km이라면, 당신의 1024x1024 그림자 지도의 각 텍스트는 1평방미터를 차지할 것입니다. 이것은 형편 없습니다. 조명의 투영 행렬은 가능한한 타이트해야합니다.

스포트라이트의 경우 범위를 조정하여 쉽게 변경할 수 있습니다.

태양과 같은 방향 조명은 더 까다롭습니다. 그것들은 정말로 전체 장면을 비추죠. 광격자를 계산하는 방법은 다음과 같습니다:

1. 잠재적 그림자 수신기 또는 줄여서 PSR은 빛의 frustum, view frustum 및 장면 경계 상자에 동시에 속하는 객체 입니다. 이름에서 알 수 있듯이, 이 물체들은 음영을 받기 쉽습니다. 카메라와 빛으로 볼 수 있습니다.
2. 잠재적 그림자 캐스터(PCF)는 모두 잠재적 그림자 수신기이며, 그 사이에 있는 모든 물체(물체는 보이지 않지만 여전히 보이는 그림자를 드리울 수 있음)입니다.

따라서 빛 투영 행렬을 계산하려면 보이는 모든 객체를 가져와서 너무 멀리 있는 객체를 제거하고 경계 상자를 계산합니다. 이 경계 상자와 조명 사이에 있는 객체를 추가하고 새 경계 상자를 계산합니다(그러나 이번에는 조명 방향을 따라 정렬됨).

이러한 집합의 정확한 계산에는 볼록 껍질 교차점 계산이 포함되지만, 이 방법은 구현하기가 훨씬 쉽습니다.

이 방법을 사용하면 그림자 맵 해상도가 갑자기 증가하기 때문에 물치가 frustum에서 사라지면 팝핑이 발생합니다. 계단식 Shadow Map에는 이러한 문제가 없지만 구현하기가 더 어려우며 시간이 지남에 따라 값을 매끄럽게 하여 보정할 수 있습니다.

지수 shadow maps

지수 그림자 맵은 그림자에 있지만 빛 표면 근처에 있는 fragment가 실제로 "가운데 어딘가"라고 가정하여 앨리어싱을 제한하려고 합니다. 테스트가 더이상 이진법이 아니라는 점을 제외하면 이는 편향과 관련 있습니다. 빛이 있는 표면까지의 거리가 증가하면 fragment가 점점 어두워집니다.

이것은 명백히 부정행위이며, 두 물체가 겹칠 때 인공물이 나타날 수 있습니다.

빛-공간 원근법 shadow maps

LiSPSM은 카메라 근처에서 더 정확하게 하기 위해 빛 투영 행렬을 조정합니다. 이것은 "불안정한 frustra"의 경우에는 특히 중요합니다. 여러분은 방향을 바라지만, 스폿라이트는 반대 방향을 바라봅니다. 당신은 빛 근처, 즉 당신으로부터 멀리 떨어진 곳에 많은 그림자 지도 정밀도를 가지고 있고, 당신이 가장 필요로 하는 카메라 근처에 낮은 해상도를 가지고 있습니다.

그러나 LiSPSM은 구현하기가 까다롭습니다. 구현에 대한 자세한 내용은 레퍼런스를 참조하십시오.

계단식 shadow maps

CSM은 LiSPSM과 완전히 동일한 문제를 다루지만 다른 방식으로 처리합니다. 단순히 view frustum의 여러 부분에 대해 여러 개의(2-4) 표준 그림자 맵을 사용합니다.

첫 번째 것은 첫 번째 미터를 다루기 때문에 꽤 작은 구역에 대해서는 훌륭한 해상도를 얻을 수 있습니다. 다음 그림자 지도는 더 먼 물체를 다룹니다. 마지막 shadow map은 장면의 큰 부분을 다루지만, 관점 때문에 가장 가까운 구역보다 시각적으로 더 중요하지는 않을 것입니다.

계단식 쉐도우 맵은 작성 당시(2012년) 최고의 복잡성/품질 비율을 가지고 있습니다. 이것은 많은 경우에 선택의 해결책입니다.

결론

보시다시피, 그림자 지도는 복잡한 주제입니다. 매년 새로운 변형과 개선사항이 발표되고 있으며, 현재로서는 어떤 솔루션도 완벽하지 않습니다.

다행히, 제시된 대부분의 방법은 함께 혼합될 수 있습니다. 빛 공간 관점에서 계산식 shadow map을 PCF로 매끄럽게 만드는 것이 완벽하게 가능합니다.. 이 모든 기술을 사용하여 실험해 보십시오.

결론적으로, 저는 당신이 가능할 때마다 미리 계산된 라이트맵을 고수하고, 동적 객체에만 shadowmap을 사용할 것을 제안합니다. 그리고 두 가지의 시작적 품질이 동일한지 확인하십시오. 완벽한 정적 환경과 모양새가 좋지 않은 그림자가 있는 것도 좋지 않습니다.