Paranoia2/game_shared/bone_setup.cpp

2381 lines
69 KiB
C++
Raw Normal View History

2020-08-31 18:50:41 +02:00
/*
bone_setup.cpp - shared code for setup studio bones
This file is part of XashNT engine
Copyright (C) 2015 Uncle Mike
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*/
#include "mathlib.h"
#include "const.h"
#include <studio.h>
#include "com_model.h"
#include "stringlib.h"
#include "bs_defs.h"
#include "ikcontext.h"
#include "iksolver.h"
//-----------------------------------------------------------------------------
// Purpose: return a sub frame rotation for a single bone
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: ExtractAnimValue( int frame, const mstudioanimvalue_t *panimvalue, float scale, float &v1, float &v2 )
{
if( !panimvalue )
{
v1 = v2 = 0.0f;
return;
}
// avoids a crash reading off the end of the data
// g-cont. this solution is coming from Source 2007 and has no changes in Source 2013
if(( panimvalue->num.total == 1 ) && ( panimvalue->num.valid == 1 ))
{
v1 = v2 = panimvalue[1].value * scale;
return;
}
int k = frame;
// find the data list that has the frame
while( panimvalue->num.total <= k )
{
k -= panimvalue->num.total;
panimvalue += panimvalue->num.valid + 1;
if( panimvalue->num.total == 0 )
{
debugMsg( "^3Error:^7 ExtractAnimValue: num.total == 0!\n" );
v1 = v2 = 0.0f;
return;
}
}
// Bah, missing blend!
if( panimvalue->num.valid > k )
{
// has valid animation data
v1 = panimvalue[k+1].value * scale;
if( panimvalue->num.valid > k + 1 )
{
// has valid animation blend data
v2 = panimvalue[k+2].value * scale;
}
else
{
if( panimvalue->num.total > k + 1 ) v2 = v1; // data repeats, no blend
else v2 = panimvalue[panimvalue->num.valid+2].value * scale; // pull blend from first data block in next list
}
}
else
{
// get last valid data block
v1 = panimvalue[panimvalue->num.valid].value * scale;
if( panimvalue->num.total > k + 1 ) v2 = v1; // data repeats, no blend
else v2 = panimvalue[panimvalue->num.valid + 2].value * scale; // pull blend from first data block in next list
}
}
//-----------------------------------------------------------------------------
// Purpose: return a sub frame rotation for a single bone (usefully to decompress IK errors)
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: ExtractAnimValue( int frame, const mstudioanimvalue_t *panimvalue, float scale, float &v1 )
{
if( !panimvalue )
{
v1 = 0.0f;
return;
}
int k = frame;
while( panimvalue->num.total <= k )
{
k -= panimvalue->num.total;
panimvalue += panimvalue->num.valid + 1;
if( panimvalue->num.total == 0 )
{
debugMsg( "^3Error:^7 ExtractAnimValue: num.total == 0!\n" );
v1 = 0.0f;
return;
}
}
// Bah, missing blend!
if( panimvalue->num.valid > k )
{
v1 = panimvalue[k+1].value * scale;
}
else
{
// get last valid data block
v1 = panimvalue[panimvalue->num.valid].value * scale;
}
}
void CStudioBoneSetup :: AdjustBoneAngles( mstudiobone_t *pbone, Radian &angles1, Radian &angles2 )
{
if( m_flBoneControllers == NULL )
return;
for( int j = 0; j < 3; j++ )
{
if( pbone->bonecontroller[j+3] != -1 )
{
angles1[j] += m_flBoneControllers[pbone->bonecontroller[j+3]];
angles2[j] += m_flBoneControllers[pbone->bonecontroller[j+3]];
}
}
}
void CStudioBoneSetup :: AdjustBoneOrigin( mstudiobone_t *pbone, Vector &origin )
{
if( m_flBoneControllers == NULL )
return;
for( int j = 0; j < 3; j++ )
{
if( pbone->bonecontroller[j] != -1 )
{
origin[j] += m_flBoneControllers[pbone->bonecontroller[j]];
}
}
}
Vector4D CStudioBoneSetup :: CalcBoneQuaternion( int frame, float s, int flags, mstudiobone_t *pbone, mstudioboneinfo_t *pinfo, mstudioanim_t *panim )
{
Radian angles1, angles2;
Vector4D q1, q2, q;
if( !FBitSet( m_pStudioHeader->flags, STUDIO_HAS_BONEINFO ))
pinfo = NULL;
if( s > 0.001f )
{
ExtractAnimValue( frame, pAnimvalue( panim, 3 ), pbone->scale[3], angles1.x, angles2.x );
ExtractAnimValue( frame, pAnimvalue( panim, 4 ), pbone->scale[4], angles1.y, angles2.y );
ExtractAnimValue( frame, pAnimvalue( panim, 5 ), pbone->scale[5], angles1.z, angles2.z );
if( !FBitSet( flags, STUDIO_DELTA ))
{
angles1.x = angles1.x + pbone->value[3];
angles1.y = angles1.y + pbone->value[4];
angles1.z = angles1.z + pbone->value[5];
angles2.x = angles2.x + pbone->value[3];
angles2.y = angles2.y + pbone->value[4];
angles2.z = angles2.z + pbone->value[5];
}
AdjustBoneAngles( pbone, angles1, angles2 );
if( angles1 != angles2 )
{
AngleQuaternion( angles1, q1 );
AngleQuaternion( angles2, q2 );
QuaternionBlend( q1, q2, s, q );
}
else AngleQuaternion( angles1, q );
}
else
{
ExtractAnimValue( frame, pAnimvalue( panim, 3 ), pbone->scale[3], angles1.x );
ExtractAnimValue( frame, pAnimvalue( panim, 4 ), pbone->scale[4], angles1.y );
ExtractAnimValue( frame, pAnimvalue( panim, 5 ), pbone->scale[5], angles1.z );
angles2 = g_radZero; // dummy
if( !FBitSet( flags, STUDIO_DELTA ))
{
angles1.x = angles1.x + pbone->value[3];
angles1.y = angles1.y + pbone->value[4];
angles1.z = angles1.z + pbone->value[5];
}
AdjustBoneAngles( pbone, angles1, angles2 );
AngleQuaternion( angles1, q );
}
// align to unified bone
if( !FBitSet( flags, STUDIO_DELTA ) && FBitSet( pbone->flags, BONE_FIXED_ALIGNMENT ) && ( pinfo != NULL ))
{
QuaternionAlign( pinfo->qAlignment, q, q );
}
return q;
}
//-----------------------------------------------------------------------------
// Purpose: return a sub frame position for a single bone
//-----------------------------------------------------------------------------
Vector CStudioBoneSetup :: CalcBonePosition( int frame, float s, int flags, mstudiobone_t *pbone, mstudioanim_t *panim )
{
Vector origin1, origin2;
Vector pos;
if( s > 0.001f )
{
ExtractAnimValue( frame, pAnimvalue( panim, 0 ), pbone->scale[0], origin1.x, origin2.x );
ExtractAnimValue( frame, pAnimvalue( panim, 1 ), pbone->scale[1], origin1.y, origin2.y );
ExtractAnimValue( frame, pAnimvalue( panim, 2 ), pbone->scale[2], origin1.z, origin2.z );
if( origin1 != origin2 )
{
InterpolateOrigin( origin1, origin2, pos, s );
}
else pos = origin1;
}
else
{
ExtractAnimValue( frame, pAnimvalue( panim, 0 ), pbone->scale[0], origin1.x );
ExtractAnimValue( frame, pAnimvalue( panim, 1 ), pbone->scale[1], origin1.y );
ExtractAnimValue( frame, pAnimvalue( panim, 2 ), pbone->scale[2], origin1.z );
pos = origin1;
}
if( !FBitSet( flags, STUDIO_DELTA ))
{
pos.x = pos.x + pbone->value[0];
pos.y = pos.y + pbone->value[1];
pos.z = pos.z + pbone->value[2];
}
AdjustBoneOrigin( pbone, pos );
return pos;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcIKError( const mstudioikerror_t *panim, int frame, float s, Vector &pos, Vector4D &q )
{
Radian angles1, angles2;
Vector origin1, origin2;
Vector4D q1, q2;
if( s > 0.0001f )
{
ExtractAnimValue( frame, pAnimvalue( panim, 0 ), panim->scale[0], origin1.x, origin2.x );
ExtractAnimValue( frame, pAnimvalue( panim, 1 ), panim->scale[1], origin1.y, origin2.y );
ExtractAnimValue( frame, pAnimvalue( panim, 2 ), panim->scale[2], origin1.z, origin2.z );
if( origin1 != origin2 )
{
InterpolateOrigin( origin1, origin2, pos, s );
}
else pos = origin1;
ExtractAnimValue( frame, pAnimvalue( panim, 3 ), panim->scale[3], angles1.x, angles2.x );
ExtractAnimValue( frame, pAnimvalue( panim, 4 ), panim->scale[4], angles1.y, angles2.y );
ExtractAnimValue( frame, pAnimvalue( panim, 5 ), panim->scale[5], angles1.z, angles2.z );
if( angles1 != angles2 )
{
AngleQuaternion( angles1, q1 );
AngleQuaternion( angles2, q2 );
QuaternionBlend( q1, q2, s, q );
}
else AngleQuaternion( angles1, q );
}
else
{
ExtractAnimValue( frame, pAnimvalue( panim, 0 ), panim->scale[0], origin1.x );
ExtractAnimValue( frame, pAnimvalue( panim, 1 ), panim->scale[1], origin1.y );
ExtractAnimValue( frame, pAnimvalue( panim, 2 ), panim->scale[2], origin1.z );
pos = origin1;
ExtractAnimValue( frame, pAnimvalue( panim, 3 ), panim->scale[3], angles1.x );
ExtractAnimValue( frame, pAnimvalue( panim, 4 ), panim->scale[4], angles1.y );
ExtractAnimValue( frame, pAnimvalue( panim, 5 ), panim->scale[5], angles1.z );
AngleQuaternion( angles1, q );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
mstudioanim_t *CStudioBoneSetup :: GetAnimSourceData( mstudioseqdesc_t *pseqdesc )
{
mstudioseqgroup_t *pseqgroup = (mstudioseqgroup_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqgroupindex) + pseqdesc->seqgroup;
if( pseqdesc->seqgroup == 0 )
return (mstudioanim_t *)((byte *)m_pStudioHeader + pseqgroup->data + pseqdesc->animindex);
return NULL; // base implementation can't lookup for sequence groups
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
mstudioanim_t *CStudioBoneSetup :: FetchAnimation( mstudioseqdesc_t *pseqdesc, int animation )
{
mstudioanim_t *panim = (mstudioanim_t *)GetAnimSourceData( pseqdesc );
if( animation < 0 || animation > ( pseqdesc->numblends - 1 ))
return panim;
panim += animation * m_pStudioHeader->numbones;
return panim;
}
//-----------------------------------------------------------------------------
// Purpose: returns animation description. Notice: may return NULL
//-----------------------------------------------------------------------------
mstudioanimdesc_t *CStudioBoneSetup :: FetchAnimDesc( mstudioseqdesc_t *pseqdesc, int animation )
{
static mstudioanimdesc_t baseDesc; // for backward compatibility
if( pseqdesc->animdescindex <= 0 || pseqdesc->animdescindex >= m_pStudioHeader->length )
{
Q_strncpy( baseDesc.label, pseqdesc->label, sizeof( baseDesc.label ));
baseDesc.numframes = pseqdesc->numframes;
baseDesc.flags = pseqdesc->flags;
baseDesc.fps = pseqdesc->fps;
return &baseDesc;
}
mstudioanimdesc_t *panimdesc = (mstudioanimdesc_t *)((byte *)m_pStudioHeader + pseqdesc->animdescindex);
if( animation < 0 || animation > ( pseqdesc->numblends - 1 ))
return panimdesc; // pointer to first anim description
panimdesc += animation;
return panimdesc;
}
//-----------------------------------------------------------------------------
// Purpose: Find and decode a sub-frame of animation
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcAnimation( Vector pos[], Vector4D q[], mstudioseqdesc_t *pseqdesc, int animation, float cycle )
{
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
mstudioanimdesc_t *animdesc = FetchAnimDesc( pseqdesc, animation );
mstudioanim_t *panim = FetchAnimation( pseqdesc, animation );
mstudioboneinfo_t *pboneinfo = NULL;
if( FBitSet( m_pStudioHeader->flags, STUDIO_HAS_BONEINFO ))
pboneinfo = (mstudioboneinfo_t *)((byte *)pbone + m_pStudioHeader->numbones * sizeof( mstudiobone_t ));
float fFrame = cycle * (animdesc->numframes - 1);
int iFrame = (int)fFrame;
float s = (fFrame - iFrame); // cut fractional part
const float *pweight = pBoneweight( pseqdesc );
// BUGBUG: the sequence, the anim, and the model can have all different bone mappings.
for( int i = 0; i < m_pStudioHeader->numbones; i++, pbone++, pboneinfo++, panim++ )
{
if( pweight[i] <= 0.0f || !IsBoneUsed( pbone ))
continue;
q[i] = CalcBoneQuaternion( iFrame, s, animdesc->flags, pbone, pboneinfo, panim );
pos[i] = CalcBonePosition( iFrame, s, animdesc->flags, pbone, panim );
}
}
//-----------------------------------------------------------------------------
// Purpose: Inter-animation blend. Assumes both types are identical.
// blend together q1,pos1 with q2,pos2. Return result in q1,pos1.
// 0 returns q1, pos1. 1 returns q2, pos2
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: BlendBones( Vector4D q1[], Vector pos1[], mstudioseqdesc_t *pseqdesc, const Vector4D q2[], const Vector pos2[], float s )
{
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
const float *pweight = pBoneweight( pseqdesc );
int i;
if( s <= 0.0f )
{
return;
}
else if( s >= 1.0 )
{
for( i = 0; i < m_pStudioHeader->numbones; i++ )
{
if( pweight[i] <= 0.0f || !IsBoneUsed( pbone + i ))
continue;
pos1[i] = pos2[i];
q1[i] = q2[i];
}
return;
}
for( i = 0; i < m_pStudioHeader->numbones; i++ )
{
if( pweight[i] > 0.0f )
{
if( FBitSet( pbone[i].flags, BONE_FIXED_ALIGNMENT ))
QuaternionBlendNoAlign( q1[i], q2[i], s, q1[i] );
else QuaternionBlend( q1[i], q2[i], s, q1[i] );
InterpolateOrigin( pos1[i], pos2[i], pos1[i], s );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: blend together q1,pos1 with q2,pos2. Return result in q1,pos1.
// 0 returns q1, pos1. 1 returns q2, pos2
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: SlerpBones( Vector4D q1[], Vector pos1[], mstudioseqdesc_t *pseqdesc, const Vector4D q2[], const Vector pos2[], float s )
{
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
const float *pweight = pBoneweight( pseqdesc );
float s2;
if( s <= 0.0f )
{
return;
}
else if( s > 1.0f )
{
s = 1.0f;
}
if( FBitSet( pseqdesc->flags, STUDIO_WORLD ))
{
WorldSpaceSlerp( q1, pos1, pseqdesc, q2, pos2, s );
return;
}
if( FBitSet( pseqdesc->flags, STUDIO_DELTA ))
{
for( int i = 0; i < m_pStudioHeader->numbones; i++ )
{
// skip unused bones
if( !IsBoneUsed( pbone + i ))
continue;
s2 = s * pweight[i]; // blend in based on this bones weight
if( s2 <= 0.0f ) continue;
if( FBitSet( pseqdesc->flags, STUDIO_POST ))
{
QuaternionMA( q1[i], s2, q2[i], q1[i] );
// FIXME: are these correct?
pos1[i] = pos1[i] + pos2[i] * s2;
}
else
{
QuaternionSM( s2, q2[i], q1[i], q1[i] );
// FIXME: are these correct?
pos1[i] = pos1[i] + pos2[i] * s2;
}
}
}
else
{
for( int i = 0; i < m_pStudioHeader->numbones; i++ )
{
// skip unused bones
if( !IsBoneUsed( pbone + i ))
continue;
s2 = s * pweight[i]; // blend in based on this bones weight
if( s2 <= 0.0f ) continue;
if( FBitSet( pbone[i].flags, BONE_FIXED_ALIGNMENT ))
QuaternionSlerpNoAlign( q1[i], q2[i], s2, q1[i] );
else QuaternionSlerp( q1[i], q2[i], s2, q1[i] );
InterpolateOrigin( pos1[i], pos2[i], pos1[i], s2 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: blend together in world space q1,pos1 with q2,pos2. Return result in q1,pos1.
// 0 returns q1, pos1. 1 returns q2, pos2
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: WorldSpaceSlerp( Vector4D q1[], Vector pos1[], mstudioseqdesc_t *pseqdesc, const Vector4D q2[], const Vector pos2[], float s )
{
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
const float *pweight = pBoneweight( pseqdesc );
float s1; // weight of parent for q2, pos2
float s2; // weight for q2, pos2
// make fake root transform
matrix3x4 rootXform;
rootXform.Identity();
for( int i = 0; i < m_pStudioHeader->numbones; i++ )
{
// skip unused bones
if( !IsBoneUsed( pbone + i ))
continue;
int n = pbone[i].parent;
s1 = 0.0f;
s2 = s * pweight[i]; // blend in based on this bones weight
if( n != -1 ) s1 = s * pweight[n];
if( s1 == 1.0f && s2 == 1.0f )
{
pos1[i] = pos2[i];
q1[i] = q2[i];
}
else if( s2 > 0.0f )
{
Vector4D srcQ, dstQ;
Vector srcPos, dstPos;
Vector4D targetQ;
Vector targetPos;
BuildBoneChain( rootXform, pos1, q1, i, dstBoneToWorld );
BuildBoneChain( rootXform, pos2, q2, i, srcBoneToWorld );
srcQ = srcBoneToWorld[i].GetQuaternion();
dstQ = dstBoneToWorld[i].GetQuaternion();
srcPos = srcBoneToWorld[i].GetOrigin();
dstPos = dstBoneToWorld[i].GetOrigin();
QuaternionSlerp( dstQ, srcQ, s2, targetQ );
targetBoneToWorld[i] = matrix3x4( dstPos, targetQ );
// back solve
if( n == -1 )
{
q1[i] = targetBoneToWorld[i].GetQuaternion();
}
else
{
matrix3x4 worldToBone = targetBoneToWorld[n].Invert();
matrix3x4 local = worldToBone.ConcatTransforms( targetBoneToWorld[i] );
q1[i] = local.GetQuaternion();
// blend bone lengths (local space)
InterpolateOrigin( pos1[i], pos2[i], pos1[i], s2 );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: build boneToWorld transforms for a specific bone
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: BuildBoneChain( const matrix3x4 &rootxform, const Vector pos[], const Vector4D q[], int iBone, matrix3x4 *pBoneToWorld, byte *pBoneSet )
{
mstudiobone_t *pbones = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
matrix3x4 bonematrix = matrix3x4( pos[iBone], q[iBone] );
int iParent = pbones[iBone].parent;
if( pBoneSet && pBoneSet[iBone] )
return;
if( iParent == -1 )
{
pBoneToWorld[iBone] = rootxform.ConcatTransforms( bonematrix );
}
else
{
// evil recursive!!!
BuildBoneChain( rootxform, pos, q, iParent, pBoneToWorld, pBoneSet );
pBoneToWorld[iBone] = pBoneToWorld[iParent].ConcatTransforms( bonematrix );
}
if( pBoneSet ) pBoneSet[iBone] = 1;
}
//-----------------------------------------------------------------------------
// Purpose: turn a specific bones boneToWorld transform into a pos and q in parents bonespace
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: SolveBone( int iBone, matrix3x4 *pBoneToWorld, Vector pos[], Vector4D q[] )
{
mstudiobone_t *pbones = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
int iParent = pbones[iBone].parent;
matrix3x4 worldToBone = pBoneToWorld[iParent].Invert();
matrix3x4 local = worldToBone.ConcatTransforms( pBoneToWorld[iBone] );
q[iBone] = local.GetQuaternion();
pos[iBone] = local.GetOrigin();
}
//-----------------------------------------------------------------------------
// Purpose: for a 2 bone chain, find the IK solution and reset the matrices
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: SolveIK( const mstudioikchain_t *pikchain, Vector &targetFoot, matrix3x4 *pBoneToWorld )
{
const mstudioiklink_t *link0 = pIKLink( pikchain, 0 );
const mstudioiklink_t *link1 = pIKLink( pikchain, 1 );
const mstudioiklink_t *link2 = pIKLink( pikchain, 2 );
if( link0->kneeDir.LengthSqr() > 0.0f )
{
Vector targetKneeDir, targetKneePos;
// FIXME: knee length should be as long as the legs
targetKneeDir = pBoneToWorld[link0->bone].VectorRotate( link0->kneeDir );
targetKneePos = pBoneToWorld[link1->bone].GetOrigin();
return SolveIK( link0->bone, link1->bone, link2->bone, targetFoot, targetKneePos, targetKneeDir, pBoneToWorld );
}
return SolveIK( link0->bone, link1->bone, link2->bone, targetFoot, pBoneToWorld );
}
//-----------------------------------------------------------------------------
// Purpose: Solve Knee position for a known hip and foot location, but no specific knee direction preference
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: SolveIK( int iThigh, int iKnee, int iFoot, Vector &targetFoot, matrix3x4 *pBoneToWorld )
{
Vector worldFoot, worldKnee, worldThigh;
worldThigh = pBoneToWorld[iThigh].GetOrigin();
worldKnee = pBoneToWorld[iKnee].GetOrigin();
worldFoot = pBoneToWorld[iFoot].GetOrigin();
// debugLine( worldThigh, worldKnee, 0, 0, 255, true, 0 );
// debugLine( worldKnee, worldFoot, 0, 0, 255, true, 0 );
Vector ikFoot, ikKnee;
ikFoot = targetFoot - worldThigh;
ikKnee = worldKnee - worldThigh;
float l1 = (worldKnee - worldThigh).Length();
float l2 = (worldFoot - worldKnee).Length();
float l3 = (worldFoot - worldThigh).Length();
// leg too straight to figure out knee?
if( l3 > (l1 + l2) * KNEEMAX_EPSILON )
{
return false;
}
Vector ikHalf = (worldFoot-worldThigh) * (l1 / l3);
// FIXME: what to do when the knee completely straight?
Vector ikKneeDir = (ikKnee - ikHalf).Normalize();
return SolveIK( iThigh, iKnee, iFoot, targetFoot, worldKnee, ikKneeDir, pBoneToWorld );
}
//-----------------------------------------------------------------------------
// Purpose: Realign the matrix so that its X axis points along the desired axis.
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: AlignIKMatrix( matrix3x4 &mMat, const Vector &vAlignTo )
{
Vector tmp1, tmp2, tmp3;
// Column 0 (X) becomes the vector.
tmp1 = vAlignTo.Normalize();
mMat.SetForward( tmp1 );
// Column 1 (Y) is the cross of the vector and column 2 (Z).
tmp3 = mMat.GetUp();
tmp2 = CrossProduct( tmp3, tmp1 ).Normalize();
// FIXME: check for X being too near to Z
mMat.SetRight( tmp2 );
// Column 2 (Z) is the cross of columns 0 (X) and 1 (Y).
tmp3 = CrossProduct( tmp1, tmp2 );
mMat.SetUp( tmp3 );
}
//-----------------------------------------------------------------------------
// Purpose: Solve Knee position for a known hip and foot location, and a known knee direction
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: SolveIK( int iThigh, int iKnee, int iFoot, Vector &targetFoot, Vector &targetKneePos, Vector &targetKneeDir, matrix3x4 *pBoneToWorld )
{
Vector worldFoot, worldKnee, worldThigh;
worldThigh = pBoneToWorld[iThigh].GetOrigin();
worldKnee = pBoneToWorld[iKnee].GetOrigin();
worldFoot = pBoneToWorld[iFoot].GetOrigin();
// debugLine( worldThigh, worldKnee, 0, 0, 255, true, 0 );
// debugLine( worldThigh, worldThigh + targetKneeDir, 0, 0, 255, true, 0 );
// debugLine( worldKnee, targetKnee, 0, 0, 255, true, 0 );
Vector ikFoot, ikTargetKnee, ikKnee;
ikFoot = targetFoot - worldThigh;
ikKnee = targetKneePos - worldThigh;
float l1 = (worldKnee-worldThigh).Length();
float l2 = (worldFoot-worldKnee).Length();
// exaggerate knee targets for legs that are nearly straight
// FIXME: should be configurable, and the ikKnee should be from the original animation, not modifed
float d = (targetFoot - worldThigh).Length() - Q_min( l1, l2 );
d = Q_max( l1 + l2, d );
// FIXME: too short knee directions cause trouble
d = d * 100.0f;
ikTargetKnee = ikKnee + targetKneeDir * d;
// debugLine( worldKnee, worldThigh + ikTargetKnee, 0, 0, 255, true, 0 );
int color[3] = { 0, 255, 0 };
// too far away? (0.9998 is about 1 degree)
if( ikFoot.Length() > ( l1 + l2 ) * KNEEMAX_EPSILON )
{
ikFoot = ikFoot.Normalize();
ikFoot *= (l1 + l2) * KNEEMAX_EPSILON;
color[0] = 255; color[1] = 0; color[2] = 0;
}
// too close?
// limit distance to about an 80 degree knee bend
float minDist = Q_max( fabs( l1 - l2 ) * 1.15f, Q_min( l1, l2 ) * 0.15f );
if( ikFoot.Length() < minDist )
{
// too close to get an accurate vector, just use original vector
ikFoot = (worldFoot - worldThigh);
ikFoot = ikFoot.Normalize();
ikFoot *= minDist;
}
CIKSolver ik; // heart of all inverse kinematics
if( ik.solve( l1, l2, ikFoot, ikTargetKnee, ikKnee ))
{
matrix3x4& mWorldThigh = pBoneToWorld[iThigh];
matrix3x4& mWorldKnee = pBoneToWorld[iKnee];
matrix3x4& mWorldFoot = pBoneToWorld[iFoot];
// debugLine( worldThigh, ikKnee + worldThigh, 255, 0, 0, true, 0 );
// debugLine( ikKnee + worldThigh, ikFoot + worldThigh, 255, 0, 0, true,0 );
// debugLine( worldThigh, ikKnee + worldThigh, color[0], color[1], color[2], true, 0 );
// debugLine( ikKnee + worldThigh, ikFoot + worldThigh, color[0], color[1], color[2], true,0 );
// build transformation matrix for thigh
AlignIKMatrix( mWorldThigh, ikKnee );
AlignIKMatrix( mWorldKnee, ikFoot - ikKnee );
mWorldKnee[3][0] = ikKnee.x + worldThigh.x;
mWorldKnee[3][1] = ikKnee.y + worldThigh.y;
mWorldKnee[3][2] = ikKnee.z + worldThigh.z;
mWorldFoot[3][0] = ikFoot.x + worldThigh.x;
mWorldFoot[3][1] = ikFoot.y + worldThigh.y;
mWorldFoot[3][2] = ikFoot.z + worldThigh.z;
return true;
}
else
{
#if 0
debugLine( worldThigh, worldThigh + ikKnee, 255, 0, 0, true, 0 );
debugLine( worldThigh + ikKnee, worldThigh + ikFoot, 255, 0, 0, true, 0 );
debugLine( worldThigh + ikFoot, worldThigh, 255, 0, 0, true, 0 );
debugLine( worldThigh + ikKnee, worldThigh + ikTargetKnee, 255, 0, 0, true, 0 );
#endif
return false;
}
}
//-----------------------------------------------------------------------------
// Purpose: calculate a pose for a single sequence
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: InitPose( Vector pos[], Vector4D q[] )
{
mstudiobone_t *pbone = (mstudiobone_t *)((byte *)m_pStudioHeader + m_pStudioHeader->boneindex);
mstudioboneinfo_t *pboneinfo = (mstudioboneinfo_t *)((byte *)pbone + m_pStudioHeader->numbones * sizeof( mstudiobone_t ));
for( int i = 0; i < m_pStudioHeader->numbones; i++, pbone++ )
{
// skip unused bones
if( !IsBoneUsed( pbone + i ))
continue;
// check if we can use aligned quaternion instead of euler angles
if( FBitSet( m_pStudioHeader->flags, STUDIO_HAS_BONEINFO )) q[i] = pboneinfo[i].quat;
else AngleQuaternion( Radian( pbone->value[3], pbone->value[4], pbone->value[5] ), q[i] );
pos[i] = Vector( pbone->value ); // grab three first values
}
}
//-----------------------------------------------------------------------------
// Purpose: turn a 2x2 blend into a 3 way triangle blend
// Returns: returns the animination indices and barycentric coordinates of a triangle
// the triangle is a right triangle, and the diagonal is between elements [0] and [2]
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: Calc9WayBlendIndices( int i0, int i1, float s0, float s1, const mstudioseqdesc_t *pseqdesc, int *pAnimIndices, float *pWeight )
{
// figure out which bi-section direction we are using to make triangles.
bool bEven = ((( i0 + i1 ) & 0x1 ) == 0 );
int x1, y1;
int x2, y2;
int x3, y3;
// diagonal is between elements 1 & 3
if( bEven )
{
// TL to BR
if( s0 > s1 )
{
// B
x1 = 0; y1 = 0;
x2 = 1; y2 = 0;
x3 = 1; y3 = 1;
pWeight[0] = (1.0f - s0);
pWeight[1] = s0 - s1;
}
else
{
// C
x1 = 1; y1 = 1;
x2 = 0; y2 = 1;
x3 = 0; y3 = 0;
pWeight[0] = s0;
pWeight[1] = s1 - s0;
}
}
else
{
float flTotal = s0 + s1;
// BL to TR
if( flTotal > 1.0f )
{
// D
x1 = 1; y1 = 0;
x2 = 1; y2 = 1;
x3 = 0; y3 = 1;
pWeight[0] = (1.0f - s1);
pWeight[1] = s0 - 1.0f + s1;
}
else
{
// A
x1 = 0; y1 = 1;
x2 = 0; y2 = 0;
x3 = 1; y3 = 0;
pWeight[0] = s1;
pWeight[1] = 1.0f - s0 - s1;
}
}
pAnimIndices[0] = iAnimBlend( pseqdesc, i0 + x1, i1 + y1 );
pAnimIndices[1] = iAnimBlend( pseqdesc, i0 + x2, i1 + y2 );
pAnimIndices[2] = iAnimBlend( pseqdesc, i0 + x3, i1 + y3 );
// clamp the diagonal
if( pWeight[1] < 0.001f ) pWeight[1] = 0.0f;
pWeight[2] = 1.0f - pWeight[0] - pWeight[1];
}
//-----------------------------------------------------------------------------
// Purpose: Calculates default values for the pose parameters
// Output: fills in an array
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcDefaultPoseParameters( float flPoseParams[] )
{
int nPoseCount = CountPoseParameters();
for( int i = 0; i < MAXSTUDIOPOSEPARAM; i++ )
{
// default to middle of the pose parameter range
flPoseParams[i] = 0.5f;
if( i < nPoseCount )
{
const mstudioposeparamdesc_t *pPose = pPoseParameter( i );
// want to try for a zero state. If one doesn't exist set it to .5 by default.
if( pPose->start < 0.0f && pPose->end > 0.0f )
{
float flPoseDelta = pPose->end - pPose->start;
flPoseParams[i] = -pPose->start / flPoseDelta;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: resolve a global pose parameter to the specific setting for this sequence
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: LocalPoseParameter( mstudioseqdesc_t *pseqdesc, int iLocalIndex, float &flSetting, int &index )
{
// first check for traditional GoldSource blenders
if( !FBitSet( pseqdesc->flags, STUDIO_BLENDPOSE ))
{
flSetting = m_flPoseParams[iLocalIndex];
index = 0; // unused
return;
}
else
{
int iPose = pseqdesc->blendtype[iLocalIndex];
if( iPose == -1 )
{
flSetting = 0;
index = 0;
return;
}
const mstudioposeparamdesc_t *pPose = pPoseParameter( iPose );
if( pPose == NULL )
{
flSetting = 0;
index = 0;
return;
}
float flValue = m_flPoseParams[iPose];
if( pPose->loop )
{
float wrap = (pPose->start + pPose->end) / 2.0 + pPose->loop / 2.0;
float shift = pPose->loop - wrap;
flValue = flValue - pPose->loop * floor((flValue + shift) / pPose->loop);
}
if( pseqdesc->posekeyindex == 0 )
{
float flLocalStart = ((float)pseqdesc->blendstart[iLocalIndex] - pPose->start) / (pPose->end - pPose->start);
float flLocalEnd = ((float)pseqdesc->blendend[iLocalIndex] - pPose->start) / (pPose->end - pPose->start);
// convert into local range
flSetting = (flValue - flLocalStart) / (flLocalEnd - flLocalStart);
// clamp. This shouldn't ever need to happen if it's looping.
flSetting = bound( 0.0f, flSetting, 1.0f );
index = 0;
if( pseqdesc->groupsize[iLocalIndex] > 2 )
{
// estimate index
index = (int)(flSetting * (pseqdesc->groupsize[iLocalIndex] - 1));
if( index == pseqdesc->groupsize[iLocalIndex] - 1 )
index = pseqdesc->groupsize[iLocalIndex] - 2;
flSetting = flSetting * (pseqdesc->groupsize[iLocalIndex] - 1) - index;
}
}
else
{
flValue = flValue * (pPose->end - pPose->start) + pPose->start;
index = 0;
// FIXME: this shouldn't be a linear search
while( 1 )
{
flSetting = (flValue - flPoseKey( pseqdesc, iLocalIndex, index ));
flSetting /= (flPoseKey( pseqdesc, iLocalIndex, index + 1 ) - flPoseKey( pseqdesc, iLocalIndex, index ));
if( index < pseqdesc->groupsize[iLocalIndex] - 2 && flSetting > 1.0f )
{
index++;
continue;
}
break;
}
// clamp.
flSetting = bound( 0.0f, flSetting, 1.0f );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: returns array of animations and weightings for a sequence based on current pose parameters
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: LocalSeqAnims( int sequence, mstudioanimdesc_t *panim[4], float *weight )
{
if( !m_pStudioHeader || sequence < 0 || sequence >= m_pStudioHeader->numseq )
{
weight[0] = weight[1] = 0.0f;
weight[2] = weight[3] = 0.0f;
return;
}
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
float s0 = 0.0f, s1 = 0.0f;
int i0 = 0, i1 = 0;
LocalPoseParameter( pseqdesc, 0, s0, i0 );
LocalPoseParameter( pseqdesc, 1, s1, i1 );
panim[0] = FetchAnimDesc( pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+0 ));
weight[0] = (1.0f - s0) * (1.0f - s1);
panim[1] = FetchAnimDesc( pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+0 ));
weight[1] = (s0) * (1.0f - s1);
panim[2] = FetchAnimDesc( pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+1 ));
weight[2] = (1.0f - s0) * (s1);
panim[3] = FetchAnimDesc( pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+1 ));
weight[3] = (s0) * (s1);
}
//-----------------------------------------------------------------------------
// Purpose: returns max frame number for a sequence
//-----------------------------------------------------------------------------
int CStudioBoneSetup :: LocalMaxFrame( int sequence )
{
mstudioanimdesc_t *panim[4];
float weight[4];
float maxFrame = 0;
LocalSeqAnims( sequence, panim, weight );
for( int i = 0; i < 4; i++ )
{
if( weight[i] > 0.0f )
{
maxFrame += panim[i]->numframes * weight[i];
}
}
if( maxFrame > 1 )
maxFrame -= 1;
// FIXME: why does the weights sometimes not exactly add it 1.0 and this sometimes rounds down?
return (maxFrame + 0.01);
}
//-----------------------------------------------------------------------------
// Purpose: returns frames per second of a sequence
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: LocalFPS( int sequence )
{
mstudioanimdesc_t *panim[4];
float weight[4];
float t = 0.0f;
LocalSeqAnims( sequence, panim, weight );
for( int i = 0; i < 4; i++ )
{
if( weight[i] > 0.0f )
{
t += panim[i]->fps * weight[i];
}
}
return t;
}
//-----------------------------------------------------------------------------
// Purpose: returns cycles per second of a sequence (cycles/second)
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: LocalCPS( int sequence )
{
mstudioanimdesc_t *panim[4];
float weight[4];
float t = 0.0f;
LocalSeqAnims( sequence, panim, weight );
for( int i = 0; i < 4; i++ )
{
if( weight[i] > 0.0f && panim[i]->numframes > 1 )
{
t += (panim[i]->fps / (panim[i]->numframes - 1)) * weight[i];
}
}
return t;
}
//-----------------------------------------------------------------------------
// Purpose: converts a ranged bone controller value into a 0..1 encoded value
// Output: ctlValue contains 0..1 encoding.
// returns clamped ranged value
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: SetController( int iController, float flValue, float &ctlValue )
{
if( !m_pStudioHeader )
return flValue;
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)m_pStudioHeader + m_pStudioHeader->bonecontrollerindex);
// find first controller that matches the index
for( int i = 0; i < m_pStudioHeader->numbonecontrollers; i++, pbonecontroller++ )
{
if( pbonecontroller->index == iController )
break;
}
if( i >= m_pStudioHeader->numbonecontrollers )
{
ctlValue = 0.0f;
return flValue;
}
// wrap 0..360 if it's a rotational controller
if( FBitSet( pbonecontroller->type, STUDIO_XR|STUDIO_YR|STUDIO_ZR ))
{
// ugly hack, invert value if end < start
if( pbonecontroller->end < pbonecontroller->start )
flValue = -flValue;
// does the controller not wrap?
if( pbonecontroller->start + 359.0f >= pbonecontroller->end )
{
if( flValue > (( pbonecontroller->start + pbonecontroller->end) / 2.0f ) + 180.0f )
flValue = flValue - 360.0f;
if( flValue < (( pbonecontroller->start + pbonecontroller->end) / 2.0f ) - 180.0f )
flValue = flValue + 360.0f;
}
else
{
if( flValue > 360.0f )
flValue = flValue - (int)(flValue / 360.0f) * 360.0f;
else if( flValue < 0.0f )
flValue = flValue + (int)((flValue / -360.0f) + 1.0f) * 360.0f;
}
}
ctlValue = (flValue - pbonecontroller->start) / (pbonecontroller->end - pbonecontroller->start);
ctlValue = bound( 0.0f, ctlValue, 1.0f );
float flReturnVal = ((1.0f - ctlValue) * pbonecontroller->start + ctlValue * pbonecontroller->end);
// ugly hack, invert value if a rotational controller and end < start
if( FBitSet( pbonecontroller->type, STUDIO_XR | STUDIO_YR | STUDIO_ZR ) && pbonecontroller->end < pbonecontroller->start )
{
flReturnVal *= -1.0f;
}
return flReturnVal;
}
//-----------------------------------------------------------------------------
// Purpose: converts a 0..1 encoded bone controller value into a ranged value
// Output: returns ranged value
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: GetController( int iController, float ctlValue )
{
if( !m_pStudioHeader )
return 0.0f;
mstudiobonecontroller_t *pbonecontroller = (mstudiobonecontroller_t *)((byte *)m_pStudioHeader + m_pStudioHeader->bonecontrollerindex);
// find first controller that matches the index
for( int i = 0; i < m_pStudioHeader->numbonecontrollers; i++, pbonecontroller++ )
{
if( pbonecontroller->index == iController )
break;
}
if( i >= m_pStudioHeader->numbonecontrollers )
return 0.0f;
return ctlValue * (pbonecontroller->end - pbonecontroller->start) + pbonecontroller->start;
}
//-----------------------------------------------------------------------------
// Purpose: converts a ranged pose parameter value into a 0..1 encoded value
// Output: ctlValue contains 0..1 encoding.
// returns clamped ranged value
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: SetPoseParameter( int iParameter, float flValue, float &ctlValue )
{
if( iParameter < 0 || iParameter >= CountPoseParameters( ))
return 0.0f;
const mstudioposeparamdesc_t *pPose = pPoseParameter( iParameter );
if( pPose->loop )
{
float wrap = (pPose->start + pPose->end) / 2.0f + pPose->loop / 2.0f;
float shift = pPose->loop - wrap;
flValue = flValue - pPose->loop * floor(( flValue + shift ) / pPose->loop );
}
ctlValue = (flValue - pPose->start) / (pPose->end - pPose->start);
ctlValue = bound( 0.0f, ctlValue, 1.0f );
return ctlValue * (pPose->end - pPose->start) + pPose->start;
}
//-----------------------------------------------------------------------------
// Purpose: converts a 0..1 encoded pose parameter value into a ranged value
// Output: returns ranged value
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: GetPoseParameter( int iParameter, float ctlValue )
{
if( iParameter < 0 || iParameter >= CountPoseParameters( ))
return 0.0f;
const mstudioposeparamdesc_t *pPose = pPoseParameter( iParameter );
return ctlValue * (pPose->end - pPose->start) + pPose->start;
}
//-----------------------------------------------------------------------------
// Purpose: returns length (in seconds) of a sequence (seconds/cycle)
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: LocalDuration( int sequence )
{
mstudioanimdesc_t *panim[4];
float weight[4];
float t = 0.0f;
LocalSeqAnims( sequence, panim, weight );
for( int i = 0; i < 4; i++ )
{
if( weight[i] > 0 && panim[i]->fps != 0.0f )
{
t += ((panim[i]->numframes - 1) / panim[i]->fps) * weight[i];
}
}
return t;
}
//-----------------------------------------------------------------------------
// Purpose: calculate changes in position and angle relative to the start of an animations cycle
// Output: updated position and angle, relative to the origin
// returns false if animation is not a movement animation
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: AnimPosition( mstudioanimdesc_t *panim, float flCycle, Vector &vecPos, Vector &vecAngle )
{
float prevframe = 0;
int iLoops = 0;
vecPos.Init( );
vecAngle.Init( );
if( panim->nummovements == 0 )
return false;
if( flCycle > 1.0f )
iLoops = (int)flCycle;
else if( flCycle < 0.0f )
iLoops = (int)flCycle - 1;
flCycle = flCycle - iLoops;
float flFrame = flCycle * (panim->numframes - 1);
for( int i = 0; i < panim->nummovements; i++ )
{
const mstudiomovement_t *pmove = pMovement( panim, i );
if( pmove->endframe >= flFrame )
{
float f = (flFrame - prevframe) / (pmove->endframe - prevframe);
float d = pmove->v0 * f + 0.5 * (pmove->v1 - pmove->v0) * f * f;
vecPos = vecPos + d * pmove->vector;
vecAngle.y = vecAngle.y * (1.0f - f) + pmove->angle * f;
if( iLoops != 0 )
{
const mstudiomovement_t *pmove = pMovement( panim, panim->nummovements - 1 );
vecPos = vecPos + iLoops * pmove->position;
vecAngle.y = vecAngle.y + iLoops * pmove->angle;
}
return true;
}
else
{
prevframe = pmove->endframe;
vecPos = pmove->position;
vecAngle.y = pmove->angle;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: calculate instantaneous velocity in ips at a given point
// in the animations cycle
// Output: velocity vector, relative to identity orientation
// returns false if animation is not a movement animation
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: AnimVelocity( mstudioanimdesc_t *panim, float flCycle, Vector &vecVelocity )
{
float flFrame = flCycle * (panim->numframes - 1);
float prevframe = 0.0f;
flFrame = flFrame - (int)(flFrame / (panim->numframes - 1));
for( int i = 0; i < panim->nummovements; i++ )
{
const mstudiomovement_t *pmove = pMovement( panim, i );
if( pmove->endframe >= flFrame )
{
float f = (flFrame - prevframe) / (pmove->endframe - prevframe);
float vel = pmove->v0 * (1 - f) + pmove->v1 * f;
// scale from per block to per sec velocity
vel = vel * panim->fps / (pmove->endframe - prevframe);
vecVelocity = pmove->vector * vel;
return true;
}
else
{
prevframe = pmove->endframe;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: calculate changes in position and angle between two points in an animation cycle
// Output: updated position and angle, relative to CycleFrom being at the origin
// returns false if animation is not a movement animation
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: AnimMovement( mstudioanimdesc_t *panim, float flCycleFrom, float flCycleTo, Vector &deltaPos, Vector &deltaAngle )
{
if( panim->nummovements == 0 )
return false;
Vector startPos;
Vector startA;
AnimPosition( panim, flCycleFrom, startPos, startA );
Vector endPos;
Vector endA;
AnimPosition( panim, flCycleTo, endPos, endA );
Vector tmp = endPos - startPos;
deltaAngle.y = endA.y - startA.y;
deltaPos = VectorYawRotate( tmp, -startA.y );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: finds how much of an animation to play to move given linear distance
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: FindAnimDistance( mstudioanimdesc_t *panim, float flDist )
{
float prevframe = 0;
if( flDist <= 0 )
return 0.0;
for( int i = 0; i < panim->nummovements; i++ )
{
const mstudiomovement_t *pmove = pMovement( panim, i );
float flMove = (pmove->v0 + pmove->v1) * 0.5f;
if( flMove >= flDist )
{
float root1, root2;
// d = V0 * t + 1/2 (V1-V0) * t^2
if( SolveQuadratic( 0.5f * ( pmove->v1 - pmove->v0 ), pmove->v0, -flDist, root1, root2 ))
{
float cpf = 1.0f / (panim->numframes - 1); // cycles per frame
return (prevframe + root1 * (pmove->endframe - prevframe)) * cpf;
}
return 0.0f;
}
else
{
flDist -= flMove;
prevframe = pmove->endframe;
}
}
return 1.0f;
}
//-----------------------------------------------------------------------------
// Purpose: calculate changes in position and angle between two points in a sequences cycle
// Output: updated position and angle, relative to CycleFrom being at the origin
// returns false if sequence is not a movement sequence
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: SeqMovement( int sequence, float flCycleFrom, float flCycleTo, Vector &deltaPos, Vector &deltaAngles )
{
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
mstudioanimdesc_t *panim[4];
float weight[4];
LocalSeqAnims( sequence, panim, weight );
deltaPos = g_vecZero;
deltaAngles = g_vecZero;
bool found = false;
for( int i = 0; i < 4; i++ )
{
if( weight[i] )
{
Vector localPos = g_vecZero;
Vector localAngles = g_vecZero;
const float *pweight = pBoneweight( pseqdesc );
if( AnimMovement( panim[i], flCycleFrom, flCycleTo, localPos, localAngles ))
{
found = true;
deltaPos = deltaPos + localPos * weight[i];
// FIXME: this makes no sense
deltaAngles = deltaAngles + localAngles * weight[i];
}
else if( !FBitSet( panim[i]->flags, STUDIO_DELTA ) && panim[i]->nummovements == 0 && pweight[0] > 0.0f )
{
// found = true;
}
}
}
// simple movement from GoldSource
if( !found && pseqdesc->linearmovement != g_vecZero )
{
Vector startPos = pseqdesc->linearmovement * flCycleFrom;
Vector endPos = pseqdesc->linearmovement * flCycleTo;
deltaPos = endPos - startPos;
found = true;
}
return found;
}
//-----------------------------------------------------------------------------
// Purpose: calculate instantaneous velocity in ips at a given point in the sequence's cycle
// Output: velocity vector, relative to identity orientation
// returns false if sequence is not a movement sequence
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: SeqVelocity( int sequence, float flCycle, Vector &vecVelocity )
{
mstudioanimdesc_t *panim[4];
float weight[4];
LocalSeqAnims( sequence, panim, weight );
vecVelocity = g_vecZero;
bool found = false;
for( int i = 0; i < 4; i++ )
{
if( weight[i] )
{
Vector vecLocalVelocity;
if( AnimVelocity( panim[i], flCycle, vecLocalVelocity ))
{
vecVelocity = vecVelocity + vecLocalVelocity * weight[i];
found = true;
}
}
}
return found;
}
//-----------------------------------------------------------------------------
// Purpose: finds how much of an sequence to play to move given linear distance
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: FindSeqDistance( int sequence, float flDist )
{
mstudioanimdesc_t *panim[4];
float weight[4];
LocalSeqAnims( sequence, panim, weight );
float flCycle = 0;
for( int i = 0; i < 4; i++ )
{
if( weight[i] )
{
float flLocalCycle = FindAnimDistance( panim[i], flDist );
flCycle = flCycle + flLocalCycle * weight[i];
}
}
return flCycle;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: IKRuleWeight( const mstudioikrule_t *ikRule, const mstudioanimdesc_t *panim, float flCycle, int &iFrame, float &fraq )
{
if( ikRule->end > 1.0f && flCycle < ikRule->start )
{
flCycle = flCycle + 1.0f;
}
float value = 0.0f;
fraq = (panim->numframes - 1) * (flCycle - ikRule->start) + ikRule->iStart;
iFrame = (int)fraq;
fraq = fraq - iFrame;
if( flCycle < ikRule->start )
{
iFrame = ikRule->iStart;
fraq = 0.0f;
return 0.0f;
}
else if( flCycle < ikRule->peak )
{
value = ( flCycle - ikRule->start ) / ( ikRule->peak - ikRule->start );
}
else if( flCycle < ikRule->tail )
{
return 1.0f;
}
else if( flCycle < ikRule->end )
{
value = 1.0f - (( flCycle - ikRule->tail ) / ( ikRule->end - ikRule->tail ));
}
else
{
fraq = (panim->numframes - 1) * (ikRule->end - ikRule->start) + ikRule->iStart;
iFrame = (int)fraq;
fraq = fraq - iFrame;
}
return SimpleSpline( value );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: IKRuleWeight( ikcontextikrule_t *ikRule, float flCycle )
{
if( ikRule->end > 1.0f && flCycle < ikRule->start )
{
flCycle = flCycle + 1.0f;
}
float value = 0.0f;
if( flCycle < ikRule->start )
{
return 0.0f;
}
else if( flCycle < ikRule->peak )
{
value = ( flCycle - ikRule->start ) / ( ikRule->peak - ikRule->start );
}
else if( flCycle < ikRule->tail )
{
return 1.0f;
}
else if( flCycle < ikRule->end )
{
value = 1.0f - ((flCycle - ikRule->tail) / (ikRule->end - ikRule->tail));
}
return SimpleSpline( value );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: IKShouldLatch( ikcontextikrule_t *ikRule, float flCycle )
{
if( ikRule->end > 1.0f && flCycle < ikRule->start )
{
flCycle = flCycle + 1.0f;
}
if( flCycle < ikRule->peak )
{
return false;
}
else if( flCycle < ikRule->end )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
float CStudioBoneSetup :: IKTail( ikcontextikrule_t *ikRule, float flCycle )
{
if( ikRule->end > 1.0f && flCycle < ikRule->start )
{
flCycle = flCycle + 1.0f;
}
if( flCycle <= ikRule->tail )
{
return 0.0f;
}
else if( flCycle < ikRule->end )
{
return (( flCycle - ikRule->tail ) / ( ikRule->end - ikRule->tail ));
}
return 0.0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: IKAnimError( const mstudioikrule_t *pRule, mstudioanimdesc_t *panim, float flCycle, Vector &pos, Vector4D &q, float &flWeight )
{
float fraq;
int iFrame;
flWeight = IKRuleWeight( pRule, panim, flCycle, iFrame, fraq );
flWeight = bound( 0.0f, flWeight, 1.0f );
if( pRule->type != IK_GROUND && flWeight < 0.0001f )
return false;
const mstudioikerror_t *pError = pCompressedError( pRule );
if( pError != NULL )
{
CalcIKError( pError, iFrame - pRule->iStart, fraq, pos, q );
return true;
}
// no data, disable IK rule
flWeight = 0.0f;
return false;
}
//-----------------------------------------------------------------------------
// Purpose: For a specific sequence:rule, find where it starts, stops, and what
// the estimated offset from the connection point is.
// return true if the rule is within bounds.
//-----------------------------------------------------------------------------
bool CStudioBoneSetup :: IKSequenceError( int iSeq, float flCycle, int iRule, mstudioanimdesc_t *panim[4], float weight[4], ikcontextikrule_t *ikRule )
{
int i;
memset( ikRule, 0, sizeof( ikcontextikrule_t ));
ikRule->start = ikRule->peak = ikRule->tail = ikRule->end = 0;
const mstudioikrule_t *prevRule = NULL;
// find overall influence
for( i = 0; i < 4; i++ )
{
if( weight[i] )
{
if( iRule >= panim[i]->numikrules || panim[i]->numikrules != panim[0]->numikrules )
return false;
const mstudioikrule_t *pRule = pIKRule( panim[i], iRule );
if( pRule == NULL )
return false;
float dt = 0.0f;
if( prevRule != NULL )
{
if( pRule->start - prevRule->start > 0.5f )
{
dt = -1.0f;
}
else if( pRule->start - prevRule->start < -0.5f )
{
dt = 1.0;
}
}
else
{
prevRule = pRule;
}
ikRule->start += (pRule->start + dt) * weight[i];
ikRule->peak += (pRule->peak + dt) * weight[i];
ikRule->tail += (pRule->tail + dt) * weight[i];
ikRule->end += (pRule->end + dt) * weight[i];
}
}
if( ikRule->start > 1.0f )
{
ikRule->start -= 1.0f;
ikRule->peak -= 1.0f;
ikRule->tail -= 1.0f;
ikRule->end -= 1.0f;
}
else if( ikRule->start < 0.0f )
{
ikRule->start += 1.0f;
ikRule->peak += 1.0f;
ikRule->tail += 1.0f;
ikRule->end += 1.0f;
}
ikRule->flWeight = IKRuleWeight( ikRule, flCycle );
if( ikRule->flWeight <= 0.001f )
{
// go ahead and allow IK_GROUND rules a virtual looping section
if( pIKRule( panim[0], iRule ) == NULL )
return false;
if(( panim[0]->flags & STUDIO_LOOPING ) && pIKRule( panim[0], iRule )->type == IK_GROUND && ikRule->end - ikRule->start > 0.75f )
{
ikRule->flWeight = 0.001f;
flCycle = ikRule->end - 0.001f;
}
else
{
return false;
}
}
ikRule->pos.Init();
ikRule->q.Init();
// find target error
float total = 0.0f;
for( i = 0; i < 4; i++ )
{
if( weight[i] )
{
Vector pos1;
Vector4D q1;
float w;
const mstudioikrule_t *pRule = pIKRule( panim[i], iRule );
if( pRule == NULL )
return false;
ikRule->chain = pRule->chain; // FIXME: this is anim local
ikRule->bone = pRule->bone; // FIXME: this is anim local
ikRule->type = pRule->type;
ikRule->slot = pRule->slot;
ikRule->height += pRule->height * weight[i];
ikRule->floor += pRule->floor * weight[i];
ikRule->radius += pRule->radius * weight[i];
ikRule->drop += pRule->drop * weight[i];
ikRule->top += pRule->top * weight[i];
// keep track of tail condition
ikRule->release += IKTail( ikRule, flCycle ) * weight[i];
// only check rules with error values
switch( ikRule->type )
{
case IK_SELF:
case IK_WORLD:
case IK_GROUND:
case IK_ATTACHMENT:
if( IKAnimError( pRule, panim[i], flCycle, pos1, q1, w ))
{
ikRule->pos = ikRule->pos + pos1 * weight[i];
QuaternionAccumulate( ikRule->q, weight[i], q1, ikRule->q );
total += weight[i];
}
break;
default:
total += weight[i];
break;
}
ikRule->latched = IKShouldLatch( ikRule, flCycle ) * ikRule->flWeight;
if( ikRule->type == IK_ATTACHMENT )
{
ikRule->iAttachment = pRule->attachment;
}
}
}
if( total <= 0.0001f )
{
return false;
}
if( total < 0.999f )
{
QuaternionScale( ikRule->q, 1.0f / total, ikRule->q );
ikRule->pos *= ( 1.0f / total );
}
ikRule->q = ikRule->q.Normalize();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: calculate a pose for a single sequence
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcPoseSingle( Vector pos[], Vector4D q[], int sequence, float cycle )
{
static Vector pos2[MAXSTUDIOBONES];
static Vector4D q2[MAXSTUDIOBONES];
static Vector pos3[MAXSTUDIOBONES];
static Vector4D q3[MAXSTUDIOBONES];
static Vector pos4[MAXSTUDIOBONES];
static Vector4D q4[MAXSTUDIOBONES];
bool anim_4wayblend = true; // FIXME: get 9-way for gold-source
mstudioseqdesc_t *pseqdesc;
if( sequence < 0 || sequence >= m_pStudioHeader->numseq )
{
debugMsg( "^2Warning:^7 sequence %i/%i out of range for model %s\n", sequence, m_pStudioHeader->numseq, m_pStudioHeader->name );
sequence = 0;
}
pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
int i0 = 0, i1 = 0;
float s0 = 0, s1 = 0;
LocalPoseParameter( pseqdesc, 0, s0, i0 );
LocalPoseParameter( pseqdesc, 1, s1, i1 );
if( FBitSet( pseqdesc->flags, STUDIO_REALTIME ))
{
float cps = LocalCPS( sequence );
cycle = m_flTime * cps;
cycle = cycle - (int)cycle;
}
else if( FBitSet( pseqdesc->flags, STUDIO_CYCLEPOSE ))
{
int iPose = bound( 0, pseqdesc->cycleposeindex, MAXSTUDIOPOSEPARAM - 1 );
cycle = m_flPoseParams[iPose];
}
else if( cycle < 0.0f || cycle >= 1.0f )
{
if( FBitSet( pseqdesc->flags, STUDIO_LOOPING ))
{
cycle = cycle - (int)cycle;
if( cycle < 0.0f ) cycle += 1.0f;
}
else
{
cycle = bound( 0.0f, cycle, 1.0f );
}
}
// GoldSource blending
if( !FBitSet( pseqdesc->flags, STUDIO_BLENDPOSE ) && ( pseqdesc->numblends > 1 ))
{
if( pseqdesc->numblends == 9 )
{
// blending is 0 - 0.5 == Left to Middle, 0.5 to 1.0 == Middle to Right
if( s1 <= 0.5f )
{
// Scale 0-0.5 blending up to 0-1.0
s1 = ( s1 * 2.0f );
if( s0 <= 0.5f )
{
// Blending is 0-127 == Top to Middle, 128 to 255 == Middle to Bottom
s0 = ( s0 * 2.0f );
// need to blend 0 - 1 - 3 - 4
CalcAnimation( pos, q, pseqdesc, 0, cycle );
CalcAnimation( pos2, q2, pseqdesc, 1, cycle );
CalcAnimation( pos3, q3, pseqdesc, 3, cycle );
CalcAnimation( pos4, q4, pseqdesc, 4, cycle );
}
else
{
// Scale 0.5-1.0 blending up to 0.0-1.0
s0 = 2.0f * ( s0 - 0.5f );
// need to blend 3 - 4 - 6 - 7
CalcAnimation( pos, q, pseqdesc, 3, cycle );
CalcAnimation( pos2, q2, pseqdesc, 4, cycle );
CalcAnimation( pos3, q3, pseqdesc, 6, cycle );
CalcAnimation( pos4, q4, pseqdesc, 7, cycle );
}
}
else
{
// Scale 0.5-1.0 blending up to 0-1.0
s1 = 2.0f * ( s1 - 0.5f );
if ( s0 <= 0.5f )
{
// Blending is 0-0.5 == Top to Middle, 0.5 to 1.0 == Middle to Bottom
s0 = ( s0 * 2.0f );
// need to blend 1 - 2 - 4 - 5
CalcAnimation( pos, q, pseqdesc, 1, cycle );
CalcAnimation( pos2, q2, pseqdesc, 2, cycle );
CalcAnimation( pos3, q3, pseqdesc, 4, cycle );
CalcAnimation( pos4, q4, pseqdesc, 5, cycle );
}
else
{
// Scale 0.5-1.0 blending up to 0-1.0
s0 = 2.0 * ( s0 - 0.5 );
// need to blend 4 - 5 - 7 - 8
CalcAnimation( pos, q, pseqdesc, 4, cycle );
CalcAnimation( pos2, q2, pseqdesc, 5, cycle );
CalcAnimation( pos3, q3, pseqdesc, 7, cycle );
CalcAnimation( pos4, q4, pseqdesc, 8, cycle );
}
}
// Spherically interpolate the bones
SlerpBones( q, pos, pseqdesc, q2, pos2, s1 );
SlerpBones( q3, pos3, pseqdesc, q4, pos4, s1 );
SlerpBones( q, pos, pseqdesc, q3, pos3, s0 );
}
else
{
CalcAnimation( pos, q, pseqdesc, 0, cycle );
CalcAnimation( pos2, q2, pseqdesc, 1, cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s0 );
if( pseqdesc->numblends == 4 )
{
CalcAnimation( pos3, q3, pseqdesc, 2, cycle );
CalcAnimation( pos4, q4, pseqdesc, 3, cycle );
BlendBones( q3, pos3, pseqdesc, q4, pos4, s0 );
BlendBones( q, pos, pseqdesc, q3, pos3, s1 );
}
}
return;
}
if( s0 < 0.001f )
{
if( s1 < 0.001f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+0 ), cycle );
}
else if( s1 > 0.999f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+1 ), cycle );
}
else
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+0 ), cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+1 ), cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s1 );
}
}
else if( s0 > 0.999f )
{
if( s1 < 0.001f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+0 ), cycle );
}
else if( s1 > 0.999f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+1 ), cycle );
}
else
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+0 ), cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+1 ), cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s1 );
}
}
else
{
if( s1 < 0.001f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+0 ), cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+0 ), cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s0 );
}
else if( s1 > 0.999f )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+1 ), cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+1 ), cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s0 );
}
else if( anim_4wayblend )
{
CalcAnimation( pos, q, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+0 ), cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+0 ), cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, s0 );
CalcAnimation( pos2, q2, pseqdesc, iAnimBlend( pseqdesc, i0+0, i1+1 ), cycle );
CalcAnimation( pos3, q3, pseqdesc, iAnimBlend( pseqdesc, i0+1, i1+1 ), cycle );
BlendBones( q2, pos2, pseqdesc, q3, pos3, s0 );
BlendBones( q, pos, pseqdesc, q2, pos2, s1 );
}
else
{
int iAnimIndices[3];
float weight[3];
Calc9WayBlendIndices( i0, i1, s0, s1, pseqdesc, iAnimIndices, weight );
if( weight[1] < 0.001f )
{
// on diagonal
CalcAnimation( pos, q, pseqdesc, iAnimIndices[0], cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimIndices[2], cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, weight[2] / ( weight[0] + weight[2] ));
}
else
{
CalcAnimation( pos, q, pseqdesc, iAnimIndices[0], cycle );
CalcAnimation( pos2, q2, pseqdesc, iAnimIndices[1], cycle );
BlendBones( q, pos, pseqdesc, q2, pos2, weight[1] / ( weight[0] + weight[1] ));
CalcAnimation( pos3, q3, pseqdesc, iAnimIndices[2], cycle );
BlendBones( q, pos, pseqdesc, q3, pos3, weight[2] );
}
}
}
// list is cleared
SetBoneControllers( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: calculate a pose for a single sequence
// adds autolayers, runs local ik rukes
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: AddSequenceLayers( CIKContext *pIKContext, Vector pos[], Vector4D q[], int sequence, float cycle, float flWeight )
{
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
for( int i = 0; i < pseqdesc->numautolayers; i++ )
{
mstudioautolayer_t *pLayer = (mstudioautolayer_t *)((byte *)m_pStudioHeader + pseqdesc->autolayerindex) + i;
if( FBitSet( pLayer->flags, STUDIO_AL_LOCAL ))
continue;
float layerCycle = cycle;
float layerWeight = flWeight;
if( pLayer->start != pLayer->end )
{
float s = 1.0;
float index;
if( !FBitSet( pLayer->flags, STUDIO_AL_POSE ))
{
index = cycle;
}
else
{
int iSequence = pLayer->iSequence;
int iPose = pLayer->iPose;
if( iPose != -1 )
{
const mstudioposeparamdesc_t *pPose = pPoseParameter( iPose );
index = m_flPoseParams[iPose] * (pPose->end - pPose->start) + pPose->start;
}
else
{
index = 0;
}
}
if( index < pLayer->start )
continue;
if( index >= pLayer->end )
continue;
if( index < pLayer->peak && pLayer->start != pLayer->peak )
{
s = (index - pLayer->start) / (pLayer->peak - pLayer->start);
}
else if( index > pLayer->tail && pLayer->end != pLayer->tail )
{
s = (pLayer->end - index) / (pLayer->end - pLayer->tail);
}
if( FBitSet( pLayer->flags, STUDIO_AL_SPLINE ))
{
s = SimpleSpline( s );
}
if( FBitSet( pLayer->flags, STUDIO_AL_XFADE ) && ( index > pLayer->tail ))
{
layerWeight = ( s * flWeight ) / ( 1.0f - flWeight + s * flWeight );
}
else if( FBitSet( pLayer->flags, STUDIO_AL_NOBLEND ))
{
layerWeight = s;
}
else
{
layerWeight = flWeight * s;
}
if( !FBitSet( pLayer->flags, STUDIO_AL_POSE ))
{
layerCycle = (cycle - pLayer->start) / (pLayer->end - pLayer->start);
}
}
AccumulatePose( pIKContext, pos, q, pLayer->iSequence, layerCycle, layerWeight );
}
}
//-----------------------------------------------------------------------------
// Purpose: calculate a pose for a single sequence
// adds autolayers, runs local ik rukes
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: AddLocalLayers( CIKContext *pIKContext, Vector pos[], Vector4D q[], int sequence, float cycle, float flWeight )
{
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
if( !FBitSet( pseqdesc->flags, STUDIO_LOCAL ))
{
return;
}
for( int i = 0; i < pseqdesc->numautolayers; i++ )
{
mstudioautolayer_t *pLayer = (mstudioautolayer_t *)((byte *)m_pStudioHeader + pseqdesc->autolayerindex) + i;
if( !FBitSet( pLayer->flags, STUDIO_AL_LOCAL ))
continue;
float layerCycle = cycle;
float layerWeight = flWeight;
if( pLayer->start != pLayer->end )
{
float s = 1.0f;
if( cycle < pLayer->start )
continue;
if( cycle >= pLayer->end )
continue;
if( cycle < pLayer->peak && pLayer->start != pLayer->peak )
{
s = (cycle - pLayer->start) / (pLayer->peak - pLayer->start);
}
else if( cycle > pLayer->tail && pLayer->end != pLayer->tail )
{
s = (pLayer->end - cycle) / (pLayer->end - pLayer->tail);
}
if( FBitSet( pLayer->flags, STUDIO_AL_SPLINE ))
{
s = SimpleSpline( s );
}
if( FBitSet( pLayer->flags, STUDIO_AL_XFADE ) && ( cycle > pLayer->tail ))
{
layerWeight = ( s * flWeight ) / ( 1.0f - flWeight + s * flWeight );
}
else if( FBitSet( pLayer->flags, STUDIO_AL_NOBLEND ))
{
layerWeight = s;
}
else
{
layerWeight = flWeight * s;
}
layerCycle = (cycle - pLayer->start) / (pLayer->end - pLayer->start);
}
AccumulatePose( pIKContext, pos, q, pLayer->iSequence, layerCycle, layerWeight );
}
}
//-----------------------------------------------------------------------------
// Purpose: accumulate a pose for a single sequence on top of existing animation
// adds autolayers, runs local ik rukes
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: AccumulatePose( CIKContext *pIKContext, Vector pos[], Vector4D q[], int sequence, float cycle, float flWeight )
{
Vector pos2[MAXSTUDIOBONES];
Vector4D q2[MAXSTUDIOBONES];
flWeight = bound( 0.0f, flWeight, 1.0f );
if( sequence < 0 ) return;
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + sequence;
// add any IK locks to prevent extremities from moving
CIKContext seq_ik;
if( pseqdesc->numiklocks )
{
// local space relative so absolute position doesn't mater
seq_ik.Init( this, g_vecZero, g_vecZero, 0.0f, 0 );
seq_ik.AddSequenceLocks( pseqdesc, pos, q );
}
if( FBitSet( pseqdesc->flags, STUDIO_LOCAL ))
{
InitPose( pos2, q2 );
}
CalcPoseSingle( pos2, q2, sequence, cycle );
// this weight is wrong, the IK rules won't composite at the correct intensity
AddLocalLayers( pIKContext, pos2, q2, sequence, cycle, 1.0 );
SlerpBones( q, pos, pseqdesc, q2, pos2, flWeight );
if( pIKContext )
{
pIKContext->AddDependencies( pseqdesc, sequence, cycle, flWeight );
}
AddSequenceLayers( pIKContext, pos, q, sequence, cycle, flWeight );
if( pseqdesc->numiklocks )
{
seq_ik.SolveSequenceLocks( pseqdesc, pos, q );
}
}
//-----------------------------------------------------------------------------
// Purpose: blend together q1,pos1 with q2,pos2. Return result in q1,pos1.
// 0 returns q1, pos1. 1 returns q2, pos2
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcBoneAdj( Vector pos[], Vector4D q[], const byte controllers[], byte mouthopen )
{
mstudiobonecontroller_t *pbonecontroller;
int i, j, k;
float value;
Vector p0;
Radian a0;
Vector4D q0;
for( j = 0; j < m_pStudioHeader->numbonecontrollers; j++ )
{
pbonecontroller = (mstudiobonecontroller_t *)((byte *)m_pStudioHeader + m_pStudioHeader->bonecontrollerindex) + j;
k = pbonecontroller->bone;
if( IsBoneUsed( k ))
{
i = pbonecontroller->index;
if( i == STUDIO_MOUTH )
value = bound( 0.0f, ( mouthopen / 64.0f ), 1.0f );
else value = bound( 0.0f, (float)controllers[i] / 255.0f, 1.0f );
value = (1.0f - value) * pbonecontroller->start + value * pbonecontroller->end;
switch( pbonecontroller->type & STUDIO_TYPES )
{
case STUDIO_XR:
a0.Init( DEG2RAD( value ), 0.0f, 0.0f );
AngleQuaternion( a0, q0 );
QuaternionSM( 1.0f, q0, q[k], q[k] );
break;
case STUDIO_YR:
a0.Init( 0.0f, DEG2RAD( value ), 0.0f );
AngleQuaternion( a0, q0 );
QuaternionSM( 1.0f, q0, q[k], q[k] );
break;
case STUDIO_ZR:
a0.Init( 0.0f, 0.0f, DEG2RAD( value ));
AngleQuaternion( a0, q0 );
QuaternionSM( 1.0f, q0, q[k], q[k] );
break;
case STUDIO_X:
pos[k].x += value;
break;
case STUDIO_Y:
pos[k].y += value;
break;
case STUDIO_Z:
pos[k].z += value;
break;
}
}
}
}
void CStudioBoneSetup :: CalcBoneAdj( float adj[], const byte controllers[], byte mouthopen )
{
mstudiobonecontroller_t *pbonecontroller;
int i, j, k;
float value;
Vector p0;
Radian a0;
Vector4D q0;
for( j = 0; j < m_pStudioHeader->numbonecontrollers; j++ )
{
pbonecontroller = (mstudiobonecontroller_t *)((byte *)m_pStudioHeader + m_pStudioHeader->bonecontrollerindex) + j;
k = pbonecontroller->bone;
if( IsBoneUsed( k ))
{
i = pbonecontroller->index;
if( i == STUDIO_MOUTH )
value = bound( 0.0f, ( mouthopen / 64.0f ), 1.0f );
else value = bound( 0.0f, (float)controllers[i] / 255.0f, 1.0f );
value = (1.0f - value) * pbonecontroller->start + value * pbonecontroller->end;
switch( pbonecontroller->type & STUDIO_TYPES )
{
case STUDIO_YR:
case STUDIO_ZR:
case STUDIO_XR:
adj[j] = DEG2RAD( value );
break;
case STUDIO_X:
case STUDIO_Y:
case STUDIO_Z:
adj[j] = value;
break;
}
}
}
// list is installed
SetBoneControllers( adj );
}
//-----------------------------------------------------------------------------
// Purpose: run all animations that automatically play and are driven off of poseParameters
//-----------------------------------------------------------------------------
void CStudioBoneSetup :: CalcAutoplaySequences( CIKContext *pIKContext, Vector pos[], Vector4D q[] )
{
if( pIKContext )
{
pIKContext->AddAutoplayLocks( pos, q );
}
for( int i = 0; i < m_pStudioHeader->numseq; i++ )
{
mstudioseqdesc_t *pseqdesc = (mstudioseqdesc_t *)((byte *)m_pStudioHeader + m_pStudioHeader->seqindex) + i;
if( !FBitSet( pseqdesc->flags, STUDIO_AUTOPLAY ))
continue;
float cps = LocalCPS( i );
float cycle = m_flTime * cps;
cycle = cycle - (int)cycle;
AccumulatePose( NULL, pos, q, i, cycle, 1.0 );
}
if( pIKContext )
{
pIKContext->SolveAutoplayLocks( pos, q );
}
}