第 21 章 - 間接描画 (アニメーション モデル) と計算シェーダー

この章では、間接描画を使用する場合のアニメーション モデルのサポートを追加します。そのために、コンピューティング シェーダーという新しいトピックを導入します。計算シェーダーを使用して、モデルの頂点をバインディング ポーズから最終的な位置に変換します (現在のアニメーションに従って)。これが完了したら、通常のシェーダーを使用してそれらをレンダリングできます。レンダリング中にアニメートされたモデルとアニメートされていないモデルを区別する必要はありません。それに加えて、レンダリング プロセスからアニメーション変換を切り離すことができます。そうすることで、アニメーション モデルをレンダリング レートとは異なるレートで更新できるようになります (アニメーション化された頂点が変更されていなければ、各フレームで変換する必要はありません)。

• ドキュメント
• ソース

サンプルコードの実行結果

実行するときに、以下の修正を行いました。
＜scene.vert＞

out uint outMaterialIdx; -> flat out uint outMaterialIdx;

コンセプト

コードを説明する前に、アニメーション モデルの間接描画の背後にある概念を説明しましょう。私たちが従うアプローチは、前の章で使用したものと多かれ少なかれ同じです。頂点データを含むグローバル バッファを作成します。主な違いは、最初に計算シェーダーを使用して頂点をバインディング ポーズから最終ポーズに変換することです。それに加えて、モデルに複数のインスタンスを使用しません。その理由は、同じアニメーション化されたモデルを共有する複数のエンティティがある場合でも、それらは異なるアニメーション状態になる可能性があります (アニメーションが後で開始されたり、更新率が低くなったり、モデルの特定の選択されたアニメーションでさえある可能性があります)異なる場合があります）。したがって、アニメーション化された頂点を含むグローバル バッファ内に、エンティティごとに 1 つのデータ チャンクが必要になります。

データをバインドし続ける必要があります。シーンのすべてのメッシュ用に別のグローバル バッファを作成します。この場合、エンティティごとに別々のチャンクを持つ必要はなく、メッシュごとに 1 つだけです。コンピューティング シェーダーは、バインディング ポーズ データ バッファーにアクセスし、エンティティごとにそれを処理し、静的モデルに使用されるものと同様の構造を持つ別のグローバル バッファーに結果を格納します。

モデルの読み込み

Modelこのクラスにはボーン マトリックス データを保存しないため、クラスを更新する必要があります。代わりに、その情報は共通のバッファに格納されます。したがって、内部クラスAnimatedFrameはもはやレコードになることはできません (レコードは不変です)。

public class Model {
    ...
    public static class AnimatedFrame {
        private Matrix4f[] bonesMatrices;
        private int offset;

        public AnimatedFrame(Matrix4f[] bonesMatrices) {
            this.bonesMatrices = bonesMatrices;
        }

        public void clearData() {
            bonesMatrices = null;
        }

        public Matrix4f[] getBonesMatrices() {
            return bonesMatrices;
        }

        public int getOffset() {
            return offset;
        }

        public void setOffset(int offset) {
            this.offset = offset;
        }
    }
    ...
}

レコードから通常の内部クラスに渡すという事実、クラス属性へのアクセス方法を変更するには、クラスModelをわずかに変更する必要があります。ModelLoader

public class ModelLoader {
    ...
    private static void buildFrameMatrices(AIAnimation aiAnimation, List<Bone> boneList, Model.AnimatedFrame animatedFrame,
                                           int frame, Node node, Matrix4f parentTransformation, Matrix4f globalInverseTransform) {
        ...
        for (Bone bone : affectedBones) {
            ...
            animatedFrame.getBonesMatrices()[bone.boneId()] = boneTransform;
        }
        ...
    }
    ...
}

RenderBuffersクラスで管理される、必要な新しいグローバル バッファを確認しましょう。

public class RenderBuffers {

    private int animVaoId;
    private int bindingPosesBuffer;
    private int bonesIndicesWeightsBuffer;
    private int bonesMatricesBuffer;
    private int destAnimationBuffer;
    ...
    public void cleanup() {
        ...
        glDeleteVertexArrays(animVaoId);
    }
    ...
    public int getAnimVaoId() {
        return animVaoId;
    }

    public int getBindingPosesBuffer() {
        return bindingPosesBuffer;
    }

    public int getBonesIndicesWeightsBuffer() {
        return bonesIndicesWeightsBuffer;
    }

    public int getBonesMatricesBuffer() {
        return bonesMatricesBuffer;
    }

    public int getDestAnimationBuffer() {
        return destAnimationBuffer;
    }
    ...
}

はanimVaoId、変換されたアニメーション頂点を含むデータを定義する VAO を格納します。つまり、計算シェーダーによって処理された後のデータです (メッシュとエンティティごとに 1 つのチャンクを覚えておいてください)。データ自体はバッファに格納され、そのハンドルは に格納されdestAnimationBufferます。VAO を理解しない計算シェーダーでそのバッファーにアクセスする必要があります。バッファーだけです。bonesMatricesBufferまた、ボーン マトリックスとインデックスとウェイトを、それぞれ と で表される 2 つのバッファに格納する必要がありbonesIndicesWeightsBufferます。このcleanup方法では、新しい VAO をきれいにすることを忘れてはなりません。新しい属性のゲッターも追加する必要があります。

loadAnimatedModelsこれで、次のように始まる を実装できます。

public class RenderBuffers {
    ...
    public void loadAnimatedModels(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(Model::isAnimated).toList();
        loadBindingPoses(modelList);
        loadBonesMatricesBuffer(modelList);
        loadBonesIndicesWeights(modelList);

        animVaoId = glGenVertexArrays();
        glBindVertexArray(animVaoId);
        int positionsSize = 0;
        int normalsSize = 0;
        int textureCoordsSize = 0;
        int indicesSize = 0;
        int offset = 0;
        int chunkBindingPoseOffset = 0;
        int bindingPoseOffset = 0;
        int chunkWeightsOffset = 0;
        int weightsOffset = 0;
        for (Model model : modelList) {
            List<Entity> entities = model.getEntitiesList();
            for (Entity entity : entities) {
                List<RenderBuffers.MeshDrawData> meshDrawDataList = model.getMeshDrawDataList();
                bindingPoseOffset = chunkBindingPoseOffset;
                weightsOffset = chunkWeightsOffset;
                for (MeshData meshData : model.getMeshDataList()) {
                    positionsSize += meshData.getPositions().length;
                    normalsSize += meshData.getNormals().length;
                    textureCoordsSize += meshData.getTextCoords().length;
                    indicesSize += meshData.getIndices().length;

                    int meshSizeInBytes = (meshData.getPositions().length + meshData.getNormals().length * 3 + meshData.getTextCoords().length) * 4;
                    meshDrawDataList.add(new MeshDrawData(meshSizeInBytes, meshData.getMaterialIdx(), offset,
                            meshData.getIndices().length, new AnimMeshDrawData(entity, bindingPoseOffset, weightsOffset)));
                    bindingPoseOffset += meshSizeInBytes / 4;
                    int groupSize = (int) Math.ceil((float) meshSizeInBytes / (14 * 4));
                    weightsOffset += groupSize * 2 * 4;
                    offset = positionsSize / 3;
                }
            }
            chunkBindingPoseOffset += bindingPoseOffset;
            chunkWeightsOffset += weightsOffset;
        }

        destAnimationBuffer = glGenBuffers();
        vboIdList.add(destAnimationBuffer);
        FloatBuffer meshesBuffer = MemoryUtil.memAllocFloat(positionsSize + normalsSize * 3 + textureCoordsSize);
        for (Model model : modelList) {
            model.getEntitiesList().forEach(e -> {
                for (MeshData meshData : model.getMeshDataList()) {
                    populateMeshBuffer(meshesBuffer, meshData);
                }
            });
        }
        meshesBuffer.flip();
        glBindBuffer(GL_ARRAY_BUFFER, destAnimationBuffer);
        glBufferData(GL_ARRAY_BUFFER, meshesBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(meshesBuffer);

        defineVertexAttribs();

        // Index VBO
        int vboId = glGenBuffers();
        vboIdList.add(vboId);
        IntBuffer indicesBuffer = MemoryUtil.memAllocInt(indicesSize);
        for (Model model : modelList) {
            model.getEntitiesList().forEach(e -> {
                for (MeshData meshData : model.getMeshDataList()) {
                    indicesBuffer.put(meshData.getIndices());
                }
            });
        }
        indicesBuffer.flip();
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(indicesBuffer);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }
    ...
}

以下のメソッドがどのように定義されているかについては後で説明しますが、今では:

・loadBindingPoses: アニメートされたモデルに関連付けられたすべてのメッシュのバインド ポーズ情報を格納します。
・loadBonesMatricesBuffer: アニメートされたモデルの各アニメーションのボーン マトリックスを格納します。
・loadBonesIndicesWeights: アニメートされたモデルのボーン インデックスとウェイト情報を格納します。
コードは と非常によく似ていloadStaticModelsます。アニメーション化されたモデルの VAO を作成することから始めて、モデルのメッシュを反復処理します。単一のバッファを使用してすべてのデータを保持するため、これらの要素を繰り返し処理して最終的なバッファ サイズを取得します。最初のループは、静的バージョンとは少し異なることに注意してください。モデルに関連付けられたエンティティを反復処理する必要があり、それらのそれぞれについて、関連付けられたすべてのメッシュのサイズを計算します。

loadBindingPosesメソッドを調べてみましょう。

public class RenderBuffers {
    ...
    private void loadBindingPoses(List<Model> modelList) {
        int meshSize = 0;
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                meshSize += meshData.getPositions().length + meshData.getNormals().length * 3 +
                        meshData.getTextCoords().length + meshData.getIndices().length;
            }
        }

        bindingPosesBuffer = glGenBuffers();
        vboIdList.add(bindingPosesBuffer);
        FloatBuffer meshesBuffer = MemoryUtil.memAllocFloat(meshSize);
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                populateMeshBuffer(meshesBuffer, meshData);
            }
        }
        meshesBuffer.flip();
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, bindingPosesBuffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, meshesBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(meshesBuffer);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
    ...
}

モデルごとにアニメーション データの反復処理を開始し、すべての情報を保持するバッファを計算するために、アニメーション化されたフレームごとに (すべてのボーンの) 関連する変換行列を取得します。サイズを取得したら、バッファを作成し、(2 番目のループで) それらの行列を入力し始めます。前のバッファーと同様に、計算シェーダーでこのバッファーにアクセスするため、GL_SHADER_STORAGE_BUFFERフラグを使用する必要があります。

メソッドは次のloadBonesIndicesWeightsように定義されます。

public class RenderBuffers {
    ...
    private void loadBonesIndicesWeights(List<Model> modelList) {
        int bufferSize = 0;
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                bufferSize += meshData.getBoneIndices().length * 4 + meshData.getWeights().length * 4;
            }
        }
        ByteBuffer dataBuffer = MemoryUtil.memAlloc(bufferSize);
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                int[] bonesIndices = meshData.getBoneIndices();
                float[] weights = meshData.getWeights();
                int rows = bonesIndices.length / 4;
                for (int row = 0; row < rows; row++) {
                    int startPos = row * 4;
                    dataBuffer.putFloat(weights[startPos]);
                    dataBuffer.putFloat(weights[startPos + 1]);
                    dataBuffer.putFloat(weights[startPos + 2]);
                    dataBuffer.putFloat(weights[startPos + 3]);
                    dataBuffer.putFloat(bonesIndices[startPos]);
                    dataBuffer.putFloat(bonesIndices[startPos + 1]);
                    dataBuffer.putFloat(bonesIndices[startPos + 2]);
                    dataBuffer.putFloat(bonesIndices[startPos + 3]);
                }
            }
        }
        dataBuffer.flip();

        bonesIndicesWeightsBuffer = glGenBuffers();
        vboIdList.add(bonesIndicesWeightsBuffer);
        glBindBuffer(GL_SHADER_STORAGE_BUFFER, bonesIndicesWeightsBuffer);
        glBufferData(GL_SHADER_STORAGE_BUFFER, dataBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(dataBuffer);

        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
    }
    ...
}

前の方法と同様に、重みとボーン インデックスの情報を 1 つのバッファーに格納するため、最初にそのサイズを計算し、後でデータを入力する必要があります。前のバッファーと同様に、計算シェーダーでこのバッファーにアクセスするため、GL_SHADER_STORAGE_BUFFERフラグを使用する必要があります。

計算シェーダー

今度は、計算シェーダーを介してアニメーション変換を実装する番です。前に述べたように、シェーダーは他のシェーダーと似ていますが、入力と出力に制限はありません。それらを使用してデータを変換し、バインディング ポーズとアニメーション変換マトリックスに関する情報を保持するグローバル バッファーにアクセスし、結果を別のバッファーにダンプします。アニメーション ( ) のシェーダー コードanim.compは次のように定義されます。

#version 460

layout (std430, binding=0) readonly buffer srcBuf {
    float data[];
} srcVector;

layout (std430, binding=1) readonly buffer weightsBuf {
    float data[];
} weightsVector;

layout (std430, binding=2) readonly buffer bonesBuf {
    mat4 data[];
} bonesMatrices;

layout (std430, binding=3) buffer dstBuf {
    float data[];
} dstVector;

struct DrawParameters
{
    int srcOffset;
    int srcSize;
    int weightsOffset;
    int bonesMatricesOffset;
    int dstOffset;
};
uniform DrawParameters drawParameters;

layout (local_size_x=1, local_size_y=1, local_size_z=1) in;

void main()
{
    int baseIdx = int(gl_GlobalInvocationID.x) * 14;
    uint baseIdxWeightsBuf  = drawParameters.weightsOffset + int(gl_GlobalInvocationID.x) * 8;
    uint baseIdxSrcBuf = drawParameters.srcOffset + baseIdx;
    uint baseIdxDstBuf = drawParameters.dstOffset + baseIdx;
    if (baseIdx >= drawParameters.srcSize) {
        return;
    }

    vec4 weights = vec4(weightsVector.data[baseIdxWeightsBuf], weightsVector.data[baseIdxWeightsBuf + 1], weightsVector.data[baseIdxWeightsBuf + 2], weightsVector.data[baseIdxWeightsBuf + 3]);
    ivec4 bonesIndices = ivec4(weightsVector.data[baseIdxWeightsBuf + 4], weightsVector.data[baseIdxWeightsBuf + 5], weightsVector.data[baseIdxWeightsBuf + 6], weightsVector.data[baseIdxWeightsBuf + 7]);

    vec4 position = vec4(srcVector.data[baseIdxSrcBuf], srcVector.data[baseIdxSrcBuf + 1], srcVector.data[baseIdxSrcBuf + 2], 1);
    position =
    weights.x * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.x] * position +
    weights.y * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.y] * position +
    weights.z * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.z] * position +
    weights.w * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.w] * position;
    dstVector.data[baseIdxDstBuf] = position.x / position.w;
    dstVector.data[baseIdxDstBuf + 1] = position.y / position.w;
    dstVector.data[baseIdxDstBuf + 2] = position.z / position.w;

    baseIdxSrcBuf += 3;
    baseIdxDstBuf += 3;
    vec4 normal = vec4(srcVector.data[baseIdxSrcBuf], srcVector.data[baseIdxSrcBuf + 1], srcVector.data[baseIdxSrcBuf + 2], 0);
    normal =
    weights.x * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.x] * normal +
    weights.y * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.y] * normal +
    weights.z * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.z] * normal +
    weights.w * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.w] * normal;
    dstVector.data[baseIdxDstBuf] = normal.x;
    dstVector.data[baseIdxDstBuf + 1] = normal.y;
    dstVector.data[baseIdxDstBuf + 2] = normal.z;

    baseIdxSrcBuf += 3;
    baseIdxDstBuf += 3;
    vec4 tangent = vec4(srcVector.data[baseIdxSrcBuf], srcVector.data[baseIdxSrcBuf + 1], srcVector.data[baseIdxSrcBuf + 2], 0);
    tangent =
    weights.x * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.x] * tangent +
    weights.y * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.y] * tangent +
    weights.z * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.z] * tangent +
    weights.w * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.w] * tangent;
    dstVector.data[baseIdxDstBuf] = tangent.x;
    dstVector.data[baseIdxDstBuf + 1] = tangent.y;
    dstVector.data[baseIdxDstBuf + 2] = tangent.z;

    baseIdxSrcBuf += 3;
    baseIdxDstBuf += 3;
    vec4 bitangent = vec4(srcVector.data[baseIdxSrcBuf], srcVector.data[baseIdxSrcBuf + 1], srcVector.data[baseIdxSrcBuf + 2], 0);
    bitangent =
    weights.x * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.x] * bitangent +
    weights.y * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.y] * bitangent +
    weights.z * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.z] * bitangent +
    weights.w * bonesMatrices.data[drawParameters.bonesMatricesOffset + bonesIndices.w] * bitangent;
    dstVector.data[baseIdxDstBuf] = bitangent.x;
    dstVector.data[baseIdxDstBuf + 1] = bitangent.y;
    dstVector.data[baseIdxDstBuf + 2] = bitangent.z;

    baseIdxSrcBuf += 3;
    baseIdxDstBuf += 3;
    vec2 textCoords = vec2(srcVector.data[baseIdxSrcBuf], srcVector.data[baseIdxSrcBuf + 1]);
    dstVector.data[baseIdxDstBuf] = textCoords.x;
    dstVector.data[baseIdxDstBuf + 1] = textCoords.y;
}

ご覧のとおり、コードは前の章でアニメーション (ループの展開) に使用したものと非常によく似ています。データが共通のバッファに格納されるようになったため、メッシュごとにオフセットを適用する必要があることに気付くでしょう。計算シェーダーでプッシュ定数をサポートするため。入力/出力データは、一連のバッファーとして定義されます。

・srcVector: このバッファには、頂点情報 (位置、法線など) が含まれます。
・weightsVector: このバッファには、特定のメッシュとエンティティの現在のアニメーション状態の重みが含まれます。
・bonesMatrices: 同じですが、ボーン マトリックス情報があります。
・dstVector: このバッファは、アニメーション変換を適用した結果を保持します。
興味深いのは、そのオフセットを計算する方法です。このgl_GlobalInvocationID変数には、計算シェーダーで現在実行中の作業項目のインデックスが含まれます。この場合、グローバル バッファにある「チャンク」と同じ数の作業項目を作成します。チャンクは、その位置、法線、テクスチャ座標などの頂点データをモデル化します。したがって、ポート頂点データは、ワークアイテムが増加するたびに、バッファー内を 14 位置 (14 float: 位置の場合は 3) 移動する必要があります。法線の場合は 3、従接線の場合は 3、接線の場合は 3、テクスチャ座標の場合は 2)。同じことが、各頂点に関連付けられたウェイト (4 つの float) とボーン インデックス (4 つの float) のデータを保持するウェイト バッファーにも当てはまります。また、頂点オフセットを使用して、バインディング ポーズ バッファーと宛先バッファーを長く移動します。drawParameters各メッシュとエンティティの ebase オフセットを指すデータ。

このシェーダーは、AnimationRender次のように定義された名前の新しいクラスで使用します。

package org.lwjglb.engine.graph;

import org.lwjglb.engine.scene.*;

import java.util.*;

import static org.lwjgl.opengl.GL43.*;

public class AnimationRender {

    private ShaderProgram shaderProgram;
    private UniformsMap uniformsMap;

    public AnimationRender() {
        List<ShaderProgram.ShaderModuleData> shaderModuleDataList = new ArrayList<>();
        shaderModuleDataList.add(new ShaderProgram.ShaderModuleData("resources/shaders/anim.comp", GL_COMPUTE_SHADER));
        shaderProgram = new ShaderProgram(shaderModuleDataList);
        createUniforms();
    }

    public void cleanup() {
        shaderProgram.cleanup();
    }

    private void createUniforms() {
        uniformsMap = new UniformsMap(shaderProgram.getProgramId());
        uniformsMap.createUniform("drawParameters.srcOffset");
        uniformsMap.createUniform("drawParameters.srcSize");
        uniformsMap.createUniform("drawParameters.weightsOffset");
        uniformsMap.createUniform("drawParameters.bonesMatricesOffset");
        uniformsMap.createUniform("drawParameters.dstOffset");
    }

    public void render(Scene scene, RenderBuffers globalBuffer) {
        shaderProgram.bind();
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, globalBuffer.getBindingPosesBuffer());
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, globalBuffer.getBonesIndicesWeightsBuffer());
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, globalBuffer.getBonesMatricesBuffer());
        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, globalBuffer.getDestAnimationBuffer());

        int dstOffset = 0;
        for (Model model : scene.getModelMap().values()) {
            if (model.isAnimated()) {
                for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                    RenderBuffers.AnimMeshDrawData animMeshDrawData = meshDrawData.animMeshDrawData();
                    Entity entity = animMeshDrawData.entity();
                    Model.AnimatedFrame frame = entity.getAnimationData().getCurrentFrame();
                    int groupSize = (int) Math.ceil((float) meshDrawData.sizeInBytes() / (14 * 4));
                    uniformsMap.setUniform("drawParameters.srcOffset", animMeshDrawData.bindingPoseOffset());
                    uniformsMap.setUniform("drawParameters.srcSize", meshDrawData.sizeInBytes() / 4);
                    uniformsMap.setUniform("drawParameters.weightsOffset", animMeshDrawData.weightsOffset());
                    uniformsMap.setUniform("drawParameters.bonesMatricesOffset", frame.getOffset());
                    uniformsMap.setUniform("drawParameters.dstOffset", dstOffset);
                    glDispatchCompute(groupSize, 1, 1);
                    dstOffset += meshDrawData.sizeInBytes() / 4;
                }
            }
        }

        glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
        shaderProgram.unbind();
    }
}

ご覧のとおり、定義は非常に単純です。シェーダーを作成するときに、GL_COMPUTE_SHADERこれが計算シェーダーであることを示すように を設定する必要があります。不適切に使用されるユニフォームには、バインディング ポーズ バッファ、ウェイトおよびマトリックス バッファ、およびデスティネーション バッファにオフセットが含まれます。このrenderメソッドでは、モデルを繰り返し処理し、各エンティティのメッシュ描画データを取得して、glDispatchCompute. キーは、再びgroupSize変数をトスします。ご覧のとおり、メッシュ内にある頂点チャンクと同じ回数だけシェーダーを呼び出す必要があります。

その他の変更

SceneRenderアニメーション化されたモデルに関連付けられたエンティティをレンダリングするには、クラスを更新する必要があります。変更点を以下に示します。

public class SceneRender {
    ...
    private int animDrawCount;
    private int animRenderBufferHandle;
    ...
    public void cleanup() {
        ...
        glDeleteBuffers(animRenderBufferHandle);
    }
    ...
    public void render(Scene scene, RenderBuffers renderBuffers, GBuffer gBuffer) {
        ...
        // Animated meshes
        drawElement = 0;
        modelList = scene.getModelMap().values().stream().filter(m -> m.isAnimated()).toList();
        for (Model model : modelList) {
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                RenderBuffers.AnimMeshDrawData animMeshDrawData = meshDrawData.animMeshDrawData();
                Entity entity = animMeshDrawData.entity();
                String name = "drawElements[" + drawElement + "]";
                uniformsMap.setUniform(name + ".modelMatrixIdx", entitiesIdxMap.get(entity.getId()));
                uniformsMap.setUniform(name + ".materialIdx", meshDrawData.materialIdx());
                drawElement++;
            }
        }
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, animRenderBufferHandle);
        glBindVertexArray(renderBuffers.getAnimVaoId());
        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, animDrawCount, 0);

        glBindVertexArray(0);
        glEnable(GL_BLEND);
        shaderProgram.unbind();
    }

    private void setupAnimCommandBuffer(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> m.isAnimated()).toList();
        int numMeshes = 0;
        for (Model model : modelList) {
            numMeshes += model.getMeshDrawDataList().size();
        }

        int firstIndex = 0;
        int baseInstance = 0;
        ByteBuffer commandBuffer = MemoryUtil.memAlloc(numMeshes * COMMAND_SIZE);
        for (Model model : modelList) {
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                // count
                commandBuffer.putInt(meshDrawData.vertices());
                // instanceCount
                commandBuffer.putInt(1);
                commandBuffer.putInt(firstIndex);
                // baseVertex
                commandBuffer.putInt(meshDrawData.offset());
                commandBuffer.putInt(baseInstance);

                firstIndex += meshDrawData.vertices();
                baseInstance++;
            }
        }
        commandBuffer.flip();
        animDrawCount = commandBuffer.remaining() / COMMAND_SIZE;

        animRenderBufferHandle = glGenBuffers();
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, animRenderBufferHandle);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, commandBuffer, GL_DYNAMIC_DRAW);

        MemoryUtil.memFree(commandBuffer);
    }

    public void setupData(Scene scene) {
        ...
        setupAnimCommandBuffer(scene);
        ...
    }
    ...
}

アニメーション モデルをレンダリングするコードは、静的エンティティに使用されるものと非常によく似ています。違いは、同じモデルを共有するエンティティをグループ化していないことです。各エンティティと関連するメッシュの描画命令を記録する必要があります。

ShadowRenderまた、アニメーション モデルをレンダリングするようにクラスを更新する必要があります。

public class ShadowRender {
    ...
    private int animDrawCount;
    private int animRenderBufferHandle;
    ...
    public void cleanup() {
        ...
        glDeleteBuffers(animRenderBufferHandle);
    }
    ...
    public void render(Scene scene, RenderBuffers renderBuffers) {
        ...
        // Anim meshes
        drawElement = 0;
        modelList = scene.getModelMap().values().stream().filter(m -> m.isAnimated()).toList();
        for (Model model : modelList) {
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                RenderBuffers.AnimMeshDrawData animMeshDrawData = meshDrawData.animMeshDrawData();
                Entity entity = animMeshDrawData.entity();
                String name = "drawElements[" + drawElement + "]";
                uniformsMap.setUniform(name + ".modelMatrixIdx", entitiesIdxMap.get(entity.getId()));
                drawElement++;
            }
        }
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, animRenderBufferHandle);
        glBindVertexArray(renderBuffers.getAnimVaoId());
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowBuffer.getDepthMapTexture().getIds()[i], 0);

            CascadeShadow shadowCascade = cascadeShadows.get(i);
            uniformsMap.setUniform("projViewMatrix", shadowCascade.getProjViewMatrix());

            glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, animDrawCount, 0);
        }

        glBindVertexArray(0);
    }
    private void setupAnimCommandBuffer(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> m.isAnimated()).toList();
        int numMeshes = 0;
        for (Model model : modelList) {
            numMeshes += model.getMeshDrawDataList().size();
        }

        int firstIndex = 0;
        int baseInstance = 0;
        ByteBuffer commandBuffer = MemoryUtil.memAlloc(numMeshes * COMMAND_SIZE);
        for (Model model : modelList) {
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                RenderBuffers.AnimMeshDrawData animMeshDrawData = meshDrawData.animMeshDrawData();
                Entity entity = animMeshDrawData.entity();
                // count
                commandBuffer.putInt(meshDrawData.vertices());
                // instanceCount
                commandBuffer.putInt(1);
                commandBuffer.putInt(firstIndex);
                // baseVertex
                commandBuffer.putInt(meshDrawData.offset());
                commandBuffer.putInt(baseInstance);

                firstIndex += meshDrawData.vertices();
                baseInstance++;
            }
        }
        commandBuffer.flip();

        animDrawCount = commandBuffer.remaining() / COMMAND_SIZE;

        animRenderBufferHandle = glGenBuffers();
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, animRenderBufferHandle);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, commandBuffer, GL_DYNAMIC_DRAW);

        MemoryUtil.memFree(commandBuffer);
    }
}

クラスでは、Renderクラスをインスタンス化し、それをループとメソッドAnimationRenderで使用するだけです。ループでは、最初にクラス メソッドを呼び出すため、シーンをレンダリングする前にアニメーション変換が適用されます。rendercleanuprenderAnimationRenderrender

public class Render {

    private AnimationRender animationRender;
    ...
    public Render(Window window) {
        ...
        animationRender = new AnimationRender();
        ...
    }

    public void cleanup() {
        ...
        animationRender.cleanup();
        ...
    }

    public void render(Window window, Scene scene) {
        animationRender.render(scene, renderBuffers);
        ...
    }    
    ...
}

最後に、このMainクラスでは、アニメーションの更新レートが異なる 2 つのアニメーション化されたエンティティを作成して、エンティティ情報ごとに正しく分離されていることを確認します。

public class Main implements IAppLogic {
    ...
    private AnimationData animationData1;
    private AnimationData animationData2;
    ...
    public static void main(String[] args) {
        ...
        Engine gameEng = new Engine("chapter-21", opts, main);
        ...
    }
    ...
    public void init(Window window, Scene scene, Render render) {
        ...
        String bobModelId = "bobModel";
        Model bobModel = ModelLoader.loadModel(bobModelId, "resources/models/bob/boblamp.md5mesh",
                scene.getTextureCache(), scene.getMaterialCache(), true);
        scene.addModel(bobModel);
        Entity bobEntity = new Entity("bobEntity-1", bobModelId);
        bobEntity.setScale(0.05f);
        bobEntity.updateModelMatrix();
        animationData1 = new AnimationData(bobModel.getAnimationList().get(0));
        bobEntity.setAnimationData(animationData1);
        scene.addEntity(bobEntity);

        Entity bobEntity2 = new Entity("bobEntity-2", bobModelId);
        bobEntity2.setPosition(2, 0, 0);
        bobEntity2.setScale(0.025f);
        bobEntity2.updateModelMatrix();
        animationData2 = new AnimationData(bobModel.getAnimationList().get(0));
        bobEntity2.setAnimationData(animationData2);
        scene.addEntity(bobEntity2);
        ...
    }
    ...
    public void update(Window window, Scene scene, long diffTimeMillis) {
        animationData1.nextFrame();
        if (diffTimeMillis % 2 == 0) {
            animationData2.nextFrame();
        }
        ...
    }
}

すべての変更を実装すると、これに似たものが表示されるはずです。

第 20 章 - 間接描画 (静的モデル)

この章まで、マテリアル ユニフォーム、テクスチャ、頂点、およびインデックス バッファをバインドし、構成されているメッシュごとに 1 つの描画コマンドを送信することによって、モデルをレンダリングしてきました。この章では、より効率的なレンダリングへの道を歩み始めます。バインドレス レンダリング (少なくともほとんどバインドレス) の実装を開始します。このタイプのレンダリングでは、一連の描画コマンドを呼び出してシーンを描画するのではなく、GPU がそれらをレンダリングできるようにする命令をバッファーに入力します。これは間接レンダリングと呼ばれ、次の理由により、より効率的な描画方法です。

・各メッシュを描画する前に、いくつかのバインド操作を実行する必要がなくなりました。
・単一の描画呼び出しを呼び出すだけで済みます。
・CPU 側の負荷を軽減するフラスタム カリングなどの GPU 内操作を実行できます。
ご覧のとおり、最終的な目標は、CPU 側で発生する可能性のある潜在的なボトルネックと、CPU から GPU への通信によるレイテンシを取り除きながら、GPU の使用率を最大化することです。この章では、レンダリングを変換して、静的モデルのみから始まる間接描画を使用します。アニメ化されたモデルは、次の章で扱います。

• ドキュメント
• ソース

サンプルコードの実行

サンプルコードの実行を行ったときに、エラーがありました。

Exception in thread "main" java.lang.RuntimeException: Error linking Shader code: Type mismatch: Type of outMaterialIdx different between shaders.
Out of resource error.

これを解消するのに、以下の部分を修正しました。
＜scene.vert＞

out uint outMaterialIdx; -> flat out uint outMaterialIdx;

コンセプト

コードを説明する前に、間接描画の背後にある概念を説明しましょう。要するに、頂点のレンダリングに使用される描画パラメータを格納するバッファを作成する必要があります。これは、描画を実行するように指示する GPU によって読み取られる命令ブロックまたは描画コマンドと考えることができます。バッファーにデータが取り込まれたら、 を呼び出してglMultiDrawElementsIndirectそのプロセスをトリガーします。DrawElementsIndirectCommandバッファーに格納された各描画コマンドは、次のパラメーターによって定義されます (C を使用している場合、これは構造体によってモデル化されます)。
・count: 描画する頂点の数 (頂点とは、位置、法線情報、テクスチャ座標などをグループ化する構造と理解します)。glDrawElementsこれには、メッシュのレンダリング時に を呼び出したときに使用した頂点の数と同じ値が含まれている必要があります。
・instanceCount: 描画されるインスタンスの数。同じモデルを共有する複数のエンティティが存在する場合があります。エンティティごとに描画命令を保存する代わりに、単一の描画命令を送信するだけで、描画するエンティティの数を設定できます。これはインスタンス レンダリングと呼ばれ、計算時間を大幅に節約します。間接的な描画がなくても、VAO ごとに特定の属性を設定することで同じ結果を得ることができます。このテクニックだとさらに簡単だと思います。
・firstIndex: この描画命令に使用されるインデックス値を保持するバッファーへのオフセット (オフセットは、バイト オフセットではなく、インデックスの数で測定されます)。
・baseVertex: 頂点データを保持するバッファーへのオフセット (オフセットは、バイト オフセットではなく、頂点の数で測定されます)。
・baseInstance: このパラメーターを使用して、描画されるすべてのインスタンスで共有される値を設定できます。この値を描画するインスタンスの数と組み合わせると、インスタンスごとのデータにアクセスできます (これについては後で説明します)。

パラメータを説明するときにすでにコメントされていますが、間接描画には、頂点データを保持するバッファと、インデックス用に別のバッファが必要です。違いは、シーンのモデルを単一のバッファに適合させる複数のメッシュからすべてのデータを結合する必要があることです。メッシュごとの特定のデータにアクセスする方法は、描画パラメータのオフセット値を再生することです。

解決すべきもう 1 つの側面は、マテリアル情報またはエンティティごとのデータ (モデル マトリックスなど) を渡す方法です。前の章では、そのためにユニフォームを使用し、メッシュまたは描画するエンティティを変更したときに適切な値を設定しました。間接的な描画では、大量の描画命令を一度に送信するため、レンダリング プロセス中にデータを変更することはできません。これに対する解決策は、追加のバッファーを使用することです。エンティティごとのデータをバッファーに格納し、baseInstanceパラメーター (インスタンス ID と組み合わせて) を使用して、そのバッファー内の適切なデータ (エンティティごと) にアクセスできます (後で説明します。バッファの代わりにユニフォームの配列を使用しますが、より単純なバッファを使用することもできます)。そのバッファ内では、2 つの追加バッファにアクセスするためのインデックスを保持します。
・モデル行列データを保持するもの。
・マテリアル データ (アルベド カラーなど) を保持するもの。
テクスチャの場合、配列テクスチャと混同しないように、テクスチャの配列を使用します。配列テクスチャは、テクスチャ情報を持つ値の配列を含むテクスチャで、同じサイズの複数の画像があります。テクスチャの配列は、通常のテクスチャにマップされるサンプルのリストであるため、異なるサイズを持つことができます。テクスチャの配列には制限があり、その長さを任意の長さにすることはできず、例では最大 16 のテクスチャを設定するという制限があります (ただし、制限を設定する前に GPU の機能を確認することをお勧めします)。複数のモデルを使用している場合、16 テクスチャは高い値ではありません。この制限を回避するには、次の 2 つのオプションがあります。
・テクスチャ アトラス (個々のテクスチャを組み合わせた巨大なテクスチャ ファイル) を使用します。間接描画を使用していない場合でも、バインド呼び出しが制限されるため、テクスチャ アトラスをできるだけ使用するようにしてください。
・バインドレス テクスチャを使用します。このアプローチでは基本的に、ハンドル (64 ビット整数値) を渡してテクスチャを識別し、その識別子を使用してシェーダー プログラムでサンプラーを取得できます。可能であれば、これは間違いなく間接レンダリングを使用する方法です (これはコア機能ではなく、バージョン 4.4 以降の拡張機能です)。RenderDoc は現在これをサポートしていないため、このアプローチは使用しません (RenderDoc なしでデバッグする機能を失うことは、私にとって致命的です)。

次の図は、間接描画に関係するバッファーと構造を示しています (これは、静的モデルのレンダリング中にのみ有効であることに注意してください。アニメーション モデルのレンダリングに使用する必要がある新しい構造については、次の章で説明します)。

エンティティ データ、マテリアル、およびモデル マトリックスごとにユニフォームの配列を使用することに注意してください (最後に、配列はバッファーですが、ユニフォームを使用することで便利な方法でデータにアクセスできます)。

実装

間接描画を使用するには、少なくとも OpenGL バージョン 4.6 を使用する必要があります。したがって、最初のステップは、ウィンドウ作成のウィンドウ ヒントとして使用するメジャー バージョンとマイナー バージョンを更新することです。

public class Window {
    ...
    public Window(String title, WindowOptions opts, Callable<Void> resizeFunc) {
        ...
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6);
        ...
    }
    ...
}

次のステップは、すべてのメッシュを 1 つのバッファにロードするようにコードを変更することですが、その前に、モデル、マテリアル、およびメッシュを格納するクラス階層を変更しません。これまで、モデルには一連のメッシュを持つ一連の関連付けられたマテリアルがあります。このクラス階層は、ドロー コールを最適化するように設定されており、最初にモデルを反復し、次にマテリアルを反復し、最後にメッシュを反復しました。この構造を変更し、マテリアルの下にメッシュを保存しなくなります。代わりに、メッシュはモデルの直下に保存されます。マテリアルを一種のキャッシュに保存し、そのキャッシュ内のメッシュのキーへの参照を保持します。それに加えて、以前は、Mesh各モデル メッシュのインスタンス。本質的に、メッシュ データの VAO と関連する VBO が含まれていました。すべてのメッシュに対して単一のバッファを使用するため、シーンのメッシュのセット全体に対して単一の VAO とそれに関連付けられた VBO が必要になります。Mesh したがって、クラスの下にインスタンスのリストを保存する代わりにModel、頂点バッファーのオフセット、インデックス バッファーのオフセットなど、描画パラメーターを構築するために使用されるデータを保存します。変更を調べてみましょう。一つずつ。

MaterialCache次のように定義されているクラスから始めます。

package org.lwjglb.engine.graph;

import java.util.*;

public class MaterialCache {

    public static final int DEFAULT_MATERIAL_IDX = 0;

    private List<Material> materialsList;

    public MaterialCache() {
        materialsList = new ArrayList<>();
        Material defaultMaterial = new Material();
        materialsList.add(defaultMaterial);
    }

    public void addMaterial(Material material) {
        materialsList.add(material);
        material.setMaterialIdx(materialsList.size() - 1);
    }

    public Material getMaterial(int idx) {
        return materialsList.get(idx);
    }

    public List<Material> getMaterialsList() {
        return materialsList;
    }
}

ご覧のとおり、Materialインスタンスを に格納するだけListです。したがって、 を識別するためにMaterial必要なのは、リスト内のそのインスタンスのインデックスだけです。(このアプローチでは、動的に新しいマテリアルを追加するのが難しくなる場合がありますが、このサンプルの目的には十分単純です。それを変更して、新しいモデル、マテリアルなどをコードに追加するための堅牢なサポートを提供することもできます。 ）。クラスを変更してインスタンスMaterialのリストを削除しMesh、マテリアル インデックスをマテリアル キャッシュに保存する必要があります。

public class Material {
    ...
    private Vector4f ambientColor;
    private Vector4f diffuseColor;
    private int materialIdx;
    private String normalMapPath;
    private float reflectance;
    private Vector4f specularColor;
    private String texturePath;

    public Material() {
        diffuseColor = DEFAULT_COLOR;
        ambientColor = DEFAULT_COLOR;
        specularColor = DEFAULT_COLOR;
        materialIdx = 0;
    }
    ...
    public int getMaterialIdx() {
        return materialIdx;
    }
    ...
    public void setMaterialIdx(int materialIdx) {
        this.materialIdx = materialIdx;
    }
    ...
}

前に説明したように、Modelクラスを変更してマテリアルへの参照を削除する必要があります。代わりに、2 つの主要なリファレンスを保持します。

・MeshDataAssimp を使用して読み取ったメッシュ データを保持するリストインスタンス (新しいクラス)。
・RenderBuffers.MeshDrawData間接描画に必要な情報 (主に、上記で説明したデータ バッファーに関連付けられたオフセット情報) を含むインスタンス (これも新しいクラス)のリスト。
MeshDataassimp を使用してモデルをロードするときに、最初にインスタンスのリストを生成します。その後、データを保持するグローバル バッファーを作成して、RenderBuffers.MeshDrawDataインスタンスを生成します。その後、 MeshDataインスタンスへの参照を削除できます。これはあまり洗練されたソリューションではありませんが、ロード前とロード後の階層を使用して複雑さを増すことなく、概念を説明するのに十分単純です。クラスの変更点は次のModelとおりです。

public class Model {
    ...
    private final String id;
    private List<Animation> animationList;
    private List<Entity> entitiesList;
    private List<MeshData> meshDataList;
    private List<RenderBuffers.MeshDrawData> meshDrawDataList;

    public Model(String id, List<MeshData> meshDataList, List<Animation> animationList) {
        entitiesList = new ArrayList<>();
        this.id = id;
        this.meshDataList = meshDataList;
        this.animationList = animationList;
        meshDrawDataList = new ArrayList<>();
    }
    ...
    public List<MeshData> getMeshDataList() {
        return meshDataList;
    }

    public List<RenderBuffers.MeshDrawData> getMeshDrawDataList() {
        return meshDrawDataList;
    }

    public boolean isAnimated() {
        return animationList != null && !animationList.isEmpty();
    }
    ...
}

クラスの定義MeshDataは非常に単純です。頂点の位置、テクスチャ座標などを保存するだけです。

package org.lwjglb.engine.graph;

import org.joml.Vector3f;

public class MeshData {

    private Vector3f aabbMax;
    private Vector3f aabbMin;
    private float[] bitangents;
    private int[] boneIndices;
    private int[] indices;
    private int materialIdx;
    private float[] normals;
    private float[] positions;
    private float[] tangents;
    private float[] textCoords;
    private float[] weights;

    public MeshData(float[] positions, float[] normals, float[] tangents, float[] bitangents,
                    float[] textCoords, int[] indices, int[] boneIndices, float[] weights,
                    Vector3f aabbMin, Vector3f aabbMax) {
        materialIdx = 0;
        this.positions = positions;
        this.normals = normals;
        this.tangents = tangents;
        this.bitangents = bitangents;
        this.textCoords = textCoords;
        this.indices = indices;
        this.boneIndices = boneIndices;
        this.weights = weights;
        this.aabbMin = aabbMin;
        this.aabbMax = aabbMax;
    }

    public Vector3f getAabbMax() {
        return aabbMax;
    }

    public Vector3f getAabbMin() {
        return aabbMin;
    }

    public float[] getBitangents() {
        return bitangents;
    }

    public int[] getBoneIndices() {
        return boneIndices;
    }

    public int[] getIndices() {
        return indices;
    }

    public int getMaterialIdx() {
        return materialIdx;
    }

    public float[] getNormals() {
        return normals;
    }

    public float[] getPositions() {
        return positions;
    }

    public float[] getTangents() {
        return tangents;
    }

    public float[] getTextCoords() {
        return textCoords;
    }

    public float[] getWeights() {
        return weights;
    }

    public void setMaterialIdx(int materialIdx) {
        this.materialIdx = materialIdx;
    }
}

クラスの変更ModelLoaderも非常に簡単です。マテリアル キャッシュを使用し、読み取ったデータをMeshData(以前のMeshクラスではなく) 新しいクラスに保存する必要があります。また、マテリアルにはメッシュ データへの参照はありませんが、メッシュ データにはキャッシュ内のマテリアルのインデックスへの参照があります。

public class ModelLoader {
    ...
    public static Model loadModel(String modelId, String modelPath, TextureCache textureCache, MaterialCache materialCache,
                                  boolean animation) {
        return loadModel(modelId, modelPath, textureCache, materialCache, aiProcess_GenSmoothNormals | aiProcess_JoinIdenticalVertices |
                aiProcess_Triangulate | aiProcess_FixInfacingNormals | aiProcess_CalcTangentSpace | aiProcess_LimitBoneWeights |
                aiProcess_GenBoundingBoxes | (animation ? 0 : aiProcess_PreTransformVertices));
    }

    public static Model loadModel(String modelId, String modelPath, TextureCache textureCache,
                                  MaterialCache materialCache, int flags) {
        ...

        for (int i = 0; i < numMaterials; i++) {
            AIMaterial aiMaterial = AIMaterial.create(aiScene.mMaterials().get(i));
            Material material = processMaterial(aiMaterial, modelDir, textureCache);
            materialCache.addMaterial(material);
            materialList.add(material);
        }

        int numMeshes = aiScene.mNumMeshes();
        PointerBuffer aiMeshes = aiScene.mMeshes();
        List<MeshData> meshDataList = new ArrayList<>();
        List<Bone> boneList = new ArrayList<>();
        for (int i = 0; i < numMeshes; i++) {
            AIMesh aiMesh = AIMesh.create(aiMeshes.get(i));
            MeshData meshData = processMesh(aiMesh, boneList);
            int materialIdx = aiMesh.mMaterialIndex();
            if (materialIdx >= 0 && materialIdx < materialList.size()) {
                meshData.setMaterialIdx(materialList.get(materialIdx).getMaterialIdx());
            } else {
                meshData.setMaterialIdx(MaterialCache.DEFAULT_MATERIAL_IDX);
            }
            meshDataList.add(meshData);
        }
        ...
        return new Model(modelId, meshDataList, animations);
    }
    ...
    private static MeshData processMesh(AIMesh aiMesh, List<Bone> boneList) {
        ...
        return new MeshData(vertices, normals, tangents, bitangents, textCoords, indices, animMeshData.boneIds,
                animMeshData.weights, aabbMin, aabbMax);
    }
}

このSceneクラスは、マテリアル キャッシュを保持するクラスになります (また、cleanupVAO と VBO がモデル マップにリンクされなくなるため、mwthod は不要になります):

public class Scene {
    ...
    private MaterialCache materialCache;
    ...
    public Scene(int width, int height) {
        ...
        materialCache = new MaterialCache();
        ...
    }
    ...
    public MaterialCache getMaterialCache() {
        return materialCache;
    }
    ...    
}

クラスの変更は、Meshクラスを導入したためMeshDataです (コンストラクターの引数とメソッドを変更するだけの問題です)。

public class Mesh {
    ...
    public Mesh(MeshData meshData) {
        try (MemoryStack stack = MemoryStack.stackPush()) {
            this.aabbMin = meshData.getAabbMin();
            this.aabbMax = meshData.getAabbMax();
            numVertices = meshData.getIndices().length;
            ...
            FloatBuffer positionsBuffer = stack.callocFloat(meshData.getPositions().length);
            positionsBuffer.put(0, meshData.getPositions());
            ...
            FloatBuffer normalsBuffer = stack.callocFloat(meshData.getNormals().length);
            normalsBuffer.put(0, meshData.getNormals());
            ...
            FloatBuffer tangentsBuffer = stack.callocFloat(meshData.getTangents().length);
            tangentsBuffer.put(0, meshData.getTangents());
            ...
            FloatBuffer bitangentsBuffer = stack.callocFloat(meshData.getBitangents().length);
            bitangentsBuffer.put(0, meshData.getBitangents());
            ...
            FloatBuffer textCoordsBuffer = MemoryUtil.memAllocFloat(meshData.getTextCoords().length);
            textCoordsBuffer.put(0, meshData.getTextCoords());
            ...
            FloatBuffer weightsBuffer = MemoryUtil.memAllocFloat(meshData.getWeights().length);
            weightsBuffer.put(meshData.getWeights()).flip();
            ...
            IntBuffer boneIndicesBuffer = MemoryUtil.memAllocInt(meshData.getBoneIndices().length);
            boneIndicesBuffer.put(meshData.getBoneIndices()).flip();
            ...
            IntBuffer indicesBuffer = stack.callocInt(meshData.getIndices().length);
            indicesBuffer.put(0, meshData.getIndices());
        }
    }
    ...
}

今度は、間接描画用に作成する新しい主要なクラスの 1 つであるRenderBuffersクラスの番です。このクラスは、すべてのメッシュのデータを含む VBO を保持する単一の VAO を作成します。この場合、静的モデルのみをサポートするため、単一の VAO が必要になります。クラスは次のRenderBuffersように始まります。

public class RenderBuffers {

    private int staticVaoId;
    private List<Integer> vboIdList;

    public RenderBuffers() {
        vboIdList = new ArrayList<>();
    }

    public void cleanup() {
        vboIdList.stream().forEach(GL30::glDeleteBuffers);
        glDeleteVertexArrays(staticVaoId);
    }
    ...
}

このクラスは、モデルをロードする 2 つのメソッドを定義します。

・loadAnimatedModelsアニメモデル用。これは、この章では実装されません。
・loadStaticModelsアニメーションのないモデルの場合。
これらのメソッドは次のように定義されています。

public class RenderBuffers {
    ...
    public final int getStaticVaoId() {
        return staticVaoId;
    }

    public void loadAnimatedModels(Scene scene) {
        // To be completed
    }

    public void loadStaticModels(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> !m.isAnimated()).toList();
        staticVaoId = glGenVertexArrays();
        glBindVertexArray(staticVaoId);
        int positionsSize = 0;
        int normalsSize = 0;
        int textureCoordsSize = 0;
        int indicesSize = 0;
        int offset = 0;
        for (Model model : modelList) {
            List<RenderBuffers.MeshDrawData> meshDrawDataList = model.getMeshDrawDataList();
            for (MeshData meshData : model.getMeshDataList()) {
                positionsSize += meshData.getPositions().length;
                normalsSize += meshData.getNormals().length;
                textureCoordsSize += meshData.getTextCoords().length;
                indicesSize += meshData.getIndices().length;

                int meshSizeInBytes = meshData.getPositions().length * 14 * 4;
                meshDrawDataList.add(new MeshDrawData(meshSizeInBytes, meshData.getMaterialIdx(), offset,
                        meshData.getIndices().length));
                offset = positionsSize / 3;
            }
        }

        int vboId = glGenBuffers();
        vboIdList.add(vboId);
        FloatBuffer meshesBuffer = MemoryUtil.memAllocFloat(positionsSize + normalsSize * 3 + textureCoordsSize);
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                populateMeshBuffer(meshesBuffer, meshData);
            }
        }
        meshesBuffer.flip();
        glBindBuffer(GL_ARRAY_BUFFER, vboId);
        glBufferData(GL_ARRAY_BUFFER, meshesBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(meshesBuffer);

        defineVertexAttribs();
         // Index VBO
        vboId = glGenBuffers();
        vboIdList.add(vboId);
        IntBuffer indicesBuffer = MemoryUtil.memAllocInt(indicesSize);
        for (Model model : modelList) {
            for (MeshData meshData : model.getMeshDataList()) {
                indicesBuffer.put(meshData.getIndices());
            }
        }
        indicesBuffer.flip();
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboId);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, indicesBuffer, GL_STATIC_DRAW);
        MemoryUtil.memFree(indicesBuffer);

        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }
    ...
}

まず、VAO (静的モデルに使用されます) を作成し、モデルのメッシュを反復処理します。単一のバッファを使用してすべてのデータを保持するため、これらの要素を繰り返し処理して最終的なバッファ サイズを取得します。RenderBuffers.MeshDrawData位置要素、法線などの数を計算します。最初のループを使用して、インスタンスを含むリストに保存するオフセット情報も入力します。その後、単一の VBO を作成します。MeshVAO と VBO を作成する同様のタスクを行ったクラスとの大きな違いがわかります。この場合、位置や法線などに単一の VBO を使用します。個別の VBO を使用する代わりに、すべてのデータを行ごとにロードするだけです。これは、populateMeshBuffer（これについては後で説明します）。その後、すべてのモデルのすべてのメッシュのインデックスを含むインデックス VBO を作成します。

クラスは次のMeshDrawDataように定義されます。

public class RenderBuffers {
    ...
    public record MeshDrawData(int sizeInBytes, int materialIdx, int offset, int vertices) {
    }
}

基本的に、メッシュのサイズ (バイト単位) ( sizeInBytes)、関連付けられているマテリアル インデックス、頂点情報と頂点を保持するバッファー内のオフセット、このメッシュのインデックス数を格納します。オフセットは「行」で測定されます。位置、法線、テクスチャ座標を保持するメッシュの部分を 1 つの「行」と考えることができます。この「行」は、1 つの頂点に関連付けられたすべての情報を保持し、頂点シェーダーで処理されます。これが、位置要素の数を 3 だけダイブする理由です。各「行」には 3 つの位置要素があり、位置データの「行」の数は法線データの「行」の数と一致します。 .

は次のpopulateMeshBufferように定義されます。

public class RenderBuffers {
    ...
    private void populateMeshBuffer(FloatBuffer meshesBuffer, MeshData meshData) {
        float[] positions = meshData.getPositions();
        float[] normals = meshData.getNormals();
        float[] tangents = meshData.getTangents();
        float[] bitangents = meshData.getBitangents();
        float[] textCoords = meshData.getTextCoords();

        int rows = positions.length / 3;
        for (int row = 0; row < rows; row++) {
            int startPos = row * 3;
            int startTextCoord = row * 2;
            meshesBuffer.put(positions[startPos]);
            meshesBuffer.put(positions[startPos + 1]);
            meshesBuffer.put(positions[startPos + 2]);
            meshesBuffer.put(normals[startPos]);
            meshesBuffer.put(normals[startPos + 1]);
            meshesBuffer.put(normals[startPos + 2]);
            meshesBuffer.put(tangents[startPos]);
            meshesBuffer.put(tangents[startPos + 1]);
            meshesBuffer.put(tangents[startPos + 2]);
            meshesBuffer.put(bitangents[startPos]);
            meshesBuffer.put(bitangents[startPos + 1]);
            meshesBuffer.put(bitangents[startPos + 2]);
            meshesBuffer.put(textCoords[startTextCoord]);
            meshesBuffer.put(textCoords[startTextCoord + 1]);
        }
    }
    ...
}

ご覧のとおり、データの「行」を繰り返し処理し、位置、法線、およびテクスチャ座標をバッファにパックします。は次のdefineVertexAttribsように定義されます。

public class RenderBuffers {
    ...
    private void defineVertexAttribs() {
        int stride = 3 * 4 * 4 + 2 * 4;
        int pointer = 0;
        // Positions
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, false, stride, pointer);
        pointer += 3 * 4;
        // Normals
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1, 3, GL_FLOAT, false, stride, pointer);
        pointer += 3 * 4;
        // Tangents
        glEnableVertexAttribArray(2);
        glVertexAttribPointer(2, 3, GL_FLOAT, false, stride, pointer);
        pointer += 3 * 4;
        // Bitangents
        glEnableVertexAttribArray(3);
        glVertexAttribPointer(3, 3, GL_FLOAT, false, stride, pointer);
        pointer += 3 * 4;
        // Texture coordinates
        glEnableVertexAttribArray(4);
        glVertexAttribPointer(4, 2, GL_FLOAT, false, stride, pointer);
    }
    ...
}

前の例のように、VAO の頂点属性を定義するだけです。ここでの唯一の違いは、単一の VBO を使用していることです。

クラスの変更を調べる前に、次のように始まる頂点シェーダー ( ) からSceneRender始めましょう。scene.vert

#version 460

const int MAX_DRAW_ELEMENTS = 100;
const int MAX_ENTITIES = 50;

layout (location=0) in vec3 position;
layout (location=1) in vec3 normal;
layout (location=2) in vec3 tangent;
layout (location=3) in vec3 bitangent;
layout (location=4) in vec2 texCoord;

out vec3 outNormal;
out vec3 outTangent;
out vec3 outBitangent;
out vec2 outTextCoord;
out vec4 outViewPosition;
out vec4 outWorldPosition;
out uint outMaterialIdx;

struct DrawElement
{
    int modelMatrixIdx;
    int materialIdx;
};

uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;
uniform DrawElement drawElements[MAX_DRAW_ELEMENTS];
uniform mat4 modelMatrices[MAX_ENTITIES];
...

最初に気付くのは、バージョンが に増えたこと460です。また、アニメーションに関連付けられた定数 (MAX_WEIGHTSおよびMAX_BONES)、ボーン インデックスの属性、およびボーン マトリックスのユニフォームを削除しました。次の章で、アニメーションにはこの情報が必要ないことがわかります。drawElementsとmodelMatricesユニフォームのサイズを定義する 2 つの新しい定数を作成しました。drawElementsユニフォームはインスタンスを保持しますDrawElement。メッシュと関連付けられたエンティティごとに 1 つのアイテムがあります。覚えていると思いますが、メッシュに関連付けられたすべてのアイテムを描画する単一の命令を記録し、描画するインスタンスの数を設定します。ただし、モデル マトリックスなど、エンティティごとに固有のデータが必要になります。これはdrawElementsこの配列は、使用されるマテリアル インデックスも指します。modelMatrices配列は、各エンティティのモデル マトリックスのみを保持します。outMaterialIdxマテリアル情報は、出力変数を使用して渡すフラグメント シェーダーで使用されます。

mainアニメーションを扱う必要がないため、関数は大幅に単純化されています。

...
void main()
{
    vec4 initPos = vec4(position, 1.0);
    vec4 initNormal = vec4(normal, 0.0);
    vec4 initTangent = vec4(tangent, 0.0);
    vec4 initBitangent = vec4(bitangent, 0.0);

    uint idx = gl_BaseInstance + gl_InstanceID;
    DrawElement drawElement = drawElements[idx];
    outMaterialIdx = drawElement.materialIdx;
    mat4 modelMatrix =  modelMatrices[drawElement.modelMatrixIdx];
    mat4 modelViewMatrix = viewMatrix * modelMatrix;
    outWorldPosition = modelMatrix * initPos;
    outViewPosition  = viewMatrix * outWorldPosition;
    gl_Position   = projectionMatrix * outViewPosition;
    outNormal     = normalize(modelViewMatrix * initNormal).xyz;
    outTangent    = normalize(modelViewMatrix * initTangent).xyz;
    outBitangent  = normalize(modelViewMatrix * initBitangent).xyz;
    outTextCoord  = texCoord;
}

ここで重要なのは、drawElementsサイズにアクセスするための適切なインデックスを取得することです。gl_BaseInstanceおよびgl_InstanceID組み込み変数を使用します。間接描画の指示を記録するときは、baseInstance属性を使用します。その属性の値は、gl_BaseInstance組み込み変数に関連付けられたものになります。は、メッシュから別のメッシュに変更するたびにgl_InstanceID開始さ0れ、モデルに関連付けられたエンティティのインスタンスの数だけ増加します。したがって、この 2 つの変数を組み合わせることで、drawElements配列内のエンティティごとの特定の情報にアクセスできるようになります。適切なインデックスを取得したら、以前のバージョンのシェーダーと同様に、位置と法線情報を変換するだけです。

シーン フラグメント シェーダー ( scene.frag) は次のように定義されます。

#version 400

const int MAX_MATERIALS  = 20;
const int MAX_TEXTURES = 16;

in vec3 outNormal;
in vec3 outTangent;
in vec3 outBitangent;
in vec2 outTextCoord;
in vec4 outViewPosition;
in vec4 outWorldPosition;
flat in uint outMaterialIdx;

layout (location = 0) out vec4 buffAlbedo;
layout (location = 1) out vec4 buffNormal;
layout (location = 2) out vec4 buffSpecular;

struct Material
{
    vec4 diffuse;
    vec4 specular;
    float reflectance;
    int normalMapIdx;
    int textureIdx;
};

uniform sampler2D txtSampler[MAX_TEXTURES];
uniform Material materials[MAX_MATERIALS];

vec3 calcNormal(int idx, vec3 normal, vec3 tangent, vec3 bitangent, vec2 textCoords) {
    mat3 TBN = mat3(tangent, bitangent, normal);
    vec3 newNormal = texture(txtSampler[idx], textCoords).rgb;
    newNormal = normalize(newNormal * 2.0 - 1.0);
    newNormal = normalize(TBN * newNormal);
    return newNormal;
}

void main() {
    Material material = materials[outMaterialIdx];
    vec4 text_color = texture(txtSampler[material.textureIdx], outTextCoord);
    vec4 diffuse = text_color + material.diffuse;
    if (diffuse.a < 0.5) {
        discard;
    }
    vec4 specular = text_color + material.specular;

    vec3 normal = outNormal;
    if (material.normalMapIdx > 0) {
        normal = calcNormal(material.normalMapIdx, outNormal, outTangent, outBitangent, outTextCoord);
    }

    buffAlbedo   = vec4(diffuse.xyz, material.reflectance);
    buffNormal   = vec4(0.5 * normal + 0.5, 1.0);
    buffSpecular = specular;
}

主な変更点は、マテリアル情報とテクスチャへのアクセス方法に関連しています。これで、マテリアル情報の配列が得られます。これは、現在outMaterialIdx入力変数にある頂点シェーダーで計算したインデックスによってアクセスされます (これには、flatこの値を頂点からフラグメント ステージに補間してはならないことを示す修飾子があります)。 . テクスチャの配列を使用して、通常のテクスチャまたは法線マップにアクセスします。これらのテクスチャへのインデックスは、Material構造体に格納されるようになりました。非定数式を使用してサンプラーの配列にアクセスするため、GLSL バージョンを 400 にアップグレードする必要があります (この機能は OpenGL 4.0 以降でのみ使用可能です)。

今度は、SceneRenderクラスの変化を調べる番です。コードで使用される一連の定数、間接描画命令 ( staticRenderBufferHandle) および描画コマンドの数( ) を持つバッファーの 1 つのハンドルを定義することから始めますstaticDrawCount。createUniforms前に示したシェーダーの変更に従って、メソッドを変更する必要もあります。

public class SceneRender {
    ...
    public static final int MAX_DRAW_ELEMENTS = 100;
    public static final int MAX_ENTITIES = 50;
    private static final int COMMAND_SIZE = 5 * 4;
    private static final int MAX_MATERIALS = 20;
    private static final int MAX_TEXTURES = 16;
    ...
    private Map<String, Integer> entitiesIdxMap;
    ...
    private int staticDrawCount;
    private int staticRenderBufferHandle;
    ...
    public SceneRender() {
        ...
        entitiesIdxMap = new HashMap<>();
    }

    private void createUniforms() {
        uniformsMap = new UniformsMap(shaderProgram.getProgramId());
        uniformsMap.createUniform("projectionMatrix");
        uniformsMap.createUniform("viewMatrix");

        for (int i = 0; i < MAX_TEXTURES; i++) {
            uniformsMap.createUniform("txtSampler[" + i + "]");
        }

        for (int i = 0; i < MAX_MATERIALS; i++) {
            String name = "materials[" + i + "]";
            uniformsMap.createUniform(name + ".diffuse");
            uniformsMap.createUniform(name + ".specular");
            uniformsMap.createUniform(name + ".reflectance");
            uniformsMap.createUniform(name + ".normalMapIdx");
            uniformsMap.createUniform(name + ".textureIdx");
        }

        for (int i = 0; i < MAX_DRAW_ELEMENTS; i++) {
            String name = "drawElements[" + i + "]";
            uniformsMap.createUniform(name + ".modelMatrixIdx");
            uniformsMap.createUniform(name + ".materialIdx");
        }

        for (int i = 0; i < MAX_ENTITIES; i++) {
            uniformsMap.createUniform("modelMatrices[" + i + "]");
        }
    }
    ...
}

は、各エンティティが配置されているモデルに関連付けられたエンティティのリスト内のentitiesIdxMap位置を保存します。Mapその情報をエンティティ識別子をキーとして使用して保存します。間接描画コマンドは、各モデルに関連付けられたメッシュを反復して記録されるため、後でこの情報が必要になります。主な変更点はrenderメソッドにあり、次のように定義されています。

public class SceneRender {
    ...
    public void render(Scene scene, RenderBuffers renderBuffers, GBuffer gBuffer) {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, gBuffer.getGBufferId());
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glViewport(0, 0, gBuffer.getWidth(), gBuffer.getHeight());
        glDisable(GL_BLEND);

        shaderProgram.bind();

        uniformsMap.setUniform("projectionMatrix", scene.getProjection().getProjMatrix());
        uniformsMap.setUniform("viewMatrix", scene.getCamera().getViewMatrix());

        TextureCache textureCache = scene.getTextureCache();
        List<Texture> textures = textureCache.getAll().stream().toList();
        int numTextures = textures.size();
        if (numTextures > MAX_TEXTURES) {
            Logger.warn("Only " + MAX_TEXTURES + " textures can be used");
        }
        for (int i = 0; i < Math.min(MAX_TEXTURES, numTextures); i++) {
            uniformsMap.setUniform("txtSampler[" + i + "]", i);
            Texture texture = textures.get(i);
            glActiveTexture(GL_TEXTURE0 + i);
            texture.bind();
        }

        int entityIdx = 0;
        for (Model model : scene.getModelMap().values()) {
            List<Entity> entities = model.getEntitiesList();
            for (Entity entity : entities) {
                uniformsMap.setUniform("modelMatrices[" + entityIdx + "]", entity.getModelMatrix());
                entityIdx++;
            }
        }

        // Static meshes
        int drawElement = 0;
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> !m.isAnimated()).toList();
        for (Model model : modelList) {
            List<Entity> entities = model.getEntitiesList();
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                for (Entity entity : entities) {
                    String name = "drawElements[" + drawElement + "]";
                    uniformsMap.setUniform(name + ".modelMatrixIdx", entitiesIdxMap.get(entity.getId()));
                    uniformsMap.setUniform(name + ".materialIdx", meshDrawData.materialIdx());
                    drawElement++;
                }
            }
        }
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, staticRenderBufferHandle);
        glBindVertexArray(renderBuffers.getStaticVaoId());
        glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, staticDrawCount, 0);
        glBindVertexArray(0);

        glEnable(GL_BLEND);
        shaderProgram.unbind();
    }
    ...
}

テクスチャ サンプラーの配列をバインドし、すべてのテクスチャ ユニットをアクティブにする必要があることがわかります。それに加えて、エンティティを繰り返し処理し、モデル マトリックスに均一な値を設定します。drawElements次のステップは、モデル マトリックスのインデックスとマテリアル インデックスを指す各エンティティの適切な値を使用して、アレイ ユニフォームをセットアップすることです。その後、glMultiDrawElementsIndirect間接描画を行う機能。その前に、描画命令 (描画コマンド) を保持するバッファーと、メッシュとインデックス データを保持する VAO をバインドする必要があります。しかし、いつ間接描画用のバッファを設定するのでしょうか? 答えは、レンダリング コールごとにこれを実行する必要はないということです。エンティティの数に変化がない場合は、そのバッファを 1 回記録して、各レンダリング コールで使用できます。この特定の例では、起動時にそのバッファにデータを入力するだけです。つまり、エンティティの数を変更したい場合は、そのバッファを再度作成する必要があります (独自のエンジンに対して行う必要があります)。

間接描画バッファーを実際に構築するメソッドが呼び出さsetupStaticCommandBufferれ、次のように定義されます。

public class SceneRender {
    ...
    private void setupStaticCommandBuffer(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> !m.isAnimated()).toList();
        int numMeshes = 0;
        for (Model model : modelList) {
            numMeshes += model.getMeshDrawDataList().size();
        }

        int firstIndex = 0;
        int baseInstance = 0;
        ByteBuffer commandBuffer = MemoryUtil.memAlloc(numMeshes * COMMAND_SIZE);
        for (Model model : modelList) {
            List<Entity> entities = model.getEntitiesList();
            int numEntities = entities.size();
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                // count
                commandBuffer.putInt(meshDrawData.vertices());
                // instanceCount
                commandBuffer.putInt(numEntities);
                commandBuffer.putInt(firstIndex);
                // baseVertex
                commandBuffer.putInt(meshDrawData.offset());
                commandBuffer.putInt(baseInstance);

                firstIndex += meshDrawData.vertices();
                baseInstance += entities.size();
            }
        }
        commandBuffer.flip();

        staticDrawCount = commandBuffer.remaining() / COMMAND_SIZE;

        staticRenderBufferHandle = glGenBuffers();
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, staticRenderBufferHandle);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, commandBuffer, GL_DYNAMIC_DRAW);

        MemoryUtil.memFree(commandBuffer);
    }
    ...
}

最初にメッシュの総数を計算します。その後、間接描画命令を保持するバッファを作成して入力します。ご覧のとおり、最初に を割り当てますByteBuffer。このバッファは、メッシュと同じ数の命令セットを保持します。描画命令の各セットは 5 つの属性で構成され、それぞれの長さは 4 バイトです (パラメーターの各セットの合計の長さがCOMMAND_SIZE定数を定義します)。すぐにスペースが不足するため、このバッファーを使用して割り当てることはできませんMemoryStack(LWJGL がこれに使用するスタックのサイズは制限されています)。したがって、使用して割り当てる必要がありますMemoryUtil完了したら、手動で割り当てを解除することを忘れないでください。バッファを取得したら、モデルに関連付けられたメッシュの反復処理を開始します。この章の冒頭を見て、間接描画に必要な構造体を確認してください。それに加えて、各エンティティのモデル マトリックス インデックスを適切に取得するために、以前に計算した をdrawElements使用してユニフォームを設定します。Map最後に、GPU バッファーを作成し、データをそこにダンプします。

メソッドを更新しcleanupて間接描画バッファを解放する必要があります。

public class SceneRender {
    ...
    public void cleanup() {
        shaderProgram.cleanup();
        glDeleteBuffers(staticRenderBufferHandle);
    }
    ...
}

マテリアル ユニフォームの値を設定するには、新しいメソッドが必要になります。

public class SceneRender {
   private void setupMaterialsUniform(TextureCache textureCache, MaterialCache materialCache) {
        List<Texture> textures = textureCache.getAll().stream().toList();
        int numTextures = textures.size();
        if (numTextures > MAX_TEXTURES) {
            Logger.warn("Only " + MAX_TEXTURES + " textures can be used");
        }
        Map<String, Integer> texturePosMap = new HashMap<>();
        for (int i = 0; i < Math.min(MAX_TEXTURES, numTextures); i++) {
            texturePosMap.put(textures.get(i).getTexturePath(), i);
        }

        shaderProgram.bind();
        List<Material> materialList = materialCache.getMaterialsList();
        int numMaterials = materialList.size();
        for (int i = 0; i < numMaterials; i++) {
            Material material = materialCache.getMaterial(i);
            String name = "materials[" + i + "]";
            uniformsMap.setUniform(name + ".diffuse", material.getDiffuseColor());
            uniformsMap.setUniform(name + ".specular", material.getSpecularColor());
            uniformsMap.setUniform(name + ".reflectance", material.getReflectance());
            String normalMapPath = material.getNormalMapPath();
            int idx = 0;
            if (normalMapPath != null) {
                idx = texturePosMap.computeIfAbsent(normalMapPath, k -> 0);
            }
            uniformsMap.setUniform(name + ".normalMapIdx", idx);
            Texture texture = textureCache.getTexture(material.getTexturePath());
            idx = texturePosMap.computeIfAbsent(texture.getTexturePath(), k -> 0);
            uniformsMap.setUniform(name + ".textureIdx", idx);
        }
        shaderProgram.unbind();
    }
}

サポートされているテクスチャの最大数 ( MAX_TEXTURES) を超えていないことを確認し、前の章で使用した情報を使用してマテリアル情報の配列を作成するだけです。唯一の変更点は、関連するテクスチャと法線マップのインデックスをマテリアル情報に保存する必要があることです。

エンティティ インデックス マップを更新するには、別のメソッドが必要です。

public class SceneRender {
    ...
    private void setupEntitiesData(Scene scene) {
        entitiesIdxMap.clear();
        int entityIdx = 0;
        for (Model model : scene.getModelMap().values()) {
            List<Entity> entities = model.getEntitiesList();
            for (Entity entity : entities) {
                entitiesIdxMap.put(entity.getId(), entityIdx);
                entityIdx++;
            }
        }
    }
    ...
}

クラスの変更を完了するには、クラスから呼び出せるようにSceneRenderをラップするメソッドを作成します。setupXXRender

public class SceneRender {
    ...
    public void setupData(Scene scene) {
        setupEntitiesData(scene);
        setupStaticCommandBuffer(scene);
        setupMaterialsUniform(scene.getTextureCache(), scene.getMaterialCache());
    }
    ...
}

影のレンダリング プロセスも間接描画を使用するように変更します。頂点シェーダー ( ) の変更は非常に似ています。アニメーション情報は使用せず、組み込み変数とshadow.vertの組み合わせを使用して適切なモデル マトリックスにアクセスする必要があります。この場合、マテリアル情報は必要ないため、フラグメント シェーダー ( ) は変更されません。gl_BaseInstancegl_InstanceIDshadow.frag

#version 460

const int MAX_DRAW_ELEMENTS = 100;
const int MAX_ENTITIES = 50;

layout (location=0) in vec3 position;
layout (location=1) in vec3 normal;
layout (location=2) in vec3 tangent;
layout (location=3) in vec3 bitangent;
layout (location=4) in vec2 texCoord;

struct DrawElement
{
    int modelMatrixIdx;
};

uniform mat4 modelMatrix;
uniform mat4 projViewMatrix;
uniform DrawElement drawElements[MAX_DRAW_ELEMENTS];
uniform mat4 modelMatrices[MAX_ENTITIES];

void main()
{
    vec4 initPos = vec4(position, 1.0);
    uint idx = gl_BaseInstance + gl_InstanceID;
    int modelMatrixIdx = drawElements[idx].modelMatrixIdx;
    mat4 modelMatrix = modelMatrices[modelMatrixIdx];
    gl_Position = projViewMatrix * modelMatrix * initPos;
}

の変更ShadowRenderも、SceneRenderクラスの変更と非常によく似ています。

public class ShadowRender {

    private static final int COMMAND_SIZE = 5 * 4;
    ...
    private Map<String, Integer> entitiesIdxMap;
    ...
    private int staticRenderBufferHandle;
    ...
    public ShadowRender() {
        ...
        entitiesIdxMap = new HashMap<>();
    }

    public void cleanup() {
        shaderProgram.cleanup();
        shadowBuffer.cleanup();
        glDeleteBuffers(staticRenderBufferHandle);
    }

    private void createUniforms() {
        ...
        for (int i = 0; i < SceneRender.MAX_DRAW_ELEMENTS; i++) {
            String name = "drawElements[" + i + "]";
            uniformsMap.createUniform(name + ".modelMatrixIdx");
        }

        for (int i = 0; i < SceneRender.MAX_ENTITIES; i++) {
            uniformsMap.createUniform("modelMatrices[" + i + "]");
        }
    }
    ...
}

新しいユニフォームを使用するには、createUniformsメソッドを更新する必要がありcleanup、間接描画バッファーを解放する必要があります。renderメソッドは、メッシュとエンティティに対して個別の描画コマンドを送信する代わりに、 を使用するようになりましたglMultiDrawElementsIndirect。

public class ShadowRender {
    ...
    public void render(Scene scene, RenderBuffers renderBuffers) {
        CascadeShadow.updateCascadeShadows(cascadeShadows, scene);

        glBindFramebuffer(GL_FRAMEBUFFER, shadowBuffer.getDepthMapFBO());
        glViewport(0, 0, ShadowBuffer.SHADOW_MAP_WIDTH, ShadowBuffer.SHADOW_MAP_HEIGHT);

        shaderProgram.bind();

        int entityIdx = 0;
        for (Model model : scene.getModelMap().values()) {
            List<Entity> entities = model.getEntitiesList();
            for (Entity entity : entities) {
                uniformsMap.setUniform("modelMatrices[" + entityIdx + "]", entity.getModelMatrix());
                entityIdx++;
            }
        }

        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowBuffer.getDepthMapTexture().getIds()[i], 0);
            glClear(GL_DEPTH_BUFFER_BIT);
        }

        // Static meshes
        int drawElement = 0;
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> !m.isAnimated()).toList();
        for (Model model : modelList) {
            List<Entity> entities = model.getEntitiesList();
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                for (Entity entity : entities) {
                    String name = "drawElements[" + drawElement + "]";
                    uniformsMap.setUniform(name + ".modelMatrixIdx", entitiesIdxMap.get(entity.getId()));
                    drawElement++;
                }
            }
        }
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, staticRenderBufferHandle);
        glBindVertexArray(renderBuffers.getStaticVaoId());
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowBuffer.getDepthMapTexture().getIds()[i], 0);

            CascadeShadow shadowCascade = cascadeShadows.get(i);
            uniformsMap.setUniform("projViewMatrix", shadowCascade.getProjViewMatrix());

            glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, staticDrawCount, 0);
        }
        glBindVertexArray(0);

        shaderProgram.unbind();
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }
    ...
}

最後に、間接描画バッファとエンティティ マップをセットアップする同様のメソッドが必要です。

public class ShadowRender {
    ...
    public void setupData(Scene scene) {
        setupEntitiesData(scene);
        setupStaticCommandBuffer(scene);
    }

    private void setupEntitiesData(Scene scene) {
        entitiesIdxMap.clear();
        int entityIdx = 0;
        for (Model model : scene.getModelMap().values()) {
            List<Entity> entities = model.getEntitiesList();
            for (Entity entity : entities) {
                entitiesIdxMap.put(entity.getId(), entityIdx);
                entityIdx++;
            }
        }
    }

    private void setupStaticCommandBuffer(Scene scene) {
        List<Model> modelList = scene.getModelMap().values().stream().filter(m -> !m.isAnimated()).toList();
        Map<String, Integer> entitiesIdxMap = new HashMap<>();
        int entityIdx = 0;
        int numMeshes = 0;
        for (Model model : scene.getModelMap().values()) {
            List<Entity> entities = model.getEntitiesList();
            numMeshes += model.getMeshDrawDataList().size();
            for (Entity entity : entities) {
                entitiesIdxMap.put(entity.getId(), entityIdx);
                entityIdx++;
            }
        }

        int firstIndex = 0;
        int baseInstance = 0;
        int drawElement = 0;
        shaderProgram.bind();
        ByteBuffer commandBuffer = MemoryUtil.memAlloc(numMeshes * COMMAND_SIZE);
        for (Model model : modelList) {
            List<Entity> entities = model.getEntitiesList();
            int numEntities = entities.size();
            for (RenderBuffers.MeshDrawData meshDrawData : model.getMeshDrawDataList()) {
                // count
                commandBuffer.putInt(meshDrawData.vertices());
                // instanceCount
                commandBuffer.putInt(numEntities);
                commandBuffer.putInt(firstIndex);
                // baseVertex
                commandBuffer.putInt(meshDrawData.offset());
                commandBuffer.putInt(baseInstance);

                firstIndex += meshDrawData.vertices();
                baseInstance += entities.size();
                for (Entity entity : entities) {
                    String name = "drawElements[" + drawElement + "]";
                    uniformsMap.setUniform(name + ".modelMatrixIdx", entitiesIdxMap.get(entity.getId()));
                    drawElement++;
                }
            }
        }
        commandBuffer.flip();
        shaderProgram.unbind();

        staticDrawCount = commandBuffer.remaining() / COMMAND_SIZE;

        staticRenderBufferHandle = glGenBuffers();
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, staticRenderBufferHandle);
        glBufferData(GL_DRAW_INDIRECT_BUFFER, commandBuffer, GL_DYNAMIC_DRAW);

        MemoryUtil.memFree(commandBuffer);
    }
}

クラスでは、Renderクラスをインスタンス化し、間接描画バッファと関連データを作成するためにすべてのモデルとエンティティが作成されたときに呼び出すことができるRenderBuffers新しいメソッドを提供するだけです。setupData

public class Render {
    ...
    private RenderBuffers renderBuffers;
    ...
    public Render(Window window) {
        ...
        renderBuffers = new RenderBuffers();
    }

    public void cleanup() {
        ...
        renderBuffers.cleanup();
    }
    ...
    public void render(Window window, Scene scene) {
        shadowRender.render(scene, renderBuffers);
        sceneRender.render(scene, renderBuffers, gBuffer);
        ...
    }
    ...
    public void setupData(Scene scene) {
        renderBuffers.loadStaticModels(scene);
        renderBuffers.loadAnimatedModels(scene);
        sceneRender.setupData(scene);
        shadowRender.setupData(scene);
        List<Model> modelList = new ArrayList<>(scene.getModelMap().values());
        modelList.forEach(m -> m.getMeshDataList().clear());
    }
}

クラスを更新して、TextureCacheすべてのテクスチャを返すメソッドを提供する必要があります。

public class TextureCache {
    ...
    public Collection<Texture> getAll() {
        return textureMap.values();
    }
    ...
}

モデルとマテリアルを扱うクラス階層を変更したため、クラスを更新する必要がありますSkyBox(個々のモデルをロードするには、追加の手順が必要になります)。

public class SkyBox {

    private Material material;
    private Mesh mesh;
    ...
    public SkyBox(String skyBoxModelPath, TextureCache textureCache, MaterialCache materialCache) {
        skyBoxModel = ModelLoader.loadModel("skybox-model", skyBoxModelPath, textureCache, materialCache, false);
        MeshData meshData = skyBoxModel.getMeshDataList().get(0);
        material = materialCache.getMaterial(meshData.getMaterialIdx());
        mesh = new Mesh(meshData);
        skyBoxModel.getMeshDataList().clear();
        skyBoxEntity = new Entity("skyBoxEntity-entity", skyBoxModel.getId());
    }

    public void cleanuo() {
        mesh.cleanup();
    }

    public Material getMaterial() {
        return material;
    }

    public Mesh getMesh() {
        return mesh;
    }
    ...
}

これらの変更はクラスにも影響しSkyBoxRenderます。sky bos render では、間接描画は使用しません (メッシュを 1 つだけレンダリングするため、使用する価値はありません)。

public class SkyBoxRender {
    ...
    public void render(Scene scene) {
        SkyBox skyBox = scene.getSkyBox();
        if (skyBox == null) {
            return;
        }
        shaderProgram.bind();

        uniformsMap.setUniform("projectionMatrix", scene.getProjection().getProjMatrix());
        viewMatrix.set(scene.getCamera().getViewMatrix());
        viewMatrix.m30(0);
        viewMatrix.m31(0);
        viewMatrix.m32(0);
        uniformsMap.setUniform("viewMatrix", viewMatrix);
        uniformsMap.setUniform("txtSampler", 0);

        Entity skyBoxEntity = skyBox.getSkyBoxEntity();
        TextureCache textureCache = scene.getTextureCache();
        Material material = skyBox.getMaterial();
        Mesh mesh = skyBox.getMesh();
        Texture texture = textureCache.getTexture(material.getTexturePath());
        glActiveTexture(GL_TEXTURE0);
        texture.bind();

        uniformsMap.setUniform("diffuse", material.getDiffuseColor());
        uniformsMap.setUniform("hasTexture", texture.getTexturePath().equals(TextureCache.DEFAULT_TEXTURE) ? 0 : 1);

        glBindVertexArray(mesh.getVaoId());

        uniformsMap.setUniform("modelMatrix", skyBoxEntity.getModelMatrix());
        glDrawElements(GL_TRIANGLES, mesh.getNumVertices(), GL_UNSIGNED_INT, 0);

        glBindVertexArray(0);

        shaderProgram.unbind();
    }
    ...
}

クラスではScene、メソッドを呼び出す必要はありませんScene cleanup(バッファに関連付けられたデータがRenderBuffersクラスにあるため)。

public class Engine {
    ...
    private void cleanup() {
        appLogic.cleanup();
        render.cleanup();
        window.cleanup();
    }
    ...
}

最後に、Mainクラスで、キューブ モデルに関連付けられた 2 つのエンティティを読み込みます。それらを個別にローテーションして、コードが正常に機能することを確認します。最も重要な部分は、すべてがロードされたときにRenderクラスメソッドを呼び出すことです。setupData

public class Main implements IAppLogic {
    ...
    private Entity cubeEntity1;
    private Entity cubeEntity2;
    ...
    private float rotation;

    public static void main(String[] args) {
        ...
        Engine gameEng = new Engine("chapter-20", opts, main);
        ...
    }

    public void init(Window window, Scene scene, Render render) {
        ...
        Model terrainModel = ModelLoader.loadModel(terrainModelId, "resources/models/terrain/terrain.obj",
                scene.getTextureCache(), scene.getMaterialCache(), false);
        ...
        Model cubeModel = ModelLoader.loadModel("cube-model", "resources/models/cube/cube.obj",
                scene.getTextureCache(), scene.getMaterialCache(), false);
        scene.addModel(cubeModel);
        cubeEntity1 = new Entity("cube-entity-1", cubeModel.getId());
        cubeEntity1.setPosition(0, 2, -1);
        cubeEntity1.updateModelMatrix();
        scene.addEntity(cubeEntity1);

        cubeEntity2 = new Entity("cube-entity-2", cubeModel.getId());
        cubeEntity2.setPosition(-2, 2, -1);
        cubeEntity2.updateModelMatrix();
        scene.addEntity(cubeEntity2);

        render.setupData(scene);
        ...
        SkyBox skyBox = new SkyBox("resources/models/skybox/skybox.obj", scene.getTextureCache(),
                scene.getMaterialCache());
        ...
    }
    ...
    public void update(Window window, Scene scene, long diffTimeMillis) {
        rotation += 1.5;
        if (rotation > 360) {
            rotation = 0;
        }
        cubeEntity1.setRotation(1, 1, 1, (float) Math.toRadians(rotation));
        cubeEntity1.updateModelMatrix();

        cubeEntity2.setRotation(1, 1, 1, (float) Math.toRadians(360 - rotation));
        cubeEntity2.updateModelMatrix();
    }
}

すべての変更を実装すると、これに似たものが表示されるはずです。

第17章 影

現在、光が 3D シーン内のオブジェクトにどのように影響するかを表すことができます。より多くの光を受け取るオブジェクトは、光を受けないオブジェクトよりも明るく表示されます。ただし、まだ影を落とすことはできません。影は、3D シーンのリアリズムの度合いを高めます。これが、この章で行うことです。

• ドキュメント
• ソース

シャドウ マッピング

ゲームで広く使用されており、エンジンのパフォーマンスに深刻な影響を与えないシャドウ マッピングという手法を使用します。シャドウ マッピングは簡単に理解できるように見えるかもしれませんが、正しく実装するのはやや困難です。または、より正確に言えば、すべての潜在的なケースをカバーし、一貫した結果を生成する一般的な方法で実装することは非常に困難です。

それでは、特定の領域 (実際にはフラグメント) が影にあるかどうかを確認する方法を考えることから始めましょう。その領域を描画しているときに、光線を光源に投射し、衝突せずに光源に到達できる場合、そのピクセルは光の中にあります。そうでない場合、ピクセルは影になっています。

次の図は、ポイント ライトの場合を示しています。ポイント PA はソース ライトに到達できますが、ポイント PB と PC は到達できないため、影になっています。

そのレイを衝突なしでキャストできるかどうかを効率的に確認するにはどうすればよいでしょうか? 光源は理論的に無限の光線を放つことができますが、光線がブロックされているかどうかを確認するにはどうすればよいでしょうか? レイ ライトをキャストする代わりにできることは、ライトの視点から 3D シーンを見て、その場所からシーンをレンダリングすることです。カメラをライトの位置に設定してシーンをレンダリングし、各フラグメントの深度を保存できるようにします。これは、光源までの各フラグメントの距離を計算することと同じです。最後に、光源から見た最小距離をシャドウ マップとして保存します。

次の図は、平面上に浮かんでいる立方体と垂直なライトを示しています。

光の視点から見たシーンは、このようなものになります (色が濃いほど、光源に近くなります)。

その情報を使用して、通常どおり 3D シーンをレンダリングし、保存されている最小距離で光源までの各フラグメントの距離を確認できます。距離がシャドウ マップに格納されている値よりも小さい場合、オブジェクトは明るくなり、それ以外の場合は影になります。同じレイ ライトが当たる可能性のあるオブジェクトを複数持つことができますが、最小距離を保存します。

したがって、シャドウ マッピングは 2 段階のプロセスです。

・最初に、シーンをライト スペースからシャドウ マップにレンダリングして、最小距離を取得します。
・次に、カメラの視点からシーンをレンダリングし、その深度マップを使用して、オブジェクトが影にあるかどうかを計算します。
深度マップをレンダリングするには、深度バッファについて説明する必要があります。シーンをレンダリングすると、すべての深度情報は、明らかに深度バッファ (または z バッファ) という名前のバッファに格納されます。その深度情報は、
レンダリングされる各フラグメントの値。最初の章で、シーンのレンダリング中に行っていたことを思い出すと、ワールド座標からスクリーン座標に変換されます。範囲の座標空間に描画しています0に1にとってxとy軸。オブジェクトが別のオブジェクトよりも離れている場合、これがオブジェクトにどのように影響するかを計算する必要がありますzとy透視投影行列による座標。によっては自動計算されません。z
価値はありますが、当社で行う必要があります。実際に z 座標に格納されるのは、そのフラグメントの深さであり、それ以下でもそれ以上でもありません。

カスケード シャドウ マップ

上記の解決策は、そのままでは、オープン スペースの質の高い結果を生み出しません。その理由は、影の解像度がテクスチャ サイズによって制限されるためです。現在、潜在的に巨大な領域をカバーしており、深度情報を保存するために使用しているテクスチャは、良い結果を得るには十分な解像度がありません。テクスチャの解像度を上げるだけで解決できると思われるかもしれませんが、これだけでは問題を完全に解決するには不十分です。そのためには、巨大なテクスチャが必要になります。したがって、基本を説明したら、単純なシャドウ マップを改良したカスケード シャドウ マップ (CSM) と呼ばれる手法について説明します。

重要な概念は、カメラに近いオブジェクトの影は、遠くのオブジェクトの影よりも高品質である必要があるということです。1 つの方法として、カメラの近くにあるオブジェクトの影をレンダリングすることもできますが、これではシーン内を移動している限り、影が現れたり消えたりします。

カスケード シャドウ マップ (CSM) が使用するアプローチは、視錐台をいくつかの分割に分割することです。カメラに近い分割はより少ない空間をカバーしますが、遠い領域はより広い領域をカバーします。次の図は、3 つの分割に分割された視錐台を示しています。

これらの分割ごとに深度マップがレンダリングされ、各分割に適合するようにライト ビューと投影マトリックスが調整されます。したがって、深度マップを格納するテクスチャは、視錐台の縮小された領域をカバーします。また、カメラに最も近いスプリットがカバーするスペースが少ないため、深度解像度が向上します。

上記の説明から推測できるように、分割と同じ数の深度テクスチャが必要になり、それぞれのライト ビューと投影マトリックスも変更します。したがって、CSM を適用するために実行する手順は次のとおりです。

• 視錐台を n 個の分割に分割します。
• 深度マップのレンダリング中、分割ごとに:
• • ライト ビューと投影行列を計算します。
• • シーンをライトの視点から別の深度マップにレンダリングします
• シーンのレンダリング中:
• • 上記で計算された深度マップを使用します。
• • 描画するフラグメントが属する分割を決定します。
• • シャドウ マップと同様にシャドウ ファクターを計算します。

のとおり、CSM の主な欠点は、分割ごとにライトの視点からシーンをレンダリングする必要があることです。これが、オープン スペースにのみ使用されることが多い理由です (もちろん、キャッシュをシャドウ計算に適用してオーバーヘッドを削減できます)。

実装

最初に作成するクラスは、ライト パースペクティブからシャドウ マップをレンダリングするために必要なマトリックスを計算します。このクラスには名前が付けられCascadeShadow、特定のカスケード シャドウ スプリット (projViewMatrixアトリビュート) の投影ビュー マトリックス (ライト パースペクティブから) と、その正射影マトリックスのファー プレーン距離(アトリビュート) が格納されsplitDistanceます。

public class CascadeShadow {

    public static final int SHADOW_MAP_CASCADE_COUNT = 3;

    private Matrix4f projViewMatrix;
    private float splitDistance;

    public CascadeShadow() {
        projViewMatrix = new Matrix4f();
    }
    ...
    public Matrix4f getProjViewMatrix() {
        return projViewMatrix;
    }

    public float getSplitDistance() {
        return splitDistance;
    }
    ...
}

このCascadeShadowクラスは、カスケード シャドウ インスタンスのリストを という名前の適切な値で初期化する静的メソッドを定義しますupdateCascadeShadows。このメソッドは次のように始まります。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        Matrix4f viewMatrix = scene.getCamera().getViewMatrix();
        Matrix4f projMatrix = scene.getProjection().getProjMatrix();
        Vector4f lightPos = new Vector4f(scene.getSceneLights().getDirLight().getDirection(), 0);

        float cascadeSplitLambda = 0.95f;

        float[] cascadeSplits = new float[SHADOW_MAP_CASCADE_COUNT];

        float nearClip = projMatrix.perspectiveNear();
        float farClip = projMatrix.perspectiveFar();
        float clipRange = farClip - nearClip;

        float minZ = nearClip;
        float maxZ = nearClip + clipRange;

        float range = maxZ - minZ;
        float ratio = maxZ / minZ;
        ...
    }
    ...
}

まず、シーンのレンダリングに使用する透視投影の分割データ、ビューと投影の行列、ライトの位置、近距離と遠距離のクリップを計算するために必要な行列を取得します。その情報を使用して、各シャドウ カスケードの分割距離を計算できます。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        ...
        // Calculate split depths based on view camera frustum
        // Based on method presented in https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch10.html
        for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
            float p = (i + 1) / (float) (SHADOW_MAP_CASCADE_COUNT);
            float log = (float) (minZ * java.lang.Math.pow(ratio, p));
            float uniform = minZ + range * p;
            float d = cascadeSplitLambda * (log - uniform) + uniform;
            cascadeSplits[i] = (d - nearClip) / clipRange;
        }
        ...
    }
    ...
}

分割位置の計算に使用されるアルゴリズムは、対数スキーマを使用して距離をより適切に分散します。カスケードを均等に分割する、または事前に設定された比率に従って分割するなど、他のさまざまなアプローチを使用することもできます。対数スキーマの利点は、近くのビューの分割に使用するスペースが少なく、カメラに近い要素の解像度が高くなることです。数学の詳細については、NVIDIA の記事を参照してください。配列には [0, 1] の範囲の値のセットが含まれます。cascadeSplitsこれを後で使用して、必要な計算を実行し、各カスケードの分割距離と射影行列を取得します。

カスケード分割のすべてのデータを計算するループを定義します。そのループでは、最初に NDC (Normalized Device Coordinates) 空間に錐台コーナーを作成します。その後、ビュー マトリックスとパースペクティブ マトリックスの逆数を使用して、これらの座標をワールド空間に投影します。ディレクショナル ライトを使用しているため、シャドウ マップのレンダリングには正投影行列を使用します。これが、NDC 座標として、可視ボリュームを含む立方体の境界のみを設定する理由です (遠くのオブジェクトはレンダリングされません)。透視投影のように小さくなります)。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        ...
        // Calculate orthographic projection matrix for each cascade
        float lastSplitDist = 0.0f;
        for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
            float splitDist = cascadeSplits[i];

            Vector3f[] frustumCorners = new Vector3f[]{
                    new Vector3f(-1.0f, 1.0f, -1.0f),
                    new Vector3f(1.0f, 1.0f, -1.0f),
                    new Vector3f(1.0f, -1.0f, -1.0f),
                    new Vector3f(-1.0f, -1.0f, -1.0f),
                    new Vector3f(-1.0f, 1.0f, 1.0f),
                    new Vector3f(1.0f, 1.0f, 1.0f),
                    new Vector3f(1.0f, -1.0f, 1.0f),
                    new Vector3f(-1.0f, -1.0f, 1.0f),
            };

            // Project frustum corners into world space
            Matrix4f invCam = (new Matrix4f(projMatrix).mul(viewMatrix)).invert();
            for (int j = 0; j < 8; j++) {
                Vector4f invCorner = new Vector4f(frustumCorners[j], 1.0f).mul(invCam);
                frustumCorners[j] = new Vector3f(invCorner.x / invCorner.w, invCorner.y / invCorner.w, invCorner.z / invCorner.w);
            }
            ...
        }
        ...
    }
    ...
}

この時点で、frustumCorners変数は可視空間を含む立方体の座標を持っていますが、この特定のカスケード分割にはワールド座標が必要です。したがって、次のステップは、それらの方法の最初に計算されたカスケード距離を機能させることです。事前に計算された距離に従って、この特定の分割の近平面と遠平面の座標を調整します。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        ...
        for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
            ...
            for (int j = 0; j < 4; j++) {
                Vector3f dist = new Vector3f(frustumCorners[j + 4]).sub(frustumCorners[j]);
                frustumCorners[j + 4] = new Vector3f(frustumCorners[j]).add(new Vector3f(dist).mul(splitDist));
                frustumCorners[j] = new Vector3f(frustumCorners[j]).add(new Vector3f(dist).mul(lastSplitDist));
            }
            ...
        }
        ...
    }
    ...
}

その後、その分割の中心の座標 (引き続きワールド座標で機能します) と、その分割の半径を計算します。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        ...
        for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
            ...
            // Get frustum center
            Vector3f frustumCenter = new Vector3f(0.0f);
            for (int j = 0; j < 8; j++) {
                frustumCenter.add(frustumCorners[j]);
            }
            frustumCenter.div(8.0f);

            float radius = 0.0f;
            for (int j = 0; j < 8; j++) {
                float distance = (new Vector3f(frustumCorners[j]).sub(frustumCenter)).length();
                radius = java.lang.Math.max(radius, distance);
            }
            radius = (float) java.lang.Math.ceil(radius * 16.0f) / 16.0f;
            ...
        }
        ...
    }
    ...
}

その情報を使用して、ライトの視点と正射投影マトリックス、および分割距離 (カメラ ビュー座標) からビュー マトリックスを計算できるようになりました。

public class CascadeShadow {
    ...
    public static void updateCascadeShadows(List<CascadeShadow> cascadeShadows, Scene scene) {
        ...
        for (int i = 0; i < SHADOW_MAP_CASCADE_COUNT; i++) {
            ...
            Vector3f maxExtents = new Vector3f(radius);
            Vector3f minExtents = new Vector3f(maxExtents).mul(-1);

            Vector3f lightDir = (new Vector3f(lightPos.x, lightPos.y, lightPos.z).mul(-1)).normalize();
            Vector3f eye = new Vector3f(frustumCenter).sub(new Vector3f(lightDir).mul(-minExtents.z));
            Vector3f up = new Vector3f(0.0f, 1.0f, 0.0f);
            Matrix4f lightViewMatrix = new Matrix4f().lookAt(eye, frustumCenter, up);
            Matrix4f lightOrthoMatrix = new Matrix4f().ortho
                    (minExtents.x, maxExtents.x, minExtents.y, maxExtents.y, 0.0f, maxExtents.z - minExtents.z, true);

            // Store split distance and matrix in cascade
            CascadeShadow cascadeShadow = cascadeShadows.get(i);
            cascadeShadow.splitDistance = (nearClip + splitDist * clipRange) * -1.0f;
            cascadeShadow.projViewMatrix = lightOrthoMatrix.mul(lightViewMatrix);

            lastSplitDist = cascadeSplits[i];
        }
        ...
    }
    ...
}

これで、シャドウ マップのレンダリングに必要な行列を計算するコードが完成しました。したがって、そのレンダリングを実行するために必要なクラスのコーディングを開始できます。この場合、別の画像 (深度画像) にレンダリングします。カスケード マップの分割ごとに 1 つのテクスチャが必要です。それを管理するために、一連のテクスチャを作成するという名前の新しいクラスArrTextureを作成します。これは次のように定義されます。

package org.lwjglb.engine.graph;

import java.nio.ByteBuffer;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL12.GL_CLAMP_TO_EDGE;
import static org.lwjgl.opengl.GL14.GL_TEXTURE_COMPARE_MODE;

public class ArrTexture {

    private final int[] ids;

    public ArrTexture(int numTextures, int width, int height, int pixelFormat) {
        ids = new int[numTextures];
        glGenTextures(ids);

        for (int i = 0; i < numTextures; i++) {
            glBindTexture(GL_TEXTURE_2D, ids[i]);
            glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, pixelFormat, GL_FLOAT, (ByteBuffer) null);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        }
    }

    public void cleanup() {
        for (int id : ids) {
            glDeleteTextures(id);
        }
    }

    public int[] getIds() {
        return ids;
    }
}

GL_CLAMP_TO_EDGEを超えた場合にテクスチャを繰り返さないため、テクスチャ ラッピング モードを に設定します。[0, 1]範囲
空のテクスチャを作成できるようになったので、それにシーンをレンダリングできるようにする必要があります。そのためには、フレーム バッファ オブジェクト (または FBO) を使用する必要があります。フレーム バッファは、レンダリングの宛先として使用できるバッファのコレクションです。画面にレンダリングしているときは、OpenGL のデフォルト バッファを使用しています。OpenGL では、FBO を使用してユーザー定義のバッファーにレンダリングできます。という名前の新しいクラスを作成することにより、シャドウ マッピング用の FBO を作成するプロセスの残りのコードを分離しますShadowBuffer。これがそのクラスの定義です。

package org.lwjglb.engine.graph;

import static org.lwjgl.opengl.GL11.*;
import static org.lwjgl.opengl.GL13.glActiveTexture;
import static org.lwjgl.opengl.GL30.*;

public class ShadowBuffer {

    public static final int SHADOW_MAP_WIDTH = 4096;

    public static final int SHADOW_MAP_HEIGHT = SHADOW_MAP_WIDTH;
    private final ArrTexture depthMap;
    private final int depthMapFBO;

    public ShadowBuffer() {
        // Create a FBO to render the depth map
        depthMapFBO = glGenFramebuffers();

        // Create the depth map textures
        depthMap = new ArrTexture(CascadeShadow.SHADOW_MAP_CASCADE_COUNT, SHADOW_MAP_WIDTH, SHADOW_MAP_HEIGHT, GL_DEPTH_COMPONENT);

        // Attach the the depth map texture to the FBO
        glBindFramebuffer(GL_FRAMEBUFFER, depthMapFBO);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthMap.getIds()[0], 0);

        // Set only depth
        glDrawBuffer(GL_NONE);
        glReadBuffer(GL_NONE);

        if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
            throw new RuntimeException("Could not create FrameBuffer");
        }

        // Unbind
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }

    public void bindTextures(int start) {
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            glActiveTexture(start + i);
            glBindTexture(GL_TEXTURE_2D, depthMap.getIds()[i]);
        }
    }

    public void cleanup() {
        glDeleteFramebuffers(depthMapFBO);
        depthMap.cleanup();
    }

    public int getDepthMapFBO() {
        return depthMapFBO;
    }

    public ArrTexture getDepthMapTexture() {
        return depthMap;
    }
}

このShadowBufferクラスは、深度マップを保持するテクスチャのサイズを決定する 2 つの定数を定義します。また、FBO 用とテクスチャ用の 2 つの属性も定義します。コンストラクターで、新しい FBO とテクスチャーの配列を作成します。その配列の各要素は、各カスケード シャドウ スプリットのシャドウ マップをレンダリングするために使用されます。FBO では、GL_DEPTH_COMPONENT深度値の保存のみに関心があるため、ピクセル形式として定数を使用します。次に、FBO をテクスチャ インスタンスにアタッチします。

行は、FBO が色をレンダリングしないように明示的に設定します。FBO にはカラー バッファが必要ですが、必要ありません。これが、カラー バッファを として使用するように設定した理由GL_NONEです。

で、シャドウ マップをレンダリングするために、以前のすべてのクラスを機能させることができます。ShadowRender次のように始まる名前の新しいクラスでこれを行います。

package org.lwjglb.engine.graph;

import org.lwjglb.engine.scene.*;

import java.util.*;

import static org.lwjgl.opengl.GL30.*;

public class ShadowRender {
    private ArrayList<CascadeShadow> cascadeShadows;
    private ShaderProgram shaderProgram;
    private ShadowBuffer shadowBuffer;
    private UniformsMap uniformsMap;

    public ShadowRender() {
        List<ShaderProgram.ShaderModuleData> shaderModuleDataList = new ArrayList<>();
        shaderModuleDataList.add(new ShaderProgram.ShaderModuleData("resources/shaders/shadow.vert", GL_VERTEX_SHADER));
        shaderProgram = new ShaderProgram(shaderModuleDataList);

        shadowBuffer = new ShadowBuffer();

        cascadeShadows = new ArrayList<>();
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            CascadeShadow cascadeShadow = new CascadeShadow();
            cascadeShadows.add(cascadeShadow);
        }

        createUniforms();
    }

    public void cleanup() {
        shaderProgram.cleanup();
        shadowBuffer.cleanup();
    }

    private void createUniforms() {
        uniformsMap = new UniformsMap(shaderProgram.getProgramId());
        uniformsMap.createUniform("modelMatrix");
        uniformsMap.createUniform("projViewMatrix");
        uniformsMap.createUniform("bonesMatrices");
    }

    public List<CascadeShadow> getCascadeShadows() {
        return cascadeShadows;
    }

    public ShadowBuffer getShadowBuffer() {
        return shadowBuffer;
    }
    ...
}

ご覧のとおり、他のレンダリング クラスと非常によく似ています。シェーダー プログラム、必要なユニフォームを作成し、cleanupメソッドを提供します。唯一の例外は次のとおりです。

• 深さの値に関心があるだけなので、フラグメントシェーダーはまったく必要ありません。頂点シェーダーからの深さを含む頂点位置をダンプするだけです-
• CascadeShadowカスケード シャドウ スプリット (クラス インスタンスのインスタンスによってモデル化) を作成します。それに加えて、カスケード シャドウ マップとシャドウ マップをレンダリングするバッファを取得するためのゲッターをいくつか提供します。これらのゲッターは、SceneRenderシャドウ マップ データにアクセスするためにクラスで使用されます。
  クラスのrenderメソッドShadowRenderは次のように定義されます。

public class ShadowRender {
    ...
    public void render(Scene scene) {
        CascadeShadow.updateCascadeShadows(cascadeShadows, scene);

        glBindFramebuffer(GL_FRAMEBUFFER, shadowBuffer.getDepthMapFBO());
        glViewport(0, 0, ShadowBuffer.SHADOW_MAP_WIDTH, ShadowBuffer.SHADOW_MAP_HEIGHT);

        shaderProgram.bind();

        Collection<Model> models = scene.getModelMap().values();
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, shadowBuffer.getDepthMapTexture().getIds()[i], 0);
            glClear(GL_DEPTH_BUFFER_BIT);

            CascadeShadow shadowCascade = cascadeShadows.get(i);
            uniformsMap.setUniform("projViewMatrix", shadowCascade.getProjViewMatrix());

            for (Model model : models) {
                List<Entity> entities = model.getEntitiesList();
                for (Material material : model.getMaterialList()) {
                    for (Mesh mesh : material.getMeshList()) {
                        glBindVertexArray(mesh.getVaoId());
                        for (Entity entity : entities) {
                            uniformsMap.setUniform("modelMatrix", entity.getModelMatrix());
                            AnimationData animationData = entity.getAnimationData();
                            if (animationData == null) {
                                uniformsMap.setUniform("bonesMatrices", AnimationData.DEFAULT_BONES_MATRICES);
                            } else {
                                uniformsMap.setUniform("bonesMatrices", animationData.getCurrentFrame().boneMatrices());
                            }
                            glDrawElements(GL_TRIANGLES, mesh.getNumVertices(), GL_UNSIGNED_INT, 0);
                        }
                    }
                }
            }
        }

        shaderProgram.unbind();
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }
}

最初に行うことは、カスケード マップを更新することです。これは、カスケード マップを更新することです。これは、シャドウ マップをレンダリングできるように、各カスケード スプリットの射影行列です (シーンを更新したり、カメラを移動したり、プレーヤーやアニメーションを変更したりできます)。これは、キャッシュして、シーンが変更された場合に再計算したい場合があります。簡単にするために、フレームごとに行います。その後、glBindFramebuffer関数を呼び出してシャドウ マップをレンダリングするフレーム バッファーをバインドします。それをクリアし、さまざまなカスケード シャドウ スプリットを反復処理します。

分割ごとに、次のアクションを実行します。

• を呼び出してカスケード シャドウ スプリットに関連付けられたテクスチャをバインドし、glFramebufferTexture2Dそれをクリアします。
• 現在のカスケード シャドウ スプリットに従って射影行列を更新します。
• クラスで行っていたように、各エンティティをレンダリングしますSceneRender。
  shadow.vert次のように定義された新しい頂点シェーダー ( ) が必要です。

#version 330

const int MAX_WEIGHTS = 4;
const int MAX_BONES = 150;

layout (location=0) in vec3 position;
layout (location=1) in vec3 normal;
layout (location=2) in vec3 tangent;
layout (location=3) in vec3 bitangent;
layout (location=4) in vec2 texCoord;
layout (location=5) in vec4 boneWeights;
layout (location=6) in ivec4 boneIndices;

uniform mat4 modelMatrix;
uniform mat4 projViewMatrix;
uniform mat4 bonesMatrices[MAX_BONES];

void main()
{
    vec4 initPos = vec4(0, 0, 0, 0);
    int count = 0;
    for (int i = 0; i < MAX_WEIGHTS; i++) {
        float weight = boneWeights[i];
        if (weight > 0) {
            count++;
            int boneIndex = boneIndices[i];
            vec4 tmpPos = bonesMatrices[boneIndex] * vec4(position, 1.0);
            initPos += weight * tmpPos;
        }
    }
    if (count == 0) {
        initPos = vec4(position, 1.0);
    }

    gl_Position = projViewMatrix * modelMatrix * initPos;
}

設定できるように、シーンの頂点シェーダーと同じ入力属性のセットを受け取ります。位置を投影するだけで、モデル マトリックスとアニメーション データに従って以前に入力された位置を更新します。

SceneRender次に、レンダリング時にカスケード シャドウ マップを使用してシャドウを適切に表示するようにクラスを更新する必要があります。まず、フラグメント シェーダーでテクスチャとしてシャドウ マップにアクセスするため、それらのユニフォームを作成する必要があります。また、頂点の位置に応じてどの分割を使用するかを選択するために、カスケード分割の射影行列と分割距離を渡す必要があります。

public class SceneRender {
    ...
    private void createUniforms() {
        ...
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            uniformsMap.createUniform("shadowMap_" + i);
            uniformsMap.createUniform("cascadeshadows[" + i + "]" + ".projViewMatrix");
            uniformsMap.createUniform("cascadeshadows[" + i + "]" + ".splitDistance");
        }
    }
    ...
}

クラスのrenderメソッドではSceneRender、モデルを調整する前にこれらのユニフォームを設定する必要があります。

public class SceneRender {
    ...
    public void render(Scene scene, ShadowRender shadowRender) {
        ...
        uniformsMap.setUniform("txtSampler", 0);
        uniformsMap.setUniform("normalSampler", 1);

        int start = 2;
        List<CascadeShadow> cascadeShadows = shadowRender.getCascadeShadows();
        for (int i = 0; i < CascadeShadow.SHADOW_MAP_CASCADE_COUNT; i++) {
            uniformsMap.setUniform("shadowMap_" + i, start + i);
            CascadeShadow cascadeShadow = cascadeShadows.get(i);
            uniformsMap.setUniform("cascadeshadows[" + i + "]" + ".projViewMatrix", cascadeShadow.getProjViewMatrix());
            uniformsMap.setUniform("cascadeshadows[" + i + "]" + ".splitDistance", cascadeShadow.getSplitDistance());
        }

        shadowRender.getShadowBuffer().bindTextures(GL_TEXTURE2);
        ...
    }
    ...
}

それでは、シーン シェーダーの変更を見てみましょう。頂点シェーダー ( scene.vert) では、モデル座標の頂点位置も fargemnet シェーダーに渡す必要があります (ビュー マトリックスの影響を受けません)。

#version 330
...
out vec3 outNormal;
out vec3 outTangent;
out vec3 outBitangent;
out vec2 outTextCoord;
out vec3 outViewPosition;
out vec4 outWorldPosition;
...
void main()
{
    ...
    outViewPosition  = mvPosition.xyz;
    outWorldPosition = modelMatrix * initPos;
    ...
}

ほとんどの変更はフラグメント シェーダーに適用されます ( scene.frag)。

#version 330
...
const int DEBUG_SHADOWS = 0;
...
const float BIAS = 0.0005;
const float SHADOW_FACTOR = 0.25;
...
in vec3 outViewPosition;
in vec4 outWorldPosition;

最初に一連の定数を定義します。

• DEBUG_SHADOWS: これは、割り当てられるカスケード スプリットを識別するためにフラグメントに色を適用するかどうかを制御します (これ1を有効にするには値が必要です)。
• SHADOW_FACTOR: 影にあるときにフラグメントに適用される塗りつぶしの暗化係数。
• BIAS: フラグメントが影の影響を受けているかどうかを推定するときに適用する深度バイアス。これは、シャドウ アクネなどのシャドウ アーティファクトを削減するために使用されます。TS シャドウ アクネは、奇妙なアーティファクトを生成する深度マップを格納するテクスチャの解像度が制限されているために生成されます。精度の問題を軽減するしきい値を設定することで、この問題を解決します。
  その後、カスケード スプリットとシャドウ マップのテクスチャを格納する新しいユニフォームを定義します。また、シェーダーに逆ビュー マトリックスを渡す必要があります。前の章では、射影行列の逆行列を使用して、ビュー座標でのフラグメントの位置を取得しました。この場合、一歩先に進み、ワールド座標でもフラグメントの位置を取得する必要があります。逆ビュー行列にビュー座標のフラグメントの位置を掛けると、ワールド座標が得られます。それに加えて、カスケード スプリットの射影ビュー マトリックスとそれらのスプリット距離が必要です。

...
struct CascadeShadow {
    mat4 projViewMatrix;
    float splitDistance;
};
...
uniform CascadeShadow cascadeshadows[NUM_CASCADES];
uniform sampler2D shadowMap_0;
uniform sampler2D shadowMap_1;
uniform sampler2D shadowMap_2;
...

という名前の新しい関数を作成します。この関数はcalcShadow、ワールド位置とカスケード分割インデックスを指定すると、最終的なフラグメント カラーに適用されるシャドウ ファクターを返します。フラグメントが影の影響を受けていない場合、結果は になり1、最終的な色には影響しません。

...
float calcShadow(vec4 worldPosition, int idx) {
    vec4 shadowMapPosition = cascadeshadows[idx].projViewMatrix * worldPosition;
    float shadow = 1.0;
    vec4 shadowCoord = (shadowMapPosition / shadowMapPosition.w) * 0.5 + 0.5;
    shadow = textureProj(shadowCoord, vec2(0, 0), idx);
    return shadow;
}
...

この関数は、正投影を使用して、特定のカスケード スプリットのために、ワールド座標空間からディレクショナル ライトの NDC 空間に変換します。つまり、ワールド空間に、指定されたカスケード スプリットの射影ビュー マトリックスを乗算します。その後、これらの座標をテクスチャ座標 (左上隅から [0, 1] の範囲) に変換する必要があります。その情報を使用textureProjして、使用する適切なシャドウ マップ テクスチャを選択する関数を使用し、結果の値に応じてシャドウ ファクターを適用します。

...
float textureProj(vec4 shadowCoord, vec2 offset, int idx) {
    float shadow = 1.0;

    if (shadowCoord.z > -1.0 && shadowCoord.z < 1.0) {
        float dist = 0.0;
        if (idx == 0) {
            dist = texture(shadowMap_0, vec2(shadowCoord.xy + offset)).r;
        } else if (idx == 1) {
            dist = texture(shadowMap_1, vec2(shadowCoord.xy + offset)).r;
        } else {
            dist = texture(shadowMap_2, vec2(shadowCoord.xy + offset)).r;
        }
        if (shadowCoord.w > 0 && dist < shadowCoord.z - BIAS) {
            shadow = SHADOW_FACTOR;
        }
    }
    return shadow;
}
...

このmain関数では、入力としてビュー位置を取り、カスケード分割ごとに計算された分割距離を反復処理して、このフラグメントが属するカスケード インデックスを決定し、シャドウ ファクターを計算します。

...
void main() {
    ...
    ...
    vec4 diffuseSpecularComp = calcDirLight(diffuse, specular, dirLight, outViewPosition, normal);

    int cascadeIndex;
    for (int i=0; i<NUM_CASCADES - 1; i++) {
        if (outViewPosition.z < cascadeshadows[i].splitDistance) {
            cascadeIndex = i + 1;
            break;
        }
    }
    float shadowFactor = calcShadow(outWorldPosition, cascadeIndex);

    for (int i=0; i<MAX_POINT_LIGHTS; i++) {
        if (pointLights[i].intensity > 0) {
            diffuseSpecularComp += calcPointLight(diffuse, specular, pointLights[i], outViewPosition, normal);
        }
    }

    for (int i=0; i<MAX_SPOT_LIGHTS; i++) {
        if (spotLights[i].pl.intensity > 0) {
            diffuseSpecularComp += calcSpotLight(diffuse, specular, spotLights[i], outViewPosition, normal);
        }
    }
    fragColor = ambient + diffuseSpecularComp;
    fragColor.rgb = fragColor.rgb * shadowFactor;

    if (fog.activeFog == 1) {
        fragColor = calcFog(outViewPosition, fragColor, fog, ambientLight.color, dirLight);
    }

    if (DEBUG_SHADOWS == 1) {
        switch (cascadeIndex) {
            case 0:
            fragColor.rgb *= vec3(1.0f, 0.25f, 0.25f);
            break;
            case 1:
            fragColor.rgb *= vec3(0.25f, 1.0f, 0.25f);
            break;
            case 2:
            fragColor.rgb *= vec3(0.25f, 0.25f, 1.0f);
            break;
            default :
            fragColor.rgb *= vec3(1.0f, 1.0f, 0.25f);
            break;
        }
    }
}

最終的なフラグメントの色は、シャドウ ファクターによって調整されます。最後に、デバッグ モードが有効になっている場合は、そのフラグメントに色を適用して、使用しているカスケードを識別します。

最後に、Renderクラスをインスタンス化して使用するようにクラスを更新する必要がありますShadowRender。また、ブレンディング アクティベーション コードをこのクラスに移動します。

public class Render {
    ...
    private ShadowRender shadowRender;
    ...
    public Render(Window window) {
        ...
        // Support for transparencies
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        ...
        shadowRender = new ShadowRender();
    }

    public void cleanup() {
        ...
        shadowRender.cleanup();
    }

    public void render(Window window, Scene scene) {
        shadowRender.render(scene);
        ...
        sceneRender.render(scene, shadowRender);
        ...
    }
    ...
}

クラスではMain、サウンド コードを削除するだけです。最後に、次のようなものが表示されます。

DEBUG_SHADOWS定数を に設定する1と、カスケード シャドウがどのように分割されるかがわかります

第16章 - オーディオ

これまではグラフィックスを扱ってきましたが、すべてのゲームのもう 1 つの重要な側面はオーディオです。この章では、サウンドのサポートを追加します。

• ドキュメント
• ソース

OpenAL

この章では、OpenAL (Open Audio Library) を使用してオーディオ機能について説明します。OpenAL はオーディオの OpenGL 版であり、抽象化レイヤーを介してサウンドを再生できます。そのレイヤーは、オーディオ サブシステムの根底にある複雑さから私たちを切り離します。それに加えて、3D シーンでサウンドを「レンダリング」することができます。サウンドを特定の場所に設定し、距離に応じて減衰させ、速度に応じて変更することができます (ドップラー効果のシミュレーション) 。

コーディングを開始する前に、OpenAL を扱う際に関係する主な要素を提示する必要があります。

バッファ。
ソース。
リスナー。
バッファには、音楽や効果音などのオーディオ データが格納されます。これらは、OpenGL ドメインのテクスチャに似ています。OpenAL は、オーディオ データが PCM (Pulse Coded Modulation) 形式 (モノラルまたはステレオ) であることを想定しているため、最初に PCM に変換せずに MP3 または OGG ファイルをダンプすることはできません。

次の要素はソースで、音を発する 3D 空間内の位置 (ポイント) を表します。ソースはバッファーに関連付けられ (一度に 1 つだけ)、次の属性で定義できます。

・位置、ソースの場所 ($$x$$、YとZ座標）。ちなみに、OpenAL は OpenGL と同様に右手デカルト座標系を使用するため、(単純化するために) ワールド座標はサウンド空間座標系の座標と同等であると想定できます。
・ソースの移動速度を指定する速度。これは、ドップラー効果をシミュレートするために使用されます。
・サウンドの強さを変更するために使用されるゲイン (アンプ係数のようなもの)。

ソースには、後でソース コードを説明するときに表示される追加の属性があります。

最後になりましたが、生成されたサウンドが聞こえるはずのリスナーです。Listener は、マイクが 3D オーディオ シーンでサウンドを受信するように設定されていることを表します。リスナーは 1 人だけです。そのため、オーディオのレンダリングはリスナーの視点から行われるとよく​​言われます。リスナーはいくつかの属性を共有しますが、向きなどの追加の属性があります。方向は、リスナーが向いている方向を表します。

つまり、オーディオ 3D シーンは、音を発する一連の音源と、それらを受信するリスナーによって構成されます。最終的に知覚される音は、リスナーからさまざまなソースまでの距離、それらの相対速度、および選択した伝播モデルによって異なります。ソースはバッファを共有し、同じデータを再生できます。次の図は、さまざまな要素タイプが含まれるサンプル 3D シーンを示しています。

実装

OpenAL を使用するには、最初に maven の依存関係をプロジェクト pom.xml に追加します。コンパイル時と実行時の依存関係を追加する必要があります。

...
<dependency>
   <groupId>org.lwjgl</groupId>
   <artifactId>lwjgl-openal</artifactId>
   <version>${lwjgl.version}</version>
</dependency>
...
<dependency>
   <groupId>org.lwjgl</groupId>
   <artifactId>lwjgl-openal</artifactId>
   <version>${lwjgl.version}</version>
   <classifier>${native.target}</classifier>
   <scope>runtime</scope>
</dependency>
...

それでは、コーディングを始めましょう。org.lwjglb.engine.soundオーディオの処理を担当するすべてのクラスをホストする名前で新しいパッケージを作成します。まずSoundBuffer、OpenAL バッファを表すという名前のクラスから始めます。そのクラスの定義の一部を以下に示します。

package org.lwjglb.engine.sound;

import org.lwjgl.stb.STBVorbisInfo;
import org.lwjgl.system.*;

import java.nio.*;

import static org.lwjgl.openal.AL10.*;
import static org.lwjgl.stb.STBVorbis.*;
import static org.lwjgl.system.MemoryUtil.NULL;

public class SoundBuffer {
    private final int bufferId;

    private ShortBuffer pcm;

    public SoundBuffer(String filePath) {
        this.bufferId = alGenBuffers();
        try (STBVorbisInfo info = STBVorbisInfo.malloc()) {
            pcm = readVorbis(filePath, info);

            // Copy to buffer
            alBufferData(bufferId, info.channels() == 1 ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16, pcm, info.sample_rate());
        }
    }

    public void cleanup() {
        alDeleteBuffers(this.bufferId);
        if (pcm != null) {
            MemoryUtil.memFree(pcm);
        }
    }

    public int getBufferId() {
        return this.bufferId;
    }

    private ShortBuffer readVorbis(String filePath, STBVorbisInfo info) {
        try (MemoryStack stack = MemoryStack.stackPush()) {
            IntBuffer error = stack.mallocInt(1);
            long decoder = stb_vorbis_open_filename(filePath, error, null);
            if (decoder == NULL) {
                throw new RuntimeException("Failed to open Ogg Vorbis file. Error: " + error.get(0));
            }

            stb_vorbis_get_info(decoder, info);

            int channels = info.channels();

            int lengthSamples = stb_vorbis_stream_length_in_samples(decoder);

            ShortBuffer result = MemoryUtil.memAllocShort(lengthSamples * channels);

            result.limit(stb_vorbis_get_samples_short_interleaved(decoder, channels, result) * channels);
            stb_vorbis_close(decoder);

            return result;
        }
    }
}

クラスのコンストラクターはサウンド ファイル パスを想定し、そこから新しいバッファーを作成します。最初に行うことは、 への呼び出しで OpenAL バッファを作成することalGenBuffersです。最後に、サウンド バッファは、それが保持するデータへのポインタのような整数によって識別されます。バッファーが作成されたら、その中にオーディオ データをダンプします。コンストラクターは OGG 形式のファイルを想定しているため、PCM 形式に変換する必要があります。これはreadVorbis メソッドで行われます。

以前のバージョンの LWJGL にはWaveData、WAV 形式のオーディオ ファイルをロードするために使用される という名前のヘルパー クラスがありました。このクラスは LWJGL 3 にはもう存在しません。それでも、そのクラスからソース コードを取得して、ゲームで使用することができます (おそらく変更は必要ありません)。

このSoundBufferクラスはcleanup、リソースを使い終わったときにリソースを解放するメソッドも提供します。

という名前のクラスによって実装される OpenAL のモデル化を続けましょうSoundSource。クラスは以下に定義されています。

package org.lwjglb.engine.sound;

import org.joml.Vector3f;

import static org.lwjgl.openal.AL10.*;

public class SoundSource {

    private final int sourceId;

    public SoundSource(boolean loop, boolean relative) {
        this.sourceId = alGenSources();
        alSourcei(sourceId, AL_LOOPING, loop ? AL_TRUE : AL_FALSE);
        alSourcei(sourceId, AL_SOURCE_RELATIVE, relative ? AL_TRUE : AL_FALSE);
    }

    public void cleanup() {
        stop();
        alDeleteSources(sourceId);
    }

    public boolean isPlaying() {
        return alGetSourcei(sourceId, AL_SOURCE_STATE) == AL_PLAYING;
    }

    public void pause() {
        alSourcePause(sourceId);
    }

    public void play() {
        alSourcePlay(sourceId);
    }

    public void setBuffer(int bufferId) {
        stop();
        alSourcei(sourceId, AL_BUFFER, bufferId);
    }

    public void setGain(float gain) {
        alSourcef(sourceId, AL_GAIN, gain);
    }

    public void setPosition(Vector3f position) {
        alSource3f(sourceId, AL_POSITION, position.x, position.y, position.z);
    }

    public void stop() {
        alSourceStop(sourceId);
    }
}

音源クラスは、その位置、ゲイン、および再生、停止、一時停止を制御するメソッドを設定するいくつかのメソッドを提供します。複数のソースが同じバッファを共有できることに注意してください。SoundBufferクラスと同様に、aSoundSourceは各操作で使用される識別子によって識別されます。このクラスはcleanup、予約されたリソースを解放するメソッドも提供します。しかし、コンストラクターを調べてみましょう。alGenSources最初に行うことは、呼び出しでソースを作成することです。次に、コンストラクターのパラメーターを使用していくつかの興味深いプロパティを設定します。

最初のパラメータ はloop、再生するサウンドをループ モードにするかどうかを示します。デフォルトでは、再生アクションがソースに対して呼び出されると、オーディオ データが消費されると再生が停止します。一部のサウンドではこれで問題ありませんが、バックグラウンド ミュージックなど、何度も再生する必要があるサウンドもあります。オーディオがいつ停止して再生プロセスを再開するかを手動で制御する代わりに、単純に looping プロパティを true に設定します: “ alSourcei(sourceId, AL_LOOPING, AL_TRUE);”.

もう 1 つのパラメータrelativeは、ソースの位置がリスナーに対して相対的かどうかを制御します。この場合、ソースの位置を設定するときは、基本的に、OpenAL 3D シーンの位置ではなく、世界の位置ではなく、リスナーまでの距離 (ベクトルを使用) を定義しています。これは、「alSourcei(sourceId, AL_SOURCE_RELATIVE, AL_TRUE);”呼び出しによってアクティブ化されます。しかし、これを何に使用できますか？このプロパティは、たとえば、リスナーまでの距離によって影響を受けてはならない (減衰されてはならない) バックグラウンド サウンドの場合に役立ちます。たとえば、プレーヤーのコントロールに関連するバックグラウンド ミュージックやサウンド エフェクトを考えてみましょう。これらのソースを相対として設定し、それらの位置を(0,0,0)それらは減衰されません。

今度はリスナーの番です。これは、驚いたことに、 という名前のクラスによってモデル化されていSoundListenerます。これがそのクラスの定義です。

package org.lwjglb.engine.sound;

import org.joml.Vector3f;

import static org.lwjgl.openal.AL10.*;

public class SoundListener {

    public SoundListener(Vector3f position) {
        alListener3f(AL_POSITION, position.x, position.y, position.z);
        alListener3f(AL_VELOCITY, 0, 0, 0);
    }

    public void setOrientation(Vector3f at, Vector3f up) {
        float[] data = new float[6];
        data[0] = at.x;
        data[1] = at.y;
        data[2] = at.z;
        data[3] = up.x;
        data[4] = up.y;
        data[5] = up.z;
        alListenerfv(AL_ORIENTATION, data);
    }

    public void setPosition(Vector3f position) {
        alListener3f(AL_POSITION, position.x, position.y, position.z);
    }

    public void setSpeed(Vector3f speed) {
        alListener3f(AL_VELOCITY, speed.x, speed.y, speed.z);
    }
}

前のクラスとの違いは、リスナーを作成する必要がないことです。リスナーは常に 1 つ存在するため、作成する必要はありません。既に用意されています。したがって、コンストラクターでは、単に初期位置を設定するだけです。同じ理由で、cleanupメソッドは必要ありません。クラスには、クラスのようにリスナーの位置と速度を設定するためのメソッドもありますSoundSourceが、リスナーの向きを変更するための追加のメソッドがあります。オリエンテーションとは何かを確認しましょう。リスナーの向きは、次の図に示すように、「at」ベクトルと「up」ベクトルの 2 つのベクトルによって定義されます。

「at」ベクトルは基本的にリスナーが向いている方向を指し、デフォルトではその座標は(0,0,-1). 「上」ベクトルは、リスナーにとって上向きの方向を決定し、デフォルトでは(0,1,0)したがって、これら 2 つのベクトルのそれぞれの 3 つのコンポーネントが、alListenerfvメソッド呼び出しで設定されます。このメソッドは、float のセット (可変数の float) をプロパティ (この場合は向き) に転送するために使用されます。

続行する前に、ソースとリスナーの速度に関するいくつかの概念を強調する必要があります。ソースとリスナー間の相対速度により、OpenAL はドップラー効果をシミュレートします。ご存じないかもしれませんが、ドップラー効果は、あなたに近づいている移動物体が、遠ざかるときよりも高い周波数で放射しているように見える原因です. 問題は、単にソースまたはリスナーの速度を設定するだけでは、OpenAL はそれらの位置を更新しないということです。相対速度を使用してドップラー効果を計算しますが、位置は変更されません。そのため、移動するソースまたはリスナーをシミュレートする場合は、ゲーム ループ内でそれらの位置を更新する必要があります。

主要な要素をモデル化したので、それらを機能するように設定できます。OpenAL ライブラリを初期化する必要があるため、これを処理するという名前の新しいクラスを作成し、次のSoundManagerように開始します。

package org.lwjglb.engine.sound;

import org.joml.*;
import org.lwjgl.openal.*;
import org.lwjglb.engine.scene.Camera;

import java.nio.*;
import java.util.*;

import static org.lwjgl.openal.AL10.alDistanceModel;
import static org.lwjgl.openal.ALC10.*;
import static org.lwjgl.system.MemoryUtil.NULL;

public class SoundManager {

    private final List<SoundBuffer> soundBufferList;
    private final Map<String, SoundSource> soundSourceMap;
    private long context;
    private long device;
    private SoundListener listener;

    public SoundManager() {
        soundBufferList = new ArrayList<>();
        soundSourceMap = new HashMap<>();

        device = alcOpenDevice((ByteBuffer) null);
        if (device == NULL) {
            throw new IllegalStateException("Failed to open the default OpenAL device.");
        }
        ALCCapabilities deviceCaps = ALC.createCapabilities(device);
        this.context = alcCreateContext(device, (IntBuffer) null);
        if (context == NULL) {
            throw new IllegalStateException("Failed to create OpenAL context.");
        }
        alcMakeContextCurrent(context);
        AL.createCapabilities(deviceCaps);
    }
    ...
}

このクラスは、SoundBufferおよびSoundSourceインスタンスへの参照を保持して、それらを追跡し、後で適切にクリーンアップします。SoundBuffers は List に格納されますが、SoundSources は に格納されるMapため、名前で取得できます。コンストラクターは OpenAL サブシステムを初期化します。

・デフォルトのデバイスを開きます。
・そのデバイスの機能を作成します。
・OpenGL のようなサウンド コンテキストを作成し、それを現在のコンテキストとして設定します。
このSoundManagerクラスは、音源とバッファを追加するメソッドと、cleanupすべてのリソースを解放するメソッドを定義します。

public class SoundManager {
    ...
    public void addSoundBuffer(SoundBuffer soundBuffer) {
        this.soundBufferList.add(soundBuffer);
    }

    public void addSoundSource(String name, SoundSource soundSource) {
        this.soundSourceMap.put(name, soundSource);
    }

    public void cleanup() {
        soundSourceMap.values().forEach(SoundSource::cleanup);
        soundSourceMap.clear();
        soundBufferList.forEach(SoundBuffer::cleanup);
        soundBufferList.clear();
        if (context != NULL) {
            alcDestroyContext(context);
        }
        if (device != NULL) {
            alcCloseDevice(device);
        }
    }
    ...
}

また、リスナーとソースを管理するメソッドと、playSoundSourceその名前を使用してサウンドを有効にするメソッドも提供します。

public class SoundManager {
    ...
    public SoundListener getListener() {
        return this.listener;
    }

    public SoundSource getSoundSource(String name) {
        return this.soundSourceMap.get(name);
    }

    public void playSoundSource(String name) {
        SoundSource soundSource = this.soundSourceMap.get(name);
        if (soundSource != null && !soundSource.isPlaying()) {
            soundSource.play();
        }
    }

    public void removeSoundSource(String name) {
        this.soundSourceMap.remove(name);
    }

    public void setAttenuationModel(int model) {
        alDistanceModel(model);
    }

    public void setListener(SoundListener listener) {
        this.listener = listener;
    }
    ...
}

このSoundManagerクラスには、カメラ位置を指定してリスナーの向きを更新するメソッドもあります。私たちの場合、カメラがあるときはいつでもリスナーが配置されます。では、カメラの位置と回転の情報が与えられた場合、「at」ベクトルと「up」ベクトルをどのように計算するのでしょうか? 答えは、カメラに関連付けられたビュー マトリックスを使用することです。「で」を変換する必要があります(0,0,-1)
そして「アップ」(0,1,0)
カメラの回転を考慮したベクトル。カメラに関連付けcameraMatrixられたビュー マトリックスを とします。それを達成するためのコードは次のとおりです。

public class SoundManager {
    ...
    public void updateListenerPosition(Camera camera) {
        Matrix4f viewMatrix = camera.getViewMatrix();
        listener.setPosition(camera.getPosition());
        Vector3f at = new Vector3f();
        viewMatrix.positiveZ(at).negate();
        Vector3f up = new Vector3f();
        viewMatrix.positiveY(up);
        listener.setOrientation(at, up);
    }
    ...
}

上記のコードは、以前に説明した説明と同等であり、より効率的なアプローチです。完全な逆行列を計算する必要がないだけで同じ結果が得られる、 JOMLライブラリで利用可能な高速な方法を使用します。このメソッドはLWJGL フォーラムでJOML の作成者によって提供されたものなので、そこで詳細を確認できます。ソース コードを確認すると、SoundManagerクラスがビュー マトリックスの独自のコピーを計算することがわかります。

それだけです。サウンドを再生するために必要なインフラストラクチャはすべて揃っています。Mainバックグラウンド サウンドを設定するクラスで使用するだけでよく、特定のアニメーション フレームで特定のサウンドがリスナーの位置に相対的な強度でアクティブになります。

public class Main implements IAppLogic {
    ...
    private SoundSource playerSoundSource;
    private SoundManager soundMgr;

    public static void main(String[] args) {
        ...
        Engine gameEng = new Engine("chapter-16", opts, main);
        ...
    }

    @Override
    public void cleanup() {
        soundMgr.cleanup();
    }

    @Override
    public void init(Window window, Scene scene, Render render) {
        ...
        lightAngle = 45;
        initSounds(bobEntity.getPosition(), camera);
    }

    private void initSounds(Vector3f position, Camera camera) {
        soundMgr = new SoundManager();
        soundMgr.setAttenuationModel(AL11.AL_EXPONENT_DISTANCE);
        soundMgr.setListener(new SoundListener(camera.getPosition()));

        SoundBuffer buffer = new SoundBuffer("resources/sounds/creak1.ogg");
        soundMgr.addSoundBuffer(buffer);
        playerSoundSource = new SoundSource(false, false);
        playerSoundSource.setPosition(position);
        playerSoundSource.setBuffer(buffer.getBufferId());
        soundMgr.addSoundSource("CREAK", playerSoundSource);

        buffer = new SoundBuffer("resources/sounds/woo_scary.ogg");
        soundMgr.addSoundBuffer(buffer);
        SoundSource source = new SoundSource(true, true);
        source.setBuffer(buffer.getBufferId());
        soundMgr.addSoundSource("MUSIC", source);
        source.play();
    }

    @Override
    public void input(Window window, Scene scene, long diffTimeMillis, boolean inputConsumed) {
        ...
        soundMgr.updateListenerPosition(camera);
    }

    @Override
    public void update(Window window, Scene scene, long diffTimeMillis) {
        animationData.nextFrame();
        if (animationData.getCurrentFrameIdx() == 45) {
            playerSoundSource.play();
        }
    }
}

最後のメモ。AL11.AL_EXPONENT_DISTANCEOpenAL では、alDistanceModel を使用して必要なモデル ( 、AL_EXPONENT_DISTANCE_CLAMPなど)を渡すことにより、減衰モデルを変更することもできます。それらで遊んで、結果を確認できます。