460 lines
13 KiB
C++
460 lines
13 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Utility methods for mdl files
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "tier3/mdlutils.h"
|
|
#include "tier0/dbg.h"
|
|
#include "tier1/callqueue.h"
|
|
#include "tier3/tier3.h"
|
|
#include "studio.h"
|
|
#include "istudiorender.h"
|
|
#include "bone_setup.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the bounding box for the model
|
|
//-----------------------------------------------------------------------------
|
|
void GetMDLBoundingBox( Vector *pMins, Vector *pMaxs, MDLHandle_t h, int nSequence )
|
|
{
|
|
if ( h == MDLHANDLE_INVALID || !g_pMDLCache )
|
|
{
|
|
pMins->Init();
|
|
pMaxs->Init();
|
|
return;
|
|
}
|
|
|
|
pMins->Init( FLT_MAX, FLT_MAX );
|
|
pMaxs->Init( -FLT_MAX, -FLT_MAX );
|
|
|
|
studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( h );
|
|
if ( !VectorCompare( vec3_origin, pStudioHdr->view_bbmin ) || !VectorCompare( vec3_origin, pStudioHdr->view_bbmax ))
|
|
{
|
|
// look for view clip
|
|
*pMins = pStudioHdr->view_bbmin;
|
|
*pMaxs = pStudioHdr->view_bbmax;
|
|
}
|
|
else if ( !VectorCompare( vec3_origin, pStudioHdr->hull_min ) || !VectorCompare( vec3_origin, pStudioHdr->hull_max ))
|
|
{
|
|
// look for hull
|
|
*pMins = pStudioHdr->hull_min;
|
|
*pMaxs = pStudioHdr->hull_max;
|
|
}
|
|
|
|
// Else use the sequence box
|
|
mstudioseqdesc_t &seqdesc = pStudioHdr->pSeqdesc( nSequence );
|
|
VectorMin( seqdesc.bbmin, *pMins, *pMins );
|
|
VectorMax( seqdesc.bbmax, *pMaxs, *pMaxs );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the radius of the model as measured from the origin
|
|
//-----------------------------------------------------------------------------
|
|
float GetMDLRadius( MDLHandle_t h, int nSequence )
|
|
{
|
|
Vector vecMins, vecMaxs;
|
|
GetMDLBoundingBox( &vecMins, &vecMaxs, h, nSequence );
|
|
float flRadius = vecMaxs.Length();
|
|
float flRadius2 = vecMins.Length();
|
|
if ( flRadius2 > flRadius )
|
|
{
|
|
flRadius = flRadius2;
|
|
}
|
|
return flRadius;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns a more accurate bounding sphere
|
|
//-----------------------------------------------------------------------------
|
|
void GetMDLBoundingSphere( Vector *pVecCenter, float *pRadius, MDLHandle_t h, int nSequence )
|
|
{
|
|
Vector vecMins, vecMaxs;
|
|
GetMDLBoundingBox( &vecMins, &vecMaxs, h, nSequence );
|
|
VectorAdd( vecMins, vecMaxs, *pVecCenter );
|
|
*pVecCenter *= 0.5f;
|
|
*pRadius = vecMaxs.DistTo( *pVecCenter );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CMDL::CMDL()
|
|
{
|
|
m_MDLHandle = MDLHANDLE_INVALID;
|
|
m_Color.SetColor( 255, 255, 255, 255 );
|
|
m_nSkin = 0;
|
|
m_nBody = 0;
|
|
m_nSequence = 0;
|
|
m_nLOD = 0;
|
|
m_flPlaybackRate = 30.0f;
|
|
m_flTime = 0.0f;
|
|
m_vecViewTarget.Init( 0, 0, 0 );
|
|
m_bWorldSpaceViewTarget = false;
|
|
memset( m_pFlexControls, 0, sizeof(m_pFlexControls) );
|
|
m_pProxyData = NULL;
|
|
}
|
|
|
|
CMDL::~CMDL()
|
|
{
|
|
UnreferenceMDL();
|
|
}
|
|
|
|
void CMDL::SetMDL( MDLHandle_t h )
|
|
{
|
|
UnreferenceMDL();
|
|
m_MDLHandle = h;
|
|
if ( m_MDLHandle != MDLHANDLE_INVALID )
|
|
{
|
|
g_pMDLCache->AddRef( m_MDLHandle );
|
|
|
|
studiohdr_t *pHdr = g_pMDLCache->LockStudioHdr( m_MDLHandle );
|
|
|
|
if ( pHdr )
|
|
{
|
|
for ( LocalFlexController_t i = LocalFlexController_t(0); i < pHdr->numflexcontrollers; ++i )
|
|
{
|
|
if ( pHdr->pFlexcontroller( i )->localToGlobal == -1 )
|
|
{
|
|
pHdr->pFlexcontroller( i )->localToGlobal = i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MDLHandle_t CMDL::GetMDL() const
|
|
{
|
|
return m_MDLHandle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Release the MDL handle
|
|
//-----------------------------------------------------------------------------
|
|
void CMDL::UnreferenceMDL()
|
|
{
|
|
if ( !g_pMDLCache )
|
|
return;
|
|
|
|
if ( m_MDLHandle != MDLHANDLE_INVALID )
|
|
{
|
|
// XXX need to figure out where it is safe to flush the queue during map change to not crash
|
|
#if 0
|
|
if ( ICallQueue *pCallQueue = materials->GetRenderContext()->GetCallQueue() )
|
|
{
|
|
// Parallel rendering: don't unlock model data until end of rendering
|
|
pCallQueue->QueueCall( g_pMDLCache, &IMDLCache::UnlockStudioHdr, m_MDLHandle );
|
|
pCallQueue->QueueCall( g_pMDLCache, &IMDLCache::Release, m_MDLHandle );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
// Immediate-mode rendering, can unlock immediately
|
|
g_pMDLCache->UnlockStudioHdr( m_MDLHandle );
|
|
g_pMDLCache->Release( m_MDLHandle );
|
|
}
|
|
m_MDLHandle = MDLHANDLE_INVALID;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the studiohdr
|
|
//-----------------------------------------------------------------------------
|
|
studiohdr_t *CMDL::GetStudioHdr()
|
|
{
|
|
if ( !g_pMDLCache )
|
|
return NULL;
|
|
return g_pMDLCache->GetStudioHdr( m_MDLHandle );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Draws the mesh
|
|
//-----------------------------------------------------------------------------
|
|
void CMDL::Draw( const matrix3x4_t& rootToWorld, const matrix3x4_t *pBoneToWorld )
|
|
{
|
|
if ( !g_pMaterialSystem || !g_pMDLCache || !g_pStudioRender )
|
|
return;
|
|
|
|
if ( m_MDLHandle == MDLHANDLE_INVALID )
|
|
return;
|
|
|
|
// Color + alpha modulation
|
|
Vector white( m_Color.r() / 255.0f, m_Color.g() / 255.0f, m_Color.b() / 255.0f );
|
|
g_pStudioRender->SetColorModulation( white.Base() );
|
|
g_pStudioRender->SetAlphaModulation( m_Color.a() / 255.0f );
|
|
|
|
DrawModelInfo_t info;
|
|
info.m_pStudioHdr = g_pMDLCache->GetStudioHdr( m_MDLHandle );
|
|
info.m_pHardwareData = g_pMDLCache->GetHardwareData( m_MDLHandle );
|
|
info.m_Decals = STUDIORENDER_DECAL_INVALID;
|
|
info.m_Skin = m_nSkin;
|
|
info.m_Body = m_nBody;
|
|
info.m_HitboxSet = 0;
|
|
info.m_pClientEntity = m_pProxyData;
|
|
info.m_pColorMeshes = NULL;
|
|
info.m_bStaticLighting = false;
|
|
info.m_Lod = m_nLOD;
|
|
|
|
Vector vecWorldViewTarget;
|
|
if ( m_bWorldSpaceViewTarget )
|
|
{
|
|
vecWorldViewTarget = m_vecViewTarget;
|
|
}
|
|
else
|
|
{
|
|
VectorTransform( m_vecViewTarget, rootToWorld, vecWorldViewTarget );
|
|
}
|
|
g_pStudioRender->SetEyeViewTarget( info.m_pStudioHdr, info.m_Body, vecWorldViewTarget );
|
|
|
|
// FIXME: Why is this necessary!?!?!?
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
|
|
// Set default flex values
|
|
float *pFlexWeights = NULL;
|
|
const int nFlexDescCount = info.m_pStudioHdr->numflexdesc;
|
|
if ( nFlexDescCount )
|
|
{
|
|
CStudioHdr cStudioHdr( info.m_pStudioHdr, g_pMDLCache );
|
|
|
|
g_pStudioRender->LockFlexWeights( info.m_pStudioHdr->numflexdesc, &pFlexWeights );
|
|
cStudioHdr.RunFlexRules( m_pFlexControls, pFlexWeights );
|
|
g_pStudioRender->UnlockFlexWeights();
|
|
}
|
|
|
|
Vector vecModelOrigin;
|
|
MatrixGetColumn( rootToWorld, 3, vecModelOrigin );
|
|
g_pStudioRender->DrawModel( NULL, info, const_cast<matrix3x4_t*>( pBoneToWorld ),
|
|
pFlexWeights, NULL, vecModelOrigin, STUDIORENDER_DRAW_ENTIRE_MODEL );
|
|
}
|
|
|
|
void CMDL::Draw( const matrix3x4_t &rootToWorld )
|
|
{
|
|
if ( !g_pMaterialSystem || !g_pMDLCache || !g_pStudioRender )
|
|
return;
|
|
|
|
if ( m_MDLHandle == MDLHANDLE_INVALID )
|
|
return;
|
|
|
|
studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( m_MDLHandle );
|
|
|
|
matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( pStudioHdr->numbones );
|
|
SetUpBones( rootToWorld, pStudioHdr->numbones, pBoneToWorld );
|
|
g_pStudioRender->UnlockBoneMatrices();
|
|
|
|
Draw( rootToWorld, pBoneToWorld );
|
|
}
|
|
|
|
|
|
void CMDL::SetUpBones( const matrix3x4_t& rootToWorld, int nMaxBoneCount, matrix3x4_t *pBoneToWorld, const float *pPoseParameters, MDLSquenceLayer_t *pSequenceLayers, int nNumSequenceLayers )
|
|
{
|
|
CStudioHdr studioHdr( g_pMDLCache->GetStudioHdr( m_MDLHandle ), g_pMDLCache );
|
|
|
|
float pPoseParameter[MAXSTUDIOPOSEPARAM];
|
|
if ( pPoseParameters )
|
|
{
|
|
V_memcpy( pPoseParameter, pPoseParameters, sizeof(pPoseParameter) );
|
|
}
|
|
else
|
|
{
|
|
// Default to middle of the pose parameter range
|
|
int nPoseCount = studioHdr.GetNumPoseParameters();
|
|
for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i )
|
|
{
|
|
pPoseParameter[i] = 0.5f;
|
|
if ( i < nPoseCount )
|
|
{
|
|
const mstudioposeparamdesc_t &Pose = studioHdr.pPoseParameter( i );
|
|
|
|
// Want to try for a zero state. If one doesn't exist set it to .5 by default.
|
|
if ( Pose.start < 0.0f && Pose.end > 0.0f )
|
|
{
|
|
float flPoseDelta = Pose.end - Pose.start;
|
|
pPoseParameter[i] = -Pose.start / flPoseDelta;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int nFrameCount = Studio_MaxFrame( &studioHdr, m_nSequence, pPoseParameter );
|
|
if ( nFrameCount == 0 )
|
|
{
|
|
nFrameCount = 1;
|
|
}
|
|
float flCycle = ( m_flTime * m_flPlaybackRate ) / nFrameCount;
|
|
|
|
// FIXME: We're always wrapping; may want to determing if we should clamp
|
|
flCycle -= (int)(flCycle);
|
|
|
|
Vector pos[MAXSTUDIOBONES];
|
|
Quaternion q[MAXSTUDIOBONES];
|
|
|
|
IBoneSetup boneSetup( &studioHdr, BONE_USED_BY_ANYTHING_AT_LOD( m_nLOD ), pPoseParameter, NULL );
|
|
boneSetup.InitPose( pos, q );
|
|
boneSetup.AccumulatePose( pos, q, m_nSequence, flCycle, 1.0f, m_flTime, NULL );
|
|
|
|
// Accumulate the additional layers if specified.
|
|
if ( pSequenceLayers )
|
|
{
|
|
int nNumSeq = studioHdr.GetNumSeq();
|
|
for ( int i = 0; i < nNumSequenceLayers; ++i )
|
|
{
|
|
int nSeqIndex = pSequenceLayers[ i ].m_nSequenceIndex;
|
|
if ( ( nSeqIndex >= 0 ) && ( nSeqIndex < nNumSeq ) )
|
|
{
|
|
float flWeight = pSequenceLayers[ i ].m_flWeight;
|
|
|
|
float flLayerCycle;
|
|
int nLayerFrameCount = MAX( 1, Studio_MaxFrame( &studioHdr, nSeqIndex, pPoseParameter ) );
|
|
|
|
if ( pSequenceLayers[i].m_bNoLoop )
|
|
{
|
|
if ( pSequenceLayers[i].m_flCycleBeganAt == 0 )
|
|
{
|
|
pSequenceLayers[i].m_flCycleBeganAt = m_flTime;
|
|
}
|
|
|
|
float flElapsedTime = m_flTime - pSequenceLayers[i].m_flCycleBeganAt;
|
|
flLayerCycle = ( flElapsedTime * m_flPlaybackRate ) / nLayerFrameCount;
|
|
|
|
// Should we keep playing layers that have ended?
|
|
//if ( flLayerCycle >= 1.0 )
|
|
//continue;
|
|
}
|
|
else
|
|
{
|
|
flLayerCycle = ( m_flTime * m_flPlaybackRate ) / nLayerFrameCount;
|
|
|
|
// FIXME: We're always wrapping; may want to determing if we should clamp
|
|
flLayerCycle -= (int)(flLayerCycle);
|
|
}
|
|
|
|
boneSetup.AccumulatePose( pos, q, nSeqIndex, flLayerCycle, flWeight, m_flTime, NULL );
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIXME: Try enabling this?
|
|
// CalcAutoplaySequences( pStudioHdr, NULL, pos, q, pPoseParameter, BONE_USED_BY_VERTEX_AT_LOD( m_nLOD ), flTime );
|
|
|
|
matrix3x4_t temp;
|
|
|
|
if ( nMaxBoneCount > studioHdr.numbones() )
|
|
{
|
|
nMaxBoneCount = studioHdr.numbones();
|
|
}
|
|
|
|
for ( int i = 0; i < nMaxBoneCount; i++ )
|
|
{
|
|
// If it's not being used, fill with NAN for errors
|
|
#ifdef _DEBUG
|
|
if ( !(studioHdr.pBone( i )->flags & BONE_USED_BY_ANYTHING_AT_LOD( m_nLOD ) ) )
|
|
{
|
|
int j, k;
|
|
for (j = 0; j < 3; j++)
|
|
{
|
|
for (k = 0; k < 4; k++)
|
|
{
|
|
pBoneToWorld[i][j][k] = VEC_T_NAN;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
matrix3x4_t boneMatrix;
|
|
QuaternionMatrix( q[i], boneMatrix );
|
|
MatrixSetColumn( pos[i], 3, boneMatrix );
|
|
|
|
if ( studioHdr.pBone(i)->parent == -1 )
|
|
{
|
|
ConcatTransforms( rootToWorld, boneMatrix, pBoneToWorld[i] );
|
|
}
|
|
else
|
|
{
|
|
ConcatTransforms( pBoneToWorld[ studioHdr.pBone(i)->parent ], boneMatrix, pBoneToWorld[i] );
|
|
}
|
|
}
|
|
Studio_RunBoneFlexDrivers( m_pFlexControls, &studioHdr, pos, pBoneToWorld, rootToWorld );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CMDL::SetupBonesWithBoneMerge( const CStudioHdr *pMergeHdr, matrix3x4_t *pMergeBoneToWorld,
|
|
const CStudioHdr *pFollow, const matrix3x4_t *pFollowBoneToWorld,
|
|
const matrix3x4_t &matModelToWorld )
|
|
{
|
|
// Default to middle of the pose parameter range
|
|
int nPoseCount = pMergeHdr->GetNumPoseParameters();
|
|
float pPoseParameter[MAXSTUDIOPOSEPARAM];
|
|
for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i )
|
|
{
|
|
pPoseParameter[i] = 0.5f;
|
|
if ( i < nPoseCount )
|
|
{
|
|
const mstudioposeparamdesc_t &Pose = ((CStudioHdr *)pMergeHdr)->pPoseParameter( i );
|
|
|
|
// Want to try for a zero state. If one doesn't exist set it to .5 by default.
|
|
if ( Pose.start < 0.0f && Pose.end > 0.0f )
|
|
{
|
|
float flPoseDelta = Pose.end - Pose.start;
|
|
pPoseParameter[i] = -Pose.start / flPoseDelta;
|
|
}
|
|
}
|
|
}
|
|
|
|
int nFrameCount = Studio_MaxFrame( pMergeHdr, m_nSequence, pPoseParameter );
|
|
if ( nFrameCount == 0 )
|
|
{
|
|
nFrameCount = 1;
|
|
}
|
|
float flCycle = ( m_flTime * m_flPlaybackRate ) / nFrameCount;
|
|
|
|
// FIXME: We're always wrapping; may want to determing if we should clamp
|
|
flCycle -= (int)(flCycle);
|
|
|
|
Vector pos[MAXSTUDIOBONES];
|
|
Quaternion q[MAXSTUDIOBONES];
|
|
|
|
IBoneSetup boneSetup( pMergeHdr, BONE_USED_BY_ANYTHING_AT_LOD( m_nLOD ), pPoseParameter );
|
|
boneSetup.InitPose( pos, q );
|
|
boneSetup.AccumulatePose( pos, q, m_nSequence, flCycle, 1.0f, m_flTime, NULL );
|
|
|
|
// Get the merge bone list.
|
|
mstudiobone_t *pMergeBones = pMergeHdr->pBone( 0 );
|
|
for ( int iMergeBone = 0; iMergeBone < pMergeHdr->numbones(); ++iMergeBone )
|
|
{
|
|
// Now find the bone in the parent entity.
|
|
bool bMerged = false;
|
|
int iParentBoneIndex = Studio_BoneIndexByName( pFollow, pMergeBones[iMergeBone].pszName() );
|
|
if ( iParentBoneIndex >= 0 )
|
|
{
|
|
MatrixCopy( pFollowBoneToWorld[iParentBoneIndex], pMergeBoneToWorld[iMergeBone] );
|
|
bMerged = true;
|
|
}
|
|
|
|
if ( !bMerged )
|
|
{
|
|
// If we get down here, then the bone wasn't merged.
|
|
matrix3x4_t matBone;
|
|
QuaternionMatrix( q[iMergeBone], pos[iMergeBone], matBone );
|
|
|
|
if ( pMergeBones[iMergeBone].parent == -1 )
|
|
{
|
|
ConcatTransforms( matModelToWorld, matBone, pMergeBoneToWorld[iMergeBone] );
|
|
}
|
|
else
|
|
{
|
|
ConcatTransforms( pMergeBoneToWorld[pMergeBones[iMergeBone].parent], matBone, pMergeBoneToWorld[iMergeBone] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|