source-engine/tier3/mdlutils.cpp

460 lines
13 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= 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] );
}
}
}
}