Function ApplyAnimation

engine/rig/src/rig.cpp:591–649

    }

    static void ApplyAnimation(RigInstance* instance, RigPlayer* player, dmArray<BonePose>& pose, dmArray<IKAnimation>& ik_animation, float blend_weight)
    {
        const dmRigDDF::RigAnimation* animation = player->m_Animation;
        if (!animation)
            return;
        float duration = GetCursorDuration(player, animation);
        float t = CursorToTime(player->m_Cursor, duration, player->m_Backwards, player->m_Playback == dmRig::PLAYBACK_ONCE_PINGPONG);

        float fraction = t * animation->m_SampleRate;
        uint32_t sample = (uint32_t)fraction;
        fraction -= sample;
        // Sample skeletal tracks (skip when there is no skeleton / bone map, e.g. morph-only rigs)
        const dmHashTable64<uint32_t>* bone_indices = instance->m_BoneIndices;
        uint32_t track_count = animation->m_Tracks.m_Count;
        if (bone_indices)
        {
            for (uint32_t ti = 0; ti < track_count; ++ti)
            {
                const dmRigDDF::AnimationTrack* track = &animation->m_Tracks[ti];

                const uint32_t* bone_index = bone_indices->Get(track->m_BoneId);
                if (!bone_index || *bone_index >= pose.Size()) {
                    continue;
                }
                dmTransform::Transform& transform = pose[*bone_index].m_Local;

                if (track->m_Positions.m_Count > 0)
                {
                    Vector3 v;
                    if (track->m_Positions.m_Count == 3)
                        v = Vector3(track->m_Positions.m_Data[0], track->m_Positions.m_Data[1], track->m_Positions.m_Data[2]);
                    else
                        v = SampleVec3(sample, fraction, track->m_Positions.m_Data);

                    transform.SetTranslation(lerp(blend_weight, transform.GetTranslation(), v));
                }
                if (track->m_Rotations.m_Count > 0)
                {
                    Quat q;
                    if (track->m_Rotations.m_Count == 4)
                        q = Quat(track->m_Rotations.m_Data[0], track->m_Rotations.m_Data[1], track->m_Rotations.m_Data[2], track->m_Rotations.m_Data[3]);
                    else
                        q = SampleQuat(sample, fraction, track->m_Rotations.m_Data);

                    transform.SetRotation(slerp(blend_weight, transform.GetRotation(), q));
                }
                if (track->m_Scale.m_Count > 0)
                {
                    Vector3 s;
                    if (track->m_Scale.m_Count == 3)
                        s = Vector3(track->m_Scale.m_Data[0], track->m_Scale.m_Data[1], track->m_Scale.m_Data[2]);
                    else
                        s = SampleVec3(sample, fraction, track->m_Scale.m_Data);

                    transform.SetScale(lerp(blend_weight, transform.GetScale(), s));
                }
            }
        }