【実装編②】OpenSiv3Dでスキニングとアニメーションさせる方法

void Skeleton::LoadBonesFromMesh(const aiMesh* mesh, Array<SkinnedVertex>& outVertices)
{
    outVertices.resize(mesh->mNumVertices);

    for (unsigned int i = 0; i < mesh->mNumBones; i++)
    {
        std::string boneName = mesh->mBones[i]->mName.C_Str();

        // 登録されていないボーンを追加
        if (boneMapping.find(boneName) == boneMapping.end())
        {
            int newIndex = static_cast<int>(boneMapping.size());
            boneMapping[boneName] = newIndex;
            boneOffsetMatrices.resize(newIndex + 1);
        }
        // オフセット行列も保存
        boneOffsetMatrices[boneMapping[boneName]] = mesh->mBones[i]->mOffsetMatrix;

        int boneIndex = boneMapping[boneName];

        // ボーンが与える影響とそのウェイトを保存する
        aiBone* bone = mesh->mBones[i];
        for (unsigned int j = 0; j < bone->mNumWeights; j++)
        {
            const aiVertexWeight& weight = bone->mWeights[j];
            int vertexId = weight.mVertexId;
            float w = weight.mWeight;

            outVertices[vertexId].boneIndices.push_back(boneIndex);
            outVertices[vertexId].boneWeight.push_back(w);
        }
    }

    for (auto& vertex : outVertices)
    {
        float totalWeight = 0.0f;
        for (float w : vertex.boneWeight)
        {
            totalWeight += w;
        }

        if (totalWeight > 0.0f)
        {
            for (float& w : vertex.boneWeight)
            {
                w /= totalWeight;
            }
        }
    }
}

void Skeleton::UpdateAnimation(double deltaTime)
{
    if (!scene || scene->mNumAnimations == 0)
    {
        return;
    }

    aiAnimation* animation = scene->mAnimations[currentAnimationIndex];
    if (!animation)
    {
        Console << U"Error: scene->mAnimations[currentAnimationIndex] がnullptrです";
        return;
    }

    float durationInSeconds = animation->mDuration / animation->mTicksPerSecond;
    currentTime += deltaTime;

    // ループ再生
    if (currentTime > durationInSeconds)
    {
        currentTime -= durationInSeconds;
    }

    CalculateBoneTransform(currentTime);
}

void Skeleton::CalculateBoneTransform(float animationTime)
{
    currentAnimationIndex = 1;

    if (!scene->HasAnimations())
    {
        Console << U"アニメーションが存在しません";
    }

    if (currentAnimationIndex < 0 || currentAnimationIndex >= scene->mNumAnimations)
    {
        Console << U"Error: currentAnimationIndex が範囲外です";
        return;
    }

    aiAnimation* anim = scene->mAnimations[currentAnimationIndex];

    double ticksPerSecond = (anim->mTicksPerSecond != 0.0) ? anim->mTicksPerSecond : 25.0;
    double timeInTicks = animationTime * ticksPerSecond;
    double animTime = fmod(timeInTicks, anim->mDuration);

    ReadNodeHierarchy(animTime, scene->mRootNode, aiMatrix4x4(), anim);
}

void Skeleton::ReadNodeHierarchy(float animationTime, const aiNode* node, const aiMatrix4x4& parentTransform, aiAnimation* animation)
{
    std::string nodeName(node->mName.C_Str());

    // nodeTransform: デフォルトのボーンの姿勢(BindPose)
    aiMatrix4x4 nodeTransform = node->mTransformation;

    // アニメーションチャンネルがある場合は補間する、ない場合はノードのデフォルトの変換を使う
    // チャンネルを探す（アニメーション対象）を探す
    aiNodeAnim* channel = FindNodeAnimation(animation, nodeName);

    if (channel)
    {
        // 位置・回転・スケールを補完する
        Vec3 position = AnimationHelper::InterpolatePosition(channel, animationTime);
        aiQuaternion rotation = AnimationHelper::InterpolateRotation(channel, animationTime);
        Vec3 scale = AnimationHelper::InterpolateScale(channel, animationTime);

        // 補完した位置・回転・スケールを aiMatrix に変換
        aiMatrix4x4 translationMatrix, scalingMatrix;
        translationMatrix.Translation(aiVector3D(position.x, position.y, position.z), translationMatrix);

        // 回転: Quaternion -> Mat4x4 -> aiMatrix4x4
        aiMatrix4x4 rotationMatrix(rotation.GetMatrix());

        scalingMatrix.Scaling(aiVector3D(scale.x, scale.y, scale.z), scalingMatrix);

        nodeTransform = translationMatrix * rotationMatrix * scalingMatrix;
    }

    aiMatrix4x4 globalTransform = parentTransform * nodeTransform;

    // このノードがボーンだった場合、finalBoneTransformを更新する
    auto it = boneMapping.find(nodeName);
    if (it != boneMapping.end())
    {
        int boneIndex = it->second;
        finalBoneTransform[boneIndex] = globalInverseTransform * globalTransform * boneOffsetMatrices[boneIndex];
    }

    // 子ノードに再帰
    for (unsigned int i = 0; i < node->mNumChildren; i++)
    {
        ReadNodeHierarchy(animationTime, node->mChildren[i], globalTransform, animation);
    }
}

final = globalInverse * currentGlobal * offset

    void CalculateBoneTransform_StaticPose(int keyFrameIndex);
    void ReadNodeHierarchy_StaticPose(const aiNode* node, const aiMatrix4x4& parentTransform, aiAnimation* animation, int keyFrameIndex);

void Skeleton::DisplayNodeHierarchy(const aiNode* node, int depth)
{
    std::string indent(depth * 2, ' ');
    Console << Unicode::FromUTF8(indent + node->mName.C_Str());

    for (unsigned int i = 0; i < node->mNumChildren; i++)
    {
        DisplayNodeHierarchy(node->mChildren[i], depth + 1);
    }
}

void Skeleton::DisplayAnimationTime() const
{
    int currentAnimationIndex = GetCurrentAnimationIndex();
    aiAnimation* animation = scene->mAnimations[currentAnimationIndex];

    // アニメーション名
    String animationName;
    if (animation->mName.length > 0)
    {
        animationName = Unicode::FromUTF8(animation->mName.C_Str());
    }
    else
    {
        U"Animation_" + Format(currentAnimationIndex);
    }

    // アニメーションの全体時間
    float duration = animation->mDuration / animation->mTicksPerSecond;

    Console << U"再生中のアニメーション: " << animationName;
    Console << U"現在の経過時間: " << currentTime << U"秒 / " << duration << U"秒";
}