Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

694 lines
18 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Dme version of a game model (MDL)
//
//=============================================================================
#include "movieobjects/dmegamemodel.h"
#include "movieobjects_interfaces.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "datacache/imdlcache.h"
#include "studio.h"
#include "tier3/tier3.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( DmeGlobalFlexControllerOperator, CDmeGlobalFlexControllerOperator );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeGlobalFlexControllerOperator::OnConstruction()
{
m_flexWeight.Init( this, "flexWeight" );
m_gameModel.Init( this, "gameModel", FATTRIB_HAS_CALLBACK );
m_ToAttributeHandle = DMATTRIBUTE_HANDLE_INVALID;
m_nFlexControllerIndex = -1;
}
void CDmeGlobalFlexControllerOperator::OnDestruction()
{
}
void CDmeGlobalFlexControllerOperator::Resolve()
{
if ( m_nFlexControllerIndex < 0 )
{
m_nFlexControllerIndex = FindGlobalFlexControllerIndex();
}
}
void CDmeGlobalFlexControllerOperator::OnAttributeChanged( CDmAttribute *pAttribute )
{
// Don't have the required interface...
if ( !g_pGlobalFlexController )
return;
if ( pAttribute == m_gameModel.GetAttribute() && m_gameModel.GetElement() )
{
m_nFlexControllerIndex = FindGlobalFlexControllerIndex();
SetupToAttribute();
}
}
void CDmeGlobalFlexControllerOperator::Operate()
{
CDmAttribute *pToAttr = g_pDataModel->GetAttribute( m_ToAttributeHandle );
if ( !pToAttr )
return;
DmAttributeType_t type = m_flexWeight.GetAttribute()->GetType();
const void *pValue = m_flexWeight.GetAttribute()->GetValueUntyped();
if ( IsArrayType( pToAttr->GetType() ) )
{
if ( m_nFlexControllerIndex == -1 )
return;
CDmrGenericArray array( pToAttr );
array.Set( m_nFlexControllerIndex, type, pValue );
}
else
{
pToAttr->SetValue( type, pValue );
}
}
void CDmeGlobalFlexControllerOperator::SetGameModel( CDmeGameModel *gameModel )
{
m_gameModel = gameModel;
}
void CDmeGlobalFlexControllerOperator::SetWeight( float flWeight )
{
m_flexWeight = flWeight;
}
void CDmeGlobalFlexControllerOperator::SetMapping( int globalIndex )
{
m_nFlexControllerIndex = globalIndex;
if ( m_gameModel.GetElement() )
{
if ( (uint)globalIndex >= m_gameModel->NumFlexWeights() )
{
m_gameModel->SetNumFlexWeights( (uint)( globalIndex + 1 ) );
}
}
}
int CDmeGlobalFlexControllerOperator::GetGlobalIndex() const
{
return m_nFlexControllerIndex;
}
void CDmeGlobalFlexControllerOperator::GetInputAttributes ( CUtlVector< CDmAttribute * > &attrs )
{
attrs.AddToTail( m_flexWeight.GetAttribute() );
}
void CDmeGlobalFlexControllerOperator::GetOutputAttributes( CUtlVector< CDmAttribute * > &attrs )
{
CDmAttribute *toAttribute = g_pDataModel->GetAttribute( m_ToAttributeHandle );
if ( toAttribute )
{
attrs.AddToTail( toAttribute );
}
}
void CDmeGlobalFlexControllerOperator::SetupToAttribute()
{
CDmElement *pObject = m_gameModel.GetElement();
if ( pObject == NULL)
return;
CDmAttribute *pAttr = pObject->GetAttribute( "flexWeights" );
Assert( pAttr );
if ( !pAttr )
return;
m_ToAttributeHandle = pAttr->GetHandle();
return;
}
//-----------------------------------------------------------------------------
// Connect up stuff by index
//-----------------------------------------------------------------------------
int CDmeGlobalFlexControllerOperator::FindGlobalFlexControllerIndex() const
{
int nGlobalFlexControllerIndex = -1;
const char *pModelName = m_gameModel->GetModelName();
MDLHandle_t h = pModelName && pModelName[0] ? g_pMDLCache->FindMDL( pModelName ) : MDLHANDLE_INVALID;
if ( h != MDLHANDLE_INVALID )
{
studiohdr_t *hdr = g_pMDLCache->GetStudioHdr( h );
Assert( hdr );
if ( hdr )
{
int fc = hdr->numflexcontrollers;
for ( LocalFlexController_t i = LocalFlexController_t(0) ; i < fc; ++i )
{
mstudioflexcontroller_t *flex = hdr->pFlexcontroller( i );
if ( flex->localToGlobal == -1 )
{
flex->localToGlobal = g_pGlobalFlexController->FindGlobalFlexController( flex->pszName() );
}
if ( !Q_stricmp( flex->pszName(), GetName() ) )
{
nGlobalFlexControllerIndex = flex->localToGlobal;
// Grow the array
if ( (uint)flex->localToGlobal >= m_gameModel->NumFlexWeights() )
{
m_gameModel->SetNumFlexWeights( (uint)( flex->localToGlobal + 1 ) );
}
break;
}
}
}
g_pMDLCache->Release( h );
}
return nGlobalFlexControllerIndex;
}
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeGameModel, CDmeGameModel );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeGameModel::OnConstruction()
{
m_flexWeights.Init( this, "flexWeights" );
m_viewTarget.Init( this, "viewTarget" );
m_modelName.Init( this, "modelName", FATTRIB_HAS_CALLBACK );
m_skin.Init( this, "skin" );
m_body.Init( this, "body" );
m_sequence.Init( this, "sequence" );
m_flags.Init( this, "flags" );
m_bones.Init( this, "bones" );
m_globalFlexControllers.Init( this, "globalFlexControllers" );
m_bComputeBounds.Init( this, "computeBounds" );
}
void CDmeGameModel::OnDestruction()
{
}
CDmeGlobalFlexControllerOperator *CDmeGameModel::AddGlobalFlexController( const char *controllerName, int globalIndex )
{
int i, c;
c = m_globalFlexControllers.Count();
for ( i = 0; i < c; ++i )
{
CDmeGlobalFlexControllerOperator *op = m_globalFlexControllers.Get( i );
Assert( op );
if ( op && !Q_stricmp( op->GetName(), controllerName ) )
break;
}
if ( i >= c )
{
CDmeGlobalFlexControllerOperator *newOperator = CreateElement< CDmeGlobalFlexControllerOperator >( controllerName, GetFileId() );
Assert( newOperator );
if ( !newOperator )
return NULL;
i = m_globalFlexControllers.AddToTail( newOperator );
}
Assert( m_globalFlexControllers.IsValidIndex( i ) );
CDmeGlobalFlexControllerOperator *op = m_globalFlexControllers.Get( i );
Assert( op );
if ( op )
{
op->SetMapping( globalIndex );
op->SetGameModel( this );
}
if ( (uint)globalIndex >= NumFlexWeights() )
{
SetNumFlexWeights( globalIndex + 1 );
}
return op;
}
//-----------------------------------------------------------------------------
// Find a flex controller by its global index
//-----------------------------------------------------------------------------
CDmeGlobalFlexControllerOperator *CDmeGameModel::FindGlobalFlexController( int nGlobalIndex )
{
int i, c;
c = m_globalFlexControllers.Count();
for ( i = 0; i < c; ++i )
{
CDmeGlobalFlexControllerOperator *op = m_globalFlexControllers.Get( i );
Assert( op );
if ( op && op->GetGlobalIndex() == nGlobalIndex )
return op;
}
return NULL;
}
studiohdr_t* CDmeGameModel::GetStudioHdr() const
{
const char *pModelName = GetModelName();
MDLHandle_t h = pModelName && pModelName[0] ? g_pMDLCache->FindMDL( pModelName ) : MDLHANDLE_INVALID;
return ( h != MDLHANDLE_INVALID ) ? g_pMDLCache->GetStudioHdr( h ) : NULL;
}
// A src bone transform transforms pre-compiled data (.dmx or .smd files, for example)
// into post-compiled data (.mdl or .ani files)
bool CDmeGameModel::GetSrcBoneTransforms( matrix3x4_t *pPreTransform, matrix3x4_t *pPostTransform, int nBoneIndex ) const
{
studiohdr_t *pStudioHdr = GetStudioHdr();
if ( !pStudioHdr )
return false;
if ( pStudioHdr->numbones <= nBoneIndex )
return false;
const char *pBoneName = pStudioHdr->pBone( nBoneIndex )->pszName();
int nCount = pStudioHdr->NumSrcBoneTransforms();
for ( int i = 0; i < nCount; ++i )
{
const mstudiosrcbonetransform_t *pSrcTransform = pStudioHdr->SrcBoneTransform( i );
if ( Q_stricmp( pSrcTransform->pszName(), pBoneName ) )
continue;
MatrixCopy( pSrcTransform->pretransform, *pPreTransform );
MatrixCopy( pSrcTransform->posttransform, *pPostTransform );
return true;
}
return false;
}
bool CDmeGameModel::IsRootTransform( int nBoneIndex ) const
{
studiohdr_t *pStudioHdr = GetStudioHdr();
if ( !pStudioHdr )
return true;
if ( pStudioHdr->numbones <= nBoneIndex )
return true;
mstudiobone_t *pBone = pStudioHdr->pBone( nBoneIndex );
return pBone->parent == -1;
}
int CDmeGameModel::NumGlobalFlexControllers() const
{
return m_globalFlexControllers.Count();
}
CDmeGlobalFlexControllerOperator *CDmeGameModel::GetGlobalFlexController( int localIndex )
{
return m_globalFlexControllers.Get( localIndex );
}
void CDmeGameModel::RemoveGlobalFlexController( CDmeGlobalFlexControllerOperator *controller )
{
int c = m_globalFlexControllers.Count();
for ( int i = 0; i < c; ++i )
{
CDmeGlobalFlexControllerOperator *check = m_globalFlexControllers.Get( i );
if ( check == controller )
{
m_globalFlexControllers.Remove( i );
break;
}
}
}
void CDmeGameModel::AppendGlobalFlexControllerOperators( CUtlVector< IDmeOperator * >& list )
{
int c = m_globalFlexControllers.Count();
for ( int i = 0 ; i < c; ++i )
{
CDmeOperator *op = m_globalFlexControllers.Get( i );
if ( !op )
continue;
list.AddToTail( op );
}
}
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------
void CDmeGameModel::AddBone( CDmeTransform* pTransform )
{
m_bones.AddToTail( pTransform );
}
//-----------------------------------------------------------------------------
// Is this dag under the game model?
//-----------------------------------------------------------------------------
static bool IsDagUnderGameModel( CDmeDag *pDag, CDmeGameModel *pGameModel )
{
if ( pDag == pGameModel )
return true;
DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pDag->GetHandle() );
while ( i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID )
{
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
CDmElement *pDmeParent = pAttribute->GetOwner();
const static UtlSymId_t symChildren = g_pDataModel->GetSymbol( "children" );
if ( pDmeParent && pAttribute->GetNameSymbol() == symChildren )
{
CDmeDag *pParent = CastElement< CDmeDag >( pDmeParent );
if ( pParent && ( pParent->GetFileId() == pDag->GetFileId() ) )
{
if ( IsDagUnderGameModel( pParent, pGameModel ) )
return true;
}
}
i = g_pDataModel->NextAttributeReferencingElement( i );
}
return false;
}
//-----------------------------------------------------------------------------
// Is this dag under the game model?
//-----------------------------------------------------------------------------
static CDmeDag* GetDagForTransform( CDmeTransform *pTransform, CDmeGameModel *pGameModel )
{
DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pTransform->GetHandle() );
while ( i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID )
{
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
CDmElement *pDmeParent = pAttribute->GetOwner();
const static UtlSymId_t symTransform = g_pDataModel->GetSymbol( "transform" );
if ( pDmeParent && pAttribute->GetNameSymbol() == symTransform )
{
CDmeDag *pParent = CastElement< CDmeDag >( pDmeParent );
if ( pParent && ( pParent->GetFileId() == pTransform->GetFileId() ) )
{
if ( IsDagUnderGameModel( pParent, pGameModel ) )
return pParent;
}
}
i = g_pDataModel->NextAttributeReferencingElement( i );
}
return NULL;
}
//-----------------------------------------------------------------------------
// Finds existing dags
//-----------------------------------------------------------------------------
void CDmeGameModel::PopulateExistingDagList( CDmeDag** pDags, int nCount )
{
int nCurrentBoneCount = m_bones.Count();
for ( int i = 0; i < nCount; ++i )
{
if ( i >= nCurrentBoneCount )
{
pDags[ i ] = NULL;
continue;
}
CDmeTransform *pTransform = GetBone( i );
Assert( pTransform );
pDags[ i ] = pTransform ? GetDagForTransform( pTransform, this ) : NULL;
}
}
//-----------------------------------------------------------------------------
// Adds bones to the game model
//-----------------------------------------------------------------------------
void CDmeGameModel::AddBones( studiohdr_t *pStudioHdr, const char *pBaseName, int nFirstBone, int nCount )
{
if ( nFirstBone + nCount > pStudioHdr->numbones )
{
nCount = pStudioHdr->numbones - nFirstBone;
if ( nCount <= 0 )
return;
}
// make room for bones
CDmeDag** pDags = ( CDmeDag** )_alloca( pStudioHdr->numbones * sizeof(CDmeDag*) );
int nDagCount = nFirstBone;
PopulateExistingDagList( pDags, nFirstBone );
char name[ 256 ];
for ( int i = 0; i < nCount; ++i )
{
int bi = i + nFirstBone;
// get parent
mstudiobone_t *pBone = pStudioHdr->pBone( bi );
int parentIndex = pBone->parent;
Assert( parentIndex < nDagCount );
// build dag hierarchy to match bone hierarchy
CDmeDag *pParent = ( parentIndex < 0 ) ? this : pDags[ parentIndex ];
Q_snprintf( name, sizeof( name ), "%s_bone %d (%s)", pBaseName, bi, pBone->pszName() );
CDmeDag *pDag = CreateElement< CDmeDag >( name, GetFileId() );
pDags[nDagCount++] = pDag;
pParent->AddChild( pDag );
CDmeTransform *pTransform = pDag->GetTransform();
pTransform->SetName( name );
// add different bone representations to dme model and input
AddBone( pTransform );
}
}
void CDmeGameModel::SetBone( uint index, const Vector& pos, const Quaternion& rot )
{
m_bones[ index ]->SetPosition( pos );
m_bones[ index ]->SetOrientation( rot );
}
void CDmeGameModel::RemoveAllBones()
{
m_bones.RemoveAll();
}
uint CDmeGameModel::NumBones() const
{
return m_bones.Count();
}
CDmeTransform *CDmeGameModel::GetBone( uint index ) const
{
return m_bones[ index ];
}
int CDmeGameModel::FindBone( CDmeTransform *pTransform ) const
{
return m_bones.Find( pTransform );
}
uint CDmeGameModel::NumFlexWeights() const
{
return m_flexWeights.Count();
}
const CUtlVector< float >& CDmeGameModel::GetFlexWeights() const
{
return m_flexWeights.Get();
}
void CDmeGameModel::SetNumFlexWeights( uint nFlexWeights )
{
if ( nFlexWeights > (uint)m_flexWeights.Count() )
{
while ( (uint)m_flexWeights.Count() < nFlexWeights )
{
m_flexWeights.AddToTail( 0.0f );
}
}
else
{
while ( (uint)m_flexWeights.Count() > nFlexWeights )
{
m_flexWeights.Remove( (uint)m_flexWeights.Count() - 1 );
}
}
}
void CDmeGameModel::SetFlexWeights( uint nFlexWeights, const float* flexWeights )
{
m_flexWeights.CopyArray( flexWeights, nFlexWeights );
}
const Vector& CDmeGameModel::GetViewTarget() const
{
return m_viewTarget.Get();
}
void CDmeGameModel::SetViewTarget( const Vector &viewTarget )
{
m_viewTarget = viewTarget;
}
void CDmeGameModel::SetFlags( int nFlags )
{
m_flags = nFlags;
}
void CDmeGameModel::SetSkin( int nSkin )
{
m_skin = nSkin;
}
void CDmeGameModel::SetBody( int nBody )
{
m_body = nBody;
}
void CDmeGameModel::SetSequence( int nSequence )
{
m_sequence = nSequence;
}
int CDmeGameModel::GetSkin() const
{
return m_skin;
}
int CDmeGameModel::GetBody() const
{
return m_body;
}
int CDmeGameModel::GetSequence() const
{
return m_sequence;
}
const char *CDmeGameModel::GetModelName() const
{
return m_modelName.Get();
}
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeGameSprite, CDmeGameSprite );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeGameSprite::OnConstruction()
{
m_modelName .Init( this, "modelName" );
m_frame .Init( this, "frame" );
m_rendermode.Init( this, "rendermode" );
m_renderfx .Init( this, "renderfx" );
m_renderscale.Init( this, "renderscale" );
m_color .Init( this, "color" );
m_proxyRadius.Init( this, "proxyRadius" );
}
void CDmeGameSprite::OnDestruction()
{
}
//-----------------------------------------------------------------------------
// accessors
//-----------------------------------------------------------------------------
const char *CDmeGameSprite::GetModelName() const
{
return m_modelName.Get();
}
float CDmeGameSprite::GetScale() const
{
return m_renderscale;
}
float CDmeGameSprite::GetFrame() const
{
return m_frame;
}
int CDmeGameSprite::GetRenderMode() const
{
return m_rendermode;
}
int CDmeGameSprite::GetRenderFX() const
{
return m_renderfx;
}
const Color &CDmeGameSprite::GetColor() const
{
return m_color;
}
float CDmeGameSprite::GetProxyRadius() const
{
return m_proxyRadius;
}
void CDmeGameSprite::SetState( bool bVisible, float nFrame, int nRenderMode, int nRenderFX, float flRenderScale, float flProxyRadius,
const Vector &pos, const Quaternion &rot, const Color &color )
{
m_Visible = bVisible;
m_frame = nFrame;
m_rendermode = nRenderMode;
m_renderfx = nRenderFX;
m_renderscale = flRenderScale;
m_proxyRadius = flProxyRadius;
m_color = color;
CDmeTransform *pTransform = GetTransform();
pTransform->SetPosition( pos );
pTransform->SetOrientation( rot );
}
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeGamePortal, CDmeGamePortal );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeGamePortal::OnConstruction()
{
m_flStaticAmount .Init( this, "staticAmount" );
m_flSecondaryStaticAmount .Init( this, "secondaryStaticAmount" );
m_flOpenAmount .Init( this, "openAmount" );
m_nPortalId .Init( this, "portalId" );
m_nLinkedPortalId .Init( this, "linkedPortalId" );
m_bIsPortal2 .Init( this, "isPortal2" );
}
void CDmeGamePortal::OnDestruction()
{
}