TSkeletonInstance Class Reference

#include <TSkeleton.h>

Classes
struct	BoneCache

Public Member Functions
	TSkeletonInstance ()
	~TSkeletonInstance ()
TAnimation *	AddAnimation (TUINT16 a_iSequenceIndex, TFLOAT a_fDestWeight, TFLOAT a_fBlendInSpeed)
TAnimation *	AddAnimationFull (TUINT16 a_iSequenceIndex, TFLOAT a_fDestWeight, TFLOAT a_fBlendInSpeed, TFLOAT a_fBlendOutSpeed, TAnimation::Flags a_eFlags)
TAnimation *	GetAnimation (TUINT16 a_iSeqId)
void	RemoveAnimation (TAnimation *a_pAnimation, TFLOAT a_fBlendOutSpeed)
void	RemoveAllAnimations ()
void	UpdateTime (TFLOAT a_fDeltaTime)
void	UpdateState (TBOOL a_bForceUpdate)
const TMatrix44 &	GetBoneTransformCurrent (TINT a_iBone)
TMatrix44 &	GetBoneTransformCurrent (TINT a_iBone, TMatrix44 &a_rOutTransform)
void	SetStateFromBasePose ()
void	Delete ()
TSkeleton *	GetSkeleton ()
const TSkeletonInstanceBone *	GetBones ()
const TSkeletonInstanceBone &	GetBone (TINT a_uiIndex)

Public Attributes
friend	TSkeleton

Static Public Attributes
static TMatrix44	g_aForwardMatrices [TANIMATION_MAXBONES]
static BoneCache	g_aBonesCaches [TANIMATION_MAXBONES]

Detailed Description

Definition at line 185 of file TSkeleton.h.

Constructor & Destructor Documentation

TSkeletonInstance()

TSkeletonInstance::TSkeletonInstance

(

)

Definition at line 551 of file TSkeleton.cpp.

{
}

~TSkeletonInstance()

TSkeletonInstance::~TSkeletonInstance

(

)

Definition at line 410 of file TSkeleton.cpp.

{
    m_pSkeleton->m_iInstanceCount--;
}

Member Function Documentation

AddAnimation()

TAnimation * TSkeletonInstance::AddAnimation	(	TUINT16	a_iSequenceIndex,
		TFLOAT	a_fDestWeight,
		TFLOAT	a_fBlendInSpeed )

Definition at line 540 of file TSkeleton.cpp.

{
    return AddAnimationFull( a_iSequenceIndex, a_fDestWeight, a_fBlendInSpeed, 0.0f, 0 );
}

AddAnimationFull()

TAnimation * TSkeletonInstance::AddAnimationFull	(	TUINT16	a_iSequenceIndex,
		TFLOAT	a_fDestWeight,
		TFLOAT	a_fBlendInSpeed,
		TFLOAT	a_fBlendOutSpeed,
		TAnimation::Flags	a_eFlags )

Definition at line 434 of file TSkeleton.cpp.

{
    if ( m_pSkeleton->GetSequenceCount() <= a_iSequenceIndex )
        return TNULL;
 
    TAnimation* pAnimation = TNULL;
 
    // Check if this animation is already playing as a base animation
    for ( auto it = m_BaseAnimations.Begin(); pAnimation != TNULL && it != m_BaseAnimations.End(); ++it )
    {
        if ( it->GetSequence() == a_iSequenceIndex )
            pAnimation = it;
    }
 
    // Check if this animation is already playing as an overlay animation
    for ( auto it = m_BaseAnimations.Begin(); pAnimation != TNULL && it != m_BaseAnimations.End(); ++it )
    {
        if ( it->GetSequence() == a_iSequenceIndex )
            pAnimation = it;
    }
 
    const TBOOL bIsNewAnim = pAnimation == TNULL;
 
    if ( bIsNewAnim )
    {
        // Get a free animation from the list
        pAnimation = m_FreeAnimations.IsEmpty() ? TNULL : m_FreeAnimations.Begin();
 
        // If the free list is empty, replace the most unimportant animation with it
        if ( !pAnimation )
        {
            TQList<TAnimation>* pIterateList = &m_BaseAnimations;
 
            // If no base animations are currently playing, get one from the overlay animations list
            if ( m_BaseAnimations.IsEmpty() )
                pIterateList = &m_OverlayAnimations;
 
            TASSERT( !pIterateList->IsEmpty() );
            pAnimation = pIterateList->Begin();
 
            // Find an animation that has the most least weight
            for ( auto it = pIterateList->Begin().Next(); it != pIterateList->End(); it++ )
            {
                if ( it->GetWeight() < pAnimation->GetWeight() )
                    pAnimation = it;
            }
 
            // Instantly remove the animation
            if ( TSkeletonInstance* pSkeletonInstance = pAnimation->GetSkeletonInstance() )
                pSkeletonInstance->RemoveAnimation( pAnimation, 0.0f );
        }
 
        // Remove animation from any list
        pAnimation->TQList<TAnimation>::TNode::Remove();
 
        if ( m_pSkeleton->GetSequence( a_iSequenceIndex )->IsBase() )
        {
            // Base Animation
            m_BaseAnimations.PushFront( pAnimation );
            m_iBaseAnimationCount++;
        }
        else
        {
            // Overlay Animation
            m_OverlayAnimations.PushFront( pAnimation );
            m_iOverlayAnimationCount++;
        }
    }
 
    // Clamp values
    TMath::Clip( a_fDestWeight, 0.0f, 1.0f );
 
    // Setup animation
    TVALIDPTR( pAnimation );
    pAnimation->m_iSeqID = a_iSequenceIndex;
    pAnimation->m_eFlags = a_eFlags | TAnimation::Flags_Active;
    pAnimation->m_iUnk3  = 0;
    pAnimation->m_fSpeed = 1.0f;
 
    if ( bIsNewAnim ) pAnimation->m_fWeight = 0.0f;
    TMath::Clip( pAnimation->m_fWeight, 0.0f, 1.0f );
 
    pAnimation->m_fBlendOutSpeed = a_fBlendOutSpeed;
    pAnimation->m_fDestWeight    = a_fDestWeight;
    pAnimation->m_fTotalTime     = 0.0f;
    pAnimation->m_fSeqTime       = 0.0f;
    pAnimation->m_fBlendInSpeed  = a_fBlendInSpeed;
 
    if ( a_fBlendInSpeed <= 0.0f )
    {
        pAnimation->m_fWeight = a_fDestWeight;
        pAnimation->m_eState  = TAnimation::STATE_PLAYING;
    }
    else
    {
        pAnimation->m_eState = TAnimation::STATE_BLENDING_IN;
    }
 
    // Clear auto bones data
    TUtil::MemSet( pAnimation->GetBones(), 0, m_pSkeleton->GetAutoBoneCount() * sizeof( TAnimationBone ) );
 
    pAnimation->m_pSkeletonInstance = this;
    return pAnimation;
}

Delete()

void TSkeletonInstance::Delete

(

)

Definition at line 395 of file TSkeleton.cpp.

{
    delete this;
}

GetAnimation()

TAnimation * TSkeletonInstance::GetAnimation

(

TUINT16

a_iSeqId

)

Definition at line 416 of file TSkeleton.cpp.

{
    T2_FOREACH( m_BaseAnimations, it )
    {
        if ( it->GetSequence() == a_iSeqId )
            return it;
    }
 
    T2_FOREACH( m_OverlayAnimations, it )
    {
        if ( it->GetSequence() == a_iSeqId )
            return it;
    }
 
    return TNULL;
}

GetBone()

const TSkeletonInstanceBone & TSkeletonInstance::GetBone

(

TINT

a_uiIndex

)

Definition at line 545 of file TSkeleton.cpp.

{
    TASSERT( a_uiIndex < m_pSkeleton->GetAutoBoneCount() );
    return m_pBones[ a_uiIndex ];
}

GetBones()

const TSkeletonInstanceBone * TSkeletonInstance::GetBones ( )

inline

Definition at line 217 of file TSkeleton.h.

{ return m_pBones; }

GetBoneTransformCurrent() [1/2]

const TMatrix44 & TSkeletonInstance::GetBoneTransformCurrent

(

TINT

a_iBone

)

Definition at line 339 of file TSkeleton.cpp.

{
    static TMatrix44 s_Transform;
 
    GetBoneTransformCurrent( a_iBone, s_Transform );
    return s_Transform;
}

GetBoneTransformCurrent() [2/2]

TMatrix44 & TSkeletonInstance::GetBoneTransformCurrent	(	TINT	a_iBone,
		TMatrix44 &	a_rOutTransform )

Definition at line 323 of file TSkeleton.cpp.

{
    if ( a_iBone < m_pSkeleton->GetAutoBoneCount() )
    {
        auto pBone = m_pSkeleton->GetBone( a_iBone );
        a_rOutTransform.Multiply( m_pBones[ a_iBone ].m_Transform, pBone->GetTransform() );
 
        return a_rOutTransform;
    }
 
    a_rOutTransform = m_pSkeleton->GetBone( a_iBone )->GetTransform();
 
    return a_rOutTransform;
}

GetSkeleton()

TSkeleton * TSkeletonInstance::GetSkeleton ( )

inline

Definition at line 216 of file TSkeleton.h.

{ return m_pSkeleton; }

RemoveAllAnimations()

void TSkeletonInstance::RemoveAllAnimations

(

)

Definition at line 401 of file TSkeleton.cpp.

{
    while ( !m_BaseAnimations.IsEmpty() )
        RemoveAnimation( m_BaseAnimations.Begin(), 0.0f );
 
    while ( !m_OverlayAnimations.IsEmpty() )
        RemoveAnimation( m_OverlayAnimations.Begin(), 0.0f );
}

RemoveAnimation()

void TSkeletonInstance::RemoveAnimation	(	TAnimation *	a_pAnimation,
		TFLOAT	a_fBlendOutSpeed )

Definition at line 348 of file TSkeleton.cpp.

{
    if ( !a_pAnimation )
        return;
 
    TASSERT( TTRUE == a_pAnimation->IsActive() );
 
    if ( a_fBlendOutSpeed > 0.0f )
    {
        a_pAnimation->m_fDestWeight    = 0.0f;
        a_pAnimation->m_fBlendOutSpeed = a_fBlendOutSpeed;
        a_pAnimation->m_eState         = TAnimation::STATE_BLENDING_OUT;
    }
    else if ( a_pAnimation->m_eFlags & TAnimation::Flags_UpdateStateOnRemove )
    {
        a_pAnimation->m_eFlags &= ~TAnimation::Flags_UpdateStateOnRemove;
        a_pAnimation->m_fDestWeight    = 1.0f;
        a_pAnimation->m_fBlendOutSpeed = 1.0f;
        a_pAnimation->m_eState         = TAnimation::STATE_BLENDING_OUT;
        m_eFlags |= 1;
    }
    else
    {
        if ( a_pAnimation->GetSequencePtr()->IsOverlay() )
            m_iOverlayAnimationCount -= 1;
        else
            m_iBaseAnimationCount -= 1;
 
        a_pAnimation->m_eFlags = TAnimation::Flags_None;
 
        // Unlink the animation and add it to the list of free animations
        a_pAnimation->Remove();
        m_FreeAnimations.PushFront( a_pAnimation );
    }
}

SetStateFromBasePose()

void TSkeletonInstance::SetStateFromBasePose

(

)

Definition at line 385 of file TSkeleton.cpp.

{
    for ( TINT i = 0; i < m_pSkeleton->GetAutoBoneCount(); i++ )
    {
        m_pBones[ i ].m_Rotation = m_pSkeleton->GetBone( i )->GetRotation();
        m_pBones[ i ].m_Position = m_pSkeleton->GetBone( i )->GetPosition();
        m_pBones[ i ].m_Transform.Identity();
    }
}

UpdateState()

void TSkeletonInstance::UpdateState

(

TBOOL

a_bForceUpdate

)

Definition at line 148 of file TSkeleton.cpp.

{
    if ( ( a_bForceUpdate || m_iLastUpdateStateFrame != g_oSystemManager.GetFrameCount() ) &&
         m_pSkeleton->GetKeyLibraryInstance().GetLibrary() != TNULL )
    {
        m_iLastUpdateStateFrame = g_oSystemManager.GetFrameCount();
 
        const auto QInterpFn           = m_pSkeleton->GetQInterpFn();
        TFLOAT     fOneOverTotalWeight = 1.0f;
 
        if ( 1.0f < m_fTotalWeight )
            fOneOverTotalWeight = 1.0f / m_fTotalWeight;
 
        TASSERT( m_pSkeleton->GetAutoBoneCount() < TANIMATION_MAXBONES );
 
        for ( TINT i = 0; i < m_pSkeleton->GetAutoBoneCount(); i++ )
        {
            TASSERT( i < TANIMATION_MAXBONES );
 
            auto& rBoneCache = g_aBonesCaches[ i ];
            auto  pBone      = m_pSkeleton->GetBone( i );
 
            if ( m_BaseAnimations.IsEmpty() )
            {
                rBoneCache.Rotation = pBone->GetRotation();
                rBoneCache.Position = pBone->GetPosition();
            }
            else
            {
                TFLOAT fWeightTotalRatio = 0.0f;
                TBOOL  bBoneHasState     = TFALSE;
 
                T2_FOREACH( m_BaseAnimations, it )
                {
                    auto pSeq     = m_pSkeleton->GetSequence( it->GetSequence() );
                    auto pSeqBone = pSeq->GetBone( i );
 
                    TINT iCurrentKeyframePos = TINT( ( it->GetSeqTime() / pSeq->GetDuration() ) * 65535 );
 
                    TUINT16 iLerpFromIndex;
                    TUINT16 iLerpToIndex;
                    TFLOAT  fLerpProgress = pSeqBone->GetKeyPair( iCurrentKeyframePos, *it->GetBone( i ), iLerpFromIndex, iLerpToIndex );
 
                    TFLOAT fWeightRatio = it->GetWeight() * fOneOverTotalWeight;
 
                    if ( fWeightRatio > 0.0f && pSeqBone->GetKeyCount() != 0 )
                    {
                        auto pFromKey = pSeqBone->GetKey( iLerpFromIndex );
                        auto pToKey   = pSeqBone->GetKey( iLerpToIndex );
 
                        auto& rKeyLibrary = m_pSkeleton->GetKeyLibraryInstance();
                        auto  pFromQuat   = rKeyLibrary.GetQ( pFromKey[ 1 ] );
                        auto  pToQuat     = rKeyLibrary.GetQ( pToKey[ 1 ] );
 
                        if ( it == m_BaseAnimations.Head() )
                        {
                            bBoneHasState     = TTRUE;
                            fWeightTotalRatio = fWeightRatio;
                            QInterpFn( rBoneCache.Rotation, *pFromQuat, *pToQuat, fLerpProgress );
 
                            if ( pSeqBone->IsTranslateAnimated() )
                            {
                                auto pFromTranslation = rKeyLibrary.GetT( pFromKey[ 2 ] );
                                auto pToTranslation   = rKeyLibrary.GetT( pToKey[ 2 ] );
 
                                rBoneCache.Position.Lerp( *pFromTranslation, *pToTranslation, fLerpProgress );
                            }
                            else
                            {
                                rBoneCache.Position = pBone->GetPosition();
                            }
                        }
                        else
                        {
                            TVector4    position;
                            TQuaternion rotation;
 
                            QInterpFn( rotation, *pFromQuat, *pToQuat, fLerpProgress );
 
                            if ( pSeqBone->IsTranslateAnimated() )
                            {
                                auto pFromTranslation = rKeyLibrary.GetT( pFromKey[ 2 ] );
                                auto pToTranslation   = rKeyLibrary.GetT( pToKey[ 2 ] );
 
                                position.Lerp3( *pFromTranslation, *pToTranslation, fLerpProgress );
                            }
 
                            fWeightTotalRatio += fWeightRatio;
                            QInterpFn( rBoneCache.Rotation, rBoneCache.Rotation, rotation, fWeightRatio / fWeightTotalRatio );
 
                            const TVector3* pLerpToVec = pSeqBone->IsTranslateAnimated() ? &position.AsVector3() : &pBone->GetPosition();
                            rBoneCache.Position.Lerp( *pLerpToVec, fWeightRatio / fWeightTotalRatio );
                        }
                    }
                }
 
                if ( !bBoneHasState )
                {
                    rBoneCache.Rotation = pBone->GetRotation();
                    rBoneCache.Position = pBone->GetPosition();
                }
            }
 
            T2_FOREACH( m_OverlayAnimations, it )
            {
                if ( it->GetWeight() != 0.0f )
                {
                    auto pSeq     = m_pSkeleton->GetSequence( it->GetSequence() );
                    auto pSeqBone = pSeq->GetBone( i );
 
                    if ( !pSeqBone->IsOverlayAnimated() && pSeqBone->GetKeyCount() != 0 )
                    {
                        TINT iCurrentKeyframePos = TINT( ( it->GetSeqTime() / pSeq->GetDuration() ) * 65535 );
 
                        TUINT16 iLerpFromIndex;
                        TUINT16 iLerpToIndex;
                        TFLOAT  fLerpProgress = pSeqBone->GetKeyPair( iCurrentKeyframePos, *it->GetBone( i ), iLerpFromIndex, iLerpToIndex );
 
                        auto pFromKey = pSeqBone->GetKey( iLerpFromIndex );
                        auto pToKey   = pSeqBone->GetKey( iLerpToIndex );
 
                        auto& rKeyLibrary = m_pSkeleton->GetKeyLibraryInstance();
                        auto  pFromQuat   = rKeyLibrary.GetQ( pFromKey[ 1 ] );
                        auto  pToQuat     = rKeyLibrary.GetQ( pToKey[ 1 ] );
 
                        TVector4    position;
                        TQuaternion rotation;
 
                        QInterpFn( rotation, rBoneCache.Rotation, *pToQuat, fLerpProgress );
                        QInterpFn( rBoneCache.Rotation, rBoneCache.Rotation, rotation, it->GetWeight() );
 
                        const TVector3* pLerpToVec;
                        if ( pSeqBone->IsTranslateAnimated() )
                        {
                            auto pFromTranslation = rKeyLibrary.GetT( pFromKey[ 2 ] );
                            auto pToTranslation   = rKeyLibrary.GetT( pToKey[ 2 ] );
 
                            position.Lerp3( *pFromTranslation, *pToTranslation, fLerpProgress );
                            pLerpToVec = &position.AsVector3();
                        }
                        else
                        {
                            pLerpToVec = &pBone->GetPosition();
                        }
 
                        rBoneCache.Position.Lerp( *pLerpToVec, it->GetWeight() );
                    }
                }
            }
 
            // Save the transform
            auto& rMatrix     = g_aForwardMatrices[ i ];
            auto  iParentBone = pBone->GetParentBone();
 
            if ( iParentBone == TBONE_INVALID )
            {
                // No parent bone
                rMatrix.SetFromQuaternion( rBoneCache.Rotation );
                rMatrix.SetTranslation( rBoneCache.Position );
            }
            else
            {
                // Has parent bone
                TMatrix44 boneTransform;
                boneTransform.SetFromQuaternion( rBoneCache.Rotation );
                boneTransform.SetTranslation( rBoneCache.Position );
                rMatrix.Multiply( g_aForwardMatrices[ iParentBone ], boneTransform );
            }
 
            m_pBones[ i ].m_Transform.Multiply( rMatrix, pBone->GetTransformInv() );
        }
    }
}

UpdateTime()

void TSkeletonInstance::UpdateTime

(

TFLOAT

a_fDeltaTime

)

Definition at line 116 of file TSkeleton.cpp.

{
    if ( !m_BaseAnimations.IsEmpty() || ( !m_OverlayAnimations.IsEmpty() && m_iLastUpdateTimeFrame != g_oSystemManager.GetFrameCount() ) )
    {
        m_iLastUpdateTimeFrame = g_oSystemManager.GetFrameCount();
        m_fTotalWeight         = 0.0f;
 
        // Update base animations
        T2_FOREACH( m_BaseAnimations, pAnim )
        {
            if ( pAnim->UpdateTime( a_fDeltaTime ) )
            {
                m_fTotalWeight += pAnim->GetWeight();
            }
        }
 
        // Update overlay animations
        T2_FOREACH( m_OverlayAnimations, pAnim )
        {
            pAnim->UpdateTime( a_fDeltaTime );
        }
 
        if ( HASANYFLAG( m_eFlags, 1 ) )
        {
            m_eFlags &= ~1;
            UpdateState( TFALSE );
        }
    }
}

Member Data Documentation

g_aBonesCaches

BoneCache TSkeletonInstance::g_aBonesCaches[TANIMATION_MAXBONES]

inlinestatic

Definition at line 222 of file TSkeleton.h.

g_aForwardMatrices

TMatrix44 TSkeletonInstance::g_aForwardMatrices[TANIMATION_MAXBONES]

inlinestatic

Definition at line 221 of file TSkeleton.h.

TSkeleton

friend TSkeletonInstance::TSkeleton

Definition at line 194 of file TSkeleton.h.

---

The documentation for this class was generated from the following files:

• D:/_dev/OpenBarnyard/Source/Toshi/Source/Render/TSkeleton.h
• D:/_dev/OpenBarnyard/Source/Toshi/Source/Render/TSkeleton.cpp