335 lines
11 KiB
C++
335 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Dme version of a skeletal model (gets compiled into a MDL)
|
|
//
|
|
//=============================================================================
|
|
#include "movieobjects/dmemodel.h"
|
|
#include "movieobjects_interfaces.h"
|
|
#include "datamodel/dmelementfactoryhelper.h"
|
|
#include "datacache/imdlcache.h"
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "tier2/tier2.h"
|
|
#include "studio.h"
|
|
#include "materialsystem/imaterialsystemhardwareconfig.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Expose this class to the scene database
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeModel, CDmeModel );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stack of DmeModels currently being rendered. Used to set up render state
|
|
//-----------------------------------------------------------------------------
|
|
CUtlStack< CDmeModel * > CDmeModel::s_ModelStack;
|
|
static CUtlVector< matrix3x4_t > s_PoseToWorld;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeModel::OnConstruction()
|
|
{
|
|
m_JointTransforms.Init( this, "jointTransforms" );
|
|
m_BaseStates.Init( this, "baseStates" );
|
|
}
|
|
|
|
void CDmeModel::OnDestruction()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Add joint
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeModel::AddJoint( CDmeDag *pJoint )
|
|
{
|
|
int nIndex = GetJointTransformIndex( pJoint->GetTransform() );
|
|
if ( nIndex >= 0 )
|
|
return nIndex;
|
|
|
|
return m_JointTransforms.AddToTail( pJoint->GetTransform() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Add joint
|
|
//-----------------------------------------------------------------------------
|
|
CDmeJoint *CDmeModel::AddJoint( const char *pJointName, CDmeDag *pParent )
|
|
{
|
|
CDmeJoint *pJoint = CreateElement<CDmeJoint>( pJointName, GetFileId() );
|
|
CDmeTransform *pTransform = pJoint->GetTransform();
|
|
pTransform->SetName( pJointName );
|
|
|
|
if ( !pParent )
|
|
{
|
|
pParent = this;
|
|
}
|
|
pParent->AddChild( pJoint );
|
|
m_JointTransforms.AddToTail( pTransform );
|
|
return pJoint;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the number of joint transforms we know about
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeModel::GetJointTransformCount() const
|
|
{
|
|
return m_JointTransforms.Count();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines joint transform index given a joint transform
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeModel::GetJointTransformIndex( CDmeTransform *pTransform ) const
|
|
{
|
|
int nCount = m_JointTransforms.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( pTransform == m_JointTransforms[i] )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines joint transform index given a joint
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeModel::GetJointTransformIndex( CDmeDag *pJoint ) const
|
|
{
|
|
return GetJointTransformIndex( pJoint->GetTransform() );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Determines joint transform index given a joint name
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTransform *CDmeModel::GetJointTransform( int nIndex )
|
|
{
|
|
return m_JointTransforms[ nIndex ];
|
|
}
|
|
|
|
const CDmeTransform *CDmeModel::GetJointTransform( int nIndex ) const
|
|
{
|
|
return m_JointTransforms[ nIndex ];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds a base state by name, returns NULL if not found
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTransformList *CDmeModel::FindBaseState( const char *pBaseStateName )
|
|
{
|
|
int nCount = m_BaseStates.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( !Q_stricmp( m_BaseStates[i]->GetName(), pBaseStateName ) )
|
|
return m_BaseStates[i];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Captures the current joint transforms into a base state
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeModel::CaptureJointsToBaseState( const char *pBaseStateName )
|
|
{
|
|
CDmeTransformList *pTransformList = FindBaseState( pBaseStateName );
|
|
if ( !pTransformList )
|
|
{
|
|
pTransformList = CreateElement<CDmeTransformList>( pBaseStateName, GetFileId() );
|
|
m_BaseStates.AddToTail( pTransformList );
|
|
}
|
|
|
|
// Make the transform list have the correct number of elements
|
|
int nJointCount = m_JointTransforms.Count();
|
|
int nCurrentCount = pTransformList->GetTransformCount();
|
|
if ( nJointCount > nCurrentCount )
|
|
{
|
|
for ( int i = nCurrentCount; i < nJointCount; ++i )
|
|
{
|
|
CDmeTransform *pTransform = CreateElement<CDmeTransform>( m_JointTransforms[i]->GetName(), pTransformList->GetFileId() );
|
|
pTransformList->m_Transforms.AddToTail( pTransform );
|
|
}
|
|
}
|
|
else if ( nJointCount < nCurrentCount )
|
|
{
|
|
pTransformList->m_Transforms.RemoveMultiple( nJointCount, nCurrentCount - nJointCount );
|
|
}
|
|
|
|
// Copy the state over
|
|
for ( int i = 0; i < nJointCount; ++i )
|
|
{
|
|
matrix3x4_t mat;
|
|
m_JointTransforms[i]->GetTransform( mat );
|
|
pTransformList->SetTransform( i, mat );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Loads up joint transforms for this model
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeModel::LoadJointTransform( CDmeDag *pJoint, CDmeTransformList *pBindPose, const matrix3x4_t &parentToWorld, const matrix3x4_t &parentToBindPose, bool bSetHardwareState )
|
|
{
|
|
CDmeTransform *pTransform = pJoint->GetTransform();
|
|
|
|
// Determines joint transform index; no index, no traversing lower in the hierarchy
|
|
int nJointIndex = GetJointTransformIndex( pTransform );
|
|
if ( nJointIndex < 0 )
|
|
return;
|
|
|
|
// FIXME: Sucky search here necessary to find bone matrix index
|
|
matrix3x4_t jointToWorld, jointToParent;
|
|
pTransform->GetTransform( jointToParent );
|
|
ConcatTransforms( parentToWorld, jointToParent, jointToWorld );
|
|
|
|
matrix3x4_t bindJointToParent, bindPoseToJoint, bindPoseToWorld, jointToBindPose;
|
|
if ( pBindPose )
|
|
{
|
|
if ( nJointIndex >= pBindPose->GetTransformCount() )
|
|
{
|
|
Warning( "Model is in an invalid state! There are different numbers of bones in the bind pose and joint transform list!\n" );
|
|
return;
|
|
}
|
|
pBindPose->GetTransform( nJointIndex )->GetTransform( bindJointToParent );
|
|
}
|
|
else
|
|
{
|
|
MatrixCopy( jointToParent, bindJointToParent );
|
|
}
|
|
ConcatTransforms( parentToBindPose, bindJointToParent, jointToBindPose );
|
|
|
|
MatrixInvert( jointToBindPose, bindPoseToJoint );
|
|
ConcatTransforms( jointToWorld, bindPoseToJoint, bindPoseToWorld );
|
|
|
|
if ( bSetHardwareState )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
pRenderContext->LoadBoneMatrix( nJointIndex, bindPoseToWorld );
|
|
}
|
|
MatrixCopy( bindPoseToWorld, s_PoseToWorld[ nJointIndex ] );
|
|
|
|
int nChildCount = pJoint->GetChildCount();
|
|
for ( int i = 0; i < nChildCount; ++i )
|
|
{
|
|
CDmeDag *pChildJoint = pJoint->GetChild(i);
|
|
if ( !pChildJoint )
|
|
continue;
|
|
|
|
LoadJointTransform( pChildJoint, pBindPose, jointToWorld, jointToBindPose, bSetHardwareState );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sets up the render state for the model
|
|
//-----------------------------------------------------------------------------
|
|
CDmeModel::SetupBoneRetval_t CDmeModel::SetupBoneMatrixState( const matrix3x4_t& shapeToWorld, bool bForceSoftwareSkin )
|
|
{
|
|
int nJointCount = m_JointTransforms.Count();
|
|
if ( nJointCount <= 0 )
|
|
return NO_SKIN_DATA;
|
|
|
|
int nBoneBatchCount = g_pMaterialSystemHardwareConfig->MaxVertexShaderBlendMatrices();
|
|
bool bSetHardwareState = ( nJointCount <= nBoneBatchCount ) && !bForceSoftwareSkin;
|
|
|
|
s_PoseToWorld.EnsureCount( nJointCount );
|
|
|
|
// Finds a base state by name, returns NULL if not found
|
|
CDmeTransformList *pBindPose = FindBaseState( "bind" );
|
|
|
|
matrix3x4_t parentToBindPose;
|
|
SetIdentityMatrix( parentToBindPose );
|
|
|
|
int nChildCount = GetChildCount();
|
|
for ( int i = 0; i < nChildCount; ++i )
|
|
{
|
|
CDmeDag *pChildJoint = GetChild(i);
|
|
if ( !pChildJoint )
|
|
continue;
|
|
|
|
LoadJointTransform( pChildJoint, pBindPose, shapeToWorld, parentToBindPose, bSetHardwareState );
|
|
}
|
|
|
|
return bSetHardwareState ? BONES_SET_UP : TOO_MANY_BONES;
|
|
}
|
|
|
|
matrix3x4_t *CDmeModel::SetupModelRenderState( const matrix3x4_t& shapeToWorld, bool bHasSkinningData, bool bForceSoftwareSkin )
|
|
{
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
if ( bHasSkinningData && ( s_ModelStack.Count() > 0 ) )
|
|
{
|
|
SetupBoneRetval_t retVal = s_ModelStack.Top()->SetupBoneMatrixState( shapeToWorld, bForceSoftwareSkin );
|
|
if ( retVal == TOO_MANY_BONES )
|
|
{
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->LoadIdentity( );
|
|
return s_PoseToWorld.Base();
|
|
}
|
|
if ( retVal != NO_SKIN_DATA )
|
|
return NULL;
|
|
}
|
|
|
|
if ( bForceSoftwareSkin )
|
|
{
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->LoadIdentity( );
|
|
s_PoseToWorld.EnsureCount( 1 );
|
|
MatrixCopy( shapeToWorld, s_PoseToWorld[0] );
|
|
return s_PoseToWorld.Base();
|
|
}
|
|
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->LoadMatrix( shapeToWorld );
|
|
return NULL;
|
|
}
|
|
|
|
void CDmeModel::CleanupModelRenderState()
|
|
{
|
|
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
|
|
pRenderContext->MatrixMode( MATERIAL_MODEL );
|
|
pRenderContext->LoadIdentity();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Recursively render the Dag hierarchy
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeModel::Draw( CDmeDrawSettings *pDrawSettings /* = NULL */ )
|
|
{
|
|
s_ModelStack.Push( this );
|
|
BaseClass::Draw( pDrawSettings );
|
|
s_ModelStack.Pop( );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Set if Z is the up axis of the model
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeModel::ZUp( bool bZUp )
|
|
{
|
|
SetValue( "upAxis", bZUp ? "Z" : "Y" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns true if the DmeModel is Z Up.
|
|
// NOTE: Since Y & Z are the only supported modes and Y is the default
|
|
// because that's how DmeModel data was originally defined,
|
|
// assume Y is up if the m_UpAxis attribute is not "Z"
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmeModel::IsZUp() const
|
|
{
|
|
const char *pszZUp = this->GetValueString( "upAxis" );
|
|
|
|
return ( pszZUp && *pszZUp ) ? StringHasPrefix( pszZUp, "Z" ) : false;
|
|
} |