tf2/tf2_src/movieobjects/dmsmdserializer.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Read SMD and create DMX data
//
//=============================================================================


// Because we use STL
#pragma warning( disable: 4530 )


// Standard includes
#include <io.h>
#include <algorithm>
#include <deque>
#include <fstream>
#include <list>
#include <map>
#include <string>


// Valve includes
#include "movieobjects/dmeanimationlist.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmedag.h"
#include "movieobjects/dmemesh.h"
#include "movieobjects/dmefaceset.h"
#include "movieobjects/dmematerial.h"
#include "movieobjects/dmemodel.h"
#include "movieobjects/dmsmdserializer.h"
#include "filesystem.h"
#include "tier1/characterset.h"
#include "tier1/fmtstr.h"
#include "tier2/tier2.h"
#include "mathlib/mathlib.h"


// Last include
#include "tier0/memdbgon.h"


//=============================================================================
//
// CDmSmdSerializer
//
//=============================================================================
//-----------------------------------------------------------------------------
// Convert from SMD -> DME
//-----------------------------------------------------------------------------
bool CDmSmdSerializer::Unserialize(
	CUtlBuffer &utlBuf,
	const char * /* pszEncodingName */,
	int /* nEncodingVersion */,
	const char * /* pszSourceFormatName */,
	int /* nSourceFormatVersion */,
	DmFileId_t nDmFileId,
	DmConflictResolution_t /* nDmConflictResolution */,
	CDmElement **ppDmRoot )
{
	if ( !ppDmRoot )
		return false;

	const char *pszFilename = g_pDataModel->GetFileName( nDmFileId );

	if ( pszFilename )
	{
		char szFilename[ MAX_PATH ];
		V_strncpy( szFilename, pszFilename, ARRAYSIZE( szFilename ) );
		V_FixSlashes( szFilename );

		*ppDmRoot = ReadSMD( utlBuf, nDmFileId, szFilename, NULL );
	}
	else
	{
		*ppDmRoot = ReadSMD( utlBuf, nDmFileId, "utlBuffer", NULL );
	}

	return *ppDmRoot != NULL;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmElement *CDmSmdSerializer::ReadSMD(
	const char *pszFilename,
	CDmeMesh **ppDmeMeshCreated /* = NULL */ )
{
	char szFilename[ MAX_PATH ];
	V_strncpy( szFilename, pszFilename, ARRAYSIZE( szFilename ) );
	V_FixSlashes( szFilename );

	CUtlBuffer utlBuf( 0, 0, CUtlBuffer::TEXT_BUFFER );

	if ( !g_pFullFileSystem->ReadFile( szFilename, NULL, utlBuf ) )
		return NULL;

	DmFileId_t nDmFileId = g_pDataModel->FindOrCreateFileId( pszFilename );

	return ReadSMD( utlBuf, nDmFileId, szFilename, ppDmeMeshCreated );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmSmdSerializer::SetUpAxis( CDmSmdSerializer::Axis_t nUpAxis )
{
	m_nUpAxis = clamp( nUpAxis, X_AXIS, Z_AXIS );

	switch ( m_nUpAxis )
	{
	case X_AXIS:	// X Up
		AngleMatrix( RadianEuler( -M_PI / 2.0, M_PI / 2.0, 0.0 ), m_mAdj );
		MatrixInverseTranspose( m_mAdj, m_mAdjNormal );
		break;
	case Y_AXIS:	// Y Up
		SetIdentityMatrix( m_mAdj );
		SetIdentityMatrix( m_mAdjNormal );
		break;
	case Z_AXIS:
	default:
		AngleMatrix( RadianEuler( -M_PI / 2.0, 0.0, 0.0 ), m_mAdj );
		MatrixInverseTranspose( m_mAdj, m_mAdjNormal );
		break;
	}
}


//-----------------------------------------------------------------------------
// Tests whether the passed buffer is an all whitespace line or not
//-----------------------------------------------------------------------------
static bool ParserIsBlankLine( const char *pszBuf )
{
	for ( const char *pChar = pszBuf; *pChar; ++pChar )
	{
		if ( !V_isspace( static_cast< unsigned char >( *pChar ) ) )
			return false;
	}

	return true;
}


//-----------------------------------------------------------------------------
// Skips over whitespace
//-----------------------------------------------------------------------------
static const char *ParserSkipSpace( const char *pszBuf )
{
	// Skip to first non-whitespace character
	for ( ;; )
	{
		if ( !V_isspace( static_cast< unsigned char >( *pszBuf ) ) )
			break;

		++pszBuf;
	}

	return pszBuf;
}


//-----------------------------------------------------------------------------
// Returns true the specified buffer is a comment line
// meaning that it starts with // (with optional white space preceding the //)
//-----------------------------------------------------------------------------
static bool IsCommentLine( const char *pszBuf )
{
	pszBuf = ParserSkipSpace( pszBuf );

	if ( *pszBuf && *pszBuf == '/' && *( pszBuf + 1 ) == '/' )
	{
		return true;
	}

	return false;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool ParserHandleVersion( const char *pszBuf, int *pnVersion = NULL )
{
	pszBuf = ParserSkipSpace( pszBuf );

	if ( !( *pszBuf && V_strnicmp( pszBuf, "version", 7 ) == 0 ) )
		return false;

	if ( pnVersion )
	{
		*pnVersion = strtol( pszBuf + 7, NULL, 0 );	// Skip past "version"
	}

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool ParserHandleSectionStart( const char *pszBuf, const char *pszSectionId )
{
	pszBuf = ParserSkipSpace( pszBuf );

	if ( ! *pszBuf )
		return false;
	
	const int nCmd = V_stricmp( pszBuf, pszSectionId );
	if ( !nCmd )
		return true;

	return false;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool ParserHandleTime( const char *pszBuf, int &nTime )
{
	if ( sscanf( pszBuf, "time %d", &nTime ) == 1 )
		return true;

	return false;
}


//-----------------------------------------------------------------------------
// Strip trailing CR/NL
//-----------------------------------------------------------------------------
static void Chomp( char *pszBuf )
{
	char *pChar = pszBuf + V_strlen( pszBuf ) - 1;

	while ( pChar >= pszBuf && ( *pChar == '\n' || *pChar == '\r' ) )
	{
		*pChar = '\0';
	}
}



//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void GetLine( CUtlBuffer &utlBuf, char *pszBuf, int nMaxLen )
{
	utlBuf.GetLine( pszBuf, nMaxLen );
	Chomp( pszBuf );
}


//=============================================================================
//
//=============================================================================
class CQcData
{
public:
	CQcData()
	: m_nUpAxis( CDmSmdSerializer::Z_AXIS )
	, m_scale( 1.0f )
	{}

	bool ParseQc( const CUtlString &smdPath, const CUtlString &qcPath );

	bool GetQcData( const CUtlString &smdPath );

	CDmSmdSerializer::Axis_t m_nUpAxis;
	float m_scale;
	std::list< std::string > m_cdmaterials;
};


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool HandleQcHints(
	const char *pBuf,
	CQcData &qcData )
{
	if ( !IsCommentLine( pBuf ) )
		return false;

	char key[ 512 ];
	key[0] = '\0';

	char val[ 512 ];
	val[0] = '\0';

	if ( sscanf( pBuf, "// %511s=%511s", key, val ) == 2 )
	{
		if ( Q_stricmp( key, "UPAXIS" ) == 0 )
		{
			if ( strpbrk( val, "xX" ) )
			{
				qcData.m_nUpAxis = CDmSmdSerializer::X_AXIS;
			}
			else if ( strpbrk( val, "yY" ) )
			{
				qcData.m_nUpAxis = CDmSmdSerializer::Y_AXIS;
			}
			else if ( strpbrk( val, "zZ" ) )
			{
				qcData.m_nUpAxis = CDmSmdSerializer::Z_AXIS;
			}
		}
	}

	key[ ARRAYSIZE(key) - 1 ] = '\0';
	val[ ARRAYSIZE(val) - 1 ] = '\0';
	
	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void Tokenize( CUtlVector< CUtlString > &tokens, const char *pszBuf )
{
	tokens.RemoveAll();
	CUtlString strBuf( pszBuf );

	for ( char *pszToken = strtok( (char *)strBuf.Get(), " \t\n" ); pszToken; pszToken = strtok( NULL, " \t\n" ) )
	{
		tokens.AddToTail( pszToken );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmSmdSerializer::ParserGetNodeName( const char *pszBuf, CUtlString &sName ) const
{
	sName = ParserSkipSpace( pszBuf );
	FixNodeName( sName );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmSmdSerializer::ParserHandleSkeletonLine(
	const char *pszBuf,
	CUtlString &sName,
	int &nId,
	int &nParentId ) const
{
	const char *pszOrigBuf = pszBuf;

	pszBuf = ParserSkipSpace( pszBuf );

	char szTmpBuf[ 512 ];
	if ( sscanf( pszBuf, "%d \"%[^\"]\" %d", &nId, szTmpBuf, &nParentId ) == 3 )
	{
		ParserGetNodeName( szTmpBuf, sName );
		return true;
	}

	Warning( "Warning! Ignoring malformed skeleton line: %s\n", pszOrigBuf );

	return false;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CUtlString PathJoin( const char *pszStr1, const char *pszStr2 )
{
	char szPath[MAX_PATH];
	V_ComposeFileName( pszStr1, pszStr2, szPath, sizeof( szPath ) );
	return CUtlString( szPath );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CQcData::ParseQc(
	const CUtlString &smdPath,
	const CUtlString &qcPath )
{
	bool bRetVal = false;

	if ( _access( qcPath.Get(), 04 ) == 0 )
	{
		try
		{
			std::string buf;
			std::ifstream ifs( qcPath.Get() );

			CUtlVector< CUtlString > tokens;

			while ( std::getline( ifs, buf ) )
			{
				Tokenize( tokens, buf.c_str() );

				if ( tokens.Count() < 1 )
					continue;

				if ( !V_stricmp( tokens[0], "$upaxis" ) )
				{
					if ( strchr( tokens[1].Get(), 'y' ) || strchr( tokens[1].Get(), 'Y' ) )
					{
						m_nUpAxis = CDmSmdSerializer::Y_AXIS;
					}
					else if ( strchr( tokens[1].Get(), 'x' ) || strchr( tokens[1].Get(), 'X' ) )
					{
						m_nUpAxis = CDmSmdSerializer::X_AXIS;
					}
					else
					{
						m_nUpAxis = CDmSmdSerializer::Z_AXIS;
					}
				}
				else if ( !V_stricmp( tokens[0], "$scale" ) )
				{
					m_scale = strtod( tokens[1].Get(), NULL );
				}
				else if ( !V_stricmp( tokens[0], "$cdmaterials" ) )
				{
					m_cdmaterials.push_back( tokens[1].Get() );
				}
			}

			bRetVal = true;
		}
		catch ( ... )
		{
		}
	}

	if ( m_cdmaterials.empty() )
	{
		// If m_cdmaterials is empty, then put the relative smd path onto the cdmaterials path

		char szBuf0[MAX_PATH];
		V_strncpy( szBuf0, smdPath.Get(), ARRAYSIZE( szBuf0 ) );
		V_StripFilename( szBuf0 );
		V_FixSlashes( szBuf0, '/' );

		CUtlVector< char *, CUtlMemory< char *, int > > sPathArray;
		V_SplitString( szBuf0, "/", sPathArray );

		CUtlString sRelSmdPath;

		bool bJoin = false;
		for ( int i = 0; i < sPathArray.Count(); ++i )
		{
			if ( !bJoin && !V_stricmp( sPathArray[i], "models" ) )
			{
				bJoin = true;
			}

			if ( bJoin )
			{
				sRelSmdPath = PathJoin( sRelSmdPath.Get(), sPathArray[i] );
			}
		}
		sRelSmdPath.FixSlashes( '/' );

		m_cdmaterials.push_back( sRelSmdPath.Get() );
	}

	return bRetVal;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CQcData::GetQcData(
	const CUtlString &smdPath )
{
	try
	{
		// Look for same thing named with a .qc extension
		char szBuf0[MAX_PATH];
		char szBuf1[MAX_PATH];

		V_strncpy( szBuf0, smdPath.Get(), ARRAYSIZE( szBuf0 ) );
		V_SetExtension( szBuf0, ".qc", ARRAYSIZE( szBuf0 ) );
		if ( _access( szBuf0, 04 ) == 0 )
			return ParseQc( smdPath, szBuf0 );

		// Remove "_reference" if found
		char *pszRef = V_stristr( szBuf0, "_reference.qc" );
		if ( pszRef )
		{
			*pszRef = '\0';

			V_SetExtension( szBuf0, ".qc", ARRAYSIZE( szBuf0 ) );
			if ( _access( szBuf0, 04 ) == 0 )
				return ParseQc( smdPath, szBuf0 );
		}
		else
		{
			// Add _reference

			V_SetExtension( szBuf0, "", ARRAYSIZE( szBuf0 ) );
			V_strcat( szBuf0, "_reference", ARRAYSIZE( szBuf0 ) );
			V_SetExtension( szBuf0, ".qc", ARRAYSIZE( szBuf0 ) );
			if ( _access( szBuf0, 04 ) == 0 )
				return ParseQc( smdPath, szBuf0 );
		}

		// Look for any *.qc file in the same directory as the smd that contains the smd pathname
		V_strncpy( szBuf0, smdPath.Get(), ARRAYSIZE( szBuf0 ) );
		V_FixSlashes( szBuf0 );

		V_FileBase( szBuf0, szBuf1, ARRAYSIZE( szBuf1 ) );
		CUtlString sFileBase0( "\"" );
		sFileBase0 += szBuf1;
		sFileBase0 += "\"";

		V_SetExtension( szBuf1, ".smd", ARRAYSIZE( szBuf1 ) );
		CUtlString sFileBase1( "\"" );
		sFileBase1 += szBuf1;
		sFileBase1 += "\"";

		V_ExtractFilePath( szBuf0, szBuf1, ARRAYSIZE( szBuf1 ) );
		CUtlString sFilePath = szBuf1;

		if ( sFileBase0.Length() > 0 && sFilePath.Length() > 0 )
		{
			struct _finddata_t qcFile;
			long hFile;

			CUtlVector< CUtlString > tokens;

			/* Find first .qc file in current directory */

			CUtlString sQcGlob = sFilePath;
			sQcGlob += "*.qc";

			if ( ( hFile = _findfirst( sQcGlob.Get(), &qcFile ) ) != -1L )
			{
				/* Find the rest of the .qc files */
				do {
					CUtlString sQcFile = sFilePath;
					sQcFile += qcFile.name;

					std::ifstream ifs( sQcFile.Get() );
					std::string buf;

					while ( std::getline( ifs, buf ) )
					{
						if ( V_stristr( buf.c_str(), sFileBase0.Get() ) || V_stristr( buf.c_str(), sFileBase1.Get() ) )
						{
							_findclose( hFile );
							return ParseQc( smdPath, sQcFile );
						}
					}
				} while( _findnext( hFile, &qcFile ) == 0 );

				_findclose( hFile );
			}
		}
	}
	catch ( const std::exception &e )
	{
		Error( "Exception: %s\n", e.what() );
	}

	return false;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
#define MAX_WEIGHTS_PER_VERTEX 3


//=============================================================================
//
//=============================================================================
class CVertexWeight
{
public:
	int m_nBoneIndex;
	float m_flWeight;

	CVertexWeight()
	: m_nBoneIndex( -1 )
	, m_flWeight( 0.0f )
	{}

	inline void Reset()
	{
		m_nBoneIndex = -1;
		m_flWeight = 0.0f;
	}

	inline bool operator==( const CVertexWeight &rhs ) const
	{
		return m_nBoneIndex == rhs.m_nBoneIndex && m_flWeight == rhs.m_flWeight;
	}

	inline bool operator!=( const CVertexWeight &rhs ) const
	{
		return m_nBoneIndex != rhs.m_nBoneIndex || m_flWeight != rhs.m_flWeight;
	}
};


//=============================================================================
//
//=============================================================================
class CVertex
{
public:
	Vector m_vPosition;
	Vector m_vNormal;
	Vector2D m_vUV;
	uint m_nWeights;
	CVertexWeight m_vertexWeights[ MAX_WEIGHTS_PER_VERTEX ];

	CVertex()
	{
		Reset();
	}

	inline bool operator==( const CVertex &rhs ) const
	{
		if ( m_vPosition != rhs.m_vPosition ||
			m_vNormal != rhs.m_vNormal ||
			m_vUV != rhs.m_vUV ||
			m_nWeights != rhs.m_nWeights )
			return false;

		for ( uint i = 0; i != m_nWeights; ++i )
		{
			if ( m_vertexWeights[ i ] != rhs.m_vertexWeights[ i ] )
				return false;
		}

		return true;
	}

	inline void Reset()
	{
		m_nWeights = 0;
		for ( int i = 0; i < ARRAYSIZE( m_vertexWeights ); ++i )
		{
			m_vertexWeights[i].Reset();
		}
	}
};


//=============================================================================
//
//=============================================================================
class CTriangle
{
public:
	uint m_nVertices;
	CVertex m_vertices[ 3 ];

	CTriangle()
	{
		Reset();
	}

	bool Valid() const;

	inline void Reset()
	{
		m_nVertices = 0;
		m_vertices[ 0U ].Reset();
		m_vertices[ 1U ].Reset();
		m_vertices[ 2U ].Reset();
	}
};


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTriangle::Valid() const
{
	// A triangle is valid it it has three vertices and all three vertices are unique

	if ( m_nVertices != 3U )
		return false;

	if ( m_vertices[0] == m_vertices[1] )
		return false;

	if ( m_vertices[1] == m_vertices[2] )
		return false;

	if ( m_vertices[2] == m_vertices[0] )
		return false;

	return true;
}


//=============================================================================
//
//=============================================================================
class CShadingGroup
{
public:
	std::string m_materialPath;
	std::map< int, std::deque< int > > m_componentListMap;
};


//=============================================================================
//
//=============================================================================
enum ParserState_t
{
	kUnknown,
	kPreamble,
	kGeneral,
	kNodes,
	kSkeleton,
	kTriangles
};


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool ParserAddJoint(
	CDmSmdSerializer::SmdJointMap_t &smdJointMap,
	int nId,
	const char *pszName,
	int nParentId,
	const char *pszFilename,
	int nLineNumber )
{
	if ( nId < 0 )
	{
		Error( "Error! %s(%d) : node error : invalid node id %d, must be >= 0: Line '%d \"%s\" %d'\n",
			pszFilename, nLineNumber, nId, nId, pszName, nParentId );
		return false;
	}

	if ( smdJointMap.IsValidIndex( smdJointMap.Find( nId ) ) )
	{
		Error( "Error! %s(%d) : node error : node id %d already defined\n",
			pszFilename, nLineNumber, nId );
		return false;
	}

	CDmSmdSerializer::SmdJoint_t &smdJoint = smdJointMap.Element( smdJointMap.Insert( nId ) );

	smdJoint.m_nId = nId;
	smdJoint.m_sName = pszName;
	smdJoint.m_nParentId = MAX( -1, nParentId );
	smdJoint.m_nLineNumber = nLineNumber;

	return true;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static bool ParserCreateJoint(
	const CDmSmdSerializer::SmdJointMap_t &smdJointMap,
	CDmeModel *pDmeModel,
	CDmeChannelsClip *pDmeChannelsClip,
	CDmSmdSerializer::SmdJoint_t *pSmdJoint,
	const char *pszFilename )
{
	const CUtlString &sName = pSmdJoint->m_sName;
	const int nId = pSmdJoint->m_nId;
	const int nParentId = pSmdJoint->m_nParentId;
	const int nLineNumber = pSmdJoint->m_nLineNumber;

	CDmeJoint *pDmeJoint = CreateElement< CDmeJoint >( sName.Get(), pDmeModel->GetFileId() );

	if ( !pDmeJoint )
	{
		Error( "%s(%d) : node error : can't create joint %d(%s)\n",
			pszFilename, nLineNumber, nId, sName.Get() );
		return false;
	}

	if ( nParentId < 0 )
	{
		if ( !pDmeModel )
		{
			Error( "%s(%d) : node error : No DmeModel passed for root joint %d(%s)\n",
				pszFilename, nLineNumber, nId, sName.Get() );
			DestroyElement( pDmeJoint );

			return false;
		}

		pDmeModel->AddChild( pDmeJoint );
		CDmAttribute *pRootJointAttr = pDmeJoint->AddAttribute( "__rootJoint", AT_BOOL );
		pRootJointAttr->AddFlag( FATTRIB_DONTSAVE );
		pRootJointAttr->SetValue( true );
	}
	else
	{
		if ( nParentId == nId )
		{
			Error( "%s(%d) : node error : joint %d(%s) is its own parent\n",
				pszFilename, nLineNumber, nId, sName.Get() );
			DestroyElement( pDmeJoint );

			return false;
		}

		const int nParentIdIndex = smdJointMap.Find( nParentId );

		if ( !smdJointMap.IsValidIndex( nParentIdIndex ) )
		{
			Error( "%s(%d) : node error : joint %d(%s) has invalid parentId (%d)\n",
				pszFilename, nLineNumber, nId, sName.Get(), nParentId );
			DestroyElement( pDmeJoint );

			return false;
		}

		CDmeDag *pDmeDagParent = smdJointMap.Element( nParentIdIndex ).m_pDmeDag;
		if ( pDmeDagParent )
		{
			pDmeDagParent->AddChild( pDmeJoint );
		}
		else
		{
			Error( "%s(%d) : node error : joint %d(%s) has invalid parentId (%d)\n",
				pszFilename, nLineNumber, nId, sName.Get(), nParentId );
		}
	}

	if ( pDmeChannelsClip )
	{
		CDmeTransform *pDmeTransform = pDmeJoint->GetTransform();

		CDmeChannel *pDmePosChannel = CreateElement< CDmeChannel >( CFmtStr( "%s_p", pDmeTransform->GetName() ).Access(), pDmeChannelsClip->GetFileId() );
		pDmePosChannel->SetMode( CM_PLAY );
		pDmePosChannel->SetOutput( pDmeTransform, "position" );
		CDmeVector3Log *pDmePosLog = pDmePosChannel->CreateLog< Vector >();
		pDmePosLog->SetValueThreshold( 1.0e-6 );
		pDmeChannelsClip->m_Channels.AddToTail( pDmePosChannel );

		CDmAttribute *pPosLogAttr = pDmeJoint->AddAttribute( "__posLog", AT_ELEMENT );
		pPosLogAttr->AddFlag( FATTRIB_DONTSAVE );
		pPosLogAttr->SetValue( pDmePosLog );

		CDmeChannel *pDmeRotChannel = CreateElement< CDmeChannel >( CFmtStr( "%s_o", pDmeTransform->GetName() ).Access(), pDmeChannelsClip->GetFileId() );
		pDmeRotChannel->SetMode( CM_PLAY );
		pDmeRotChannel->SetOutput( pDmeTransform, "orientation" );
		CDmeQuaternionLog *pDmeRotLog = pDmeRotChannel->CreateLog< Quaternion >();
		pDmeRotLog->SetValueThreshold( 1.0e-6 );
		pDmeChannelsClip->m_Channels.AddToTail( pDmeRotChannel );

		CDmAttribute *pRotLogAttr = pDmeJoint->AddAttribute( "__rotLog", AT_ELEMENT );
		pRotLogAttr->AddFlag( FATTRIB_DONTSAVE );
		pRotLogAttr->SetValue( pDmeRotLog );
	}

	pSmdJoint->m_pDmeDag = pDmeJoint;
	pDmeModel->AddJoint( pDmeJoint );

	return true;
}


//-----------------------------------------------------------------------------
// Used by ParserAddJoints, sorts joints by parent index
//-----------------------------------------------------------------------------
static bool SmdJointLessFunc( const CDmSmdSerializer::SmdJoint_t *pLhs, const CDmSmdSerializer::SmdJoint_t *pRhs )
{
	// try to preserve joints without parents in their original order as much as possible
	if ( pLhs->m_nParentId < 0 )
		return pLhs->m_nId < pRhs->m_nId;

	return pLhs->m_nParentId < pRhs->m_nParentId;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void ParserCreateJoints(
	CDmSmdSerializer::SmdJointMap_t &smdJointMap,
	CDmeModel *pDmeModel,
	CDmeChannelsClip *pDmeChannelsClip,
	const char *pszFilename )
{
	// Sort the joints in order of parent, pointers only temporary and no elements
	// added/removed from map while pointers exist, so pointers are stable
	CUtlVector< CDmSmdSerializer::SmdJoint_t * > smdJointList;
	FOR_EACH_MAP_FAST( smdJointMap, nSmdJointMapIndex )
	{
		smdJointList.AddToTail( &smdJointMap.Element( nSmdJointMapIndex ) );
	}

	std::stable_sort( smdJointList.Base(), smdJointList.Base() + smdJointList.Count(), SmdJointLessFunc );

	for ( int i = 0; i < smdJointList.Count(); ++i )
	{
		CDmSmdSerializer::SmdJoint_t *pSmdJoint = smdJointList[i];
		pSmdJoint->m_nActualId = i;

		ParserCreateJoint( smdJointMap, pDmeModel, pDmeChannelsClip, pSmdJoint, pszFilename );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmSmdSerializer::ParserSetJoint(
	const SmdJointMap_t &smdJointMap,
	int nFrame,
	int nId,
	const Vector &vPosition,
	const RadianEuler &eRadianEulerXYZ,
	const char *pszFilename,
	int nLineNumber )
{
	const SmdJointMap_t::IndexType_t nIdIndex = smdJointMap.Find( nId );
	if ( !smdJointMap.IsValidIndex( nIdIndex ) )
	{
		Error( "%s(%d) : skeleton error : can't find joint %d\n",
			pszFilename, nLineNumber, nId );
		return;
	}

	CDmeDag *pDmeDag = smdJointMap.Element( nIdIndex ).m_pDmeDag;
	if ( !pDmeDag )
	{
		Error( "%s(%d) : skeleton error : no dmedag created for can't find joint %d (%s)\n",
			pszFilename, nLineNumber, nId, smdJointMap.Element( nIdIndex ).m_sName.Get() );
		return;
	}

	const Quaternion qOrientation = eRadianEulerXYZ;

	if ( pDmeDag->GetValue( "__rootJoint", false ) && GetUpAxis() != CDmSmdSerializer::Y_AXIS )
	{
		matrix3x4_t mPre;
		matrix3x4_t mPost;
		AngleMatrix( qOrientation, vPosition, mPre );
		ConcatTransforms( m_mAdj, mPre, mPost );
		pDmeDag->GetTransform()->SetTransform( mPost );
	}
	else
	{
		pDmeDag->GetTransform()->SetPosition( vPosition );
		pDmeDag->GetTransform()->SetOrientation( qOrientation );
	}

	if ( m_bOptAnimation )
	{
		const DmeTime_t tCurrent( static_cast< float >( nFrame ), DmeFramerate_t( m_flFrameRate ) );

		CDmeTransform *pDmeTransform = pDmeDag->GetTransform();

		CDmeVector3Log *pDmePosLog = pDmeDag->GetValueElement< CDmeVector3Log >( "__posLog" );
		pDmePosLog->SetKey( tCurrent, pDmeTransform->GetPosition() );

		CDmeQuaternionLog *pDmeRotLog = pDmeDag->GetValueElement< CDmeQuaternionLog >( "__rotLog" );
		pDmeRotLog->SetKey( tCurrent, pDmeTransform->GetOrientation() );
	}
}

//-----------------------------------------------------------------------------
// Returns -1 if invalid
//-----------------------------------------------------------------------------
static int GetActualId( const CDmSmdSerializer::SmdJointMap_t &smdJointMap, int nId )
{
	const CDmSmdSerializer::SmdJointMap_t::IndexType_t nIdIndex = smdJointMap.Find( nId );

	if ( !smdJointMap.IsValidIndex( nIdIndex ) )
	{
		Error( "Error! Invalid node id %d looked up\n", nId );
		return -1;
	}

	return smdJointMap.Element( nIdIndex ).m_nActualId;
}


//-----------------------------------------------------------------------------
// Used by HandleVertexWeights, sorts vertex weights by weight
//-----------------------------------------------------------------------------
static int VertexWeightLessFunc( const void *pLhs, const void *pRhs )
{
	const CVertexWeight *pVertexWeightL = reinterpret_cast< const CVertexWeight * >( pLhs );
	const CVertexWeight *pVertexWeightR = reinterpret_cast< const CVertexWeight * >( pRhs );

	if ( pVertexWeightL->m_nBoneIndex < 0 )
	{
		if ( pVertexWeightR->m_nBoneIndex < 0 )
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
	else if ( pVertexWeightR->m_nBoneIndex < 0 )
	{
		return -1;
	}

	if ( pVertexWeightL->m_flWeight > pVertexWeightR->m_flWeight )
	{
		return -1;
	}
	else if ( pVertexWeightL->m_flWeight < pVertexWeightR->m_flWeight )
	{
		return 1;
	}

	return 0;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void HandleVertexWeights(
	const CDmSmdSerializer::SmdJointMap_t &smdJointMap,
	int nFallbackBoneIndexId,
	CVertex &vertex,
	const char *pszLine,
	const char *pszFilename,
	int nLineNumber )
{
	for ( int i = 0; i < ARRAYSIZE( vertex.m_vertexWeights ); ++i )
	{
		vertex.m_vertexWeights[i].Reset();
	}

	CUtlVector< CVertexWeight > tmpVertexWeights;

	CUtlVector< CUtlString > tokens;
	Tokenize( tokens, pszLine );

	const float flEps = 1.0e-6;

	uint nTokenEnd = tokens.Count();
	if ( nTokenEnd > 10 )
	{
		int nId = -1;
		float flWeight = 0.0f;
		for ( uint i = 10; i < nTokenEnd; ++i )
		{
			nId = strtol( tokens[ i ].Get(), NULL, 0 );
			++i;
			flWeight = strtod( tokens[ i ].Get(), NULL );

			if ( nId < 0 || flWeight < flEps )
				continue;

			const int nActualId = GetActualId( smdJointMap, nId );

			if ( nActualId < 0 )
			{
				Error( "%s(%d) : triangle error : ignoring unknown joint id(%d) with actual id(%d) for vertex weight\n",
					pszFilename, nLineNumber, nId, nActualId );
				continue;
			}

			CVertexWeight &tmpVertexWeight = tmpVertexWeights[ tmpVertexWeights.AddToTail() ];
			tmpVertexWeight.m_nBoneIndex = nActualId;
			tmpVertexWeight.m_flWeight = flWeight;
		}

		// Sort vertex weights inversely by weight
		qsort( tmpVertexWeights.Base(), tmpVertexWeights.Count(), sizeof( CVertexWeight ), VertexWeightLessFunc );

		// Take at most the top ARRAYSIZE( vertex.m_vertexWeights ) from tmpVertexWeights
		// Figure out actual weight count and total weight

		float flTotalWeight = 0.0f;
		vertex.m_nWeights = 0;

		for ( int i = 0; i < tmpVertexWeights.Count() && i < ARRAYSIZE( vertex.m_vertexWeights ); ++i )
		{
			CVertexWeight &vertexWeight( vertex.m_vertexWeights[ i ] );
			vertexWeight = tmpVertexWeights[i];
			flTotalWeight += vertexWeight.m_flWeight;
			vertex.m_nWeights += 1;
		}

		// If there are valid user specified weights then renormalize
		if ( vertex.m_nWeights > 0 && flTotalWeight > flEps )
		{
			for ( uint i = 0; i != ARRAYSIZE( vertex.m_vertexWeights ); ++i )
			{
				CVertexWeight &vertexWeight( vertex.m_vertexWeights[ i ] );
				if ( vertexWeight.m_nBoneIndex >= 0 )
				{
					vertexWeight.m_flWeight /= flTotalWeight;
				}
			}
		}
		else
		{
			// No valid user weights, assign to fallback bone with weight of 1
			vertex.m_vertexWeights[ 0 ].m_nBoneIndex = GetActualId( smdJointMap, nFallbackBoneIndexId );
			if ( vertex.m_vertexWeights[0].m_nBoneIndex < 0 )
			{
				// Vertex is not weighted, can't find fallback bone, this is invalid
				vertex.m_nWeights = 0;
				vertex.m_vertexWeights[0].m_nBoneIndex = -1;
				vertex.m_vertexWeights[0].m_flWeight = 0.0f;
			}
			else
			{
				vertex.m_nWeights = 1;
				vertex.m_vertexWeights[0].m_flWeight = 1.0f;
			}

			// Assign rest of weights to -1, 0.0f
			for ( uint i = 1; i < ARRAYSIZE( vertex.m_vertexWeights ); ++i )
			{
				vertex.m_vertexWeights[i].m_nBoneIndex = -1;
				vertex.m_vertexWeights[i].m_flWeight = 0.0f;
			}
		}
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CDmeMesh *CreateDmeMesh(
	CDmeModel *pDmeModel,
	const char *pszFilename,
	int nLineNumber )
{
	char szFileBase[MAX_PATH];
	szFileBase[0] = '\0';

	const char *pszMeshName = "mesh";

	if ( pszFilename )
	{
		V_FileBase( pszFilename, szFileBase, ARRAYSIZE( szFileBase ) );

		if ( V_strlen( szFileBase ) > 0 )
		{
			pszMeshName = szFileBase;
		}
	}

	CDmeDag *pDmeDag = CreateElement< CDmeDag >( pszMeshName, pDmeModel->GetFileId() );
	if ( !pDmeDag )
		return NULL;

	pDmeModel->AddChild( pDmeDag );

	CUtlString sMeshName = pDmeDag->GetName();
	sMeshName += "Shape";

	CDmeMesh *pDmeMesh = CreateElement< CDmeMesh >( sMeshName.Get(), pDmeDag->GetFileId() );
	if ( !pDmeMesh )
		return NULL;

	CDmeVertexData *pDmeVertexData = pDmeMesh->FindOrCreateBaseState( "bind" );
	pDmeMesh->SetCurrentBaseState( "bind" );
	
	pDmeVertexData->FlipVCoordinate( true );
	pDmeVertexData->CreateField( CDmeVertexData::FIELD_POSITION );
	pDmeVertexData->CreateField( CDmeVertexData::FIELD_NORMAL );
	pDmeVertexData->CreateField( CDmeVertexData::FIELD_TEXCOORD );
	FieldIndex_t nJointWeightField;
	FieldIndex_t nJointIndexField;
	pDmeVertexData->CreateJointWeightsAndIndices( MAX_WEIGHTS_PER_VERTEX, &nJointWeightField, &nJointIndexField );

	pDmeDag->SetShape( pDmeMesh );

	pDmeVertexData->Resolve();
	pDmeMesh->Resolve();
	pDmeDag->Resolve();

	return pDmeMesh;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CDmeFaceSet *FindOrCreateFaceSet(
	CDmeMesh *pDmeMesh,
	const CUtlString &sMaterial,
	const char *pszFilename,
	int nLineNumber )
{
	// Could cache in a hashed map or something...
	for ( int i = 0; i < pDmeMesh->FaceSetCount(); ++i )
	{
		CDmeFaceSet *pDmeFaceSet = pDmeMesh->GetFaceSet( i );
		if ( !pDmeFaceSet )
			continue;

		CDmeMaterial *pDmeMaterial = pDmeFaceSet->GetMaterial();
		if ( !pDmeMaterial )
			continue;

		if ( !V_strcmp( pDmeMaterial->GetMaterialName(), sMaterial.Get() ) )
			return pDmeFaceSet;
	}

	char szFaceSetName[ MAX_PATH ];
	V_FileBase( sMaterial.Get(), szFaceSetName, ARRAYSIZE( szFaceSetName ) );

	CDmeFaceSet *pDmeFaceSet = CreateElement< CDmeFaceSet >( szFaceSetName, pDmeMesh->GetFileId() );
	Assert( pDmeFaceSet );

	CDmeMaterial *pDmeMaterial = CreateElement< CDmeMaterial >( szFaceSetName, pDmeMesh->GetFileId() );
	Assert( pDmeMaterial );

	pDmeMaterial->SetMaterial( sMaterial.Get() );
	pDmeFaceSet->SetMaterial( pDmeMaterial );

	pDmeMesh->AddFaceSet( pDmeFaceSet );

	return pDmeFaceSet;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static void CreatePolygon(
	CDmeMesh *pDmeMesh,
	const CUtlString &sMaterial,
	CTriangle &triangle,
	const char *pszFilename,
	int nLineNumber )
{
	if ( !triangle.Valid() || !pDmeMesh )
		return;

	CDmeVertexData *pDmeVertexData = pDmeMesh->GetBindBaseState();
	Assert( pDmeVertexData );

	FieldIndex_t nPositionField = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
	CDmrArray< Vector > positionData = pDmeVertexData->GetVertexData( nPositionField );

	FieldIndex_t nNormalField = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
	CDmrArray< Vector > normalData = pDmeVertexData->GetVertexData( nNormalField );

	FieldIndex_t nUvField = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_TEXCOORD );
	CDmrArray< Vector2D > uvData = pDmeVertexData->GetVertexData( nUvField );

	FieldIndex_t nJointWeightField = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_JOINT_WEIGHTS );
	CDmrArray< float > jointWeightData = pDmeVertexData->GetVertexData( nJointWeightField );

	FieldIndex_t nJointIndexField = pDmeVertexData->FindFieldIndex( CDmeVertexData::FIELD_JOINT_INDICES );
	CDmrArray< int > jointIndexData = pDmeVertexData->GetVertexData( nJointIndexField );

	CDmeFaceSet *pDmeFaceSet = FindOrCreateFaceSet( pDmeMesh, sMaterial, pszFilename, nLineNumber );
	if ( !pDmeFaceSet )
	{
		Error( "%s(%d) : mesh error : couldn't find or create DmeFace set for material \"%s\" on mesh \"%s\"\n",
			pszFilename, nLineNumber, sMaterial.Get(), pDmeMesh->GetName() );
		return;
	}

	for ( uint i = 0; i < 3; ++i )
	{
		const int nNewVertexIndex = pDmeVertexData->AddVertexIndices( 1 );

		CVertex &cVertex = triangle.m_vertices[i];

		{
			// TODO: Make two positions if they are skinned differently
			int nPositionIndex = positionData.Find( cVertex.m_vPosition );
			if ( !positionData.IsValidIndex( nPositionIndex ) )
			{
				nPositionIndex = positionData.AddToTail( cVertex.m_vPosition );

				for ( int j = 0; j < ARRAYSIZE( cVertex.m_vertexWeights ); ++j )
				{
					jointWeightData.AddToTail( cVertex.m_vertexWeights[j].m_flWeight );
					jointIndexData.AddToTail( cVertex.m_vertexWeights[j].m_nBoneIndex );
				}
			}

			pDmeVertexData->SetVertexIndices( nPositionField, nNewVertexIndex, 1, &nPositionIndex );

			const int nFaceSetIndex = pDmeFaceSet->AddIndices( 1 );
			pDmeFaceSet->SetIndices( nFaceSetIndex, 1, const_cast< int * >( &nNewVertexIndex ) );

		}

		{
			int nNormalIndex = normalData.Find( cVertex.m_vNormal );
			if ( !normalData.IsValidIndex( nNormalIndex ) )
			{
				nNormalIndex = normalData.AddToTail( cVertex.m_vNormal );
			}

			pDmeVertexData->SetVertexIndices( nNormalField, nNewVertexIndex, 1, &nNormalIndex );
		}


		{
			int nUvIndex = uvData.Find( cVertex.m_vUV );
			if ( !uvData.IsValidIndex( nUvIndex ) )
			{
				nUvIndex = uvData.AddToTail( cVertex.m_vUV );
			}

			pDmeVertexData->SetVertexIndices( nUvField, nNewVertexIndex, 1, &nUvIndex );
		}

	}

	static const int nFaceDelimiter = -1;
	const int nFaceSetIndex = pDmeFaceSet->AddIndices( 1 );
	pDmeFaceSet->SetIndices( nFaceSetIndex, 1, const_cast< int * >( &nFaceDelimiter ) );

	triangle.Reset();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CDmeFaceSet *FindOrAddFaceSet(
	CDmeMesh *pDmeMesh,
	CUtlMap< CUtlString, CDmeFaceSet * > &faceListMap,
	const char *pszMaterialPath )
{
	CUtlMap< CUtlString, CDmeFaceSet * >::IndexType_t nIndex = faceListMap.Find( CUtlString( pszMaterialPath ) );

	if ( faceListMap.IsValidIndex( nIndex ) )
		return faceListMap.Element( nIndex );

	CDmeFaceSet *pDmeFaceSet = CreateElement< CDmeFaceSet >( pszMaterialPath, pDmeMesh->GetFileId() );
	CDmeMaterial *pDmeMaterial = CreateElement< CDmeMaterial >( pszMaterialPath, pDmeMesh->GetFileId() );
	Assert( pDmeFaceSet && pDmeMaterial );
	pDmeMaterial->SetMaterial( pszMaterialPath );
	pDmeMesh->AddFaceSet( pDmeFaceSet );

	return faceListMap.Element( faceListMap.Insert( CUtlString( pszMaterialPath ), pDmeFaceSet ) );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmeChannelsClip *FindOrCreateChannelsClip( CDmElement *pDmeRoot, const char *pszAnimationName )
{
	CDmeAnimationList *pDmeAnimationList = pDmeRoot->GetValueElement< CDmeAnimationList >( "animationList" );
	CDmeChannelsClip *pDmeChannelsClip = NULL;

	if ( pDmeAnimationList )
	{
		pDmeChannelsClip = pDmeAnimationList->GetAnimation( 0 );
	}
	else
	{
		CDmeModel *pDmeModel = pDmeRoot->GetValueElement< CDmeModel >( "skeleton" );

		pDmeAnimationList = CreateElement< CDmeAnimationList >( pszAnimationName, pDmeRoot->GetFileId() );
		pDmeChannelsClip = CreateElement< CDmeChannelsClip >( pszAnimationName, pDmeRoot->GetFileId() );
		pDmeAnimationList->AddAnimation( pDmeChannelsClip );
		pDmeRoot->SetValue( "animationList", pDmeAnimationList );
		pDmeModel->SetValue( "animationList", pDmeAnimationList );
	}

	return pDmeChannelsClip;
}

//-----------------------------------------------------------------------------
// Common function both ReadSMD & Unserialize can call
//-----------------------------------------------------------------------------
CDmElement *CDmSmdSerializer::ReadSMD(
	CUtlBuffer &utlBuf,
	DmFileId_t nDmFileId,
	const char *pszFilename,
	CDmeMesh **ppDmeMeshCreated )
{
	CDmElement *pDmeRoot = CreateElement< CDmElement >( "root", nDmFileId );
	CDmeModel *pDmeModel = CreateElement< CDmeModel >( "model", nDmFileId );

	char szAnimationName[ MAX_PATH ] = "";

	if ( pszFilename )
	{
		V_FileBase( pszFilename, szAnimationName, ARRAYSIZE( szAnimationName ) );
	}
	else
	{
		pszFilename = "unknown";
	}

	if ( V_strlen( szAnimationName ) > 0 )
	{
		pDmeModel->SetName( szAnimationName );
	}
	else
	{
		V_strcpy_safe( szAnimationName, "anim" );
	}

	pDmeRoot->SetValue( "skeleton", pDmeModel );

	if ( !m_bOptAnimation )
	{
		// Don't set root.model if animation only, studiomdl can't handle it
		pDmeRoot->SetValue( "model", pDmeModel );
	}

	SmdJointMap_t smdJointMap( CDefOps< int >::LessFunc );

	CUtlString sMaterial;

	CTriangle triangle;

	uint nLineNumber = 0;
	uint nBadPreambleCount = 0;
	ParserState_t nParserState = kPreamble;
	int nFrame = 0;

	CDmeChannelsClip *pDmeChannelsClip = NULL;

	if ( m_bOptAnimation )
	{
		pDmeChannelsClip = FindOrCreateChannelsClip( pDmeRoot, szAnimationName );
	}

	bool bStartTimeSet = false;

	CQcData qcData;

	CDmeMesh *pDmeMesh = NULL;

	char szLine[ 4096 ];

	while ( utlBuf.IsValid() )
	{
		GetLine( utlBuf, szLine, ARRAYSIZE( szLine ) );
		++nLineNumber;

		const char *pszLine = ParserSkipSpace( szLine );

		if ( ParserIsBlankLine( pszLine ) )
			continue;

		if ( nParserState == kPreamble )
		{
			if ( HandleQcHints( pszLine, qcData ) )
				continue;

			if ( ParserHandleVersion( pszLine ) )
			{
				if ( qcData.m_nUpAxis != m_nUpAxis )
				{
					Warning( "Importer UpAxis (%d) is different from UpAxis in SMD data (%d), using value found in SMD/QC\n", m_nUpAxis, qcData.m_nUpAxis );
				}

				SetUpAxis( qcData.m_nUpAxis );
				nParserState = kGeneral;
				continue;
			}

			Error( "%s(%d) : preamble error : expecting comment: \"%s\"\n",
				pszFilename, nLineNumber, szLine );

			++nBadPreambleCount;
			if ( nBadPreambleCount > 10 )
			{
				Error( "%s(%d) : preamble error : too many errors, not an SMD file, aborting\n",
					pszFilename, nLineNumber );
				break;
			}
		}
		else if ( nParserState == kGeneral )
		{
			if ( ParserHandleSectionStart( pszLine, "nodes" ) )
			{
				nParserState = kNodes;
			}
			else if ( ParserHandleSectionStart( pszLine, "skeleton" ) )
			{
				nParserState = kSkeleton;
			}
			else if ( ParserHandleSectionStart( pszLine, "triangles" ) )
			{
				nParserState = kTriangles;
			}
		}
		else if ( nParserState == kNodes )
		{
			if ( ParserHandleSectionStart( pszLine, "end" ) )
			{
				ParserCreateJoints( smdJointMap, pDmeModel, pDmeChannelsClip, pszFilename );

				nParserState = kGeneral;
				continue;
			}

			CUtlString sName;
			int nId;
			int nParentId;

			if ( !m_bOptImportSkeleton || !ParserHandleSkeletonLine( pszLine, sName, nId, nParentId ) )
				continue;

			if ( !ParserAddJoint( smdJointMap, nId, sName, nParentId, pszFilename, nLineNumber ) )
				continue;
		}
		else if ( nParserState == kSkeleton )
		{
			if ( ParserHandleSectionStart( pszLine, "end" ) )
			{
				nParserState = kGeneral;
				continue;
			}

			if ( m_bOptAnimation && ParserHandleTime( pszLine, nFrame ) )
			{
				if ( !bStartTimeSet )
				{
					pDmeChannelsClip->SetStartTime( DmeTime_t( static_cast< float >( nFrame ), DmeFramerate_t( m_flFrameRate ) ) );
					bStartTimeSet = true;
				}
				continue;
			}

			int nId;
			Vector vPosition;
			RadianEuler eRadianEulerXYZ;

			if ( sscanf( pszLine, "%d %f %f %f %f %f %f", &nId, &vPosition.x, &vPosition.y, &vPosition.z, &eRadianEulerXYZ.x, &eRadianEulerXYZ.y, &eRadianEulerXYZ.z ) == 7 )
			{
				if ( !m_bOptImportSkeleton )
					continue;

				ParserSetJoint( smdJointMap, nFrame, nId, vPosition, eRadianEulerXYZ, pszFilename, nLineNumber );
			}
		}
		else if ( nParserState == kTriangles )
		{
			if ( ParserHandleSectionStart( pszLine, "end" ) )
			{
				triangle.Reset();
				nParserState = kGeneral;
				continue;
			}

			int nFallbackSkinJoint;
			Vector vPosition;
			Vector vNormal;
			Vector2D vUV;
			char szShadingGroup[ ARRAYSIZE( szLine ) ];

			if ( sscanf( pszLine, "%d %f %f %f %f %f %f %f %f",
				&nFallbackSkinJoint,
				&vPosition.x, &vPosition.y, &vPosition.z,
				&vNormal.x, &vNormal.y, &vNormal.z, &vUV.x, &vUV.y ) == 9 )
			{
				if ( triangle.m_nVertices >= 3 )
				{
					Error( "%s(%d) : triangle error : Too many vertices in triangle\n",
						pszFilename, nLineNumber );
					continue;
				}

				CVertex &vertex( triangle.m_vertices[ triangle.m_nVertices++ ] );
				vertex.m_vUV = vUV;

				if ( GetUpAxis() != CDmSmdSerializer::Y_AXIS )
				{
					VectorTransform( vPosition, m_mAdj, vertex.m_vPosition );
					VectorTransform( vNormal, m_mAdjNormal, vertex.m_vNormal );
				}
				else
				{
					vertex.m_vPosition = vPosition;
					vertex.m_vNormal = vNormal;
				}

				if ( m_bOptImportSkeleton )
				{
					HandleVertexWeights( smdJointMap, nFallbackSkinJoint, vertex, pszLine, pszFilename, nLineNumber );
				}

				if ( !pDmeMesh )
				{
					pDmeMesh = CreateDmeMesh( pDmeModel, pszFilename, nLineNumber );
					if ( !pDmeMesh )
					{
						Error( "%s(%d) : Couldn't create DmeMesh\n",
							pszFilename, nLineNumber );
						break;
					}
				}

				CreatePolygon( pDmeMesh, sMaterial, triangle, pszFilename, nLineNumber );
			}
			else if ( sscanf( pszLine, "%1024s", szShadingGroup ) == 1 )
			{
				char pszMaterialPath[ ARRAYSIZE( szShadingGroup ) ];
				V_StripExtension( szShadingGroup, pszMaterialPath, ARRAYSIZE( pszMaterialPath ) );

				sMaterial = pszMaterialPath;

				triangle.Reset();
			}
			else
			{
				Error( "%s(%d) : triangle error : unexpected data in triangles\n",
					pszFilename, nLineNumber );
				triangle.Reset();
			}
		}
		else
		{
			Error( "%s(%d) : parser error : unknown parser state\n",
				pszFilename, nLineNumber );
			nParserState = kGeneral;
		}
	}

	pDmeModel->CaptureJointsToBaseState( "bind" );

	if ( pDmeChannelsClip )
	{
		// Reset skeleton values to the first sample
		FOR_EACH_MAP_FAST( smdJointMap, nJointMapIndex )
		{
			CDmeDag *pDmeDag = smdJointMap.Element( nJointMapIndex ).m_pDmeDag;
			if ( pDmeDag )
			{
				CDmeTransform *pDmeTransform = pDmeDag->GetTransform();

				CDmeVector3Log *pDmePosLog = pDmeDag->GetValueElement< CDmeVector3Log >( "__posLog" );
				pDmeTransform->SetPosition( pDmePosLog->GetKeyValue( 0 ) );

				CDmeQuaternionLog *pDmeRotLog = pDmeDag->GetValueElement< CDmeQuaternionLog >( "__rotLog" );
				pDmeTransform->SetOrientation( pDmeRotLog->GetKeyValue( 0 ) );
			}
		}

		pDmeChannelsClip->SetDuration( DmeTime_t( nFrame, DmeFramerate_t( m_flFrameRate ) ) - pDmeChannelsClip->GetStartTime() );
	}

	return pDmeRoot;
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmSmdSerializer::FixNodeName( CUtlString &sName ) const
{
	char szTmpBuf0[ MAX_PATH ];
	char szTmpBuf1[ MAX_PATH ];

	V_strncpy( szTmpBuf0, sName.Get(), ARRAYSIZE( szTmpBuf0 ) );

	// Strip trailing quotes
	char *pszName = szTmpBuf0 + sName.Length() - 1;
	while ( pszName >= szTmpBuf0 && *pszName && *pszName == '"' )
	{
		*pszName = '\0';
		--pszName;
	}

	// Strip leading quotes
	pszName = szTmpBuf0;
	while ( *pszName && *pszName == '"')
	{
		++pszName;
	}

	if ( m_bOptAutoStripPrefix )
	{
		// Get the string before the '.'
		V_FileBase( pszName, szTmpBuf1, ARRAYSIZE( szTmpBuf1 ) );
		V_strncpy( szTmpBuf0, szTmpBuf1, ARRAYSIZE( szTmpBuf0 ) );
		pszName = szTmpBuf0;
	}

	if ( !m_sNodeDelPrefix.IsEmpty() && StringHasPrefix( pszName, m_sNodeDelPrefix.Get() ) )
	{
		pszName = const_cast< char * >( StringAfterPrefix( pszName, m_sNodeDelPrefix.Get() ) );
	}

	if ( m_sNodeAddPrefix.IsEmpty() )
	{
		sName = pszName;
	}
	else
	{
		sName = m_sNodeAddPrefix;
		sName += pszName;
	}
}