Java 3D LWJGL GitBook: 第15章 – アニメーション

第15章 - アニメーション

これまでは静的な 3D モデルしかロードしていませんでしたが、この章ではそれらをアニメーション化する方法を学びます。アニメーションについて考えるとき、最初のアプローチは、モデルの位置ごとに異なるメッシュを作成し、それらを GPU にロードし、それらを順番に描画して動きの錯覚を作成することです。このアプローチは一部のゲームには最適ですが、メモリ消費に関してはあまり効率的ではありません。ここで骨格アニメーションが活躍します。assimpを使用してこれらのモデルをロードする方法を学習します。

この章の完全なソースコードは、ここにあります。

ここでは、ボーン・アニメーションの実装を行うようです。マインクラフトみたいにプレーヤーをコントロールするときにも使用できそうです。
というか、マイクラはLWJGLで動いているので、できて当たり前ですがね（笑）※実装するのは難しそうだ。。。

単語の意味

ボーン：「骨」という意味だが、ここではモデルに対して、アニメーションするときの動きを関連図けるための格子のようなオブジェクトを指す
トラバース：XML文書を処理する場合、通常はDOMツリーを生成し、それに対して要素の追加や変更などの操作を行う。こうした場合、まずDOMツリーの根（ルート）からたどって、ツリーを上ったり下りたりしながらさまざまな処理を行うことになる。この移動をトラバースという。
ノード：レンダリング実行時の各処理を構成する機能ブロックのことです。

アンチエイリアシングのサポート

この章では、アンチエイリアスのサポートも追加します。この瞬間まで、モデルにのこぎりのようなエッジが見られたかもしれません。これらの影響を取り除くために、基本的にいくつかのサンプルの値を使用して各ピクセルの最終的な値を構築するアンチエイリアシングを適用します。この場合、4 つのサンプル値を使用します。イメージを作成する前に、これをウィンドウヒントとして設定する必要があります (それを制御する新しいウィンドウオプションを追加します)。

public class Window {
    ...
    public Window(String title, WindowOptions opts, Callable<Void> resizeFunc) {
        ...
        if (opts.antiAliasing) {
            glfwWindowHint(GLFW_SAMPLES, 4);
        }
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
        ...
    }
    ...
    public static class WindowOptions {
        public boolean antiAliasing;
        ...
    }
}

このRenderクラスでは、マルチサンプリングを有効にする必要があります (それに加えて、サンプルモデルを適切にレンダリングするために顔のカリングを削除します)。

public class Render {
    ...
    public Render(Window window) {
        GL.createCapabilities();
        glEnable(GL_MULTISAMPLE);
        glEnable(GL_DEPTH_TEST);

        sceneRender = new SceneRender();
        guiRender = new GuiRender(window);
        skyBoxRender = new SkyBoxRender();
    }
    ...
}

序章

スケルトンアニメーションでは、モデルがアニメーション化される方法は、その下にあるスケルトンによって定義されます。スケルトンは、ボーンと呼ばれる特別な要素の階層によって定義されます。これらのボーンは、位置と回転によって定義されます。これは階層であるとも言いました。つまり、各ボーンの最終的な位置は、親の位置の影響を受けます。たとえば、手首について考えてみましょう。キャラクターが肘を動かしたり、肩を動かしたりすると、手首の位置が変更されます。

骨は、物理的な骨や関節を表す必要はありません。骨は、クリエイティブがアニメーションをモデル化できるようにするアーティファクトです。ボーンに加えて、3D モデルを構成する三角形を定義するポイントである頂点があります。しかし、スケルトンアニメーションでは、関連するボーンの位置に基づいて頂点が描画されます。

この章では、さまざまな情報源を参考にしましたが、アニメーションモデルの作成方法について非常に適切に説明している 2 つの情報源を見つけました。論文のソースは次の場所で参照できます。

現在のコードでアニメーションを含むモデルをロードすると、バインディングポーズと呼ばれるものが得られます。(前の章のコードで) それを試すことができ、3D モデルを完全に見ることができます。バインディングポイズは、アニメーションの影響をまったく受けずに、モデルの位置法線、テクスチャ座標を定義します。アニメーション化されたモデルは、基本的に次の追加情報を定義します。
・変換を構成できる階層を定義するボーンによって構成されたツリーのような構造。
・各メッシュには、頂点の位置、法線などに関する情報が含まれているだけでなく、この頂点がどのボーンに関連しているか (ボーンインデックスを使用) と、それらがどの程度影響を受けているか (つまり、重み係数を使用してエフェクトを調整している) に関する情報が含まれます。 .
・各ボーンに適用する必要がある特定の変換を定義する一連のアニメーションキーフレームは、拡張によって関連する頂点を変更します。モデルは複数のアニメーションを定義でき、それぞれが複数のアニメーションキーフレームで構成されている場合があります。アニメーションの場合、これらのキーフレーム (期間を定義する) を反復処理し、それらの間で相互運用することもできます。基本的に、特定の瞬間に、関連するボーンに関連付けられた変換を各頂点に適用します。

まず、アニメーション情報を含む assimp が扱う構造体をおさらいしましょう。まず、ボーンとウェイトの情報から始めます。それぞれについてAIMesh、頂点の位置、テクスチャ座標、およびインデックスにアクセスできます。メッシュにはボーンのリストも保存されます。各ボーンは、次の属性によって定義されます。
・名前。
・オフセットマトリックス: これは後で各ボーンで使用される最終的な変換を計算するために使用されます。
ボーンは重みのリストも指します。各重みは、次の属性によって定義されます。

・重み係数、つまり、各頂点に関連付けられたボーンの変換の影響を調整するために使用される数値です。
・頂点識別子、つまり現在のボーンに関連付けられている頂点。
次の図は、これらすべての要素間の関係を示しています。

したがって、各頂点は、位置、法線、およびテクスチャ座標を含むだけでなく、それらの頂点に影響を与えるボーンの一連のインデックス (通常は 4 つの値) ( jointIndices) と、その効果を調整する一連のウェイトを持ちます。各頂点は、最終的な位置を計算するために、各ジョイントに関連付けられた変換行列に従って変更されます。したがって、次の図に示すように、各メッシュに関連付けられた VAO を拡張してその情報を保持する必要があります。

Assimp シーンオブジェクトは、ノードの階層を定義します。各ノードは、名前と子ノードのリストによって定義されます。アニメーションはこれらのノードを使用して、適用する変換を定義します。この階層は、実際にボーンの階層として定義されます。すべてのボーンはノードであり、ルートノードを除く親と、場合によっては子のセットを持ちます。ボーンではない特別なノードがあり、変換をグループ化するために使用され、変換を計算するときに処理する必要があります。もう 1 つの問題は、このノード階層がモデル全体から定義されていることです。メッシュごとに個別の階層はありません。

シーンは、一連のアニメーションも定義します。1 つのモデルに複数のアニメーションを設定して、キャラクターの歩き方、走り方などをモデル化できます。これらのアニメーションはそれぞれ、異なる変換を定義します。アニメーションには次の属性があります。

・名前。
・期間。つまり、アニメーションの継続時間です。アニメーションは、異なるフレームごとに各ノードに適用する必要がある変換のリストであるため、名前がわかりにくいかもしれません。
・アニメーションチャンネルのリスト。アニメーションチャネルには、特定の瞬間に、各ノードに適用する必要がある移動、回転、スケーリングの情報が含まれます。アニメーションチャネルに含まれるデータをモデル化するクラスはAINodeAnim. アニメーションチャネルは、キーフレームとして同化できます。
次の図は、上記のすべての要素間の関係を示しています。

フレームの特定の瞬間に、ボーンに適用される変換は、その瞬間のアニメーションチャネルで定義された変換に、ルートノードまでのすべての親ノードの変換を乗算したものです。したがって、シーンに保存されている情報を抽出する必要があります。プロセスは次のとおりです。

・ノード階層を構築します。
・アニメーションごとに、(アニメーションノードごとに) 各アニメーションチャネルを反復処理し、考えられるすべてのアニメーションフレームの各ボーンの変換行列を作成します。これらの変換行列は、骨に関連付けられたノードの変換行列と骨変換行列の組み合わせです。
・ルートノードから開始し、フレームごとに、そのノードの変換マトリックスを作成します。これは、ノードの変換マトリックスに、そのノードの特定のフレームの移動、回転、スケールマトリックスの構成を掛けたものです。
・次に、そのノードに関連付けられたボーンを取得し、ボーンのオフセットマトリックスを乗算してその変換を補完します。結果は、その特定のフレームの関連するボーンに関連付けられた変換マトリックスになり、シェーダーで使用されます。
・その後、子ノードを繰り返し処理し、親ノードの変換行列を渡し、子ノードの変換と組み合わせて使用します。

実装

実装の説明は、以下の順序で行われてます。

メインの変更点の説明
付随する部分の変更点

メインの変更点がModelLoaderなので、修正した後に、呼び出している部分とそれに付随する部分を修正していきます。

ModelLoaderクラスの変更を分析することから始めましょう。

public class ModelLoader {

    public static final int MAX_BONES = 150;
    private static final Matrix4f IDENTITY_MATRIX = new Matrix4f();
    ...
    public static Model loadModel(String modelId, String modelPath, TextureCache textureCache, boolean animation) {
        return loadModel(modelId, modelPath, textureCache, aiProcess_GenSmoothNormals | aiProcess_JoinIdenticalVertices |
                aiProcess_Triangulate | aiProcess_FixInfacingNormals | aiProcess_CalcTangentSpace | aiProcess_LimitBoneWeights |
                (animation ? 0 : aiProcess_PreTransformVertices));

    }
    ...
}

アニメーション付きのモデルをロードしているかどうかを示すために、メソッドに追加の引数 ( という名前animation) が必要です。loadModelその場合、aiProcess_PreTransformVerticesフラグは使用できません。このフラグは、ロードされたデータに対して何らかの変換を実行するため、モデルは原点に配置され、座標は数学 OpenGL 座標系に修正されます。このフラグはアニメーションデータ情報を削除するため、アニメーションモデルには使用できません。

メッシュを処理している間、メッシュを処理しているときに、各頂点に関連付けられているボーンとウェイトも処理します。それらを処理している間、必要な変換を後で構築できるように、ボーンのリストを保存します。

public class ModelLoader {
    ...
    public static Model loadModel(String modelId, String modelPath, TextureCache textureCache, int flags) {
        ...
        List<Bone> boneList = new ArrayList<>();
        for (int i = 0; i < numMeshes; i++) {
            AIMesh aiMesh = AIMesh.create(aiMeshes.get(i));
            Mesh mesh = processMesh(aiMesh, boneList);
            ...
        }
        ...
    }
    ...
    private static Mesh processMesh(AIMesh aiMesh, List<Bone> boneList) {
        ...
        AnimMeshData animMeshData = processBones(aiMesh, boneList);
        ...
        return new Mesh(vertices, normals, tangents, bitangents, textCoords, indices, animMeshData.boneIds, animMeshData.weights);
    }
    ...
}

新しいメソッドprocessBonesは次のように定義されます。

public class ModelLoader {
    ...
    private static AnimMeshData processBones(AIMesh aiMesh, List<Bone> boneList) {
        List<Integer> boneIds = new ArrayList<>();
        List<Float> weights = new ArrayList<>();

        Map<Integer, List<VertexWeight>> weightSet = new HashMap<>();
        int numBones = aiMesh.mNumBones();
        PointerBuffer aiBones = aiMesh.mBones();
        for (int i = 0; i < numBones; i++) {
            AIBone aiBone = AIBone.create(aiBones.get(i));
            int id = boneList.size();
            Bone bone = new Bone(id, aiBone.mName().dataString(), toMatrix(aiBone.mOffsetMatrix()));
            boneList.add(bone);
            int numWeights = aiBone.mNumWeights();
            AIVertexWeight.Buffer aiWeights = aiBone.mWeights();
            for (int j = 0; j < numWeights; j++) {
                AIVertexWeight aiWeight = aiWeights.get(j);
                VertexWeight vw = new VertexWeight(bone.boneId(), aiWeight.mVertexId(),
                        aiWeight.mWeight());
                List<VertexWeight> vertexWeightList = weightSet.get(vw.vertexId());
                if (vertexWeightList == null) {
                    vertexWeightList = new ArrayList<>();
                    weightSet.put(vw.vertexId(), vertexWeightList);
                }
                vertexWeightList.add(vw);
            }
        }

        int numVertices = aiMesh.mNumVertices();
        for (int i = 0; i < numVertices; i++) {
            List<VertexWeight> vertexWeightList = weightSet.get(i);
            int size = vertexWeightList != null ? vertexWeightList.size() : 0;
            for (int j = 0; j < Mesh.MAX_WEIGHTS; j++) {
                if (j < size) {
                    VertexWeight vw = vertexWeightList.get(j);
                    weights.add(vw.weight());
                    boneIds.add(vw.boneId());
                } else {
                    weights.add(0.0f);
                    boneIds.add(0);
                }
            }
        }

        return new AnimMeshData(Utils.listFloatToArray(weights), Utils.listIntToArray(boneIds));
    }
    ...
}

このメソッドは、特定のメッシュのボーン定義をトラバースし、それらのウェイトを取得して生成し、3 つのリストを埋めます。

・boneList: オフセットマトリックスを含むボーンのリストが含まれます。後で最終的な骨の変換を計算するために使用します。Boneその情報を保持するために、という名前の新しいクラスが作成されました。このリストには、すべてのメッシュのボーンが含まれます。
・boneIds: の各頂点のボーンの識別子のみが含まれますMesh。ボーンは、レンダリング時の位置によって識別されます。このリストには、特定のメッシュのボーンのみが含まれています。
・weightsMesh:関連するボーンに適用されるの各頂点の重みが含まれています。
このメソッドで取得された情報は、AnimMeshDataレコードにカプセル化されます (クラス内で定義されますModelLoader)。newBoneとVertexWeightclass もレコードです。それらは次のように定義されます。

public class ModelLoader {
    ...
    public record AnimMeshData(float[] weights, int[] boneIds) {
    }

    private record Bone(int boneId, String boneName, Matrix4f offsetMatrix) {
    }

    private record VertexWeight(int boneId, int vertexId, float weight) {
    }
}

s とsを配列Utilsに変換するために、クラスに 2 つの新しいメソッドも作成しました。Listfloatint

public class Utils {
    ...
    public static float[] listFloatToArray(List<Float> list) {
        int size = list != null ? list.size() : 0;
        float[] floatArr = new float[size];
        for (int i = 0; i < size; i++) {
            floatArr[i] = list.get(i);
        }
        return floatArr;
    }

    public static int[] listIntToArray(List<Integer> list) {
        return list.stream().mapToInt((Integer v) -> v).toArray();
    }
    ...
}

メソッドに戻るとloadModel、メッシュとマテリアルを処理したら、アニメーションデータ (各アニメーションとその変換に関連付けられたさまざまなアニメーションキーフレーム) を処理します。そのすべての情報もModelクラスに保存されます。

public class ModelLoader {
    ...
    public static Model loadModel(String modelId, String modelPath, TextureCache textureCache, int flags) {
        ...
        List<Model.Animation> animations = new ArrayList<>();
        int numAnimations = aiScene.mNumAnimations();
        if (numAnimations > 0) {
            Node rootNode = buildNodesTree(aiScene.mRootNode(), null);
            Matrix4f globalInverseTransformation = toMatrix(aiScene.mRootNode().mTransformation()).invert();
            animations = processAnimations(aiScene, boneList, rootNode, globalInverseTransformation);
        }

        aiReleaseImport(aiScene);

        return new Model(modelId, materialList, animations);
    }
    ...
}

メソッドは非常に単純です。buildNodesTreeノードのツリーを構築するルートノードから開始して、ノード階層をトラバースするだけです。

public class ModelLoader {
    ...
    private static Node buildNodesTree(AINode aiNode, Node parentNode) {
        String nodeName = aiNode.mName().dataString();
        Node node = new Node(nodeName, parentNode, toMatrix(aiNode.mTransformation()));

        int numChildren = aiNode.mNumChildren();
        PointerBuffer aiChildren = aiNode.mChildren();
        for (int i = 0; i < numChildren; i++) {
            AINode aiChildNode = AINode.create(aiChildren.get(i));
            Node childNode = buildNodesTree(aiChildNode, node);
            node.addChild(childNode);
        }
        return node;
    }
    ...
}

このtoMatrixメソッドは assimp 行列を JOML 行列に変換するだけです:

public class ModelLoader {
    ...
    private static Matrix4f toMatrix(AIMatrix4x4 aiMatrix4x4) {
        Matrix4f result = new Matrix4f();
        result.m00(aiMatrix4x4.a1());
        result.m10(aiMatrix4x4.a2());
        result.m20(aiMatrix4x4.a3());
        result.m30(aiMatrix4x4.a4());
        result.m01(aiMatrix4x4.b1());
        result.m11(aiMatrix4x4.b2());
        result.m21(aiMatrix4x4.b3());
        result.m31(aiMatrix4x4.b4());
        result.m02(aiMatrix4x4.c1());
        result.m12(aiMatrix4x4.c2());
        result.m22(aiMatrix4x4.c3());
        result.m32(aiMatrix4x4.c4());
        result.m03(aiMatrix4x4.d1());
        result.m13(aiMatrix4x4.d2());
        result.m23(aiMatrix4x4.d3());
        result.m33(aiMatrix4x4.d4());

        return result;
    }
    ...
}

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

public class ModelLoader {
    ...
    private static List<Model.Animation> processAnimations(AIScene aiScene, List<Bone> boneList,
                                                           Node rootNode, Matrix4f globalInverseTransformation) {
        List<Model.Animation> animations = new ArrayList<>();

        // Process all animations
        int numAnimations = aiScene.mNumAnimations();
        PointerBuffer aiAnimations = aiScene.mAnimations();
        for (int i = 0; i < numAnimations; i++) {
            AIAnimation aiAnimation = AIAnimation.create(aiAnimations.get(i));
            int maxFrames = calcAnimationMaxFrames(aiAnimation);

            List<Model.AnimatedFrame> frames = new ArrayList<>();
            Model.Animation animation = new Model.Animation(aiAnimation.mName().dataString(), aiAnimation.mDuration(), frames);
            animations.add(animation);

            for (int j = 0; j < maxFrames; j++) {
                Matrix4f[] boneMatrices = new Matrix4f[MAX_BONES];
                Arrays.fill(boneMatrices, IDENTITY_MATRIX);
                Model.AnimatedFrame animatedFrame = new Model.AnimatedFrame(boneMatrices);
                buildFrameMatrices(aiAnimation, boneList, animatedFrame, j, rootNode,
                        rootNode.getNodeTransformation(), globalInverseTransformation);
                frames.add(animatedFrame);
            }
        }
        return animations;
    }
    ...
}

このメソッドはインスタンスのを返しListますModel.Animation。モデルには複数のアニメーションを含めることができるため、アニメーションはインデックスごとに保存されることに注意してください。これらのアニメーションごとに、アニメーションフレーム (Model.AnimatedFrameインスタンス) のリストを作成します。これは、基本的に、モデルを構成する各ボーンに適用される変換マトリックスのリストです。アニメーションごとに、次のcalcAnimationMaxFramesように定義されているメソッドを呼び出して、最大フレーム数を計算します。

public class ModelLoader {
    ...
    private static int calcAnimationMaxFrames(AIAnimation aiAnimation) {
        int maxFrames = 0;
        int numNodeAnims = aiAnimation.mNumChannels();
        PointerBuffer aiChannels = aiAnimation.mChannels();
        for (int i = 0; i < numNodeAnims; i++) {
            AINodeAnim aiNodeAnim = AINodeAnim.create(aiChannels.get(i));
            int numFrames = Math.max(Math.max(aiNodeAnim.mNumPositionKeys(), aiNodeAnim.mNumScalingKeys()),
                    aiNodeAnim.mNumRotationKeys());
            maxFrames = Math.max(maxFrames, numFrames);
        }

        return maxFrames;
    }
    ...
}

クラスの変更を確認する前に、アニメーション情報を保持するためModelLoaderのクラスの変更を確認しましょう。Model

public class Model {
    ...
    private List<Animation> animationList;
    ...
    public Model(String id, List<Material> materialList, List<Animation> animationList) {
        entitiesList = new ArrayList<>();
        this.id = id;
        this.materialList = materialList;
        this.animationList = animationList;
    }
    ...
    public List<Animation> getAnimationList() {
        return animationList;
    }
    ...
    public record AnimatedFrame(Matrix4f[] boneMatrices) {
    }

    public record Animation(String name, double duration, List<AnimatedFrame> frames) {
    }
}

ご覧のとおり、モデルに関連付けられたアニメーションのリストを保存します。それぞれのアニメーションは、名前、持続時間、およびアニメーションフレームのリストによって定義されます。基本的には、各ボーンに適用されるボーン変換マトリックスを保存するだけです。

ModelLoaderクラスに戻ると、各AINodeAnimインスタンスは、特定のフレームのモデル内のノードに適用されるいくつかの変換を定義します。特定のノードに対するこれらの変換は、AINodeAnim実例。これらの変換は、位置の移動、回転、およびスケーリング値の形式で定義されます。ここでの秘訣は、たとえば、特定のノードの移動値は特定のフレームで停止できますが、回転とスケーリングの値は次のフレームで継続できるということです。この場合、回転やスケーリングよりも移動値が少なくなります。したがって、フレームの最大数を計算するには、最大値を使用することをお勧めします。これはノードごとに定義されるため、問題はさらに複雑になります。ノードは、最初のフレームにいくつかの変換を定義するだけで、残りのフレームにそれ以上の変更を適用することはできません。この場合、常に最後に定義された値を使用する必要があります。したがって、ノードに関連付けられたすべてのアニメーションの最大数を取得します。

メソッドに戻ると、processAnimationsその情報を使用して、さまざまなフレームを反復処理し、メソッドを呼び出してボーンの変換マトリックスを構築する準備が整いましたbuildFrameMatrices。フレームごとに、ルートノードから開始し、ノード階層の上から下に再帰的に変換を適用します。は次のbuildFrameMatricesように定義されます。

public class ModelLoader {
    ...
    private static void buildFrameMatrices(AIAnimation aiAnimation, List<Bone> boneList, Model.AnimatedFrame animatedFrame,
                                           int frame, Node node, Matrix4f parentTransformation, Matrix4f globalInverseTransform) {
        String nodeName = node.getName();
        AINodeAnim aiNodeAnim = findAIAnimNode(aiAnimation, nodeName);
        Matrix4f nodeTransform = node.getNodeTransformation();
        if (aiNodeAnim != null) {
            nodeTransform = buildNodeTransformationMatrix(aiNodeAnim, frame);
        }
        Matrix4f nodeGlobalTransform = new Matrix4f(parentTransformation).mul(nodeTransform);

        List<Bone> affectedBones = boneList.stream().filter(b -> b.boneName().equals(nodeName)).toList();
        for (Bone bone : affectedBones) {
            Matrix4f boneTransform = new Matrix4f(globalInverseTransform).mul(nodeGlobalTransform).
                    mul(bone.offsetMatrix());
            animatedFrame.boneMatrices()[bone.boneId()] = boneTransform;
        }

        for (Node childNode : node.getChildren()) {
            buildFrameMatrices(aiAnimation, boneList, animatedFrame, frame, childNode, nodeGlobalTransform,
                    globalInverseTransform);
        }
    }
    ...
}

ノードに関連付けられた変換を取得します。次に、このノードにアニメーションノードが関連付けられているかどうかを確認します。その場合、処理しているフレームに適用される適切な移動、回転、およびスケーリング変換を取得する必要があります。その情報を使用して、そのノードに関連付けられたボーンを取得し、その特定のフレームの各ボーンの変換行列を次のように乗算して更新します。

・モデルの逆グローバル変換行列 (ルートノード変換行列の逆行列)。
・ノードの変換マトリックス。
・ボーンオフセットマトリックス。
その後、ノード変換マトリックスをそれらの子ノードの親マトリックスとして使用して、子ノードを反復処理します。

public class ModelLoader {
    ...
    private static Matrix4f buildNodeTransformationMatrix(AINodeAnim aiNodeAnim, int frame) {
        AIVectorKey.Buffer positionKeys = aiNodeAnim.mPositionKeys();
        AIVectorKey.Buffer scalingKeys = aiNodeAnim.mScalingKeys();
        AIQuatKey.Buffer rotationKeys = aiNodeAnim.mRotationKeys();

        AIVectorKey aiVecKey;
        AIVector3D vec;

        Matrix4f nodeTransform = new Matrix4f();
        int numPositions = aiNodeAnim.mNumPositionKeys();
        if (numPositions > 0) {
            aiVecKey = positionKeys.get(Math.min(numPositions - 1, frame));
            vec = aiVecKey.mValue();
            nodeTransform.translate(vec.x(), vec.y(), vec.z());
        }
        int numRotations = aiNodeAnim.mNumRotationKeys();
        if (numRotations > 0) {
            AIQuatKey quatKey = rotationKeys.get(Math.min(numRotations - 1, frame));
            AIQuaternion aiQuat = quatKey.mValue();
            Quaternionf quat = new Quaternionf(aiQuat.x(), aiQuat.y(), aiQuat.z(), aiQuat.w());
            nodeTransform.rotate(quat);
        }
        int numScalingKeys = aiNodeAnim.mNumScalingKeys();
        if (numScalingKeys > 0) {
            aiVecKey = scalingKeys.get(Math.min(numScalingKeys - 1, frame));
            vec = aiVecKey.mValue();
            nodeTransform.scale(vec.x(), vec.y(), vec.z());
        }

        return nodeTransform;
    }
    ...
}

インスタンスは、AINodeAnim移動、回転、およびスケーリング情報を含む一連のキーを定義します。これらのキーは、特定の瞬間を参照します。情報は時間順に並べられていると仮定し、各フレームに適用される変換を含む行列のリストを作成します。前に述べたように、これらの変換の一部は特定のフレームで「停止」する可能性があるため、最後のフレームには最後の値を使用する必要があります。

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

public class ModelLoader {
    ...
    private static AINodeAnim findAIAnimNode(AIAnimation aiAnimation, String nodeName) {
        AINodeAnim result = null;
        int numAnimNodes = aiAnimation.mNumChannels();
        PointerBuffer aiChannels = aiAnimation.mChannels();
        for (int i = 0; i < numAnimNodes; i++) {
            AINodeAnim aiNodeAnim = AINodeAnim.create(aiChannels.get(i));
            if (nodeName.equals(aiNodeAnim.mNodeName().dataString())) {
                result = aiNodeAnim;
                break;
            }
        }
        return result;
    }
    ...
}

Meshボーンインデックスとボーンウェイトに新しい VBO を割り当てるには、クラスを更新する必要があります。最大 4 つのウェイト (および頂点ごとの関連付けられたボーンインデックス) を使用することがわかります。

public class Mesh {

    public static final int MAX_WEIGHTS = 4;
    ...
    public Mesh(float[] positions, float[] normals, float[] tangents, float[] bitangents, float[] textCoords, int[] indices) {
        this(positions, normals, tangents, bitangents, textCoords, indices,
                new int[Mesh.MAX_WEIGHTS * positions.length / 3], new float[Mesh.MAX_WEIGHTS * positions.length / 3]);
    }

    public Mesh(float[] positions, float[] normals, float[] tangents, float[] bitangents, float[] textCoords, int[] indices,
                int[] boneIndices, float[] weights) {
        try (MemoryStack stack = MemoryStack.stackPush()) {
            ...
            // Bone weights
            vboId = glGenBuffers();
            vboIdList.add(vboId);
            FloatBuffer weightsBuffer = MemoryUtil.memAllocFloat(weights.length);
            weightsBuffer.put(weights).flip();
            glBindBuffer(GL_ARRAY_BUFFER, vboId);
            glBufferData(GL_ARRAY_BUFFER, weightsBuffer, GL_STATIC_DRAW);
            glEnableVertexAttribArray(5);
            glVertexAttribPointer(5, 4, GL_FLOAT, false, 0, 0);

            // Bone indices
            vboId = glGenBuffers();
            vboIdList.add(vboId);
            IntBuffer boneIndicesBuffer = MemoryUtil.memAllocInt(boneIndices.length);
            boneIndicesBuffer.put(boneIndices).flip();
            glBindBuffer(GL_ARRAY_BUFFER, vboId);
            glBufferData(GL_ARRAY_BUFFER, boneIndicesBuffer, GL_STATIC_DRAW);
            glEnableVertexAttribArray(6);
            glVertexAttribPointer(6, 4, GL_FLOAT, false, 0, 0);
            ...
        }
    }
    ...
}

このNodeクラスは、に関連付けられたデータを格納するだけで、AINodeその子を管理するための特定のメソッドがあります。

package org.lwjglb.engine.scene;

import org.joml.Matrix4f;

import java.util.*;

public class Node {
    private final List<Node> children;

    private final String name;

    private final Node parent;

    private Matrix4f nodeTransformation;

    public Node(String name, Node parent, Matrix4f nodeTransformation) {
        this.name = name;
        this.parent = parent;
        this.nodeTransformation = nodeTransformation;
        this.children = new ArrayList<>();
    }

    public void addChild(Node node) {
        this.children.add(node);
    }

    public List<Node> getChildren() {
        return children;
    }

    public String getName() {
        return name;
    }

    public Matrix4f getNodeTransformation() {
        return nodeTransformation;
    }

    public Node getParent() {
        return parent;
    }
}

これで、アニメーションモデルをレンダリングする方法と、静的モデルと共存させる方法を確認できます。SceneRenderクラスから始めましょう。このクラスでは、(現在のアニメーションフレームに割り当てられた) ボーンマトリックスを渡すために新しいユニフォームをセットアップして、シェーダーで使用できるようにするだけです。それに加えて、静的およびアニメーション化されたエンティティのレンダリングは、このクラスに追加の影響を与えません。

public class SceneRender {
    ...
    private void createUniforms() {
        ...
        uniformsMap.createUniform("bonesMatrices");
        ...
    }

    public void render(Scene scene) {
        ...
        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);
                    }
                }
            }
        }
    }
    ...
}

静的モデルの場合、null に設定された行列の配列を渡します。UniformsMap行列の配列の値を設定する新しいメソッドを追加するには、も変更する必要があります。

public class UniformsMap {
    ...
    public void setUniform(String uniformName, Matrix4f[] matrices) {
        try (MemoryStack stack = MemoryStack.stackPush()) {
            int length = matrices != null ? matrices.length : 0;
            FloatBuffer fb = stack.mallocFloat(16 * length);
            for (int i = 0; i < length; i++) {
                matrices[i].get(16 * i, fb);
            }
            glUniformMatrix4fv(uniforms.get(uniformName), false, fb);
        }
    }
}

AnimationDataに設定された現在のアニメーションを制御する名前の新しいクラスも作成しましたEntity。

package org.lwjglb.engine.scene;

import org.joml.Matrix4f;
import org.lwjglb.engine.graph.Model;

public class AnimationData {

    public static final Matrix4f[] DEFAULT_BONES_MATRICES = new Matrix4f[ModelLoader.MAX_BONES];

    static {
        Matrix4f zeroMatrix = new Matrix4f().zero();
        for (int i = 0; i < DEFAULT_BONES_MATRICES.length; i++) {
            DEFAULT_BONES_MATRICES[i] = zeroMatrix;
        }
    }

    private Model.Animation currentAnimation;
    private int currentFrameIdx;

    public AnimationData(Model.Animation currentAnimation) {
        currentFrameIdx = 0;
        this.currentAnimation = currentAnimation;
    }

    public Model.Animation getCurrentAnimation() {
        return currentAnimation;
    }

    public Model.AnimatedFrame getCurrentFrame() {
        return currentAnimation.frames().get(currentFrameIdx);
    }

    public int getCurrentFrameIdx() {
        return currentFrameIdx;
    }

    public void nextFrame() {
        int nextFrame = currentFrameIdx + 1;
        if (nextFrame > currentAnimation.frames().size() - 1) {
            currentFrameIdx = 0;
        } else {
            currentFrameIdx = nextFrame;
        }
    }

    public void setCurrentAnimation(Model.Animation currentAnimation) {
        currentFrameIdx = 0;
        this.currentAnimation = currentAnimation;
    }
}

もちろん、インスタンスEntityへの参照を保持するようにクラスを変更する必要があります。AnimationData

public class Entity {
    ...
    private AnimationData animationData;
    ...
    public AnimationData getAnimationData() {
        return animationData;
    }
    ...
    public void setAnimationData(AnimationData animationData) {
        this.animationData = animationData;
    }
    ...
}

シーンの頂点シェーダー ( scene.vert) を変更して、アニメーションデータを再生する必要があります。いくつかの定数と、ボーンの重みとインデックスの新しい入力属性を定義することから始めます (頂点ごとに 4 つの要素を使用するため、とを使用vec4しますivec4)。現在のアニメーションに関連付けられているボーンマトリックスもユニフォームとして渡します。

#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 bonesMatrices[MAX_BONES];
...

このmain関数では、関連付けられたボーンインデックスによって指定され、関連付けられた重みによって変調された行列を使用して、ボーンウェイトを繰り返し処理し、位置と法線を変更します。各ボーンが位置 (および法線) の修正に寄与するが、重みを使用して変調される場合のように考えることができます。静的モデルを使用している場合、重みはゼロになるため、元の位置と法線の値に固執します。

...
void main()
{
    vec4 initPos = vec4(0, 0, 0, 0);
    vec4 initNormal = vec4(0, 0, 0, 0);
    vec4 initTangent = vec4(0, 0, 0, 0);
    vec4 initBitangent = 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;

            vec4 tmpNormal = bonesMatrices[boneIndex] * vec4(normal, 0.0);
            initNormal += weight * tmpNormal;

            vec4 tmpTangent = bonesMatrices[boneIndex] * vec4(tangent, 0.0);
            initTangent += weight * tmpTangent;

            vec4 tmpBitangent = bonesMatrices[boneIndex] * vec4(bitangent, 0.0);
            initTangent += weight * tmpBitangent;
        }
    }
    if (count == 0) {
        initPos = vec4(position, 1.0);
        initNormal = vec4(normal, 0.0);
        initTangent = vec4(tangent, 0.0);
        initBitangent = vec4(bitangent, 0.0);
    }

    mat4 modelViewMatrix = viewMatrix * modelMatrix;
    vec4 mvPosition =  modelViewMatrix * initPos;
    gl_Position   = projectionMatrix * mvPosition;
    outPosition   = mvPosition.xyz;
    outNormal     = normalize(modelViewMatrix * initNormal).xyz;
    outTangent    = normalize(modelViewMatrix * initTangent).xyz;
    outBitangent  = normalize(modelViewMatrix * initBitangent).xyz;
    outTextCoord  = texCoord;
}

次の図は、プロセスを示しています

このMainクラスでは、アニメーションモデルをロードし、アンチエイリアシングを有効にする必要があります。また、更新ごとにアニメーションフレームをインクリメントします。

public class Main implements IAppLogic {
    ...
    private AnimationData animationData;
    ...
    public static void main(String[] args) {
        Main main = new Main();
        Window.WindowOptions opts = new Window.WindowOptions();
        opts.antiAliasing = true;
        Engine gameEng = new Engine("chapter-15", opts, main);
        gameEng.start();
    }
    ...
    @Override
    public void init(Window window, Scene scene, Render render) {
        String terrainModelId = "terrain";
        Model terrainModel = ModelLoader.loadModel(terrainModelId, "resources/models/terrain/terrain.obj",
                scene.getTextureCache(), false);
        scene.addModel(terrainModel);
        Entity terrainEntity = new Entity("terrainEntity", terrainModelId);
        terrainEntity.setScale(100.0f);
        terrainEntity.updateModelMatrix();
        scene.addEntity(terrainEntity);

        String bobModelId = "bobModel";
        Model bobModel = ModelLoader.loadModel(bobModelId, "resources/models/bob/boblamp.md5mesh",
                scene.getTextureCache(), true);
        scene.addModel(bobModel);
        Entity bobEntity = new Entity("bobEntity", bobModelId);
        bobEntity.setScale(0.05f);
        bobEntity.updateModelMatrix();
        animationData = new AnimationData(bobModel.getAnimationList().get(0));
        bobEntity.setAnimationData(animationData);
        scene.addEntity(bobEntity);

        SceneLights sceneLights = new SceneLights();
        AmbientLight ambientLight = sceneLights.getAmbientLight();
        ambientLight.setIntensity(0.5f);
        ambientLight.setColor(0.3f, 0.3f, 0.3f);

        DirLight dirLight = sceneLights.getDirLight();
        dirLight.setPosition(0, 1, 0);
        dirLight.setIntensity(1.0f);
        scene.setSceneLights(sceneLights);

        SkyBox skyBox = new SkyBox("resources/models/skybox/skybox.obj", scene.getTextureCache());
        skyBox.getSkyBoxEntity().setScale(100);
        skyBox.getSkyBoxEntity().updateModelMatrix();
        scene.setSkyBox(skyBox);

        scene.setFog(new Fog(true, new Vector3f(0.5f, 0.5f, 0.5f), 0.02f));

        Camera camera = scene.getCamera();
        camera.setPosition(-1.5f, 3.0f, 4.5f);
        camera.addRotation((float) Math.toRadians(15.0f), (float) Math.toRadians(390.f));

        lightAngle = 0;
    }
    ...
    @Override
    public void update(Window window, Scene scene, long diffTimeMillis) {
        animationData.nextFrame();
    }
}

最後に、クラスのメソッドが変更されているSkyBoxため、クラスも変更する必要があります。loadModelModelLoader

public class SkyBox {
    ...
    public SkyBox(String skyBoxModelPath, TextureCache textureCache) {
        skyBoxModel = ModelLoader.loadModel("skybox-model", skyBoxModelPath, textureCache, false);
        ...
    }
}

次のようなものが表示されます。

投稿者:

takunoji

音響、イベント会場設営業界からIT業界へ転身。現在はJava屋としてサラリーマンをやっている。自称ガテン系プログラマー(笑) Javaプログラミングを布教したい、ラスパイとJavaの相性が良いことに気が付く。 Spring framework, Struts, Seaser, Hibernate, Playframework, JavaEE6, JavaEE7などの現場経験あり。 SQL, VBA, PL/SQL, コマンドプロント, Shellなどもやります。 takunoji の投稿をすべて表示

コメントを残すコメントをキャンセル

コメントを投稿するにはログインしてください。