csgo/cstrike15_src/movieobjects/dmemodel.cpp

//====== Copyright © 1996-2004, 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"
#include "movieobjects/dmemesh.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmelog.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_JointList.Init( this, "jointList" );
	m_BaseStates.Init( this, "baseStates" );
	m_UpAxis.InitAndSet( this, "upAxis", "Y" );
	m_eAxisSystem.InitAndCreate( this, "axisSystem" );	// Defaults to Y up
}

void CDmeModel::OnDestruction()
{
}


//-----------------------------------------------------------------------------
// Add joint
//-----------------------------------------------------------------------------
int CDmeModel::AddJoint( CDmeDag *pJoint )
{
	const int nIndex = GetJointIndex( pJoint );
	if ( nIndex >= 0 )
		return nIndex;

	return m_JointList.AddToTail( pJoint );
}


//-----------------------------------------------------------------------------
// 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_JointList.AddToTail( pJoint );

	return pJoint;
}


//-----------------------------------------------------------------------------
// Returns the number of joint transforms we know about
//-----------------------------------------------------------------------------
int CDmeModel::GetJointCount() const
{
	return m_JointList.Count();
}


//-----------------------------------------------------------------------------
// Determines joint transform index	given a joint transform
//-----------------------------------------------------------------------------
int CDmeModel::GetJointIndex( CDmeDag *pJoint ) const
{
	const int nJointCount = m_JointList.Count();
	for ( int i = 0; i < nJointCount; ++i )
	{
		if ( pJoint == m_JointList[ i ] )
		{
			return i;
		}
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Determines joint transform index	given a joint name
//-----------------------------------------------------------------------------
int CDmeModel::GetJointIndex( const char *pJointName ) const
{
	const int nJointCount = m_JointList.Count();
	for ( int i = 0; i < nJointCount; ++i )
	{
		if ( !V_strcmp( pJointName, m_JointList[ i ]->GetName() ) )
		{
			return i;
		}
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Determines joint transform index	given a joint name hash
//-----------------------------------------------------------------------------
int CDmeModel::GetJointIndex( CUtlStringToken nJointNameHash ) const
{
	const int nJointCount = m_JointList.Count();
	for ( int i = 0; i < nJointCount; ++i )
	{
		if ( MakeStringToken( m_JointList[ i ]->GetName() ) == nJointNameHash )
		{
			return i;
		}
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Returns the DmeDag for the specified joint index
//-----------------------------------------------------------------------------
CDmeDag *CDmeModel::GetJoint( int nIndex )
{
	return m_JointList[ nIndex ];
}


const CDmeDag *CDmeModel::GetJoint( int nIndex ) const
{
	return m_JointList[ nIndex ];
}


//-----------------------------------------------------------------------------
// Determines joint transform index	given a joint name
//-----------------------------------------------------------------------------
CDmeTransform *CDmeModel::GetJointTransform( int nIndex )
{
	return m_JointList[ nIndex ]->GetTransform();
}


const CDmeTransform *CDmeModel::GetJointTransform( int nIndex ) const
{
	return m_JointList[ nIndex ]->GetTransform();
}


//-----------------------------------------------------------------------------
// 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 ( !V_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
	const int nJointCount = m_JointList.Count();
	const int nCurrentCount = pTransformList->GetTransformCount();
	if ( nJointCount > nCurrentCount )
	{
		for ( int i = nCurrentCount; i < nJointCount; ++i )
		{
			CDmeTransform *pTransform = CreateElement<CDmeTransform>( m_JointList[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;

		CDmeDag *pDmeDag = m_JointList[i];
		if ( !pDmeDag )
		{
			char szTmpBuf0[ 38 ];
			UniqueIdToString( GetId(), szTmpBuf0, ARRAYSIZE( szTmpBuf0 ) );
			Warning( "DmeModel::CaptureJointsToBaseState( %s ): DmeModel %s[%s].jointList[ %d ] is NULL\n", pBaseStateName, GetName(), szTmpBuf0, i );
			continue;
		}

		CDmeTransform *pDmeTransform = pDmeDag->GetTransform();
		if ( !pDmeTransform )
		{
			char szTmpBuf0[ 38 ];
			UniqueIdToString( GetId(), szTmpBuf0, ARRAYSIZE( szTmpBuf0 ) );
			char szTmpBuf1[ 38 ];
			UniqueIdToString( pDmeDag->GetId(), szTmpBuf1, ARRAYSIZE( szTmpBuf1 ) );
			Warning( "DmeModel::CaptureJointsToBaseState( %s ) - DmeModel %s[%s].jointList[ %d ].transform ( %s[%s].transform ) is NULL\n", pBaseStateName, GetName(), szTmpBuf0, i, pDmeDag->GetName(), szTmpBuf1 );
			continue;
		}

		pDmeTransform->GetTransform( mat );
		pTransformList->SetTransform( i, mat );
	}
}


//-----------------------------------------------------------------------------
// Sets the joint transforms to the values in the specified base state, if it exists
//-----------------------------------------------------------------------------
void CDmeModel::PushBaseStateToJoints( const char *pBaseStateName )
{
	CDmeTransformList *pTransformList = FindBaseState( pBaseStateName );
	if ( !pTransformList )
		return;

	for ( int ii = 0; ii < pTransformList->GetTransformCount(); ++ii )
	{
		CDmeTransform *pSrcDmeTransform = pTransformList->GetTransform( ii );
		CDmeDag *pDmeJoint = GetJoint( ii );

		if ( !pSrcDmeTransform || !pDmeJoint )
			continue;

		CDmeTransform *pDstDmeTransform = pDmeJoint->GetTransform();
		if ( !pDstDmeTransform )
			continue;

		pDstDmeTransform->SetPosition( pSrcDmeTransform->GetPosition() );
		pDstDmeTransform->SetOrientation( pSrcDmeTransform->GetOrientation() );
	}
}


//-----------------------------------------------------------------------------
// Loads up joint transforms for this model
//-----------------------------------------------------------------------------
void CDmeModel::LoadJointTransform( CDmeDag *pJoint, CDmeTransformList *pBindPose, const matrix3x4_t &parentToWorld, const matrix3x4_t &parentToBindPose, bool bSetHardwareState )
{
	// Determines joint transform index; no index, no traversing lower in the hierarchy
	const int nJointIndex = GetJointIndex( pJoint );
	if ( nJointIndex < 0 )
		return;

	// FIXME: Sucky search here necessary to find bone matrix index
	matrix3x4_t	jointToWorld, jointToParent;
	pJoint->GetTransform()->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 )
{
	const int nJointCount = m_JointList.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 )
{
	if ( bZUp )
	{
		// Z up is technically ambiguous, but only Maya created SMD Z Up files, everything else assumes Z up is Valve engine Z up
		SetAxisSystem( CDmeAxisSystem::AS_VALVE_ENGINE );
	}
	else
	{
		SetAxisSystem( CDmeAxisSystem::AS_MAYA_YUP );
	}
}

//-----------------------------------------------------------------------------
// Returns the matrix that moves DmeModel data to engine space
//-----------------------------------------------------------------------------
void CDmeModel::GetModelToEngineMat( matrix3x4_t &modelToEngineMat )
{
	CDmeDag::DmeToEngineMatrix( modelToEngineMat, IsZUp() );
}


//-----------------------------------------------------------------------------
// Returns the matrix that moves engine data to DmeModel space
//-----------------------------------------------------------------------------
void CDmeModel::GetEngineToModelMat( matrix3x4_t &engineToModelMat )
{
	CDmeDag::EngineToDmeMatrix( engineToModelMat, IsZUp() );
}

//-----------------------------------------------------------------------------
// Returns true if the data under the DmeModel is AS_VALVE_ENGINE_SPACE ( Up: Z, Fwd: X, Left: Y )
// Returns false otherwise, NOTE: false doesn't imply any other axis system, examine m_eAxisSystem to see
//-----------------------------------------------------------------------------
bool CDmeModel::IsZUp() const
{
	Assert( m_eAxisSystem.GetElement() );

	if ( m_eAxisSystem.GetElement()->IsEqual( CDmeAxisSystem::AS_VALVE_ENGINE ) )
		return true;

	if ( m_eAxisSystem.GetElement()->IsEqual( CDmeAxisSystem::AS_MAYA_YUP ) )
		return false;

	AssertMsg( false, "CDmeModel::IsZUp() called, but axis system is neither AS_VALVE_ENGINE or AS_MAYA_YUP, cannot represent via true/false, ambiguous state" );

	return false;
}


//-----------------------------------------------------------------------------
// Replace all instances of a material with a different material
//-----------------------------------------------------------------------------
void CDmeModel::ReplaceMaterial( CDmeDag *pDag, const char *pOldMaterialName, const char *pNewMaterialName )
{
	if ( !pDag )
		return;

	CDmeMesh *pMesh = CastElement< CDmeMesh >( pDag->GetShape() );
	if ( pMesh )
	{
		pMesh->ReplaceMaterial( pOldMaterialName, pNewMaterialName );
	}

	int nCount = pDag->GetChildCount();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeDag	*pChild = pDag->GetChild( i );
		ReplaceMaterial( pChild, pOldMaterialName, pNewMaterialName );
	}
}

void CDmeModel::ReplaceMaterial( const char *pOldMaterialName, const char *pNewMaterialName )
{
	ReplaceMaterial( this, pOldMaterialName, pNewMaterialName );
}


//-----------------------------------------------------------------------------
// Gets the joint with the specified name
//-----------------------------------------------------------------------------
CDmeDag *CDmeModel::GetJoint( const char *pJointName )
{
	CDmeDag *pJoint = NULL;

	const int nJointCount = m_JointList.Count();
	for ( int i = 0; i < nJointCount; ++i )
	{
		pJoint = m_JointList[ i ];
		if ( !pJoint )
			continue;

		if ( !V_stricmp( pJointName, pJoint->GetName() ) )
			return pJoint;
	}

	return NULL;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::ReskinMeshes( const int *pJointTransformIndexRemap )
{
	ReskinMeshes( this, pJointTransformIndexRemap );
}


//-----------------------------------------------------------------------------
// Reskin meshes based on bone collapse
//-----------------------------------------------------------------------------
void CDmeModel::ReskinMeshes( CDmeDag *pDag, const int *pJointTransformIndexRemap )
{
	if ( !pDag )
		return;

	CDmeMesh *pMesh = CastElement< CDmeMesh >( pDag->GetShape() );
	if ( pMesh )
	{
		pMesh->Reskin( pJointTransformIndexRemap );
	}

	int nCount = pDag->GetChildCount();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeDag	*pChild = pDag->GetChild( i );
		ReskinMeshes( pChild, pJointTransformIndexRemap );
	}
}


//-----------------------------------------------------------------------------
// Remove joints
//-----------------------------------------------------------------------------
void CDmeModel::RemoveJoints( int nNewJointCount, const int *pInvJointRemap )
{
	const int nOldJointTransformCount = m_JointList.Count();

	const int nSizeInBytes = nNewJointCount * sizeof(CDmeTransform*);
	CDmeDag **ppJoints = (CDmeDag**)stackalloc( nSizeInBytes );
	for ( int i = 0; i < nNewJointCount; ++i )
	{
		ppJoints[i] = m_JointList[ pInvJointRemap[i] ];
	}

	m_JointList.RemoveAll();
	for ( int i = 0; i < nNewJointCount; ++i )
	{
		m_JointList.AddToTail( ppJoints[i] );
	}

	CUtlVectorFixedGrowable< CDmeTransform*, 256 > transforms;

	const int nCount = m_BaseStates.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeTransformList *pList = m_BaseStates[i];
		int nTransformCount = pList->GetTransformCount();
		transforms.SetCount( nTransformCount );
		int nStateJointCount = nNewJointCount;
		for ( int j = 0; j < nNewJointCount; ++j )
		{
			transforms[j] = pList->GetTransform( pInvJointRemap[j] );
		}
		for ( int j = nOldJointTransformCount; j < nTransformCount; ++j )
		{
			transforms[ nStateJointCount++ ] = pList->GetTransform( j );
		}

		pList->m_Transforms.RemoveAll();
		for ( int j = 0; j < nStateJointCount; ++j )
		{
			pList->m_Transforms.AddToTail( transforms[ j ] );
		}
	}
}


//-----------------------------------------------------------------------------
// Updates all base states by adding missing joints
//-----------------------------------------------------------------------------
void CDmeModel::UpdateBaseStates()
{
	const int nJointCount = m_JointList.Count();

	for ( int i = 0; i < m_BaseStates.Count(); ++i )
	{
		CDmeTransformList *pTransformList = m_BaseStates[i];
		if ( !pTransformList )
			continue;

		// Make the transform list have the correct number of elements
		const int nCurrentCount = pTransformList->GetTransformCount();

		if ( nJointCount < nCurrentCount )
		{
			pTransformList->m_Transforms.RemoveMultiple( nJointCount, nCurrentCount - nJointCount );
			return;
		}
		else if ( nJointCount == nCurrentCount )
		{
			return;
		}

		Assert( nJointCount > nCurrentCount );

		for ( int i = nCurrentCount; i < nJointCount; ++i )
		{
			CDmeTransform *pTransform = CreateElement<CDmeTransform>( m_JointList[i]->GetName(), pTransformList->GetFileId() );
			pTransformList->m_Transforms.AddToTail( pTransform );

			matrix3x4_t mat;
			CDmeDag *pDmeDag = m_JointList[i];
			if ( !pDmeDag )
				continue;

			CDmeTransform *pDmeTransform = pDmeDag->GetTransform();
			if ( !pDmeTransform )
				continue;

			pDmeTransform->GetTransform( mat );
			pTransformList->SetTransform( i, mat );
		}
	}
}


//-----------------------------------------------------------------------------
// Removes all children from this joint, moving shapes to be 
//-----------------------------------------------------------------------------
void CDmeModel::RemoveAllChildren( CDmeDag *pDag, CDmeDag *pSubtreeRoot, const matrix3x4_t &jointToSubtreeRoot )
{
	if ( !pDag )
		return;

	CDmeTransform *pDagTransform = pDag->GetTransform();
	matrix3x4_t curToSubtreeRoot, dagToParent;
	pDagTransform->GetTransform( dagToParent );
	ConcatTransforms( jointToSubtreeRoot, dagToParent, curToSubtreeRoot );

	if ( !CastElement< CDmeJoint >( pDag ) )
	{
		pSubtreeRoot->AddChild( pDag );
		pDagTransform->SetTransform( curToSubtreeRoot );
	}

	int nCount = pDag->GetChildCount();
	for ( int i = 0; i < nCount; ++i )
	{
		RemoveAllChildren( pDag->GetChild(i), pSubtreeRoot, curToSubtreeRoot );
	}

	pDag->RemoveAllChildren();
}

void CDmeModel::RemoveAllChildren( CDmeDag *pSubtreeRoot )
{
	matrix3x4_t root;
	SetIdentityMatrix( root );

	int nCount = pSubtreeRoot->GetChildCount();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeDag *pChild = pSubtreeRoot->GetChild(i);
		if ( !CastElement< CDmeJoint >( pChild ) )
			continue;
		RemoveAllChildren( pChild, pSubtreeRoot, root );
	}

	// Regetting the child count, as it has changed from the RemoveAllChildren calls
	nCount = pSubtreeRoot->GetChildCount();
	for ( int i = nCount; --i >= 0; )
	{
		if ( !CastElement< CDmeJoint >( pSubtreeRoot->GetChild(i) ) )
			continue;

		pSubtreeRoot->RemoveChild( i );
	}
}


//-----------------------------------------------------------------------------
// Collapses all joints below the specified joint name, reskinning any meshes
// referring to collapsed joints to use the specified joint instead
//-----------------------------------------------------------------------------
void CDmeModel::CollapseJoints( const char *pJointName )
{
	CDmeDag *pJoint = GetJoint( pJointName );
	if ( !pJoint )
		return;

	// Determine which joints must be collapsed
	CDmeDag *pParent;
	const int nCount = m_JointList.Count();
	bool *pIsCollapsed = (bool*)stackalloc( nCount * sizeof(bool) );
	for ( int i = 0; i < nCount; ++i ) 
	{
		CDmeDag *pTestJoint = m_JointList[ i ];
		if ( !pTestJoint )
			continue;

		pIsCollapsed[i] = ( pJoint->FindChild( pParent, pTestJoint ) >= 0 ); 
	}

	// Build remap indices
	int nNewJointCount = 0;
	int nCollapseJointIndex = 0;
	int* pJointRemap = (int*)stackalloc( nCount * sizeof(int) );
	int* pInvJointRemap = (int*)stackalloc( nCount * sizeof(int) );
	for ( int i = 0; i < nCount; ++i ) 
	{
		if ( pIsCollapsed[i] )
		{
			pJointRemap[i] = -1;
			continue;
		}

		if ( pJoint == m_JointList[i] )
		{
			nCollapseJointIndex = nNewJointCount;
		}
		pInvJointRemap[nNewJointCount] = i;
		pJointRemap[i] = nNewJointCount++;
	}

	for ( int i = 0; i < nCount; ++i ) 
	{
		if ( pJointRemap[i] < 0 )
		{
			pJointRemap[i] = nCollapseJointIndex;
		}
	}

	// Reskin meshes
	ReskinMeshes( this, pJointRemap );

	// Fixup joint transform + base state lists
	RemoveJoints( nNewJointCount, pInvJointRemap );

	// Remove all children from this node
	RemoveAllChildren( pJoint );

	stackfree( pIsCollapsed );
	stackfree( pJointRemap );
	stackfree( pInvJointRemap );
}



//-----------------------------------------------------------------------------
// Returns the matrix & quaternion to reorient
//-----------------------------------------------------------------------------
void CDmeModel::GetReorientData( matrix3x4_t &m, Quaternion &q, bool bMakeZUp )
{
	// YUP_ACTIVE: FIXME
	if ( bMakeZUp )
	{
		static const matrix3x4_t mYtoZ( 
			0.0f,  0.0f,  1.0f, 0.0f,
			1.0f,  0.0f,  0.0f, 0.0f,
			0.0f,  1.0f,  0.0f, 0.0f );

		m = mYtoZ;

		matrix3x4a_t mA;
		CDmeAxisSystem::GetConversionMatrix( mA, CDmeAxisSystem::AS_MAYA_YUP, CDmeAxisSystem::AS_VALVE_ENGINE );
		Assert( MatricesAreEqual( mYtoZ, mA ) );
	}
	else
	{
		static const matrix3x4_t mZtoY( 
			0.0f,  1.0f,  0.0f, 0.0f,
			0.0f,  0.0f,  1.0f, 0.0f,
			1.0f,  0.0f,  0.0f, 0.0f );
			
		m = mZtoY;

		matrix3x4a_t mA;
		CDmeAxisSystem::GetConversionMatrix( mA, CDmeAxisSystem::AS_VALVE_ENGINE, CDmeAxisSystem::AS_MAYA_YUP );
		Assert( MatricesAreEqual( mZtoY, mA, 1.0e-4 ) );
	}

	MatrixQuaternion( m, q );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::ReorientDmeAnimation( CDmeDag *pDmeDag, const matrix3x4_t &mOrient, const Quaternion &qOrient )
{
	if ( !pDmeDag )
		return;

	CUtlVector< CDmeChannel * > dmeChannelList;

	if ( !FindReferringElements( dmeChannelList, pDmeDag->GetTransform(), g_pDataModel->GetSymbol( "toElement" ) ) || dmeChannelList.Count() < 0 )
		return;

	const int nDmeChannelCount = dmeChannelList.Count();
	for ( int i = 0; i < nDmeChannelCount; ++i )
	{
		CDmeChannel *pDmeChannel = dmeChannelList[ i ];
		if ( !pDmeChannel )
			continue;

		CDmeLog *pDmeLog = pDmeChannel->GetLog();
		if ( !pDmeLog )
			continue;

		const int nLogLayerCount = pDmeLog->GetNumLayers();
		for ( int j = 0; j < nLogLayerCount; ++j )
		{
			CDmeLogLayer *pDmeLogLayer = pDmeLog->GetLayer( j );

			CDmeVector3LogLayer *pDmeVector3LogLayer = CastElement< CDmeVector3LogLayer >( pDmeLogLayer );
			if ( pDmeVector3LogLayer  )
			{
				RotatePositionLog( pDmeVector3LogLayer, mOrient );
				continue;
			}

			CDmeQuaternionLogLayer *pDmeQuaternionLogLayer = CastElement< CDmeQuaternionLogLayer >( pDmeLogLayer );
			if ( pDmeQuaternionLogLayer  )
			{
				RotateOrientationLog( pDmeQuaternionLogLayer, mOrient, true );
				continue;
			}
		}
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::ReorientDmeTransform( CDmeTransform *pDmeTransform, const matrix3x4_t &mOrient, const Quaternion &qOrient )
{
	if ( !pDmeTransform )
		return;

	Vector vTmp;
	VectorRotate( pDmeTransform->GetPosition(), mOrient, vTmp );
	pDmeTransform->SetPosition( vTmp );

	Quaternion qTmp;
	QuaternionMult( qOrient, pDmeTransform->GetOrientation(), qTmp );
	pDmeTransform->SetOrientation( qTmp );
}

//-----------------------------------------------------------------------------
// Changes the orientation of the vertices and normals of a CDmeMesh using
// the given transform.
//-----------------------------------------------------------------------------
void CDmeModel::ReorientDmeMesh( CDmeMesh *pDmeMesh, matrix3x4_t absMat )
{
	CDisableUndoScopeGuard();

	CDmeVertexData *pDmeVertexData = pDmeMesh->GetBindBaseState();

	FieldIndex_t nFieldPosIndex = pDmeVertexData->FindFieldIndex( CDmeVertexDataBase::FIELD_POSITION );
	FieldIndex_t nFieldNormIndex = pDmeVertexData->FindFieldIndex( CDmeVertexDataBase::FIELD_NORMAL );
	if ( nFieldPosIndex >= 0 && nFieldNormIndex > 0 )
	{
		CDmAttribute *pDmPositionAttr = pDmeVertexData->GetVertexData( nFieldPosIndex );
		CDmAttribute *pDmNormalAttr = pDmeVertexData->GetVertexData( nFieldNormIndex );

		CDmrArray< Vector > positions( pDmPositionAttr );
		CDmrArray< Vector > normals( pDmNormalAttr );

		CUtlVector<Vector> newPositions;

		matrix3x4_t normalMat;
		MatrixInverseTranspose( absMat, normalMat );

		for ( int i = 0; i < positions.Count(); ++i )
		{
			Vector newPosition;

			VectorTransform( positions[i], absMat, newPosition );
			positions.Set( i, newPosition );
		}

		for ( int i = 0; i < normals.Count(); ++i )
		{
			Vector normalizedNormal;
			Vector newNormal;

			VectorCopy( normals[i], normalizedNormal );
			VectorNormalize( normalizedNormal );
			VectorRotate( normalizedNormal, normalMat, newNormal );
			normals.Set( i, newNormal );
		}

	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::ReorientDmeModelChildren( CDmeModel *pDmeModel, const matrix3x4_t &mOrient, const Quaternion &qOrient )
{
	if ( !pDmeModel )
		return;

	CDmeTransformList *pDmeTransformList = pDmeModel->FindBaseState( "bind" );
	const int nTransformCount = pDmeTransformList ? pDmeTransformList->GetTransformCount() : 0;

	const int nChildCount = pDmeModel->GetChildCount();
	for ( int i = 0; i < nChildCount; ++i )
	{
		CDmeDag *pDmeDag = pDmeModel->GetChild( i );
		if ( !pDmeDag )
			continue;

		ReorientDmeTransform( pDmeDag->GetTransform(), mOrient, qOrient );

		if ( pDmeTransformList )
		{
			int nJointIndex = pDmeModel->GetJointIndex( pDmeDag );
			if ( nJointIndex >= 0 && nJointIndex < nTransformCount )
			{
				ReorientDmeTransform( pDmeTransformList->GetTransform( nJointIndex ), mOrient, qOrient );
			}
		}

		ReorientDmeAnimation( pDmeDag, mOrient, qOrient );
	}
}


//-----------------------------------------------------------------------------
// Changes the orientation of a given CDmeDag's mesh data and those of any 
// children the CDmeDag has.
//-----------------------------------------------------------------------------
void CDmeModel::ReorientChildDmeMeshes_R( CDmeDag *pDmeDag )
{
	// Reorient the Dag's shape
	CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( pDmeDag->GetShape() );

	if ( pDmeMesh ) 
	{
		matrix3x4_t absMat;
		pDmeDag->GetAbsTransform( absMat );

		ReorientDmeMesh( pDmeMesh, absMat );
	}

	// Recurse all child CDmeDags and 
	const int nChildCount = pDmeDag->GetChildCount();
	for ( int i = 0; i < nChildCount; ++i )
	{
		ReorientChildDmeMeshes_R( pDmeDag->GetChild( i ) );
	}
}


//-----------------------------------------------------------------------------
// Walks through the immediate children of this DmeModel and bakes the world
// space transform of any DmeMesh into its vertices and then sets the transform
// of that mesh to the identity.  Currently only called by hammer import and
// hammer <-> modo in modo via ReorientToEngineSpace & ReorientToDCCToolSpace
// dmeutils to convert DmeMesh to CMesh uses ReorientToValveEngineSpace
// which does not call FreezeChildMeshes.  FreezeChildMeshes is also not a
// complete implementation as it doesn't take into account deltas on meshes
//-----------------------------------------------------------------------------
void CDmeModel::FreezeChildMeshes()
{
	const int nChildCount = GetChildCount();
	for ( int i = 0; i < nChildCount; ++i )
	{
		CDmeDag *pDmeDag = GetChild( i );
		if ( !pDmeDag )
			continue;

		ReorientChildDmeMeshes_R( pDmeDag );

		// Zero out the rotation since ReorientChildDmeMeshes_R bakes it into the mesh
		CDmeTransform *pTransform = pDmeDag->GetTransform();
		if ( pTransform )
		{
			Quaternion qZero;
			qZero.Init();
			pTransform->SetOrientation( qZero );
		}
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeModel::SetAxisSystem( CDmeAxisSystem::PredefinedAxisSystem ePredefAxisSystem )
{
	if ( !m_eAxisSystem.GetElement() )
		return false;

	return m_eAxisSystem.GetElement()->Init( ePredefAxisSystem );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeModel::SetAxisSystem(
	CDmeAxisSystem::Axis_t eUpAxis,
	CDmeAxisSystem::ForwardParity_t eForwardParity,
	CDmeAxisSystem::CoordSys_t eCoordSys /* = CDmeAxisSystem::AS_RIGHT_HANDED */ )
{
	if ( !m_eAxisSystem.GetElement() )
		return false;

	return m_eAxisSystem.GetElement()->Init( eUpAxis, eForwardParity, eCoordSys );
}


//-----------------------------------------------------------------------------
// This expects the app has handled undo
//-----------------------------------------------------------------------------
bool CDmeModel::ConvertToAxisSystem( CDmeAxisSystem::PredefinedAxisSystem eToPredefinedAxisSystem )
{
	if ( !m_eAxisSystem.GetElement() )
		return false;

	CDmeAxisSystem::Axis_t eToUpAxis;
	CDmeAxisSystem::ForwardParity_t eToForwardParity;
	CDmeAxisSystem::CoordSys_t eToCoordSys;

	if ( !CDmeAxisSystem::GetPredefinedAxisSystem( eToUpAxis, eToForwardParity, eToCoordSys, eToPredefinedAxisSystem ) )
		return false;

	return ConvertToAxisSystem( eToUpAxis, eToForwardParity, eToCoordSys );
}


//-----------------------------------------------------------------------------
// This expects the app has handled undo
//-----------------------------------------------------------------------------
bool CDmeModel::ConvertToAxisSystem(
	CDmeAxisSystem::Axis_t eToUpAxis,
	CDmeAxisSystem::ForwardParity_t eToForwardParity,
	CDmeAxisSystem::CoordSys_t eToCoordSys /* = CDmeAxisSystem::AS_RIGHT_HANDED */ )
{
	if ( !m_eAxisSystem.GetElement() )
		return false;

	if ( !CDmeAxisSystem::IsValid( eToUpAxis, eToForwardParity, eToCoordSys ) )
		return false;

	const CDmeAxisSystem *pFromDmeAxisSystem = m_eAxisSystem.GetElement();

	Assert( pFromDmeAxisSystem->IsValid() );

	const CDmeAxisSystem::Axis_t eFromUpAxis = pFromDmeAxisSystem->GetUpAxis();
	const CDmeAxisSystem::ForwardParity_t eFromForwardParity = pFromDmeAxisSystem->GetForwardParity();
	const CDmeAxisSystem::CoordSys_t eFromCoordSys = pFromDmeAxisSystem->GetCoordSys();

	Assert( CDmeAxisSystem::IsValid( eToUpAxis, eToForwardParity, eToCoordSys ) );

	if ( eFromUpAxis == eToUpAxis &&
		 eFromForwardParity == eToForwardParity &&
		 eFromCoordSys == eToCoordSys )
	{
		// No change needed
		return true;
	}

	matrix3x4a_t mConversion = g_MatrixIdentity;
	CDmeAxisSystem::GetConversionMatrix( mConversion, eFromUpAxis, eFromForwardParity, eFromCoordSys, eToUpAxis, eToForwardParity, eToCoordSys );
	const Quaternion qConversion = MatrixQuaternion( mConversion );

	ReorientDmeModelChildren( this, mConversion, qConversion );

	m_UpAxis.Set( "axisSystem" );

	return SetAxisSystem( eToUpAxis, eToForwardParity, eToCoordSys );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmeModel::GetConversionMatrix( matrix3x4a_t &mConversion, CDmeAxisSystem::PredefinedAxisSystem eToPredefinedAxisSystem )
{
	const CDmeAxisSystem *pFromDmeAxisSystem = m_eAxisSystem.GetElement();

	Assert( pFromDmeAxisSystem->IsValid() );

	const CDmeAxisSystem::Axis_t eFromUpAxis = pFromDmeAxisSystem->GetUpAxis();
	const CDmeAxisSystem::ForwardParity_t eFromForwardParity = pFromDmeAxisSystem->GetForwardParity();
	const CDmeAxisSystem::CoordSys_t eFromCoordSys = pFromDmeAxisSystem->GetCoordSys();

	CDmeAxisSystem::Axis_t eToUpAxis;
	CDmeAxisSystem::ForwardParity_t eToForwardParity;
	CDmeAxisSystem::CoordSys_t eToCoordSys;

	if ( !CDmeAxisSystem::GetPredefinedAxisSystem( eToUpAxis, eToForwardParity, eToCoordSys, eToPredefinedAxisSystem ) )
		return false;

	CDmeAxisSystem::GetConversionMatrix( mConversion, eFromUpAxis, eFromForwardParity, eFromCoordSys, eToUpAxis, eToForwardParity, eToCoordSys );

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::TransformScene(
	const Vector &vScale /*= Vector( 1.0f, 1.0f, 1.0f )*/,
	const Vector &vTranslate /*= vec3_origin*/,
	const DegreeEuler &eRotation /*= DegreeEuler( 0.0f, 0.0f, 0.0f )*/,
	float flEps /*= 1.0e-4 */ )
{
	if ( !VectorsAreEqual( vScale, Vector( 1.0f, 1.0f, 1.0f ), flEps ) )
	{
		ScaleScene( vScale );
	}

	if ( !VectorsAreEqual( vTranslate, vec3_origin, flEps ) || !DegreeEulersAreEqual( eRotation, DegreeEuler( 0.0f, 0.0f, 0.0f ), flEps ) )
	{
		matrix3x4a_t mTransform;
		AngleMatrix( RadianEuler( eRotation ), vTranslate, mTransform );

		matrix3x4a_t mIdentity;
		SetIdentityMatrix( mIdentity );

		matrix3x4a_t mDag;
		CDmeTransform *pDmeModelTransform = GetTransform();
		pDmeModelTransform->GetTransform( mDag );

		if ( MatricesAreEqual( mDag, mIdentity, flEps ) )
		{
			// DmeModel is just a group, leave it alone, put transform on all children
			const int nChildCount = GetChildCount();
			for ( int i = 0; i < nChildCount; ++i )
			{
				CDmeDag *pDmeDagChild = GetChild( i );
				CDmeTransform *pDmeTransform = pDmeDagChild->GetTransform();
				pDmeTransform->GetTransform( mDag );
				pDmeTransform->SetTransform( ConcatTransforms( mTransform, mDag ) );
			}
		}
		else
		{
			// DmeModel has transformation data of its own... put transform on it
			pDmeModelTransform->SetTransform( ConcatTransforms( mTransform, mDag ) );
		}
	}

	CaptureJointsToBaseState( "bind" );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeModel::ScaleScene( const Vector &vScale )
{
	CUtlStack< CDmeDag * > depthFirstStack;
	depthFirstStack.Push( this );

	while ( depthFirstStack.Count() > 0 )
	{
		CDmeDag *pDmeDag = depthFirstStack.Top();
		depthFirstStack.Pop();

		if ( !pDmeDag )
			continue;

		const int nChildCount = pDmeDag->GetChildCount();
		for ( int i = nChildCount + 1; i >= 0; --i )
		{
			depthFirstStack.Push( pDmeDag->GetChild( i ) );
		}

		CDmeTransform *pDmeTransform = pDmeDag->GetTransform();
		Vector vLocalPos = pDmeTransform->GetPosition();
		vLocalPos.x *= vScale.x;
		vLocalPos.y *= vScale.y;
		vLocalPos.z *= vScale.z;
		pDmeTransform->SetPosition( vLocalPos );

		matrix3x4a_t mScale;
		SetScaleMatrix( vScale, mScale );

		matrix3x4a_t mScaleInvTranspose;
		MatrixInverseTranspose( mScale, mScaleInvTranspose );

		CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( pDmeDag->GetShape() );
		if ( pDmeMesh )
		{
			CUtlVector< CDmeVertexDataBase * > vertexDataList;

			const int nStateCount = pDmeMesh->BaseStateCount();
			for ( int i = 0; i < nStateCount; ++i )
			{
				CDmeVertexDataBase *pDmeVertexData = pDmeMesh->GetBaseState( i );
				if ( pDmeVertexData )
				{
					vertexDataList.AddToTail( pDmeVertexData );
				}
			}

			// TODO: See if delta data needs to be scaled differently, positions shouldn't but normals might
			const int nDeltaStateCount = pDmeMesh->DeltaStateCount();
			for ( int i = 0; i < nDeltaStateCount; ++i )
			{
				CDmeVertexDataBase *pDmeVertexData = pDmeMesh->GetDeltaState( i );
				if ( pDmeVertexData )
				{
					vertexDataList.AddToTail( pDmeVertexData );
				}
			}

			const int nVertexDataCount = vertexDataList.Count();
			for ( int i = 0; i < nVertexDataCount; ++i )
			{
				CDmeVertexDataBase *pDmeVertexData = vertexDataList[i];

				const FieldIndex_t nPosFieldIndex = pDmeVertexData->FindFieldIndex( CDmeVertexDataBase::FIELD_POSITION );
				if ( nPosFieldIndex >= 0 )
				{
					CDmrArray< Vector > vertexData = pDmeVertexData->GetVertexData( nPosFieldIndex );

					const int nDataCount = vertexData.Count();
					for ( int j = 0; j < nDataCount; ++j )
					{
						vertexData.Set( j, VectorTransform( vertexData.Get( j ), mScale ) );
					}
				}

				const FieldIndex_t nNormalFieldIndex = pDmeVertexData->FindFieldIndex( CDmeVertexDataBase::FIELD_NORMAL );
				if ( nPosFieldIndex >= 0 )
				{
					CDmrArray< Vector > vertexData = pDmeVertexData->GetVertexData( nNormalFieldIndex );

					const int nDataCount = vertexData.Count();
					for ( int j = 0; j < nDataCount; ++j )
					{
						vertexData.Set( j, VectorTransform( vertexData.Get( j ), mScaleInvTranspose ).Normalized() );
					}
				}
			}
		}
	}
}


#if 0
//-----------------------------------------------------------------------------
// temp function for validation of code changes, used by CompareDmeDag_R
//-----------------------------------------------------------------------------
static bool CompareDmeMeshes( CDmeMesh *pDmeMeshA, CDmeMesh *pDmeMeshB )
{
	if ( !pDmeMeshA && !pDmeMeshB )
		return true;

	if ( !pDmeMeshA || !pDmeMeshB )
		return false;

	pDmeMeshA->Resolve();
	pDmeMeshB->Resolve();

	if ( pDmeMeshA->BaseStateCount() != pDmeMeshB->BaseStateCount() )
	{
		AssertMsg( 0, "DmeMesh BaseStateCount mismatch: %s:%d vs %s:%d\n", pDmeMeshA->GetName(), pDmeMeshA->BaseStateCount(), pDmeMeshB->GetName(), pDmeMeshB->BaseStateCount() );
		return false;
	}

	CDmeVertexData *pDmeVertexDataA = pDmeMeshA->GetBindBaseState();
	CDmeVertexData *pDmeVertexDataB = pDmeMeshB->GetBindBaseState();

	if ( !pDmeVertexDataA && !pDmeVertexDataB )
		return true;	// No vertex data in bind base state... not really a good state but they are the same

	if ( !pDmeVertexDataA || !pDmeVertexDataB )
	{
		AssertMsg( 0, "DmeMesh one NULL BindBaseState: %s:0x%p vs %s:0x%p\n", pDmeMeshA->GetName(), pDmeVertexDataA, pDmeMeshB->GetName(), pDmeVertexDataB );
		return false;
	}

	pDmeVertexDataA->Resolve();
	pDmeVertexDataB->Resolve();

	const CUtlVector< Vector > &posDataA = pDmeVertexDataA->GetPositionData();
	const CUtlVector< Vector > &posDataB = pDmeVertexDataB->GetPositionData();

	if ( posDataA.Count() != posDataB.Count() )
	{
		AssertMsg( 0, "DmeMesh posData count mismatch: %s:%d vs %s:%d\n", pDmeMeshA->GetName(), posDataA.Count(), pDmeMeshB->GetName(), posDataB.Count() );
		return false;
	}

	for ( int i = 0; i < posDataA.Count(); ++i )
	{
		if ( !VectorsAreEqual( posDataA[i], posDataB[i] ) )
		{
			AssertMsg( 0, "DmeMesh posData vector mismatch: %d %s:< %6.2f %6.2f %6.2f > vs %s:< %6.2f %6.2f %6.2f >\n",
				i,
				pDmeMeshA->GetName(),
				posDataA[i].x,
				posDataA[i].y,
				posDataA[i].z,
				pDmeMeshB->GetName(),
				posDataB[i].x,
				posDataB[i].y,
				posDataB[i].z );
			return false;
		}
	}

	const CUtlVector< Vector > &normalDataA = pDmeVertexDataA->GetNormalData();
	const CUtlVector< Vector > &normalDataB = pDmeVertexDataB->GetNormalData();

	if ( normalDataA.Count() != normalDataB.Count() )
	{
		AssertMsg( 0, "DmeMesh normalData count mismatch: %s:%d vs %s:%d\n", pDmeMeshA->GetName(), normalDataA.Count(), pDmeMeshB->GetName(), normalDataB.Count() );
		return false;
	}

	for ( int i = 0; i < normalDataA.Count(); ++i )
	{
		if ( !VectorsAreEqual( normalDataA[i], normalDataB[i] ) )
		{
			AssertMsg( 0, "DmeMesh normalData vector mismatch: %d %s:< %6.2f %6.2f %6.2f > vs %s:< %6.2f %6.2f %6.2f >\n",
				i,
				pDmeMeshA->GetName(),
				normalDataA[i].x,
				normalDataA[i].y,
				normalDataA[i].z,
				pDmeMeshB->GetName(),
				normalDataB[i].x,
				normalDataB[i].y,
				normalDataB[i].z );
			return false;
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// temp function for validation of code changes, used by CompareDmeDag_R
//-----------------------------------------------------------------------------
static bool CompareDmeDag_R( CDmeDag *pDmeDagA, CDmeDag *pDmeDagB )
{
	// Both NULL, Ok
	if ( !pDmeDagA && !pDmeDagB )
		return true;

	// Only one NULL, bad
	if ( !pDmeDagA || !pDmeDagB )
	{
		AssertMsg( 0, "One Dag NULL, the other isn't: 0x%p vs 0x%p\n", pDmeDagA, pDmeDagB );
		return false;
	}

	// Names don't match, bad
	if ( V_strcmp( pDmeDagA->GetName(), pDmeDagB->GetName() ) )
	{
		AssertMsg( 0, "Shape name mismatch: %s vs %s\n", pDmeDagA->GetName(), pDmeDagB->GetName() );
		return false;
	}

	// Transforms don't match, bad
	CDmeTransform *pDmeTransformA = pDmeDagA->GetTransform();
	CDmeTransform *pDmeTransformB = pDmeDagB->GetTransform();

	if ( pDmeTransformA && pDmeTransformB )
	{
		matrix3x4a_t mA;
		pDmeTransformA->GetTransform( mA );

		matrix3x4a_t mB;
		pDmeTransformB->GetTransform( mB );

		if ( !MatricesAreEqual( mA, mB ) )
		{
			AssertMsg( 0, "Matrix mismatch" );
			return false;
		}
	}
	else if ( pDmeTransformA || pDmeTransformB )
	{
		AssertMsg( 0, "One DmeTransform NULL, the other isn't: %s 0x%p vs %s 0x%p \n", pDmeDagA->GetName(), pDmeTransformA, pDmeDagB->GetName(), pDmeTransformB );
		return false;
	}

	// Compare shapes, if they exist
	CDmeShape *pDmeShapeA = pDmeDagA->GetShape();
	CDmeShape *pDmeShapeB = pDmeDagB->GetShape();

	if ( pDmeShapeA && pDmeShapeB )
	{
		if ( pDmeShapeA->GetType() != pDmeShapeB->GetType() )
		{
			AssertMsg( 0, "Shape type mismatch: %s vs %s\n", pDmeShapeA->GetTypeString(), pDmeShapeB->GetTypeString() );
			return false;
		}

		if ( pDmeShapeA->IsA( CDmeMesh::GetStaticTypeSymbol() ) )
		{
			if ( !CompareDmeMeshes( CastElement< CDmeMesh >( pDmeShapeA ), CastElement< CDmeMesh >( pDmeShapeB ) ) )
			{
				AssertMsg( 0, "Mesh Mismatch: %s vs %s\n", pDmeShapeA->GetName(), pDmeShapeB->GetName() );
				return false;
			}
		}
	}
	else if ( pDmeShapeA || pDmeShapeB )
	{
		AssertMsg( 0, "One Shape NULL, the other isn't: 0x%p vs 0x%p\n", pDmeShapeA, pDmeShapeB );
		return false;
	}

	// Child count don't match, bad
	const int nChildCountA = pDmeDagA->GetChildCount();
	const int nChildCountB = pDmeDagB->GetChildCount();

	if ( nChildCountA != nChildCountB )
		return false;

	// Compare their children
	for ( int i = 0; i < nChildCountA; ++i )
	{
		if ( !CompareDmeDag_R( pDmeDagA->GetChild( i ), pDmeDagB->GetChild( i ) ) )
			return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// temp function for validation of code changes, used by CompareDmeDag_R
//-----------------------------------------------------------------------------
static void ResolveDmeDagHierarchy_R( CDmeDag *pDmeDag )
{
	if ( !pDmeDag )
		return;

	pDmeDag->Resolve();
	CDmeShape *pDmeShape = pDmeDag->GetShape();

	if ( pDmeShape )
	{
		pDmeShape->Resolve();

		CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( pDmeShape );
		if ( pDmeMesh )
		{
			pDmeMesh->Resolve();
			for ( int i = 0; i < pDmeMesh->BaseStateCount(); ++i )
			{
				CDmeVertexData *pDmeVertexData = pDmeMesh->GetBaseState( i );
				if ( pDmeVertexData )
				{
					pDmeVertexData->Resolve();
				}
			}
		}
	}

	for ( int i = 0; i < pDmeDag->GetChildCount(); ++i )
	{
		ResolveDmeDagHierarchy_R( pDmeDag->GetChild( i ) );
	}
}
#endif // 0