1HEADmaster

24 files changed, 38148 insertions, 0 deletions

diff --git a/utils/studiomdl/UnifyLODs.cpp b/utils/studiomdl/UnifyLODs.cpp
new file mode 100644
index 0000000..19bf9d7
--- /dev/null
+++ b/utils/studiomdl/UnifyLODs.cpp
@@ -0,0 +1,1631 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <float.h>
+
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+#include "bone_setup.h"
+#include "tier1/strtools.h"
+#include "mathlib/vmatrix.h"
+#include "optimize.h"
+
+// debugging only - enabling turns off remapping to create all lod vertexes as unique
+// to ensure remapping logic does not introduce collapse anomalies
+//#define UNIQUE_VERTEXES_FOR_LOD
+
+
+
+//-----------------------------------------------------------------------------
+// Forward declarations local to this file
+//-----------------------------------------------------------------------------
+class CVertexDictionary;
+struct VertexInfo_t;
+static void BuildBoneLODMapping( CUtlVector<int> &boneMap, int lodID );
+
+
+//-----------------------------------------------------------------------------
+// Globals
+//-----------------------------------------------------------------------------
+static int g_NumBonesInLOD[MAX_NUM_LODS];
+
+
+//-----------------------------------------------------------------------------
+// Makes sure all boneweights in a s_boneweight_t are valid
+//-----------------------------------------------------------------------------
+static void ValidateBoneWeight( const s_boneweight_t &boneWeight )
+{
+#ifdef _DEBUG
+	int i;
+	if( boneWeight.weight[0] == 1.0f )
+	{
+		Assert( boneWeight.numbones == 1 );
+	}
+	for( i = 0; i < boneWeight.numbones; i++ )
+	{
+		Assert( boneWeight.bone[i] >= 0 && boneWeight.bone[i] < g_numbones );
+	}
+
+	float weight = 0.0f;
+	for( i = 0; i < boneWeight.numbones; i++ )
+	{
+		weight += boneWeight.weight[i] ;
+	}
+	Assert( fabs( weight - 1.0f ) < 1e-3 );
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Swap bones
+//-----------------------------------------------------------------------------
+static inline void SwapBones( s_boneweight_t &boneWeight, int nBone1, int nBone2 )
+{
+	// swap
+	int nTmpBone = boneWeight.bone[nBone1];
+	float flTmpWeight = boneWeight.weight[nBone1];
+	boneWeight.bone[nBone1] = boneWeight.bone[nBone2];
+	boneWeight.weight[nBone1] = boneWeight.weight[nBone2];
+	boneWeight.bone[nBone2] = nTmpBone;
+	boneWeight.weight[nBone2] = flTmpWeight;
+}
+
+
+//-----------------------------------------------------------------------------
+// Sort the bone weight structure to be sorted by bone weight
+//-----------------------------------------------------------------------------
+static void SortBoneWeightByWeight( s_boneweight_t &boneWeight )
+{
+	// bubble sort the bones by weight. . .put the largest weight first.
+	for( int j = boneWeight.numbones; j > 1; j-- )
+	{
+		for( int k = 0; k < j - 1; k++ )
+		{
+			if( boneWeight.weight[k] >= boneWeight.weight[k+1] )
+				continue;
+
+			SwapBones( boneWeight, k, k+1 );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sort the bone weight structure to be sorted by bone index
+//-----------------------------------------------------------------------------
+static void SortBoneWeightByIndex( s_boneweight_t &boneWeight )
+{
+	// bubble sort the bones by index. . .put the smallest index first.
+	for ( int j = boneWeight.numbones; j > 1; j-- )
+	{
+		for( int k = 0; k < j - 1; k++ )
+		{
+			if( boneWeight.bone[k] <= boneWeight.bone[k+1] )
+				continue;
+
+			SwapBones( boneWeight, k, k+1 );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// A vertex format
+//-----------------------------------------------------------------------------
+struct VertexInfo_t
+{
+	Vector			m_Position;
+	Vector			m_Normal;
+	Vector2D		m_TexCoord;
+	Vector4D		m_TangentS;
+	s_boneweight_t	m_BoneWeight;
+	int				m_nLodFlag;
+};
+
+
+//-----------------------------------------------------------------------------
+// Stores all vertices in the vertex dictionary
+//-----------------------------------------------------------------------------
+class CVertexDictionary
+{
+public:
+	CVertexDictionary();
+
+	// Adds a vertex to the dictionary
+	int AddVertex( const VertexInfo_t &srcVertex );
+	int AddVertexFromSource( const s_source_t *pSrc, int nVertexIndex, int nLod );
+
+	// Iteration
+	int VertexCount() const;
+	VertexInfo_t &Vertex( int i );
+	const VertexInfo_t &Vertex( int i ) const;
+
+	int RootLODVertexStart() const;
+	int RootLODVertexEnd() const;
+
+	// Gets the vertex count for the previous LOD
+	int PrevLODVertexCount() const;
+
+	// Marks the dictionary as starting defining vertices for a new LOD
+	void StartNewLOD();
+
+	void SetRootVertexRange( int start, int end );
+
+private:
+	CUtlVector<VertexInfo_t>	m_Verts;
+	int							m_nPrevLODCount;
+	int							m_nRootLODStart;
+	int							m_nRootLODEnd;
+};
+
+
+//-----------------------------------------------------------------------------
+// Copies in a particular vertex from the s_source_t
+//-----------------------------------------------------------------------------
+CVertexDictionary::CVertexDictionary()
+{
+	m_nPrevLODCount = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Accessor
+//-----------------------------------------------------------------------------
+inline VertexInfo_t &CVertexDictionary::Vertex( int i )
+{
+	return m_Verts[i];
+}
+
+inline const VertexInfo_t &CVertexDictionary::Vertex( int i ) const
+{
+	return m_Verts[i];
+}
+
+	
+//-----------------------------------------------------------------------------
+// Gets the vertex count for the previous LOD
+//-----------------------------------------------------------------------------
+inline int CVertexDictionary::PrevLODVertexCount() const
+{
+	return m_nPrevLODCount;
+}
+
+
+inline int CVertexDictionary::RootLODVertexStart() const
+{
+	return m_nRootLODStart;
+}
+
+
+inline int CVertexDictionary::RootLODVertexEnd() const
+{
+	return m_nRootLODEnd;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Marks the dictionary as starting defining vertices for a new LOD
+//-----------------------------------------------------------------------------
+void CVertexDictionary::StartNewLOD()
+{
+	m_nPrevLODCount = VertexCount();
+}
+
+
+void CVertexDictionary::SetRootVertexRange( int start, int end )
+{
+	m_nRootLODStart = start;
+	m_nRootLODEnd   = end;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Adds a vertex to the dictionary
+//-----------------------------------------------------------------------------
+int CVertexDictionary::AddVertex( const VertexInfo_t &srcVertex )
+{
+	int nDstVertID = m_Verts.AddToTail( srcVertex );
+	VertexInfo_t &vertex = m_Verts[ nDstVertID ];
+	ValidateBoneWeight( vertex.m_BoneWeight );
+	SortBoneWeightByIndex( vertex.m_BoneWeight );
+	ValidateBoneWeight( vertex.m_BoneWeight );
+
+	return nDstVertID;
+}
+
+
+//-----------------------------------------------------------------------------
+// Copies in a particular vertex from the s_source_t
+//-----------------------------------------------------------------------------
+int CVertexDictionary::AddVertexFromSource( const s_source_t *pSrc, int nVertexIndex, int nLod )
+{
+	int nDstVertID = m_Verts.AddToTail( );
+	VertexInfo_t &vertex = m_Verts[ nDstVertID ];
+
+	const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[nVertexIndex];
+	vertex.m_Position   = srcVertex.position;
+	vertex.m_Normal     = srcVertex.normal;
+	vertex.m_TexCoord   = srcVertex.texcoord;
+	vertex.m_TangentS   = srcVertex.tangentS;
+	vertex.m_BoneWeight = srcVertex.boneweight;
+	vertex.m_nLodFlag	= 1 << nLod;
+
+	ValidateBoneWeight( vertex.m_BoneWeight );
+	SortBoneWeightByIndex( vertex.m_BoneWeight );
+	ValidateBoneWeight( vertex.m_BoneWeight );
+
+	return nDstVertID;
+}
+
+
+//-----------------------------------------------------------------------------
+// How many vertices in the dictionary?
+//-----------------------------------------------------------------------------
+int CVertexDictionary::VertexCount() const
+{
+	return m_Verts.Count();
+}
+
+
+s_source_t* GetModelLODSource( const char *pModelName, 
+								const LodScriptData_t& scriptLOD, bool* pFound )
+{
+	// When doing LOD replacement, ignore all path + extension information
+	char* pTempBuf = (char*)_alloca( Q_strlen(pModelName) + 1 );
+
+	// Strip off extensions for the source...
+	strcpy( pTempBuf, pModelName ); 
+	char* pDot = strrchr( pTempBuf, '.' );
+	if (pDot)
+	{
+		*pDot = 0;
+	}
+
+	for( int i = 0; i < scriptLOD.modelReplacements.Count(); i++ )
+	{
+		// FIXME: Should we strip off path information?
+//		char* pSlash = strrchr( pTempBuf1, '\\' );
+//		char* pSlash2 = strrchr( pTempBuf1, '/' );
+//		if (pSlash2 > pSlash)
+//			pSlash = pSlash2;
+//		if (!pSlash)
+//			pSlash = pTempBuf1;
+
+		if( !Q_stricmp( pTempBuf, scriptLOD.modelReplacements[i].GetSrcName() ) )
+		{
+			*pFound = true;
+			return scriptLOD.modelReplacements[i].m_pSource;
+		}
+	}
+
+	*pFound = false;
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Tolerances for all fields of the vertex
+//-----------------------------------------------------------------------------
+#define POSITION_EPSILON	0.01f	// Was 0.05f
+#define TEXCOORD_EPSILON	0.01f
+#define NORMAL_EPSILON		10.0f	// in degrees
+#define TANGENT_EPSILON		10.0f	// in degrees
+#define BONEWEIGHT_EPSILON	0.05f
+
+#define UNMATCHED_BONE_WEIGHT 1.0f
+
+//-----------------------------------------------------------------------------
+// Computes error between two positions; returns false if the error is too great
+//-----------------------------------------------------------------------------
+bool ComparePositionFuzzy( const Vector &p1, const Vector &p2, float &flError )
+{
+	Vector vecDelta;
+	VectorSubtract( p1, p2, vecDelta );
+	flError = DotProduct( vecDelta, vecDelta );
+	return ( flError <= (POSITION_EPSILON * POSITION_EPSILON) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes error between two normals; returns false if the error is too great
+//-----------------------------------------------------------------------------
+bool CompareNormalFuzzy( const Vector &n1, const Vector &n2, float &flError )
+{ 
+	static float flEpsilon = cos( DEG2RAD( NORMAL_EPSILON ) );
+
+	Vector v1, v2;
+	v1 = n1;
+	v2 = n2;
+	VectorNormalize( v1 );
+	VectorNormalize( v2 );
+	float flDot = DotProduct( v1, v2 );
+	flError = 1.0F - flDot;
+	return ( flDot >= flEpsilon );
+}
+
+//-----------------------------------------------------------------------------
+// Computes error between two tangentS vectors; returns false if the error is too great
+//-----------------------------------------------------------------------------
+bool CompareTangentSFuzzy( const Vector4D &n1, const Vector4D &n2, float &flError )
+{ 
+	static float flEpsilon = cos( DEG2RAD( TANGENT_EPSILON ) );
+
+	Vector4D v1, v2;
+	v1 = n1;
+	v2 = n2;
+
+	if (v1.w != v2.w)
+	{
+		// must match as -1 or 1
+		flError = 2;
+		return false;
+	}
+
+	VectorNormalize( v1.AsVector3D() );
+	VectorNormalize( v2.AsVector3D() );
+	float flDot = DotProduct( v1.AsVector3D(), v2.AsVector3D() );
+
+	// error ranges from [0..2]
+	flError = 1.0F - flDot;
+
+	return ( flDot >= flEpsilon );
+}
+
+//-----------------------------------------------------------------------------
+// Computes error between two texcoords; returns false if the error is too great
+//-----------------------------------------------------------------------------
+bool CompareTexCoordsFuzzy( const Vector2D &t1, const Vector2D &t2, float &flError )
+{
+	Vector2D vecError;
+	vecError[0] = fabs( t2[0] - t1[0] );
+	vecError[1] = fabs( t2[1] - t1[1] );
+	flError = vecError.LengthSqr();
+	return ( flError <= (TEXCOORD_EPSILON * TEXCOORD_EPSILON) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the error between two bone weights, returns false if they are too far
+//-----------------------------------------------------------------------------
+bool CompareBoneWeightsFuzzy( const s_boneweight_t &b1, const s_boneweight_t &b2, float &flError )
+{
+	// This is a list of which bones that exist in b1 also exist in b2.
+	// Use the index to figure out where in the array for b2 that the corresponding bone in b1 is.
+	int nMatchingBones = 0;
+	int pBoneIndexMap1[MAX_NUM_BONES_PER_VERT]; 
+	int pBoneIndexMap2[MAX_NUM_BONES_PER_VERT]; 
+
+	int i;
+	for ( i = 0; i < b2.numbones; ++i )
+	{
+		pBoneIndexMap2[i] = -1;
+	}
+
+	for ( i = 0; i < b1.numbones; ++i )
+	{
+		pBoneIndexMap1[i] = -1;
+		for ( int j = 0; j < b2.numbones; ++j )
+		{
+			if ( b2.bone[j] == b1.bone[i] )
+			{
+				pBoneIndexMap1[i] = j;
+				pBoneIndexMap2[j] = i;
+				++nMatchingBones;
+				break;
+			}
+		}
+	}
+
+	// If no bones match, we're done
+	if ( !nMatchingBones )
+	{
+		flError = FLT_MAX;
+		return false;
+	}
+
+	// At least one bone matches, so we're going to consider this vertex as a potential match
+	// This loop will take care of figuring out the error for all bones that exist in
+	// b1 alone, and all bones that exist in b1 and b2
+	flError = 0;
+	for ( i = 0; i < b1.numbones; ++i )
+	{
+		// If we didn't find a match for this bone, compute a more expensive weight
+		if ( pBoneIndexMap1[i] == -1 )
+		{
+			flError += b1.weight[i] * b1.weight[i] * UNMATCHED_BONE_WEIGHT;
+			continue;
+		}
+
+		float flDeltaWeight = fabs( b1.weight[i] - b2.weight[ pBoneIndexMap1[i] ] );
+		flError += flDeltaWeight * flDeltaWeight;
+	}
+
+	// This loop will take care of figuring out the error for all bones that exist in b2 alone
+	for ( i = 0; i < b2.numbones; ++i )
+	{
+		// If we didn't find a match for this bone, compute a more expensive weight
+		if ( pBoneIndexMap2[i] == -1 )
+		{
+			flError += b2.weight[i] * b2.weight[i] * UNMATCHED_BONE_WEIGHT;
+		}
+	}
+
+	// This renormalizes the error. The error will become greater with the total
+	// number of bones in the two vertices.
+	flError /= sqrt( (float) (b1.numbones + b2.numbones));
+	return ( flError <= BONEWEIGHT_EPSILON );
+}
+
+
+//-----------------------------------------------------------------------------
+// Searches for a material in the texture list
+//-----------------------------------------------------------------------------
+int FindMaterialByName( const char *pMaterialName )
+{
+	int i;
+	int allocLen = strlen( pMaterialName ) + 1;
+	char *pBaseName = ( char * )_alloca( allocLen );
+	Q_FileBase( ( char * )pMaterialName, pBaseName, allocLen );
+
+	for( i = 0; i < g_numtextures; i++ )
+	{
+		if( stricmp( pBaseName, g_texture[i].name ) == 0 )
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+static s_mesh_t *FindMeshByMaterial( s_source_t *pSrc, int nMaterialID )
+{
+	for ( int m = 0; m < pSrc->nummeshes; m++ )
+	{
+		if ( pSrc->meshindex[m] == nMaterialID )
+			return &pSrc->mesh[ pSrc->meshindex[m] ];
+	}
+	
+	// this mesh/material doesn't exist at this lod.
+	return NULL;
+}
+
+
+static s_mesh_t *FindOrCullMesh( int nLodID, s_source_t *pSrc, int nMaterialID )
+{
+	char	baseMeshName[MAX_PATH];
+	char	baseRemovalName[MAX_PATH];
+
+	// possibly marked for removal via $removemesh
+	// determine mesh name
+	int nTextureID = MaterialToTexture( nMaterialID );
+	if (nTextureID == -1)
+	{
+		MdlError( "Unknown Texture for Material %d\n", nMaterialID );
+	}
+
+	Q_FileBase(g_texture[nTextureID].name, baseMeshName, sizeof(baseMeshName)-1);
+	for ( int i = 0; i < g_ScriptLODs[nLodID].meshRemovals.Count(); i++ )
+	{
+		const char *pMeshRemovalName = g_ScriptLODs[nLodID].meshRemovals[i].GetSrcName();
+		Q_FileBase( pMeshRemovalName, baseRemovalName, sizeof(baseRemovalName)-1);
+
+		if (!stricmp( baseRemovalName, baseMeshName ))
+		{
+			// mesh has been marked for removal
+			return NULL;
+		}
+	}
+
+	s_mesh_t *pMesh = FindMeshByMaterial( pSrc, nMaterialID );
+	return pMesh;
+}
+
+
+static void CopyVerts( int nLodID, const s_source_t *pSrc, const s_mesh_t *pSrcMesh, CVertexDictionary &vertexDict, s_mesh_t *pDstMesh, int *pMeshVertIndexMap )
+{
+	// populate the dictionary with the verts
+	for( int srcVertID = 0; srcVertID < pSrcMesh->numvertices; srcVertID++ )
+	{
+		int nVertexIndex = pSrcMesh->vertexoffset + srcVertID;
+		pMeshVertIndexMap[ nVertexIndex ] = vertexDict.AddVertexFromSource( pSrc, nVertexIndex, nLodID ) - pDstMesh->vertexoffset;
+	}
+
+	pDstMesh->numvertices = pSrcMesh->numvertices;
+}
+
+static void CopyFaces( const s_source_t *pSrc, const s_mesh_t *pSrcMesh, CUtlVector<s_face_t> &faces, s_mesh_t *pDstMesh )
+{
+	int srcFaceID;
+	for( srcFaceID = 0; srcFaceID < pSrcMesh->numfaces; srcFaceID++ )
+	{
+		int srcID = srcFaceID + pSrcMesh->faceoffset;
+		s_face_t *pSrcFace = &pSrc->face[srcID];
+		s_face_t *pDstFace = &faces[faces.AddToTail()];
+		pDstFace->a = pSrcFace->a;
+		pDstFace->b = pSrcFace->b;
+		pDstFace->c = pSrcFace->c;
+		pDstMesh->numfaces++;
+	}
+}
+
+#define IGNORE_POSITION		0x01
+#define IGNORE_TEXCOORD		0x02
+#define IGNORE_BONEWEIGHT	0x04
+#define IGNORE_NORMAL		0x08
+#define IGNORE_TANGENTS		0x10
+
+//-----------------------------------------------------------------------------
+// return -1 if there is no match. The index returned is used to index into vertexDict.
+//-----------------------------------------------------------------------------
+static int FindVertexWithinVertexDictionary( const VertexInfo_t &find, 
+	const CVertexDictionary &vertexDict, int nStartVert, int nEndVert, int fIgnore )
+{
+	int		nBestIndex = -1;
+	float	flPositionError = 0.0f;
+	float	flNormalError = 0.0f;
+	float	flTangentSError = 0.0f;
+	float	flTexcoordError = 0.0f;
+	float	flBoneWeightError = 0.0f;
+	float	flMinPositionError = FLT_MAX;
+	float	flMinNormalError = FLT_MAX;
+	float	flMinTangentSError = FLT_MAX;
+	float	flMinTexcoordError = FLT_MAX;
+	float	flMinBoneWeightError = FLT_MAX;
+	bool	bFound;
+
+	if (fIgnore & IGNORE_POSITION)
+	{
+		flMinPositionError = 0;
+		flPositionError    = 0;
+	}
+
+	if (fIgnore & IGNORE_TEXCOORD)
+	{
+		flMinTexcoordError = 0;
+		flTexcoordError    = 0;
+	}
+
+	if (fIgnore & IGNORE_BONEWEIGHT)
+	{
+		flMinBoneWeightError = 0;
+		flBoneWeightError    = 0;
+	}
+
+	if (fIgnore & IGNORE_NORMAL)
+	{
+		flMinNormalError = 0;
+		flNormalError    = 0;
+	}
+
+	if (fIgnore & IGNORE_TANGENTS)
+	{
+		flMinTangentSError = 0;
+		flTangentSError    = 0;
+	}
+
+	for ( int nVertexIndex = nStartVert; nVertexIndex < nEndVert; ++nVertexIndex )
+	{
+		// see if the position is reasonable
+		if ( !(fIgnore & IGNORE_POSITION) && !ComparePositionFuzzy( find.m_Position, vertexDict.Vertex(nVertexIndex).m_Position, flPositionError ) )
+			continue;
+
+		if ( !(fIgnore & IGNORE_TEXCOORD) && !CompareTexCoordsFuzzy( find.m_TexCoord, vertexDict.Vertex(nVertexIndex).m_TexCoord, flTexcoordError ) )
+			continue;
+
+		if ( !(fIgnore & IGNORE_BONEWEIGHT) && !CompareBoneWeightsFuzzy( find.m_BoneWeight, vertexDict.Vertex(nVertexIndex).m_BoneWeight, flBoneWeightError ) )
+			continue;
+
+		if ( !(fIgnore & IGNORE_NORMAL) && !CompareNormalFuzzy( find.m_Normal, vertexDict.Vertex(nVertexIndex).m_Normal, flNormalError ) )
+			continue;
+
+		if ( !(fIgnore & IGNORE_TANGENTS) && !CompareTangentSFuzzy( find.m_TangentS, vertexDict.Vertex(nVertexIndex).m_TangentS, flTangentSError ) )
+			continue;
+
+		// the vert with minimum error is the best or exact candidate
+		bFound = false;
+		if (flMinPositionError > flPositionError)
+		{
+			bFound = true;
+		}
+		else if (flMinPositionError == flPositionError)
+		{
+			if (flMinTexcoordError > flTexcoordError)
+			{
+				bFound = true;
+			}
+			else if (flMinTexcoordError == flTexcoordError)
+			{
+				if (flMinBoneWeightError > flBoneWeightError)
+				{
+					bFound = true;
+				}
+				else if (flMinBoneWeightError == flBoneWeightError)
+				{
+					if (flMinNormalError > flNormalError)
+					{
+						bFound = true;
+					}
+					else if (flMinNormalError == flNormalError)
+					{
+						if (flMinTangentSError >= flTangentSError)
+						{
+							bFound = true;	
+						}
+					}
+				}
+			}
+		}
+
+		if (!bFound)
+			continue;
+
+		flMinPositionError	 = flPositionError;
+		flMinTexcoordError	 = flTexcoordError;
+		flMinBoneWeightError = flBoneWeightError;
+		flMinNormalError	 = flNormalError;
+		flMinTangentSError	 = flTangentSError;
+		nBestIndex			 = nVertexIndex;
+	}
+
+	return nBestIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// Use position, normal, and texcoord checks across the entire model to find a boneweight
+//-----------------------------------------------------------------------------
+static void FindBoneWeightWithinModel( const VertexInfo_t &searchVertex, const s_source_t *pSrc, s_boneweight_t &boneWeight, int fIgnore )
+{
+	int		nBestIndex = -1;
+	float	flPositionError = 0.0f;
+	float	flNormalError = 0.0f;
+	float	flTangentSError = 0.0f;
+	float	flTexcoordError = 0.0f;
+	float	flMinPositionError = FLT_MAX;
+	float	flMinNormalError = FLT_MAX;
+	float	flMinTangentSError = FLT_MAX;
+	float	flMinTexcoordError = FLT_MAX;
+	bool	bFound;
+
+	if (fIgnore & IGNORE_NORMAL)
+	{
+		flMinNormalError = 0;
+		flNormalError    = 0;
+	}
+
+	if (fIgnore & IGNORE_TEXCOORD)
+	{
+		flMinTexcoordError = 0;
+		flTexcoordError    = 0;
+	}
+
+	if (fIgnore & IGNORE_TANGENTS)
+	{
+		flMinTangentSError = 0;
+		flTangentSError    = 0;
+	}
+
+	int nVertexCount = pSrc->m_GlobalVertices.Count();
+	for ( int i = 0; i < nVertexCount; i++ )
+	{
+		const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[i];
+
+		// Compute error metrics
+		ComparePositionFuzzy( searchVertex.m_Position, srcVertex.position, flPositionError );
+
+		if (!(fIgnore & IGNORE_NORMAL))
+		{
+			CompareNormalFuzzy( searchVertex.m_Normal, srcVertex.normal, flNormalError );
+		}
+
+		if (!(fIgnore & IGNORE_TEXCOORD))
+		{
+			CompareTexCoordsFuzzy( searchVertex.m_TexCoord, srcVertex.texcoord, flTexcoordError );
+		}
+
+		if (!(fIgnore & IGNORE_TANGENTS))
+		{
+			CompareTangentSFuzzy( searchVertex.m_TangentS, srcVertex.tangentS, flTangentSError );
+		}
+
+		// the vert with minimum error is the best or exact candidate
+		bFound = false;
+		if (flMinPositionError > flPositionError)
+		{
+			bFound = true;
+		}
+		else if (flMinPositionError == flPositionError)
+		{
+			if (flMinTexcoordError > flTexcoordError)
+			{
+				bFound = true;
+			}
+			else if (flMinTexcoordError == flTexcoordError)
+			{
+				if (flMinNormalError > flNormalError)
+				{
+					bFound = true;
+				}
+				else if (flMinNormalError == flNormalError)
+				{
+					if (flMinTangentSError >= flTangentSError)
+					{
+						bFound = true;
+					}
+				}
+			}
+		}
+
+		if (bFound)
+		{
+			flMinPositionError  = flPositionError;
+			flMinTexcoordError  = flTexcoordError;
+			flMinNormalError    = flNormalError;
+			flMinTangentSError  = flTangentSError;
+			nBestIndex          = i;
+		}
+	}
+	
+	if ( nBestIndex == -1 )
+	{
+		MdlError( "Encountered a mesh with no vertices!\n" );
+	}
+
+	memcpy( &boneWeight, &pSrc->m_GlobalVertices[ nBestIndex ].boneweight, sizeof(s_boneweight_t) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Modify the bone weights in all of the vertices....
+//-----------------------------------------------------------------------------
+static void RemapBoneWeights( const CUtlVector<int> &boneMap, s_boneweight_t &boneWeight )
+{
+	for( int i = 0; i < boneWeight.numbones; i++ )
+	{
+		Assert( boneWeight.bone[i] >= 0 && boneWeight.bone[i] < boneMap.Count() );
+		boneWeight.bone[i] = boneMap[ boneWeight.bone[i] ];
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// After the remapping, we may get multiple instances of the same bone
+// which we want to collapse into a single bone
+//-----------------------------------------------------------------------------
+static void CollapseBoneWeights( s_boneweight_t &boneWeight )
+{
+	// We need the bones to be sorted by bone index for the loop right below
+	SortBoneWeightByIndex( boneWeight );
+
+	for( int i = 0; i < boneWeight.numbones-1; i++ )
+	{
+		if( boneWeight.bone[i] != boneWeight.bone[i+1] )
+			continue;
+
+		// add i+1's weight to i since they have the same bone index
+		boneWeight.weight[i] += boneWeight.weight[i+1];
+
+		// remove i+1
+		for( int j = i+1; j < boneWeight.numbones-1; j++ )
+		{
+			boneWeight.bone[j] = boneWeight.bone[j+1];
+			boneWeight.weight[j] = boneWeight.weight[j+1];
+		}
+		--boneWeight.numbones;
+
+		// Gotta step back one, may have many bones collapsing into one
+		--i;
+	}
+
+	ValidateBoneWeight( boneWeight );
+}
+
+
+//-----------------------------------------------------------------------------
+// Find a matching vertex within the root lod 
+//-----------------------------------------------------------------------------
+static void CalculateBoneWeightFromRootLod( const VertexInfo_t &searchVertex, CVertexDictionary &vertexDict, 
+	const s_source_t *pRootLODSrc, VertexInfo_t &idealVertex )
+{
+	idealVertex = searchVertex;
+
+	// Look through the part of the vertex dictionary associated with the root LODs for a match
+	// bone weights are not defined properly in SMDs for lower LODs, so don't consider
+	// we can only accept the boneweight from the root LOD
+	int nVertexDictID = FindVertexWithinVertexDictionary( searchVertex, vertexDict, 
+		vertexDict.RootLODVertexStart(), vertexDict.RootLODVertexEnd(), IGNORE_BONEWEIGHT|IGNORE_TANGENTS ); 
+	if ( nVertexDictID != -1 )
+	{
+		Assert( nVertexDictID >= vertexDict.RootLODVertexStart() && nVertexDictID < vertexDict.RootLODVertexEnd() );
+		Assert( nVertexDictID >= 0 && nVertexDictID < vertexDict.VertexCount() );
+
+		// found vertex in dictionary
+#ifdef UNIQUE_VERTEXES_FOR_LOD
+		// keep entry vertex and fill in the missing bone weight attribute
+		idealVertex.m_BoneWeight = vertexDict.Vertex( nVertexDictID ).m_BoneWeight;
+#else
+		// discard entry vertex in favor of best match
+		// this ensures all the attributes, including bone weight are correct for that vertex
+		// the worst case is that the vertex is not an *exact* match for entry attributes just a "close" match
+		idealVertex = vertexDict.Vertex( nVertexDictID );
+#endif
+		return;
+	}
+
+	// In this case, we didn't find anything within the tolerance, so we need to
+	// do a *positional check only* to give us a bone weight to assign to this vertex.
+	FindBoneWeightWithinModel( searchVertex, pRootLODSrc, idealVertex.m_BoneWeight, IGNORE_BONEWEIGHT|IGNORE_TANGENTS );
+}
+
+//-----------------------------------------------------------------------------
+// Find a matching vertex
+//-----------------------------------------------------------------------------
+static void CalculateIdealVert( const VertexInfo_t &searchVertex, CVertexDictionary &vertexDict, 
+	const s_mesh_t *pVertexDictMesh, const s_source_t *pRootLODSrc, VertexInfo_t &idealVertex )
+{
+#ifndef UNIQUE_VERTEXES_FOR_LOD
+	// Only look through the part of the vertex dictionary associated with all *higher* LODs for a match
+	int nVertexDictID = FindVertexWithinVertexDictionary( searchVertex, vertexDict, 
+		pVertexDictMesh->vertexoffset, vertexDict.PrevLODVertexCount(), 0 ); 
+	if ( nVertexDictID != -1 )
+	{
+		Assert( nVertexDictID >= pVertexDictMesh->vertexoffset && nVertexDictID < vertexDict.PrevLODVertexCount() );
+		Assert( nVertexDictID >= 0 && nVertexDictID < vertexDict.VertexCount() );
+
+		// found vertex in dictionary
+		idealVertex = vertexDict.Vertex( nVertexDictID );
+		return;
+	}
+#endif
+
+	// could not find a tolerant match
+	// the search vertex is unique
+	idealVertex = searchVertex;
+}
+
+
+static bool FuzzyFloatCompare( float f1, float f2, float epsilon )
+{
+	if( fabs( f1 - f2 ) < epsilon )
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+								
+
+//-----------------------------------------------------------------------------
+// Is this bone weight structure sorted by bone?
+//-----------------------------------------------------------------------------
+static bool IsBoneWeightSortedByBone( const s_boneweight_t &src )
+{
+	for ( int i = 1; i < src.numbones; ++i )
+	{
+		Assert( src.bone[i] != -1 );
+		if ( src.bone[ i-1 ] > src.bone[ i ] )
+			return false;
+	}
+
+	return true;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Are two bone-weight structures equal?
+//-----------------------------------------------------------------------------
+static bool AreBoneWeightsEqual( const s_boneweight_t &b1, const s_boneweight_t &b2 )
+{
+	// Have to have the same number of bones
+	if ( b1.numbones != b2.numbones )
+		return false;
+
+	// This is a list of which bones that exist in b1 also exist in b2.
+	// Use the index to figure out where in the array for b2 that the corresponding bone in b1 is.
+	int nMatchingBones = 0;
+	int pBoneIndexMap[MAX_NUM_BONES_PER_VERT]; 
+
+	int i;
+	for ( i = 0; i < b1.numbones; ++i )
+	{
+		pBoneIndexMap[i] = -1;
+		for ( int j = 0; j < b2.numbones; ++j )
+		{
+			if ( b2.bone[j] == b1.bone[i] )
+			{
+				pBoneIndexMap[i] = j;
+				++nMatchingBones;
+				break;
+			}
+		}
+	}
+
+	// If we aren't using the same bone indices, we're done
+	if ( nMatchingBones != b1.numbones )
+		return false;
+
+	// Check to see if the weights are the same
+	for ( i = 0; i < b1.numbones; ++i )
+	{
+		Assert( pBoneIndexMap[i] != -1 );
+		if ( b1.weight[i] != b2.weight[ pBoneIndexMap[i] ] )
+			return false;
+	}
+
+	return true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Finds an *exact* requested vertex in the dictionary
+//-----------------------------------------------------------------------------
+static int FindVertexInDictionaryExact( CVertexDictionary &vertexDict, int nStartVert, int nEndVert, const VertexInfo_t &vertex )
+{
+	for ( int nVertID = nStartVert; nVertID < nEndVert; ++nVertID )
+	{
+		if ( vertexDict.Vertex( nVertID ).m_Position != vertex.m_Position )
+			continue;
+
+		if ( !AreBoneWeightsEqual( vertexDict.Vertex( nVertID ).m_BoneWeight, vertex.m_BoneWeight ) )
+			continue;
+
+		if ( vertexDict.Vertex( nVertID ).m_TexCoord != vertex.m_TexCoord )
+			continue;
+
+		if ( vertexDict.Vertex( nVertID ).m_Normal != vertex.m_Normal )
+			continue;
+
+		if ( vertexDict.Vertex( nVertID ).m_TangentS != vertex.m_TangentS )
+			continue;
+
+		return nVertID;
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Finds the *exact* requested vertex in the dictionary or creates it
+//-----------------------------------------------------------------------------
+static int FindOrCreateExactVertexInDictionary( CVertexDictionary &vertexDict, 
+	const VertexInfo_t &vertex, s_mesh_t *pDstMesh )
+{
+	int nMeshVertID = FindVertexInDictionaryExact( vertexDict, pDstMesh->vertexoffset, pDstMesh->vertexoffset+pDstMesh->numvertices, vertex );
+	if ( nMeshVertID != -1 )
+	{
+		// flag vertex for what LoD's are using it
+		vertexDict.Vertex( nMeshVertID ).m_nLodFlag |= vertex.m_nLodFlag;
+		return nMeshVertID - pDstMesh->vertexoffset;
+	}
+
+	nMeshVertID = vertexDict.AddVertex( vertex );
+	++pDstMesh->numvertices;
+	return nMeshVertID - pDstMesh->vertexoffset;
+}
+
+static void PrintBonesUsedInLOD( s_source_t *pSrc )
+{
+	printf( "PrintBonesUsedInLOD\n" );
+
+	int nVertexCount = pSrc->m_GlobalVertices.Count();
+	for( int i = 0; i <nVertexCount; i++ )
+	{
+		Vector &pos = pSrc->m_GlobalVertices[i].position;
+		Vector &norm = pSrc->m_GlobalVertices[i].normal;
+		Vector2D &texcoord = pSrc->m_GlobalVertices[i].texcoord;
+		printf( "pos: %f %f %f norm: %f %f %f texcoord: %f %f\n",
+			pos[0], pos[1], pos[2], norm[0], norm[1], norm[2], texcoord[0], texcoord[1] );
+		s_boneweight_t *pBoneWeight = &pSrc->m_GlobalVertices[i].boneweight;
+		int j;
+		for( j = 0; j < pBoneWeight->numbones; j++ )
+		{
+			int globalBoneID = pBoneWeight->bone[j];
+			const char *pBoneName = g_bonetable[globalBoneID].name;
+			printf( "vert: %d bone: %d boneid: %d weight: %f name: \"%s\"\n", i, ( int )j, ( int )pBoneWeight->bone[j], 
+				( float )pBoneWeight->weight[j], pBoneName );
+		}
+		printf( "\n" );
+		fflush( stdout );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates a particular set of bones is used by a particular LOD
+//-----------------------------------------------------------------------------
+static void	MarkBonesUsedByLod( const s_boneweight_t &boneWeight, int nLodID )
+{
+	for( int j = 0; j < boneWeight.numbones; ++j )
+	{
+		int nGlobalBoneID = boneWeight.bone[j];
+		s_bonetable_t *pBone = &g_bonetable[nGlobalBoneID];
+		pBone->flags |= ( BONE_USED_BY_VERTEX_LOD0 << nLodID );
+	}
+}
+
+
+static void PrintSBoneWeight( s_boneweight_t *pBoneWeight, const s_source_t *pSrc )
+{
+	int j;
+	for( j = 0; j < pBoneWeight->numbones; j++ )
+	{
+		int globalBoneID;
+		globalBoneID = pBoneWeight->bone[j];
+		const char *pBoneName = g_bonetable[globalBoneID].name;
+		printf( "bone: %d boneid: %d weight: %f name: \"%s\"\n", ( int )j, ( int )pBoneWeight->bone[j], 
+			( float )pBoneWeight->weight[j], pBoneName );
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// In the non-top LOD, look for vertices that would be appropriate from the
+// vertex dictionary, and use them if you find them, or add new vertices to the 
+// vertex dictionary if not and use those new vertices.
+//-----------------------------------------------------------------------------
+static void CreateLODVertsInDictionary( int nLodID, const s_source_t *pRootLODSrc, s_source_t *pCurrentLODSrc, 
+	const s_mesh_t *pCurrLODMesh, s_mesh_t *pVertexDictMesh, CVertexDictionary &vertexDict, int *pMeshVertIndexMap )
+{
+	// this function is specific to lods and not the root
+	Assert( nLodID );
+
+	int nNumCurrentVerts = vertexDict.VertexCount();
+
+	// Used to control where we look for vertices + merging rules
+	vertexDict.StartNewLOD();
+
+	CUtlVector<int> boneMap;
+	BuildBoneLODMapping( boneMap, nLodID );
+
+	for( int nSrcVertID = 0; nSrcVertID < pCurrLODMesh->numvertices; ++nSrcVertID )
+	{
+		int nSrcID = nSrcVertID + pCurrLODMesh->vertexoffset;
+
+		// candidate vertex
+		// vertices at lower LODs have bogus boneweights assigned
+		// must get the boneweight from the nearest or exact vertex at root lod
+		const s_vertexinfo_t& srcVertex = pCurrentLODSrc->m_GlobalVertices[nSrcID];
+		VertexInfo_t vertex;
+		vertex.m_Position   = srcVertex.position; 
+		vertex.m_Normal     = srcVertex.normal;
+		vertex.m_TexCoord   = srcVertex.texcoord;
+		vertex.m_TangentS   = srcVertex.tangentS;
+
+#ifdef _DEBUG
+		memset( &vertex.m_BoneWeight, 0xDD, sizeof( s_boneweight_t ) );
+#endif
+		// determine the best bone weight for the desired vertex within the root lod only
+		// the root lod contains no bone remappings
+		// this ensures we get a vertex with its matched proper boneweight assignment
+		VertexInfo_t idealVertex;
+		CalculateBoneWeightFromRootLod( vertex, vertexDict, pRootLODSrc, idealVertex );
+
+		// try again to match the candidate vertex
+		// determine the ideal vertex with desired remapped boneweight
+		vertex = idealVertex;
+		CalculateIdealVert( vertex, vertexDict, pVertexDictMesh, pRootLODSrc, idealVertex);
+
+		// remap bone
+		RemapBoneWeights( boneMap, idealVertex.m_BoneWeight );
+		CollapseBoneWeights( idealVertex.m_BoneWeight );
+		SortBoneWeightByWeight( idealVertex.m_BoneWeight );
+
+		// FIXME: this is marking bones based on the slammed vertex data
+		MarkBonesUsedByLod( idealVertex.m_BoneWeight, nLodID );
+
+		// tag ideal vertex as being part of the current lod
+		idealVertex.m_nLodFlag		= 1 << nLodID;
+
+		// Find the exact vertex or create it in the dictionary
+		int nMeshVertID = FindOrCreateExactVertexInDictionary( vertexDict, idealVertex, pVertexDictMesh );
+
+		// Indicate where in the higher LODs the vertex we selected resides
+		pMeshVertIndexMap[nSrcID] = nMeshVertID;
+	}
+
+	int nNewVertsCreated = vertexDict.VertexCount() - nNumCurrentVerts;
+	if (!g_quiet && nNewVertsCreated)
+	{
+		printf( "Lod %d: vertexes: %d (%d new)\n", nLodID, vertexDict.VertexCount(), nNewVertsCreated);
+	}
+}
+
+static void PrintSourceVerts( s_source_t *pSrc )
+{
+	int nVertexCount = pSrc->m_GlobalVertices.Count();
+	for( int i = 0; i < nVertexCount; i++ )
+	{
+		const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[i];
+		printf( "v %d ", i );
+		printf( "pos: %f %f %f ", srcVertex.position[0], srcVertex.position[1], srcVertex.position[2] );
+		printf( "norm: %f %f %f ", srcVertex.normal[0], srcVertex.normal[1], srcVertex.normal[2] );
+		printf( "texcoord: %f %f\n", srcVertex.texcoord[0], srcVertex.texcoord[1] );
+		int j;
+		for( j = 0; j < srcVertex.boneweight.numbones; j++ )
+		{
+			printf( "\t%d: %d %f\n", j, ( int )srcVertex.boneweight.bone[j], 
+				srcVertex.boneweight.weight[j] );
+		}
+		fflush( stdout );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Copy the vertex dictionary to the finalized processed data
+// Leaves the source data intact, necessary for later processes.
+// Routines can then choose which data they operate on
+//-----------------------------------------------------------------------------
+static void SetProcessedWithDictionary( s_model_t* pSrcModel, CVertexDictionary &vertexDict,
+	CUtlVector<s_face_t> &faces, CUtlVector<s_mesh_t> &meshes, int *pMeshVertIndexMaps[MAX_NUM_LODS] )
+{
+	int	i;
+
+	s_loddata_t *pLodData = new s_loddata_t;
+	memset( pLodData, 0, sizeof(s_loddata_t) );
+	
+	pSrcModel->m_pLodData = pLodData;
+
+	int nVertexCount = vertexDict.VertexCount();
+
+	pLodData->vertex = (s_lodvertexinfo_t *)kalloc( nVertexCount, sizeof( s_lodvertexinfo_t ) );
+	pLodData->numvertices = nVertexCount;
+	pLodData->face = (s_face_t *)kalloc( faces.Count(), sizeof( s_face_t ));
+	pLodData->numfaces = faces.Count();
+	
+	for ( i = 0; i < nVertexCount; ++i )
+	{
+		const VertexInfo_t &srcVertex = vertexDict.Vertex( i );
+		s_lodvertexinfo_t &dstVertex = pLodData->vertex[i];
+
+		dstVertex.boneweight = srcVertex.m_BoneWeight;
+		Assert( dstVertex.boneweight.numbones <= 4 );
+		dstVertex.position	= srcVertex.m_Position;
+		dstVertex.normal	= srcVertex.m_Normal;
+		dstVertex.texcoord	= srcVertex.m_TexCoord;
+		dstVertex.tangentS	= srcVertex.m_TangentS;
+		dstVertex.lodFlag	= srcVertex.m_nLodFlag;
+	}
+
+	memcpy( pLodData->face, faces.Base(), faces.Count() * sizeof( s_face_t ) );
+	memcpy( pLodData->mesh, meshes.Base(), meshes.Count() * sizeof( s_mesh_t ) );
+
+	for (i=0; i<MAX_NUM_LODS; i++)
+	{
+		pLodData->pMeshVertIndexMaps[i] = pMeshVertIndexMaps[i];
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// This fills out boneMap, which is a mapping from src bone to src bone replacement (or to itself
+// if there is no bone replacement.
+//-----------------------------------------------------------------------------
+static void BuildBoneLODMapping( CUtlVector<int> &boneMap, int lodID )
+{
+	boneMap.AddMultipleToTail( g_numbones );
+
+	Assert( lodID < g_ScriptLODs.Size() );
+	LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
+
+	// First, create a direct mapping where no bones are collapsed
+	int i;
+	for( i = 0; i < g_numbones; i++ )
+	{
+		boneMap[i] = i;
+	}
+
+	for( i = 0; i < scriptLOD.boneReplacements.Size(); i++ )
+	{
+		const char *src, *dst;
+		src = scriptLOD.boneReplacements[i].GetSrcName();
+		dst = scriptLOD.boneReplacements[i].GetDstName();
+		int j = findGlobalBone( src );
+		int k = findGlobalBone( dst );
+
+		if ( j != -1 && k != -1)
+		{
+			boneMap[j] = k;
+		}
+		else if ( j == -1)
+		{
+			// FIXME: is this really an error?  It could just be  replacement command for bone that doesnt' exist anymore.
+			if (g_verbose)
+			{
+				MdlWarning( "Couldn't replace unknown bone \"%s\" with \"%s\"\n", src, dst );
+			}
+		}
+		else
+		{
+			// FIXME: is this really an error?  It could just be  replacement command for bone that doesnt' exist anymore.
+			if (g_verbose)
+			{
+				MdlWarning( "Couldn't replace bone \"%s\" with unknown \"%s\"\n", src, dst );
+			}
+		}
+	}
+}
+
+static void MarkRootLODBones( CVertexDictionary &vertexDictionary )
+{
+	// should result in an identity mapping
+	// because their are no bone remaps at the root lod
+	CUtlVector<int> boneMap;
+	BuildBoneLODMapping( boneMap, 0 );
+
+	// iterate and mark bones
+	for (int nVertDictID=vertexDictionary.RootLODVertexStart(); nVertDictID<vertexDictionary.RootLODVertexEnd(); nVertDictID++)
+	{
+		s_boneweight_t &boneWeight = vertexDictionary.Vertex( nVertDictID ).m_BoneWeight;
+
+		RemapBoneWeights( boneMap, boneWeight );
+		CollapseBoneWeights( boneWeight );
+		SortBoneWeightByWeight( boneWeight );
+
+		MarkBonesUsedByLod( boneWeight, 0 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes LOD vertices for a model piece.
+//-----------------------------------------------------------------------------
+static void UnifyModelLODs( s_model_t *pSrcModel )
+{
+	if ( !Q_stricmp( pSrcModel->name, "blank" ) )
+		return;
+
+	// each lod has a unique vertex mapping table
+	int nNumLODs = pSrcModel->m_LodSources.Count();
+	int nLodID;
+	int *pMeshVertIndexMaps[MAX_NUM_LODS];
+	for ( nLodID = 0; nLodID < MAX_NUM_LODS; nLodID++ )
+	{
+		if ( nLodID < nNumLODs && pSrcModel->m_LodSources[nLodID] )
+		{
+			int nVertexCount = pSrcModel->m_LodSources[nLodID]->m_GlobalVertices.Count();
+			pMeshVertIndexMaps[nLodID] = new int[ nVertexCount ];
+#ifdef _DEBUG
+			memset( pMeshVertIndexMaps[nLodID], 0xDD, nVertexCount * sizeof(int) );
+#endif
+		}
+		else
+		{
+			pMeshVertIndexMaps[nLodID] = NULL;
+		}
+	}
+
+	// These hold the aggregate data for the model that grows as lods are processed
+	CVertexDictionary vertexDictionary;
+	CUtlVector<s_face_t> faces;
+	CUtlVector<s_mesh_t> meshes;
+	
+	meshes.AddMultipleToTail( MAXSTUDIOSKINS );
+	Assert( meshes.Count() == MAXSTUDIOSKINS );
+	memset( meshes.Base(), 0, meshes.Count() * sizeof( s_mesh_t ) );
+
+	int nMeshID;
+	for( nMeshID = 0; nMeshID < pSrcModel->source->nummeshes; nMeshID++ )
+	{
+		s_mesh_t *pVertexDictMesh = &meshes[pSrcModel->source->meshindex[nMeshID]];
+		
+		pVertexDictMesh->numvertices = 0;
+		pVertexDictMesh->vertexoffset = vertexDictionary.VertexCount();
+		pVertexDictMesh->numfaces = 0;
+		pVertexDictMesh->faceoffset = faces.Count();
+		
+		// First build up information for LOD 0
+		if ( !pSrcModel->m_LodSources[0] )
+			continue;
+
+		s_source_t *pLOD0Source = pSrcModel->m_LodSources[0];
+
+		// lookup the material used by this mesh
+		int nMaterialID = pLOD0Source->meshindex[nMeshID];
+		s_mesh_t *pLOD0Mesh = FindMeshByMaterial( pLOD0Source, nMaterialID );
+		if ( !pLOD0Mesh )
+			continue;
+
+		// populate with all vertices from LOD 0
+		int nStart = vertexDictionary.VertexCount();
+		CopyVerts( 0, pLOD0Source, pLOD0Mesh, vertexDictionary, pVertexDictMesh, pMeshVertIndexMaps[0] );
+		vertexDictionary.SetRootVertexRange( nStart, vertexDictionary.VertexCount() );
+	
+		MarkRootLODBones( vertexDictionary );
+
+		// only fix up the faces for the highest lod since the lowest ones are going
+		// to be reprocessed later.
+		CopyFaces( pLOD0Source, pLOD0Mesh, faces, pVertexDictMesh );
+
+		// Now, for each LOD, try to build meshes using the vertices in LOD 0.
+		// Ideally, vertices used in an LOD would be in LOD 0 for the benefit of shared vertices.
+		// If we don't find vertices in LOD 0, this code will add vertices into LOD 0's list
+		// of vertices for the next LOD to find
+		for ( nLodID = 1; nLodID < nNumLODs; ++nLodID )
+		{
+			s_source_t *pCurrLOD = pSrcModel->m_LodSources[nLodID];
+			if ( !pCurrLOD )
+				continue;
+
+			// Find the mesh that matches the material
+			// mesh may not be present or could be culled due to $removemesh commands
+			s_mesh_t *pCurrLODMesh = FindOrCullMesh( nLodID, pCurrLOD, nMaterialID );
+			if ( !pCurrLODMesh )
+				continue;
+
+			CreateLODVertsInDictionary( nLodID, pLOD0Source, pCurrLOD, pCurrLODMesh, pVertexDictMesh, vertexDictionary, pMeshVertIndexMaps[nLodID]);
+		}
+	}
+
+#ifdef _DEBUG
+	Msg( "Total vertex count: %d\n", vertexDictionary.VertexCount() );
+#endif
+
+	// save the data we just built into the processed data section
+	// The processed data has all of the verts that are needed for all LODs.
+	SetProcessedWithDictionary( pSrcModel, vertexDictionary, faces, meshes, pMeshVertIndexMaps );
+//	PrintSourceVerts( pSrcModel->m_LodModels[0] );
+}
+
+
+//-----------------------------------------------------------------------------
+// Force the vertex array for a model to have all of the vertices that are needed
+// for all of the LODs of the model.
+//-----------------------------------------------------------------------------
+void UnifyLODs( void )
+{
+	// todo: need to fixup the firstref/lastref stuff . . do we really need it anymore?
+	for( int modelID = 0; modelID < g_nummodelsbeforeLOD; modelID++ )
+	{
+		UnifyModelLODs( g_model[modelID] );
+	}
+}
+
+
+static void PrintSpaces( int numSpaces )
+{
+	int i;
+	for( i = 0; i < numSpaces; i++ )
+	{
+		printf( " " );
+	}
+}
+
+static void SpewBoneInfo( int globalBoneID, int depth )
+{
+	s_bonetable_t *pBone = &g_bonetable[globalBoneID];
+	if( g_bPrintBones )
+	{
+		PrintSpaces( depth * 2 );
+		printf( "%d \"%s\" ", depth, pBone->name );
+	}
+	int i;
+	for( i = 0; i < 8; i++ )
+	{
+		if( pBone->flags & ( BONE_USED_BY_VERTEX_LOD0 << i ) )
+		{
+			if( g_bPrintBones )
+			{
+				printf( "lod%d ", i );
+			}
+			g_NumBonesInLOD[i]++;
+		}
+	}
+	if( g_bPrintBones )
+	{
+		printf( "\n" );	
+	}
+	
+	int j;
+	for( j = 0; j < g_numbones; j++ )
+	{
+		s_bonetable_t *pBone = &g_bonetable[j];
+		if( pBone->parent == globalBoneID )
+		{
+			SpewBoneInfo( j, depth + 1 );
+		}
+	}
+}
+
+void SpewBoneUsageStats( void )
+{
+	memset( g_NumBonesInLOD, 0, sizeof( int ) * MAX_NUM_LODS );
+	if( g_numbones == 0 )
+	{
+		return;
+	}
+	SpewBoneInfo( 0, 0 );
+	if( g_bPrintBones )
+	{
+		int i;
+		for( i = 0; i < g_ScriptLODs.Count(); i++ )
+		{
+			printf( "\t%d bones used in lod %d\n", g_NumBonesInLOD[i], i );
+		}
+	}
+}
+
+void MarkParentBoneLODs( void )
+{
+	int i;
+	for( i = 0; i < g_numbones; i++ )
+	{
+		int flags = g_bonetable[i].flags;
+		flags &= BONE_USED_BY_VERTEX_MASK;
+		int globalBoneID = g_bonetable[i].parent;
+		while( globalBoneID != -1 )
+		{
+			g_bonetable[globalBoneID].flags |= flags;
+			globalBoneID = g_bonetable[globalBoneID].parent;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the sources associated with the various LODs based on the script commands
+//-----------------------------------------------------------------------------
+static void GetLODSources( CUtlVector< s_source_t * > &lods, const s_model_t *pSrcModel )
+{
+	int nNumLODs = g_ScriptLODs.Count();
+	lods.EnsureCount( nNumLODs );
+	for( int lodID = 0; lodID < nNumLODs; lodID++ )
+	{
+		LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
+
+		bool bFound;
+		s_source_t* pSource = GetModelLODSource( pSrcModel->filename, scriptLOD, &bFound );
+		if ( !pSource && !bFound )
+		{
+			pSource = pSrcModel->source;
+		}
+
+		lods[lodID] = pSource;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates models to store converted data for the various LODs
+//-----------------------------------------------------------------------------
+void LoadLODSources( void )
+{
+	g_nummodelsbeforeLOD = g_nummodels;
+	for( int modelID = 0; modelID < g_nummodelsbeforeLOD; modelID++ )
+	{
+		if ( !Q_stricmp( g_model[modelID]->name, "blank" ) )
+		{
+			int nNumLODs = g_ScriptLODs.Count();
+			g_model[modelID]->m_LodSources.SetCount( nNumLODs );
+			for ( int i = 0; i < nNumLODs; ++i )
+			{
+				g_model[modelID]->m_LodSources[i] = NULL;
+			}
+			continue;
+		}
+
+		GetLODSources( g_model[modelID]->m_LodSources, g_model[modelID] );
+	}
+}
+
+static void ReplaceBonesRecursive( int globalBoneID, bool replaceThis, 
+								   CUtlVector<CLodScriptReplacement_t> &boneReplacements, 
+								   const char *replacementName )
+{
+	if( replaceThis )
+	{
+		CLodScriptReplacement_t &boneReplacement = boneReplacements[boneReplacements.AddToTail()];
+		boneReplacement.SetSrcName( g_bonetable[globalBoneID].name );
+		boneReplacement.SetDstName( replacementName );
+	}
+
+	// find children and recurse.
+	int i;
+	for( i = 0; i < g_numbones; i++ )
+	{
+		if( g_bonetable[i].parent == globalBoneID )
+		{
+			ReplaceBonesRecursive( i, true, boneReplacements, replacementName );
+		}
+	}
+}
+
+static void ConvertSingleBoneTreeCollapseToReplaceBones( CLodScriptReplacement_t &boneTreeCollapse, 
+														 CUtlVector<CLodScriptReplacement_t> &boneReplacements )
+{
+	// find the bone that we are starting with.
+	int i = findGlobalBone( boneTreeCollapse.GetSrcName() );
+	if (i != -1)
+	{
+		ReplaceBonesRecursive( i, false, boneReplacements, g_bonetable[i].name );
+		return;
+	}
+	MdlWarning( "Couldn't find bone %s for bonetreecollapse, skipping\n", boneTreeCollapse.GetSrcName() );
+}
+
+void ConvertBoneTreeCollapsesToReplaceBones( void )
+{
+	int i;
+	for( i = 0; i < g_ScriptLODs.Size(); i++ )
+	{
+		LodScriptData_t& lod = g_ScriptLODs[i];
+		int j;
+		for( j = 0; j < lod.boneTreeCollapses.Size(); j++ )
+		{
+			ConvertSingleBoneTreeCollapseToReplaceBones( lod.boneTreeCollapses[j], 
+				lod.boneReplacements );
+		}
+	}
+}
+
+/*
+static void PrintReplacedBones( LodScriptData_t &lod )
+{
+	int i;
+	for( i = 0; i < lod.boneReplacements.Count(); i++ )
+	{
+		printf( "%s -> %s\n", 
+			lod.boneReplacements[i].GetSrcName(), 
+			lod.boneReplacements[i].GetDstName() );
+	}
+}
+*/
+
+void FixupReplacedBonesForLOD( LodScriptData_t &lod )
+{
+/*
+	printf( "before:\n" );
+	PrintReplacedBones( lod );
+*/
+	bool changed;
+	int i;
+	int j;
+	do
+	{
+		changed = false;
+		for( i = 0; i < lod.boneReplacements.Count(); i++ )
+		{
+			for( j = 0; j < lod.boneReplacements.Count(); j++ )
+			{
+				if( i == j )
+				{
+					continue;
+				}
+				if( Q_stricmp( lod.boneReplacements[i].GetSrcName(), lod.boneReplacements[j].GetDstName() ) == 0 )
+				{
+					lod.boneReplacements[j].SetDstName( lod.boneReplacements[i].GetDstName() );
+					changed = true;
+				}
+			}
+		}
+	} while( changed );
+/*
+	printf( "after:\n" );
+	PrintReplacedBones( lod );
+*/
+}
+
+void FixupReplacedBones( void )
+{
+	int i;
+	for( i = 0; i < g_ScriptLODs.Size(); i++ )
+	{
+		FixupReplacedBonesForLOD( g_ScriptLODs[i] );
+	}
+}
diff --git a/utils/studiomdl/bmpread.cpp b/utils/studiomdl/bmpread.cpp
new file mode 100644
index 0000000..24663fe
--- /dev/null
+++ b/utils/studiomdl/bmpread.cpp
@@ -0,0 +1,98 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+
+#include <windows.h>
+#include <STDIO.H>
+
+
+int
+ReadBmpFile(
+	char* szFile,
+	unsigned char** ppbPalette,
+	unsigned char** ppbBits,
+	int *pwidth,
+	int *pheight)
+	{
+	int rc = 0;
+	FILE *pfile = NULL;
+	BITMAPFILEHEADER bmfh;
+	BITMAPINFOHEADER bmih;
+	RGBQUAD rgrgbPalette[256];
+	ULONG cbPalBytes;
+	ULONG cbBmpBits;
+	BYTE* pbBmpBits;
+
+	// Bogus parameter check
+	if (!(ppbPalette != NULL && ppbBits != NULL))
+		{ rc = -1000; goto GetOut; }
+
+	// File exists?
+	if ((pfile = fopen(szFile, "rb")) == NULL)
+		{ rc = -1; goto GetOut; }
+	
+	// Read file header
+	if (fread(&bmfh, sizeof bmfh, 1/*count*/, pfile) != 1)
+		{ rc = -2; goto GetOut; }
+
+	// Bogus file header check
+	if (!(bmfh.bfReserved1 == 0 && bmfh.bfReserved2 == 0))
+		{ rc = -2000; goto GetOut; }
+
+	// Read info header
+	if (fread(&bmih, sizeof bmih, 1/*count*/, pfile) != 1)
+		{ rc = -3; goto GetOut; }
+
+	// Bogus info header check
+	if (!(bmih.biSize == sizeof bmih && bmih.biPlanes == 1))
+		{ rc = -3000; goto GetOut; }
+
+	// Bogus bit depth?  Only 8-bit supported.
+	if (bmih.biBitCount != 8)
+		{ rc = -4; goto GetOut; }
+	
+	// Bogus compression?  Only non-compressed supported.
+	if (bmih.biCompression != BI_RGB)
+		{ rc = -5; goto GetOut; }
+
+	// Figure out how many entires are actually in the table
+	if (bmih.biClrUsed == 0)
+		{
+		cbPalBytes = (1 << bmih.biBitCount) * sizeof( RGBQUAD );
+		}
+	else 
+		{
+		cbPalBytes = bmih.biClrUsed * sizeof( RGBQUAD );
+		}
+
+	// Read palette (256 entries)
+	if (fread(rgrgbPalette, cbPalBytes, 1/*count*/, pfile) != 1)
+		{ rc = -6; goto GetOut; }
+
+	// Read bitmap bits (remainder of file)
+	cbBmpBits = bmfh.bfSize - ftell(pfile);
+	pbBmpBits = (BYTE *)malloc(cbBmpBits);
+	if (fread(pbBmpBits, cbBmpBits, 1/*count*/, pfile) != 1)
+		{ rc = -7; goto GetOut; }
+
+	// Set output parameters
+	*ppbPalette = (BYTE *)malloc(sizeof rgrgbPalette);
+	memcpy(*ppbPalette, rgrgbPalette, cbPalBytes);
+	*ppbBits = pbBmpBits;
+
+
+    *pwidth = bmih.biWidth;
+    *pheight = bmih.biHeight;
+
+	printf("w %d h %d s %d\n",bmih.biWidth, bmih.biHeight, cbBmpBits );
+
+GetOut:
+	if (pfile) fclose(pfile);
+	return rc;
+	}
+
diff --git a/utils/studiomdl/checkuv.cpp b/utils/studiomdl/checkuv.cpp
new file mode 100644
index 0000000..ff7063b
--- /dev/null
+++ b/utils/studiomdl/checkuv.cpp
@@ -0,0 +1,460 @@
+//============ Copyright (c) Valve Corporation, All rights reserved. ==========
+//
+// Function which do validation tests on UVs values at the s_source_t level
+//
+//=============================================================================
+
+
+#include "tier1/fmtstr.h"
+#include "tier1/utlmap.h"
+
+
+#include "studiomdl.h"
+#include "checkuv.h"
+
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+CCheckUVCmd::CCheckUVCmd()
+{
+	Clear();
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+void CCheckUVCmd::Clear()
+{
+	ClearCheck( CHECK_UV_ALL_FLAGS );
+	m_nOptGutterTexWidth = 512;
+	m_nOptGutterTexHeight = 512;
+	m_nOptGutterMin = 5;
+}
+
+
+//-----------------------------------------------------------------------------
+// Dumps an s_soruce_t as an OBJ file
+//-----------------------------------------------------------------------------
+static void WriteOBJ( const char *pszFilename, const s_source_t *pSource )
+{
+	FILE *pFile = fopen( pszFilename, "w" );
+
+	fprintf( pFile, "#\n" );
+	fprintf( pFile, "# s_source_t: %s\n", pSource->filename );
+	fprintf( pFile, "# Bone Count: %d\n", pSource->numbones );
+	
+	for ( int i = 0; i < pSource->numbones; ++i )
+	{
+		if ( pSource->localBone[i].parent >= 0 )
+		{
+			fprintf( pFile, "# Bone %3d: %s Parent %3d: %s\n", i, pSource->localBone[i].name, pSource->localBone[i].parent, pSource->localBone[pSource->localBone[i].parent].name );
+		}
+		else
+		{
+			fprintf( pFile, "# Bone %3d: %s\n", i, pSource->localBone[i].name );
+		}
+	}
+
+	fprintf( pFile, "# Mesh Count:   %d\n", pSource->nummeshes );
+	fprintf( pFile, "# Vertex Count: %d\n", pSource->numvertices );
+	fprintf( pFile, "# Face Count:   %d\n", pSource->numfaces );
+
+	fprintf( pFile, "#\n" );
+	fprintf( pFile, "# positions\n" );
+	fprintf( pFile, "#\n" );
+
+	for ( int i = 0; i < pSource->numvertices; ++i )
+	{
+		const s_vertexinfo_t &v = pSource->vertex[i];
+		fprintf( pFile, "v %.4f %.4f %.4f\n", v.position.x, v.position.y, v.position.z );
+	}
+
+	fprintf( pFile, "#\n" );
+	fprintf( pFile, "# texture coordinates\n" );
+	fprintf( pFile, "#\n" );
+
+	for ( int i = 0; i < pSource->numvertices; ++i )
+	{
+		const s_vertexinfo_t &v = pSource->vertex[i];
+		fprintf( pFile, "vt %.4f %.4f\n", v.texcoord.x, v.texcoord.y );
+	}
+
+	fprintf( pFile, "#\n" );
+	fprintf( pFile, "# normals\n" );
+	fprintf( pFile, "#\n" );
+
+	for ( int i = 0; i < pSource->numvertices; ++i )
+	{
+		const s_vertexinfo_t &v = pSource->vertex[i];
+		fprintf( pFile, "vn %.4f %.4f %.4f\n", v.normal.x, v.normal.y, v.normal.z );
+	}
+
+	for ( int i = 0; i < pSource->nummeshes; ++i )
+	{
+		const s_mesh_t &m = pSource->mesh[i];
+		const s_texture_t &t = g_texture[pSource->meshindex[i]];
+
+		fprintf( pFile, "#\n" );
+		fprintf( pFile, "# mesh %d - %s\n", i, t.name );
+		fprintf( pFile, "# Face Count:   %d\n", m.numfaces );
+		fprintf( pFile, "#\n" );
+		fprintf( pFile, "usemtl %s\n", t.name );
+
+		for ( int j = 0; j < m.numfaces; ++j )
+		{
+			const s_face_t &f = pSource->face[m.faceoffset + j];
+			fprintf( pFile, "f %d/%d/%d %d/%d/%d %d/%d/%d\n",
+				f.a, f.a, f.a,
+				f.b, f.b, f.b,
+				f.c, f.c, f.c );
+		}
+	}
+
+	fclose( pFile );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+bool CCheckUVCmd::CheckUVs( const s_source_t *const *pSourceList, int nSourceCount ) const
+{
+	if ( !DoAnyCheck() || nSourceCount <= 0 )
+		return true;
+
+	bool bRet = true;
+
+	for ( int i = 0; i < nSourceCount; ++i )
+	{
+		const s_source_t *pSource = pSourceList[i];
+
+		bRet &= CheckNormalized( pSource );
+		bRet &= CheckOverlap( pSource );
+		bRet &= CheckInverse( pSource );
+		bRet &= CheckGutter( pSource );
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Check that all UVs are in the [0, 1] range
+//-----------------------------------------------------------------------------
+bool CCheckUVCmd::CheckNormalized( const struct s_source_t *pSource ) const
+{
+	if ( !DoCheck( CHECK_UV_FLAG_NORMALIZED ) )
+		return true;
+
+	CUtlRBTree< int > badVertexIndices( CDefOps< int >::LessFunc );
+
+	for ( int i = 0; i < pSource->numvertices; ++i )
+	{
+		const s_vertexinfo_t &v = pSource->vertex[i];
+
+		if (
+			v.texcoord.x < 0.0f || v.texcoord.x > 1.0f ||
+			v.texcoord.y < 0.0f || v.texcoord.y > 1.0f )
+		{
+			badVertexIndices.InsertIfNotFound( i );
+		}
+	}
+
+	if ( badVertexIndices.Count() <= 0 )
+		return true;
+
+	Msg( "Error! %s\n", pSource->filename );
+	Msg( "       UVs outside of [0, 1] range\n" );
+
+	for ( int i = 0; i < pSource->nummeshes; ++i )
+	{
+		const s_mesh_t &m = pSource->mesh[i];
+		const s_texture_t &t = g_texture[pSource->meshindex[i]];
+
+		CUtlRBTree< int > badMeshVertexIndices( CDefOps< int >::LessFunc );
+
+		for ( int j = 0; j < m.numfaces; ++j )
+		{
+			const s_face_t &f = pSource->face[m.faceoffset + j];
+
+			if ( badVertexIndices.HasElement( f.a ) )
+			{
+				badMeshVertexIndices.InsertIfNotFound( f.a );
+			}
+
+			if ( badVertexIndices.HasElement( f.b ) )
+			{
+				badMeshVertexIndices.InsertIfNotFound( f.b );
+			}
+
+			if ( badVertexIndices.HasElement( f.c ) )
+			{
+				badMeshVertexIndices.InsertIfNotFound( f.c );
+			}
+		}
+
+		for ( auto vIt = badMeshVertexIndices.FirstInorder(); badMeshVertexIndices.IsValidIndex( vIt ); vIt = badMeshVertexIndices.NextInorder( vIt ) )
+		{
+			PrintVertex( pSource->vertex[badMeshVertexIndices.Element( vIt )], t );
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Check that all polygons in UV do not overlap
+//-----------------------------------------------------------------------------
+bool CCheckUVCmd::CheckOverlap( const struct s_source_t *pSource ) const
+{
+	if ( !DoCheck( CHECK_UV_FLAG_OVERLAP ) )
+		return true;
+
+	bool bRet = true;
+
+	CUtlVector< CUtlVector< int > > faceOverlapMap;
+	faceOverlapMap.SetCount( pSource->numfaces );
+
+	for ( int i = 0; i < pSource->numfaces; ++i )
+	{
+		const s_face_t &fA = pSource->face[i];
+
+		const Vector2D &tAA = pSource->vertex[fA.a].texcoord;
+		const Vector2D &tAB = pSource->vertex[fA.b].texcoord;
+		const Vector2D &tAC = pSource->vertex[fA.c].texcoord;
+
+		for ( int j = i + 1; j < pSource->numfaces; ++j )
+		{
+			const s_face_t &fB = pSource->face[j];
+
+			const Vector2D tB[] = {
+				pSource->vertex[fB.a].texcoord,
+				pSource->vertex[fB.b].texcoord,
+				pSource->vertex[fB.c].texcoord };
+
+			for ( int k = 0; k < ARRAYSIZE( tB ); ++k )
+			{
+				const Vector vCheck = Barycentric( tB[k], tAA, tAB, tAC );
+
+				if ( vCheck.x > 0.0f && vCheck.y > 0.0f && vCheck.z > 0.0f )
+				{
+					if ( bRet )
+					{
+						Msg( "Error! %s\n", pSource->filename );
+						Msg( "       Overlapping UV faces\n" );
+
+						bRet = false;
+					}
+
+					faceOverlapMap[i].AddToTail( j );
+
+					break;
+				}
+			}
+		}
+	}
+
+	for ( int i = 0; i < faceOverlapMap.Count(); ++i )
+	{
+		const CUtlVector< int > &overlapList = faceOverlapMap[i];
+		
+		if ( overlapList.IsEmpty() )
+			continue;;
+
+		const int nFaceA = i;
+		const int nMeshA = FindMeshIndex( pSource, nFaceA );
+		PrintFace( pSource, nMeshA, nFaceA );
+		Msg( "       Overlaps\n" );
+
+		for ( int j = 0; j < overlapList.Count(); ++j )
+		{
+			const int nFaceB = overlapList[j];
+			const int nMeshB = FindMeshIndex( pSource, nFaceB );
+			PrintFace( pSource, nMeshB, nFaceB, "                " );
+		}
+	}
+
+	return bRet;
+}
+
+
+//-----------------------------------------------------------------------------
+// Check that all polygons in UV have the correct winding, i.e. the cross
+// product of edge AB x BC points the right direction
+//-----------------------------------------------------------------------------
+bool CCheckUVCmd::CheckInverse( const struct s_source_t *pSource ) const
+{
+	if ( !DoCheck( CHECK_UV_FLAG_INVERSE ) )
+		return true;
+
+	bool bRetVal = true;
+
+	for ( int i = 0; i < pSource->nummeshes; ++i )
+	{
+		const s_mesh_t &m = pSource->mesh[i];
+
+		for ( int j = 0; j < m.numfaces; ++j )
+		{
+			const int nFaceIndex = m.faceoffset + j;
+
+			const s_face_t &f = pSource->face[nFaceIndex];
+
+			const Vector2D &tA = pSource->vertex[f.a].texcoord;
+			const Vector2D &tB = pSource->vertex[f.b].texcoord;
+			const Vector2D &tC = pSource->vertex[f.c].texcoord;
+
+			const Vector vA( tA.x, tA.y, 0.0f );
+			const Vector vB( tB.x, tB.y, 0.0f );
+			const Vector vC( tC.x, tC.y, 0.0f );
+
+			const Vector vAB = vB - vA;
+			const Vector vBC = vC - vB;
+
+			const Vector vUVNormal = CrossProduct( vAB, vBC );
+
+			const float flDot = DotProduct( vUVNormal, Vector( 0.0f, 0.0f, 1.0f ) );
+
+			if ( flDot < 0.0f )
+			{
+				if ( bRetVal )
+				{
+					Msg( "Error! %s\n", pSource->filename );
+					Msg( "       Inverse UV faces\n" );
+
+					bRetVal = false;
+				}
+
+				PrintFace( pSource, i, nFaceIndex );
+			}
+		}
+	}
+
+	return bRetVal;
+}
+
+
+//-----------------------------------------------------------------------------
+// Check that the distance between edges in UV islands is a minimum number of pixels for a given texture size
+//-----------------------------------------------------------------------------
+bool CCheckUVCmd::CheckGutter( const struct s_source_t *pSource ) const
+{
+	if ( !DoCheck( CHECK_UV_FLAG_GUTTER ) )
+		return true;
+
+	// TODO: Implement me!
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+Vector CCheckUVCmd::Barycentric( const Vector2D &vP, const Vector2D &vA, const Vector2D &vB, const Vector2D &vC )
+{
+	const Vector2D v0 = vB - vA;
+	const Vector2D v1 = vC - vA;
+	const Vector2D v2 = vP - vA;
+
+	const float d00 = DotProduct2D( v0, v0 );
+	const float d01 = DotProduct2D( v0, v1 );
+	const float d11 = DotProduct2D( v1, v1 );
+	const float d20 = DotProduct2D( v2, v0 );
+	const float d21 = DotProduct2D( v2, v1 );
+
+	const float flDenom = d00 * d11 - d01 * d01;
+
+	const float flV = ( d11 * d20 - d01 * d21 ) / flDenom;
+	const float flW = ( d00 * d21 - d01 * d20 ) / flDenom;
+	const float flU = 1.0f - flV - flW;
+
+	return Vector( flV, flW, flU );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+Vector CCheckUVCmd::Barycentric( const Vector &vP, const Vector &vA, const Vector &vB, const Vector &vC )
+{
+	const Vector v0 = vB - vA;
+	const Vector v1 = vC - vA;
+	const Vector v2 = vP - vA;
+
+	const float d00 = DotProduct( v0, v0 );
+	const float d01 = DotProduct( v0, v1 );
+	const float d11 = DotProduct( v1, v1 );
+	const float d20 = DotProduct( v2, v0 );
+	const float d21 = DotProduct( v2, v1 );
+
+	const float flDenom = d00 * d11 - d01 * d01;
+
+	const float flV = ( d11 * d20 - d01 * d21 ) / flDenom;
+	const float flW = ( d00 * d21 - d01 * d20 ) / flDenom;
+	const float flU = 1.0f - flV - flW;
+
+	return Vector( flV, flW, flU );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+int CCheckUVCmd::FindMeshIndex( const struct s_source_t *pSource, int nFaceIndex )
+{
+	for ( int i = 1; i < pSource->nummeshes; ++i )
+	{
+		if ( nFaceIndex <= pSource->mesh[i].faceoffset )
+			return i;
+	}
+
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+void CCheckUVCmd::PrintVertex( const s_vertexinfo_t &v, const char *pszPrefix /* = "       " */ )
+{
+	Msg( "%sP: %8.4f %8.4f %8.4f T: %8.4f %8.4f\n",
+		pszPrefix,
+		v.position.x, v.position.y, v.position.z,
+		v.texcoord.x, v.texcoord.y );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+void CCheckUVCmd::PrintVertex( const s_vertexinfo_t &v, const s_texture_t &t, const char *pszPrefix /* = "       " */ )
+{
+	Msg( "%sP: %8.4f %8.4f %8.4f T: %8.4f %8.4f M: %s\n",
+		pszPrefix,
+		v.position.x, v.position.y, v.position.z,
+		v.texcoord.x, v.texcoord.y,
+		t.name );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+void CCheckUVCmd::PrintFace( const s_source_t *pSource, const int nMesh, const int nFace, const char *pszPrefix /* = "       " */ )
+{
+	const s_texture_t &t = g_texture[pSource->meshindex[nMesh]];
+	const s_face_t &f = pSource->face[nFace];
+
+	Msg( "%sF: %4d %s\n", pszPrefix, nFace, t.name );
+
+	PrintVertex( pSource->vertex[f.a], pszPrefix );
+	PrintVertex( pSource->vertex[f.b], pszPrefix );
+	PrintVertex( pSource->vertex[f.c], pszPrefix );
+}
\ No newline at end of file
diff --git a/utils/studiomdl/checkuv.h b/utils/studiomdl/checkuv.h
new file mode 100644
index 0000000..a5ee976
--- /dev/null
+++ b/utils/studiomdl/checkuv.h
@@ -0,0 +1,59 @@
+//============ Copyright (c) Valve Corporation, All rights reserved. ==========
+//
+//=============================================================================
+
+
+#pragma once
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+class CCheckUVCmd
+{
+public:
+	int m_nOptGutterTexWidth;	// Width of texture for gutter check
+	int m_nOptGutterTexHeight;	// Height of texture for gutter check
+	int m_nOptGutterMin;		// Minimum number of pixels between polygon islands in UV space
+
+	enum CheckMask_t
+	{
+		CHECK_UV_FLAG_NORMALIZED =	( 1 << 0 ),
+		CHECK_UV_FLAG_OVERLAP =		( 1 << 1 ),
+		CHECK_UV_FLAG_INVERSE =		( 1 << 2 ),
+		CHECK_UV_FLAG_GUTTER =		( 1 << 3 ),
+		CHECK_UV_ALL_FLAGS = ( CHECK_UV_FLAG_NORMALIZED | CHECK_UV_FLAG_OVERLAP | CHECK_UV_FLAG_INVERSE | CHECK_UV_FLAG_GUTTER )
+	};
+
+	int m_nOptChecks;
+
+	CCheckUVCmd();
+
+	void Clear();
+
+	bool DoCheck( CheckMask_t eCheckMask ) const	{ return ( m_nOptChecks & eCheckMask ) == eCheckMask; }
+	bool DoAnyCheck() const							{ return ( m_nOptChecks & CHECK_UV_ALL_FLAGS ) != 0; }
+	void SetCheck( CheckMask_t eCheckMask )			{ m_nOptChecks |= ( CHECK_UV_ALL_FLAGS & eCheckMask ); }
+	void ClearCheck( CheckMask_t eCheckMask )		{ m_nOptChecks &= ( CHECK_UV_ALL_FLAGS & ~eCheckMask ); }
+
+	bool CheckUVs( const struct s_source_t *const *pSourceList, int nSourceCount ) const;
+
+	// Check that all UVs are in the [0, 1] range
+	bool CheckNormalized( const struct s_source_t *pSource ) const;
+	// Check that all polygons in UV do not overlap
+	bool CheckOverlap( const struct s_source_t *pSource ) const;
+	// Check that all polygons in UV have the correct winding, i.e. the cross
+	// product of edge AB x BC points the right direction
+	bool CheckInverse( const struct s_source_t *pSource ) const;
+	// Check that the distance between edges in UV islands is a minimum number of pixels for a given texture size
+	bool CheckGutter( const struct s_source_t *pSource ) const;
+
+	// Returns barycentric coordinates Vector( u, v, w ) for point vP with respect to triangle ( vA, vB, vC )
+	static Vector Barycentric( const Vector2D &vP, const Vector2D &vA, const Vector2D &vB, const Vector2D &vC );
+	static Vector Barycentric( const Vector &vP, const Vector &vA, const Vector &vB, const Vector &vC );
+
+	static int FindMeshIndex( const struct s_source_t *pSource, int nFaceIndex );
+	static void PrintVertex( const struct s_vertexinfo_t &v, const char *pszPrefix = "       " );
+	static void PrintVertex( const struct s_vertexinfo_t &v, const struct s_texture_t &t, const char *pszPrefix = "       " );
+	static void PrintFace( const s_source_t *pSource, const int nMesh, const int nFace, const char *pszPrefix = "       " );
+};
\ No newline at end of file
diff --git a/utils/studiomdl/collisionmodel.cpp b/utils/studiomdl/collisionmodel.cpp
new file mode 100644
index 0000000..2a6e7e3
--- /dev/null
+++ b/utils/studiomdl/collisionmodel.cpp
@@ -0,0 +1,2724 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Builds physics collision models from studio model source
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================//
+
+// NOTE: The term joint here is used to mean a bone, collision model, and a joint.
+// Each "joint" is the collision geometry at a named bone (or set of bones that have been merged)
+// and the joint (with constraints) between that set and its parent.  The root "joint" has
+// no constraints.
+// I chose to refer to them as joints to avoid confusion.  Yes they encompass bones and joints,
+// but they use the same names, and the data is actually linked.
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+
+#include "vphysics/constraints.h"
+#include "collisionmodel.h"
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+#include "physdll.h"
+#include "phyfile.h"
+#include "utlvector.h"
+#include "vcollide_parse.h"
+#include "tier1/strtools.h"
+#include "tier2/tier2.h"
+#include "KeyValues.h"
+
+#include "tier1/smartptr.h"
+#include "tier2/p4helpers.h"
+
+
+// these functions just wrap atoi/atof and check for NULL
+static float Safe_atof( const char *pString );
+static int Safe_atoi( const char *pString );
+
+IPhysicsCollision *physcollision = NULL;
+IPhysicsSurfaceProps *physprops = NULL;
+
+float g_WeldVertEpsilon = 0.0f;
+float g_WeldNormalEpsilon = 0.999f;
+
+//-----------------------------------------------------------------------------
+// Purpose: Contains a single convex element of a physical collision system
+//-----------------------------------------------------------------------------
+class CPhysCollisionModel
+{
+public:
+	CPhysCollisionModel( void )
+	{
+		memset( this, 0, sizeof(*this) );
+	}
+
+	const char	*m_parent;
+	const char	*m_name;
+
+	// physical properties stored on disk
+	float		m_mass;
+	float		m_volume;
+	float		m_surfaceArea;
+	float		m_damping;
+	float		m_rotdamping;
+	float		m_inertia;
+	float		m_dragCoefficient;
+
+	// these tune the model building process, they don't go in the file
+	float		m_massBias;
+
+	CPhysCollide	*m_pCollisionData;
+	CPhysCollisionModel	*m_pNext;
+};
+
+enum jointlimit_t
+{
+	JOINT_FREE = 0,
+	JOINT_FIXED = 1,
+	JOINT_LIMIT = 2,
+};
+
+// list of vertex indices that form a convex element
+struct convexlist_t
+{
+	int	firstVertIndex;
+	int numVertIndex;
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: element of a list of constraints for a jointed model
+//-----------------------------------------------------------------------------
+class CJointConstraint
+{
+public:
+	CJointConstraint( void )
+	{
+		m_pJointName = NULL;
+	}
+
+	CJointConstraint( const char *pName, int axis, jointlimit_t type, float min, float max, float friction )
+		: m_axis(axis), m_jointType(type), m_limitMin(min), m_limitMax(max), m_friction(friction)
+	{
+		m_pJointName = pName;
+	}
+
+	const char		*m_pJointName;
+	int				m_axis;
+	jointlimit_t	m_jointType;
+	float			m_limitMin;
+	float			m_limitMax;
+	float			m_friction;
+
+	CJointConstraint *m_pNext;
+};
+
+struct mergelist_t
+{
+	char		*pParent;
+	char		*pChild;
+};
+
+struct collisionpair_t
+{
+	int obj0;
+	int obj1;
+	const char *pName0;
+	const char *pName1;
+	collisionpair_t *pNext;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Search a source for a bone with a specified name
+// Input  : *pSource - 
+//			*pName - 
+// Output : int boneIndex, -1 if none
+//-----------------------------------------------------------------------------
+int FindLocalBoneNamed( const s_source_t *pSource, const char *pName )
+{
+	if ( pName )
+	{
+		int i;
+		for ( i = 0; i < pSource->numbones; i++ )
+		{
+			if ( !stricmp( pName, pSource->localBone[i].name ) )
+				return i;
+		}
+
+		pName = RenameBone( pName );
+
+		for ( i = 0; i < pSource->numbones; i++ )
+		{
+			if ( !stricmp( pName, pSource->localBone[i].name ) )
+				return i;
+		}
+	}
+
+	return -1;
+}
+
+
+// Returns the index to pName in g_bonetable
+int FindBoneInTable( const char *pName )
+{
+	return findGlobalBone( pName );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Contains a complete physical joint system with constraint relationships
+//-----------------------------------------------------------------------------
+// This class is really just a namespace for a set of globals...
+class CJointedModel
+{
+public:
+	s_source_t				*m_pModel;
+	int						m_collisionCount;
+	CPhysCollisionModel		*m_pCollisionList;
+	collisionpair_t			*m_pCollisionPairs;
+	float					m_totalMass;
+	int						m_bonemap[MAXSTUDIOSRCBONES];
+	CJointConstraint		*m_pConstraintList;
+	int						m_constraintCount;
+	int						m_totalVerts;
+	int						m_maxConvex;
+	char					m_rootName[128];
+	bool					m_allowConcave;
+	bool					m_allowConcaveJoints;
+	bool					m_isMassCenterForced;
+	bool					m_noSelfCollisions;
+	bool					m_remove2d;
+	Vector					m_massCenterForced;
+
+	float					m_defaultDamping;
+	float					m_defaultRotdamping;
+	float					m_defaultInertia;
+	float					m_defaultDrag;
+	CUtlVector<char>		m_textCommands;
+	CUtlVector<mergelist_t> m_mergeList;
+
+	CJointedModel( void );
+
+	void SetSource( s_source_t *pmodel );
+
+	void InitBoneMap( void );
+	void SkipBone( int boneIndex );
+	void MergeBones( int parent, int child );
+	void AddMergeCommand( char const *pParent, char const *pChild );
+	bool ShouldProcessBone( int boneIndex );
+	int BoneIndex( const char *pName );
+	int	RemapBone( int boneIndex ) const;
+	void AppendCollisionModel( CPhysCollisionModel *pCollide );
+	void UnlinkCollisionModel( CPhysCollisionModel *pCollide );
+	CPhysCollisionModel *GetCollisionModel( const char *pName );
+	void AppendCollisionPair( const char *pName0, const char *pName1 );
+	void AddConstraint( const char *pJointName, int axis, jointlimit_t jointType, float limitMin, float limitMax, float friction );
+	int CollisionIndex( const char *pName );
+	void SortCollisionList( void );
+	void ForceMassCenter( const Vector &centerOfMass );
+	void AllowConcave( void ) { m_allowConcave = true; }
+	void AllowConcaveJoints() { m_allowConcaveJoints = true; }
+	void Remove2DConvex() { m_remove2d = true; }
+	void SetMaxConvex( int newMax ) { m_maxConvex = newMax; }
+	void Simplify();
+	void DefaultDamping( float damping );
+	void DefaultRotdamping( float rotdamping );
+	void DefaultInertia( float inertia );
+	void DefaultDrag( float drag );
+	void SetTotalMass( float mass );
+	void SetAutoMass( void );
+	void SetNoSelfCollisions();
+	void SetCollisionModelDefaults( CPhysCollisionModel *pModel );
+
+	void JointDamping( const char *pJointName, float damping );
+	void JointRotdamping( const char *pJointName, float rotdamping );
+	void JointInertia( const char *pJointName, float inertia );
+	void JointMassBias( const char *pJointName, float massBias );
+
+	void AddText( const char *pText )
+	{
+		int len = strlen(pText);
+		int count = m_textCommands.Size();
+		m_textCommands.AddMultipleToTail( len );
+		memcpy( m_textCommands.Base() + count, pText, len );
+	}
+	void ComputeMass( void );
+
+	float					m_flFrictionTimeIn;
+	float					m_flFrictionTimeOut;
+	float					m_flFrictionTimeHold;
+	int						m_iMinAnimatedFriction;
+	int						m_iMaxAnimatedFriction;
+	bool					m_bHasAnimatedFriction;
+
+	bool					m_bAssumeWorldspace; // assume the model is already declared in worldspace, regardless of bone names
+};
+
+
+CJointedModel g_JointedModel;
+bool g_bJointed = false;
+
+CJointedModel::CJointedModel( void )
+{
+	m_pModel = NULL;
+
+	m_collisionCount = 0;
+	m_pCollisionList = NULL;
+	m_pCollisionPairs = NULL;
+	m_totalMass = 1.0;
+
+	memset( m_bonemap, 0, sizeof(m_bonemap) );
+	m_pConstraintList = NULL;
+	m_constraintCount = 0;
+	
+	m_totalVerts = 0;
+
+	// UNDONE: Move these defaults elsewhere?  They are all overrideable by the QC/script
+	m_defaultDamping = 0;
+	m_defaultRotdamping = 0;
+	m_defaultInertia = 1.0;
+	m_defaultDrag = -1;
+	m_allowConcave = false;
+	m_allowConcaveJoints = false;
+	m_remove2d = false;
+	m_maxConvex = 40;
+	m_isMassCenterForced = false;
+	m_noSelfCollisions = false;
+	m_massCenterForced.Init();
+
+	m_flFrictionTimeIn = 0.0f;
+	m_flFrictionTimeOut = 0.0f;
+	m_iMinAnimatedFriction = 1.0f;
+	m_iMaxAnimatedFriction = 1.0f;
+	m_bHasAnimatedFriction = false;
+}
+
+
+
+void CJointedModel::SetSource( s_source_t *pmodel )
+{
+	m_pModel = pmodel;
+	InitBoneMap();
+	m_totalVerts = pmodel->numvertices;
+}
+
+void CJointedModel::InitBoneMap( void )
+{
+	for ( int i = 0; i < m_pModel->numbones; i++ )
+	{
+		m_bonemap[i] = i;
+	}
+}
+
+void CJointedModel::SkipBone( int boneIndex )
+{
+	if ( boneIndex >= 0 )
+		m_bonemap[boneIndex] = -1;
+}
+
+void CJointedModel::AddMergeCommand( char const *pParent, char const *pChild )
+{
+	int i = m_mergeList.AddToTail();
+	m_mergeList[i].pParent = strdup(pParent);
+	m_mergeList[i].pChild = strdup(pChild);
+}
+
+void CJointedModel::MergeBones( int parent, int child )
+{
+	if ( parent < 0 || child < 0 )
+		return;
+
+	int map = parent;
+	int safety = 0;
+	while ( m_bonemap[map] != map )
+	{
+		map = m_bonemap[map];
+		safety++;
+		// infinite loop?
+		if ( safety > m_pModel->numbones )
+			break;
+
+		if ( map < 0 )
+			break;
+	}
+
+	m_bonemap[child] = map;
+}
+
+
+bool CJointedModel::ShouldProcessBone( int boneIndex )
+{
+	if ( boneIndex >= 0 )
+	{
+		if ( m_bonemap[boneIndex] == boneIndex )
+			return true;
+	}
+	return false;
+}
+
+int CJointedModel::BoneIndex( const char *pName )
+{
+	pName = RenameBone( pName );
+	for ( int boneIndex = 0; boneIndex < m_pModel->numbones; boneIndex++ )
+	{
+		if ( !stricmp( m_pModel->localBone[boneIndex].name, pName ) )
+			return boneIndex;
+	}
+
+	return -1;
+}
+
+int	CJointedModel::RemapBone( int boneIndex ) const
+{
+	if ( boneIndex >= 0 )
+		return m_bonemap[boneIndex];
+	return boneIndex;
+}
+
+void CJointedModel::AppendCollisionModel( CPhysCollisionModel *pCollide )
+{
+	if ( m_isMassCenterForced )
+	{
+		physcollision->CollideSetMassCenter( pCollide->m_pCollisionData, m_massCenterForced );
+	}
+
+	pCollide->m_pNext = m_pCollisionList;
+	m_pCollisionList = pCollide;
+	m_collisionCount++;
+}
+
+
+void CJointedModel::UnlinkCollisionModel( CPhysCollisionModel *pCollide )
+{
+	CPhysCollisionModel **pList = &m_pCollisionList;
+
+	if ( !pCollide )
+		return;
+
+	while ( *pList )
+	{
+		CPhysCollisionModel *pNode = *pList;
+		if ( pNode == pCollide )
+		{
+			*pList = pCollide->m_pNext;
+			m_collisionCount--;
+			pCollide->m_pNext = NULL;
+			return;
+		}
+		pList = &pNode->m_pNext;
+	}
+}
+
+int CJointedModel::CollisionIndex( const char *pName )
+{
+	CPhysCollisionModel *pList = m_pCollisionList;
+	int index = 0;
+	while ( pList )
+	{
+		if ( !stricmp( pName, pList->m_name ) )
+			return index;
+		
+		pList = pList->m_pNext;
+		index++;
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sort the list so that parents come before their children
+//-----------------------------------------------------------------------------
+void CJointedModel::SortCollisionList( void )
+{
+	if ( !m_collisionCount )
+		return;
+
+	CPhysCollisionModel **pArray;
+	pArray = new CPhysCollisionModel *[m_collisionCount];
+	CPhysCollisionModel *pList = m_pCollisionList;
+	
+	// make an array to make sorting easier
+	int i = 0;
+
+	while ( pList )
+	{
+		pArray[i++] = pList;
+		pList = pList->m_pNext;
+	}
+
+	// really stupid bubble sort!
+	// this is really inefficient but it was easy to code and there are never
+	// more than maxConvex elements.
+	bool swapped = true;
+
+	while ( swapped )
+	{
+		swapped = false;
+		// loop over all solids and swap any parent/child pairs that are out of order
+		for ( i = 0; i < m_collisionCount; i++ )
+		{
+			CPhysCollisionModel *pPhys = pArray[i];
+			if ( !pPhys->m_parent )
+				continue;
+
+			// Don't try to move ones where the pPhys and its parent have the same name
+			// otherwise an infinite loop results
+			if ( !Q_stricmp( pPhys->m_name, pPhys->m_parent ) )
+				continue;
+
+			// find the parent
+			int j;
+			for ( j = 0; j < m_collisionCount; j++ )
+			{
+				if ( j == i )
+					continue;
+
+				if ( !stricmp( pPhys->m_parent, pArray[j]->m_name ) )
+					break;
+			}
+
+			// if the child came before the parent, then swap the parent and child positions
+			if ( j > i && j < m_collisionCount )
+			{
+				swapped = true;
+				pArray[i] = pArray[j];
+				pArray[j] = pPhys;
+			}
+		}
+	}
+
+	// link up the sorted list
+	for ( i = 0; i < m_collisionCount-1; i++ )
+	{
+		pArray[i]->m_pNext = pArray[i+1];
+	}
+	// terminate
+	pArray[i]->m_pNext = NULL;
+	// point the list to first joint
+	m_pCollisionList = pArray[0];
+
+	// delete the working array
+	delete[] pArray;
+}
+
+void CJointedModel::AppendCollisionPair( const char *pName0, const char *pName1 )
+{
+	collisionpair_t *pPair = new collisionpair_t;
+	pPair->obj0 = -1;
+	pPair->obj1 = -1;
+	int jointIndex0 = FindLocalBoneNamed( m_pModel, pName0 );
+	pPair->pName0 = (jointIndex0 >= 0) ? m_pModel->localBone[jointIndex0].name : NULL;
+	int jointIndex1 = FindLocalBoneNamed( m_pModel, pName1 );
+	pPair->pName1 = (jointIndex1 >= 0) ? m_pModel->localBone[jointIndex1].name : NULL;
+
+	pPair->pNext = m_pCollisionPairs;
+	m_pCollisionPairs = pPair;
+}
+
+void CJointedModel::ForceMassCenter( const Vector &centerOfMass )
+{
+	m_isMassCenterForced = true;
+	m_massCenterForced = centerOfMass;
+}
+
+// called before processing, after the model has been simplified.
+// Update internal state due to simplification
+void CJointedModel::Simplify()
+{
+	for ( int i = 0; i < m_pModel->numbones; i++ )
+	{
+		if ( m_pModel->boneLocalToGlobal[i] < 0 )
+		{
+			SkipBone(i);
+		}
+	}
+
+	extern int g_rootIndex;
+	const char *pAnimationRootBone = g_bonetable[g_rootIndex].name;
+
+	// merge this root bone with the root of animation
+	MergeBones( FindLocalBoneNamed( m_pModel, pAnimationRootBone ), FindLocalBoneNamed( m_pModel, m_rootName ) );
+
+}
+
+
+CPhysCollisionModel *CJointedModel::GetCollisionModel( const char *pName )
+{
+	CPhysCollisionModel *pList = m_pCollisionList;
+	while ( pList )
+	{
+		if ( !stricmp( pName, pList->m_name ) )
+			return pList;
+		
+		pList = pList->m_pNext;
+	}
+
+	return NULL;
+}
+
+void CJointedModel::AddConstraint( const char *pJointName, int axis, jointlimit_t jointType, float limitMin, float limitMax, float friction )
+{
+	// In the editor/qc friction values are shown as 5X so 1.0 can be the default.
+	CJointConstraint *pConstraint = new CJointConstraint( pJointName, axis, jointType, limitMin, limitMax, friction * (1.0f/5.0f) );
+
+	// link it in
+	pConstraint->m_pNext = m_pConstraintList;
+	m_pConstraintList = pConstraint;
+	m_constraintCount++;
+}
+
+void CJointedModel::DefaultDamping( float damping )
+{
+	m_defaultDamping = damping;
+}
+
+void CJointedModel::DefaultRotdamping( float rotdamping )
+{
+	m_defaultRotdamping = rotdamping;
+}
+
+void CJointedModel::DefaultInertia( float inertia )
+{
+	m_defaultInertia = inertia;
+}
+
+void CJointedModel::SetTotalMass( float mass )
+{
+	m_totalMass = mass;
+}
+
+void CJointedModel::SetAutoMass( void )
+{
+	m_totalMass = -1;
+}
+
+void CJointedModel::SetNoSelfCollisions()
+{
+	m_noSelfCollisions = true;
+}
+
+void CJointedModel::SetCollisionModelDefaults( CPhysCollisionModel *pModel )
+{
+	pModel->m_damping = m_defaultDamping;
+	pModel->m_inertia = m_defaultInertia;
+	pModel->m_rotdamping = m_defaultRotdamping;
+	pModel->m_massBias = 1.0;
+	
+	// not written unless modified
+	pModel->m_dragCoefficient = m_defaultDrag;
+}
+
+
+
+void CJointedModel::ComputeMass( void )
+{
+	// already set
+	if ( m_totalMass >= 0 )
+		return;
+
+	CPhysCollisionModel *pList = m_pCollisionList;
+	m_totalMass = 0;
+
+	while ( pList )
+	{
+		char* pSurfaceProps = GetSurfaceProp( pList->m_name );
+		int index = physprops->GetSurfaceIndex( pSurfaceProps );
+		float density, thickness;
+		physprops->GetPhysicsProperties( index, &density, &thickness, NULL, NULL );
+
+		if ( thickness > 0 )
+		{
+			m_totalMass += pList->m_surfaceArea * thickness * CUBIC_METERS_PER_CUBIC_INCH * density;
+		}
+		else
+		{
+			// density is in kg/m^3, volume is in in^3
+			m_totalMass += pList->m_volume * CUBIC_METERS_PER_CUBIC_INCH * density;
+		}
+		pList = pList->m_pNext;
+	}
+
+	if( !g_quiet )
+	{
+		printf("Computed Mass: %.2f kg\n", m_totalMass );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates a collision object using the defaults in joints
+// Input  : &joints - joint system to create the model in
+//			*pJointName - name to give this model
+// Output : static CPhysCollisionModel
+//-----------------------------------------------------------------------------
+static CPhysCollisionModel *InitCollisionModel( CJointedModel &joints, const char *pJointName )
+{
+	CPhysCollisionModel *pModel = joints.GetCollisionModel( pJointName );
+	if ( !pModel )
+	{
+		int boneIndex = joints.BoneIndex( pJointName );
+		if ( boneIndex < 0 )
+			return NULL;
+
+		pModel = new CPhysCollisionModel;
+		// this name is the same as pJointName, but guaranteed to be non-volatile (we'd have to copy pJointName)
+		pModel->m_name = joints.m_pModel->localBone[boneIndex].name;
+		if ( joints.m_pModel->localBone[boneIndex].parent >= 0 )
+		{
+			pModel->m_parent = joints.m_pModel->localBone[joints.m_pModel->localBone[boneIndex].parent].name;
+		}
+		else
+		{
+			pModel->m_parent = NULL;
+		}
+
+		joints.SetCollisionModelDefaults( pModel );
+		joints.AppendCollisionModel( pModel );
+	}
+
+	return pModel;
+}
+
+void CJointedModel::JointDamping( const char *pJointName, float damping )
+{
+	CPhysCollisionModel *pModel = InitCollisionModel( *this, pJointName );
+	if ( pModel )
+	{
+		pModel->m_damping = damping;
+	}
+}
+
+void CJointedModel::JointRotdamping( const char *pJointName, float rotdamping )
+{
+	CPhysCollisionModel *pModel = InitCollisionModel( *this, pJointName );
+	if ( pModel )
+	{
+		pModel->m_rotdamping = rotdamping;
+	}
+}
+
+void CJointedModel::JointMassBias( const char *pJointName, float massBias )
+{
+	CPhysCollisionModel *pModel = InitCollisionModel( *this, pJointName );
+	if ( pModel )
+	{
+		pModel->m_massBias = massBias;
+	}
+}
+
+void CJointedModel::JointInertia( const char *pJointName, float inertia )
+{
+	CPhysCollisionModel *pModel = InitCollisionModel( *this, pJointName );
+	if ( pModel )
+	{
+		pModel->m_inertia = inertia;
+	}
+}
+
+
+void CJointedModel::DefaultDrag( float drag )
+{
+	m_defaultDrag = drag;
+}
+
+// ----------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Transforms the source's verts into "world" space
+// Input  : *psource - 
+//			*worldVerts - 
+//-----------------------------------------------------------------------------
+void ConvertToWorldSpace( CJointedModel &joints, s_source_t *psource, CUtlVector<Vector> &worldVerts )
+{
+	int i, n;
+
+	if (!joints.m_bAssumeWorldspace)
+	{
+		matrix3x4_t boneToWorld[MAXSTUDIOSRCBONES];	// bone transformation matrix
+		CalcBoneTransforms( g_panimation[0], 0, boneToWorld );
+
+		for (i = 0; i < psource->numvertices; i++)
+		{
+			Vector tmp,tmp2;
+			worldVerts[i].Init( 0, 0, 0 );
+
+			int nBoneCount = psource->vertex[i].boneweight.numbones;
+			for (n = 0; n < nBoneCount; n++)
+			{
+				// convert to Half-Life world space
+				// convert vertex into original models' bone local space
+				int localBone = psource->vertex[i].boneweight.bone[n];
+				int globalBone = psource->boneLocalToGlobal[localBone];
+				Assert( localBone >= 0 );
+				Assert( globalBone >= 0 );
+
+				matrix3x4_t boneToPose;
+				ConcatTransforms( psource->boneToPose[localBone], g_bonetable[globalBone].srcRealign, boneToPose );
+				VectorITransform( psource->vertex[i].position, boneToPose, tmp2 );
+
+				// now transform to that bone's world-space position in this animation
+				VectorTransform(tmp2, boneToWorld[globalBone], tmp );
+				VectorMA( worldVerts[i], psource->vertex[i].boneweight.weight[n], tmp, worldVerts[i] );
+			}
+		}
+	}
+	else
+	{
+		matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];	// bone transformation matrix
+		BuildRawTransforms( psource, "BindPose", 0, psource->scale, psource->adjust, psource->rotation, 0, srcBoneToWorld );
+
+		for (i = 0; i < psource->numvertices; i++)
+		{
+			Vector tmp;
+			worldVerts[i].Init( 0, 0, 0 );
+
+			int nBoneCount = psource->vertex[i].boneweight.numbones;
+			for (n = 0; n < nBoneCount; n++)
+			{
+				int localBone = psource->vertex[i].boneweight.bone[n];
+				Assert( localBone >= 0 );
+
+				// convert vertex into world space
+				VectorTransform( psource->vertex[i].position, srcBoneToWorld[localBone], tmp );
+				// just assume the model is in identity space 
+				// FIXME: shouldn't this do an inverse xform of the default boneToWorld?
+
+				VectorMA( worldVerts[i], psource->vertex[i].boneweight.weight[n], tmp, worldVerts[i] );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Transforms the set of verts into the space of a particular bone
+// Input  : *psource - 
+//			boneIndex - 
+//			*boneVerts - 
+//-----------------------------------------------------------------------------
+void ConvertToBoneSpace( s_source_t *psource, int boneIndex, CUtlVector<Vector> &boneVerts )
+{
+	int i;
+
+	int remapIndex = psource->boneLocalToGlobal[boneIndex];
+	matrix3x4_t boneToPose;
+	if ( remapIndex < 0 )
+	{
+		MdlWarning("Error! physics for unused bone %s\n", psource->localBone[boneIndex].name );
+		MatrixCopy( psource->boneToPose[boneIndex], boneToPose );
+	}
+	else
+	{
+		ConcatTransforms( psource->boneToPose[boneIndex], g_bonetable[remapIndex].srcRealign, boneToPose );
+	}
+
+	for (i = 0; i < psource->numvertices; i++)
+	{
+		VectorITransform(psource->vertex[i].position, boneToPose, boneVerts[i] );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Test this face to see if any of its verts are assigned to a particular bone
+// Input  : &joints - 
+//			*pmodel - 
+//			*face - 
+//			boneIndex - 
+// Output : Returns true if this face has a vert assigned to boneIndex
+//-----------------------------------------------------------------------------
+bool FaceHasVertOnBone( const CJointedModel &joints, s_source_t *pSource, s_face_t *face, int boneIndex )
+{
+	if ( boneIndex < 0 )
+		return true;
+
+	int j;
+	s_boneweight_t *pweight;
+	pweight = &pSource->vertex[ face->a ].boneweight;
+	for ( j = 0; j < pweight->numbones; j++ )
+	{
+		// assigned to boneIndex?
+		if ( joints.RemapBone( pweight->bone[j] ) == boneIndex )
+			return true;
+	}
+
+	pweight = &pSource->vertex[ face->b ].boneweight;
+	for ( j = 0; j < pweight->numbones; j++ )
+	{
+		// assigned to boneIndex?
+		if ( joints.RemapBone( pweight->bone[j] ) == boneIndex )
+			return true;
+	}
+
+	pweight = &pSource->vertex[ face->c ].boneweight;
+	for ( j = 0; j < pweight->numbones; j++ )
+	{
+		// assigned to boneIndex?
+		if ( joints.RemapBone( pweight->bone[j] ) == boneIndex )
+			return true;
+	}
+
+	return false;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixup the pointers in this face to reference the mesh globally (source relative)
+//			(faces are mesh relative, each source has several meshes)
+// Input  : *pout - 
+//			*pmesh - 
+//			*pin - 
+//-----------------------------------------------------------------------------
+void GlobalFace( s_face_t *pout, s_mesh_t *pmesh, s_face_t *pin )
+{
+	pout->a = pmesh->vertexoffset + pin->a;
+	pout->b = pmesh->vertexoffset + pin->b;
+	pout->c = pmesh->vertexoffset + pin->c;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy all verts assigned to this bone.
+//			NOTE: Leaves gaps in the model around joints
+// Input  : **verts - 
+//			*worldVerts - 
+//			&joints - 
+//			boneIndex - 
+// Output : int vertCount
+//-----------------------------------------------------------------------------
+int CopyVertsByBone( Vector **verts, Vector *worldVerts, const CJointedModel &joints, int boneIndex )
+{
+	int vertCount = 0;
+	s_source_t *pmodel = joints.m_pModel;
+
+	// loop through each vert to find those assigned to this bone
+	for ( int i = 0; i < pmodel->numvertices; i++ )
+	{
+		s_boneweight_t *pweight = &pmodel->vertex[ i ].boneweight;
+
+		// look at each assignment for this vert
+		for ( int j = 0; j < pweight->numbones; j++ )
+		{
+			// Discover the local bone index for this bone
+			int localBone = pweight->bone[j];
+
+			// assigned to boneIndex?
+			if ( joints.RemapBone( localBone ) == boneIndex )
+			{
+				// add this vert to model
+				verts[vertCount++] = &worldVerts[i];
+			}
+		}
+	}
+
+	return vertCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy all verts that are referenced by a face which has a vert assigned
+//			to this bone.
+//			NOTE: convex hulls of each bone will overlap at the joints
+// Input  : **verts - 
+//			*worldVerts - 
+//			&joints - 
+//			boneIndex - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CopyFaceVertsByBone( Vector **verts, Vector *worldVerts, const CJointedModel &joints, int boneIndex )
+{
+	int vertCount = 0;
+	s_source_t *pmodel = joints.m_pModel;
+
+	int *vertChecked = new int[pmodel->numvertices];
+	for ( int b = 0; b < pmodel->numvertices; b++ )
+	{
+		vertChecked[b] = 0;
+	}
+
+	for ( int i = 0; i < pmodel->nummeshes; i++ )
+	{
+		s_mesh_t *pmesh = pmodel->mesh + pmodel->meshindex[i];
+		for ( int j = 0; j < pmesh->numfaces; j++ )
+		{
+			s_face_t *face = pmodel->face + pmesh->faceoffset + j;
+			s_face_t globalFace;
+			GlobalFace( &globalFace, pmesh, face );
+			if ( FaceHasVertOnBone( joints, pmodel, &globalFace, boneIndex ) )
+			{
+				if ( !vertChecked[globalFace.a] )
+				{
+					// add this vert to model
+					verts[vertCount++] = &worldVerts[globalFace.a];
+				}
+				if ( !vertChecked[globalFace.b] )
+				{
+					// add this vert to model
+					verts[vertCount++] = &worldVerts[globalFace.b];
+				}
+				if ( !vertChecked[globalFace.c] )
+				{
+					// add this vert to model
+					verts[vertCount++] = &worldVerts[globalFace.c];
+				}
+				// mark these verts so you only add them once
+				vertChecked[globalFace.a] = 1;
+				vertChecked[globalFace.b] = 1;
+				vertChecked[globalFace.c] = 1;
+			}
+		}
+	}
+
+	delete[] vertChecked;
+	return vertCount;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Find all verts that differ only by texture coordinates - this allows
+//			us to ignore texture coordinates on collision models
+// Input  : *weldTable - output table
+//			*pmodel - input model
+//-----------------------------------------------------------------------------
+void BuildVertWeldTable( int *weldTable, s_source_t *pmodel )
+{
+	for ( int i = 0; i < pmodel->numvertices; i++ )
+	{
+		bool found = false;
+		for ( int j = 0; j < i; j++ )
+		{
+			float dist = (pmodel->vertex[j].position - pmodel->vertex[i].position).Length();
+			float normalDist = DotProduct( pmodel->vertex[j].normal, pmodel->vertex[i].normal );
+			if ( dist <= g_WeldVertEpsilon && normalDist > g_WeldNormalEpsilon )
+			{
+				found = true;
+				weldTable[i] = j;
+				break;
+			}
+		}
+
+		if ( !found )
+		{
+			weldTable[i] = i;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: marks all verts with a unique ID.  Each set of connected verts has
+//			the same ID.  IDs are the index of the lowest numbered face on the 
+//			mesh
+// Input  : *vertID - array that holds IDs
+//			*pmodel - model to process
+//-----------------------------------------------------------------------------
+void MarkConnectedMeshes( int *vertID, s_source_t *pmodel, int *vertMap )
+{
+	int i;
+
+	// mark all verts as max faceid + 1
+	for ( i = 0; i < pmodel->numvertices; i++ )
+	{
+		// If these verts have been welded to a lower-index vert, mark them
+		// as already processed to avoid making additional convex objects out of them.
+		if ( vertMap[i] != i )
+		{
+			vertID[i] = -1;
+		}
+		else
+		{
+			vertID[i] = pmodel->numfaces+1;
+		}
+	}
+
+	int marked = 0;
+	int faceid = 0;
+	// iterate the face list, minimizing the vertID at each vert
+	// until we have an iteration where no vertIDs are changed
+	do 
+	{
+		marked = 0;
+		faceid = 0;
+
+		for ( i = 0; i < pmodel->nummeshes; i++ )
+		{
+			s_mesh_t *pmesh = pmodel->mesh + pmodel->meshindex[i];
+			for ( int j = 0; j < pmesh->numfaces; j++ )
+			{
+				s_face_t *face = pmodel->face + pmesh->faceoffset + j;
+				s_face_t globalFace;
+				GlobalFace( &globalFace, pmesh, face );
+				// account for welding
+				globalFace.a = vertMap[globalFace.a];
+				globalFace.b = vertMap[globalFace.b];
+				globalFace.c = vertMap[globalFace.c];
+
+
+				// find min(faceid, vertID[a], vertID[b], vertID[c]);
+				int newid = min(faceid, vertID[globalFace.a]);
+				newid = min( newid, vertID[globalFace.b]);
+				newid = min( newid, vertID[globalFace.c]);
+				
+				// mark all verts with the minimum, count the number we had to mark
+				if ( vertID[globalFace.a] != newid )
+				{
+					vertID[globalFace.a] = newid;
+					marked++;
+				}
+				if ( vertID[globalFace.b] != newid )
+				{
+					vertID[globalFace.b] = newid;
+					marked++;
+				}
+				if ( vertID[globalFace.c] != newid )
+				{
+					vertID[globalFace.c] = newid;
+					marked++;
+				}
+				faceid++;
+			}
+		}
+	} while ( marked != 0 );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Finds a CPhysCollisionModel in a linked list of models.
+// Input  : *pHead - 
+//			*pName - 
+// Output : CPhysCollisionModel
+//-----------------------------------------------------------------------------
+CPhysCollisionModel *FindObjectInList( CPhysCollisionModel *pHead, const char *pName )
+{
+	while ( pHead )
+	{
+		if ( !stricmp( pName, pHead->m_name ) )
+			break;
+		pHead = pHead->m_pNext;
+	}
+
+	return pHead;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Fix all bones to reference the remapped/collapsed bone structure
+// Input  : *pSource - 
+//			*pList - 
+//-----------------------------------------------------------------------------
+void FixBoneList( int *boneMap, const s_source_t *pSource, CPhysCollisionModel *pList )
+{
+	if ( !g_bJointed )
+		return;
+
+	CPhysCollisionModel *pmodel = pList;
+	while ( pmodel )
+	{
+		int nodeIndex = FindLocalBoneNamed( pSource, pmodel->m_name );
+		if ( nodeIndex < 0 )
+		{
+			MdlWarning("Physics for unknown bone %s\n", pmodel->m_name );
+		}
+		else
+		{
+			int count = 0;
+			// remove simplified bones
+			while ( pSource->boneLocalToGlobal[nodeIndex] < 0 )
+			{
+				if ( count++ > MAXSTUDIOSRCBONES )
+					break;
+
+				// simplified out, move up to the parent
+				nodeIndex = pSource->localBone[nodeIndex].parent;
+			}
+
+			if ( nodeIndex >= 0 )
+			{
+				// bone collapse may have changed parent hierarchy, and the root name. 
+				// The vertices are converted to the new reference by ConvertToWorldSpace(), as well as RemapVerticesToGlobalBones()
+				pmodel->m_name = g_bonetable[  pSource->boneLocalToGlobal[nodeIndex] ].name;
+				pmodel->m_parent = NULL;
+				int parentIndex = pSource->localBone[nodeIndex].parent;
+				if ( parentIndex >= 0 && parentIndex != nodeIndex )
+				{
+					parentIndex = boneMap[parentIndex];
+					if (pSource->boneLocalToGlobal[parentIndex] < 0)
+					{
+						pmodel->m_parent = pSource->localBone[parentIndex].name;
+					}
+					else
+					{
+						pmodel->m_parent = g_bonetable[  pSource->boneLocalToGlobal[parentIndex] ].name;
+					}
+				}
+			}
+			else
+			{
+				MdlWarning("Physics for unknown bone %s\n", pmodel->m_name );
+			}
+		}
+
+		pmodel = pmodel->m_pNext;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Fixup all references to parents by walking up on models whose parents
+//			have no collision geometry.  Bones without geometry cannot be physically
+//			simulated, so they must be removed.
+//			NOTE: This is broken.  It won't work for tree structures with an empty parent
+//			(i.e. 2 children attached to a parent bone that has no physics geometry - thus empty)
+//			It will not convert that parent into a constraint between 2 children
+// Input  : *pList - 
+//			*pSource - 
+//			*pParentName - 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *FixParent( CPhysCollisionModel *pList, s_source_t *pSource, const char *pParentName )
+{
+	while ( pParentName )
+	{
+		if ( FindObjectInList( pList, pParentName ) )
+		{
+			return pParentName;
+		}
+		int nodeIndex = FindLocalBoneNamed( pSource, pParentName );
+		if ( nodeIndex < 0 )
+			return NULL;
+		int parentIndex = pSource->localBone[nodeIndex].parent;
+		if ( parentIndex < 0 )
+		{
+			break;
+		}
+
+		pParentName = pSource->localBone[parentIndex].name;
+	}
+
+	return NULL;
+}
+
+
+struct boundingvolume_t
+{
+	Vector	mins;
+	Vector	maxs;
+};
+
+
+void CreateCollide( CPhysCollisionModel *pBase, CPhysConvex **pElements, int elementCount, const boundingvolume_t &bv )
+{
+	int i;
+
+	if ( !pBase )
+		return;
+
+	// NOTE: Must do this before building collide
+	pBase->m_volume = 0;
+	pBase->m_surfaceArea = 0;
+	for ( i = 0; i < elementCount; i++ )
+	{
+		pBase->m_volume += physcollision->ConvexVolume( pElements[i] );
+		pBase->m_surfaceArea += physcollision->ConvexSurfaceArea( pElements[i] );
+	}
+
+	convertconvexparams_t params;
+	params.Defaults();
+	params.buildOuterConvexHull = true;
+	params.buildDragAxisAreas = true;
+	Vector size = bv.maxs - bv.mins;
+
+	int largest = 0;
+	float minSurfaceArea = -1.0f;
+	for ( i = 0; i < 3; i++ )
+	{
+		if ( size[i] > size[largest] )
+		{
+			largest = i;
+		}
+
+		int other = (i+1)%3;
+		int cross = (i+2)%3;
+		float surfaceArea = size[other] * size[cross];
+		if ( minSurfaceArea < 0 || surfaceArea < minSurfaceArea )
+		{
+			minSurfaceArea = surfaceArea;
+		}
+	}
+	// this can be really slow with super-large models and a low error tolerance
+	// Basically you get a ray cast through each square of epsilon surface area on each OBB side
+	// So compute it for 0.01% error (on the smallest side, less on larger sides)
+	params.dragAreaEpsilon = clamp( minSurfaceArea * 1e-4f, 0.25f, 128.0f );
+
+	Vector tmp = size;
+	tmp[largest] = 0;
+	float len = tmp.Length();
+	if ( len > 0 )
+	{
+		float sizeRatio = size[largest] / len;
+		// HACKHACK: Hardcoded size ratio to induce damping
+		// This prevents long skinny objects from rolling endlessly
+		if ( sizeRatio > 9 )
+		{
+			pBase->m_rotdamping = 1.0f;
+		}
+	}
+	// THIS DESTROYS pConvex!!
+	pBase->m_pCollisionData = physcollision->ConvertConvexToCollideParams( pElements, elementCount, params );
+
+	// debug output for the drag area calculations
+#if 0
+	Msg("Drag epsilon is %.3f\n", params.dragAreaEpsilon );
+	Vector areas = physcollision->CollideGetOrthographicAreas( pBase->m_pCollisionData );
+	Msg("Drag fractions are %.3f %.3f %.3f\n", areas.x, areas.y, areas.z );
+#endif
+}
+
+
+// is this list of verts contained in a slab of epsilon width?  If so, it's probably
+// an error of some kind - we shouldn't be authoring flat or 2d collision models
+bool IsApproximatelyPlanar( Vector **verts, int vertCount, float epsilon )
+{
+	if ( vertCount < 4 )
+		return true;
+
+	// If we're using an un-welded model, then this may generate a degenerate normal
+	// loop to search for an actual plane
+	int v0 = 1, v1 = 2;
+	Vector normal;
+	while ( v0 < vertCount && v1 < vertCount )
+	{
+		Vector edge0 = *verts[v0] - *verts[0];
+		Vector edge1 = *verts[v1] - *verts[0];
+
+		normal = CrossProduct( edge0, edge1 );
+		float len = VectorNormalize( normal );
+		if ( len > 0.001 )
+			break;
+		if ( edge0.Length() < 0.001 )
+		{
+			// verts[0] and v0 are coincident, try new verts
+			v0++;
+			v1++;
+		}
+		else
+		{
+			// v0 seems fine, try a new v1 -- it's probably coincident with v0
+			v1++;
+		}
+	}
+
+	// form the plane and project all of the verts into it
+	float minDist = DotProduct( normal, *verts[0] );
+	float maxDist = minDist;
+
+	for ( int i = 0; i < vertCount; i++ )
+	{
+		float d = DotProduct( *verts[i], normal );
+		if ( d < minDist )
+		{
+			minDist = d;
+		}
+		else if ( d > maxDist )
+		{
+			maxDist = d;
+		}
+		// at least one vert out of the plane, we've got something 3 dimensional
+		if ( fabsf(maxDist-minDist) > epsilon )
+			return false;
+	}
+	return true;
+}
+
+
+
+void BuildConvexListByVertID( s_source_t *pmodel, CUtlVector<convexlist_t> &convexList, CUtlVector<int> &vertList, CUtlVector<int> &vertID )
+{
+	// loop through each island of verts and append it to the convex list
+	convexlist_t current;
+	for ( int i = 0; i < pmodel->numvertices; i++ )
+	{
+		// already processed this group
+		if ( vertID[i] < 0 || vertID[i] > pmodel->numfaces )
+			continue;
+
+		current.firstVertIndex = vertList.Count();
+		current.numVertIndex = 0;
+
+		int id = vertID[i];
+
+		for ( int j = i; j < pmodel->numvertices; j++ )
+		{
+			if ( vertID[j] == id )
+			{
+				vertList.AddToTail(j);
+				current.numVertIndex++;
+				// don't reuse this vert
+				vertID[j] = -1;
+			}
+		}
+		convexList.AddToTail(current);
+	}
+}
+
+// build a list of vertex indices for each connected sub-piece
+void BuildSingleConvexForFaceList( s_source_t *pmodel, CUtlVector<convexlist_t> &convexList, CUtlVector<int> &vertList, const CUtlVector<s_face_t> &faceList )
+{
+	CUtlVector<int> vertID;
+	vertID.SetCount(pmodel->numvertices);
+	int i;
+	for ( i = 0; i < pmodel->numvertices; i++ )
+	{
+		vertID[i] = -1;
+	}
+
+	for ( i = 0; i < faceList.Count(); i++ )
+	{
+		const s_face_t &globalFace = faceList[i];
+		vertID[globalFace.a] = 1;
+		vertID[globalFace.b] = 1;
+		vertID[globalFace.c] = 1;
+	}
+	BuildConvexListByVertID( pmodel, convexList, vertList, vertID );
+}
+
+void BuildConvexListForFaceList( s_source_t *pmodel, CUtlVector<convexlist_t> &convexList, CUtlVector<int> &vertList, const CUtlVector<s_face_t> &faceList )
+{
+	CUtlVector<int> weldTable;
+	weldTable.SetCount(pmodel->numvertices);
+	BuildVertWeldTable( weldTable.Base(), pmodel );
+
+	int i;
+	CUtlVector<int> vertID;
+	vertID.SetCount(pmodel->numvertices);
+
+	// mark all verts as max faceid + 1
+	for ( i = 0; i < pmodel->numvertices; i++ )
+	{
+		// If these verts have been welded to a lower-index vert, mark them
+		// as already processed to avoid making additional convex objects out of them.
+		if ( weldTable[i] != i )
+		{
+			vertID[i] = -1;
+		}
+		else
+		{
+			vertID[i] = pmodel->numfaces+1;
+		}
+	}
+
+	Assert(convexList.Count()==0);
+	Assert(vertList.Count()==0);
+
+	int marked = 0;
+	int faceid = 0;
+	// iterate the face list, minimizing the vertID at each vert
+	// until we have an iteration where no vertIDs are changed
+	do 
+	{
+		marked = 0;
+		faceid = 0;
+
+		// basically this flood fills ids out to the verts until each island of connected 
+		// verts shares a single id (so new verts got marked)
+		for ( i = 0; i < faceList.Count(); i++ )
+		{
+			s_face_t globalFace = faceList[i];
+			// account for welding
+			globalFace.a = weldTable[globalFace.a];
+			globalFace.b = weldTable[globalFace.b];
+			globalFace.c = weldTable[globalFace.c];
+
+
+			int newid = min(i, vertID[globalFace.a]);
+			newid = min( newid, vertID[globalFace.b]);
+			newid = min( newid, vertID[globalFace.c]);
+
+			// mark all verts with the minimum, count the number we had to mark
+			if ( vertID[globalFace.a] != newid )
+			{
+				vertID[globalFace.a] = newid;
+				marked++;
+			}
+			if ( vertID[globalFace.b] != newid )
+			{
+				vertID[globalFace.b] = newid;
+				marked++;
+			}
+			if ( vertID[globalFace.c] != newid )
+			{
+				vertID[globalFace.c] = newid;
+				marked++;
+			}
+		}
+	} while ( marked != 0 );
+
+	BuildConvexListByVertID( pmodel, convexList, vertList, vertID );
+}
+
+
+// take a list of convex elements (lists of vert indices into master vert list) and build CPhysConvex out of them
+// return true if there are no errors detected
+bool BuildConvexesForLists( CUtlVector<CPhysConvex *> &convexOut, const CUtlVector<convexlist_t> &convexList, const CUtlVector<int> &vertList, const CUtlVector<Vector> &worldspaceVerts, bool bRemove2d )
+{
+	bool bValid = true;
+	CUtlVector<Vector *> vertsThisConvex;
+	for ( int i = 0; i < convexList.Count(); i++ )
+	{
+		const convexlist_t &elem = convexList[i];
+		vertsThisConvex.RemoveAll();
+		for ( int j = 0; j < elem.numVertIndex; j++ )
+		{
+			// this is ok because physcollision won't modify these, but wants non-const
+			Vector *pVert = const_cast<Vector *>(&worldspaceVerts[vertList[j + elem.firstVertIndex]]);
+			vertsThisConvex.AddToTail( pVert );
+		}
+
+		// need at least 3 verts to build a CPhysConvex
+		if ( vertsThisConvex.Count() > 2 )
+		{
+			const float g_epsilon_2d = 0.5f;
+			// HACKHACK: A heuristic to detect models without smoothing groups set
+			// UNDONE: Do a BSP to decompose arbitrary models to convex?
+			if ( IsApproximatelyPlanar( vertsThisConvex.Base(), vertsThisConvex.Count(), g_epsilon_2d ) )
+			{
+				if ( bRemove2d )
+					continue;
+				MdlWarning("Model has 2-dimensional geometry (less than %.3f inches thick on any axis)!!!\n", g_epsilon_2d );
+				bValid = false;
+			}
+			// go ahead and build it out
+			CPhysConvex *pConvex = physcollision->ConvexFromVerts( vertsThisConvex.Base(), vertsThisConvex.Count() );
+			if ( pConvex )
+			{
+				// Got something valid, attach this convex data to the root model
+				physcollision->SetConvexGameData( pConvex, 0 );
+				convexOut.AddToTail(pConvex);
+			}
+		}
+	}
+
+	return bValid;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Build a jointed collision model with constraints
+// Input  : &joints - 
+// Output : int
+//-----------------------------------------------------------------------------
+int ProcessJointedModel( CJointedModel &joints )
+{
+	if( !g_quiet )
+	{
+		printf("Processing jointed collision model\n" );
+	}
+	s_source_t *pmodel = joints.m_pModel;
+	// loop through each bone and form a collision model
+	for ( int boneIndex = 0; boneIndex < joints.m_pModel->numbones; boneIndex++ )
+	{
+		if ( !joints.ShouldProcessBone( boneIndex ) )
+			continue;
+
+		CUtlVector<Vector> bonespaceVerts;
+		bonespaceVerts.SetCount(pmodel->numvertices);
+		ConvertToBoneSpace( joints.m_pModel, boneIndex, bonespaceVerts );
+		CUtlVector<s_face_t> faceList;
+		CUtlVector<convexlist_t> convexList;
+		CUtlVector<int> vertList;
+		CUtlVector<CPhysConvex *> convexOut;
+		bool bValid = false;
+
+		for ( int i = 0; i < pmodel->nummeshes; i++ )
+		{
+			s_mesh_t *pmesh = pmodel->mesh + pmodel->meshindex[i];
+			for ( int j = 0; j < pmesh->numfaces; j++ )
+			{
+				s_face_t *face = pmodel->face + pmesh->faceoffset + j;
+				s_face_t globalFace;
+				GlobalFace( &globalFace, pmesh, face );
+				if ( FaceHasVertOnBone( joints, pmodel, &globalFace, boneIndex ) )
+				{
+					faceList.AddToTail( globalFace );
+				}
+			}
+			
+			if ( joints.m_allowConcaveJoints )
+			{
+				BuildConvexListForFaceList( pmodel, convexList, vertList, faceList );
+			}
+			else
+			{
+				BuildSingleConvexForFaceList( pmodel, convexList, vertList, faceList );
+			}
+
+			bValid = BuildConvexesForLists( convexOut, convexList, vertList, bonespaceVerts, joints.m_remove2d );
+		}
+
+		if ( convexOut.Count() > joints.m_maxConvex )
+		{
+			MdlWarning("COSTLY COLLISION MODEL!!!! (%d parts - %d allowed)\n", convexOut.Count(), joints.m_maxConvex );
+			bValid = false;
+		}
+
+		if ( !bValid && convexOut.Count() )
+		{
+			MdlWarning("Error with convex elements of %s, building single convex!!!!\n", pmodel->filename );
+			for ( int i = 0; i < convexOut.Count(); i++ )
+			{
+				physcollision->ConvexFree( convexOut[i] );
+			}
+			convexOut.Purge();
+		}
+
+		if ( convexOut.Count() )
+		{
+			int i;
+
+			CPhysCollisionModel *pPhys = InitCollisionModel( joints, pmodel->localBone[boneIndex].name );
+
+			pPhys->m_mass = 1.0;
+			pPhys->m_name = joints.m_pModel->localBone[boneIndex].name;
+			if ( joints.m_pModel->localBone[boneIndex].parent >= 0 )
+			{
+				pPhys->m_parent = joints.m_pModel->localBone[joints.m_pModel->localBone[boneIndex].parent].name;
+			}
+			else
+			{
+				pPhys->m_parent = NULL;
+			}
+
+			boundingvolume_t bv;
+			ClearBounds( bv.mins, bv.maxs );
+			int vertCount = 0;
+			for ( i = 0; i < convexList.Count(); i++ )
+			{
+				const convexlist_t &elem = convexList[i];
+				for ( int j = 0; j < elem.numVertIndex; j++ )
+				{
+					AddPointToBounds( bonespaceVerts[vertList[elem.firstVertIndex+j]], bv.mins, bv.maxs );
+					vertCount++;
+				}
+			}
+			for ( i = 0; i < convexOut.Count(); i++ )
+			{
+				// Attach this convex data to this particular bone
+				int globalBoneIndex = joints.m_pModel->boneLocalToGlobal[boneIndex];
+				physcollision->SetConvexGameData( convexOut[i], globalBoneIndex + 1 );
+			}
+
+			CreateCollide( pPhys, convexOut.Base(), convexOut.Count(), bv );
+			if( !g_quiet )
+			{
+				printf("%-24s (%3d verts, %d convex elements) volume: %4.2f\n", pPhys->m_name, vertCount, convexOut.Count(), pPhys->m_volume );
+			}
+			joints.UnlinkCollisionModel( pPhys );
+			joints.AppendCollisionModel( pPhys );
+		}
+	}
+	// remove any non-physical joints at this point
+	CPhysCollisionModel *pPhys = joints.m_pCollisionList;
+	while (pPhys)
+	{
+		CPhysCollisionModel *pNext = pPhys->m_pNext;
+		if ( !pPhys->m_pCollisionData )
+		{
+			joints.UnlinkCollisionModel(pPhys);
+			delete pPhys;
+		}
+		pPhys = pNext;
+	}
+
+	return 1;
+}
+
+
+#if 0
+// debug visualization code - use this to dump out intermediate geometry files for visualization in glview.exe
+void DumpToGLView( char const *pName, s_source_t *pmodel, Vector *worldVerts, int *used )
+{
+	int i;
+
+	for ( i = 0; i < pmodel->numvertices; i++ )
+		used[i] = -1;
+
+	FILE *fp = fopen( pName, "w" );
+	
+	// dump the model to a glview file
+	for ( i = 0; i < pmodel->nummeshes; i++ )
+	{
+		s_mesh_t *pmesh = pmodel->mesh + pmodel->meshindex[i];
+		for ( int j = 0; j < pmesh->numfaces; j++ )
+		{
+			s_face_t *face = pmodel->face + pmesh->faceoffset + j;
+			s_face_t globalFace;
+			GlobalFace( &globalFace, pmesh, face );
+
+			fprintf( fp, "3\n" );
+			fprintf( fp, "%6.3f %6.3f %6.3f 0 1 0\n", worldVerts[globalFace.b].x, worldVerts[globalFace.b].y, worldVerts[globalFace.b].z );
+			fprintf( fp, "%6.3f %6.3f %6.3f 1 0 0\n", worldVerts[globalFace.a].x, worldVerts[globalFace.a].y, worldVerts[globalFace.a].z );
+			fprintf( fp, "%6.3f %6.3f %6.3f 0 0 1\n", worldVerts[globalFace.c].x, worldVerts[globalFace.c].y, worldVerts[globalFace.c].z );
+			used[globalFace.a] = 0;
+			used[globalFace.b] = 0;
+			used[globalFace.c] = 0;
+		}
+	}
+
+	// dump a triangle expanded around each vert to the file (to show degenerate tris' verts).
+	for ( i = 0; i < pmodel->numvertices; i++ )
+	{
+		if ( used[i] < 0 )
+			continue;
+
+		fprintf( fp, "3\n" );
+		Vector vert;
+		vert = worldVerts[i] + Vector(0,0,5);
+		fprintf( fp, "%6.3f %6.3f %6.3f 1 0 0\n", vert.x, vert.y, vert.z );
+		vert = worldVerts[i] + Vector(5,0,-5);
+		fprintf( fp, "%6.3f %6.3f %6.3f 0 1 0\n", vert.x, vert.y, vert.z );
+		vert = worldVerts[i] + Vector(-5,0,-5);
+		fprintf( fp, "%6.3f %6.3f %6.3f 0 0 1\n", vert.x, vert.y, vert.z );
+
+	}
+
+	fclose( fp );
+}
+#endif
+
+
+int ProcessSingleBody( CJointedModel &joints )
+{
+	s_source_t *pmodel = joints.m_pModel;
+	// THIS CODE IS ONLY EXECUTED ON PROPS - i.e. NON-JOINTED MODELS
+	CUtlVector<Vector> worldspaceVerts;
+	worldspaceVerts.SetCount(pmodel->numvertices);
+	ConvertToWorldSpace( joints, pmodel, worldspaceVerts );
+	CUtlVector<s_face_t> faceList;
+
+	CUtlVector<convexlist_t> convexList;
+	CUtlVector<int> vertList;
+	CUtlVector<CPhysConvex *> convexOut;
+	bool bValid = false;
+	if ( joints.m_allowConcave )
+	{
+		for ( int i = 0; i < pmodel->nummeshes; i++ )
+		{
+			s_mesh_t *pmesh = pmodel->mesh + pmodel->meshindex[i];
+			for ( int j = 0; j < pmesh->numfaces; j++ )
+			{
+				s_face_t *face = pmodel->face + pmesh->faceoffset + j;
+				s_face_t globalFace;
+				GlobalFace( &globalFace, pmesh, face );
+				faceList.AddToTail( globalFace );
+			}
+		}
+		BuildConvexListForFaceList( pmodel, convexList, vertList, faceList );
+		bValid = BuildConvexesForLists( convexOut, convexList, vertList, worldspaceVerts, joints.m_remove2d );
+	}
+
+	if ( convexOut.Count() > joints.m_maxConvex )
+	{
+		MdlWarning("COSTLY COLLISION MODEL!!!! (%d parts - %d allowed)\n", convexOut.Count(), joints.m_maxConvex );
+		bValid = false;
+	}
+
+	if ( !bValid && convexOut.Count() )
+	{
+		MdlWarning("Error with convex elements of %s, building single convex!!!!\n", pmodel->filename );
+		for ( int i = 0; i < convexOut.Count(); i++ )
+		{
+			physcollision->ConvexFree( convexOut[i] );
+		}
+		convexOut.Purge();
+	}
+
+	// either we don't want concave, or there was an error building it
+	if ( !convexOut.Count() )
+	{
+		convexlist_t elem;
+		elem.firstVertIndex = 0;
+		elem.numVertIndex = pmodel->numvertices;
+		convexList.AddToTail(elem);
+		for ( int i = 0; i < pmodel->numvertices; i++ )
+		{
+			vertList.AddToTail(i);
+		}
+		BuildConvexesForLists( convexOut, convexList, vertList, worldspaceVerts, true );
+	}
+
+	if ( convexOut.Count() )
+	{
+		if( !g_quiet )
+		{
+			printf("Model has %d convex sub-parts\n", convexOut.Count() );
+		}
+
+		CPhysCollisionModel *pPhys = new CPhysCollisionModel;
+		joints.SetCollisionModelDefaults( pPhys );
+
+		boundingvolume_t bv;
+		ClearBounds( bv.mins, bv.maxs );
+		for ( int i = worldspaceVerts.Count()-1; --i >= 0; )
+		{
+			AddPointToBounds( worldspaceVerts[i], bv.mins, bv.maxs );
+		}
+		CreateCollide( pPhys, convexOut.Base(), convexOut.Count(), bv );
+
+		// Init mass, write routine will distribute the total mass
+		pPhys->m_mass = 1.0;
+		char tmp[512];
+		Q_FileBase( pmodel->filename, tmp, sizeof( tmp ) );
+
+		// UNDONE: Memory leak
+		char *out = new char[strlen(tmp)+1];
+		strcpy( out, tmp );
+		pPhys->m_name = out;
+		pPhys->m_parent = NULL;
+
+		joints.AppendCollisionModel( pPhys );
+	}
+	return 1;
+}
+
+
+
+#define MAX_ARGS	16
+#define ARG_SIZE	256
+
+//-----------------------------------------------------------------------------
+// Purpose: HACKETY HACK - get the args into a buffer.
+//			This checks for overflow, but it's not very robust - shouldn't be necessary though
+// Input  : pArgs[][ARG_SIZE] - 
+//			maxCount - array size of pargs
+// Output : int - count actually used
+//-----------------------------------------------------------------------------
+int ReadArgs( char pArgs[][ARG_SIZE], int maxCount )
+{
+	int argCount = 0;
+
+	while ( argCount < maxCount && TokenAvailable() )
+	{
+		GetToken(false);
+		strncpy( pArgs[argCount], token, ARG_SIZE );
+		argCount++;
+	}
+
+	return argCount;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Simple atof wrapper to keep from crashing on bad user input
+// Input  : *pString - 
+// Output : float
+//-----------------------------------------------------------------------------
+float Safe_atof( const char *pString )
+{
+	if ( !pString )
+		return 0;
+
+	return atof(pString);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Simple atoi wrapper to avoid crashing on bad user input
+// Input  : *pString - 
+// Output : int
+//-----------------------------------------------------------------------------
+int Safe_atoi( const char *pString )
+{
+	if ( !pString )
+		return 0;
+
+	return atoi(pString);
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a constraint to our joint system
+// Input  : &joints - 
+//			*pJointName - 
+//			*pJointAxis - 
+//			*pJointType - 
+//			*pLimitMin - 
+//			*pLimitMax - 
+//-----------------------------------------------------------------------------
+void CCmd_JointConstrain( CJointedModel &joints, const char *pJointName, const char *pJointAxis, const char *pJointType, const char *pLimitMin, const char *pLimitMax, const char *pFriction )
+{
+	float limitMin = Safe_atof(pLimitMin);
+	float limitMax = Safe_atof(pLimitMax);
+	float friction = Safe_atof(pFriction);
+	
+	int axis = -1;
+	int jointIndex = FindLocalBoneNamed( joints.m_pModel, pJointName );
+	if ( !g_bCreateMakefile && jointIndex < 0 )
+	{
+		MdlWarning("Can't find joint %s\n", pJointName );
+		return;
+	}
+	pJointName = joints.m_pModel->localBone[jointIndex].name;
+
+	if ( pJointAxis )
+	{
+		axis = tolower(pJointAxis[0]) - 'x';
+	}
+	if ( axis < 0 || axis > 2 || limitMin > limitMax )
+	{
+		MdlError("Invalid joint constraint for %s\nCan't build ragdoll!\n", pJointName );
+		return;
+	}
+
+	jointlimit_t jointType = JOINT_FREE;
+	if ( !stricmp( pJointType, "free" ) )
+	{
+		jointType = JOINT_FREE;
+	}
+	else if ( !stricmp( pJointType, "fixed" ) )
+	{
+		jointType = JOINT_FIXED;
+	}
+	else if ( !stricmp( pJointType, "limit" ) )
+	{
+		jointType = JOINT_LIMIT;
+	}
+	else
+	{
+		MdlWarning("Unknown joint type %s (must be free, fixed, or limit)\n", pJointType );
+		return;
+	}
+	joints.AddConstraint( pJointName, axis, jointType, limitMin, limitMax, friction );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Remove a joint from the system (don't create physical geometry for it)
+// Input  : &joints - 
+//			args[][ARG_SIZE] - 
+//			argCount - 
+//-----------------------------------------------------------------------------
+// UNDONE: Automatically skip joints that will have mass that is too low?
+void CCmd_JointSkip( CJointedModel &joints, const char *pName )
+{
+	int boneIndex = FindLocalBoneNamed( joints.m_pModel, pName );
+	if ( boneIndex < 0 )
+	{
+		MdlWarning("Can't skip joint %s, not found\n", pName );
+	}
+	else
+	{
+//			printf("skipping joint %s\n", pName );
+		joints.SkipBone( boneIndex );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets the object's mass.  The code will distribute this mass to each
+//			part based on the collision model's volume
+// Input  : &joints - 
+//			*pMass - 
+//-----------------------------------------------------------------------------
+void CCmd_TotalMass( CJointedModel &joints, const char *pMass )
+{
+	joints.SetTotalMass( Safe_atof(pMass) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: verts from the bone named pChild are added to the collision model of pParent
+// Input  : *pmodel - source model
+//			*pParent - destination bone name
+//			*pChild - source bone name
+//-----------------------------------------------------------------------------
+void CCmd_JointMerge( CJointedModel &joints, const char *pParent, const char *pChild )
+{
+	joints.AddMergeCommand( pParent, pChild );
+	joints.MergeBones( FindLocalBoneNamed( joints.m_pModel, pParent ), FindLocalBoneNamed( joints.m_pModel, pChild ) );
+}
+
+
+void CCmd_JointRoot( CJointedModel &joints, const char *pBone )
+{
+	// save the root bone name
+	strcpy( joints.m_rootName, pBone );
+}
+
+
+void CCmd_JoinAnimatedFriction( CJointedModel &joints, const char *pMinFriction, const char *pMaxFriction, const char *pTimeIn, const char *pTimeHold, const char *pTimeOut )
+{
+	joints.m_flFrictionTimeIn = Safe_atof( pTimeIn );
+	joints.m_flFrictionTimeOut = Safe_atof( pTimeOut );
+	joints.m_flFrictionTimeHold = Safe_atof( pTimeHold );
+	joints.m_iMinAnimatedFriction = Safe_atoi( pMinFriction );
+	joints.m_iMaxAnimatedFriction = Safe_atoi( pMaxFriction );
+	joints.m_bHasAnimatedFriction = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Parses all legal commands inside the $collisionjoints {} block
+// Input  : &joints - 
+//-----------------------------------------------------------------------------
+void ParseCollisionCommands( CJointedModel &joints )
+{
+	char command[512];
+
+	char args[MAX_ARGS][ARG_SIZE];
+	int argCount;
+
+	while( GetToken( true ) )
+	{
+		if ( !strcmp( token, "}" ) )
+			return;
+
+		strcpy( command, token );
+
+		if ( !stricmp( command, "$mass" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			CCmd_TotalMass( joints, args[0] );
+		}
+		// default properties
+		else if ( !stricmp( command, "$automass" ) )
+		{
+			joints.SetAutoMass();
+		}
+		else if ( !stricmp( command, "$inertia" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			joints.DefaultInertia( Safe_atof( args[0] ) );
+		}
+		else if ( !stricmp( command, "$damping" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			joints.DefaultDamping( Safe_atof( args[0] ) );
+		}
+		else if ( !stricmp( command, "$rotdamping" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			joints.DefaultRotdamping( Safe_atof( args[0] ) );
+		}
+		else if ( !stricmp( command, "$drag" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			joints.DefaultDrag( Safe_atof( args[0] ) );
+		}
+		else if ( !stricmp( command, "$rollingDrag" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			// JAY: Removed this in favor of heuristic/tuning approach
+			//joints.DefaultRollingDrag( Safe_atof( args[0] ) );
+		}
+		else if ( !stricmp( command, "$maxconvexpieces") )
+		{
+			argCount = ReadArgs( args, 1 );
+			joints.SetMaxConvex( Safe_atoi(args[0]) );
+		}
+		else if ( !stricmp( command, "$remove2d") )
+		{
+			joints.Remove2DConvex();
+		}
+		else if ( !stricmp( command, "$concaveperjoint") )
+		{
+			joints.AllowConcaveJoints();
+		}
+		else if ( !stricmp( command, "$weldposition") )
+		{
+			argCount = ReadArgs(args,1);
+			g_WeldVertEpsilon = Safe_atof( args[0] );
+		}
+		else if ( !stricmp( command, "$weldnormal") )
+		{
+			argCount = ReadArgs(args,1);
+			g_WeldNormalEpsilon = Safe_atof( args[0] );
+		}
+		else if ( !stricmp( command, "$concave" ) )
+		{
+			joints.AllowConcave();
+		}
+		else if ( !stricmp( command, "$masscenter" ) )
+		{
+			argCount = ReadArgs( args, 3 );
+			Vector center;
+			center.Init( Safe_atof(args[0]), Safe_atof(args[1]), Safe_atof(args[2]) );
+			joints.ForceMassCenter( center );
+		}
+		// joint commands
+		else if ( !stricmp( command, "$jointskip" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			CCmd_JointSkip( joints, args[0] );
+		}
+		else if ( !stricmp( command, "$jointmerge" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			CCmd_JointMerge( joints, args[0], args[1] );
+		}
+		else if ( !stricmp( command, "$rootbone" ) )
+		{
+			argCount = ReadArgs( args, 1 );
+			CCmd_JointRoot( joints, args[0] );
+		}
+		else if ( !stricmp( command, "$jointconstrain" ) )
+		{
+			argCount = ReadArgs( args, 6 );
+			char *pFriction = args[5];
+			if ( argCount < 6 )
+			{
+				pFriction = "1.0";
+			}
+			CCmd_JointConstrain( joints, args[0], args[1], args[2], args[3], args[4], pFriction );
+		}
+		// joint properties
+		else if ( !stricmp( command, "$jointinertia" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			joints.JointInertia( args[0], Safe_atof( args[1] ) );
+		}
+		else if ( !stricmp( command, "$jointdamping" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			joints.JointDamping( args[0], Safe_atof( args[1] ) );
+		}
+		else if ( !stricmp( command, "$jointrotdamping" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			joints.JointRotdamping( args[0], Safe_atof( args[1] ) );
+		}
+		else if ( !stricmp( command, "$jointmassbias" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			joints.JointMassBias( args[0], Safe_atof( args[1] ) );
+		}
+		else if ( !stricmp( command, "$noselfcollisions" ) )
+		{
+			joints.SetNoSelfCollisions();
+		}
+		else if ( !stricmp( command, "$jointcollide" ) )
+		{
+			argCount = ReadArgs( args, 2 );
+			joints.AppendCollisionPair( args[0], args[1] );
+		}
+		else if ( !stricmp( command, "$animatedfriction" ) )
+		{
+			argCount = ReadArgs( args, 5 );
+
+			if ( argCount == 5 )
+			{
+				CCmd_JoinAnimatedFriction( joints, args[0], args[1], args[2], args[3], args[4] );
+			}
+		}
+		else if ( !stricmp( command, "$assumeworldspace") )
+		{
+			joints.m_bAssumeWorldspace = true;
+		}
+		else
+		{
+			MdlWarning("Unknown command %s in collision series\n", command );
+		}
+	}
+}
+
+
+void Cmd_CollisionText( void )
+{
+	int level = 1;
+
+	if ( !GetToken( true ) )
+		return;
+
+	if ( token[0] != '{' )
+		return;
+
+
+	while ( GetToken(true) )
+	{
+		if ( !strcmp( token, "}" ) )
+		{
+			level--;
+			if ( level <= 0 )
+				break;
+			g_JointedModel.AddText( " }\n" );
+		}
+		else if ( !strcmp( token, "{" ) )
+		{
+			g_JointedModel.AddText( "{" );
+			level++;
+		}
+		else
+		{
+			// tokens inside braces  are quoted
+			if ( level > 1 )
+			{
+				g_JointedModel.AddText( "\"" );
+				g_JointedModel.AddText( token );
+				g_JointedModel.AddText( "\" " );
+			}
+			else
+			{
+				g_JointedModel.AddText( token );
+				g_JointedModel.AddText( " " );
+			}
+		}
+	}
+}
+
+static bool LoadSurfaceProps( const char *pMaterialFilename )
+{
+	if ( !physprops )
+		return false;
+
+	FileHandle_t fp = g_pFileSystem->Open( pMaterialFilename, "rb", TOOLS_READ_PATH_ID );
+	if ( fp == FILESYSTEM_INVALID_HANDLE )
+		return false;
+
+	int len = g_pFileSystem->Size( fp );
+	char *pText = new char[len+1];
+	g_pFileSystem->Read( pText, len, fp );
+	g_pFileSystem->Close( fp );
+	
+	pText[len]=0;
+
+	physprops->ParseSurfaceData( pMaterialFilename, pText );
+
+	delete[] pText;
+
+	return true;
+}
+
+void LoadSurfacePropsAll()
+{
+	// already loaded
+	if ( physprops->SurfacePropCount() )
+		return;
+
+	const char *SURFACEPROP_MANIFEST_FILE = "scripts/surfaceproperties_manifest.txt";
+	KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE );
+	if ( manifest->LoadFromFile( g_pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) )
+	{
+		for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() )
+		{
+			if ( !Q_stricmp( sub->GetName(), "file" ) )
+			{
+				// Add
+				LoadSurfaceProps( sub->GetString() );
+				continue;
+			}
+		}
+	}
+
+	manifest->deleteThis();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Entry point for script processing.  Delegate to necessary subroutines.
+//			Parse the collisionmodel {} and collisionjoints {} chunks
+// Input  : separateJoints - whether this has a constraint system or not (true if it does)
+// Output : int
+//-----------------------------------------------------------------------------
+int DoCollisionModel( bool separateJoints )
+{
+	char name[512];
+	s_source_t *pmodel;
+
+	// name
+	if (!GetToken(false)) return 0;
+
+	V_strcpy_safe( name, token );
+
+	PhysicsDLLPath( "VPHYSICS.DLL" );
+
+//	CreateInterfaceFn physicsFactory = GetPhysicsFactory();
+	CreateInterfaceFn physicsFactory = Sys_GetFactory(Sys_LoadModule( "vphysics.dll" ));
+	if ( !physicsFactory )
+		return 0;
+
+	physcollision = (IPhysicsCollision *)physicsFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL );
+	physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL );
+	LoadSurfacePropsAll();
+
+	int nummaterials = g_nummaterials;
+	int numtextures = g_numtextures;
+
+	pmodel = Load_Source( name, "SMD" );
+	if ( !pmodel )
+		return 0;
+
+	// auto-remove any new materials/textures
+	if (nummaterials && numtextures && (numtextures != g_numtextures || nummaterials != g_nummaterials))
+	{
+		g_numtextures = numtextures;
+		g_nummaterials = nummaterials;
+
+		pmodel->texmap[0] = 0;
+	}
+
+	// all bones map to themselves by default
+	g_JointedModel.SetSource( pmodel );
+	
+	bool parseCommands = false;
+
+	// If the next token is a { that means a data block for the collision model
+	if (GetToken(true))
+	{
+		if ( !strcmp( token, "{" ) )
+		{
+			parseCommands = true;
+		}
+		else
+		{
+			UnGetToken();
+		}
+	}
+
+	if ( parseCommands )
+	{
+		ParseCollisionCommands( g_JointedModel );
+	}
+
+	g_bJointed = separateJoints;
+
+	// collision script is stored in g_JointedModel for later processing
+	return 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Walk the list of models, add up the volume
+// Input  : *pList - 
+// Output : float
+//-----------------------------------------------------------------------------
+float TotalVolume( CPhysCollisionModel *pList )
+{
+	float volume = 0;
+	while ( pList )
+	{
+		volume += pList->m_volume * pList->m_massBias;
+		pList = pList->m_pNext;
+	}
+
+	return volume;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Write key/value pairs out to a file
+// Input  : *fp - output file
+//			*pKeyName - key name
+//			outputData - type specific output data
+//-----------------------------------------------------------------------------
+void KeyWriteInt( FILE *fp, const char *pKeyName, int outputData )
+{
+	fprintf( fp, "\"%s\" \"%d\"\n", pKeyName, outputData );
+}
+
+void KeyWriteIntPair( FILE *fp, const char *pKeyName, int outputData0, int outputData1 )
+{
+	fprintf( fp, "\"%s\" \"%d,%d\"\n", pKeyName, outputData0, outputData1 );
+}
+void KeyWriteString( FILE *fp, const char *pKeyName, const char *outputData )
+{
+	fprintf( fp, "\"%s\" \"%s\"\n", pKeyName, outputData );
+}
+
+void KeyWriteVector3( FILE *fp, const char *pKeyName, const Vector& outputData )
+{
+	fprintf( fp, "\"%s\" \"%f %f %f\"\n", pKeyName, outputData[0], outputData[1], outputData[2] );
+}
+
+void KeyWriteQAngle( FILE *fp, const char *pKeyName, const QAngle& outputData )
+{
+	fprintf( fp, "\"%s\" \"%f %f %f\"\n", pKeyName, outputData[0], outputData[1], outputData[2] );
+}
+
+void KeyWriteFloat( FILE *fp, const char *pKeyName, float outputData )
+{
+	fprintf( fp, "\"%s\" \"%f\"\n", pKeyName, outputData );
+}
+
+
+void FixCollisionHierarchy( CJointedModel &joints )
+{
+	if ( joints.m_pCollisionList )
+	{
+		CPhysCollisionModel *pPhys = joints.m_pCollisionList;
+
+		FixBoneList( joints.m_bonemap, joints.m_pModel, joints.m_pCollisionList );
+		// Point parents at joints that are actually in the model
+		for ( ;pPhys; pPhys = pPhys->m_pNext )
+		{
+			pPhys->m_parent = FixParent( joints.m_pCollisionList, joints.m_pModel, pPhys->m_parent );
+		}
+
+		// sort the list so parents come before children
+		joints.SortCollisionList();
+		// Now remap the constraints to bones to 
+		// Now that bones are in order, set physics indices in main bone structure
+
+		CJointConstraint *pList = g_JointedModel.m_pConstraintList;
+		while ( pList )
+		{
+			pList->m_pJointName = FixParent( joints.m_pCollisionList, joints.m_pModel, pList->m_pJointName );
+			pList = pList->m_pNext;
+		}
+
+		pPhys = joints.m_pCollisionList;
+		int i;
+		for ( i = 0; i < g_numbones; i++ )
+		{
+			g_bonetable[i].physicsBoneIndex = -1;
+		}
+		int index = 0;
+		while ( pPhys )
+		{
+			int boneIndex = FindBoneInTable( pPhys->m_name );
+			if ( boneIndex >= 0 )
+			{
+				g_bonetable[boneIndex].physicsBoneIndex = index;
+			}
+			pPhys = pPhys->m_pNext;
+			index ++;
+		}
+		for ( i = 0; i < g_numbones; i++ )
+		{
+			// if no bone was set, set to parent bone
+			if ( g_bonetable[i].physicsBoneIndex < 0 )
+			{
+				int index = g_bonetable[i].parent;
+				int bone = -1;
+				while ( index >= 0 )
+				{
+					bone = g_bonetable[index].physicsBoneIndex;
+					if ( bone >= 0 )
+						break;
+					index = g_bonetable[index].parent;
+				}
+
+				// found one?
+				if ( bone >= 0 )
+				{
+					g_bonetable[i].physicsBoneIndex = bone;
+				}
+				else
+				{
+					// just set physics to affect root
+					g_bonetable[i].physicsBoneIndex = 0;
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Builds the physics/collision model.
+//			This must execute after the model has been simplified!!
+//-----------------------------------------------------------------------------
+void CollisionModel_Build( void )
+{
+	// no collision model referenced
+	if ( !g_JointedModel.m_pModel )
+		return;
+
+	g_JointedModel.Simplify();
+	if ( g_bJointed )
+	{
+		ProcessJointedModel( g_JointedModel );
+	}
+	else
+	{
+		ProcessSingleBody( g_JointedModel );
+	}
+	FixCollisionHierarchy( g_JointedModel );
+	if( !g_quiet )
+	{
+		printf("Collision model completed.\n" );
+	}
+	g_JointedModel.ComputeMass();
+}
+
+void BuildRagdollConstraint( CPhysCollisionModel *pPhys, constraint_ragdollparams_t &ragdoll )
+{
+	memset( &ragdoll, 0, sizeof(ragdoll) );
+	ragdoll.parentIndex = g_JointedModel.CollisionIndex(pPhys->m_parent);
+	ragdoll.childIndex = g_JointedModel.CollisionIndex(pPhys->m_name);
+	if ( ragdoll.parentIndex < 0 || ragdoll.childIndex < 0 )
+	{
+		MdlWarning("Constraint between bone %s and %s\n", pPhys->m_name, pPhys->m_parent );
+		if ( ragdoll.childIndex < 0 )
+			MdlWarning("\"%s\" does not appear in collision model!!!\n", pPhys->m_name );
+		if ( ragdoll.parentIndex < 0 )
+			MdlWarning("\"%s\" does not appear in collision model!!!\n", pPhys->m_parent );
+		MdlError("Bad constraint in ragdoll\n");
+	}
+	CJointConstraint *pList = g_JointedModel.m_pConstraintList;
+	while ( pList )
+	{
+		int index = g_JointedModel.CollisionIndex(pList->m_pJointName);
+		CPhysCollisionModel *pListModel = g_JointedModel.GetCollisionModel(pList->m_pJointName);
+		if ( index < 0 )
+		{
+			MdlError("Rotation constraint on bone \"%s\" which does not appear in collision model!!!\n", pList->m_pJointName );
+		}
+		else if ( (!pListModel->m_parent || g_JointedModel.CollisionIndex(pListModel->m_parent) < 0) && stricmp( pList->m_pJointName, g_JointedModel.m_rootName ) )
+		{
+			MdlError("Rotation constraint on bone \"%s\" which has no parent!!!\n", pList->m_pJointName );
+		}
+		else if ( index == ragdoll.childIndex )
+		{
+			switch ( pList->m_jointType )
+			{
+			case JOINT_LIMIT:
+				ragdoll.axes[pList->m_axis].SetAxisFriction( pList->m_limitMin, pList->m_limitMax, pList->m_friction );
+				break;
+			case JOINT_FIXED:
+				ragdoll.axes[pList->m_axis].SetAxisFriction( 0,0,0 );
+				break;
+			case JOINT_FREE:
+				ragdoll.axes[pList->m_axis].SetAxisFriction( -360, 360, pList->m_friction );
+				break;
+			}
+		}
+		pList = pList->m_pNext;
+	}
+}
+
+float GetCollisionModelMass()
+{
+	return g_JointedModel.m_totalMass;
+}
+
+void CollisionModel_ExpandBBox( Vector &mins, Vector &maxs )
+{
+	// don't do fixup for ragdolls
+	if ( g_bJointed )
+		return;
+
+	if ( g_JointedModel.m_pCollisionList )
+	{
+		Vector collideMins, collideMaxs;
+
+		physcollision->CollideGetAABB( &collideMins, &collideMaxs, g_JointedModel.m_pCollisionList->m_pCollisionData, vec3_origin, vec3_angle );
+		
+		// add the 0.25 inch collision separation as well
+		const float radius = 0.25;
+		collideMins -= Vector(radius,radius,radius);
+		collideMaxs += Vector(radius,radius,radius);
+
+		AddPointToBounds( collideMins, mins, maxs );
+		AddPointToBounds( collideMaxs, mins, maxs );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Write out any data that's been saved in the globals
+//-----------------------------------------------------------------------------
+void CollisionModel_Write( long checkSum )
+{
+	if ( g_JointedModel.m_pCollisionList )
+	{
+		CPhysCollisionModel *pPhys = g_JointedModel.m_pCollisionList;
+
+		char filename[MAX_PATH];
+
+		V_strcpy_safe( filename, gamedir );
+//		if( *g_pPlatformName )
+//		{
+//			strcat( filename, "platform_" );
+//			strcat( filename, g_pPlatformName );
+//			strcat( filename, "/" );	
+//		}
+		V_strcat_safe( filename, "models/" );	
+		V_strcat_safe( filename, outname );	
+
+		float volume = TotalVolume( pPhys );
+		if ( volume <= 0 )
+			volume = 1;
+		if( !g_quiet )
+		{
+			printf("Collision model volume %.2f in^3\n", volume );
+		}
+
+		Q_SetExtension( filename, ".phy", sizeof( filename ) );
+		CPlainAutoPtr< CP4File > spFile( g_p4factory->AccessFile( filename ) );
+		spFile->Edit();
+		FILE *fp = fopen( filename, "wb" );
+		if ( fp )
+		{
+			// write out the collision header (size is version)
+			phyheader_t header;
+			header.size = sizeof(header);
+			header.id = 0;
+			header.checkSum = checkSum;
+
+			header.solidCount = 0;
+			pPhys = g_JointedModel.m_pCollisionList;
+			while ( pPhys )
+			{
+				header.solidCount++;
+				pPhys = pPhys->m_pNext;
+			}
+
+			fwrite( &header, sizeof(header), 1, fp );
+
+			// Write out the binary physics collision data
+			pPhys = g_JointedModel.m_pCollisionList;
+			while ( pPhys )
+			{
+				int size = physcollision->CollideSize( pPhys->m_pCollisionData );
+				fwrite( &size, sizeof(int), 1, fp );
+				char *buf = (char *)stackalloc( size );
+				physcollision->CollideWrite( buf, pPhys->m_pCollisionData );
+				fwrite( buf, size, 1, fp );
+				pPhys = pPhys->m_pNext;
+			}
+
+			// write out the properties of each solid
+			int solidIndex = 0;
+			pPhys = g_JointedModel.m_pCollisionList;
+			while ( pPhys )
+			{
+				pPhys->m_mass = ((pPhys->m_volume * pPhys->m_massBias) / volume) * g_JointedModel.m_totalMass;
+				if ( pPhys->m_mass < 1.0 )
+					pPhys->m_mass = 1.0;
+
+				fprintf( fp, "solid {\n" );
+				KeyWriteInt( fp, "index", solidIndex );
+				KeyWriteString( fp, "name", pPhys->m_name );
+				if ( pPhys->m_parent )
+				{
+					KeyWriteString( fp, "parent", pPhys->m_parent );
+				}
+			
+				KeyWriteFloat( fp, "mass", pPhys->m_mass );
+				//KeyWriteFloat( fp, "volume", pPhys->m_volume );
+
+				char* pSurfaceProps = GetSurfaceProp( pPhys->m_name );
+
+				KeyWriteString( fp, "surfaceprop", pSurfaceProps );
+				KeyWriteFloat( fp, "damping", pPhys->m_damping );
+				KeyWriteFloat( fp, "rotdamping", pPhys->m_rotdamping );
+				
+				if ( pPhys->m_dragCoefficient != -1 )
+				{
+					KeyWriteFloat( fp, "drag", pPhys->m_dragCoefficient );
+				}
+				KeyWriteFloat( fp, "inertia", pPhys->m_inertia );
+				KeyWriteFloat( fp, "volume", pPhys->m_volume );
+				if ( pPhys->m_massBias != 1.0f )
+				{
+					KeyWriteFloat( fp, "massbias", pPhys->m_massBias );
+				}
+
+				fprintf( fp, "}\n" );
+				pPhys = pPhys->m_pNext;
+				solidIndex++;
+
+			}
+
+			// by default, write constraints from each limb to its parent
+			pPhys = g_JointedModel.m_pCollisionList;
+			while ( pPhys )
+			{
+				// check to see if bone collapse/remap has left this with parent pointing at itself
+				if ( pPhys->m_parent )
+				{
+					constraint_ragdollparams_t ragdoll;
+					BuildRagdollConstraint( pPhys, ragdoll );
+					if ( ragdoll.parentIndex != ragdoll.childIndex )
+					{
+						fprintf( fp, "ragdollconstraint {\n" );
+						KeyWriteInt( fp, "parent", ragdoll.parentIndex );
+						KeyWriteInt( fp, "child", ragdoll.childIndex );
+						KeyWriteFloat( fp, "xmin", ragdoll.axes[0].minRotation );
+						KeyWriteFloat( fp, "xmax", ragdoll.axes[0].maxRotation );
+						KeyWriteFloat( fp, "xfriction", ragdoll.axes[0].torque );
+						KeyWriteFloat( fp, "ymin", ragdoll.axes[1].minRotation );
+						KeyWriteFloat( fp, "ymax", ragdoll.axes[1].maxRotation );
+						KeyWriteFloat( fp, "yfriction", ragdoll.axes[1].torque );
+						KeyWriteFloat( fp, "zmin", ragdoll.axes[2].minRotation );
+						KeyWriteFloat( fp, "zmax", ragdoll.axes[2].maxRotation );
+						KeyWriteFloat( fp, "zfriction", ragdoll.axes[2].torque );
+						fprintf( fp, "}\n" );
+					}
+				}
+				pPhys = pPhys->m_pNext;
+
+			}
+			if ( g_JointedModel.m_noSelfCollisions )
+			{
+				fprintf(fp, "collisionrules {\n" );
+				KeyWriteInt( fp, "selfcollisions", 0 );
+				fprintf(fp, "}\n");
+			}
+			else if ( g_JointedModel.m_pCollisionPairs )
+			{
+				fprintf(fp, "collisionrules {\n" );
+				collisionpair_t *pPair = g_JointedModel.m_pCollisionPairs;
+				while ( pPair )
+				{
+					pPair->obj0 = g_JointedModel.CollisionIndex( pPair->pName0 );
+					pPair->obj1 = g_JointedModel.CollisionIndex( pPair->pName1 );
+					if ( pPair->obj0 >= 0 && pPair->obj1 >= 0 && pPair->obj0 != pPair->obj1 )
+					{
+						KeyWriteIntPair( fp, "collisionpair", pPair->obj0, pPair->obj1 );
+					}
+					else
+					{
+						MdlWarning("Invalid collision pair (%s, %s)\n", pPair->pName0, pPair->pName1 );
+					}
+					pPair = pPair->pNext;
+				}
+				fprintf(fp, "}\n");
+			}
+
+			if ( g_JointedModel.m_bHasAnimatedFriction == true )
+			{
+				fprintf( fp, "animatedfriction {\n" );
+				KeyWriteFloat( fp, "animfrictionmin", g_JointedModel.m_iMinAnimatedFriction );
+				KeyWriteFloat( fp, "animfrictionmax", g_JointedModel.m_iMaxAnimatedFriction );
+				KeyWriteFloat( fp, "animfrictiontimein", g_JointedModel.m_flFrictionTimeIn );
+				KeyWriteFloat( fp, "animfrictiontimeout", g_JointedModel.m_flFrictionTimeOut );
+				KeyWriteFloat( fp, "animfrictiontimehold", g_JointedModel.m_flFrictionTimeHold );
+				fprintf( fp, "}\n" );
+			}
+
+			// block that is only parsed by the editor
+			fprintf( fp, "editparams {\n" );
+			KeyWriteString( fp, "rootname", g_JointedModel.m_rootName );
+			KeyWriteFloat( fp, "totalmass", g_JointedModel.m_totalMass );
+			if ( g_JointedModel.m_allowConcave )
+			{
+				KeyWriteInt( fp, "concave", 1 );
+			}
+			for ( int k = 0; k < g_JointedModel.m_mergeList.Count(); k++ )
+			{
+				char buf[512];
+				Q_snprintf( buf, sizeof(buf), "%s,%s", g_JointedModel.m_mergeList[k].pParent, g_JointedModel.m_mergeList[k].pChild );
+				KeyWriteString( fp, "jointmerge", buf );
+			}
+
+			fprintf( fp, "}\n" );
+
+			char terminator = 0;
+			if ( g_JointedModel.m_textCommands.Size() )
+			{
+				fwrite( g_JointedModel.m_textCommands.Base(), g_JointedModel.m_textCommands.Size(), 1, fp );
+			}
+			fwrite( &terminator, sizeof(terminator), 1, fp );
+			fclose( fp );
+			spFile->Add();
+		}
+		else
+		{
+			MdlWarning("Error writing %s!!!\n", filename );
+		}
+	}
+}
+
+
diff --git a/utils/studiomdl/collisionmodel.h b/utils/studiomdl/collisionmodel.h
new file mode 100644
index 0000000..8a3f37d
--- /dev/null
+++ b/utils/studiomdl/collisionmodel.h
@@ -0,0 +1,28 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef COLLISIONMODEL_H
+#define COLLISIONMODEL_H
+#pragma once
+
+extern void Cmd_CollisionText( void );
+extern int DoCollisionModel( bool separateJoints );
+
+// execute after simplification, before writing
+extern void CollisionModel_Build( void );
+// execute during writing
+extern void CollisionModel_Write( long checkSum );
+
+void CollisionModel_ExpandBBox( Vector &mins, Vector &maxs );
+
+#endif // COLLISIONMODEL_H
diff --git a/utils/studiomdl/dmxsupport.cpp b/utils/studiomdl/dmxsupport.cpp
new file mode 100644
index 0000000..2e83255
--- /dev/null
+++ b/utils/studiomdl/dmxsupport.cpp
@@ -0,0 +1,1213 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Loads mesh data from dmx files 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+#include "studiomdl.h"
+#include "movieobjects/dmemodel.h"
+#include "movieobjects/dmemesh.h"
+#include "movieobjects/dmefaceset.h"
+#include "movieobjects/dmematerial.h"
+#include "movieobjects/dmeclip.h"
+#include "movieobjects/dmechannel.h"
+#include "movieobjects/dmeattachment.h"
+#include "movieobjects/dmeanimationlist.h"
+#include "movieobjects/dmecombinationoperator.h"
+
+
+void UnifyIndices( s_source_t *psource );
+
+
+//-----------------------------------------------------------------------------
+// Mapping of bone transforms
+//-----------------------------------------------------------------------------
+struct BoneTransformMap_t 
+{
+	// Number of bones
+	int m_nBoneCount;
+
+	// The order in which transforms appear in this list specifies their bone indices
+	CDmeTransform *m_ppTransforms[MAXSTUDIOSRCBONES];
+
+	// BoneRemap[bone index in file] == bone index in studiomdl
+	int	m_pBoneRemap[MAXSTUDIOSRCBONES];
+};
+
+
+//-----------------------------------------------------------------------------
+// Index into an s_node_t array for the default root node
+//-----------------------------------------------------------------------------
+static int s_nDefaultRootNode;
+
+
+//-----------------------------------------------------------------------------
+// Balance/speed data
+//-----------------------------------------------------------------------------
+static CUtlVector<float> s_Balance;
+static CUtlVector<float> s_Speed;
+
+
+//-----------------------------------------------------------------------------
+// List of unique vertices
+//-----------------------------------------------------------------------------
+struct VertIndices_t
+{
+	int v;
+	int n;
+	int t;
+	int balance;
+	int speed;
+};
+
+static CUtlVector< VertIndices_t > s_UniqueVertices;	// A list of the unique vertices in the mesh
+
+// Given the non-unique vertex index, return the unique vertex index
+// The indices are absolute indices into s_UniqueVertices
+// But as both arrays contain information for all meshes in the DMX
+// The proper offset for the desired mesh must be added to the lookup
+// into the map but the value returned has the offset already built in
+static CUtlVector< int > s_UniqueVerticesMap;
+
+
+//-----------------------------------------------------------------------------
+// Delta state intermediate data [used for positions, normals, etc.]
+//-----------------------------------------------------------------------------
+struct DeltaIndex_t
+{
+	DeltaIndex_t() : m_nPositionIndex(-1), m_nNormalIndex(-1), m_nNextDelta(-1), m_nWrinkleIndex(-1), m_bInList(false) {}
+	int m_nPositionIndex;	// Index into DeltaState_t::m_PositionDeltas
+	int m_nNormalIndex;		// Index into DeltaState_t::m_NormalDeltas
+	int m_nWrinkleIndex;	// Index into DeltaState_t::m_WrinkleDeltas
+	int m_nNextDelta;		// Index into DeltaState_t::m_DeltaIndices;
+	bool m_bInList;
+};
+
+struct DeltaState_t
+{
+	DeltaState_t() : m_nDeltaCount( 0 ), m_nFirstDelta( -1 ) {}
+
+	CUtlString m_Name;
+	CUtlVector< Vector > m_PositionDeltas;
+	CUtlVector< Vector > m_NormalDeltas;
+	CUtlVector< float > m_WrinkleDeltas;
+	CUtlVector< DeltaIndex_t > m_DeltaIndices;
+	int m_nDeltaCount;
+	int m_nFirstDelta;
+};
+
+
+// NOTE: This is a temporary which loses its state once Load_DMX is exited.
+static CUtlVector<DeltaState_t> s_DeltaStates;
+
+
+//-----------------------------------------------------------------------------
+// Finds or adds delta states. These pointers are invalidated by calling FindOrAddDeltaState again
+//-----------------------------------------------------------------------------
+static DeltaState_t* FindOrAddDeltaState( const char *pDeltaStateName, int nBaseStateVertexCount )
+{
+	int nCount = s_DeltaStates.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !Q_stricmp( s_DeltaStates[i].m_Name, pDeltaStateName ) )
+		{
+			MdlWarning( "Unsupported duplicate delta state named \"%s\" in DMX file\n", pDeltaStateName );
+
+			s_DeltaStates[i].m_DeltaIndices.EnsureCount( nBaseStateVertexCount );
+			return &s_DeltaStates[i];
+		}
+	}
+
+	int j = s_DeltaStates.AddToTail();
+	s_DeltaStates[j].m_Name = pDeltaStateName;
+	s_DeltaStates[j].m_DeltaIndices.SetCount( nBaseStateVertexCount );
+	return &s_DeltaStates[j];
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the vertices from the model
+//-----------------------------------------------------------------------------
+static bool DefineUniqueVertices( CDmeVertexData *pBindState, int nStartingUniqueCount )
+{
+	const CUtlVector<int> &positionIndices = pBindState->GetVertexIndexData( CDmeVertexData::FIELD_POSITION );
+	const CUtlVector<int> &normalIndices = pBindState->GetVertexIndexData( CDmeVertexData::FIELD_NORMAL );
+	const CUtlVector<int> &texcoordIndices = pBindState->GetVertexIndexData( CDmeVertexData::FIELD_TEXCOORD );
+	const CUtlVector<int> &balanceIndices = pBindState->GetVertexIndexData( CDmeVertexData::FIELD_BALANCE );
+	const CUtlVector<int> &speedIndices = pBindState->GetVertexIndexData( CDmeVertexData::FIELD_MORPH_SPEED );
+
+	int nPositionCount = positionIndices.Count();
+	int nNormalCount = normalIndices.Count();
+	int nTexcoordCount = texcoordIndices.Count();
+	int nBalanceCount = balanceIndices.Count();
+	int nSpeedCount = speedIndices.Count();
+	if ( nNormalCount && nPositionCount != nNormalCount )
+	{
+		MdlError( "Encountered a mesh with invalid geometry (different number of indices for various data fields)\n" );
+		return false;
+	}
+	if ( nTexcoordCount && nPositionCount != nTexcoordCount )
+	{
+		MdlError( "Encountered a mesh with invalid geometry (different number of indices for various data fields)\n" );
+		return false;
+	}
+	if ( nBalanceCount && nPositionCount != nBalanceCount )
+	{
+		MdlError( "Encountered a mesh with invalid geometry (different number of indices for various data fields)\n" );
+		return false;
+	}
+	if ( nSpeedCount && nPositionCount != nSpeedCount )
+	{
+		MdlError( "Encountered a mesh with invalid geometry (different number of indices for various data fields)\n" );
+		return false;
+	}
+
+	// Only add unique vertices to the list as in UnifyIndices
+
+	for ( int i = 0; i < nPositionCount; ++i )
+	{
+		VertIndices_t vert;
+		vert.v = g_numverts + positionIndices[i]; 
+		vert.n = ( nNormalCount > 0 ) ? g_numnormals + normalIndices[i] : -1; 
+		vert.t = ( nTexcoordCount > 0 ) ? g_numtexcoords + texcoordIndices[i] : -1; 
+		vert.balance = s_Balance.Count() + ( ( nBalanceCount > 0 ) ? balanceIndices[i] : 0 ); 
+		vert.speed = s_Speed.Count() + ( ( nSpeedCount > 0 ) ? speedIndices[i] : 0 );
+
+		bool unique( true );
+		for ( int j = nStartingUniqueCount; j < s_UniqueVertices.Count(); ++j )
+		{
+			const VertIndices_t &tmpVert( s_UniqueVertices[j] );
+
+			if ( vert.v != tmpVert.v )
+				continue;
+			if ( vert.n != tmpVert.n )
+				continue;
+			if ( vert.t != tmpVert.t )
+				continue;
+
+			unique = false;
+			s_UniqueVerticesMap.AddToTail( j );
+			break;
+		}
+
+		if ( !unique )
+			continue;
+
+		int k = s_UniqueVertices.AddToTail();
+		s_UniqueVertices[k] = vert;
+		s_UniqueVerticesMap.AddToTail( k );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the vertices from the model
+//-----------------------------------------------------------------------------
+static bool LoadVertices( CDmeVertexData *pBindState, const matrix3x4_t& mat, float flScale, int nBoneAssign, int *pBoneRemap, int nStartingUniqueCount )
+{
+	if ( nBoneAssign < 0 )
+	{
+		nBoneAssign = s_nDefaultRootNode;
+	}
+
+	// Used by the morphing system to set up delta states
+	DefineUniqueVertices( pBindState, nStartingUniqueCount );
+
+	matrix3x4_t normalMat;
+	MatrixInverseTranspose( mat, normalMat );
+
+	const CUtlVector<Vector> &positions = pBindState->GetPositionData( );
+	const CUtlVector<Vector> &normals = pBindState->GetNormalData( );
+	const CUtlVector<Vector2D> &texcoords = pBindState->GetTextureCoordData( );
+	const CUtlVector<float> &balances = pBindState->GetBalanceData( );
+	const CUtlVector<float> &speeds = pBindState->GetMorphSpeedData( );
+
+	int nCount = positions.Count();
+	int nJointCount = pBindState->HasSkinningData() ? pBindState->JointCount() : 0;
+	if ( nJointCount > MAXSTUDIOBONEWEIGHTS )
+	{
+		MdlError( "Too many bone influences per vertex!\n" );
+		return false;
+	}
+
+	// Copy positions + bone info
+	for ( int i = 0; i < nCount; ++i )
+	{
+		// NOTE: The transform transforms the positions into the bind space
+		VectorTransform( positions[i], mat, g_vertex[g_numverts] );
+		g_vertex[g_numverts] *= flScale;
+		if ( nJointCount == 0 )
+		{
+			g_bone[g_numverts].numbones = 1;
+			g_bone[g_numverts].bone[0] = pBoneRemap[ nBoneAssign ];
+			g_bone[g_numverts].weight[0] = 1.0;
+		}
+		else
+		{
+			const float *pJointWeights = pBindState->GetJointWeightData( i );
+			const int *pJointIndices = pBindState->GetJointIndexData( i );
+
+			float *pWeightBuf = (float*)_alloca( nJointCount * sizeof(float) );
+			int *pIndexBuf = (int*)_alloca( nJointCount * sizeof(int) );
+			memcpy( pWeightBuf, pJointWeights, nJointCount * sizeof(float) );
+			memcpy( pIndexBuf, pJointIndices, nJointCount * sizeof(int) );
+
+			int nBoneCount = SortAndBalanceBones( nJointCount, MAXSTUDIOBONEWEIGHTS, pIndexBuf, pWeightBuf );
+
+			g_bone[g_numverts].numbones = nBoneCount;
+			for ( int j = 0; j < nBoneCount; ++j )
+			{
+				g_bone[g_numverts].bone[j] = pBoneRemap[ pIndexBuf[j] ];
+				g_bone[g_numverts].weight[j] = pWeightBuf[j];
+			}
+		}
+		++g_numverts;
+	}
+
+	// Copy normals
+	nCount = normals.Count();
+	if ( nCount + g_numnormals > MAXSTUDIOVERTS )
+	{
+		MdlError( "Too many normals in model!\n" );
+		return false;
+	}
+	for ( int i = 0; i < nCount; ++i )
+	{
+		VectorRotate( normals[i], normalMat, g_normal[g_numnormals] );
+		VectorNormalize( g_normal[g_numnormals] );
+		++g_numnormals;
+	}
+
+	// Copy texcoords
+	nCount = texcoords.Count();
+	if ( nCount + g_numtexcoords > MAXSTUDIOVERTS )
+	{
+		MdlError( "Too many texture coordinates in model!\n" );
+		return false;
+	}
+	bool bFlipVCoordinate = pBindState->IsVCoordinateFlipped();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		g_texcoord[g_numtexcoords].x = texcoords[i].x;
+		g_texcoord[g_numtexcoords].y = bFlipVCoordinate ? 1.0f - texcoords[i].y : texcoords[i].y;
+		++g_numtexcoords;
+	}
+
+	// In the event of no speed or balance map, use the same value of 1 for all vertices
+	if ( balances.Count() )
+	{
+		s_Balance.AddMultipleToTail( balances.Count(), balances.Base() );
+	}
+	else
+	{
+		s_Balance.AddToTail( 1.0f );
+	}
+
+	if ( speeds.Count() )
+	{
+		s_Speed.AddMultipleToTail( speeds.Count(), speeds.Base() );
+	}
+	else
+	{
+		s_Speed.AddToTail( 1.0f );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Hook delta into delta list
+//-----------------------------------------------------------------------------
+static void AddToDeltaList( DeltaState_t *pDeltaStateData, int nUniqueVertex )
+{
+	DeltaIndex_t &index = pDeltaStateData->m_DeltaIndices[ nUniqueVertex ];
+	if ( !index.m_bInList )
+	{
+		index.m_nNextDelta = pDeltaStateData->m_nFirstDelta;
+		pDeltaStateData->m_nFirstDelta = nUniqueVertex;
+		pDeltaStateData->m_nDeltaCount++;
+		index.m_bInList = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the vertices from the delta state
+//-----------------------------------------------------------------------------
+
+static bool LoadDeltaState(
+	CDmeVertexDeltaData *pDeltaState,
+	CDmeVertexData *pBindState,
+	const matrix3x4_t& mat,
+	float flScale,
+	int nStartingUniqueVertex,
+	int nStartingUniqueVertexMap )
+{
+	DeltaState_t *pDeltaStateData = FindOrAddDeltaState( pDeltaState->GetName(), nStartingUniqueVertex + pBindState->VertexCount() );
+
+	matrix3x4_t normalMat;
+	MatrixInverseTranspose( mat, normalMat );
+
+	const CUtlVector<Vector> &positions = pDeltaState->GetPositionData( );
+	const CUtlVector<int> &positionIndices = pDeltaState->GetVertexIndexData( CDmeVertexDataBase::FIELD_POSITION );
+	const CUtlVector<Vector> &normals = pDeltaState->GetNormalData( );
+	const CUtlVector<int> &normalIndices = pDeltaState->GetVertexIndexData( CDmeVertexDataBase::FIELD_NORMAL );
+	const CUtlVector<float> &wrinkle = pDeltaState->GetWrinkleData( );
+	const CUtlVector<int> &wrinkleIndices = pDeltaState->GetVertexIndexData( CDmeVertexDataBase::FIELD_WRINKLE );
+
+	if ( positions.Count() != positionIndices.Count() )
+	{
+		MdlError( "DeltaState %s contains a different number of positions + position indices!\n", pDeltaState->GetName() );
+		return false;
+	}
+
+	if ( normals.Count() != normalIndices.Count() )
+	{
+		MdlError( "DeltaState %s contains a different number of normals + normal indices!\n", pDeltaState->GetName() );
+		return false;
+	}
+
+	if ( wrinkle.Count() != wrinkleIndices.Count() )
+	{
+		MdlError( "DeltaState %s contains a different number of wrinkles + wrinkle indices!\n", pDeltaState->GetName() );
+		return false;
+	}
+
+	// Copy position delta
+	int nCount = positions.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		Vector vecDelta;
+
+		// NOTE NOTE!!: This is VectorRotate, *not* VectorTransform. This is because
+		// we're transforming a delta, which is basically a direction vector. To
+		// move it into the new space, we must rotate it
+		VectorRotate( positions[i], mat, vecDelta );
+		vecDelta *= flScale;
+
+		int nPositionIndex = pDeltaStateData->m_PositionDeltas.AddToTail( vecDelta );
+
+		// Indices 
+		const CUtlVector< int > &baseVerts = pBindState->FindVertexIndicesFromDataIndex( CDmeVertexData::FIELD_POSITION, positionIndices[i] );
+		int nBaseVertCount = baseVerts.Count();
+		for ( int k = 0; k < nBaseVertCount; ++k )
+		{
+			int nUniqueVertexIndex = s_UniqueVerticesMap[ nStartingUniqueVertexMap + baseVerts[k] ];
+			AddToDeltaList( pDeltaStateData, nUniqueVertexIndex );
+			DeltaIndex_t &index = pDeltaStateData->m_DeltaIndices[ nUniqueVertexIndex ];
+			index.m_nPositionIndex = nPositionIndex;
+		}
+	}
+
+	// Copy normals
+	nCount = normals.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		Vector vecDelta;
+		VectorRotate( normals[i], normalMat, vecDelta );
+		int nNormalIndex = pDeltaStateData->m_NormalDeltas.AddToTail( vecDelta );
+
+		// Indices 
+		const CUtlVector< int > &baseVerts = pBindState->FindVertexIndicesFromDataIndex( CDmeVertexData::FIELD_NORMAL, normalIndices[i] );
+		int nBaseVertCount = baseVerts.Count();
+		for ( int k = 0; k < nBaseVertCount; ++k )
+		{
+			int nUniqueVertexIndex = s_UniqueVerticesMap[ nStartingUniqueVertexMap + baseVerts[k] ];
+			AddToDeltaList( pDeltaStateData, nUniqueVertexIndex );
+			DeltaIndex_t &index = pDeltaStateData->m_DeltaIndices[ nUniqueVertexIndex ];
+			index.m_nNormalIndex = nNormalIndex;
+		}
+	}
+
+	// Copy wrinkle
+	nCount = wrinkle.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		int nWrinkleIndex = pDeltaStateData->m_WrinkleDeltas.AddToTail( wrinkle[i] );
+
+		// Indices 
+		const CUtlVector< int > &baseVerts = pBindState->FindVertexIndicesFromDataIndex( CDmeVertexData::FIELD_WRINKLE, wrinkleIndices[i] );
+		int nBaseVertCount = baseVerts.Count();
+		for ( int k = 0; k < nBaseVertCount; ++k )
+		{
+			int nUniqueVertexIndex = s_UniqueVerticesMap[ nStartingUniqueVertexMap + baseVerts[k] ];
+			AddToDeltaList( pDeltaStateData, nUniqueVertexIndex );
+			DeltaIndex_t &index = pDeltaStateData->m_DeltaIndices[ nUniqueVertexIndex ];
+			index.m_nWrinkleIndex = nWrinkleIndex;
+		}
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Reads the face data from the DMX data
+//-----------------------------------------------------------------------------
+static void ParseFaceData( CDmeVertexData *pVertexData, int material, int v1, int v2, int v3, int vi, int ni, int ti )
+{
+	s_tmpface_t f;
+	f.material = material;
+
+	int p, n, t;
+	p = pVertexData->GetPositionIndex(v1); n = pVertexData->GetNormalIndex(v1); t = pVertexData->GetTexCoordIndex(v1);
+	f.a = ( p >= 0 ) ? vi + p : 0; f.na = ( n >= 0 ) ? ni + n : 0; f.ta = ( t >= 0 ) ? ti + t : 0;
+	p = pVertexData->GetPositionIndex(v2); n = pVertexData->GetNormalIndex(v2); t = pVertexData->GetTexCoordIndex(v2);
+	f.b = ( p >= 0 ) ? vi + p : 0; f.nb = ( n >= 0 ) ? ni + n : 0; f.tb = ( t >= 0 ) ? ti + t : 0;
+	p = pVertexData->GetPositionIndex(v3); n = pVertexData->GetNormalIndex(v3); t = pVertexData->GetTexCoordIndex(v3);
+	f.c = ( p >= 0 ) ? vi + p : 0; f.nc = ( n >= 0 ) ? ni + n : 0; f.tc = ( t >= 0 ) ? ti + t : 0;
+
+	Assert( f.a <= (unsigned long)g_numverts && f.b <= (unsigned long)g_numverts && f.c <= (unsigned long)g_numverts );
+	Assert( f.na <= (unsigned long)g_numnormals && f.nb <= (unsigned long)g_numnormals && f.nc <= (unsigned long)g_numnormals );
+	Assert( f.ta <= (unsigned long)g_numtexcoords && f.tb <= (unsigned long)g_numtexcoords && f.tc <= (unsigned long)g_numtexcoords );
+
+	Assert( g_numfaces < MAXSTUDIOTRIANGLES-1 );
+	if ( g_numfaces >= MAXSTUDIOTRIANGLES-1 )
+		return;
+
+	int i = g_numfaces++;
+	g_face[i] = f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Reads the mesh data from the DMX data
+//-----------------------------------------------------------------------------
+static bool LoadMesh( CDmeMesh *pMesh, CDmeVertexData *pBindState, const matrix3x4_t& mat, float flScale, 
+	int nBoneAssign, int *pBoneRemap, s_source_t *pSource )
+{
+	pMesh->CollapseRedundantNormals( normal_blend );
+
+	// Load the vertices
+	int nStartingVertex = g_numverts;
+	int nStartingNormal = g_numnormals;
+	int nStartingTexCoord = g_numtexcoords;
+	int nStartingUniqueCount = s_UniqueVertices.Count();
+	int nStartingUniqueMapCount = s_UniqueVerticesMap.Count();
+
+	// This defines s_UniqueVertices & s_UniqueVerticesMap
+	LoadVertices( pBindState, mat, flScale, nBoneAssign, pBoneRemap, nStartingUniqueCount );
+
+	// Load the deltas
+	int nDeltaStateCount = pMesh->DeltaStateCount();
+	for ( int i = 0; i < nDeltaStateCount; ++i )
+	{
+		CDmeVertexDeltaData *pDeltaState = pMesh->GetDeltaState( i );
+		if ( !LoadDeltaState( pDeltaState, pBindState, mat, flScale, nStartingUniqueCount, nStartingUniqueMapCount ) )
+			return false;
+	}
+
+	// load the base triangles
+	int texture;
+	int material;
+	char pTextureName[MAX_PATH];
+
+	int nFaceSetCount = pMesh->FaceSetCount();
+	for ( int i = 0; i < nFaceSetCount; ++i )
+	{
+		CDmeFaceSet *pFaceSet = pMesh->GetFaceSet( i );
+		CDmeMaterial *pMaterial = pFaceSet->GetMaterial();
+
+		// Get the material name
+		Q_strncpy( pTextureName, pMaterial->GetMaterialName(), sizeof(pTextureName) );
+
+		// funky texture overrides (specified with the -t command-line argument) 
+		for ( int j = 0; j < numrep; j++ )  
+		{
+			if ( sourcetexture[j][0] == '\0' ) 
+			{
+				Q_strncpy( pTextureName, defaulttexture[j], sizeof(pTextureName) );
+				break;
+			}
+			if ( Q_stricmp( pTextureName, sourcetexture[j]) == 0 ) 
+			{
+				Q_strncpy( pTextureName, defaulttexture[j], sizeof(pTextureName) );
+				break;
+			}
+		}
+
+		// skip all faces with the null texture on them.
+		char pPathNoExt[MAX_PATH];
+		Q_StripExtension( pTextureName, pPathNoExt, sizeof(pPathNoExt) );
+		if ( !Q_stricmp( pPathNoExt, "null" ) )
+			continue;
+
+		texture = LookupTexture( pTextureName, true );
+		pSource->texmap[texture] = texture;	// hack, make it 1:1
+		material = UseTextureAsMaterial( texture );
+
+		// prepare indices
+		int nFirstIndex = 0;
+		int nIndexCount = pFaceSet->NumIndices();
+		while ( nFirstIndex < nIndexCount )
+		{
+			int nVertexCount = pFaceSet->GetNextPolygonVertexCount( nFirstIndex );
+			if ( nVertexCount >= 3 )
+			{
+				int nOutCount = (nVertexCount-2) * 3;
+				int *pIndices = (int*)_alloca( nOutCount * sizeof(int)	);
+				pMesh->ComputeTriangulatedIndices( pBindState, pFaceSet, nFirstIndex, pIndices, nOutCount );
+				for ( int ii = 0; ii < nOutCount; ii +=3 )
+				{
+					ParseFaceData( pBindState, material, pIndices[ii], pIndices[ii+2], pIndices[ii+1], nStartingVertex, nStartingNormal, nStartingTexCoord );
+				}
+			}
+			nFirstIndex += nVertexCount + 1;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Method used to add mesh data
+//-----------------------------------------------------------------------------
+struct LoadMeshInfo_t
+{
+	s_source_t *m_pSource;
+	CDmeModel *m_pModel;
+	float m_flScale;
+	int *m_pBoneRemap;
+	matrix3x4_t m_pBindPose[MAXSTUDIOSRCBONES];
+};
+
+static bool LoadMeshes( const LoadMeshInfo_t &info, CDmeDag *pDag, const matrix3x4_t &parentToBindPose, int nBoneAssign )
+{
+	// We want to create an aggregate matrix transforming from this dag to its closest
+	// parent which actually is an animated joint. This is done so we can autoskin
+	// meshes to their closest parents if they have not been skinned.
+	matrix3x4_t dagToBindPose;
+	CDmeTransform *pDagTransform = pDag->GetTransform();
+	int nFoundIndex = info.m_pModel->GetJointTransformIndex( pDagTransform );
+
+	// Update autoskin to autoskin to non-DmeJoint's if they are children of the DmeModel (i.e. they have no parent bone)
+	if ( nFoundIndex >= 0 )
+	{
+		if ( pDag == info.m_pModel || CastElement< CDmeJoint >( pDag ) )
+		{
+			nBoneAssign = nFoundIndex;
+		}
+		else
+		{
+			for ( int i = 0; i < info.m_pModel->GetChildCount(); ++i )
+			{
+				if ( info.m_pModel->GetChild( i ) == pDag )
+				{
+					nBoneAssign = nFoundIndex;
+					break;
+				}
+			}
+		}
+	}
+
+	if ( nFoundIndex >= 0 )
+	{
+		ConcatTransforms( parentToBindPose, info.m_pBindPose[nFoundIndex], dagToBindPose );
+	}
+	else
+	{
+		// NOTE: This isn't particularly kosher; we're using the current pose instead of the bind pose
+		// because there's no transform in the bind pose
+		matrix3x4_t dagToParent;
+		pDagTransform->GetTransform( dagToParent );
+		ConcatTransforms( parentToBindPose, dagToParent, dagToBindPose );
+	}
+
+	CDmeMesh *pMesh = CastElement< CDmeMesh >( pDag->GetShape() );
+	if ( pMesh )
+	{
+		CDmeVertexData *pBindState = pMesh->FindBaseState( "bind" );
+		if ( !pBindState )
+			return false;
+
+		if ( !LoadMesh( pMesh, pBindState, dagToBindPose, info.m_flScale, nBoneAssign, info.m_pBoneRemap, info.m_pSource ) )
+			return false;
+	}
+
+	int nCount = pDag->GetChildCount();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		CDmeDag *pChild = pDag->GetChild( i );
+		if ( !LoadMeshes( info, pChild, dagToBindPose, nBoneAssign ) )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Method used to add mesh data
+//-----------------------------------------------------------------------------
+static bool LoadMeshes( CDmeModel *pModel, float flScale, int *pBoneRemap, s_source_t *pSource )
+{
+	matrix3x4_t mat;
+	SetIdentityMatrix( mat );
+
+	LoadMeshInfo_t info;
+	info.m_pModel = pModel;
+	info.m_flScale = flScale;
+	info.m_pBoneRemap = pBoneRemap;
+	info.m_pSource = pSource;
+
+	CDmeTransformList *pBindPose = pModel->FindBaseState( "bind" );
+	int nCount = pBindPose ? pBindPose->GetTransformCount() : pModel->GetJointTransformCount();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		CDmeTransform *pTransform = pBindPose ? pBindPose->GetTransform(i) : pModel->GetJointTransform(i);
+
+		matrix3x4_t jointTransform;
+		pTransform->GetTransform( info.m_pBindPose[i] );
+	}
+
+	int nChildCount = pModel->GetChildCount();
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		CDmeDag *pChild = pModel->GetChild( i );
+		if ( !LoadMeshes( info, pChild, mat, -1 ) )
+			return false;
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Builds s_vertanim_ts 
+//-----------------------------------------------------------------------------
+static void BuildVertexAnimations( s_source_t *pSource )
+{
+	int nCount = s_DeltaStates.Count();
+	if ( nCount == 0 )
+		return;
+
+	Assert( s_Speed.Count() > 0 );
+	Assert( s_Balance.Count() > 0 );
+
+	Assert( s_UniqueVertices.Count() == numvlist );
+	s_vertanim_t *pVertAnim = (s_vertanim_t *)_alloca( numvlist * sizeof( s_vertanim_t ) );
+	for ( int i = 0; i < nCount; ++i )
+	{
+		DeltaState_t &state = s_DeltaStates[i];
+
+		s_sourceanim_t *pSourceAnim = FindOrAddSourceAnim( pSource, state.m_Name );
+		pSourceAnim->numframes = 1;
+		pSourceAnim->startframe = 0;
+		pSourceAnim->endframe = 0;
+		pSourceAnim->newStyleVertexAnimations = true;
+
+		// Traverse the linked list of unique vertex indices j that has a delta
+		int nVertAnimCount = 0;
+		for ( int j = state.m_nFirstDelta; j >= 0; j = state.m_DeltaIndices[j].m_nNextDelta )
+		{
+			// The Delta Indices array is a parallel array to s_UniqueVertices
+			// j is used to index into both
+			DeltaIndex_t &delta = state.m_DeltaIndices[j];
+			Assert( delta.m_nPositionIndex >= 0 || delta.m_nNormalIndex >= 0 || delta.m_nWrinkleIndex >= 0 );
+
+			VertIndices_t &uniqueVert = s_UniqueVertices[j];
+
+			const v_unify_t *pList = v_list[uniqueVert.v];
+			for( ; pList; pList = pList->next )
+			{
+				if ( pList->n != uniqueVert.n || pList->t != uniqueVert.t )
+					continue;
+				
+				s_vertanim_t& vertanim = pVertAnim[nVertAnimCount++];
+				vertanim.vertex = pList - v_listdata;
+				vertanim.speed = s_Speed[ s_UniqueVertices[j].speed ];
+				vertanim.side = s_Balance[ s_UniqueVertices[j].balance ];
+				if ( delta.m_nPositionIndex >= 0 )
+				{
+					vertanim.pos = state.m_PositionDeltas[ delta.m_nPositionIndex ];
+				}
+				else
+				{
+					vertanim.pos = vec3_origin;
+				}
+				if ( delta.m_nNormalIndex >= 0 )
+				{
+					vertanim.normal = state.m_NormalDeltas[ delta.m_nNormalIndex ];
+				}
+				else
+				{
+					vertanim.normal = vec3_origin;
+				}
+
+				if ( delta.m_nWrinkleIndex >= 0 )
+				{
+					vertanim.wrinkle = state.m_WrinkleDeltas[ delta.m_nWrinkleIndex ];
+				}
+				else
+				{
+					vertanim.wrinkle = 0.0f;
+				}
+			}
+		}
+		pSourceAnim->numvanims[0] = nVertAnimCount;
+		pSourceAnim->vanim[0] = (s_vertanim_t *)kalloc( nVertAnimCount, sizeof( s_vertanim_t ) );
+		memcpy( pSourceAnim->vanim[0], pVertAnim, nVertAnimCount * sizeof( s_vertanim_t ) );
+	}
+}
+
+	
+//-----------------------------------------------------------------------------
+// Loads the skeletal hierarchy from the game model, returns bone count
+//-----------------------------------------------------------------------------
+static bool AddDagJoint( CDmeModel *pModel, CDmeDag *pDag, s_node_t *pNodes, int nParentIndex, BoneTransformMap_t &boneMap )
+{
+	CDmeTransform *pDmeTransform = pDag->GetTransform();
+	const char *pTransformName = pDmeTransform->GetName();
+	int nJointIndex = boneMap.m_nBoneCount++;
+	if ( nJointIndex >= MAXSTUDIOSRCBONES )
+	{
+		MdlWarning( "DMX Model has too many bones [%d, max can be %d]!\n", boneMap.m_nBoneCount, MAXSTUDIOSRCBONES );
+		return false;
+	}
+	
+	boneMap.m_ppTransforms[ nJointIndex ] = pDmeTransform;
+	int nFoundIndex = 0;
+	if ( pModel )
+	{
+		nFoundIndex = pModel->GetJointTransformIndex( pDmeTransform );
+		if ( nFoundIndex >= 0 )
+		{
+			boneMap.m_pBoneRemap[nFoundIndex] = nJointIndex;
+		}
+	}
+
+	Q_strncpy( pNodes[ nJointIndex ].name, pTransformName, sizeof( pNodes[ nJointIndex ].name ) );
+	pNodes[ nJointIndex ].parent = nParentIndex;
+
+	// Now deal with children
+	int nChildCount = pDag->GetChildCount();
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		CDmeDag *pChild = pDag->GetChild( i );
+		if ( !pChild )
+			continue;
+
+		int nCurrentBoneCount = boneMap.m_nBoneCount;
+		if ( !AddDagJoint( pModel, pChild, pNodes, nJointIndex, boneMap ) )
+			return false;
+
+		if ( ( nCurrentBoneCount != boneMap.m_nBoneCount ) && ( nFoundIndex < 0 ) )
+		{
+			MdlWarning( "DMX Model has a joint \"%s\" which is not in its joint transform list.\n"
+				"This joint has children which are in the joint transform list, which is illegal.\n",
+				pDag->GetName() );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Main entry point for loading the skeleton
+//-----------------------------------------------------------------------------
+static int LoadSkeleton( CDmeDag *pRoot, CDmeModel *pModel, s_node_t *pNodes, BoneTransformMap_t &map )
+{
+	// Initialize bone indices
+	map.m_nBoneCount = 0;
+	for ( int i = 0; i < MAXSTUDIOSRCBONES; ++i )
+	{
+		pNodes[i].name[0] = 0;
+		pNodes[i].parent = -1;
+		map.m_pBoneRemap[i] = -1;
+		map.m_ppTransforms[i] = NULL;
+	}
+
+	// Don't create joints for the the root dag ever.. just deal with the children
+	int nChildCount = pRoot->GetChildCount();
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		CDmeDag *pChild = pRoot->GetChild( i );
+		if ( !pChild )
+			continue;
+
+		if ( !AddDagJoint( pModel, pChild, pNodes, -1, map ) )
+			return 0;
+	}
+
+	// Add a default identity bone used for autoskinning if no joints are specified
+	s_nDefaultRootNode = map.m_nBoneCount;
+	Q_strncpy( pNodes[s_nDefaultRootNode].name, "defaultRoot", sizeof( pNodes[ s_nDefaultRootNode ].name ) );
+	pNodes[s_nDefaultRootNode].parent = -1;
+
+	if ( !pModel )
+		return map.m_nBoneCount + 1;
+
+	// Look for joints listed in the transform list which aren't in the hierarchy
+	int nInitialBoneCount = pModel->GetJointTransformCount();
+	for ( int i = 0; i < nInitialBoneCount; ++i )
+	{
+		int nIndex = map.m_pBoneRemap[i];
+		if ( nIndex < 0 )
+		{
+			map.m_pBoneRemap[i] = map.m_nBoneCount++;
+			nIndex = map.m_pBoneRemap[i];
+		}
+		if ( pNodes[nIndex].name[0] == 0 )
+		{
+			CDmeTransform *pTransform = pModel->GetJointTransform( i );
+			Q_strncpy( pNodes[ nIndex ].name, pTransform->GetName(), sizeof( pNodes[ nIndex ].name ) );
+			MdlWarning( "Joint %s specified in the joint transform list but doesn't appear in the dag hierarchy!\n", pTransform->GetName() );
+		}
+	}
+	return map.m_nBoneCount + 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the skeletal hierarchy from the game model, returns bone count
+//-----------------------------------------------------------------------------
+static void LoadAttachments( CDmeDag *pRoot, CDmeDag *pDag, s_source_t *pSource )
+{
+	CDmeAttachment *pAttachment = CastElement< CDmeAttachment >( pDag->GetShape() );
+	if ( pAttachment && ( pDag != pRoot ) )
+	{
+		int i = pSource->m_Attachments.AddToTail();
+		s_attachment_t &attachment = pSource->m_Attachments[i];
+		memset( &attachment, 0, sizeof(s_attachment_t) );
+		Q_strncpy( attachment.name, pAttachment->GetName(), sizeof( attachment.name ) );
+		Q_strncpy( attachment.bonename, pDag->GetName(), sizeof( attachment.bonename ) );
+		SetIdentityMatrix( attachment.local );
+		if ( pAttachment->m_bIsRigid )
+		{
+			attachment.type |= IS_RIGID;
+		}
+		if ( pAttachment->m_bIsWorldAligned )
+		{
+			attachment.flags |= ATTACHMENT_FLAG_WORLD_ALIGN;
+		}
+	}
+
+	// Don't create joints for the the root dag ever.. just deal with the children
+	int nChildCount = pDag->GetChildCount();
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		CDmeDag *pChild = pDag->GetChild( i );
+		if ( !pChild )
+			continue;
+
+		LoadAttachments( pRoot, pChild, pSource );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the bind pose
+//-----------------------------------------------------------------------------
+static void LoadBindPose( CDmeModel *pModel, float flScale, int *pBoneRemap, s_source_t *pSource )
+{
+	s_sourceanim_t *pSourceAnim = FindOrAddSourceAnim( pSource, "BindPose" );
+	pSourceAnim->startframe = 0;
+	pSourceAnim->endframe = 0;
+	pSourceAnim->numframes = 1;
+
+	// Default all transforms to identity
+	pSourceAnim->rawanim[0] = (s_bone_t *)kalloc( pSource->numbones, sizeof(s_bone_t) );
+	for ( int i = 0; i < pSource->numbones; ++i )
+	{
+		pSourceAnim->rawanim[0][i].pos.Init();
+		pSourceAnim->rawanim[0][i].rot.Init();
+	}							 
+	 
+	// Override those bones in the bind pose with the real values
+	// NOTE: This means that bones that are not in the bind pose are set to identity!
+	// Is this correct? I think it shouldn't matter, but we may need to fix this.
+	CDmeTransformList *pBindPose = pModel->FindBaseState( "bind" );
+	int nCount = pBindPose ? pBindPose->GetTransformCount() : pModel->GetJointTransformCount();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		CDmeTransform *pTransform = pBindPose ? pBindPose->GetTransform(i) : pModel->GetJointTransform(i);
+
+		matrix3x4_t jointTransform;
+		pTransform->GetTransform( jointTransform );
+
+		int nActualBoneIndex = pBoneRemap[i]; 
+		s_bone_t &bone = pSourceAnim->rawanim[0][nActualBoneIndex];
+		MatrixAngles( jointTransform, bone.rot, bone.pos );
+		bone.pos *= flScale;
+	}
+
+	Build_Reference( pSource, "BindPose" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Main entry point for loading DMX files
+//-----------------------------------------------------------------------------
+static void PrepareChannels( CDmeChannelsClip *pAnimation ) 
+{
+	int nChannelsCount = pAnimation->m_Channels.Count();
+	for ( int i = 0; i < nChannelsCount; ++i )
+	{
+		pAnimation->m_Channels[i]->SetMode( CM_PLAY );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Update channels so they are in position for the next frame
+//-----------------------------------------------------------------------------
+static void UpdateChannels( CDmeChannelsClip *pAnimation, DmeTime_t clipTime ) 
+{
+	int nChannelsCount = pAnimation->m_Channels.Count();
+	DmeTime_t channelTime = pAnimation->ToChildMediaTime( clipTime );
+	CUtlVector< IDmeOperator* > operators( 0, nChannelsCount );
+	for ( int i = 0; i < nChannelsCount; ++i )
+	{
+		pAnimation->m_Channels[i]->SetCurrentTime( channelTime );
+		operators.AddToTail( pAnimation->m_Channels[i] );
+	}
+
+	// Recompute the position of the joints
+	{
+		CDisableUndoScopeGuard guard;
+		g_pDmElementFramework->SetOperators( operators );
+		g_pDmElementFramework->Operate( true );
+	}
+	g_pDmElementFramework->BeginEdit();
+}
+
+
+//-----------------------------------------------------------------------------
+// Initialize the pose for this frame
+//-----------------------------------------------------------------------------
+static void ComputeFramePose( s_sourceanim_t *pSourceAnim, int nFrame, float flScale, BoneTransformMap_t& boneMap ) 
+{
+	pSourceAnim->rawanim[nFrame] = (s_bone_t *)kalloc( boneMap.m_nBoneCount, sizeof( s_bone_t ) );
+
+	for ( int i = 0; i < boneMap.m_nBoneCount; ++i )
+	{
+		matrix3x4_t jointTransform;
+		boneMap.m_ppTransforms[i]->GetTransform( jointTransform );
+		MatrixAngles( jointTransform, pSourceAnim->rawanim[nFrame][i].rot, pSourceAnim->rawanim[nFrame][i].pos );
+		pSourceAnim->rawanim[nFrame][i].pos *= flScale;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Main entry point for loading animations
+//-----------------------------------------------------------------------------
+static void LoadAnimations( s_source_t *pSource, CDmeAnimationList *pAnimationList, float flScale, BoneTransformMap_t &boneMap )
+{
+	int nAnimationCount = pAnimationList->GetAnimationCount();
+	for ( int i = 0; i < nAnimationCount; ++i )
+	{
+		CDmeChannelsClip *pAnimation = pAnimationList->GetAnimation( i );
+
+		if ( !Q_stricmp( pAnimationList->GetName(), "BindPose" ) )
+		{
+			MdlError( "Error: Cannot use \"BindPose\" as an animation name!\n" );
+			break;
+		}
+
+		s_sourceanim_t *pSourceAnim = FindOrAddSourceAnim( pSource, pAnimation->GetName() );
+
+		DmeTime_t nStartTime = pAnimation->GetStartTime();
+		DmeTime_t nEndTime = pAnimation->GetEndTime();
+		int nFrameRateVal = pAnimation->GetValue<int>( "frameRate" );
+		if ( nFrameRateVal <= 0 )
+		{
+			nFrameRateVal = 30;
+		}
+		DmeFramerate_t nFrameRate = nFrameRateVal;
+		pSourceAnim->startframe = nStartTime.CurrentFrame( nFrameRate );
+		pSourceAnim->endframe = nEndTime.CurrentFrame( nFrameRate );
+		pSourceAnim->numframes = pSourceAnim->endframe - pSourceAnim->startframe + 1;
+
+		// Prepare channels for playback
+		PrepareChannels( pAnimation );
+
+		float flOOFrameRate = 1.0f / (float)nFrameRateVal;
+		DmeTime_t nTime = nStartTime;
+		int nFrame = 0;
+		while ( nFrame < pSourceAnim->numframes )
+		{
+			int nSecond = nFrame / nFrameRateVal;
+			int nFraction = nFrame - nSecond * nFrameRateVal;
+			DmeTime_t t = nStartTime + DmeTime_t( nSecond * 10000 ) + DmeTime_t( (float)nFraction * flOOFrameRate );
+
+			// Update the current time
+			UpdateChannels( pAnimation, t );
+
+			// Initialize the pose for this frame
+			ComputeFramePose( pSourceAnim, nFrame, flScale, boneMap );
+
+			++nFrame;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads the skeletal hierarchy from the game model, returns bone count
+//-----------------------------------------------------------------------------
+static void AddFlexKeys( CDmeDag *pRoot, CDmeDag *pDag, CDmeCombinationOperator *pComboOp, s_source_t *pSource )
+{
+	CDmeMesh *pMesh = CastElement< CDmeMesh >( pDag->GetShape() );
+	if ( pMesh && ( pDag != pRoot ) )
+	{
+		int nDeltaStateCount = pMesh->DeltaStateCount();
+		for ( int i = 0; i < nDeltaStateCount; ++i )
+		{
+			CDmeVertexDeltaData *pDeltaState = pMesh->GetDeltaState( i );
+			AddFlexKey( pSource, pComboOp, pDeltaState->GetName() );
+		}
+	}
+
+	// Don't create joints for the the root dag ever.. just deal with the children
+	int nChildCount = pDag->GetChildCount();
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		CDmeDag *pChild = pDag->GetChild( i );
+		if ( !pChild )
+			continue;
+
+		AddFlexKeys( pRoot, pChild, pComboOp, pSource );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Loads all auxilliary model info:
+//
+//	*	Determine original source files used to generate
+//		the current DMX file and schedule them for processing.
+//-----------------------------------------------------------------------------
+void LoadModelInfo( CDmElement *pRoot, char const *pFullPath )
+{
+	// Determine original source files and schedule them for processing
+	if ( CDmElement *pMakeFile = pRoot->GetValueElement< CDmElement >( "makefile" ) )
+	{
+		if ( CDmAttribute *pSources = pMakeFile->GetAttribute( "sources" ) )
+		{
+			CDmrElementArray< CDmElement > arrSources( pSources );
+			for ( int kk = 0; kk < arrSources.Count(); ++ kk )
+			{
+				if ( CDmElement *pModelSource = arrSources.Element( kk ) )
+				{
+					if ( char const *szName = pModelSource->GetName() )
+					{
+						ProcessOriginalContentFile( pFullPath, szName );
+					}
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Main entry point for loading DMX files
+//-----------------------------------------------------------------------------
+int Load_DMX( s_source_t *pSource )
+{
+	DmFileId_t fileId;
+	s_DeltaStates.RemoveAll();
+	s_Balance.RemoveAll();
+	s_Speed.RemoveAll();
+	s_UniqueVertices.RemoveAll();
+	s_UniqueVerticesMap.RemoveAll();
+
+	// use the full search tree, including mod hierarchy to find the file
+	char pFullPath[MAX_PATH];
+	if ( !GetGlobalFilePath( pSource->filename, pFullPath, sizeof(pFullPath) ) )
+		return 0;
+
+	// When reading, keep the CRLF; this will make ReadFile read it in binary format
+	// and also append a couple 0s to the end of the buffer.
+	CDmElement *pRoot;
+	if ( g_pDataModel->RestoreFromFile( pFullPath, NULL, NULL, &pRoot ) == DMFILEID_INVALID )
+		return 0;
+
+	if ( !g_quiet )
+	{
+		Msg( "DMX Model %s\n", pFullPath );
+	}
+
+	// Load model info
+	LoadModelInfo( pRoot, pFullPath );
+
+	// Extract out the skeleton
+	CDmeDag *pSkeleton = pRoot->GetValueElement< CDmeDag >( "skeleton" );
+	CDmeModel *pModel = pRoot->GetValueElement< CDmeModel >( "model" );
+	CDmeCombinationOperator *pCombinationOperator = pRoot->GetValueElement< CDmeCombinationOperator >( "combinationOperator" );
+	if ( !pSkeleton )
+		goto dmxError;
+
+	// BoneRemap[bone index in file] == bone index in studiomdl
+	BoneTransformMap_t boneMap;
+	pSource->numbones = LoadSkeleton( pSkeleton, pModel, pSource->localBone, boneMap );
+	if ( pSource->numbones == 0 )
+		goto dmxError;
+
+	LoadAttachments( pSkeleton, pSkeleton, pSource );
+
+	g_numfaces = 0;
+	if ( pModel )
+	{
+		if ( pCombinationOperator )
+		{
+			pCombinationOperator->GenerateWrinkleDeltas( false );
+		}
+		LoadBindPose( pModel, g_currentscale, boneMap.m_pBoneRemap, pSource );
+		if ( !LoadMeshes( pModel, g_currentscale, boneMap.m_pBoneRemap, pSource ) )
+			goto dmxError;
+
+		UnifyIndices( pSource );
+		BuildVertexAnimations( pSource );
+		BuildIndividualMeshes( pSource );
+	}
+
+	if ( pCombinationOperator )
+	{
+		AddFlexKeys( pModel, pModel, pCombinationOperator, pSource );
+		AddCombination( pSource, pCombinationOperator );
+	}
+
+	CDmeAnimationList *pAnimationList = pRoot->GetValueElement< CDmeAnimationList >( "animationList" );
+	if ( pAnimationList )
+	{
+		LoadAnimations( pSource, pAnimationList, g_currentscale, boneMap );
+	}
+
+	fileId = pRoot->GetFileId();
+	g_pDataModel->RemoveFileId( fileId );
+	return 1;
+
+dmxError:
+	fileId = pRoot->GetFileId();
+	g_pDataModel->RemoveFileId( fileId );
+	return 0;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/utils/studiomdl/filebuffer.h b/utils/studiomdl/filebuffer.h
new file mode 100644
index 0000000..d7c0a42
--- /dev/null
+++ b/utils/studiomdl/filebuffer.h
@@ -0,0 +1,131 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef FILEBUFFER_H
+#define FILEBUFFER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tier1/smartptr.h"
+#include "tier2/p4helpers.h"
+
+class CFileBuffer
+{
+public:
+	CFileBuffer( int size )
+	{
+		m_pData = new unsigned char[size];
+#ifdef _DEBUG
+		m_pUsed = new const char *[size];
+		memset( m_pUsed, 0, size * sizeof( const char * ) );
+#endif
+		m_Size = size;
+		m_pCurPos = m_pData;
+#ifdef _DEBUG
+		memset( m_pData, 0xbaadf00d, size );
+#endif
+	}
+	~CFileBuffer()
+	{
+		delete [] m_pData;
+#ifdef _DEBUG
+		delete [] m_pUsed;
+#endif
+	}
+
+#ifdef _DEBUG
+	void TestWritten( int EndOfFileOffset )
+	{
+		if ( !g_quiet )
+		{
+			printf( "testing to make sure that the whole file has been written\n" );
+		}
+		int i;
+		for( i = 0; i < EndOfFileOffset; i++ )
+		{
+			if( !m_pUsed[i] )
+			{
+				printf( "offset %d not written, end of file invalid!\n", i );
+				assert( 0 );
+			}
+		}
+	}
+#endif
+	
+	void WriteToFile( const char *fileName, int size )
+	{
+		CPlainAutoPtr< CP4File > spFile( g_p4factory->AccessFile( fileName ) );
+		spFile->Edit();
+		FILE *fp = fopen( fileName, "wb" );
+		if( !fp )
+		{
+			MdlWarning( "Can't open \"%s\" for writing!\n", fileName );
+			return;
+		}
+
+		fwrite( m_pData, 1, size, fp );
+		
+		fclose( fp );
+		spFile->Add();
+	}
+	
+	void WriteAt( int offset, void *data, int size, const char *name )
+	{
+//		printf( "WriteAt: \"%s\" offset: %d end: %d size: %d\n", name, offset, offset + size - 1, size );
+		m_pCurPos = m_pData + offset;
+
+#ifdef _DEBUG
+		int i;
+		const char **used = m_pUsed + offset;
+		bool bitched = false;
+		for( i = 0; i < size; i++ )
+		{
+			if( used[i] )
+			{
+				if( !bitched )
+				{
+					printf( "overwrite at %d! (overwriting \"%s\" with \"%s\")\n", i + offset, used[i], name );
+					assert( 0 );
+					bitched = true;
+				}
+			}
+			else
+			{
+				used[i] = name;
+			}
+		}
+#endif // _DEBUG
+
+		Append( data, size );
+	}
+	int GetOffset( void )
+	{
+		return m_pCurPos - m_pData;
+	}
+	void *GetPointer( int offset )
+	{
+		return m_pData + offset;
+	}
+private:
+	void Append( void *data, int size )
+	{
+		assert( m_pCurPos + size - m_pData < m_Size );
+		memcpy( m_pCurPos, data, size );
+		m_pCurPos += size;
+	}
+	CFileBuffer(); // undefined
+	int m_Size;
+	unsigned char *m_pData;
+	unsigned char *m_pCurPos;
+#ifdef _DEBUG
+	const char **m_pUsed;
+#endif
+};
+	
+
+#endif // FILEBUFFER_H
diff --git a/utils/studiomdl/hardwarematrixstate.cpp b/utils/studiomdl/hardwarematrixstate.cpp
new file mode 100644
index 0000000..b49430c
--- /dev/null
+++ b/utils/studiomdl/hardwarematrixstate.cpp
@@ -0,0 +1,232 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include <windows.h>
+#include "HardwareMatrixState.h"
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "studio.h"
+#include "studiomdl.h"
+
+CHardwareMatrixState::CHardwareMatrixState()
+{
+	m_LRUCounter = 0;
+	m_NumMatrices = 0;
+	m_matrixState = NULL;
+	m_savedMatrixState = NULL;
+}
+
+void CHardwareMatrixState::Init( int numHardwareMatrices )
+{
+	m_NumMatrices = numHardwareMatrices;
+	delete [] m_matrixState;
+	m_matrixState = new MatrixState_t[m_NumMatrices];
+	Assert( m_matrixState );
+	delete [] m_savedMatrixState;
+	m_savedMatrixState = new MatrixState_t[m_NumMatrices];
+	Assert( m_savedMatrixState );
+	m_LRUCounter = 0;
+	m_AllocatedMatrices = 0;
+
+	int i;
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		m_matrixState[i].allocated = false;
+	}
+}
+
+bool CHardwareMatrixState::AllocateMatrix( int globalMatrixID )
+{
+	int i;
+
+	if( IsMatrixAllocated( globalMatrixID ) )
+	{
+		return true;
+	}
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( !m_matrixState[i].allocated )
+		{
+			m_matrixState[i].globalMatrixID = globalMatrixID;
+			m_matrixState[i].allocated = true;
+			m_matrixState[i].lastUsageID = m_LRUCounter++;
+			++m_AllocatedMatrices;
+			DumpState();
+			return true;
+		}
+	}
+	DumpState();
+	return false;
+}
+
+int CHardwareMatrixState::FindLocalLRUIndex( void )
+{
+	int oldestLRUCounter = INT_MAX;
+	int i;
+	int oldestID = 0;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( !m_matrixState[i].allocated )
+		{
+			continue;
+		}
+		if( m_matrixState[i].lastUsageID < oldestLRUCounter )
+		{
+			oldestLRUCounter = m_matrixState[i].lastUsageID;
+			oldestID = i;
+		}
+	}
+
+	Assert( oldestLRUCounter != INT_MAX );
+	return oldestID;
+}
+
+void CHardwareMatrixState::DeallocateLRU( void )
+{
+	int id;
+
+	id = FindLocalLRUIndex();
+	m_matrixState[id].allocated = false;
+	--m_AllocatedMatrices;
+}
+
+void CHardwareMatrixState::DeallocateLRU( int n )
+{
+	int i;
+
+	for( i = 0; i < n; i++ )
+	{
+		DeallocateLRU();
+	}
+}
+
+bool CHardwareMatrixState::IsMatrixAllocated( int globalMatrixID ) const
+{
+	int i;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( m_matrixState[i].globalMatrixID == globalMatrixID && 
+			m_matrixState[i].allocated )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+void CHardwareMatrixState::DeallocateAll()
+{
+	int i;
+
+	DumpState();
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		m_matrixState[i].allocated = false;
+		m_matrixState[i].globalMatrixID = INT_MAX;
+		m_matrixState[i].lastUsageID = INT_MAX;
+	}
+	m_AllocatedMatrices = 0;
+	DumpState();
+}
+
+void CHardwareMatrixState::SaveState( void )
+{
+	int i;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		m_savedMatrixState[i] = m_matrixState[i];
+	}
+}
+
+void CHardwareMatrixState::RestoreState( void )
+{
+	int i;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		m_matrixState[i] = m_savedMatrixState[i];
+	}
+}
+
+int CHardwareMatrixState::AllocatedMatrixCount() const
+{
+	return m_AllocatedMatrices;
+}
+
+int CHardwareMatrixState::FreeMatrixCount() const
+{
+	return m_NumMatrices - m_AllocatedMatrices;
+}
+
+int CHardwareMatrixState::GetNthBoneGlobalID( int n ) const
+{
+	int i;
+	int m = 0;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( m_matrixState[i].allocated )
+		{
+			if( n == m )
+			{
+				return m_matrixState[i].globalMatrixID;
+			}
+			m++;
+		}
+	}
+	Assert( 0 );
+	MdlError( "GetNthBoneGlobalID() Failure\n" );
+	return 0;
+}
+
+void CHardwareMatrixState::DumpState( void )
+{
+	int i;
+	static char buf[256];
+
+//#ifndef _DEBUG
+	return;
+//#endif
+	
+	OutputDebugString( "DumpState\n:" );
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( m_matrixState[i].allocated )
+		{
+			sprintf( buf, "%d: allocated: %s lastUsageID: %d globalMatrixID: %d\n",
+				i, 
+				m_matrixState[i].allocated ? "true " : "false",
+				m_matrixState[i].lastUsageID,
+				m_matrixState[i].globalMatrixID );
+			OutputDebugString( buf );
+		}
+	}
+}
+
+int CHardwareMatrixState::FindHardwareMatrix( int globalMatrixID )
+{
+	int i;
+
+	for( i = 0; i < m_NumMatrices; i++ )
+	{
+		if( m_matrixState[i].globalMatrixID == globalMatrixID )
+		{
+			return i;
+		}
+	}
+
+	Assert( 0 );
+	MdlError( "barfing in FindHardwareMatrix\n" );
+
+	return 0;
+}
+
diff --git a/utils/studiomdl/hardwarematrixstate.h b/utils/studiomdl/hardwarematrixstate.h
new file mode 100644
index 0000000..47673df
--- /dev/null
+++ b/utils/studiomdl/hardwarematrixstate.h
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HARDWAREMATRIXSTATE_H
+#define HARDWAREMATRIXSTATE_H
+#pragma once
+
+// This emulates the hardware matrix palette and keeps up with 
+// matrix usage, LRU's matrices, etc.
+class CHardwareMatrixState
+{
+public:
+	CHardwareMatrixState();
+
+	void Init( int numHardwareMatrices );
+	
+	// return false if there is no slot for this matrix.
+	bool AllocateMatrix( int globalMatrixID );
+
+	// deallocate the least recently used matrix
+	void DeallocateLRU( void );
+	void DeallocateLRU( int n );
+
+	// return true if a matrix is allocate.
+	bool IsMatrixAllocated( int globalMatrixID ) const;
+	
+	// flush usage flags - signifies that none of the matrices are being used in the current strip
+	// do this when starting a new strip.
+	void SetAllUnused();
+
+	void DeallocateAll();
+
+	// save the complete state of the hardware matrices
+	void SaveState();
+
+	// restore the complete state of the hardware matrices
+	void RestoreState();
+
+	// Returns the number of free + unsed matrices
+	int AllocatedMatrixCount() const;
+	int	FreeMatrixCount() const;
+
+	int GetNthBoneGlobalID( int n ) const;
+
+	void DumpState( void );
+
+private:
+	int FindHardwareMatrix( int globalMatrixID );
+	int FindLocalLRUIndex( void );
+
+	// Increment and return LRU counter.
+	struct MatrixState_t
+	{
+		bool allocated;
+		int lastUsageID;
+		int globalMatrixID;
+	};
+
+	int m_LRUCounter;
+	int m_NumMatrices;
+	int m_AllocatedMatrices;
+
+	MatrixState_t *m_matrixState;
+	MatrixState_t *m_savedMatrixState;
+};
+
+#endif // HARDWAREMATRIXSTATE_H
diff --git a/utils/studiomdl/hardwarevertexcache.cpp b/utils/studiomdl/hardwarevertexcache.cpp
new file mode 100644
index 0000000..1c5a41c
--- /dev/null
+++ b/utils/studiomdl/hardwarevertexcache.cpp
@@ -0,0 +1,71 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "HardwareVertexCache.h"
+
+CHardwareVertexCache::CHardwareVertexCache()
+{
+	m_Fifo = NULL;
+	m_Size = 0;
+	Flush();
+}
+
+void CHardwareVertexCache::Init( int size )
+{
+	m_Size = size;
+	m_Fifo = new int[size];
+	Flush();
+}
+
+void CHardwareVertexCache::Flush( void )
+{
+	m_HeadIndex = 0;
+	m_NumEntries = 0;
+}
+
+bool CHardwareVertexCache::IsPresent( int index )
+{
+	int i;
+//	printf( "testing if %d is present\n", index );
+	for( i = 0; i < m_NumEntries; i++ )
+	{
+		if( m_Fifo[( m_HeadIndex + i ) % m_Size] == index )
+		{
+//			printf( "yes!\n" );
+			return true;
+		}
+	}
+//	printf( "no!\n" );
+//	Print();
+	return false;
+}
+
+void CHardwareVertexCache::Insert( int index )
+{
+//	printf( "Inserting: %d\n", index );
+	m_Fifo[( m_HeadIndex + m_NumEntries ) % m_Size] = index;
+	if( m_NumEntries == m_Size )
+	{
+		m_HeadIndex = ( m_HeadIndex + 1 ) % m_Size;
+	}
+	else
+	{
+		m_NumEntries++;
+	}
+//	Print();
+}
+
+void CHardwareVertexCache::Print( void )
+{
+	int i;
+	for( i = 0; i < m_NumEntries; i++ )
+	{
+		printf( "fifo entry %d: %d\n", i, ( int )m_Fifo[( m_HeadIndex + i ) % m_Size] );
+	}
+}
diff --git a/utils/studiomdl/hardwarevertexcache.h b/utils/studiomdl/hardwarevertexcache.h
new file mode 100644
index 0000000..a9eb2a5
--- /dev/null
+++ b/utils/studiomdl/hardwarevertexcache.h
@@ -0,0 +1,32 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef HARDWAREVERTEXCACHE_H
+#define HARDWAREVERTEXCACHE_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+// emulate a hardware post T&L vertex fifo
+
+class CHardwareVertexCache
+{
+public:
+	CHardwareVertexCache();
+	void Init( int size );
+	void Insert( int index );
+	bool IsPresent( int index );
+	void Flush( void );
+	void Print( void );
+private:
+	int m_Size;
+	int *m_Fifo;
+	int m_HeadIndex;
+	int m_NumEntries;
+};
+
+#endif // HARDWAREVERTEXCACHE_H
diff --git a/utils/studiomdl/mrmsupport.cpp b/utils/studiomdl/mrmsupport.cpp
new file mode 100644
index 0000000..60cfcb1
--- /dev/null
+++ b/utils/studiomdl/mrmsupport.cpp
@@ -0,0 +1,882 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+
+//
+// studiomdl.c: generates a studio .mdl file from a .qc script
+// models/<scriptname>.mdl.
+//
+
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+//#include "..\..\dlls\activity.h"
+
+bool IsEnd( char const* pLine )
+{
+	if (strncmp( "end", pLine, 3 ) != 0) 
+		return false;
+	return (pLine[3] == '\0') || (pLine[3] == '\n');
+}
+
+
+int SortAndBalanceBones( int iCount, int iMaxCount, int bones[], float weights[] )
+{
+	int i;
+
+	// collapse duplicate bone weights
+	for (i = 0; i < iCount-1; i++)
+	{
+		int j;
+		for (j = i + 1; j < iCount; j++)
+		{
+			if (bones[i] == bones[j])
+			{
+				weights[i] += weights[j];
+				weights[j] = 0.0;
+			}
+		}
+	}
+
+	// do sleazy bubble sort
+	int bShouldSort;
+	do {
+		bShouldSort = false;
+		for (i = 0; i < iCount-1; i++)
+		{
+			if (weights[i+1] > weights[i])
+			{
+				int j = bones[i+1]; bones[i+1] = bones[i]; bones[i] = j;
+				float w = weights[i+1]; weights[i+1] = weights[i]; weights[i] = w;
+				bShouldSort = true;
+			}
+		}
+	} while (bShouldSort);
+
+	// throw away all weights less than 1/20th
+	while (iCount > 1 && weights[iCount-1] < 0.05)
+	{
+		iCount--;
+	}
+
+	// clip to the top iMaxCount bones
+	if (iCount > iMaxCount)
+	{
+		iCount = iMaxCount;
+	}
+
+	float t = 0;
+	for (i = 0; i < iCount; i++)
+	{
+		t += weights[i];
+	}
+
+	if (t <= 0.0)
+	{
+		// missing weights?, go ahead and evenly share?
+		// FIXME: shouldn't this error out?
+		t = 1.0 / iCount;
+
+		for (i = 0; i < iCount; i++)
+		{
+			weights[i] = t;
+		}
+	}
+	else
+	{
+		// scale to sum to 1.0
+		t = 1.0 / t;
+
+		for (i = 0; i < iCount; i++)
+		{
+			weights[i] = weights[i] * t;
+		}
+	}
+
+	return iCount;
+}
+
+
+
+void Grab_Vertexlist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			int j;
+			int bone;
+			Vector p;
+			int		iCount, bones[4];
+			float   weights[4];
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+
+			int i = sscanf( g_szLine, "%d %d %f %f %f %d %d %f %d %f %d %f %d %f",
+				&j, 
+				&bone, 
+				&p[0], &p[1], &p[2],
+				&iCount,
+				&bones[0], &weights[0], &bones[1], &weights[1], &bones[2], &weights[2], &bones[3], &weights[3] );
+			
+			if (i == 5)
+			{
+				if (bone < 0 || bone >= psource->numbones) 
+				{
+					MdlWarning( "bogus bone index\n" );
+					MdlWarning( "%d %s :\n%s", g_iLinecount, g_szFilename, g_szLine );
+					MdlError( "Exiting due to errors\n" );
+				}
+
+				VectorCopy( p, g_vertex[j] );
+				g_bone[j].numbones = 1;
+				g_bone[j].bone[0] = bone;
+				g_bone[j].weight[0] = 1.0;
+			} 
+			else if (i > 5)
+			{
+				iCount = SortAndBalanceBones( iCount, MAXSTUDIOBONEWEIGHTS, bones, weights );
+
+				VectorCopy( p, g_vertex[j] );
+				g_bone[j].numbones = iCount;
+				for (i = 0; i < iCount; i++)
+				{
+					g_bone[j].bone[i] = bones[i];
+					g_bone[j].weight[i] = weights[i];
+				}
+			}
+			else 
+			{
+				MdlError("%s: error on line %d: %s", g_szFilename, g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+
+void Grab_Facelist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			int j;
+			s_tmpface_t f;
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+			if (sscanf( g_szLine, "%d %d %d %d",
+				&j, 
+				&f.a, &f.b, &f.c) == 4)
+			{
+				g_face[j] = f;
+			}
+			else 
+			{
+				MdlError("%s: error on line %d: %s", g_szFilename, g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+
+void Grab_Materiallist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			// char name[256];
+			char path[MAX_PATH];
+			rgb2_t a, d, s;
+			float g;
+			int j;
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+			if (sscanf( g_szLine, "%d  %f %f %f %f   %f %f %f %f  %f %f %f %f  %f \"%[^\"]s", 
+				&j, 
+				&a.r, &a.g, &a.b, &a.a,
+				&d.r, &d.g, &d.b, &d.a,
+				&s.r, &s.g, &s.b, &s.a,
+				&g,
+				path ) == 15)
+			{
+				if (path[0] == '\0')
+				{
+					psource->texmap[j] = -1;
+				}
+				else if (j < ARRAYSIZE(psource->texmap))
+				{
+					psource->texmap[j] = LookupTexture( path );
+				}
+				else
+				{
+					MdlError( "Too many materials, max %d\n", ARRAYSIZE(psource->texmap) );
+				}
+			}
+		}
+	}
+}
+
+
+void Grab_Texcoordlist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			int j;
+			Vector2D t;
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+			if (sscanf( g_szLine, "%d %f %f",
+				&j, 
+				&t[0], &t[1]) == 3)
+			{
+				t[1] = 1.0 - t[1];
+				g_texcoord[j][0] = t[0];
+				g_texcoord[j][1] = t[1];
+			}
+			else 
+			{
+				MdlError("%s: error on line %d: %s", g_szFilename, g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+void Grab_Normallist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			int j;
+			int bone;
+			Vector n;
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+
+			if (sscanf( g_szLine, "%d %d %f %f %f",
+				&j, 
+				&bone, 
+				&n[0], &n[1], &n[2]) == 5)
+			{
+				if (bone < 0 || bone >= psource->numbones) 
+				{
+					MdlWarning( "bogus bone index\n" );
+					MdlWarning( "%d %s :\n%s", g_iLinecount, g_szFilename, g_szLine );
+					MdlError( "Exiting due to errors\n" );
+				}
+
+				VectorCopy( n, g_normal[j] );
+			}
+			else 
+			{
+				MdlError("%s: error on line %d: %s", g_szFilename, g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+
+void Grab_Faceattriblist( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			int j;
+			int smooth;
+			int material;
+			s_tmpface_t f;
+			unsigned short s;
+
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+
+			if (sscanf( g_szLine, "%d %d %d %d %d %d %d %d %d",
+				&j, 
+				&material,
+				&smooth,
+				&f.ta, &f.tb, &f.tc,
+				&f.na, &f.nb, &f.nc) == 9)
+			{
+				f.a = g_face[j].a;
+				f.b = g_face[j].b;
+				f.c = g_face[j].c;
+
+				f.material = UseTextureAsMaterial( psource->texmap[material] );
+				if (f.material < 0)
+				{
+					MdlError( "face %d references NULL texture %d\n", j, material );
+				}
+				
+				if (1)
+				{
+					s = f.b;  f.b  = f.c;  f.c  = s;
+					s = f.tb; f.tb = f.tc; f.tc = s;
+					s = f.nb; f.nb = f.nc; f.nc = s;
+				}
+
+				g_face[j] = f;
+			}
+			else 
+			{
+				MdlError("%s: error on line %d: %s", g_szFilename, g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+int closestNormal( int v, int n )
+{
+	float maxdot = -1.0;
+	float dot;
+	int	r = n;
+
+	v_unify_t *cur = v_list[v];
+
+	while (cur)
+	{
+		dot = DotProduct( g_normal[cur->n], g_normal[n] );
+		if (dot > maxdot)
+		{
+			r = cur->n;
+			maxdot = dot;
+		}
+		cur = cur->next;
+	}
+	
+	return r;
+}
+
+
+int AddToVlist( int v, int m, int n, int t, int firstref )
+{
+	v_unify_t *prev = NULL;
+	v_unify_t *cur = v_list[v];
+
+	while (cur)
+	{
+		if (cur->m == m && cur->n == n && cur->t == t)
+		{
+			cur->refcount++;
+			return cur - v_listdata;
+		}
+		prev = cur;
+		cur = cur->next;
+	}
+
+	if (numvlist >= MAXSTUDIOVERTS)
+	{
+		MdlError( "Too many unified vertices\n");
+	}
+
+	cur = &v_listdata[numvlist++];
+	cur->lastref = -1;
+	cur->refcount = 1;
+	cur->firstref = firstref;
+	cur->v = v;
+	cur->m = m;
+	cur->n = n;
+	cur->t = t;
+
+	if (prev)
+	{
+		prev->next = cur;
+	}
+	else
+	{
+		v_list[v] = cur;
+	}
+
+	return numvlist - 1;
+}
+
+void DecrementReferenceVlist( int uv, int numverts )
+{
+	if (uv < 0 || uv >= MAXSTUDIOVERTS)
+		MdlError( "decrement outside of range\n");
+
+	v_listdata[uv].refcount--;
+
+	if (v_listdata[uv].refcount == 0)
+	{
+		v_listdata[uv].lastref = numverts;
+	}
+	else if (v_listdata[uv].refcount < 0)
+	{
+		MdlError("<0 ref\n");
+	}
+}
+
+
+void UnifyIndices( s_source_t *psource )
+{
+	int i;
+
+	static s_tmpface_t		tmpface[MAXSTUDIOTRIANGLES];	// mrm processed g_face
+	static s_face_t			uface[MAXSTUDIOTRIANGLES];		// mrm processed unified face
+
+	// clear v_list
+	numvlist = 0;
+	memset( v_list, 0, sizeof( v_list ) );
+	memset( v_listdata, 0, sizeof( v_listdata ) );
+
+	// create an list of all the 
+	for (i = 0; i < g_numfaces; i++)
+	{
+		tmpface[i] = g_face[i];
+
+		uface[i].a = AddToVlist( g_face[i].a, g_face[i].material, g_face[i].na, g_face[i].ta, g_numverts );
+		uface[i].b = AddToVlist( g_face[i].b, g_face[i].material, g_face[i].nb, g_face[i].tb, g_numverts );
+		uface[i].c = AddToVlist( g_face[i].c, g_face[i].material, g_face[i].nc, g_face[i].tc, g_numverts );
+
+		// keep an original copy
+		g_src_uface[i] = uface[i];
+	}
+
+	// printf("%d : %d %d %d\n", numvlist, g_numverts, g_numnormals, g_numtexcoords );
+}
+
+void CalcModelTangentSpaces( s_source_t *pSrc );
+
+
+//-----------------------------------------------------------------------------
+// Builds a list of unique vertices in a source
+//-----------------------------------------------------------------------------
+static void BuildUniqueVertexList( s_source_t *pSource, const int *pDesiredToVList )
+{
+	// allocate memory
+	pSource->vertex = (s_vertexinfo_t *)kalloc( pSource->numvertices, sizeof( s_vertexinfo_t ) );
+
+	// create arrays of unique vertexes, normals, texcoords.
+	for (int i = 0; i < pSource->numvertices; i++)
+	{
+		int j = pDesiredToVList[i];
+
+		s_vertexinfo_t &vertex = pSource->vertex[i];
+		VectorCopy( g_vertex[ v_listdata[j].v ], vertex.position );
+		VectorCopy( g_normal[ v_listdata[j].n ], vertex.normal );		
+		Vector2Copy( g_texcoord[ v_listdata[j].t ], vertex.texcoord );
+
+		vertex.boneweight.numbones		= g_bone[ v_listdata[j].v ].numbones;
+		int k;
+		for( k = 0; k < MAXSTUDIOBONEWEIGHTS; k++ )
+		{
+			vertex.boneweight.bone[k]	= g_bone[ v_listdata[j].v ].bone[k];
+			vertex.boneweight.weight[k]	= g_bone[ v_listdata[j].v ].weight[k];
+		}
+
+		// store a bunch of other info
+		vertex.material			= v_listdata[j].m;
+
+#if 0
+		pSource->vertexInfo[i].firstref		= v_listdata[j].firstref;
+		pSource->vertexInfo[i].lastref		= v_listdata[j].lastref;
+#endif	
+		// printf("%4d : %2d :  %6.2f %6.2f %6.2f\n", i, psource->boneweight[i].bone[0], psource->vertex[i][0], psource->vertex[i][1], psource->vertex[i][2] );
+	}
+
+}
+
+
+//-----------------------------------------------------------------------------
+// sort new vertices by materials, last used
+//-----------------------------------------------------------------------------
+static int vlistCompare( const void *elem1, const void *elem2 )
+{
+	v_unify_t *u1 = &v_listdata[*(int *)elem1];
+	v_unify_t *u2 = &v_listdata[*(int *)elem2];
+
+	// sort by material
+	if (u1->m < u2->m)
+		return -1;
+	if (u1->m > u2->m)
+		return 1;
+
+	// sort by last used
+	if (u1->lastref < u2->lastref)
+		return -1;
+	if (u1->lastref > u2->lastref)
+		return 1;
+
+	return 0;
+}
+
+static void SortVerticesByMaterial( int *pDesiredToVList, int *pVListToDesired )
+{
+	for ( int i = 0; i < numvlist; i++ )
+	{
+		pDesiredToVList[i] = i;
+	}
+	qsort( pDesiredToVList, numvlist, sizeof( int ), vlistCompare );
+	for ( int i = 0; i < numvlist; i++ )
+	{
+		pVListToDesired[ pDesiredToVList[i] ] = i;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// sort new faces by materials, last used
+//-----------------------------------------------------------------------------
+static int faceCompare( const void *elem1, const void *elem2 )
+{
+	int i1 = *(int *)elem1;
+	int i2 = *(int *)elem2;
+
+	// sort by material
+	if (g_face[i1].material < g_face[i2].material)
+		return -1;
+	if (g_face[i1].material > g_face[i2].material)
+		return 1;
+
+	// sort by original usage
+	if (i1 < i2)
+		return -1;
+	if (i1 > i2)
+		return 1;
+
+	return 0;
+}
+
+static void SortFacesByMaterial( int *pDesiredToSrcFace )
+{
+	// NOTE: Unlike SortVerticesByMaterial, srcFaceToDesired isn't needed, so we're not computing it
+	for ( int i = 0; i < g_numfaces; i++ )
+	{
+		pDesiredToSrcFace[i] = i;
+	}
+	qsort( pDesiredToSrcFace, g_numfaces, sizeof( int ), faceCompare );
+}
+
+
+//-----------------------------------------------------------------------------
+// Builds mesh structures in the source
+//-----------------------------------------------------------------------------
+static void PointMeshesToVertexAndFaceData( s_source_t *pSource, int *pDesiredToSrcFace )
+{
+	// First, assign all meshes to be empty
+	// A mesh is a set of faces + vertices that all use 1 material
+	for ( int m = 0; m < MAXSTUDIOSKINS; m++ )
+	{
+		pSource->mesh[m].numvertices = 0;
+		pSource->mesh[m].vertexoffset = pSource->numvertices;
+
+		pSource->mesh[m].numfaces = 0;
+		pSource->mesh[m].faceoffset = pSource->numfaces;
+	}
+
+	// find first and count of vertices per material
+	for ( int i = 0; i < pSource->numvertices; i++ )
+	{
+		int m = pSource->vertex[i].material;
+		pSource->mesh[m].numvertices++;
+		if (pSource->mesh[m].vertexoffset > i)
+		{
+			pSource->mesh[m].vertexoffset = i;
+		}
+	}
+
+	// find first and count of faces per material
+	for ( int i = 0; i < pSource->numfaces; i++ )
+	{
+		int m = g_face[ pDesiredToSrcFace[i] ].material;
+
+		pSource->mesh[m].numfaces++;
+		if (pSource->mesh[m].faceoffset > i)
+		{
+			pSource->mesh[m].faceoffset = i;
+		}
+	}
+
+	/*
+	for (k = 0; k < MAXSTUDIOSKINS; k++)
+	{
+		printf("%d : %d:%d %d:%d\n", k, psource->mesh[k].numvertices, psource->mesh[k].vertexoffset, psource->mesh[k].numfaces, psource->mesh[k].faceoffset );
+	}
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Builds the face list in the mesh
+//-----------------------------------------------------------------------------
+static void BuildFaceList( s_source_t *pSource, int *pVListToDesired, int *pDesiredToSrcFace )
+{
+	pSource->face = (s_face_t *)kalloc( pSource->numfaces, sizeof( s_face_t ));
+	for ( int m = 0; m < MAXSTUDIOSKINS; m++)
+	{
+		if ( !pSource->mesh[m].numfaces )
+			continue;
+
+		pSource->meshindex[ pSource->nummeshes++ ] = m;
+
+		for ( int i = pSource->mesh[m].faceoffset; i < pSource->mesh[m].numfaces + pSource->mesh[m].faceoffset; i++)
+		{
+			int j = pDesiredToSrcFace[i];
+
+			// NOTE: per-face vertex indices a,b,c are mesh relative (hence the subtraction),
+			// while g_src_uface are model relative 
+			pSource->face[i].a = pVListToDesired[ g_src_uface[j].a ] - pSource->mesh[m].vertexoffset;
+			pSource->face[i].b = pVListToDesired[ g_src_uface[j].b ] - pSource->mesh[m].vertexoffset;
+			pSource->face[i].c = pVListToDesired[ g_src_uface[j].c ] - pSource->mesh[m].vertexoffset;
+			Assert( ((pSource->face[i].a & 0xF0000000) == 0) && ((pSource->face[i].b & 0xF0000000) == 0) && 
+				((pSource->face[i].c & 0xF0000000) == 0) );
+			// printf("%3d : %4d %4d %4d\n", i, pSource->face[i].a, pSource->face[i].b, pSource->face[i].c );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Remaps the vertex animations based on the new vertex ordering
+//-----------------------------------------------------------------------------
+static void RemapVertexAnimations( s_source_t *pSource, int *pVListToDesired )
+{
+	int nAnimationCount = pSource->m_Animations.Count();
+	for ( int i = 0; i < nAnimationCount; ++i )
+	{
+		s_sourceanim_t &anim = pSource->m_Animations[i];
+		if ( !anim.newStyleVertexAnimations )
+			continue;
+
+		for ( int j = 0; j < MAXSTUDIOANIMFRAMES; ++j )
+		{
+			int nVAnimCount = anim.numvanims[j];
+			if ( nVAnimCount == 0 )
+				continue;
+
+			// Copy off the initial vertex data
+			// Have to do it in 2 loops because it'll overwrite itself if we do it in 1
+			int *pTemp = (int*)_alloca( nVAnimCount * sizeof(int) );
+			for ( int k = 0; k < nVAnimCount; ++k )
+			{
+				pTemp[k] = anim.vanim[j][k].vertex;
+			}
+
+			for ( int k = 0; k < nVAnimCount; ++k )
+			{
+				// NOTE: vertex animations are model relative, not mesh relative
+				anim.vanim[j][k].vertex = pVListToDesired[ pTemp[k] ];
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sorts vertices by material type, re-maps data structures that refer to those vertices
+// to use the new indices
+//-----------------------------------------------------------------------------
+void BuildIndividualMeshes( s_source_t *pSource )
+{	
+	static int v_listsort[MAXSTUDIOVERTS];		// map desired order to vlist entry
+	static int v_ilistsort[MAXSTUDIOVERTS];		// map vlist entry to desired order
+	static int facesort[MAXSTUDIOTRIANGLES];	// map desired order to src_face entry
+
+	SortVerticesByMaterial( v_listsort, v_ilistsort );
+	SortFacesByMaterial( facesort );
+
+	pSource->numvertices = numvlist;
+	pSource->numfaces = g_numfaces;
+
+	BuildUniqueVertexList( pSource, v_listsort );
+	PointMeshesToVertexAndFaceData( pSource, facesort );
+	BuildFaceList( pSource, v_ilistsort, facesort );
+	RemapVertexAnimations( pSource, v_ilistsort );
+	CalcModelTangentSpaces( pSource );
+}
+
+
+void Grab_MRMFaceupdates( s_source_t *psource )
+{
+	while (1) 
+	{
+		if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+		{
+			g_iLinecount++;
+
+			// check for end
+			if (IsEnd(g_szLine)) 
+				return;
+		}
+	}
+}
+
+int Load_VRM ( s_source_t *psource )
+{
+	char	cmd[1024];
+	int		option;
+
+	if (!OpenGlobalFile( psource->filename ))
+	{	
+		return 0;
+	}
+
+	if( !g_quiet )
+	{
+		printf ("grabbing %s\n", psource->filename);
+	}
+
+	g_iLinecount = 0;
+
+	while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+	{
+		g_iLinecount++;
+		sscanf( g_szLine, "%1023s %d", cmd, &option );
+		if (stricmp( cmd, "version" ) == 0) 
+		{
+			if (option != 2) 
+			{
+				MdlError("bad version\n");
+			}
+		}
+		else if (stricmp( cmd, "name" ) == 0)
+		{
+		}
+		else if (stricmp( cmd, "vertices" ) == 0) 
+		{
+			g_numverts = option;
+		}
+		else if (stricmp( cmd, "faces" ) == 0) 
+		{
+			g_numfaces = option;
+		}
+		else if (stricmp( cmd, "materials" ) == 0) 
+		{
+			// doesn't matter;
+		}
+		else if (stricmp( cmd, "texcoords" ) == 0) 
+		{
+			g_numtexcoords = option;
+			if (option == 0)
+				MdlError( "model has no texture coordinates\n");
+		}
+		else if (stricmp( cmd, "normals" ) == 0) 
+		{
+			g_numnormals = option;
+		}
+		else if (stricmp( cmd, "tristrips" ) == 0) 
+		{
+			// should be 0;
+		}
+
+		else if (stricmp( cmd, "vertexlist" ) == 0) 
+		{
+			Grab_Vertexlist( psource );
+		}
+		else if (stricmp( cmd, "facelist" ) == 0) 
+		{
+			Grab_Facelist( psource );
+		}
+		else if (stricmp( cmd, "materiallist" ) == 0) 
+		{
+			Grab_Materiallist( psource );
+		}
+		else if (stricmp( cmd, "texcoordlist" ) == 0) 
+		{
+			Grab_Texcoordlist( psource );
+		}
+		else if (stricmp( cmd, "normallist" ) == 0) 
+		{
+			Grab_Normallist( psource );
+		}
+		else if (stricmp( cmd, "faceattriblist" ) == 0) 
+		{
+			Grab_Faceattriblist( psource );
+		}
+
+		else if (stricmp( cmd, "MRM" ) == 0) 
+		{
+		}
+		else if (stricmp( cmd, "MRMvertices" ) == 0) 
+		{
+		}
+		else if (stricmp( cmd, "MRMfaces" ) == 0) 
+		{
+		}
+		else if (stricmp( cmd, "MRMfaceupdates" ) == 0) 
+		{
+			Grab_MRMFaceupdates( psource );
+		}
+
+		else if (stricmp( cmd, "nodes" ) == 0) 
+		{
+			psource->numbones = Grab_Nodes( psource->localBone );
+		}
+		else if (stricmp( cmd, "skeleton" ) == 0) 
+		{
+			Grab_Animation( psource, "BindPose" );
+		}
+/*		
+		else if (stricmp( cmd, "triangles" ) == 0) {
+			Grab_Triangles( psource );
+		}
+*/
+		else 
+		{
+			MdlError("unknown VRM command : %s \n", cmd );
+		}
+	}
+
+	UnifyIndices( psource );
+	BuildIndividualMeshes( psource );
+
+	fclose( g_fpInput );
+
+	return 1;
+}
+
diff --git a/utils/studiomdl/objsupport.cpp b/utils/studiomdl/objsupport.cpp
new file mode 100644
index 0000000..776e5bc
--- /dev/null
+++ b/utils/studiomdl/objsupport.cpp
@@ -0,0 +1,432 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+
+//
+// studiomdl.c: generates a studio .mdl file from a .qc script
+// models/<scriptname>.mdl.
+//
+
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+#include "tier1/utlbuffer.h"
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "tier1/characterset.h"
+#include "studiomdl.h"
+//#include "..\..\dlls\activity.h"
+
+bool IsEnd( char const* pLine );
+int SortAndBalanceBones( int iCount, int iMaxCount, int bones[], float weights[] );
+
+int AddToVlist( int v, int m, int n, int t, int firstref );
+void DecrementReferenceVlist( int uv, int numverts );
+int faceCompare( const void *elem1, const void *elem2 );
+
+
+void UnifyIndices( s_source_t *psource );
+
+struct MtlInfo_t
+{
+	CUtlString m_MtlName;
+	CUtlString m_TgaName;
+};
+
+static CUtlVector<MtlInfo_t> g_MtlLib;
+
+void ParseMtlLib( CUtlBuffer &buf )
+{
+	int nCurrentMtl = -1;
+	while ( buf.IsValid() )
+	{
+		buf.GetLine( g_szLine, sizeof(g_szLine) );
+
+		if ( !Q_strnicmp( g_szLine, "newmtl ", 7 ) )
+		{
+			char mtlName[1024];
+			if ( sscanf( g_szLine, "newmtl %s", mtlName ) == 1 )
+			{
+				nCurrentMtl = g_MtlLib.AddToTail( );
+				g_MtlLib[nCurrentMtl].m_MtlName = mtlName;
+				g_MtlLib[nCurrentMtl].m_TgaName = "debugempty";
+			}
+			continue;
+		}
+
+		if ( !Q_strnicmp( g_szLine, "map_Kd ", 7 ) )
+		{
+			if ( nCurrentMtl < 0 )
+				continue;
+
+			char tgaPath[MAX_PATH];
+			char tgaName[1024];
+			if ( sscanf( g_szLine, "map_Kd %s", tgaPath ) == 1 )
+			{
+				Q_FileBase( tgaPath, tgaName, sizeof(tgaName) );
+				g_MtlLib[nCurrentMtl].m_TgaName = tgaName;
+			}
+			continue;
+		}
+	}
+}
+
+const char *FindMtlEntry( const char *pTgaName )
+{
+	int nCount = g_MtlLib.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !Q_stricmp( g_MtlLib[i].m_MtlName, pTgaName ) )
+			return g_MtlLib[i].m_TgaName;
+	}
+	return pTgaName;
+}									 
+
+static bool ParseVertex( CUtlBuffer& bufParse, characterset_t &breakSet, int &v, int &t, int &n )
+{
+	char	cmd[1024];
+	int nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
+	if ( nLen <= 0 )
+		return false;
+
+	v = atoi( cmd );
+	n = 0;
+	t = 0;
+
+	char c = *(char*)bufParse.PeekGet();
+	bool bHasTexCoord = IN_CHARACTERSET( breakSet, c ) != 0;
+	bool bHasNormal = false;
+	if ( bHasTexCoord )
+	{
+		// Snag the '/'
+		nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
+		Assert( nLen == 1 );
+
+		c = *(char*)bufParse.PeekGet();
+		if ( !IN_CHARACTERSET( breakSet, c ) )
+		{
+			nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
+			Assert( nLen > 0 );
+			t = atoi( cmd );
+
+			c = *(char*)bufParse.PeekGet();
+			bHasNormal = IN_CHARACTERSET( breakSet, c ) != 0;
+		}
+		else
+		{
+			bHasNormal = true;
+			bHasTexCoord = false;
+		}
+
+		if ( bHasNormal )
+		{
+			// Snag the '/'
+			nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
+			Assert( nLen == 1 );
+
+			nLen = bufParse.ParseToken( &breakSet, cmd, sizeof(cmd), false );
+			Assert( nLen > 0 );
+			n = atoi( cmd );
+		}
+	}
+	return true;
+}
+
+
+int Load_OBJ( s_source_t *psource )
+{
+	char	cmd[1024];
+	int		i;
+	int		material = -1;
+
+	g_MtlLib.RemoveAll();
+
+	if ( !OpenGlobalFile( psource->filename ) )
+		return 0;
+
+	char pFullPath[MAX_PATH];
+	if ( !GetGlobalFilePath( psource->filename, pFullPath, sizeof(pFullPath) ) )
+		return 0;
+
+	char pFullDir[MAX_PATH];
+	Q_ExtractFilePath( pFullPath, pFullDir, sizeof(pFullDir) );
+
+	if( !g_quiet )
+	{
+		printf( "grabbing %s\n", psource->filename );
+	}
+
+	g_iLinecount = 0;
+
+	psource->numbones = 1;
+	strcpy( psource->localBone[0].name, "default" );
+	psource->localBone[0].parent = -1;
+	Assert( psource->m_Animations.Count() == 0 );
+    s_sourceanim_t *pSourceAnim = FindOrAddSourceAnim( psource, "BindPose" );
+	pSourceAnim->numframes = 1;
+	pSourceAnim->startframe = 0;
+	pSourceAnim->endframe = 0;
+	pSourceAnim->rawanim[0] = (s_bone_t *)kalloc( 1, sizeof( s_bone_t ) );
+	pSourceAnim->rawanim[0][0].pos.Init();
+	pSourceAnim->rawanim[0][0].rot.Init();
+	Build_Reference( psource, "BindPose" );
+
+	characterset_t breakSet;
+	CharacterSetBuild( &breakSet, "/\\" );
+
+	while ( GetLineInput() ) 
+	{
+		Vector tmp;
+
+		if ( strncmp( g_szLine, "v ", 2 ) == 0 )
+		{
+			i = g_numverts++;
+
+			sscanf( g_szLine, "v %f %f %f", &g_vertex[i].x, &g_vertex[i].y, &g_vertex[i].z );
+			g_bone[i].numbones = 1;
+			g_bone[i].bone[0] = 0;
+			g_bone[i].weight[0] = 1.0;
+			continue;
+		}
+		
+		if (strncmp( g_szLine, "vn ", 3 ) == 0)
+		{
+			i = g_numnormals++;
+			sscanf( g_szLine, "vn %f %f %f", &g_normal[i].x, &g_normal[i].y, &g_normal[i].z );
+			continue;
+		}
+		
+		if (strncmp( g_szLine, "vt ", 3 ) == 0)
+		{
+			i = g_numtexcoords++;
+			sscanf( g_szLine, "vt %f %f", &g_texcoord[i].x, &g_texcoord[i].y );
+			g_texcoord[i].y = 1.0 - g_texcoord[i].y;
+			continue;
+		}
+		
+		if ( !Q_strncmp( g_szLine, "mtllib ", 7 ) )
+		{
+			sscanf( g_szLine, "mtllib %s", &cmd[0] );
+			CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
+
+			char pFullMtlLibPath[MAX_PATH];
+			Q_ComposeFileName( pFullDir, cmd, pFullMtlLibPath, sizeof(pFullMtlLibPath) );
+			if ( g_pFullFileSystem->ReadFile( pFullMtlLibPath, NULL, buf ) )
+			{
+				ParseMtlLib( buf );
+			}
+			continue;
+		}
+
+		if (strncmp( g_szLine, "usemtl ", 7 ) == 0)
+		{
+			sscanf( g_szLine, "usemtl %s", &cmd[0] );
+
+			const char *pTexture = FindMtlEntry( cmd );
+			int texture = LookupTexture( pTexture );
+			psource->texmap[texture] = texture;	// hack, make it 1:1
+			material = UseTextureAsMaterial( texture );
+			continue;
+		}
+
+		if (strncmp( g_szLine, "f ", 2 ) == 0)
+		{
+			if ( material < 0 )
+			{
+				int texture = LookupTexture( "debugempty.tga" );
+				psource->texmap[texture] = texture;
+				material = UseTextureAsMaterial( texture );
+			}
+
+			int v0, n0, t0;
+			int v1, n1, t1;
+			int v2, n2, t2;
+
+			s_tmpface_t f;
+
+			// Are we specifying p only, p and t only, p and n only, or p and n and t?
+			char *pData = g_szLine + 2;
+			int nLen = Q_strlen( pData );
+
+			CUtlBuffer bufParse( pData, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
+
+			ParseVertex( bufParse, breakSet, v0, t0, n0 );
+			ParseVertex( bufParse, breakSet, v1, t1, n1 );
+			Assert( v0 <= g_numverts && t0 <= g_numtexcoords && n0 <= g_numnormals );
+			Assert( v1 <= g_numverts && t1 <= g_numtexcoords && n1 <= g_numnormals );
+			while ( bufParse.IsValid() )
+			{
+				if ( !ParseVertex( bufParse, breakSet, v2, t2, n2 ) )
+					break;
+
+				Assert( v2 <= g_numverts && t2 <= g_numtexcoords && n2 <= g_numnormals );
+	
+				i = g_numfaces++;
+				f.material = material;
+				f.a = v0 - 1; f.na = (n0 > 0) ? n0 - 1 : 0, f.ta = (t0 > 0) ? t0 - 1 : 0;
+				f.b = v2 - 1; f.nb = (n2 > 0) ? n2 - 1 : 0, f.tb = (t2 > 0) ? t2 - 1 : 0;
+				f.c = v1 - 1; f.nc = (n1 > 0) ? n1 - 1 : 0, f.tc = (t1 > 0) ? t1 - 1 : 0;
+				g_face[i] = f;
+
+				v1 = v2; t1 = t2; n1 = n2;
+			}
+			continue;
+		}
+	}
+
+	UnifyIndices( psource );
+
+	BuildIndividualMeshes( psource );
+
+	fclose( g_fpInput );
+
+	return 1;
+}
+
+
+
+int AppendVTAtoOBJ( s_source_t *psource, char *filename, int frame )
+{
+	char	cmd[1024];
+	int		i, j;
+	int		material = 0;
+
+	Vector tmp;
+	matrix3x4_t m;
+
+	AngleMatrix( RadianEuler( 1.570796, 0, 0 ), m );
+
+	if ( !OpenGlobalFile( filename ) )
+		return 0;
+
+	if( !g_quiet )
+	{
+		printf ("grabbing %s\n", filename );
+	}
+
+	g_iLinecount = 0;
+
+	g_numverts = g_numnormals = g_numtexcoords = g_numfaces = 0;
+
+	while ( GetLineInput() ) 
+	{
+		Vector tmp;
+
+		if (strncmp( g_szLine, "v ", 2 ) == 0)
+		{
+			i = g_numverts++;
+
+			sscanf( g_szLine, "v %f %f %f", &tmp.x, &tmp.y, &tmp.z );
+			VectorTransform( tmp, m, g_vertex[i] );
+
+			// printf("%f %f %f\n", g_vertex[i].x, g_vertex[i].y, g_vertex[i].z );
+
+			g_bone[i].numbones = 1;
+			g_bone[i].bone[0] = 0;
+			g_bone[i].weight[0] = 1.0;
+		}
+		else if (strncmp( g_szLine, "vn ", 3 ) == 0)
+		{
+			i = g_numnormals++;
+			sscanf( g_szLine, "vn %f %f %f", &tmp.x, &tmp.y, &tmp.z );
+			VectorRotate( tmp, m, g_normal[i] );
+		}
+		else if (strncmp( g_szLine, "vt ", 3 ) == 0)
+		{
+			i = g_numtexcoords++;
+			sscanf( g_szLine, "vt %f %f", &g_texcoord[i].x, &g_texcoord[i].y );
+		}
+		else if (strncmp( g_szLine, "usemtl ", 7 ) == 0)
+		{
+			sscanf( g_szLine, "usemtl %s", &cmd[0] );
+
+			int texture = LookupTexture( cmd );
+			psource->texmap[texture] = texture;	// hack, make it 1:1
+			material = UseTextureAsMaterial( texture );
+		}
+		else if (strncmp( g_szLine, "f ", 2 ) == 0)
+		{
+			int v0, n0, t0;
+			int v1, n1, t1;
+			int v2, n2, t2;
+			int v3, n3, t3;
+
+			s_tmpface_t f;
+
+			i = g_numfaces++;
+
+			j = sscanf( g_szLine, "f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", &v0, &t0, &n0, &v1, &t1, &n1, &v2, &t2, &n2, &v3, &t3, &n3 );
+
+			f.material = material;
+			f.a = v0 - 1; f.na = n0 - 1, f.ta = 0;
+			f.b = v2 - 1; f.nb = n2 - 1, f.tb = 0;
+			f.c = v1 - 1; f.nc = n1 - 1, f.tc = 0;
+
+			Assert( v0 <= g_numverts && v1 <= g_numverts && v2 <= g_numverts );
+			Assert( n0 <= g_numnormals && n1 <= g_numnormals && n2 <= g_numnormals );
+
+			g_face[i] = f;
+
+			if (j == 12)
+			{
+				i = g_numfaces++;
+				f.a = v0 - 1; f.na = n0 - 1, f.ta = 0;
+				f.b = v3 - 1; f.nb = n3 - 1, f.tb = 0;
+				f.c = v2 - 1; f.nc = n2 - 1, f.tc = 0;
+				g_face[i] = f;
+			}
+		}
+	}
+
+
+	UnifyIndices( psource );
+
+	s_sourceanim_t *pSourceAnim = FindOrAddSourceAnim( psource, "BindPose" );
+	if ( frame == 0 )
+	{
+		psource->numbones = 1;
+		strcpy( psource->localBone[0].name, "default" );
+		psource->localBone[0].parent = -1;
+		pSourceAnim->numframes = 1;
+		pSourceAnim->startframe = 0;
+		pSourceAnim->endframe = 0;
+		pSourceAnim->rawanim[0] = (s_bone_t *)kalloc( 1, sizeof( s_bone_t ) );
+		pSourceAnim->rawanim[0][0].pos.Init();
+		pSourceAnim->rawanim[0][0].rot = RadianEuler( 1.570796, 0.0, 0.0 );
+		Build_Reference( psource, "BindPose" );
+
+		BuildIndividualMeshes( psource );
+	}
+
+	// printf("%d %d : %d\n", g_numverts, g_numnormals, numvlist );
+
+	int t = frame;
+	int count = numvlist;
+
+	pSourceAnim->numvanims[t] = count;
+	pSourceAnim->vanim[t] = (s_vertanim_t *)kalloc( count, sizeof( s_vertanim_t ) );
+	for (i = 0; i < count; i++)
+	{
+		pSourceAnim->vanim[t][i].vertex = i;
+		pSourceAnim->vanim[t][i].pos = g_vertex[v_listdata[i].v];
+		pSourceAnim->vanim[t][i].normal = g_normal[v_listdata[i].n];
+	}
+
+	fclose( g_fpInput );
+
+	return 1;
+}
diff --git a/utils/studiomdl/optimize.cpp b/utils/studiomdl/optimize.cpp
new file mode 100644
index 0000000..88f6d0f
--- /dev/null
+++ b/utils/studiomdl/optimize.cpp
@@ -0,0 +1,4017 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#pragma warning( disable : 4786 )
+
+#pragma warning( disable : 4748 )		// buffer overrun with optimizations off
+// This file has tons of problems with global optimizations. . turn 'em off.
+// NOTE: Would be nice to have a test case for this! - not verified in vs2005
+#pragma optimize( "g", off )
+
+// use this much memory to build an output file in memory.
+#define FILEBUFFER_SIZE ( 4 * 1024 * 1024 )
+
+//#define IGNORE_BONES
+
+#define NVTRISTRIP
+
+#define EMIT_TRILISTS
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <float.h>
+#include "mathlib/mathlib.h"
+#include "cmdlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+#include "HardwareMatrixState.h"
+#include "HardwareVertexCache.h"
+#include "optimize.h"
+#include <malloc.h>
+#include <nvtristrip.h>
+#include "FileBuffer.h"
+#include "tier1/utlvector.h"
+#include "materialsystem/imaterial.h"
+#include "tier1/utllinkedlist.h"
+
+#include "tier1/smartptr.h"
+#include "tier2/p4helpers.h"
+
+bool g_bDumpGLViewFiles;
+extern bool g_IHVTest;
+
+// flush bones between strips rather than deallocating the LRU.
+#define USE_FLUSH
+
+extern int FindMaterialByName( const char *pMaterialName );
+
+namespace OptimizedModel
+{
+
+//-----------------------------------------------------------------------------
+// Defines which debugging output file we will see
+//-----------------------------------------------------------------------------
+
+enum 
+{ 
+	WRITEGLVIEW_SHOWMESH			= 0x00000001,
+	WRITEGLVIEW_SHOWSTRIPGROUP		= 0x00000002,
+	WRITEGLVIEW_SHOWSTRIP			= 0x00000004,
+	WRITEGLVIEW_SHOWSUBSTRIP		= 0x00000008,
+	WRITEGLVIEW_SHOWFLEXED			= 0x00000010,
+	WRITEGLVIEW_SHOWSW				= 0x00000020,
+	WRITEGLVIEW_SHOWMESHPROPS		= 0x00000040,
+	WRITEGLVIEW_SHOWVERTNUMBONES	= 0x00000080,
+	WRITEGLVIEW_SHOWSTRIPNUMBONES	= 0x00000100,
+	WRITEGLVIEW_FORCEUINT			= 0xffffffff
+};
+
+//-----------------------------------------------------------------------------
+// This is used to help us figure out where in the file data should go
+// and also to display stats
+//-----------------------------------------------------------------------------
+struct TotalMeshStats_t
+{
+	int m_TotalBodyParts;
+	int m_TotalModels;
+	int m_TotalModelLODs;
+	int m_TotalMeshes;
+	int m_TotalStrips;
+	int m_TotalStripGroups;
+	int m_TotalVerts;
+	int m_TotalIndices;
+	int m_TotalBoneStateChanges;
+	int m_TotalMaterialReplacements;
+};
+
+struct Triangle_t
+{
+	Triangle_t()
+	{
+		touched = false;
+		neighborTriID[0] = neighborTriID[1] = neighborTriID[2] = -1;
+	}
+	int vertID[3];
+	int neighborTriID[3];
+	int boneID[MAX_NUM_BONES_PER_TRI];
+	int numBones;
+	bool touched;
+};
+
+
+//-----------------------------------------------------------------------------
+// Associates software bone indices with hardware bone indices
+//-----------------------------------------------------------------------------
+struct BoneStateChange_t
+{
+	int hardwareID;
+	int newBoneID;
+};
+
+struct Strip_t
+{
+	// these are the verts and indices that are used while building.
+	// (there may be verts in here that aren't use in the stripGroup.)
+	CUtlVector<Vertex_t> verts;
+	int numIndices;
+	unsigned short *pIndices;
+
+	unsigned int flags;
+
+	int numBones;
+
+	// These are the final, sorted verts as they appear in the strip group.
+	int stripGroupIndexOffset;  // offset into stripGroup's indices
+	int numStripGroupIndices;
+	int stripGroupVertexOffset; // offset into stripGroup's verts
+	int numStripGroupVerts;
+
+	int numBoneStateChanges;
+	BoneStateChange_t boneStateChanges[MAX_NUM_BONES_PER_STRIP];
+};
+
+
+//-----------------------------------------------------------------------------
+// a list of vertices + triangles for a strip group
+//-----------------------------------------------------------------------------
+
+typedef CUtlVector<Vertex_t>	VertexList_t;
+typedef CUtlVector<Triangle_t>	TriangleList_t;
+typedef CUtlVector<unsigned short>	VertexIndexList_t;
+typedef CUtlVector<Strip_t>		StripList_t;
+typedef CUtlVector<bool>		TriangleProcessedList_t;
+
+//-----------------------------------------------------------------------------
+// String table
+//-----------------------------------------------------------------------------
+class CStringTable
+{
+public:
+	int StringTableOffset( const char *string )
+	{
+		int i;
+		int size = 0;
+		for( i = 0; i < m_Strings.Size(); i++ )
+		{
+			if( stricmp( m_Strings[i].Base(), string ) == 0 )
+			{
+				return size;
+			}
+			size += m_Strings[i].Size();
+		}
+		return -1;
+	}
+	bool StringPresent( const char *string )
+	{
+		int i;
+		for( i = 0; i < m_Strings.Size(); i++ )
+		{
+			if( stricmp( m_Strings[i].Base(), string ) == 0 )
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+	void AddString( const char *newString )
+	{
+		if( StringPresent( newString ) )
+		{
+			return;
+		}
+		CUtlVector<char> &s = m_Strings[m_Strings.AddToTail()];
+		int size = strlen( newString ) + 1;
+		s.AddMultipleToTail( size );
+		strcpy( s.Base(), newString );
+	}
+	void Purge()
+	{
+		m_Strings.Purge();
+	}
+	int CalcSize( void )
+	{
+		int size = 0;
+		int i;
+		for( i = 0; i < m_Strings.Size(); i++ )
+		{
+			size += m_Strings[i].Size();
+		}
+		return size;
+	}
+	void WriteToMem( char *pDst )
+	{
+		int size = 0;
+		int i;
+		for( i = 0; i < m_Strings.Size(); i++ )
+		{
+#ifdef _DEBUG
+			int j = Q_strlen( m_Strings[i].Base() ) + 1;
+			int k = m_Strings[i].Size();
+			Assert( j == k );
+#endif
+			memcpy( pDst + size, m_Strings[i].Base(), m_Strings[i].Size() );
+			size += m_Strings[i].Size();
+		}
+	}
+private:
+	typedef CUtlVector<char> CharVector_t;
+	CUtlVector<CharVector_t> m_Strings;
+};
+
+// global string table for the whole vtx file.
+static CStringTable s_StringTable;
+
+//-----------------------------------------------------------------------------
+// This is all the indices, vertices, and strips that make up this group
+// a group can be rendered all in one call to the material system
+//-----------------------------------------------------------------------------
+
+struct StripGroup_t
+{
+	VertexIndexList_t	indices;
+	VertexList_t		verts;
+	StripList_t			strips;
+	unsigned int flags;
+};
+
+struct Mesh_t
+{
+	CUtlVector<StripGroup_t> stripGroups;
+	unsigned int flags;
+};
+
+struct ModelLOD_t
+{
+	CUtlVector<Mesh_t> meshes;
+	float switchPoint;
+};
+
+struct Model_t
+{
+	CUtlVector<ModelLOD_t> modelLODs;
+};
+
+//-----------------------------------------------------------------------------
+// Main class that does all the dirty work to stripy + groupify
+//-----------------------------------------------------------------------------
+
+class COptimizedModel
+{
+public:
+	bool OptimizeFromStudioHdr( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts, int vertCacheSize, 
+		bool usesFixedFunction, bool bForceSoftwareSkin, bool bHWFlex, int maxBonesPerVert, int maxBonesPerTri, 
+		int maxBonesPerStrip, const char *fileName, const char *glViewFileName );
+
+private:
+	void CleanupEverything();
+
+	// Setup to get the ball rolling
+	void SetupMeshProcessing( studiohdr_t *phdr, int vertCacheSize,  
+			bool usesFixedFunction, int maxBonesPerVert, int maxBonesPerTri, 
+			int maxBonesPerStrip, const char *fileName );
+
+	// 
+	// Methods associated with pre-processing the mesh
+	//
+
+	//
+	// Methods associated with mesh processing
+	//
+
+	void SourceMeshToTriangleList( s_model_t *pSrcModel, s_mesh_t *pSrcMesh, CUtlVector<mstudioiface_t> &meshTriangleList );
+	void CreateLODTriangleList( s_model_t *pSrcModel, int nLodID, s_source_t* pLODSource,
+											mstudiomodel_t *pStudioModel,
+											mstudiomesh_t *pStudioMesh,
+											CUtlVector<mstudioiface_t> &meshTriangleList, bool writeDebug );
+
+	// This processes the model + breaks it into strips
+	void ProcessModel( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts, TotalMeshStats_t& stats, 
+		bool bForceSoftwareSkin, bool bHWFlex );
+
+	// processes a single mesh within the model
+	void ProcessMesh( Mesh_t *pMesh, studiohdr_t *pStudioHeader, CUtlVector<mstudioiface_t> &srcFaces,
+						mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, bool ForceNoFlex, 
+						bool bForceSoftwareSkin, bool bHWFlex );
+
+	// Processes a single strip group
+	void ProcessStripGroup( StripGroup_t *pStripGroup, bool isHWSkinned, bool isFlexed, 
+							mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh,
+							CUtlVector<mstudioiface_t> &srcFaces,
+							TriangleProcessedList_t& trianglesProcessed,
+							int maxBonesPerVert, int maxBonesPerTri, int maxBonesPerStrip,
+							bool forceNoFlex, bool bHWFlex );
+
+	// Constructs vertices appropriate for a strip group based on source face data
+	bool GenerateStripGroupVerticesFromFace( mstudioiface_t* pFace, 
+		mstudiomesh_t *pStudioMesh, int maxPreferredBones, Vertex_t* pStripGroupVert );
+
+	// Count the number of unique bones in a set of vertices
+	int CountUniqueBones( int count, Vertex_t *pVertex ) const;
+	int CountMaxVertBones( int count, Vertex_t *pVertex ) const;
+
+	// Counts the unique # of bones in a strip
+	int CountUniqueBonesInStrip( StripGroup_t *pStripGroup, Strip_t *pStrip );
+
+	// Builds SW + HW skinned strips
+	void BuildSWSkinnedStrips( TriangleList_t& tris, 
+		VertexList_t const& verts, StripGroup_t *pStripGroup );
+	void BuildHWSkinnedStrips( TriangleList_t& tris, VertexList_t& verts,
+		StripGroup_t *pStripGroup, int maxBonesPerStrip );
+
+	// These methods deal with finding another triangle to batch together
+	// in a similar matrix state group
+	int ComputeNewBonesNeeded( Triangle_t const& triangle ) const;
+	bool AllocateHardwareBonesForTriangle( Triangle_t *tri );
+	Triangle_t* GetNextTriangle( TriangleList_t& triangles, bool allowNewStrip );
+	Triangle_t* GetNextUntouchedWithoutBoneStateChange( TriangleList_t& triangles );
+	Triangle_t* GetNextUntouchedWithLeastBoneStateChanges( TriangleList_t& triangles );
+
+	// Actually does the stripification
+	void Stripify( VertexIndexList_t const& sourceIndices, bool isHWSkinned,
+					int* pNumIndices, unsigned short** ppIndices );
+
+	// Makes sure our vertices are using the correct bones
+	void SanityCheckVertBones( VertexIndexList_t const& list, VertexList_t const& vertices );
+
+	// Sets the flags associated with a particular strip group + mesh
+	void ComputeStripGroupFlags( StripGroup_t *pStripGroup, bool isHWSkinned, bool isFlexed );
+	void ComputeMeshFlags( Mesh_t *pMesh, studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh );
+
+	bool MeshIsTeeth( studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh );
+
+	// Tries to add neighboring vertices that'll fit into the matrix transform state
+	void BuildStripsRecursive( VertexIndexList_t& indices, TriangleList_t& list, Triangle_t *triangle );
+
+	// Figures out all bones affecting a particular triangle
+	void BuildTriangleBoneData( VertexList_t& list, Triangle_t& tri );
+
+	// Memory optimize the strip data
+	void PostProcessStripGroup( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, StripGroup_t *pStripGroup );
+
+	void COptimizedModel::ZeroNumBones( void );
+
+	//
+	// Methods associated with writing VTX files
+	//
+
+	// This writes the strip data out to a VTX file
+	void WriteVTXFile( studiohdr_t *pHdr, char const* pFileName, 
+						TotalMeshStats_t const& stats );
+
+
+	//
+	// Methods associated with writing GL View files
+	//
+
+
+	// This writes the GL debugging files
+	void WriteGLViewFiles( studiohdr_t *pHdr, const char *glViewFileName );
+
+	void OutputMemoryUsage( void );
+	bool IsVertexFlexed( mstudiomesh_t *pStudioMesh, int vertID ) const;
+	void BuildNeighborInfo( TriangleList_t& list, int nMaxVertexId );
+	void ClearTouched( void );
+	void PrintVert( Vertex_t *v, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh );
+	void SanityCheckAgainstStudioHDR( studiohdr_t *phdr );
+	void WriteStringTable( int stringTableOffset );
+	void WriteMaterialReplacements( int materialReplacementsOffset );
+	void WriteMaterialReplacementLists( int materialReplacementsOffset, int materialReplacementListOffset );
+	void WriteHeader( int vertCacheSize, int maxBonesPerVert, 
+		int maxBonesPerTri, int maxBonesPerStrip, int numBodyParts, long checkSum );
+	void WriteBodyPart( int bodyPartID, mstudiobodyparts_t *pBodyPart, int modelID );
+	void WriteModel( int modelID, mstudiomodel_t *pModel, int lodID );
+	void WriteModelLOD( int lodID, ModelLOD_t *pLOD, int meshID );
+	void WriteMesh( int meshID, Mesh_t *pMesh, int stripGroupID );
+	void WriteStripGroup( int stripGroupID, StripGroup_t *pStripGroup,
+						  int vertID, int indexID, int stripID );
+	int WriteVerts( int vertID, StripGroup_t *pStripGroup );
+	int WriteIndices( int indexID, StripGroup_t *pStripGroup );
+	void WriteStrip( int stripID, Strip_t *pStrip, int indexID, int vertID, int boneID );
+	void WriteBoneStateChange( int boneID, BoneStateChange_t *boneStateChange );
+	
+	void DrawGLViewTriangle( FILE *fp, Vector& pos1, Vector& pos2, Vector& pos3,
+										 Vector& color1, Vector& color2, Vector& color3 );
+	void WriteGLViewFile( studiohdr_t *phdr, const char *pFileName, unsigned int flags, float shrinkFactor );
+	void ShrinkVerts( float shrinkFactor );
+	void GLViewDrawBegin( int mode );
+	void CheckVertBoneWeights( Vertex_t *pVert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh );
+	void GLViewVert( FILE *fp, Vertex_t vert, int index, Vector& color, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, bool showSubStrips, float shrinkFraction );
+	void GLViewDrawEnd( void );
+	void SetMeshPropsColor( unsigned int meshFlags, Vector& color );
+	void SetFlexedAndSkinColor( unsigned int glViewFlags, unsigned int stripGroupFlags, Vector& color );
+	void SetColorFromNumVertexBones( int numBones, Vector& color );
+	Vector& GetOrigVertPosition( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert );
+	float GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
+	mstudioboneweight_t &GetOrigVertBoneWeight( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert );
+	int GetOrigVertBoneIndex( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
+	void ShowStats( void );
+	void MapGlobalBonesToHardwareBoneIDsAndSortBones( studiohdr_t *phdr );
+	void RemoveRedundantBoneStateChanges( void );
+	void CheckVert( Vertex_t *pVert, int maxBonesPerTri, int maxBonesPerVert );
+	void CheckAllVerts( int maxBonesPerTri, int maxBonesPerVert );
+	void SortBonesWithinVertex( bool flexed, Vertex_t *vert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, int *globalToHardwareBoneIndex, int *hardwareToGlobalBoneIndex, int maxBonesPerTri, int maxBonesPerVert );
+	int GetTotalVertsForMesh( Mesh_t *pMesh );
+	int GetTotalIndicesForMesh( Mesh_t *pMesh );
+	int GetTotalStripsForMesh( Mesh_t *pMesh );
+	int GetTotalStripGroupsForMesh( Mesh_t *pMesh );
+	int GetTotalBoneStateChangesForMesh( Mesh_t *pMesh );
+	bool MeshNeedsRemoval( studiohdr_t *pHdr, mstudiomesh_t *pStudioMesh,
+												   LodScriptData_t& scriptLOD );
+
+	void PrintBoneStateChanges( studiohdr_t *pHdr, int lod );
+	void PrintVerts( studiohdr_t *phdr, int lod );
+	void SanityCheckVertexBoneLODFlags( studiohdr_t *pStudioHdr, FileHeader_t *pVtxHeader );
+
+	//
+	// SOURCE DATA
+	//
+
+	// These are all the built models
+	CUtlVector<Model_t> m_Models;
+	
+	// total number of bones in the studio model
+	int m_NumBones;
+
+	// information about the hardware
+	int m_VertexCacheSize;
+	int m_MaxBonesPerTri;
+	int m_MaxBonesPerVert;
+	int	m_MaxBonesPerStrip;
+	bool m_UsesFixedFunction;
+
+	// stats
+	int m_NumSkinnedAndFlexedVerts;
+
+	CHardwareMatrixState m_HardwareMatrixState;
+
+	// a place to stick file output.
+	CFileBuffer *m_FileBuffer;
+
+	// offset for different items in the output file.
+	int m_BodyPartsOffset;
+	int m_ModelsOffset;
+	int m_ModelLODsOffset;
+	int m_MeshesOffset;
+	int m_StripGroupsOffset;
+	int m_StripsOffset;
+	int m_VertsOffset;
+	int m_IndicesOffset;
+	int m_BoneStageChangesOffset;
+	int m_StringTableOffset;
+	int m_MaterialReplacementsOffset;
+	int m_MaterialReplacementsListOffset;
+	int m_EndOfFileOffset;
+};
+
+//-----------------------------------------------------------------------------
+// Singleton instance
+//-----------------------------------------------------------------------------
+
+static COptimizedModel s_OptimizedModel;
+
+
+//-----------------------------------------------------------------------------
+// Cleanup method
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::CleanupEverything()
+{
+}
+
+
+
+void COptimizedModel::OutputMemoryUsage( void )
+{
+	printf( "body parts:   %7d bytes\n", ( int )( m_ModelsOffset - m_BodyPartsOffset ) );
+	printf( "models:       %7d bytes\n", ( int )( m_MeshesOffset - m_ModelsOffset ) );
+	printf( "model LODs:   %7d bytes\n", ( int )( m_MeshesOffset - m_ModelLODsOffset ) );
+	printf( "meshes:       %7d bytes\n", ( int )( m_StripGroupsOffset - m_MeshesOffset ) );
+	printf( "strip groups: %7d bytes\n", ( int )( m_StripsOffset - m_StripGroupsOffset ) );
+	printf( "strips:       %7d bytes\n", ( int )( m_VertsOffset - m_StripsOffset ) );
+	printf( "verts:        %7d bytes\n", ( int )( m_IndicesOffset - m_VertsOffset ) );
+	printf( "indices:      %7d bytes\n", ( int )( m_BoneStageChangesOffset - m_IndicesOffset ) );
+	printf( "bone changes: %7d bytes\n", ( int )( m_EndOfFileOffset - m_BoneStageChangesOffset ) );
+	printf( "everything:   %7d bytes\n", ( int )( m_EndOfFileOffset ) );
+}
+
+void COptimizedModel::SanityCheckAgainstStudioHDR( studiohdr_t *phdr )
+{
+#if 0 // garymcthack
+	printf( "SanityCheckAgainstStudioHDR\n" );
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	Assert( header->numBodyParts == phdr->numbodyparts );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+		Assert( bodyPart->numModels == pStudioBodyPart->nummodels );
+		for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *model = bodyPart->pModel( modelID );
+			mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+			Assert( model->numMeshes == pStudioModel->nummeshes );
+			for( int meshID = 0; meshID < model->numMeshes; meshID++ )
+			{
+				MeshHeader_t *mesh = model->pMesh( meshID );
+				mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+				for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+				{
+					StripGroupHeader_t *stripGroup = mesh->pStripGroup( stripGroupID );
+					for( int stripID = 0; stripID < stripGroup->numStrips; stripID++ )
+					{
+						StripHeader_t *strip = stripGroup->pStrip( stripID );
+					}
+				}
+			}
+		}
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// The following methods are all related to creating groups of meshes to strip
+//
+//-----------------------------------------------------------------------------
+
+
+
+//-----------------------------------------------------------------------------
+// pick any triangle that hasn't been used yet to start with.
+//-----------------------------------------------------------------------------
+
+static Triangle_t *GetNextUntouched( TriangleList_t& triangles )
+{
+	int i;
+	for( i = 0; i < triangles.Size(); i++ )
+	{
+		if( !triangles[i].touched )
+			return &triangles[i];
+	}
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the number of bones that are not represented in the current hardware state
+//-----------------------------------------------------------------------------
+
+inline int COptimizedModel::ComputeNewBonesNeeded( Triangle_t const& triangle )	const
+{
+	int numNewBones = 0;
+	for( int i = 0; i < triangle.numBones; ++i )
+	{
+		if( !m_HardwareMatrixState.IsMatrixAllocated( triangle.boneID[i] ) )
+			++numNewBones;
+	}
+	return numNewBones;
+}
+
+
+//-----------------------------------------------------------------------------
+// returns triangle index
+// Find the next triangle without a bone state change
+// May add new hardware bones if there is space and is necessary.
+//-----------------------------------------------------------------------------
+
+Triangle_t* COptimizedModel::GetNextUntouchedWithoutBoneStateChange( TriangleList_t& triangles )
+{
+	Triangle_t *bestTriangle = 0;
+	int bestNumNewBones = MAX_NUM_BONES_PER_TRI + 1;
+	
+	int i;
+	for( i = 0; i < triangles.Size(); i++ )
+	{
+		// We haven't processed this one, so let's try it
+		if( !triangles[i].touched )
+		{
+			// How many bones are not represented in the current state?
+			int numNewBones = ComputeNewBonesNeeded( triangles[i] );
+
+			// if this triangle fit and if it's the best so far, save it.
+			if ( (numNewBones <= m_HardwareMatrixState.FreeMatrixCount()) && 
+				 (numNewBones < bestNumNewBones ) )
+			{
+				bestNumNewBones = numNewBones;
+				bestTriangle = &triangles[i];
+
+				// Can't get any better than this!
+				if (bestNumNewBones == 0)
+					break;
+			}
+		}
+	}
+	return bestTriangle;
+}
+
+
+//-----------------------------------------------------------------------------
+// This will returns the triangle that requires the last number of bone
+// state changes
+//-----------------------------------------------------------------------------
+
+Triangle_t *COptimizedModel::GetNextUntouchedWithLeastBoneStateChanges( TriangleList_t& triangles )
+{
+	Triangle_t *bestTriangle = 0;
+	int bestNumNewBones = MAX_NUM_BONES_PER_TRI + 1;
+	int i;
+	
+	// For this one, just find the triangle that needs the least number
+	// of new bones. That way, we'll not have to change too many states
+	for( i = 0; i < triangles.Size(); i++ )
+	{
+		if( !triangles[i].touched )
+		{
+			int numNewBones = ComputeNewBonesNeeded( triangles[i] );
+
+			if( numNewBones < bestNumNewBones )
+			{
+				bestNumNewBones = numNewBones;
+				bestTriangle = &triangles[i];
+			}
+		}
+	}
+	
+	// This only happens if there are no triangles untouched
+	if( !bestTriangle )
+		return 0;
+
+#ifdef USE_FLUSH
+	m_HardwareMatrixState.DeallocateAll();
+#else
+	// Remove bones until we have enough space...
+	int numToRemove = bestNumNewBones - m_HardwareMatrixState.FreeMatrixCount();
+	Assert( numToRemove > 0 );
+	m_HardwareMatrixState.DeallocateLRU(numToRemove);
+#endif
+
+	return bestTriangle;
+}
+
+
+//-----------------------------------------------------------------------------
+// Allocate bones for a triangle from the hardware matrix state
+//-----------------------------------------------------------------------------
+
+bool COptimizedModel::AllocateHardwareBonesForTriangle( Triangle_t *tri )
+{
+	for( int i = 0; i < tri->numBones; ++i )
+	{
+		int bone = tri->boneID[i];
+		if( !m_HardwareMatrixState.IsMatrixAllocated( bone ) )
+		{
+			if( !m_HardwareMatrixState.AllocateMatrix( bone ) )
+				return false;
+		}
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Get the next triangle.
+// Try to find one that doesn't cause a bone state change by jumping to 
+// a new location in the model that works with the bones that we have allocated.
+// If we can't find one, and allowNewStrip is true, then flush and pick the next
+// best triangle that is close to the current hardware bone state.
+//-----------------------------------------------------------------------------
+
+Triangle_t *COptimizedModel::GetNextTriangle( TriangleList_t& tris, bool allowNewStrip )
+{
+	// First try to get a triangle that doesn't involve changing matrix state
+	Triangle_t *tri;
+	tri = GetNextUntouchedWithoutBoneStateChange( tris );
+
+	// If that didn't work, pick the triangle that changes the state the least
+	if( !tri && allowNewStrip )
+	{
+		tri = GetNextUntouchedWithLeastBoneStateChanges( tris );
+	}
+
+	// Return the triangle we found
+	return tri;
+}
+
+
+//-----------------------------------------------------------------------------
+// Make sure all vertices we've added up to now use bones in the matrix list
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::SanityCheckVertBones( VertexIndexList_t const& list, VertexList_t const& vertices )
+{
+#ifdef _DEBUG
+	Vertex_t const *pVert;
+	int i;
+	for( i = 0; i < list.Size(); i++ )
+	{
+		pVert = &vertices[list[i]];
+		if( !g_staticprop )
+		{
+			Assert( pVert->numBones != 0 );
+		}
+		int j;
+		for( j = 0; j < pVert->numBones; j++ )
+		{
+			if( pVert->boneID[j] == -1 )
+			{
+				continue;
+			}
+			if( !m_HardwareMatrixState.IsMatrixAllocated( pVert->boneID[j] ) )
+			{
+				Assert( 0 );
+			}
+		}
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Make sure all vertices we've added up to now use bones in the matrix list
+//-----------------------------------------------------------------------------
+void COptimizedModel::Stripify( VertexIndexList_t const& sourceIndices, bool isHWSkinned,
+							    int* pNumIndices, unsigned short** ppIndices ) 
+{
+	if( sourceIndices.Size() == 0 )
+	{
+		*ppIndices = 0;
+		*pNumIndices = 0;
+		return;
+	}
+
+	// Skip the tristripping phase if we're building in preview mode
+	if ( g_bBuildPreview || isHWSkinned == false )
+	{
+		*pNumIndices = sourceIndices.Count();
+		*ppIndices = new unsigned short[*pNumIndices];
+		memcpy( *ppIndices, sourceIndices.Base(), (*pNumIndices) * sizeof(unsigned short) );
+		return;
+	}
+
+/*
+	printf( "Stripify\n" );
+	int i;
+	for( i = 0; i < sourceIndices.Size(); i++ )
+	{
+		printf( "stripindex: %d\n", sourceIndices[i] );
+	}
+*/
+
+#ifdef NVTRISTRIP
+	PrimitiveGroup *primGroups;
+	unsigned short numPrimGroups;
+
+	// Be sure to call delete[] on the returned primGroups to avoid leaking mem
+	GenerateStrips( &sourceIndices[0], sourceIndices.Size(),
+		&primGroups, &numPrimGroups );
+	Assert( numPrimGroups == 1 );
+	*pNumIndices = primGroups->numIndices;
+	*ppIndices = new unsigned short[*pNumIndices];
+	memcpy( *ppIndices, primGroups->indices, sizeof( unsigned short ) * *pNumIndices );
+	delete [] primGroups;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// eat up triangle recursively by flood-filling around the model until
+// we run out of bones on the hardware.
+//-----------------------------------------------------------------------------
+void COptimizedModel::BuildStripsRecursive( VertexIndexList_t& indices,
+								TriangleList_t& tris, Triangle_t *triangle )
+{
+	Assert( triangle );
+
+	// Don't process the triangle if it's already been processed
+	if( triangle->touched )
+		return;
+
+	// Only suck in triangles that need no state change
+	if ( ComputeNewBonesNeeded( *triangle ) )
+		return;
+
+	// We've got enough hardware bones. Lets add this triangle's vertices, and 
+	// then add the vertices of all the neighboring triangles.
+	triangle->touched = true;
+
+	indices.AddToTail( ( unsigned short )triangle->vertID[0] );
+	indices.AddToTail( ( unsigned short )triangle->vertID[1] );
+	indices.AddToTail( ( unsigned short )triangle->vertID[2] );
+
+	// Try to add our neighbors
+	if( triangle->neighborTriID[0] != -1 )
+	{
+		BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[0]] );
+	}
+	if( triangle->neighborTriID[1] != -1 )
+	{
+		BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[1]] );
+	}
+	if( triangle->neighborTriID[2] != -1 )
+	{
+		BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[2]] );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Processes a HW-skinned strip group
+//-----------------------------------------------------------------------------
+void COptimizedModel::BuildHWSkinnedStrips( TriangleList_t& triangles, 
+	VertexList_t& vertices, StripGroup_t *pStripGroup, int maxBonesPerStrip )
+{
+	// Set up the hardware matrix state
+	m_HardwareMatrixState.Init( maxBonesPerStrip );
+
+	// Empty out the list of triangles to be stripified.
+	VertexIndexList_t trianglesToStrip;
+	trianglesToStrip.EnsureCapacity( triangles.Size() * 3 );
+
+	// pick any old unused triangle to start with.
+	Triangle_t *pSeedTri = GetNextUntouched( triangles );
+	while( pSeedTri )
+	{
+		// Make sure we've got out transforms allocated
+#ifdef DBGFLAG_ASSERT
+		bool ok = 
+#endif
+			AllocateHardwareBonesForTriangle( pSeedTri );
+		Assert( ok );
+
+		// eat up triangle recursively by flood-filling around the model until
+		// we run out of bones on the hardware.
+		BuildStripsRecursive( trianglesToStrip, triangles, pSeedTri );
+
+		// Try to jump to a new location in the mesh without 
+		// causing a hardware bone state overflow or flush.
+		pSeedTri = GetNextTriangle( triangles, false );
+		if( pSeedTri )
+			continue;
+
+		// Save the results of the generated strip.
+		int stripIdx = pStripGroup->strips.AddToTail( );
+		Strip_t& newStrip = pStripGroup->strips[stripIdx];
+
+		// Compute the strip flags
+		newStrip.flags = 0;
+#ifdef EMIT_TRILISTS
+		newStrip.flags |= STRIP_IS_TRILIST;
+#else
+		newStrip.flags |= STRIP_IS_TRISTRIP;
+#endif
+
+		// Sanity check the indices of the bones.
+		SanityCheckVertBones( trianglesToStrip, vertices );
+
+		// There are no more triangles to eat up without causing a flush, so 
+		// go ahead and stripify what we have and flush.
+		// NOTE: This allocates space for stripIndices.pIndices.
+		Stripify( trianglesToStrip, true, &newStrip.numIndices, &newStrip.pIndices );
+
+		// hack - should just build directly into newStrip.verts instead of using a global.
+		int i;
+		for( i = 0; i < vertices.Size(); i++ )
+		{
+			newStrip.verts.AddToTail( vertices[i] );
+		}
+
+		// Compute the number of bones in this strip
+		newStrip.numBoneStateChanges = m_HardwareMatrixState.AllocatedMatrixCount();
+		Assert( newStrip.numBoneStateChanges <= maxBonesPerStrip );
+
+		// Save off the bones used for this strip.
+		for( i = 0; i < m_HardwareMatrixState.AllocatedMatrixCount(); i++ )
+		{
+			newStrip.boneStateChanges[i].hardwareID = i;
+			newStrip.boneStateChanges[i].newBoneID = m_HardwareMatrixState.GetNthBoneGlobalID( i );
+		}
+
+		// Empty out the triangles to strip so that we can start again with a new strip.
+		trianglesToStrip.RemoveAll();
+
+		// Get the next best triangle, allowing for a bone state flushes.
+		pSeedTri = GetNextTriangle( triangles, true );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Processes a SW-skinned strip group
+//-----------------------------------------------------------------------------
+void COptimizedModel::BuildSWSkinnedStrips( TriangleList_t& triangles, 
+	VertexList_t const& vertices, StripGroup_t *pStripGroup )
+{
+	// Save the results of the generated strip.
+	int stripIdx = pStripGroup->strips.AddToTail( );
+	Strip_t& newStrip = pStripGroup->strips[stripIdx];
+
+	// Set the strip flags
+	newStrip.flags = 0;
+#ifdef EMIT_TRILISTS
+	newStrip.flags |= STRIP_IS_TRILIST;
+#else
+	newStrip.flags |= STRIP_IS_TRISTRIP;
+#endif
+
+	int nTriangleCount = triangles.Count();
+
+	VertexIndexList_t indices;
+	indices.EnsureCapacity( nTriangleCount * 3 );
+
+	for( int i = 0; i < nTriangleCount; i++ )
+	{
+		Triangle_t* triangle = &triangles[i];
+		triangle->touched = true;
+		indices.AddToTail( ( unsigned short )triangle->vertID[0] );
+		indices.AddToTail( ( unsigned short )triangle->vertID[1] );
+		indices.AddToTail( ( unsigned short )triangle->vertID[2] );
+	}
+	
+	Stripify( indices, false, &newStrip.numIndices, &newStrip.pIndices );
+
+	// hack - should just build directly into newStrip.verts instead of using a global.
+	for( int i = 0; i < vertices.Size(); i++ )
+	{
+		newStrip.verts.AddToTail( vertices[i] );
+	}
+
+	newStrip.numBoneStateChanges = 0;
+	for( int i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
+	{
+		newStrip.boneStateChanges[i].hardwareID = -1;
+		newStrip.boneStateChanges[i].newBoneID = -1;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns true if a particular vertex is part of a flex
+//-----------------------------------------------------------------------------
+bool COptimizedModel::IsVertexFlexed( mstudiomesh_t *pStudioMesh, int vertID ) const
+{
+	mstudioflex_t	*pflex = pStudioMesh->pFlex( 0 );
+	
+	int i, j, n;
+
+	// Iterate through all the flexes
+	// figure out if the vertex is part of the flex
+	for (i = 0; i < pStudioMesh->numflexes; i++)
+	{
+		byte *pvanim = pflex[i].pBaseVertanim();
+		int nVAnimSizeBytes = pflex[i].VertAnimSizeBytes();
+
+		for (j = 0; j < pflex[i].numverts; j++, pvanim += nVAnimSizeBytes )
+		{
+			mstudiovertanim_t *pAnim = (mstudiovertanim_t*)( pvanim );
+
+			n = pAnim->index;
+			if ( n == vertID )
+				return true;
+		}
+	}
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Computes flags for the strip group
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::ComputeStripGroupFlags( StripGroup_t *pStripGroup,
+											  bool isHWSkinned, bool isFlexed )
+{
+	pStripGroup->flags = 0;
+	if( isFlexed )
+	{
+		pStripGroup->flags |= STRIPGROUP_IS_FLEXED;
+		pStripGroup->flags |= STRIPGROUP_IS_DELTA_FLEXED;	// Going forward, DX9 models are delta flexed
+	}
+	if( isHWSkinned )
+	{
+		pStripGroup->flags |= STRIPGROUP_IS_HWSKINNED;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Try to reduce the number of bones affecting this vert so hardware can deal
+//-----------------------------------------------------------------------------
+
+#define MIN_BONE_INFLUENCE 1.0f
+
+static void	TryToReduceBoneInfluence( Vertex_t& stripGroupVert, 
+							mstudioboneweight_t const& boneWeights, int maxBones )
+{
+	int i;
+	while (	stripGroupVert.numBones > maxBones)
+	{
+		// Find the minimum bone weight...
+		float minWeight = 2.0;
+		int minIndex = -1;
+		for( i = 0; i < MAX_NUM_BONES_PER_VERT; ++i )
+		{
+			if (stripGroupVert.boneID[i] != -1)
+			{
+				float weight = boneWeights.weight[ stripGroupVert.boneWeightIndex[i] ];
+				if (weight < minWeight)
+				{
+					minWeight = weight;
+					minIndex = i;
+				}
+			}
+		}
+		Assert( minIndex >= 0 );
+		
+		// Now that we got it, remove that bone influence if it's small enough
+		if (minWeight >= MIN_BONE_INFLUENCE)
+			return;
+
+		// Blat out that bone!
+		for( i = minIndex; i < MAX_NUM_BONES_PER_VERT - 1; ++i )
+		{
+			stripGroupVert.boneID[i] = stripGroupVert.boneID[i+1];
+			stripGroupVert.boneWeightIndex[i] = stripGroupVert.boneWeightIndex[i+1];
+		}
+		stripGroupVert.boneID[ MAX_NUM_BONES_PER_VERT - 1] = -1;
+		stripGroupVert.boneWeightIndex[ MAX_NUM_BONES_PER_VERT - 1] = 0;
+
+		--stripGroupVert.numBones;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Generate three strip-group ready vertices from source mesh data
+// returns true if the face contants a flexed vertex
+//-----------------------------------------------------------------------------
+
+bool COptimizedModel::GenerateStripGroupVerticesFromFace(	mstudioiface_t* pFace, 
+															mstudiomesh_t *pStudioMesh, 
+															int maxPreferredBones,
+															Vertex_t* pStripGroupVert )
+{
+	int vertIDs[3];
+	vertIDs[0] = pFace->a;
+	vertIDs[1] = pFace->b;
+	vertIDs[2] = pFace->c;
+	
+	const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
+	Assert( vertData ); // This can only return NULL on X360 for now
+
+	bool triangleIsFlexed = false;
+	for( int faceIndex = 0; faceIndex < 3; ++faceIndex )
+	{
+		// Get the original source vertex id
+		int vertex = vertIDs[faceIndex];
+
+		// Check the verts of the triangle to see if they are flexed
+		triangleIsFlexed = triangleIsFlexed || IsVertexFlexed( pStudioMesh, vertex );
+
+		// How many bones affect this vertex
+		mstudioboneweight_t *pBoneWeight = vertData->BoneWeights(vertex);
+
+		int bonesAffectingVertex = pBoneWeight->numbones;
+		if( !g_staticprop && bonesAffectingVertex <= 0 )
+		{
+			MdlWarning( "too few bones/vert (%d) : it has no bones!\n", bonesAffectingVertex );
+		}
+		else if( bonesAffectingVertex > MAX_NUM_BONES_PER_VERT )
+		{
+			MdlError( "too many bones/vert (%d) : MAX_NUM_BONES_PER_VERT needs to be upped\n", bonesAffectingVertex );
+		}
+
+		// Set the fields of the strip group's vert
+		pStripGroupVert[faceIndex].origMeshVertID = vertex;
+
+		pStripGroupVert[faceIndex].numBones = bonesAffectingVertex;
+
+		int boneID;
+
+#ifndef IGNORE_BONES
+		for( boneID = 0; boneID < bonesAffectingVertex; boneID++ )
+		{
+			pStripGroupVert[faceIndex].boneID[boneID] = pBoneWeight->bone[boneID];
+			pStripGroupVert[faceIndex].boneWeightIndex[boneID] = boneID;
+		}
+		for( ; boneID < MAX_NUM_BONES_PER_VERT; boneID++ )
+		{
+			pStripGroupVert[faceIndex].boneID[boneID] = -1;
+			pStripGroupVert[faceIndex].boneWeightIndex[boneID] = boneID;
+		}
+#else
+		// don't let bones have any influence.
+		for( boneID = 0; boneID < MAX_NUM_BONES_PER_VERT; boneID++ )
+		{
+			pStripGroupVert[faceIndex].boneID[boneID] = -1;
+			pStripGroupVert[faceIndex].boneWeights[boneID] = 0;
+		}
+#endif
+
+		// For hardware skinning, we want to try to reduce the number of
+		// bone influences, which we'll do here if we can.
+		// At the moment, we can't do this for fixed function because
+		// we get seam problems at transitions between SW and HW rendered
+		if (!m_UsesFixedFunction)
+		{
+			if ((maxPreferredBones > 0) && (bonesAffectingVertex > maxPreferredBones))
+			{
+				TryToReduceBoneInfluence( pStripGroupVert[faceIndex], *pBoneWeight, 
+					maxPreferredBones );
+			}
+		}
+	}
+
+	return triangleIsFlexed;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the unique number of bones in a specified set of vertices
+//-----------------------------------------------------------------------------
+
+int COptimizedModel::CountUniqueBones( int count, Vertex_t *pVertex ) const
+{
+	int uniqueBoneCount = 0;
+	int uniqueBoneList[MAX_NUM_BONES_PER_STRIP];
+	while ( --count >= 0 )
+	{
+		for (int i = 0; i < pVertex[count].numBones; ++i)
+		{
+			int boneID = pVertex[count].boneID[i];
+			int j = uniqueBoneCount;
+			while ( --j >= 0 )
+			{
+				if (uniqueBoneList[j] == boneID)
+					break;
+			}
+
+			// Didn't find a match!
+			if (j < 0)
+			{
+				Assert( uniqueBoneCount < MAX_NUM_BONES_PER_STRIP );
+				uniqueBoneList[uniqueBoneCount++] = boneID;
+			}
+		}
+	}
+
+	return uniqueBoneCount;
+}
+
+int COptimizedModel::CountMaxVertBones( int count, Vertex_t *pVertex ) const
+{
+	int maxBones = 0;
+	while ( --count >= 0 )
+	{
+		if (maxBones < pVertex[count].numBones)
+			maxBones = pVertex[count].numBones;
+	}
+
+	return maxBones;
+}
+
+//-----------------------------------------------------------------------------
+// Adds a vertex to the list of vertices to be added to the strip group
+//-----------------------------------------------------------------------------
+
+static int FindOrCreateVertex( VertexList_t& list, Vertex_t const& vert )
+{
+	int i;
+	for( i = 0; i < list.Size(); i++ )
+	{
+		if (list[i].origMeshVertID == vert.origMeshVertID)
+		{
+			// If this is the case, then everything else should be too!
+			Assert( !memcmp( &list[i], &vert, sizeof( vert )) );
+			return i;
+		}
+	}
+
+	list.AddToTail( vert );
+	return i;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the bones used by the triangle
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::BuildTriangleBoneData( VertexList_t& list, Triangle_t& tri )
+{
+	int j, k, l;
+
+	// Blat out the bone ID state
+	tri.numBones = 0;
+	for( j = 0; j < MAX_NUM_BONES_PER_TRI; j++ )
+	{
+		tri.boneID[j] = -1;
+	}
+
+	// Iterate through the vertices in the triangle
+	for( j = 0; j < 3; j++ )
+	{
+		// Iterate over the bones influencing the vertex
+		Vertex_t& vert = list[tri.vertID[j]];
+		for( k = 0; k < vert.numBones; ++k )
+		{
+			int bone = vert.boneID[k];
+			Assert( (bone >= 0) && (bone < m_NumBones) );
+
+			// Look for matches with previously found bones
+			for ( l = tri.numBones; --l >= 0; )
+			{
+				if ( bone == tri.boneID[l] )
+					break;
+			}
+
+			// No match, add it to our list
+			if ( l < 0 )
+				tri.boneID[tri.numBones++] = bone;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes neighboring triangles along each face of a triangle
+//-----------------------------------------------------------------------------
+struct EdgeInfo_t
+{
+	int m_nConnectedVertId;
+	int m_nEdgeIndex;
+	int m_nTriangleId;
+};
+
+static void FindMatchingEdge( TriangleList_t& list, int nTriangleId, int nEdgeIndex, 
+	const int *pVertIds, CUtlVector< int >& vertexToEdges, CUtlFixedLinkedList< EdgeInfo_t >& edges )
+{
+	// Have we already attached this edge to something?
+	Triangle_t &tri = list[nTriangleId];
+	if ( tri.neighborTriID[nEdgeIndex] != -1 )
+		return;
+
+	int nVertIndex = ( pVertIds[0] < pVertIds[1] ) ? 0 : 1;
+	int nConnectedVertId = pVertIds[ 1-nVertIndex ];
+	int hFirstEdge = vertexToEdges[nVertIndex];
+	for ( int hEdge = hFirstEdge; hEdge != edges.InvalidIndex(); hEdge = edges.Next(hEdge) )
+	{
+		EdgeInfo_t &edge = edges[hEdge];
+		if ( edge.m_nConnectedVertId != nConnectedVertId )
+			continue;
+
+		// Can't attach triangles to themselves
+		if ( edge.m_nTriangleId == nTriangleId )
+			continue;
+
+		// Found a match! Mark the two triangles as sharing an edge
+		tri.neighborTriID[nEdgeIndex] = edge.m_nTriangleId;
+		list[ edge.m_nTriangleId ].neighborTriID[ edge.m_nEdgeIndex ] = nTriangleId;
+		if ( hEdge == hFirstEdge )
+		{
+			vertexToEdges[nVertIndex] = edges.Next( hFirstEdge );
+		}
+		edges.Free( hEdge );
+		return;
+	}
+
+	// No match! Insert the disconnected edge into the edge list
+	int hNewEdge = edges.Alloc( true );
+	EdgeInfo_t &newEdge = edges[hNewEdge];
+	newEdge.m_nConnectedVertId = nConnectedVertId;
+	newEdge.m_nEdgeIndex = nEdgeIndex;
+	newEdge.m_nTriangleId = nTriangleId;
+	edges.LinkBefore( hFirstEdge, hNewEdge );
+	vertexToEdges[nVertIndex] = hNewEdge;
+}
+
+void COptimizedModel::BuildNeighborInfo( TriangleList_t& list, int nMaxVertexId )
+{
+	// NOTE: vertexToEdges[vertId] contains the index of the head of a linked list stored in edges
+	CUtlFixedLinkedList< EdgeInfo_t > edges;
+	CUtlVector< int > vertexToEdges;
+	vertexToEdges.SetCount( nMaxVertexId );
+	memset( vertexToEdges.Base(), 0, nMaxVertexId * sizeof(int) );
+
+	int pEdgeVertIds[2];
+	int nTriCount = list.Count();
+	for ( int i = 0; i < nTriCount; ++i )
+	{
+		Triangle_t &tri = list[i];
+
+		// Add the three edges for this tri into a lookup table indexed by the lower vertID
+		pEdgeVertIds[0] = tri.vertID[0]; pEdgeVertIds[1] = tri.vertID[1];
+		FindMatchingEdge( list, i, 0, pEdgeVertIds, vertexToEdges, edges );
+
+		pEdgeVertIds[0] = tri.vertID[1]; pEdgeVertIds[1] = tri.vertID[2];
+		FindMatchingEdge( list, i, 1, pEdgeVertIds, vertexToEdges, edges );
+
+		pEdgeVertIds[0] = tri.vertID[2]; pEdgeVertIds[1] = tri.vertID[0];
+		FindMatchingEdge( list, i, 2, pEdgeVertIds, vertexToEdges, edges );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Processes a single strip group
+//-----------------------------------------------------------------------------
+void COptimizedModel::ProcessStripGroup( StripGroup_t *pStripGroup, bool isHWSkinned, 
+										bool isFlexed, mstudiomodel_t *pStudioModel, 
+										mstudiomesh_t *pStudioMesh,	
+										CUtlVector<mstudioiface_t> &srcFaces,
+										TriangleProcessedList_t& trianglesProcessed,
+										int maxBonesPerVert, int maxBonesPerTri, 
+										int maxBonesPerStrip, bool forceNoFlex, bool bHWFlex )
+{
+	ComputeStripGroupFlags( pStripGroup, isHWSkinned, isFlexed );
+
+	// all of the triangles before stripping for the current stripgroup.
+	TriangleList_t	stripGroupSourceTriangles;
+	VertexList_t	stripGroupVertices;
+
+	// FIXME: Flexed/HWSkinned state of faces don't change with each pass.
+	// We could precompute those flags just once (instead of doing it 4 times)
+
+	// Add each face to the stripgroup, if it's appropriate
+	for( int n=0; n < srcFaces.Size(); ++n )
+	{
+		// Don't bother processing a triangle that's already been done
+		if (trianglesProcessed[n])
+			continue;
+
+		mstudioiface_t *pFace = &srcFaces[n];
+
+		int preferredBones = isHWSkinned && (bHWFlex || !isFlexed) ? maxBonesPerVert : 0;
+		// start a new strip group header.
+		Vertex_t stripGroupVert[3];
+		bool triangleIsFlexed = GenerateStripGroupVerticesFromFace( 
+			pFace, pStudioMesh, 
+			preferredBones, 
+			stripGroupVert );
+
+		if( forceNoFlex )
+		{
+			triangleIsFlexed = false;
+		}
+		
+		// Don't bother to add the vertices to our strip-group vertex list
+		// if we don't need to.
+		if ( triangleIsFlexed != isFlexed )
+			continue;
+
+		// If we're doing software skinning, then always accept, even if 
+		// this triangle should have been a HW skinned triangle.
+		if (isHWSkinned)
+		{
+			// Check how many unique bones were in that face, and how many vertices
+			// maximally in a vertex
+			int numVertexBones = CountMaxVertBones( 3, stripGroupVert );
+			int numTriangleBones = CountUniqueBones( 3, stripGroupVert );
+
+			// If we have too many, we'll be skinning in software
+			bool triangleIsHWSkinned = ( numTriangleBones <= maxBonesPerTri ) &&
+										( numVertexBones <= maxBonesPerVert );
+
+			// Don't bother to add vertices which aren't gonna be used in this pass
+			if (!triangleIsHWSkinned)
+				continue;
+		}
+
+		// Add a new triangle to our list of triangles
+		int triIndex = stripGroupSourceTriangles.AddToTail( );
+
+		Triangle_t& newTri = stripGroupSourceTriangles[triIndex];
+		newTri.vertID[0] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[0] );
+		newTri.vertID[1] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[1] );
+		newTri.vertID[2] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[2] );
+		BuildTriangleBoneData( stripGroupVertices, newTri );
+
+		// By default, this processes a triangle
+		// Later on below, we may decide to un-process triangles
+		// if tristrips that are too small are generated
+		trianglesProcessed[n] = true;
+	}
+	
+	// No mesh? bye bye
+	if (stripGroupSourceTriangles.Size() == 0)
+		return;
+
+	// Figure out neighboring triangles
+	BuildNeighborInfo( stripGroupSourceTriangles, stripGroupVertices.Count() );
+
+	// Build the actual strips
+	if( isHWSkinned )
+	{
+		BuildHWSkinnedStrips( stripGroupSourceTriangles, stripGroupVertices, pStripGroup, maxBonesPerStrip );
+
+		// Check to see if any strips were produced that are too small
+		// If so, remove them, and let the software pass take care of them.
+		//if (stripGroupSourceTriangles.Size() < m_MinimumGroupSize
+		//	trianglesProcessed[n] = false;
+	}
+	else
+	{
+		BuildSWSkinnedStrips( stripGroupSourceTriangles, stripGroupVertices, pStripGroup );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// How many unique bones are in a strip?
+//-----------------------------------------------------------------------------
+
+int COptimizedModel::CountUniqueBonesInStrip( StripGroup_t *pStripGroup, Strip_t *pStrip )
+{
+	int *boneUsageCounts = ( int * )_alloca( m_NumBones * sizeof( int ) );
+	memset( boneUsageCounts, 0, sizeof( int ) * m_NumBones );
+	int i;
+	for( i = 0; i < pStrip->numStripGroupVerts; i++ )
+	{
+		Vertex_t *pVert = &pStripGroup->verts[i+pStrip->stripGroupVertexOffset];
+		if( !g_staticprop )
+		{
+			Assert( pVert->numBones != 0 );
+		}
+		int j;
+		for( j = 0; j < pVert->numBones; j++ )
+		{
+			int boneID;
+			boneID = pVert->boneID[j];
+			Assert( boneID != -1 );
+			boneUsageCounts[boneID]++;
+		}
+	}
+	int numBones = 0;
+	for( i = 0; i < m_NumBones; i++ )
+	{
+		if( boneUsageCounts[i] )
+		{
+			numBones++;
+		}
+	}
+	return numBones;
+}
+
+
+//-----------------------------------------------------------------------------
+// A little work to be done after we construct the strip groups
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::PostProcessStripGroup( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, StripGroup_t *pStripGroup )
+{
+	int i;
+	
+	// We're gonna compile all of the vertices in the current strip into
+	// the current strip group's vertex list
+	for( i = 0; i < pStripGroup->strips.Size(); i++ )
+	{
+		// create sorted strip verts and indices in the stripgroup
+		Strip_t *pStrip = &pStripGroup->strips[i];
+		int vertOffset = pStripGroup->verts.Size();
+		pStrip->stripGroupVertexOffset = vertOffset;
+		pStrip->stripGroupIndexOffset = pStripGroup->indices.Size();
+
+		// make sure we have enough memory allocated
+		pStripGroup->indices.EnsureCapacity( pStripGroup->indices.Size() + pStrip->numIndices );
+
+		// Try to find each of the strip's vertices in the strip group
+		int maxNumBones = 0;
+		int j;
+		for( j = 0; j < pStrip->numIndices; j++ )
+		{
+			int newIndex = -1;
+			int index = pStrip->pIndices[j];
+			Vertex_t *pVert = &pStrip->verts[index];
+
+			// Does this vertex exist in the strip group?
+			int k;
+			for( k = vertOffset; k < pStripGroup->verts.Size(); k++ )
+			{
+				if( pVert->origMeshVertID == pStripGroup->verts[k].origMeshVertID )
+				{
+					newIndex = k;
+					break;
+				}
+			}
+
+			// Didn't find it? Add the vertex to the list
+			if( newIndex == -1 )
+			{
+				newIndex = pStripGroup->verts.AddToTail( *pVert );
+			}
+			pStripGroup->indices.AddToTail( newIndex );
+
+#ifdef _DEBUG
+			//	float GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
+			int i;
+			float *pWeight = ( float * )_alloca( sizeof( float ) * pVert->numBones );
+			for( i = 0; i < pVert->numBones; i++ )
+			{
+				pWeight[i] = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, pVert, i );
+			}
+#endif
+			
+			// Keep track of the max # of bones in a vert
+			if (pVert->numBones > maxNumBones)
+				maxNumBones = pVert->numBones;
+		}
+		pStrip->numStripGroupIndices = pStripGroup->indices.Size() - pStrip->stripGroupIndexOffset;
+		pStrip->numStripGroupVerts = pStripGroup->verts.Size() - pStrip->stripGroupVertexOffset;
+
+		// The number of bones in a strip is the max number of 
+		// bones in a vertex in this strip for vertex shaders, and it's the
+		// number of unique bones in the strip for fixed-function
+		if (!m_UsesFixedFunction)
+			pStrip->numBones = maxNumBones;
+		else
+			pStrip->numBones = CountUniqueBonesInStrip(pStripGroup, pStrip);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns true if a particular mesh is teeth
+//-----------------------------------------------------------------------------
+
+bool COptimizedModel::MeshIsTeeth( studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh )
+{
+	// The mesh is teeth if it's got a skin whose material has a non-zero flags
+	int i;
+	for( i = 0; i < pStudioHeader->numskinfamilies; i++ )
+	{
+		short *pskinref	= pStudioHeader->pSkinref( 0 );
+		pskinref += ( i * pStudioHeader->numskinref );
+		mstudiotexture_t *ptexture;
+		ptexture = pStudioHeader->pTexture( pskinref[ pStudioMesh->material ] );
+		if( ptexture->flags )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the flags for a mesh
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::ComputeMeshFlags( Mesh_t *pMesh, studiohdr_t *pStudioHeader, 
+										mstudiomesh_t *pStudioMesh )
+{
+	// eyeball?
+	pMesh->flags = 0;
+	if( pStudioMesh->materialtype != 0 )
+	{
+		pMesh->flags |= MESH_IS_EYES;
+	}
+
+	// teeth?
+	if( MeshIsTeeth( pStudioHeader, pStudioMesh ) )
+	{
+		pMesh->flags |= MESH_IS_TEETH;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates 4 strip groups for a mesh, combinations of flexed + hwskinned
+// A mesh has a single material
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::ProcessMesh( Mesh_t *pMesh, studiohdr_t *pStudioHeader, 
+								  CUtlVector<mstudioiface_t> &srcFaces,
+								  mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh,
+								  bool forceNoFlex, bool bForceSoftwareSkin, bool bHWFlex )
+{
+	// Compute the mesh flags
+	ComputeMeshFlags( pMesh, pStudioHeader, pStudioMesh );
+
+	// We're gonna keep track of which ones we haven't processed
+	// because we're gonna add all unprocessed faces to the software
+	// lists if for some reason they don't get added to the hardware lists
+	TriangleProcessedList_t	trianglesProcessed;
+	trianglesProcessed.AddMultipleToTail( srcFaces.Size() ); 
+	memset( trianglesProcessed.Base(), 0, trianglesProcessed.Size() );
+	
+	// there are up to 4 stripgroups per mesh
+	// Note that we're gonna do the HW skinned versions first
+	// because they have the option of deciding not to be hardware after all
+	int isHWSkinned, isFlexed;
+	for( isHWSkinned = bForceSoftwareSkin ? 0 : 1; isHWSkinned >= 0; --isHWSkinned )
+	{
+		for( isFlexed = 1; isFlexed >= 0; --isFlexed )
+		{
+			int realMaxBonesPerTri, realMaxBonesPerVert, realMaxBonesPerStrip;
+
+			if( isFlexed && !bHWFlex )
+			{
+				realMaxBonesPerTri = 1;
+				realMaxBonesPerVert = 1;
+				realMaxBonesPerStrip = 1;
+			}
+			else
+			{
+				realMaxBonesPerTri = m_MaxBonesPerTri;
+				realMaxBonesPerVert = m_MaxBonesPerVert;
+				realMaxBonesPerStrip = m_MaxBonesPerStrip;
+			}
+
+			int newStripGroupIndex = pMesh->stripGroups.AddToTail( );
+			StripGroup_t& newStripGroup = pMesh->stripGroups[newStripGroupIndex];
+			ProcessStripGroup( &newStripGroup, 
+				isHWSkinned ? true : false, 
+				isFlexed ? true : false, 
+				pStudioModel, pStudioMesh, srcFaces, trianglesProcessed,
+				realMaxBonesPerVert, realMaxBonesPerTri, realMaxBonesPerStrip, forceNoFlex, bHWFlex );
+
+			PostProcessStripGroup( pStudioModel, pStudioMesh, &newStripGroup );
+
+			// Clear out the strip group if there wasn't anything in it
+			if( !newStripGroup.indices.Size() )
+				pMesh->stripGroups.FastRemove( newStripGroupIndex );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// some setup required before we really get into it
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::SetupMeshProcessing( studiohdr_t *pHdr, int vertexCacheSize,  
+		bool usesFixedFunction, int maxBonesPerVert, int maxBonesPerTri, 
+		int maxBonesPerStrip, const char *fileName )
+{
+#ifdef NVTRISTRIP
+	// tell nvtristrip all of it's params
+	SetCacheSize( vertexCacheSize );
+	SetStitchStrips( true );
+	SetMinStripSize( 0 );
+#	ifdef EMIT_TRILISTS
+	SetListsOnly( true );
+#	else
+	SetListsOnly( false );
+#	endif
+#endif // NVTRISTRIP
+	
+	if( !g_quiet )
+	{
+		printf( "---------------------\n" );
+		printf( "Generating optimized mesh \"%s\":\n", fileName );
+#ifdef _DEBUG
+		printf( "\tvertex cache size: %d\n", vertexCacheSize );
+		printf( "\tmax bones/tri:     %d\n", maxBonesPerTri );
+		printf( "\tmax bones/vert:    %d\n", maxBonesPerVert );
+		printf( "\tmax bones/strip:   %d\n", maxBonesPerStrip );
+#endif
+	}
+
+	CleanupEverything();
+
+	// Total number of bones in the original model
+	m_NumBones = pHdr->numbones;
+
+	// Hardware limitations
+	m_MaxBonesPerVert = maxBonesPerVert;
+	m_MaxBonesPerTri = maxBonesPerTri;
+	m_MaxBonesPerStrip = maxBonesPerStrip;
+	m_UsesFixedFunction = usesFixedFunction; 
+	m_VertexCacheSize = vertexCacheSize;
+
+	// stats
+	m_NumSkinnedAndFlexedVerts = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process the entire model, return stats...
+//-----------------------------------------------------------------------------
+
+int COptimizedModel::GetTotalVertsForMesh( Mesh_t *pMesh )
+{
+	int numVerts = 0;
+	int i;
+	for( i = 0; i < pMesh->stripGroups.Size(); i++ )
+	{
+		StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
+		numVerts += pStripGroup->verts.Size();
+	}
+	return numVerts;
+}
+
+int COptimizedModel::GetTotalIndicesForMesh( Mesh_t *pMesh )
+{
+	int numIndices = 0;
+	int i;
+	for( i = 0; i < pMesh->stripGroups.Size(); i++ )
+	{
+		StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
+		numIndices += pStripGroup->indices.Size();
+	}
+	return numIndices;
+}
+
+int COptimizedModel::GetTotalStripsForMesh( Mesh_t *pMesh )
+{
+	int numStrips = 0;
+	int i;
+	for( i = 0; i < pMesh->stripGroups.Size(); i++ )
+	{
+		StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
+		numStrips += pStripGroup->strips.Size();
+	}
+	return numStrips;
+}
+
+int COptimizedModel::GetTotalStripGroupsForMesh( Mesh_t *pMesh )
+{
+	return pMesh->stripGroups.Size();
+}
+
+int COptimizedModel::GetTotalBoneStateChangesForMesh( Mesh_t *pMesh )
+{
+	int numBoneStateChanges = 0;
+	int i;
+	for( i = 0; i < pMesh->stripGroups.Size(); i++ )
+	{
+		StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
+		int j;
+		for( j = 0; j < pStripGroup->strips.Size(); j++ )
+		{
+			Strip_t *pStrip = &pStripGroup->strips[j];
+			numBoneStateChanges += pStrip->numBoneStateChanges;
+		}
+	}
+	return numBoneStateChanges;
+}
+
+
+
+/*
+static void WriteDebugFile( const char *fileName, const char *outFileName, float red, float grn, float blu )
+{
+	char *tmpName = ( char * )_alloca( strlen( fileName ) + 1 );
+	strcpy( tmpName, fileName );
+	
+	s_source_t *pSrc = Load_Source( tmpName, "SMD" );
+	Assert( pSrc );
+
+	int i, j;
+
+	FILE *fp;
+	fp = fopen( outFileName, "w" );
+	Assert( fp );
+	
+	for( i = 0; i < pSrc->nummeshes; i++ )
+	{
+		s_mesh_t *pMesh = &pSrc->mesh[i];
+		for( j = 0; j < pMesh->numfaces; j++ )
+		{
+			s_face_t *pFace = &pSrc->face[pMesh->faceoffset + j];
+			Vector &a = pSrc->vertex[pMesh->vertexoffset + pFace->a];
+			Vector &b = pSrc->vertex[pMesh->vertexoffset + pFace->b];
+			Vector &c = pSrc->vertex[pMesh->vertexoffset + pFace->c];
+			fprintf( fp, "3\n" );
+			fprintf( fp, "%f %f %f %f %f %f\n", ( float )( a[0] ), ( float )( a[1] ), ( float )( a[2] ), 
+				( float )red, ( float )grn, ( float )blu );
+			fprintf( fp, "%f %f %f %f %f %f\n", ( float )( b[0] ), ( float )( b[1] ), ( float )( b[2] ), 
+				( float )red, ( float )grn, ( float )blu );
+			fprintf( fp, "%f %f %f %f %f %f\n", ( float )( c[0] ), ( float )( c[1] ), ( float )( c[2] ), 
+				( float )red, ( float )grn, ( float )blu );
+		}
+
+	}
+	fclose( fp );
+}
+*/
+
+void COptimizedModel::SourceMeshToTriangleList( s_model_t *pSrcModel, s_mesh_t *pSrcMesh, 
+										  CUtlVector<mstudioiface_t> &meshTriangleList )
+{
+	s_face_t *pFaces = pSrcModel->source->face + pSrcMesh->faceoffset;
+	int i;
+	for ( i = 0; i < pSrcMesh->numfaces; i++ )
+	{
+		const s_face_t &pFace = pFaces[i];
+		int j = meshTriangleList.AddToTail();
+		mstudioiface_t &newTriangle = meshTriangleList[j];
+		newTriangle.a = pFace.a;
+		newTriangle.b = pFace.b;
+		newTriangle.c = pFace.c;
+	}
+}
+
+/*
+static void WriteSourceMesh( s_model_t *pSrcModel, s_mesh_t *pSrcMesh, int red_, int grn_, int blu_ )
+{
+	FILE *fp;
+	fp = fopen( "blah.glv", "a+" );
+	float red, grn, blu;
+
+	red = ( float )rand() / ( float )VALVE_RAND_MAX;
+	grn = ( float )rand() / ( float )VALVE_RAND_MAX;
+	blu = ( float )rand() / ( float )VALVE_RAND_MAX;
+	float len = red * red + grn * grn + blu * blu;
+	len = sqrt( len );
+	red *= 255.0f / len;
+	grn *= 255.0f / len;
+	blu *= 255.0f / len;
+	
+	s_face_t *pFaces = pSrcModel->source->face + pSrcMesh->faceoffset;
+	int i;
+	for( i = 0; i < pSrcMesh->numfaces; i++ )
+	{
+		const s_face_t &face = pFaces[i];
+		Vector a, b, c;
+		a = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.a];
+		b = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.b];
+		c = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.c];
+		fprintf( fp, "3\n" );
+		fprintf( fp, "%f %f %f %f %f %f\n", a[0], a[1], a[2], red, grn, blu );
+		fprintf( fp, "%f %f %f %f %f %f\n", c[0], c[1], c[2], red, grn, blu );
+		fprintf( fp, "%f %f %f %f %f %f\n", b[0], b[1], b[2], red, grn, blu );
+	}
+	fclose( fp );
+}
+*/
+
+static void RandomColor( Vector& color )
+{
+	color[0] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
+	color[1] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
+	color[2] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
+	VectorNormalize( color );
+}
+
+/*
+static void GLViewCube( Vector pos, float size, FILE *fp )
+{
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
+
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
+
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
+
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
+
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
+
+	fprintf( fp, "4\n" );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
+	fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
+}
+*/
+
+#if 0
+static void MStudioBoneWeightToSBoneWeight( s_boneweight_t &sbone, const mstudioboneweight_t &mbone, 
+										   const s_source_t *pSrc )
+{
+	int i;
+	for( i = 0; i < mbone.numbones; i++ )
+	{
+		sbone.bone[i] = pSrc->boneimap[mbone.bone[i]];
+//		sbone.bone[i] = mbone.bone[i];
+		sbone.weight[i] = mbone.weight[i];
+	}
+	sbone.numbones = mbone.numbones;
+}
+#endif
+
+void COptimizedModel::CreateLODTriangleList( s_model_t *pSrcModel, int nLodID, s_source_t* pSrc,
+											mstudiomodel_t *pStudioModel,
+											mstudiomesh_t *pStudioMesh,
+											CUtlVector<mstudioiface_t> &meshTriangleList, 
+											bool writeDebug )
+{
+	if ( !pSrc || !pSrcModel )
+		return;
+
+#ifdef _DEBUG
+//	const mstudio_modelvertexdata_t *vertData = pStudioModel->GetVertexData();
+//	Assert( vertData ); // This can only return NULL on X360 for now
+//	mstudiovertex_t *modelFirstVert = vertData->Vertex( 0 );
+//	mstudiovertex_t *modelLastVert = vertData->Vertex( pStudioModel->numvertices - 1 );
+//	mstudiovertex_t *meshFirstVert = vertData->Vertex( 0 );
+//	mstudiovertex_t *meshLastVert = vertData->Vertex( pStudioMesh->numvertices - 1 );
+#endif
+	
+/*
+	if( writeDebug )
+	{
+		printf( "MODEL VERTS:\n" );
+		int i;
+		for( i = 0; i < pStudioModel->numvertices; i++ )
+		{
+			Vector &v = *pStudioModel->pVertex( i );
+			Vector &n = *pStudioModel->pNormal( i );
+			Vector2D &t = *pStudioModel->pTexcoord( i );
+			printf( "model %d: p %f %f %f n: %f %f %f t: %f %f\n",
+				i, v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1] );
+		}
+		printf( "MESH VERTS:\n" );
+		for( i = 0; i < pStudioMesh->numvertices; i++ )
+		{
+			Vector &v = *pStudioMesh->pVertex( i );
+			Vector &n = *pStudioMesh->pNormal( i );
+			Vector2D &t = *pStudioMesh->pTexcoord( i );
+			printf( "mesh %d: p %f %f %f n: %f %f %f t: %f %f\n",
+				i, v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1] );
+		}
+	}
+*/
+	// need to find the mesh in the lod model that matches the original model.
+	int i;
+	int textureSearchID = MaterialToTexture( pStudioMesh->material );
+
+	// this is icky.. . pSrc->nummeshes really refers to the total number of non-empty meshes
+	// in the model.  In pSrc->meshes, there are some empty meshes in the middle if they 
+	// don't exist for the material, so you have to go through all of the meshes to find
+	// the non-empty ones.
+	s_mesh_t *pSrcMesh = NULL;
+	for ( i = 0; i < pStudioModel->nummeshes; i++ )
+	{
+		if ( pSrc->texmap[pSrc->meshindex[i]] == textureSearchID )
+		{
+			// woo hoo!  found it.
+			pSrcMesh = &pSrc->mesh[pSrc->meshindex[i]];
+			break;
+		}
+	}
+	if ( !pSrcMesh )
+	{
+		//printf( "%s doesn't have material %d\n", lodSMDName, textureSearchID );
+		// There aren't any triangles in this lower lod with this material on it.
+		return;
+	}
+
+	CUtlVector<int> indexMapping;
+	indexMapping.AddMultipleToTail( pSrcMesh->numvertices );
+
+	for ( i = 0; i < pSrcMesh->numvertices; i++ )
+	{
+		// get the mapping between indices in the lod and their real pool location.
+		indexMapping[i] = pSrcModel->m_pLodData->pMeshVertIndexMaps[nLodID][pSrcMesh->vertexoffset + i];
+	}
+
+	// build the lod's faces so indexes map to remapped vertexes
+	for ( i = 0; i < pSrcMesh->numfaces; i++ )
+	{
+		int index = meshTriangleList.AddToTail();
+		mstudioiface_t& newFace = meshTriangleList[index];
+		const s_face_t &srcFace = pSrc->face[pSrcMesh->faceoffset + i];
+		newFace.a = indexMapping[srcFace.a];
+		newFace.b = indexMapping[srcFace.b];
+		newFace.c = indexMapping[srcFace.c];
+	}
+}
+
+
+bool ComparePath( const char *a, const char *b )
+{
+	if ( strlen( a ) != strlen( b ) )
+	{
+		return false;
+	}
+
+	// case and seperator invariant
+	for ( ; *a; a++, b++ )
+	{
+		if ( *a == *b )
+		{
+			continue;
+		}
+		if ( tolower( *a ) == tolower( *b ) )
+		{
+			continue;
+		}
+		if ( ( *a == '/' || *a == '\\' ) && 
+			( *b == '/' || *b == '\\' ) )
+		{
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+
+bool COptimizedModel::MeshNeedsRemoval( studiohdr_t *pHdr, mstudiomesh_t *pStudioMesh,
+											   LodScriptData_t& scriptLOD )
+{
+	mstudiotexture_t *ptexture;
+	short *pskinref	= pHdr->pSkinref( 0 );
+	ptexture = pHdr->pTexture( pskinref[ pStudioMesh->material ] );
+	const char *meshName = ptexture->material->GetName();
+	int i;
+	for( i = 0; i < scriptLOD.meshRemovals.Size(); i++ )
+	{
+		const char *meshRemovalName = scriptLOD.meshRemovals[i].GetSrcName();
+		if ( ComparePath( meshName, meshRemovalName ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process the entire model, return stats...
+//-----------------------------------------------------------------------------
+void COptimizedModel::ProcessModel( studiohdr_t *pHdr, s_bodypart_t *pSrcBodyParts, 
+										  TotalMeshStats_t& stats, bool bForceSoftwareSkin, bool bHWFlex )
+{
+	memset( &stats, 0, sizeof(stats) );
+	m_Models.RemoveAll();
+
+	int bodyPartID, modelID, meshID, lodID;
+	for ( bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++, stats.m_TotalBodyParts++ )
+	{
+		mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
+		s_bodypart_t *pSrcBodyPart = &pSrcBodyParts[bodyPartID];
+		for ( modelID = 0; modelID < pBodyPart->nummodels; modelID++, stats.m_TotalModels++ )
+		{
+			int i = m_Models.AddToTail();
+			Model_t& newModel = m_Models[i];
+			mstudiomodel_t *pStudioModel = pBodyPart->pModel( modelID );
+			s_model_t *pSrcModel = pSrcBodyPart->pmodel[modelID];
+			for ( lodID = 0; lodID < g_ScriptLODs.Count(); lodID++, stats.m_TotalModelLODs++ )
+			{
+				LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
+				s_source_t *pLODSource = pSrcModel->m_LodSources[lodID];
+
+				int i = newModel.modelLODs.AddToTail();
+				Assert( i == lodID );
+				ModelLOD_t& newLOD = newModel.modelLODs[i];
+				newLOD.switchPoint = scriptLOD.switchValue;
+
+				// In this case, we've been told to remove the model
+				if ( !pLODSource )
+				{
+					if ( pSrcModel && stricmp( pSrcModel->name, "blank" ) != 0)
+					{
+						// This is nonsensical
+						Assert( lodID != 0 );
+					}
+					continue;
+				}
+
+				for ( meshID = 0; meshID < pStudioModel->nummeshes; meshID++, stats.m_TotalMeshes++ )
+				{
+#ifdef _DEBUG
+//					printf( "bodyPart: %d model: %d modellod: %d mesh: %d\n", bodyPartID, modelID, lodID, meshID );
+#endif
+					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					s_mesh_t *pSrcMesh = &pSrcModel->source->mesh[pSrcModel->source->meshindex[meshID]];
+
+					int i = newLOD.meshes.AddToTail();
+					Assert( i == meshID );
+					Mesh_t& newMesh = newLOD.meshes[i];
+					
+					if ( MeshNeedsRemoval( pHdr, pStudioMesh, scriptLOD ) )
+						continue;				
+#ifdef _DEBUG
+//					int textureSearchID = material_to_texture( pStudioMesh->material );
+//					const char *pDebugName = pHdr->pTexture( textureSearchID )->pszName( );
+#endif
+					CUtlVector<mstudioiface_t> meshTriangleList;
+					if ( pLODSource )
+					{
+						// map the lod data to triangles
+						// uses the original mesh redirected through a mapping table
+						// this expects built per lod-to-root mapping tables to generate faces
+						CreateLODTriangleList( pSrcModel, lodID, pLODSource, pStudioModel, pStudioMesh, meshTriangleList, false );
+					}
+					else
+					{
+						// build the triangle list from the unmapped source
+						SourceMeshToTriangleList( pSrcModel, pSrcMesh, meshTriangleList );
+					}
+					
+					ProcessMesh( &newMesh, pHdr, meshTriangleList, pStudioModel, pStudioMesh, 
+						!scriptLOD.GetFacialAnimationEnabled(), bForceSoftwareSkin, bHWFlex );
+					
+					stats.m_TotalVerts += GetTotalVertsForMesh( &newMesh );
+					stats.m_TotalIndices += GetTotalIndicesForMesh( &newMesh );
+					stats.m_TotalStrips += GetTotalStripsForMesh( &newMesh );
+					stats.m_TotalStripGroups += GetTotalStripGroupsForMesh( &newMesh );
+					stats.m_TotalBoneStateChanges += GetTotalBoneStateChangesForMesh( &newMesh );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Some processing that happens at the end
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::MapGlobalBonesToHardwareBoneIDsAndSortBones( studiohdr_t *phdr )
+{
+	// garymcthack: holy jesus is this function long!
+#ifdef IGNORE_BONES
+	return;
+#endif
+	
+	int *globalToHardwareBoneIndex;
+	int hardwareToGlobalBoneIndex[MAX_NUM_BONES_PER_STRIP];
+	
+	globalToHardwareBoneIndex = ( int * )_alloca( m_NumBones * sizeof( int ) );
+	Assert( globalToHardwareBoneIndex );
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+		for( int lodID = 0; lodID < header->numLODs; lodID++ )
+		{
+			// Dear LORD!  This needs to be in another function! (garymcthack)
+			int i;
+			for( i = 0; i < m_NumBones; i++ )
+			{
+				globalToHardwareBoneIndex[i] = -1;
+			}
+			for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
+			{
+				hardwareToGlobalBoneIndex[i] = -1;
+			}
+			
+			for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+			{
+				ModelHeader_t *model = bodyPart->pModel( modelID );
+				mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						// Only do this to HW-skinned meshes
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						if( !( pStripGroup->flags & STRIPGROUP_IS_HWSKINNED ) )
+						{
+							continue;
+						}
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							//						printf( "UPDATING BONE STATE\n" );
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+							
+							// Generate mapping back and forth between hardware IDs and original bone IDs
+							int boneStateChangeID;
+							for( boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
+							{
+								BoneStateChangeHeader_t *pBoneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
+								globalToHardwareBoneIndex[pBoneStateChange->newBoneID] = pBoneStateChange->hardwareID;
+								if( pBoneStateChange->hardwareID != -1 )
+								{
+									hardwareToGlobalBoneIndex[pBoneStateChange->hardwareID] = pBoneStateChange->newBoneID;
+								}
+							}
+							int vertID;
+							for( vertID = 0; vertID < pStrip->numVerts; vertID++ )
+							{
+								Vertex_t *vert = pStripGroup->pVertex( vertID + pStrip->vertOffset );
+								int boneID;
+								for( boneID = 0; boneID < header->maxBonesPerVert; boneID++ )
+								{
+									int globalBoneID = vert->boneID[boneID];
+									if( globalBoneID == -1 )
+									{
+										// this index isn't used.
+										vert->boneID[boneID] = 0;
+										// make sure it's associated weight is zero.
+										//									Assert( vert->boneWeights[boneID] == 0 );
+										continue;
+									}
+									Assert( globalBoneID >= 0 && globalBoneID < m_NumBones );
+									vert->boneID[boneID] = globalToHardwareBoneIndex[globalBoneID];
+									Assert( vert->boneID[boneID] >= 0 && vert->boneID[boneID] < header->maxBonesPerStrip );
+								}
+								
+								// We only do index palette skinning when we're not doing fixed function
+								if (m_UsesFixedFunction)
+								{
+//									bool flexed = pStripGroup->flags & STRIPGROUP_IS_FLEXED;
+									SortBonesWithinVertex( false /* flexed */, vert, pStudioModel, 
+										pStudioMesh, globalToHardwareBoneIndex, hardwareToGlobalBoneIndex, 
+										m_MaxBonesPerTri, m_MaxBonesPerVert );
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// The following methods are associated with writing a .vtx file
+//
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::WriteHeader( int vertCacheSize, int maxBonesPerVert, 
+	int maxBonesPerTri, int maxBonesPerStrip, int numBodyParts, long checkSum )
+{
+	FileHeader_t fileHeader;
+
+	fileHeader.version = OPTIMIZED_MODEL_FILE_VERSION;
+	fileHeader.vertCacheSize = vertCacheSize;
+	fileHeader.maxBonesPerTri = IsUShort( maxBonesPerTri );
+	fileHeader.maxBonesPerVert = maxBonesPerVert;
+	fileHeader.maxBonesPerStrip = IsUShort( maxBonesPerStrip );
+	fileHeader.numBodyParts = numBodyParts;
+	fileHeader.bodyPartOffset = sizeof( FileHeader_t );
+	fileHeader.checkSum = checkSum;
+	fileHeader.numLODs = g_ScriptLODs.Size();
+	fileHeader.materialReplacementListOffset = m_MaterialReplacementsListOffset;
+	m_FileBuffer->WriteAt( 0, &fileHeader, sizeof( FileHeader_t ), "header" );
+#ifdef _DEBUG
+//	FileHeader_t *debug = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+//	BodyPartHeader_t *pBodyPart = debug->pBodyPart( 0 );
+#endif
+}
+
+
+void COptimizedModel::WriteBodyPart( int bodyPartID, mstudiobodyparts_t *pBodyPart, int modelID )
+{
+	BodyPartHeader_t bodyPart;
+	bodyPart.numModels = pBodyPart->nummodels;
+	int bodyPartOffset = m_BodyPartsOffset + bodyPartID * sizeof( BodyPartHeader_t );
+	int modelFileOffset = m_ModelsOffset + modelID * sizeof( ModelHeader_t );
+	bodyPart.modelOffset = modelFileOffset - bodyPartOffset;
+	m_FileBuffer->WriteAt( bodyPartOffset, &bodyPart, sizeof( BodyPartHeader_t ), "bodypart" );
+#ifdef _DEBUG
+//	BodyPartHeader_t *debug = ( BodyPartHeader_t * )m_FileBuffer->GetPointer( bodyPartOffset );
+//	ModelHeader_t *pModel = debug->pModel( 0 );
+#endif
+}
+
+void COptimizedModel::WriteModel( int modelID, mstudiomodel_t *pModel, int lodID )
+{
+	ModelHeader_t model;
+	model.numLODs = IsChar( g_ScriptLODs.Size() );
+	int modelFileOffset = m_ModelsOffset + modelID * sizeof( ModelHeader_t );
+	int lodFileOffset = m_ModelLODsOffset + lodID * sizeof( ModelLODHeader_t );
+	model.lodOffset = lodFileOffset - modelFileOffset;
+	m_FileBuffer->WriteAt( modelFileOffset, &model, sizeof( ModelHeader_t ), "model" );
+#ifdef _DEBUG
+//	ModelHeader_t *debug = ( ModelHeader_t * )m_FileBuffer->GetPointer( modelFileOffset );
+//	ModelLODHeader_t *pLOD = debug->pLOD( 0 );
+#endif
+}
+
+void COptimizedModel::WriteModelLOD( int lodID, ModelLOD_t *pLOD, int meshID )
+{
+	ModelLODHeader_t lod;
+	int lodFileOffset = m_ModelLODsOffset + lodID * sizeof( ModelLODHeader_t );
+	int meshFileOffset = m_MeshesOffset + meshID * sizeof( MeshHeader_t );
+	lod.meshOffset = meshFileOffset - lodFileOffset;
+	lod.numMeshes = pLOD->meshes.Size();
+	lod.switchPoint = pLOD->switchPoint;
+	m_FileBuffer->WriteAt( lodFileOffset, &lod, sizeof( ModelLODHeader_t ), "modellod" );
+#ifdef _DEBUG
+//	ModelLODHeader_t *debug = ( ModelLODHeader_t * )m_FileBuffer->GetPointer( lodFileOffset );
+//	MeshHeader_t *pMesh = debug->pMesh( 0 );
+#endif
+}
+
+void COptimizedModel::WriteMesh( int meshID, Mesh_t *pMesh, int stripGroupID )
+{
+	MeshHeader_t mesh;
+	mesh.numStripGroups = IsChar( pMesh->stripGroups.Size() );
+	int meshFileOffset = m_MeshesOffset + meshID * sizeof( MeshHeader_t );
+	int stripGroupFileOffset = m_StripGroupsOffset + stripGroupID * sizeof( StripGroupHeader_t );
+	mesh.stripGroupHeaderOffset = stripGroupFileOffset - meshFileOffset;
+	mesh.flags = pMesh->flags;
+	m_FileBuffer->WriteAt( meshFileOffset, &mesh, sizeof( MeshHeader_t ), "mesh" );
+#ifdef _DEBUG
+//	MeshHeader_t *debug = ( MeshHeader_t * )m_FileBuffer->GetPointer( meshFileOffset );
+//	StripGroupHeader_t *pStripGroup = debug->pStripGroup( 0 );
+#endif
+}
+
+void COptimizedModel::WriteStripGroup( int stripGroupID, StripGroup_t *pStripGroup,
+									   int vertID, int indexID, int stripID )
+{
+	StripGroupHeader_t stripGroup;
+	stripGroup.numVerts = pStripGroup->verts.Size();
+	stripGroup.numIndices = pStripGroup->indices.Size();
+	stripGroup.numStrips = pStripGroup->strips.Size();
+	stripGroup.flags = IsByte( pStripGroup->flags );
+	int stripGroupFileOffset = m_StripGroupsOffset + stripGroupID * sizeof( StripGroupHeader_t );
+	int vertsFileOffset = m_VertsOffset + vertID * sizeof( Vertex_t );
+	int indicesFileOffset = m_IndicesOffset + indexID * sizeof( unsigned short );
+	int stripsFileOffset = m_StripsOffset + stripID * sizeof( StripHeader_t );
+	stripGroup.vertOffset = vertsFileOffset - stripGroupFileOffset;
+	stripGroup.indexOffset = indicesFileOffset - stripGroupFileOffset;
+	stripGroup.stripOffset = stripsFileOffset - stripGroupFileOffset;
+	m_FileBuffer->WriteAt( stripGroupFileOffset, &stripGroup, sizeof( StripGroupHeader_t), "strip group" );
+#ifdef _DEBUG
+//	StripGroupHeader_t *debug = ( StripGroupHeader_t * )m_FileBuffer->GetPointer( stripGroupFileOffset );
+//	unsigned short *pIndex = debug->pIndex( 0 );
+//	Vertex_t *pVert = debug->pVertex( 0 );
+//	StripHeader_t *pStripHeader = debug->pStrip( 0 );
+#endif
+}
+
+int COptimizedModel::WriteVerts( int vertID, StripGroup_t *pStripGroup )
+{
+	int vertFileOffset = m_VertsOffset + vertID * sizeof( Vertex_t );
+	int numVerts = pStripGroup->verts.Size();
+	m_FileBuffer->WriteAt( vertFileOffset, &pStripGroup->verts[0], sizeof( Vertex_t ) * numVerts, "verts" );
+#ifdef _DEBUG
+//	Vertex_t *debug = ( Vertex_t * )m_FileBuffer->GetPointer( vertFileOffset );
+#endif
+	return numVerts;
+}
+
+int COptimizedModel::WriteIndices( int indexID, StripGroup_t *pStripGroup )
+{
+	int indexFileOffset = m_IndicesOffset + indexID * sizeof( unsigned short );
+	int numIndices = pStripGroup->indices.Size();
+	m_FileBuffer->WriteAt( indexFileOffset, &pStripGroup->indices[0], sizeof( unsigned short ) * numIndices, "indices" );
+#ifdef _DEBUG
+//	unsigned short *debug = ( unsigned short * )m_FileBuffer->GetPointer( indexFileOffset );
+#endif
+	return numIndices;
+}
+
+void COptimizedModel::WriteStrip( int stripID, Strip_t *pStrip, int indexID, int vertID, int boneID )
+{
+	StripHeader_t stripHeader;
+
+	stripHeader.numIndices = pStrip->numStripGroupIndices;
+	stripHeader.indexOffset = pStrip->stripGroupIndexOffset;
+	stripHeader.numVerts = pStrip->numStripGroupVerts;
+	stripHeader.vertOffset = pStrip->stripGroupVertexOffset;
+	stripHeader.numBoneStateChanges = pStrip->numBoneStateChanges;
+	stripHeader.numBones = IsShort( pStrip->numBones );
+	stripHeader.flags = IsByte( pStrip->flags );
+	int boneFileOffset = m_BoneStageChangesOffset + boneID * sizeof( BoneStateChangeHeader_t );
+	int stripFileOffset = m_StripsOffset + stripID * sizeof( StripHeader_t );
+	stripHeader.boneStateChangeOffset = IsInt24( boneFileOffset - stripFileOffset );
+	m_FileBuffer->WriteAt( stripFileOffset, &stripHeader, sizeof( StripHeader_t ), "strip" );
+#ifdef _DEBUG
+//	StripHeader_t *debug = ( StripHeader_t* )m_FileBuffer->GetPointer( stripFileOffset );
+//	BoneStateChangeHeader_t *pBoneStateChange = debug->pBoneStateChange( 0 );
+#endif
+}
+
+void COptimizedModel::WriteBoneStateChange( int boneID, BoneStateChange_t *boneStateChange )
+{
+	BoneStateChangeHeader_t boneHeader;
+	boneHeader.hardwareID = boneStateChange->hardwareID;
+	boneHeader.newBoneID = boneStateChange->newBoneID;
+	int boneFileOffset = m_BoneStageChangesOffset + boneID * sizeof( BoneStateChangeHeader_t );
+#if 0
+	printf( "\tboneStateChange: hwid: %d boneID %d\n", ( int )boneHeader.hardwareID, 
+		( int )boneHeader.newBoneID );
+#endif
+	m_FileBuffer->WriteAt( boneFileOffset, &boneHeader, sizeof( BoneStateChangeHeader_t ), "bone" );
+#ifdef _DEBUG
+//	BoneStateChangeHeader_t *debug = ( BoneStateChangeHeader_t * )m_FileBuffer->GetPointer( boneFileOffset );
+#endif
+}
+	
+void COptimizedModel::ZeroNumBones( void )
+{
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	int bodyPartID, modelID, lodID, meshID, stripGroupID, vertID, stripID;
+	for( bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *pBodyPart = header->pBodyPart( bodyPartID );
+		for( modelID = 0; modelID < pBodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *pModel = pBodyPart->pModel( modelID );
+			for( lodID = 0; lodID < pModel->numLODs; lodID++ )
+			{
+				ModelLODHeader_t *pLOD = pModel->pLOD( lodID );
+				for( meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *pMesh = pLOD->pMesh( meshID );
+					for( stripGroupID = 0; stripGroupID < pMesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = pMesh->pStripGroup( stripGroupID );
+						for( vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
+						{
+							Vertex_t *pVert = pStripGroup->pVertex( vertID );
+							pVert->numBones = 0;
+						}
+						for( stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+							pStrip->numBones = 0;
+							pStrip->numBoneStateChanges = 0;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void COptimizedModel::WriteStringTable( int stringTableOffset )
+{
+	int stringTableSize = s_StringTable.CalcSize();
+	if( stringTableSize == 0 )
+	{
+		return;
+	}
+	char *pTmp = new char[stringTableSize];
+	s_StringTable.WriteToMem( pTmp );
+	m_FileBuffer->WriteAt( stringTableOffset, pTmp, stringTableSize, "string table" );
+//	char *pDebug = ( char * )m_FileBuffer->GetPointer( stringTableOffset );
+	delete [] pTmp;
+}
+
+void COptimizedModel::WriteMaterialReplacements( int materialReplacementsOffset )
+{
+	int offset = materialReplacementsOffset;
+ 	int i, j;
+	int numLODs = g_ScriptLODs.Size();
+	for( i = 0; i < numLODs; i++ )
+	{
+		LodScriptData_t &scriptLOD = g_ScriptLODs[i];
+		for( j = 0; j < scriptLOD.materialReplacements.Size(); j++ )
+		{
+			CLodScriptReplacement_t &materialReplacement = scriptLOD.materialReplacements[j];
+			MaterialReplacementHeader_t tmpHeader;
+			tmpHeader.materialID = FindMaterialByName( materialReplacement.GetSrcName() );
+			tmpHeader.replacementMaterialNameOffset = m_StringTableOffset + 
+				s_StringTable.StringTableOffset( materialReplacement.GetDstName() ) - offset;
+			m_FileBuffer->WriteAt( offset, &tmpHeader, sizeof( tmpHeader ), "material replacements" );
+			offset += sizeof( MaterialReplacementHeader_t );
+		}
+	}
+}
+
+void COptimizedModel::WriteMaterialReplacementLists( int materialReplacementsOffset, int materialReplacementListOffset )
+{
+	int replacementOffset = materialReplacementsOffset;
+	int offset = materialReplacementListOffset;
+	int i;
+	int numLODs = g_ScriptLODs.Size();
+	for( i = 0; i < numLODs; i++ )
+	{
+		LodScriptData_t &scriptLOD = g_ScriptLODs[i];
+		MaterialReplacementListHeader_t tmpHeader;
+		tmpHeader.numReplacements = IsChar( scriptLOD.materialReplacements.Size() );
+		tmpHeader.replacementOffset = IsInt24( replacementOffset - offset );
+		m_FileBuffer->WriteAt( offset, &tmpHeader, sizeof( tmpHeader ), "material replacement headers" );
+		MaterialReplacementListHeader_t *pDebugList = 
+			( MaterialReplacementListHeader_t * )m_FileBuffer->GetPointer( offset );
+		if( pDebugList->numReplacements )
+		{
+//			MaterialReplacementHeader_t *pDebug = pDebugList->pMaterialReplacement( 0 );
+//			const char *string = pDebug->pMaterialReplacementName();
+		}
+		replacementOffset += tmpHeader.numReplacements * sizeof( MaterialReplacementHeader_t );
+		offset += sizeof( MaterialReplacementListHeader_t );
+	}
+}
+
+void COptimizedModel::SanityCheckVertexBoneLODFlags( studiohdr_t *pStudioHdr, FileHeader_t *pVtxHeader )
+{
+	int bodyPartID;
+	for( bodyPartID = 0; bodyPartID < pStudioHdr->numbodyparts; bodyPartID++ )
+	{
+		mstudiobodyparts_t *pBodyPart = pStudioHdr->pBodypart( bodyPartID );
+		BodyPartHeader_t *pVtxBodyPart = pVtxHeader->pBodyPart( bodyPartID );
+		int modelID;
+		for( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
+		{
+			mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
+			ModelHeader_t *pVtxModel = pVtxBodyPart->pModel( modelID );
+			int lodID;
+			for( lodID = 0; lodID < pVtxModel->numLODs; lodID++ )
+			{
+				ModelLODHeader_t *pVtxLOD = pVtxModel->pLOD( lodID );
+				int meshID;
+				Assert( pVtxLOD->numMeshes == pModel->nummeshes );
+				for( meshID = 0; meshID < pVtxLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *pVtxMesh = pVtxLOD->pMesh( meshID );
+					mstudiomesh_t *pMesh = pModel->pMesh( meshID );
+					int stripGroupID;
+					for( stripGroupID = 0; stripGroupID < pVtxMesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = pVtxMesh->pStripGroup( stripGroupID );
+						int vertID;
+						for( vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
+						{
+							Vertex_t *pVertex = pStripGroup->pVertex( vertID );
+							Vector pos = GetOrigVertPosition( pModel, pMesh, pVertex );
+							const mstudioboneweight_t &boneWeight = GetOrigVertBoneWeight( pModel, pMesh, pVertex );
+							int i;
+
+							for( i = 0; i < boneWeight.numbones; i++ )
+							{
+								mstudiobone_t *pBone = pStudioHdr->pBone( boneWeight.bone[i] );
+//								const char *pBoneName = pBone->pszName();
+								if (!( pBone->flags & ( BONE_USED_BY_VERTEX_LOD0 << lodID ) ))
+								{
+									MdlError("Mismarked Bone flag");
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void COptimizedModel::WriteVTXFile( studiohdr_t *pHdr, const char *pFileName, 
+								    TotalMeshStats_t const& stats )
+{
+
+	// calculate file offsets
+	m_FileBuffer = new CFileBuffer( FILEBUFFER_SIZE );
+	m_BodyPartsOffset = sizeof( FileHeader_t );
+	m_ModelsOffset = m_BodyPartsOffset + sizeof( BodyPartHeader_t ) * stats.m_TotalBodyParts;
+	m_ModelLODsOffset = m_ModelsOffset + sizeof( ModelHeader_t ) * stats.m_TotalModels;
+	m_MeshesOffset = m_ModelLODsOffset + sizeof( ModelLODHeader_t ) * stats.m_TotalModelLODs;
+	m_StripGroupsOffset = m_MeshesOffset + sizeof( MeshHeader_t ) * stats.m_TotalMeshes;
+	m_StripsOffset = m_StripGroupsOffset + sizeof( StripGroupHeader_t ) * stats.m_TotalStripGroups;
+	m_VertsOffset = m_StripsOffset + sizeof( StripHeader_t ) * stats.m_TotalStrips;
+	m_IndicesOffset = m_VertsOffset + sizeof( Vertex_t ) * stats.m_TotalVerts;
+	m_BoneStageChangesOffset = m_IndicesOffset + sizeof( unsigned short ) * stats.m_TotalIndices;
+	m_StringTableOffset = m_BoneStageChangesOffset + sizeof( BoneStateChangeHeader_t ) * stats.m_TotalBoneStateChanges;
+	m_MaterialReplacementsOffset = m_StringTableOffset + s_StringTable.CalcSize();
+	m_MaterialReplacementsListOffset = m_MaterialReplacementsOffset + stats.m_TotalMaterialReplacements * sizeof( MaterialReplacementHeader_t );
+	m_EndOfFileOffset = m_MaterialReplacementsListOffset + g_ScriptLODs.Count() * sizeof( MaterialReplacementListHeader_t );
+	
+	int curModel = 0;
+	int curLOD = 0;
+	int curMesh = 0;
+	int curStrip = 0;
+	int curStripGroup = 0;
+	int curVert = 0;
+	int curIndex = 0;
+	int curBoneStateChange = 0;
+	int deltaModel = 0;
+	int deltaLOD = 0;
+	int deltaMesh = 0;
+	int deltaStrip = 0;
+	int deltaStripGroup = 0;
+	int deltaVert = 0;
+	int deltaIndex = 0;
+	int deltaBoneStateChange = 0;
+	
+	WriteStringTable( m_StringTableOffset );
+	WriteMaterialReplacements( m_MaterialReplacementsOffset );
+	WriteMaterialReplacementLists( m_MaterialReplacementsOffset, m_MaterialReplacementsListOffset );
+	
+	for( int bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++ )
+	{
+		mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
+		for( int modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
+		{
+			mstudiomodel_t *pStudioModel = pBodyPart->pModel( modelID );
+			Model_t *pModel = &m_Models[curModel + deltaModel];
+			for( int lodID = 0; lodID < g_ScriptLODs.Count(); lodID++ )
+			{
+//				printf( "lod: %d\n", lodID );
+				ModelLOD_t *pLOD = &pModel->modelLODs[lodID];
+				for( int meshID = 0; meshID < pStudioModel->nummeshes; meshID++ )
+				{
+					Mesh_t *pMesh = &pLOD->meshes[meshID];
+					for( int stripGroupID = 0; stripGroupID < pMesh->stripGroups.Count(); stripGroupID++ )
+					{
+						StripGroup_t *pStripGroup = &pMesh->stripGroups[stripGroupID];
+						deltaVert += WriteVerts( curVert + deltaVert, pStripGroup );
+						deltaIndex += WriteIndices( curIndex + deltaIndex, pStripGroup );
+
+						int nStripCount = pStripGroup->strips.Count();
+						for( int stripID = 0; stripID < nStripCount; stripID++ )
+						{
+							Strip_t *pStrip = &pStripGroup->strips[stripID];
+							for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
+							{
+								WriteBoneStateChange( curBoneStateChange + deltaBoneStateChange, &pStrip->boneStateChanges[boneStateChangeID] );
+								deltaBoneStateChange++;
+							}
+							WriteStrip( curStrip + deltaStrip, pStrip, curIndex, curVert, curBoneStateChange );
+							deltaStrip++;
+							curBoneStateChange += deltaBoneStateChange;
+							deltaBoneStateChange = 0;
+						}
+						WriteStripGroup( curStripGroup + deltaStripGroup, pStripGroup, curVert, curIndex, curStrip );
+						deltaStripGroup++;
+						curStrip += deltaStrip;
+						deltaStrip = 0;
+						curVert += deltaVert;
+						deltaVert = 0;
+						curIndex += deltaIndex;
+						deltaIndex = 0;
+					}
+					WriteMesh( curMesh + deltaMesh, pMesh, curStripGroup );
+					deltaMesh++;
+					curStripGroup += deltaStripGroup;
+					deltaStripGroup = 0;
+				}
+				WriteModelLOD( curLOD + deltaLOD, pLOD, curMesh );
+				deltaLOD++;
+				curMesh += deltaMesh;
+				deltaMesh = 0;
+			}
+			WriteModel( curModel + deltaModel, pStudioModel, curLOD );
+			deltaModel++;
+			curLOD += deltaLOD;
+			deltaLOD = 0;
+		}
+		WriteBodyPart( bodyPartID, pBodyPart, curModel );
+		curModel += deltaModel;
+		deltaModel = 0;
+	}
+
+	WriteHeader( m_VertexCacheSize, m_MaxBonesPerVert, m_MaxBonesPerTri, 
+		m_MaxBonesPerStrip, pHdr->numbodyparts, pHdr->checksum );
+
+#ifdef _DEBUG
+	m_FileBuffer->TestWritten( m_EndOfFileOffset );
+#endif
+	
+	MapGlobalBonesToHardwareBoneIDsAndSortBones( pHdr );
+
+//	DebugCompareVerts( phdr );
+	SanityCheckAgainstStudioHDR( pHdr );
+
+	if ( !g_quiet )
+	{
+		OutputMemoryUsage();
+	}
+		
+	RemoveRedundantBoneStateChanges();
+	if( g_staticprop )
+	{
+		ZeroNumBones();
+	}
+
+	// Show statistics
+#ifdef _DEBUG
+//	ShowStats();
+#endif
+		
+	m_FileBuffer->WriteToFile( pFileName, m_EndOfFileOffset );
+
+	FileHeader_t *pVtxHeader = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	SanityCheckVertexBoneLODFlags( pHdr, pVtxHeader );
+}
+	
+
+
+static void MergeLikeBoneIndicesWithinVert( mstudioboneweight_t *pBoneWeight )
+{
+	if( pBoneWeight->numbones == 1 )
+	{
+		return;
+	}
+	
+	int i, j;
+	int realNumBones = pBoneWeight->numbones;
+	for( i = 0; i < pBoneWeight->numbones; i++ )
+	{
+		for( j = i+1; j < pBoneWeight->numbones; j++ )
+		{
+			if( ( pBoneWeight->bone[i] == pBoneWeight->bone[j] ) && ( pBoneWeight->weight[i] != 0.0f ) )
+			{
+				pBoneWeight->weight[i] += pBoneWeight->weight[j];
+				pBoneWeight->weight[j] = 0.0f;
+				realNumBones--;
+			}
+		}
+	}
+
+	// force all of the -1's at the end with a bubble sort
+	
+	float tmpWeight;
+	int tmpIndex;
+	// bubble sort the bones.
+	for( j = pBoneWeight->numbones; j > 1; j-- )
+	{
+		int k;
+		for( k = 0; k < j - 1; k++ )
+		{
+			if( ( pBoneWeight->weight[k] == 0.0f ) && ( pBoneWeight->weight[k+1] != 0.0f ) )
+			{
+				// swap
+				tmpIndex = pBoneWeight->bone[k];
+				tmpWeight = pBoneWeight->weight[k];
+				pBoneWeight->bone[k] = pBoneWeight->bone[k+1];
+				pBoneWeight->weight[k] = pBoneWeight->weight[k+1];
+				pBoneWeight->bone[k+1] = tmpIndex;
+				pBoneWeight->weight[k+1] = tmpWeight;
+			}
+		}
+	}
+	pBoneWeight->numbones = realNumBones;
+}
+
+static void MergeLikeBoneIndicesWithinVerts( studiohdr_t *pHdr )
+{
+	int bodyPartID, modelID, vertID;
+	for( bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++ )
+	{
+		mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
+		for( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
+		{
+			mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
+			for( vertID = 0; vertID < pModel->numvertices; vertID++ )
+			{
+				const mstudio_modelvertexdata_t *vertData = pModel->GetVertexData();
+				Assert( vertData ); // This can only return NULL on X360 for now
+				mstudioboneweight_t *pBoneWeight = vertData->BoneWeights( vertID );
+				MergeLikeBoneIndicesWithinVert( pBoneWeight );
+			}
+		}
+	}
+}
+
+void COptimizedModel::PrintBoneStateChanges( studiohdr_t *phdr, int lod )
+{
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+//		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+//		for( int lodID = 0; lodID < header->numLODs; lodID++ )
+		int lodID = lod;
+		{
+			for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+			{
+				ModelHeader_t *model = bodyPart->pModel( modelID );
+//				mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+//					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+							for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
+							{
+								BoneStateChangeHeader_t *pBoneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
+								printf( "bone change: hwid: %d boneid: %d (%s)\n", 
+									( int )pBoneStateChange->hardwareID, 
+									( int )pBoneStateChange->newBoneID,
+									g_bonetable[pBoneStateChange->newBoneID].name);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+void COptimizedModel::PrintVerts( studiohdr_t *phdr, int lod )
+{
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+//		for( int lodID = 0; lodID < header->numLODs; lodID++ )
+		int lodID = lod;
+		{
+			for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+			{
+				ModelHeader_t *model = bodyPart->pModel( modelID );
+				mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						for( int vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
+						{
+							PrintVert( pStripGroup->pVertex( vertID ), pStudioModel, pStudioMesh );
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+static int CalcNumMaterialReplacements()
+{
+ 	int i;
+	int numReplacements = 0;
+	int numLODs = g_ScriptLODs.Size();
+	for( i = 0; i < numLODs; i++ )
+	{
+		LodScriptData_t &scriptLOD = g_ScriptLODs[i];
+		numReplacements += scriptLOD.materialReplacements.Size();
+	}
+	return numReplacements;
+}
+
+//-----------------------------------------------------------------------------
+//
+// Main entry point
+//
+//-----------------------------------------------------------------------------
+
+bool COptimizedModel::OptimizeFromStudioHdr( studiohdr_t *pHdr, s_bodypart_t *pSrcBodyParts, 
+		int vertCacheSize, 
+		bool usesFixedFunction, bool bForceSoftwareSkin, bool bHWFlex, int maxBonesPerVert, int maxBonesPerTri, 
+		int maxBonesPerStrip, const char *pFileName, const char *glViewFileName )
+{
+	Assert( maxBonesPerVert <= MAX_NUM_BONES_PER_VERT );
+	Assert( maxBonesPerTri <= MAX_NUM_BONES_PER_TRI );
+	Assert( maxBonesPerStrip <= MAX_NUM_BONES_PER_STRIP );
+	
+	MergeLikeBoneIndicesWithinVerts( pHdr );
+	
+	// Some initialization shite
+	SetupMeshProcessing( pHdr, vertCacheSize, usesFixedFunction, maxBonesPerVert,
+		maxBonesPerTri, maxBonesPerStrip, pFileName );
+
+	// The dude that does it all
+	TotalMeshStats_t stats;
+	ProcessModel( pHdr, pSrcBodyParts, stats, bForceSoftwareSkin, bHWFlex );
+	stats.m_TotalMaterialReplacements = CalcNumMaterialReplacements();
+
+	// Write it out to disk
+	WriteVTXFile( pHdr, pFileName, stats );
+	
+	// Write out debugging files....
+	WriteGLViewFiles( pHdr, glViewFileName );
+	
+	//	DebugCrap( pHdr );
+
+//	PrintBoneStateChanges( pHdr, 1 );
+//	PrintVerts( pHdr, 1 );
+
+	delete m_FileBuffer;
+	m_FileBuffer = NULL;
+
+	if( m_NumSkinnedAndFlexedVerts != 0 )
+	{
+		MdlWarning( "!!!!WARNING!!!!: %d flexed verts had more than one bone influence. . will use SLOW path in engine\n", m_NumSkinnedAndFlexedVerts );
+	}
+	
+	CleanupEverything();
+
+	return true;
+}
+
+
+static int numGLViewTrangles = 0;
+static int numGLViewSWDegenerates = 0;
+static int numGLViewHWDegenerates = 0;
+
+
+enum 
+{ 
+	GLVIEWDRAW_TRILIST, 
+	GLVIEWDRAW_TRISTRIP, 
+	GLVIEWDRAW_NONE 
+};
+
+static int s_DrawMode;
+static int s_LastThreeIndices[3];
+static Vertex_t s_LastThreeVerts[3];
+static Vector s_LastThreePositions[3];
+static int s_ListID = 0;
+static bool s_Shrunk[3];
+
+//-----------------------------------------------------------------------------
+//
+// The following methods are used in writing out GL View files
+//
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::PrintVert( Vertex_t *v, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh )
+{
+	printf( "vert:\n" );
+#if 0
+	printf( "\tposition: %f %f %f\n",
+		v->position[0], v->position[1], v->position[2] );
+	printf( "\tnormal: %f %f %f\n", 
+		v->normal[0], v->normal[1], v->normal[2] );
+	printf( "\ttexcoord: %f %f\n",
+		v->texCoord[0], v->texCoord[1] );
+#endif
+	printf( "\torigMeshVertID: %d\n", v->origMeshVertID );
+	printf( "\tnumBones: %d\n", v->numBones );
+	int i;
+//	for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
+	for( i = 0; i < v->numBones; i++ )
+	{
+		float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, v, i );
+		printf( "\tboneID[%d]: %d weight: %f (%s)\n", i, ( int )v->boneID[i], boneWeight, 
+		         g_bonetable[v->boneID[i]].name );
+	}
+}
+
+
+static float RandomFloat( float min, float max )
+{
+	float ret;
+
+	ret = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
+	ret *= max - min;
+	ret += min;
+	return ret;
+}
+
+Vector& COptimizedModel::GetOrigVertPosition( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert )
+{
+	Assert( pStudioMesh->pModel() == pStudioModel );
+
+	const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
+	Assert( vertData ); // This can only return NULL on X360 for now
+	return *vertData->Position( pVert->origMeshVertID );
+}
+
+float COptimizedModel::GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID )
+{
+	Assert( pStudioMesh->pModel() == pStudioModel );
+
+	const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
+	Assert( vertData ); // This can only return NULL on X360 for now
+	return vertData->BoneWeights( pVert->origMeshVertID )->weight[pVert->boneWeightIndex[boneID]];
+}
+
+mstudioboneweight_t &COptimizedModel::GetOrigVertBoneWeight( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert )
+{
+	Assert( pStudioMesh->pModel() == pStudioModel );
+
+	const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
+	Assert( vertData ); // This can only return NULL on X360 for now
+	return *vertData->BoneWeights( pVert->origMeshVertID );
+}
+
+int COptimizedModel::GetOrigVertBoneIndex( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID )
+{
+	Assert( pStudioMesh->pModel() == pStudioModel );
+
+	const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
+	Assert( vertData ); // This can only return NULL on X360 for now
+	return vertData->BoneWeights( pVert->origMeshVertID )->bone[pVert->boneWeightIndex[boneID]];
+}
+
+void COptimizedModel::SetMeshPropsColor( unsigned int meshFlags, Vector& color )
+{
+	if( meshFlags & MESH_IS_TEETH )
+	{
+		color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
+	}
+	else if( meshFlags & MESH_IS_EYES )
+	{
+		color[0] = 1.0f; color[1] = 1.0f; color[2] = 0.0f;
+	}
+	else
+	{
+		color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
+	}
+}
+
+void COptimizedModel::SetFlexedAndSkinColor( unsigned int glViewFlags, unsigned int stripGroupFlags, Vector& color )
+{
+	if( ( glViewFlags & WRITEGLVIEW_SHOWFLEXED ) && ( glViewFlags & WRITEGLVIEW_SHOWSW ) )
+	{
+		if( ( stripGroupFlags & STRIPGROUP_IS_FLEXED ) && 
+			( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
+		{
+			// flexed and hw skinned = yellow
+			color[0] = 1.0f; color[1] = 1.0f; color[2] = 0.0f;
+		}
+		else if( !( stripGroupFlags & STRIPGROUP_IS_FLEXED ) && 
+				 ( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
+		{
+			// not flexed and hw skinned = green
+			color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
+		}
+		else if( !( stripGroupFlags & STRIPGROUP_IS_FLEXED ) && 
+				 !( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
+		{
+			// not flexed and sw skinned = blue
+			color[0] = 0.0f; color[1] = 0.0f; color[2] = 1.0f;
+		}
+		else if( ( stripGroupFlags & STRIPGROUP_IS_FLEXED ) && 
+				 !( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
+		{
+			// flexed and sw skinned = red
+			color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
+		}
+		else
+		{
+			Assert( 0 );
+		}
+
+	}
+	else if( glViewFlags & WRITEGLVIEW_SHOWFLEXED )
+	{
+		if( stripGroupFlags & STRIPGROUP_IS_FLEXED )
+		{
+			color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
+		}
+		else
+		{
+			color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
+		}
+	}
+	else if( glViewFlags & WRITEGLVIEW_SHOWSW )
+	{
+		if( stripGroupFlags & STRIPGROUP_IS_HWSKINNED )
+		{
+			color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
+		}
+		else
+		{
+			color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
+		}
+	}
+}
+
+void COptimizedModel::SetColorFromNumVertexBones( int numBones, Vector& color )
+{
+	Vector numBonesColor[5] = {
+		Vector( 0.0f, 0.0f, 0.0f ), // 0 bones = black
+		Vector( 0.0f, 1.0f, 0.0f ), // 1 bone  = green
+		Vector( 1.0f, 1.0f, 0.0f ), // 2 bones = yellow
+		Vector( 0.0f, 0.0f, 1.0f ), // 3 bones = blue
+		Vector( 1.0f, 0.0f, 0.0f )  // 4 bones = red
+	};
+	Assert( numBones >= 0 && numBones <= 4 );
+	VectorCopy( numBonesColor[numBones], color );	
+}
+
+
+void COptimizedModel::DrawGLViewTriangle( FILE *fp, Vector& pos1, Vector& pos2, Vector& pos3,
+										 Vector& color1, Vector& color2, Vector& color3 )
+{
+	numGLViewTrangles++;
+	fprintf( fp, "3\n" );
+	fprintf( fp, "%f %f %f %f %f %f\n", pos1[0], pos1[1], pos1[2], color1[0], color1[1], color1[2] );
+	fprintf( fp, "%f %f %f %f %f %f\n", pos2[0], pos2[1], pos2[2], color2[0], color2[1], color2[2] );
+	fprintf( fp, "%f %f %f %f %f %f\n", pos3[0], pos3[1], pos3[2], color3[0], color3[1], color3[2] );
+}
+
+//-----------------------------------------------------------------------------
+// use index to test for degenerates. . isn't used for anything else.
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::GLViewVert( FILE *fp, Vertex_t vert, int index, 
+	Vector& color, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, 
+	bool showSubStrips, float shrinkFactor )
+{
+//	CheckVertBoneWeights( &vert, pStudioModel, pStudioMesh );
+	Assert( s_DrawMode != GLVIEWDRAW_NONE );
+	int id = s_ListID % 3;
+	s_LastThreeIndices[id] = index;
+	s_LastThreeVerts[id] = vert;
+	s_Shrunk[id] = false;
+	VectorCopy( GetOrigVertPosition( pStudioModel, pStudioMesh, &s_LastThreeVerts[id] ), s_LastThreePositions[id] );
+	if( s_DrawMode == GLVIEWDRAW_TRILIST )
+	{
+		// trilist
+		if( id == 2 )
+		{
+			ShrinkVerts( shrinkFactor );
+			DrawGLViewTriangle( fp,
+				s_LastThreePositions[0],
+				s_LastThreePositions[1],
+				s_LastThreePositions[2],
+				color, color, color );
+		}
+	}
+	else
+	{
+		// tristrip
+		if( s_ListID >= 2 )
+		{
+			// spit out the triangle with both facings. . doesn't matter if we
+			// get the facing right for glview
+			if( s_LastThreeIndices[0] == s_LastThreeIndices[1] ||
+				s_LastThreeIndices[1] == s_LastThreeIndices[2] ||
+				s_LastThreeIndices[0] == s_LastThreeIndices[2] )
+			{
+				// skip degenerate triangles
+				numGLViewHWDegenerates++;
+				if( showSubStrips )
+				{
+					RandomColor( color );
+				}
+			}
+			else if( !( s_ListID & 1 ) )
+			{
+				ShrinkVerts( shrinkFactor );
+				DrawGLViewTriangle( fp,
+					s_LastThreePositions[(id+0-2+3)%3],
+					s_LastThreePositions[(id+1-2+3)%3],
+					s_LastThreePositions[(id+2-2+3)%3],
+					color, color, color );
+			}
+			else
+			{
+				ShrinkVerts( shrinkFactor );
+				DrawGLViewTriangle( fp,
+					s_LastThreePositions[(id+2-2+3)%3],
+					s_LastThreePositions[(id+1-2+3)%3],
+					s_LastThreePositions[(id+0-2+3)%3],
+					color, color, color );
+			}
+		}
+	}
+
+	s_ListID++;
+}
+
+void COptimizedModel::GLViewDrawEnd( void )
+{
+	s_DrawMode = GLVIEWDRAW_NONE;
+}
+
+/*
+void COptimizedModel::DebugCrap( studiohdr_t *phdr )
+{
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+		for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *model = bodyPart->pModel( modelID );
+			mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+			for( int lodID = 0; lodID < model->numLODs; lodID++ )
+			{
+				char tmp[256];
+				sprintf( tmp, "crap.lod%d", lodID );
+				printf( "writing %s\n", tmp );
+				FILE *fp = fopen( tmp, "w" );
+				if( !fp )
+				{
+					printf( "can't write crap file %s\n", tmp );
+					return;
+				}
+				
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+							for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
+							{
+								int id = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
+								Vertex_t& vert = *pStripGroup->pVertex( id );
+								Vector& vertPos = GetOrigVertPosition( pStudioModel, pStudioMesh, &vert );
+								fprintf( fp, "mesh: %04d origvertid: %04d pos: %0.2f %0.2f %0.2f ", meshID, vert.origMeshVertID, vertPos[0], vertPos[1], vertPos[2] );
+								int i;
+								for( i = 0; i < vert.numBones; i++ )
+								{
+									float boneWeight;
+									boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, &vert, i );
+									int boneID;
+									boneID = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, &vert, i );
+									fprintf( fp, "bone: %d %0.1f ", boneID, boneWeight );
+								}
+								fprintf( fp, "\n" );
+							}
+						}
+					}
+				}
+				fclose( fp );
+			}
+		}
+	}
+}
+*/
+
+
+void COptimizedModel::WriteGLViewFile( studiohdr_t *phdr, const char *pFileName, unsigned int flags, float shrinkFactor )
+{
+	Vector color;
+	RandomColor( color );
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
+		for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *model = bodyPart->pModel( modelID );
+			mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
+			for( int lodID = 0; lodID < model->numLODs; lodID++ )
+			{
+				char tmp[256];
+				sprintf( tmp, "%s.lod%d", pFileName, lodID );
+				printf( "writing %s\n", tmp );
+				CPlainAutoPtr< CP4File > spFile( g_p4factory->AccessFile( tmp ) );
+				spFile->Edit();
+				FILE *fp = fopen( tmp, "w" );
+				if( !fp )
+				{
+					printf( "can't write glview file %s\n", tmp );
+					return;
+				}
+
+/*
+				// write out tangent space vectors
+				int vertID;
+				for( vertID = 0; vertID < pStudioModel->numvertices; vertID++ )
+				{
+					const Vector &pos = *pStudioModel->pVertex( vertID );
+					const Vector &norm = *pStudioModel->pNormal( vertID );
+					const Vector4D &sVect = *pStudioModel->pTangentS( vertID );
+					Vector tmpVect;
+					tmpVect = pos + norm * .15f;
+					fprintf( fp, "2\n" );
+					fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", pos[0], pos[1], pos[2] );
+					fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
+
+					Vector tmpSVect( sVect[0], sVect[1], sVect[2] );
+					tmpVect = pos + tmpSVect * .15f;
+					fprintf( fp, "2\n" );
+					fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", pos[0], pos[1], pos[2] );
+					fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
+
+					Vector tmpTVect;
+					CrossProduct( norm, tmpSVect, tmpTVect );
+					tmpTVect *= sVect[3];
+					tmpVect = pos + tmpTVect * .15f;
+
+					fprintf( fp, "2\n" );
+					fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", pos[0], pos[1], pos[2] );
+					fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
+
+				}
+				continue;
+				*/
+  
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
+					if( flags & WRITEGLVIEW_SHOWMESH )
+					{
+						RandomColor( color );
+					}
+					if( flags & WRITEGLVIEW_SHOWMESHPROPS )
+					{
+						SetMeshPropsColor( mesh->flags, color );
+					}
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						if( flags & WRITEGLVIEW_SHOWSTRIPGROUP )
+						{
+							RandomColor( color );
+						}
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						
+						SetFlexedAndSkinColor( flags, pStripGroup->flags, color );	
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+							if( flags & WRITEGLVIEW_SHOWSTRIP )
+							{
+								RandomColor( color );
+							}
+							
+							if( flags & WRITEGLVIEW_SHOWSTRIPNUMBONES )
+							{
+								switch (pStrip->numBones)
+								{
+								case 0:
+								case 1:
+									color.Init( 0, 0, 255 );
+									break;
+									
+								case 2:
+									color.Init( 0, 255, 0 );
+									break;
+									
+								case 3:
+									color.Init( 255, 255, 0 );
+									break;
+									
+								case 4:
+									color.Init( 255, 0, 0 );
+									break;
+								}
+							}
+							
+							GLViewDrawBegin( ( pStrip->flags & STRIP_IS_TRILIST ) ? GLVIEWDRAW_TRILIST : GLVIEWDRAW_TRISTRIP );
+							for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
+							{
+								int id = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
+								Vertex_t& vert = *pStripGroup->pVertex( id );
+								
+								if( flags & WRITEGLVIEW_SHOWVERTNUMBONES )
+								{
+									switch (vert.numBones)
+									{
+									case 0:
+									case 1:
+										color.Init( 0, 0, 255 );
+										break;
+										
+									case 2:
+										color.Init( 0, 255, 0 );
+										break;
+										
+									case 3:
+										color.Init( 255, 255, 0 );
+										break;
+										
+									case 4:
+										color.Init( 255, 0, 0 );
+										break;
+									}
+								}
+								
+								GLViewVert( fp, vert, id, color, pStudioModel, pStudioMesh, 
+									( flags & WRITEGLVIEW_SHOWSUBSTRIP ) ? true : false, shrinkFactor );
+							}
+							GLViewDrawEnd();
+						}
+					}
+				}
+				fclose( fp );
+				spFile->Add();
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Write out all GL View files
+//-----------------------------------------------------------------------------
+
+void COptimizedModel::WriteGLViewFiles( studiohdr_t *pHdr, char const* glViewFileName )
+{
+	if( !g_bDumpGLViewFiles )
+		return;
+
+	char tmpFileName[128];
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".mesh" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWMESH, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".stripgroup" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIPGROUP, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".strip" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIP, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".substrip" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSUBSTRIP, .97f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".flexed" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWFLEXED, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".sw" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSW, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".flexedandsw" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSW | WRITEGLVIEW_SHOWFLEXED, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".meshprops" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWMESHPROPS, .8f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".vertnumbones" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWVERTNUMBONES, 1.0f );
+	strcpy( tmpFileName, glViewFileName );
+	strcat( tmpFileName, ".stripnumbones" );
+	WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIPNUMBONES, 1.0f );
+}
+
+
+void COptimizedModel::GLViewDrawBegin( int mode )
+{
+	s_DrawMode = mode;
+	s_ListID = 0;
+}
+
+void COptimizedModel::ShrinkVerts( float shrinkFactor )
+{
+	Vector center;
+	Vector delta;
+
+	VectorCopy( s_LastThreePositions[0], center );
+	VectorAdd( center, s_LastThreePositions[1], center );
+	VectorAdd( center, s_LastThreePositions[2], center );
+	VectorScale( center, 1.0f / 3.0f, center );
+
+	int i;
+	for( i = 0; i < 3; i++ )
+	{
+		if( s_Shrunk[i] )
+		{
+			continue;
+		}
+		VectorSubtract( s_LastThreePositions[i], center, delta );
+		VectorScale( delta, shrinkFactor, delta );
+		VectorAdd( center, delta, s_LastThreePositions[i] );
+		s_Shrunk[i] = true;
+	}
+}
+
+void COptimizedModel::CheckVertBoneWeights( Vertex_t *pVert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh )
+{
+	int i;
+	float sum = 0;
+	for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
+	{
+		float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, pVert, i );
+		sum += boneWeight;
+	}
+	Assert( sum > 0.95f && sum < 1.1f );
+}
+
+
+#define CACHE_INEFFICIENCY 6
+void COptimizedModel::ShowStats( void )
+{
+	int totalHWTriangles = 0;
+	int totalHWDegenerates = 0;
+	int totalHWIndices = 0;
+	int totalHWVertexCacheHits = 0;
+	int totalHWVertexCacheMisses = 0;
+	int totalSWTriangles = 0;
+	int totalSWDegenerates = 0;
+	int totalSWIndices = 0;
+	int totalSWVertexCacheHits = 0;
+	int totalSWVertexCacheMisses = 0;
+	
+	CHardwareVertexCache hardwareVertexCache;
+	hardwareVertexCache.Init( m_VertexCacheSize - CACHE_INEFFICIENCY );
+	
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	printf( "header: %d body parts\n", header->numBodyParts );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+		printf( "  bodyPart %d: %d models\n", bodyPartID, bodyPart->numModels );
+		for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *model = bodyPart->pModel( modelID );
+			printf( "    model: %d lods\n", model->numLODs );
+			for( int lodID = 0; lodID < 1; lodID++ )
+			{
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				printf( "     lod: %d meshes\n", pLOD->numMeshes );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					printf( "       mesh %d: %d stripsgroups\n", meshID, mesh->numStripGroups );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+							{
+								int lastThreeIndices[3];
+								
+								StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+								printf( "         strip: %d numIndices: %d indexOffset: %d\n", stripID, pStrip->numIndices, pStrip->indexOffset );
+								
+								hardwareVertexCache.Flush();
+								if( pStrip->flags & STRIP_IS_TRISTRIP )
+								{
+									for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
+									{
+										totalHWIndices++;
+										int newVertOffset = indexID % 3;
+										lastThreeIndices[newVertOffset] = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
+										if( !hardwareVertexCache.IsPresent( lastThreeIndices[newVertOffset] ) )
+										{
+											totalHWVertexCacheMisses++;
+											hardwareVertexCache.Insert( lastThreeIndices[newVertOffset] );
+										}
+										else
+										{
+											totalHWVertexCacheHits++;
+										}
+										if( indexID >= 2 )
+										{
+											totalHWTriangles++;
+											if( lastThreeIndices[0] != lastThreeIndices[1] &&
+												lastThreeIndices[1] != lastThreeIndices[2] )
+											{
+												
+											}
+											else
+											{
+												totalHWDegenerates++;
+											}
+										}
+									}
+								}
+								else
+								{
+									Assert( pStrip->numIndices % 3 == 0 );
+									totalHWTriangles += pStrip->numIndices / 3;
+									for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
+									{
+										int newVertOffset = indexID % 3;
+										int index = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
+//										printf( "%d\n", index );
+										lastThreeIndices[newVertOffset] = index;
+										if( newVertOffset == 2 )
+										{
+											if( lastThreeIndices[0] == lastThreeIndices[1] ||
+												lastThreeIndices[1] == lastThreeIndices[2] ||
+												lastThreeIndices[0] == lastThreeIndices[2] )
+											{
+//												printf( "degenerate triangle!!!! %d %d %d\n", lastThreeIndices[0], lastThreeIndices[1], lastThreeIndices[2] );
+												totalHWDegenerates++;
+											}
+										}
+										totalHWIndices++;
+										if( !hardwareVertexCache.IsPresent( index ) )
+										{
+											totalHWVertexCacheMisses++;
+											hardwareVertexCache.Insert( index );
+										}
+										else
+										{
+											totalHWVertexCacheHits++;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	int totalRealHWTriangles = totalHWTriangles - totalHWDegenerates;
+	int totalRealSWTriangles = totalSWTriangles - totalSWDegenerates;
+	printf( "TotalHWTriangles: %d\n", totalHWTriangles );
+	printf( "TotalHWDegenerates: %d\n", totalHWDegenerates );
+	printf( "TotalRealHWTriangles: %d\n", totalRealHWTriangles );
+	printf( "TotalHWIndices: %d\n", totalHWIndices );
+	printf( "HW real tris/index: %f\n", ( float )totalRealHWTriangles / ( float )totalHWIndices );
+	printf( "totalHWVertexCacheHits: %d\n", totalHWVertexCacheHits );
+	printf( "totalHWVertexCacheMisses: %d\n", totalHWVertexCacheMisses );
+	printf( "HW vertex cache hit/miss ratio: %f\n", ( float )totalHWVertexCacheHits / ( float )totalHWVertexCacheMisses );
+
+	printf( "TotalSWTriangles: %d\n", totalSWTriangles );
+	printf( "TotalSWDegenerates: %d\n", totalSWDegenerates );
+	printf( "TotalRealSWTriangles: %d\n", totalRealSWTriangles );
+	printf( "TotalSWIndices: %d\n", totalSWIndices );
+	printf( "SW real tris/index: %f\n", ( float )totalRealSWTriangles / ( float )totalSWIndices );
+	printf( "totalSWVertexCacheHits: %d\n", totalSWVertexCacheHits );
+	printf( "totalSWVertexCacheMisses: %d\n", totalSWVertexCacheMisses );
+	printf( "SW vertex cache hit/miss ratio: %f\n", ( float )totalSWVertexCacheHits / ( float )totalSWVertexCacheMisses );
+}
+
+void COptimizedModel::CheckVert( Vertex_t *pVert, int maxBonesPerTri, int maxBonesPerVert )
+{
+#ifndef IGNORE_BONES
+
+#ifdef _DEBUG
+	int offset = ( int )( ( unsigned char * )pVert - ( unsigned char * )m_FileBuffer->GetPointer( 0 ) );
+	Assert( offset >= m_VertsOffset && offset < m_IndicesOffset );
+	Assert( ( ( offset - m_VertsOffset ) % sizeof( Vertex_t ) ) == 0 );
+#endif
+
+	int j;
+	for( j = 0; j < maxBonesPerVert; j++ )
+	{
+		if( pVert->boneID[j] != -1 )
+		{
+			Assert( pVert->boneID[j] >= 0 && pVert->boneID[j] < maxBonesPerTri );
+		}
+#if 0
+		if( pVert->boneWeights[j] != 0 )
+		{
+			Assert( pVert->boneID[j] != -1 );
+		}
+#endif
+	}
+	// Test to make sure we are sorted.
+	for( j = 0; j < maxBonesPerVert-1; j++ )
+	{
+#if 1
+//		if( pVert->boneWeights[j] != 0 && pVert->boneWeights[j+1] != 0 )
+		{
+			Assert( pVert->boneID[j] < pVert->boneID[j+1] );
+		}
+#endif
+	}
+#if 0
+	// Make sure that all the non-zero weights are first.
+	bool foundZero = false;
+	for( j = 0; j < maxBonesPerVert; j++ )
+	{
+		if( !foundZero )
+		{
+			if( pVert->boneWeights[j] == 0.0f )
+			{
+				foundZero = true;
+			}
+		}
+		else
+		{
+			Assert( pVert->boneWeights[j] == 0.0f );
+		}
+	}
+#endif
+#endif
+}
+
+void COptimizedModel::CheckAllVerts( int maxBonesPerTri, int maxBonesPerVert )
+{
+	int i;
+	for( i = m_VertsOffset; i < m_IndicesOffset; i += sizeof( Vertex_t ) )
+	{
+		Vertex_t *vert = ( Vertex_t * )m_FileBuffer->GetPointer( i );
+		CheckVert( vert, maxBonesPerTri, maxBonesPerVert );
+	}
+}
+
+void COptimizedModel::SortBonesWithinVertex( bool flexed, Vertex_t *vert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, int *globalToHardwareBoneIndex, int *hardwareToGlobalBoneIndex, int maxBonesPerTri, int maxBonesPerVert )
+{
+	int i;
+/*
+	for( i = 0; i < m_NumBones; i++ )
+	{
+		if( globalToHardwareBoneIndex[i] != -1 )
+		{
+			if( flexed )
+			{
+				printf( "global bone id: %d hardware bone id: %d\n",
+					i, globalToHardwareBoneIndex[i] );
+			}
+		}
+	}
+*/
+#if 0
+	unsigned char tmpWeightIndex;
+	int tmpIndex;
+	int j;
+	// bubble sort the bones.
+	for( j = m_MaxBonesPerVert; j > 1; j-- )
+	{
+		int k;
+		for( k = 0; k < j - 1; k++ )
+		{
+			if( vert->boneID[k] > vert->boneID[k+1] )
+			{
+				// swap
+				tmpIndex = vert->boneID[k];
+				tmpWeightIndex = vert->boneWeightIndex[k];
+				vert->boneID[k] = vert->boneID[k+1];
+				vert->boneWeightIndex[k] = vert->boneWeightIndex[k+1];
+				vert->boneID[k+1] = tmpIndex;
+				vert->boneWeightIndex[k+1] = tmpWeightIndex;
+			}
+		}
+	}
+#else
+	
+	int origBoneWeightIndex[MAX_NUM_BONES_PER_VERT];
+	int zeroWeightIndex = -1;
+	// find a orig vert bone index that has a zero weight
+	for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
+	{
+		float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
+		if( boneWeight == 0.0f )
+		{
+			zeroWeightIndex = i;
+			break;
+		}
+	}
+
+	for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
+	{
+		origBoneWeightIndex[i] = zeroWeightIndex;
+	}
+	for( i = 0; i < vert->numBones; i++ )
+	{
+		float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
+		int globalBoneIndex = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, vert, i );
+//		if( vert->numBones > 1 )
+		{
+			if( flexed )
+			{
+				printf( "boneWeight: %f\n", boneWeight );
+				printf( "globalBoneIndex: %d\n", globalBoneIndex );
+			}
+		}
+		if( boneWeight > 0.0f )
+		{
+			int hardwareBoneIndex = globalToHardwareBoneIndex[globalBoneIndex];
+			Assert( globalBoneIndex != -1 );
+			origBoneWeightIndex[hardwareBoneIndex] = vert->boneWeightIndex[i];
+		}
+		else
+		{
+			int hardwareBoneIndex = globalToHardwareBoneIndex[globalBoneIndex];
+			origBoneWeightIndex[hardwareBoneIndex] = zeroWeightIndex;
+			Assert( zeroWeightIndex != -1 );
+			Assert( globalBoneIndex == -1 );
+		}
+	}
+//	if( vert->numBones > 1 )
+	for( i = 0; i < maxBonesPerTri; i++ )
+	{
+		vert->boneID[i] = i;
+		vert->boneWeightIndex[i] = origBoneWeightIndex[i];
+		float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
+		int globalBoneIndex = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, vert, i );
+		if( flexed )
+		{
+			Assert( boneWeight >= 0.0f && boneWeight <= 1.0f );
+			printf( "boneWeight: %f ", boneWeight );
+			printf( "globalBoneIndex: %d ", globalBoneIndex );
+			printf( "hardwareBoneID: %d\n", i );
+		}
+	}
+	vert->numBones = maxBonesPerTri; // this may be different for software t&l stuff
+#endif	
+}
+
+void COptimizedModel::RemoveRedundantBoneStateChanges( void )
+{
+	FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
+	for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
+	{
+		BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
+
+		bool allocated[MAX_NUM_BONES_PER_STRIP];
+		int hardwareBoneState[MAX_NUM_BONES_PER_STRIP];
+		bool changed[MAX_NUM_BONES_PER_STRIP];
+		
+		// start anew with each body part
+//		printf( "START BODY PARTY - RESETTING BONE MATRIX STATE\n" );
+		int i;
+		for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
+		{
+			hardwareBoneState[i] = -1;
+			allocated[i] = false;
+		}
+		
+		for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
+		{
+			ModelHeader_t *model = bodyPart->pModel( modelID );
+			for( int lodID = 0; lodID < model->numLODs; lodID++ )
+			{
+				ModelLODHeader_t *pLOD = model->pLOD( lodID );
+				for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
+				{
+					MeshHeader_t *mesh = pLOD->pMesh( meshID );
+					for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
+					{
+						StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
+						if( !( pStripGroup->flags & STRIPGROUP_IS_HWSKINNED ) )
+						{
+//							printf( "skipping! software skinned stripgroup\n" );
+							continue;
+						}
+						for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
+						{
+							StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
+//							int startNumBoneChanges = pStrip->numBoneStateChanges;
+/*
+							printf( "HARDWARE BONE STATE\n" );
+							for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
+							{
+								if( allocated[i] )
+								{
+									printf( "\thw: %d global: %d\n", i, hardwareBoneState[i] );
+								}
+							}
+							
+							printf( "before optimization\n" );
+							for( i = 0; i < pStrip->numBoneStateChanges; i++ )
+							{
+								printf( "\thw: %d global: %d\n", 
+									( int )pStrip->pBoneStateChange( i )->hardwareID,
+									( int )pStrip->pBoneStateChange( i )->newBoneID );
+							}
+*/
+							
+							for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
+							{
+								changed[i] = false;
+							}
+							for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
+							{
+								BoneStateChangeHeader_t *boneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
+								Assert( boneStateChange->hardwareID >= 0 && boneStateChange->hardwareID < MAX_NUM_BONES_PER_STRIP );
+								if( allocated[boneStateChange->hardwareID] && 
+									hardwareBoneState[boneStateChange->hardwareID] == boneStateChange->newBoneID )
+								{
+									// already got this one!
+								}
+								else
+								{
+									changed[boneStateChange->hardwareID] = true;
+									allocated[boneStateChange->hardwareID] = true;
+									hardwareBoneState[boneStateChange->hardwareID] = boneStateChange->newBoneID;
+								}
+							}
+/*
+							// now "changed" should tell us which ones we care about.
+							int curOutBoneID = 0;
+							for( i = 0; i < pStrip->numBoneStateChanges; i++ )
+							{
+								// hack . . going to stomp over what is already there with new data.
+								if( changed[i] )
+								{
+									BoneStateChangeHeader_t *boneStateChange = pStrip->pBoneStateChange( curOutBoneID );
+									boneStateChange->hardwareID = i;
+									boneStateChange->newBoneID = hardwareBoneState[i];
+									curOutBoneID++;
+								}
+							}
+							pStrip->numBoneStateChanges = curOutBoneID;
+							printf( "start bone changes: %d end bone changes: %d\n", startNumBoneChanges, pStrip->numBoneStateChanges );
+							printf( "after optimization\n" );
+							for( i = 0; i < pStrip->numBoneStateChanges; i++ )
+							{
+								printf( "\thw: %d global: %d\n", 
+										( int )pStrip->pBoneStateChange( i )->hardwareID,
+										( int )pStrip->pBoneStateChange( i )->newBoneID );
+							}
+
+  */
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+static void AddMaterialReplacementsToStringTable( void )
+{
+ 	int i, j;
+	int numLODs = g_ScriptLODs.Size();
+	for( i = 0; i < numLODs; i++ )
+	{
+		LodScriptData_t &scriptLOD = g_ScriptLODs[i];
+		for( j = 0; j < scriptLOD.materialReplacements.Size(); j++ )
+		{
+			CLodScriptReplacement_t &materialReplacement = scriptLOD.materialReplacements[j];
+			s_StringTable.AddString( materialReplacement.GetDstName() );
+		}
+	}
+}
+
+
+// Check that all replacematerial/removemesh commands map to valid source materials
+void ValidateLODReplacements( studiohdr_t *pHdr )
+{
+	bool failed = false;
+	int lodID;
+	for( lodID = 0; lodID < g_ScriptLODs.Size(); lodID++ )
+	{
+		LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
+		int j;
+		for( j = 0; j < scriptLOD.meshRemovals.Count(); j++ )
+		{
+			const char *pName1 = scriptLOD.meshRemovals[j].GetSrcName();
+			int i;
+			for( i = 0; i < pHdr->numtextures; i++ )
+			{
+				const char *pName2 = pHdr->pTexture( i )->material->GetName();
+				if( ComparePath( pName1, pName2 ) )
+				{
+					goto got_one;
+				}
+			}
+
+			// no match
+			MdlWarning( "\"%s\" doesn't match any of the materals in the model\n", pName1 );
+			failed = true;
+got_one:
+			;
+		}
+	}
+	if( failed )
+	{
+		MdlWarning( "possible materials in model:\n" );
+		int i;
+		for( i = 0; i < pHdr->numtextures; i++ )
+		{
+			MdlWarning( "\t\"%s\"\n", pHdr->pTexture( i )->material->GetName() );
+		}
+		MdlError( "Exiting due to errors\n" );
+	}
+}
+
+void WriteOptimizedFiles( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts )
+{
+	char		filename[MAX_PATH];
+	char		tmpFileName[MAX_PATH];
+	char		glViewFilename[MAX_PATH];
+	
+	ValidateLODReplacements( phdr );
+	
+	s_StringTable.Purge();
+	
+	// hack!  This should really go in the mdl file since it's common to all LODs.
+	AddMaterialReplacementsToStringTable();
+	
+	V_strcpy_safe( filename, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		strcat( filename, "platform_" );
+//		strcat( filename, g_pPlatformName );
+//		strcat( filename, "/" );	
+//	}
+	V_strcat_safe( filename, "models/" );	
+	V_strcat_safe( filename, outname );
+	Q_StripExtension( filename, filename, sizeof( filename ) );
+
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".sw.vtx" );
+	V_strcpy_safe( glViewFilename, filename );
+	V_strcat_safe( glViewFilename, ".sw.glview" );
+	bool bForceSoftwareSkinning = phdr->numbones > 0 && !g_staticprop;
+	s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
+											512,	//vert cache size FIXME: figure out the correct size for L1
+											false, /* doesn't use fixed function */
+											bForceSoftwareSkinning,	// force software skinning if not static prop
+											false, // No hardware flex
+											3,		// bones/vert
+											3*3,		// bones/tri
+											512,	// bones/strip
+											tmpFileName, glViewFilename );
+
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".dx80.vtx" );
+	V_strcpy_safe( glViewFilename, filename );
+	V_strcat_safe( glViewFilename, ".dx80.glview" );
+	s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
+											24 /* vert cache size (real size, not effective!)*/, 
+											false, /* doesn't use fixed function */
+											false, // don't force software skinning
+											false, // No hardware flex
+											3  /* bones/vert */, 
+											9  /* bones/tri */, 
+											16  /* bones/strip */,
+											tmpFileName, glViewFilename );
+
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".dx90.vtx" );
+	V_strcpy_safe( glViewFilename, filename );
+	V_strcat_safe( glViewFilename, ".dx90.glview" );
+	s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
+											24 /* vert cache size (real size, not effective!)*/, 
+											false, /* doesn't use fixed function */
+											false, // don't force software skinning
+											true, // Hardware flex on DX9 parts
+											3  /* bones/vert */, 
+											9  /* bones/tri */, 
+											53  /* bones/strip */,
+											tmpFileName, glViewFilename );
+
+	s_StringTable.Purge();
+}
+
+}; // namespace OptimizedModel
+#pragma optimize( "", on )
diff --git a/utils/studiomdl/perfstats.cpp b/utils/studiomdl/perfstats.cpp
new file mode 100644
index 0000000..c450843
--- /dev/null
+++ b/utils/studiomdl/perfstats.cpp
@@ -0,0 +1,274 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//===========================================================================//
+
+#include <stdlib.h>
+#include <tier0/dbg.h>
+#include "interface.h"
+#include "istudiorender.h"
+#include "studio.h"
+#include "optimize.h"
+#include "cmdlib.h"
+#include "studiomdl.h"
+#include "perfstats.h"
+
+extern void MdlError( char const *pMsg, ... );
+
+static StudioRenderConfig_t s_StudioRenderConfig;
+
+class CStudioDataCache : public CBaseAppSystem<IStudioDataCache>
+{
+public:
+	bool VerifyHeaders( studiohdr_t *pStudioHdr );
+	vertexFileHeader_t *CacheVertexData( studiohdr_t *pStudioHdr );
+};
+
+static CStudioDataCache	g_StudioDataCache;
+EXPOSE_SINGLE_INTERFACE_GLOBALVAR( CStudioDataCache, IStudioDataCache, STUDIO_DATA_CACHE_INTERFACE_VERSION, g_StudioDataCache );
+
+
+/*
+=================
+VerifyHeaders
+
+Minimal presence and header validation, no data loads
+Return true if successful, false otherwise.
+=================
+*/
+bool CStudioDataCache::VerifyHeaders( studiohdr_t *pStudioHdr )
+{
+	// default valid
+	return true;
+}
+
+/*
+=================
+CacheVertexData
+
+Cache model's specified dynamic data
+=================
+*/
+vertexFileHeader_t *CStudioDataCache::CacheVertexData( studiohdr_t *pStudioHdr )
+{
+	// minimal implementation - return persisted data
+	return (vertexFileHeader_t*)pStudioHdr->pVertexBase;
+}
+
+static void UpdateStudioRenderConfig( void )
+{
+	memset( &s_StudioRenderConfig, 0, sizeof(s_StudioRenderConfig) );
+
+	s_StudioRenderConfig.bEyeMove = true;
+	s_StudioRenderConfig.fEyeShiftX = 0.0f;
+	s_StudioRenderConfig.fEyeShiftY = 0.0f;
+	s_StudioRenderConfig.fEyeShiftZ = 0.0f;
+	s_StudioRenderConfig.fEyeSize = 10.0f;
+	s_StudioRenderConfig.bSoftwareSkin = false;
+	s_StudioRenderConfig.bNoHardware = false;
+	s_StudioRenderConfig.bNoSoftware = false;
+	s_StudioRenderConfig.bTeeth = true;
+	s_StudioRenderConfig.drawEntities = true;
+	s_StudioRenderConfig.bFlex = true;
+	s_StudioRenderConfig.bEyes = true;
+	s_StudioRenderConfig.bWireframe = false;
+	s_StudioRenderConfig.bDrawNormals = false;
+	s_StudioRenderConfig.skin = 0;
+	s_StudioRenderConfig.maxDecalsPerModel = 0;
+	s_StudioRenderConfig.bWireframeDecals = false;
+	s_StudioRenderConfig.fullbright = false;
+	s_StudioRenderConfig.bSoftwareLighting = false;
+	s_StudioRenderConfig.bShowEnvCubemapOnly = false;
+	g_pStudioRender->UpdateConfig( s_StudioRenderConfig );
+}
+
+static SpewOutputFunc_t				s_pSavedSpewFunc;
+
+SpewRetval_t NullSpewOutputFunc( SpewType_t spewType, const tchar *pMsg )
+{
+	switch( spewType )
+	{
+	case SPEW_WARNING:
+		return SPEW_CONTINUE;
+	case SPEW_MESSAGE:
+	case SPEW_ASSERT:
+	case SPEW_ERROR:
+	case SPEW_LOG:
+		Assert( s_pSavedSpewFunc );
+		if( s_pSavedSpewFunc )
+		{
+			return s_pSavedSpewFunc( spewType, pMsg );
+		}
+		break;
+	}
+	Assert( 0 );
+	return SPEW_CONTINUE;
+}
+
+void SpewPerfStats( studiohdr_t *pStudioHdr, const char *pFilename, unsigned int flags )
+{
+	char							fileName[260];
+	vertexFileHeader_t				*pNewVvdHdr;
+	vertexFileHeader_t				*pVvdHdr = 0;
+	OptimizedModel::FileHeader_t	*pVtxHdr = 0;
+	studiohwdata_t					studioHWData;
+	int								vvdSize = 0;
+	const char						*prefix[] = {".dx80.vtx", ".dx90.vtx", ".sw.vtx"};
+	s_pSavedSpewFunc				= NULL;
+	if( !( flags & SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS ) )
+	{
+		s_pSavedSpewFunc = GetSpewOutputFunc();
+		SpewOutputFunc( NullSpewOutputFunc );
+	}
+
+	// no stats on these
+	if (!pStudioHdr->numbodyparts)
+		return;
+
+	// Need to update the render config to spew perf stats.
+	UpdateStudioRenderConfig();
+
+	// persist the vvd data
+	Q_StripExtension( pFilename, fileName, sizeof( fileName ) );
+	strcat( fileName, ".vvd" );
+
+	if (FileExists( fileName ))
+	{
+		vvdSize = LoadFile( fileName, (void**)&pVvdHdr );
+	}
+	else
+	{
+		MdlError( "Could not open '%s'\n", fileName );
+	}
+
+	// validate header
+	if (pVvdHdr->id != MODEL_VERTEX_FILE_ID)
+	{
+		MdlError( "Bad id for '%s' (got %d expected %d)\n", fileName, pVvdHdr->id, MODEL_VERTEX_FILE_ID);
+	}
+	if (pVvdHdr->version != MODEL_VERTEX_FILE_VERSION)
+	{
+		MdlError( "Bad version for '%s' (got %d expected %d)\n", fileName, pVvdHdr->version, MODEL_VERTEX_FILE_VERSION);
+	}
+	if (pVvdHdr->checksum != pStudioHdr->checksum)
+	{
+		MdlError( "Bad checksum for '%s' (got %d expected %d)\n", fileName, pVvdHdr->checksum, pStudioHdr->checksum);
+	}
+
+	if (pVvdHdr->numFixups)
+	{
+		// need to perform mesh relocation fixups
+		// allocate a new copy
+		pNewVvdHdr = (vertexFileHeader_t *)malloc( vvdSize );
+		if (!pNewVvdHdr)
+		{
+			MdlError( "Error allocating %d bytes for Vertex File '%s'\n", vvdSize, fileName );
+		}
+
+		Studio_LoadVertexes( pVvdHdr, pNewVvdHdr, 0, true );
+
+		// discard original
+		free( pVvdHdr );
+
+		pVvdHdr = pNewVvdHdr;
+	}
+	
+	// iterate all ???.vtx files
+	for (int j=0; j<sizeof(prefix)/sizeof(prefix[0]); j++)
+	{
+		// make vtx filename
+		Q_StripExtension( pFilename, fileName, sizeof( fileName ) );
+		strcat( fileName, prefix[j] );
+
+		// persist the vtx data
+		if (FileExists(fileName))
+		{
+			LoadFile( fileName, (void**)&pVtxHdr );
+		}
+		else
+		{
+			MdlError( "Could not open '%s'\n", fileName );
+		}
+
+		// validate header
+		if (pVtxHdr->version != OPTIMIZED_MODEL_FILE_VERSION)
+		{
+			MdlError( "Bad version for '%s' (got %d expected %d)\n", fileName, pVtxHdr->version, OPTIMIZED_MODEL_FILE_VERSION );
+		}
+		if (pVtxHdr->checkSum != pStudioHdr->checksum)
+		{
+			MdlError( "Bad checksum for '%s' (got %d expected %d)\n", fileName, pVtxHdr->checkSum, pStudioHdr->checksum );
+		}
+
+		// studio render will request these through cache interface
+		pStudioHdr->pVertexBase = (void *)pVvdHdr;
+		pStudioHdr->pIndexBase  = (void *)pVtxHdr;
+
+		g_pStudioRender->LoadModel( pStudioHdr, pVtxHdr, &studioHWData );
+
+		if( flags & SPEWPERFSTATS_SHOWPERF )
+		{
+			if(  flags & SPEWPERFSTATS_SPREADSHEET )
+			{
+				printf( "%s,%s,%d,", fileName, prefix[j], studioHWData.m_NumLODs - studioHWData.m_RootLOD );
+			}
+			else
+			{
+				printf( "\n" );
+				printf( "Performance Stats: %s\n", fileName );
+				printf( "------------------\n" );
+			}
+		}
+
+		int i;
+		if( flags & SPEWPERFSTATS_SHOWPERF )
+		{
+			for( i = studioHWData.m_RootLOD; i < studioHWData.m_NumLODs; i++ )
+			{
+				DrawModelInfo_t drawModelInfo;
+				drawModelInfo.m_Skin = 0;
+				drawModelInfo.m_Body = 0;
+				drawModelInfo.m_HitboxSet = 0;
+				drawModelInfo.m_pClientEntity = 0;
+				drawModelInfo.m_pColorMeshes = 0;
+				drawModelInfo.m_pStudioHdr = pStudioHdr;
+				drawModelInfo.m_pHardwareData = &studioHWData;	
+				CUtlBuffer statsOutput( 0, 0, CUtlBuffer::TEXT_BUFFER );
+				if( !( flags & SPEWPERFSTATS_SPREADSHEET ) )
+				{
+					printf( "LOD:%d\n", i );
+				}
+				drawModelInfo.m_Lod = i;
+
+				DrawModelResults_t results;
+				g_pStudioRender->GetPerfStats( &results, drawModelInfo, &statsOutput );
+				if( flags & SPEWPERFSTATS_SPREADSHEET )
+				{
+					printf( "%d,%d,%d,", results.m_ActualTriCount, results.m_NumBatches, results.m_NumMaterials  );
+				}
+				else
+				{
+					printf( "    actual tris:%d\n", ( int )results.m_ActualTriCount );
+					printf( "    texture memory bytes: %d (only valid in a rendering app)\n", ( int )results.m_TextureMemoryBytes );
+					printf( ( char * )statsOutput.Base() );
+				}
+			}
+			if( flags & SPEWPERFSTATS_SPREADSHEET )
+			{
+				printf( "\n" );
+			}
+		}
+		g_pStudioRender->UnloadModel( &studioHWData );
+		free(pVtxHdr);
+	}
+
+	if (pVvdHdr)
+		free(pVvdHdr);
+
+	if( !( flags & SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS ) )
+	{
+		SpewOutputFunc( s_pSavedSpewFunc );
+	}
+}
+
diff --git a/utils/studiomdl/perfstats.h b/utils/studiomdl/perfstats.h
new file mode 100644
index 0000000..acf2926
--- /dev/null
+++ b/utils/studiomdl/perfstats.h
@@ -0,0 +1,25 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef PERFSTATS_H
+#define PERFSTATS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "studio.h"
+#include "optimize.h"
+
+enum
+{
+	SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS = 1,
+	SPEWPERFSTATS_SHOWPERF = 2,
+	SPEWPERFSTATS_SPREADSHEET = 4,
+};
+
+void SpewPerfStats( studiohdr_t *pStudioHdr, const char *pFilename, unsigned int flags );
+
+#endif // PERFSTATS_H
diff --git a/utils/studiomdl/simplify.cpp b/utils/studiomdl/simplify.cpp
new file mode 100644
index 0000000..a9baf4d
--- /dev/null
+++ b/utils/studiomdl/simplify.cpp
@@ -0,0 +1,8238 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// studiomdl.c: generates a studio .mdl file from a .qc script
+// models/<scriptname>.mdl.
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <float.h>
+
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+#include "bone_setup.h"
+#include "tier1/strtools.h"
+#include "mathlib/vmatrix.h"
+#include "mdlobjects/dmeboneflexdriver.h"
+
+
+class CBoneRenderBounds
+{
+public:
+	Vector m_Mins;	// In bone space.
+	Vector m_Maxs;
+};
+
+// this is computed once so render models and their physics hulls get translated by the same amount
+static Vector g_PropCenterOffset(0,0,0);
+
+
+//----------------------------------------------------------------------
+// underlay:
+// studiomdl : delta = new_anim * ( -1 * base_anim )
+// engine : result = (w * delta) * base_anim
+// 
+// overlay
+// 
+// studiomdl : delta = (-1 * base_anim ) * new_anim
+// engine : result = base_anim * (w * delta)
+//
+//----------------------------------------------------------------------
+void QuaternionSMAngles( float s, Quaternion const &p, Quaternion const &q, RadianEuler &angles )
+{
+	Quaternion qt;
+	QuaternionSM( s, p, q, qt );
+	QuaternionAngles( qt, angles );
+}
+
+
+void QuaternionMAAngles( Quaternion const &p, float s, Quaternion const &q, RadianEuler &angles )
+{
+	Quaternion qt;
+	QuaternionMA( p, s, q, qt );
+	QuaternionAngles( qt, angles );
+}
+
+
+// q = p * (-q * p)
+
+//-----------------------------------------------------------------------------
+// Purpose: subtract linear motion from root bone animations
+//			fixup missing frames from looping animations
+//			create "delta" animations
+//-----------------------------------------------------------------------------
+int g_rootIndex = 0;
+
+
+void buildAnimationWeights( void );
+void extractLinearMotion( s_animation_t *panim, int motiontype, int iStartFrame, int iEndFrame, int iSrcFrame, s_animation_t *pRefAnim, int iRefFrame /* , Vector pos, QAngle angles */ );
+void fixupMissingFrame( s_animation_t *panim );
+void realignLooping( s_animation_t *panim );
+void extractUnusedMotion( s_animation_t *panim );
+
+// TODO: psrc and pdest as terms are ambigious, replace with something better
+void setAnimationWeight( s_animation_t *panim, int index );
+void processMatch( s_animation_t *psrc, s_animation_t *pdest, int flags );
+void worldspaceBlend( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags );
+void processAutoorigin( s_animation_t *psrc, s_animation_t *pdest, int flags, int srcframe, int destframe, int bone );
+void subtractBaseAnimations( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags );
+void fixupLoopingDiscontinuities( s_animation_t *panim, int start, int end );
+void matchBlend( s_animation_t *pDestAnim, s_animation_t *pSrcAnimation, int iSrcFrame, int iDestFrame, int iPre, int iPost );
+void makeAngle( s_animation_t *panim, float angle );
+void fixupIKErrors( s_animation_t *panim, s_ikrule_t *pRule );
+void createDerivative( s_animation_t *panim, float scale );
+void clearAnimations( s_animation_t *panim );
+void counterRotateBone( s_animation_t *panim, int bone, QAngle target );
+void localHierarchy( s_animation_t *panim, char *pBonename, char *pParentname, int start, int peak, int tail, int end  );
+
+void linearDelta( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags );
+void splineDelta( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags );
+void reencodeAnimation( s_animation_t *panim, int frameskip );
+void forceNumframes( s_animation_t *panim, int frames );
+
+void forceAnimationLoop( s_animation_t *panim );
+
+void solveBone( s_animation_t *panim, int iFrame, int iBone, matrix3x4_t* pBoneToWorld );
+
+
+void ClearModel (void)
+{
+
+}
+
+
+void processAnimations()
+{ 
+	int i, j;
+
+	// find global root bone.
+	if ( strlen( rootname ) )
+	{
+		g_rootIndex = findGlobalBone( rootname );
+		if (g_rootIndex == -1)
+			g_rootIndex = 0;
+	}
+
+	buildAnimationWeights( );
+
+	for (i = 0; i < g_numani; i++)
+	{
+		s_animation_t *panim = g_panimation[i];
+
+		extractUnusedMotion( panim ); // FIXME: this should be part of LinearMotion()
+
+		setAnimationWeight( panim, 0 );
+
+		int startframe = 0;
+
+		if (panim->fudgeloop)
+		{
+			fixupMissingFrame( panim );
+		}
+
+		for (j = 0; j < panim->numcmds; j++)
+		{
+			s_animcmd_t *pcmd = &panim->cmds[j];
+
+			switch( pcmd->cmd )
+			{
+			case CMD_WEIGHTS:
+				setAnimationWeight( panim, pcmd->u.weightlist.index );
+				break;
+			case CMD_SUBTRACT:
+				panim->flags |= STUDIO_DELTA;
+				subtractBaseAnimations( pcmd->u.subtract.ref, panim, pcmd->u.subtract.frame, pcmd->u.subtract.flags );
+				break;
+			case CMD_AO:
+				{
+					int bone = g_rootIndex;
+					if (pcmd->u.ao.pBonename != NULL)
+					{
+						bone = findGlobalBone( pcmd->u.ao.pBonename );
+						if (bone == -1)
+						{
+							MdlError("unable to find bone %s to alignbone\n", pcmd->u.ao.pBonename );
+						}
+					}
+					processAutoorigin( pcmd->u.ao.ref, panim, pcmd->u.ao.motiontype, pcmd->u.ao.srcframe, pcmd->u.ao.destframe, bone );
+				}
+				break;
+			case CMD_MATCH:
+				processMatch( pcmd->u.match.ref, panim, false );
+				break;
+			case CMD_FIXUP:
+				fixupLoopingDiscontinuities( panim, pcmd->u.fixuploop.start, pcmd->u.fixuploop.end );
+				break;
+			case CMD_ANGLE:
+				makeAngle( panim, pcmd->u.angle.angle );
+				break;
+			case CMD_IKFIXUP:
+				break;
+			case CMD_IKRULE:
+				// processed later
+				break;
+			case CMD_MOTION:
+				{
+					extractLinearMotion( 
+						panim, 
+						pcmd->u.motion.motiontype, 
+						startframe, 
+						pcmd->u.motion.iEndFrame, 
+						pcmd->u.motion.iEndFrame, 
+						panim, 
+						startframe );
+					startframe = pcmd->u.motion.iEndFrame;
+				}
+				break;
+			case CMD_REFMOTION:
+				{
+					extractLinearMotion(
+						panim, 
+						pcmd->u.motion.motiontype, 
+						startframe, 
+						pcmd->u.motion.iEndFrame, 
+						pcmd->u.motion.iSrcFrame, 
+						pcmd->u.motion.pRefAnim, 
+						pcmd->u.motion.iRefFrame );
+					startframe = pcmd->u.motion.iEndFrame;
+				}
+				break;
+			case CMD_DERIVATIVE:
+				{
+					createDerivative(
+						panim, 
+						pcmd->u.derivative.scale );
+				}
+				break;
+			case CMD_NOANIMATION:
+				{
+					clearAnimations( panim );
+				}
+				break;
+			case CMD_LINEARDELTA:
+				{
+					panim->flags |= STUDIO_DELTA;
+					linearDelta( panim, panim, panim->numframes - 1, pcmd->u.linear.flags );
+				}
+				break;
+			case CMD_COMPRESS:
+				{
+					reencodeAnimation( panim, pcmd->u.compress.frames );
+				}
+				break;
+			case CMD_NUMFRAMES:
+				{
+					forceNumframes( panim, pcmd->u.numframes.frames );
+				}
+				break;
+			case CMD_COUNTERROTATE:
+				{
+					int bone = findGlobalBone( pcmd->u.counterrotate.pBonename );
+					if (bone != -1)
+					{
+						QAngle target;
+
+						if (!pcmd->u.counterrotate.bHasTarget)
+						{
+							matrix3x4_t rootxform;
+							matrix3x4_t defaultBoneToWorld;
+							AngleMatrix( panim->rotation, rootxform );
+							ConcatTransforms( rootxform, g_bonetable[bone].boneToPose, defaultBoneToWorld );
+
+							MatrixAngles( defaultBoneToWorld, target );
+						}
+						else
+						{
+							target.Init( pcmd->u.counterrotate.targetAngle[0], pcmd->u.counterrotate.targetAngle[1], pcmd->u.counterrotate.targetAngle[2] );
+						}
+
+						counterRotateBone( panim, bone, target );
+					}
+					else
+					{
+						MdlError("unable to find bone %s to counterrotate\n", pcmd->u.counterrotate.pBonename );
+					}
+				}
+				break;
+			case CMD_WORLDSPACEBLEND:
+				worldspaceBlend( pcmd->u.world.ref, panim, pcmd->u.world.startframe, pcmd->u.world.loops );
+				break;
+			case CMD_MATCHBLEND:
+				matchBlend( panim, pcmd->u.match.ref, pcmd->u.match.srcframe, pcmd->u.match.destframe, pcmd->u.match.destpre, pcmd->u.match.destpost );
+				break;
+			case CMD_LOCALHIERARCHY:
+				localHierarchy( panim, pcmd->u.localhierarchy.pBonename, pcmd->u.localhierarchy.pParentname, pcmd->u.localhierarchy.start, pcmd->u.localhierarchy.peak, pcmd->u.localhierarchy.tail, pcmd->u.localhierarchy.end );
+				// localHierarchy( panim, char	*pBonename, char *pParentname, int start, int peak, int tail, int end );
+				break;
+			}
+		}
+
+		if (panim->motiontype)
+		{
+			int lastframe;
+			if (!(panim->flags & STUDIO_LOOPING) )
+			{
+				// roll back 0.2 seconds to try to prevent popping
+				int frames = panim->fps * panim->motionrollback;
+				lastframe = max( min( startframe + 1, panim->numframes - 1), panim->numframes - frames - 1 );
+				//printf("%s : %d %d (%d)\n", panim->name, startframe, lastframe, panim->numframes - 1 );
+			}
+			else
+			{
+				lastframe = panim->numframes - 1;
+			}
+			extractLinearMotion( panim, panim->motiontype, startframe, lastframe, panim->numframes - 1, panim, startframe );
+			startframe = panim->numframes - 1;
+		}
+
+		realignLooping( panim );
+
+		forceAnimationLoop( panim );
+	}
+
+	// merge weightlists
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		int k, n;
+		for (n = 0; n < g_numbones; n++)
+		{
+			g_sequence[i].weight[n] = 0.0;
+
+			for (j = 0; j < g_sequence[i].groupsize[0]; j++)
+			{
+				for (k = 0; k < g_sequence[i].groupsize[1]; k++)
+				{
+					g_sequence[i].weight[n] = max( g_sequence[i].weight[n], g_sequence[i].panim[j][k]->weight[n] );
+				}
+			}
+		}
+	}
+}
+
+
+/*
+void lookupLinearMotion( s_animation_t *panim, int motiontype, int startframe, int endframe, Vector &p1, Vector &p2 )
+{
+	Vector p0 = panim->sanim[startframe][g_rootIndex].pos;
+	p2 = panim->sanim[endframe][g_rootIndex].pos[0];
+
+	float fFrame = (startframe + endframe) / 2.0;
+	int iFrame = (int)fFrame;
+	float s = fFrame - iFrame;
+
+	p1 = panim->sanim[iFrame][g_rootIndex].pos * (1 - s) + panim->sanim[iFrame+1][g_rootIndex].pos * s;
+}
+*/
+
+
+	// 0.375 * v1 + 0.125 * v2 - d2 = 0.5 * v1 + 0.5 * v2 - d3;
+
+	// 0.375 * v1 - 0.5 * v1 = 0.5 * v2 - d3 - 0.125 * v2 + d2;
+	// 0.375 * v1 - 0.5 * v1 = 0.5 * v2 - d3 - 0.125 * v2 + d2;
+	// -0.125 * v1 = 0.375 * v2 - d3 + d2;
+	// v1 = (0.375 * v2 - d3 + d2) / -0.125;
+
+	// -3 * (0.375 * v2 - d3 + d2) + 0.125 * v2 - d2 = 0
+	// -3 * (0.375 * v2 - d3 + d2) + 0.125 * v2 - d2 = 0
+	// -1 * v2 + 3 * d3 - 3 * d2 - d2 = 0
+	// v2 = 3 * d3 - 4 * d2
+
+	// 0.5 * v1 + 0.5 * v2 - d3
+	// -4 * (0.375 * v2 - d3 + d2) + 0.5 * v2 - d3 = 0
+	// -1.5 * v2 + 4 * d3 - 4 * d2 + 0.5 * v2 - d3 = 0
+	// v2 = 4 * d3 - 4 * d2 - d3 
+	// v2 = 3 * d3 - 4 * d2
+
+	// 0.5 * v1 + 0.5 * (3 * d3 - 4 * d2) - d3 = 0
+	// v1 + (3 * d3 - 4 * d2) - 2 * d3 = 0
+	// v1 = -3 * d3 + 4 * d2 + 2 * d3
+	// v1 = -1 * d3 + 4 * d2
+
+
+
+void ConvertToAnimLocal( s_animation_t *panim, Vector &pos, QAngle &angles )
+{
+	matrix3x4_t bonematrix;
+	matrix3x4_t adjmatrix;
+
+	// convert explicit position/angle into animation relative values
+	AngleMatrix( angles, pos, bonematrix );
+	AngleMatrix( panim->rotation, panim->adjust, adjmatrix );
+	MatrixInvert( adjmatrix, adjmatrix );
+	ConcatTransforms( adjmatrix, bonematrix, bonematrix );
+	MatrixAngles( bonematrix, angles, pos );
+	// pos = pos * panim->scale;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: find the linear movement/rotation between two frames, subtract that 
+//			out of the animation and add it back on as a "piecewise movement" command
+// panim		- current animation
+// motiontype	- what to extract
+// iStartFrame	- first frame to apply motion over
+// iEndFrame	- last end frame to apply motion over
+// iSrcFrame	- match refFrame against what frame of the current animation
+// pRefAnim		- reference animtion
+// iRefFrame	- frame of reference animation to match
+//-----------------------------------------------------------------------------
+
+void extractLinearMotion( s_animation_t *panim, int motiontype, int iStartFrame, int iEndFrame, int iSrcFrame, s_animation_t *pRefAnim, int iRefFrame /* , Vector pos, QAngle angles */ )
+{
+	int j, k;
+	matrix3x4_t adjmatrix;
+
+	// Can't extract motion with only 1 frame of animation!
+	if ( panim->numframes <= 1 )
+	{
+		MdlError( "Can't extract motion from sequence %s (%s).  Check your QC options!\n", panim->name, panim->filename );
+	}
+
+	if (panim->numpiecewisekeys >= MAXSTUDIOMOVEKEYS)
+	{
+		MdlError( "Too many piecewise movement keys in %s (%s)\n", panim->name, panim->filename );
+	}
+
+	if (iEndFrame > panim->numframes - 1)
+		iEndFrame = panim->numframes - 1;
+
+	if (iSrcFrame > panim->numframes - 1)
+		iSrcFrame = panim->numframes - 1;
+
+	if (iStartFrame >= iEndFrame)
+	{
+		MdlWarning("Motion extraction ignored, no frames remaining in %s (%s)\n", panim->name, panim->filename );
+		return;
+	}
+
+	float fFrame = (iStartFrame + iSrcFrame) / 2.0;
+	int iMidFrame = (int)fFrame;
+	float s = fFrame - iMidFrame;
+
+	// find rotation
+	RadianEuler	rot( 0, 0, 0 );
+
+	if (motiontype & (STUDIO_LXR | STUDIO_LYR | STUDIO_LZR))
+	{
+		Quaternion q0;
+		Quaternion q1;
+		Quaternion q2;
+
+		AngleQuaternion( pRefAnim->sanim[iRefFrame][g_rootIndex].rot, q0 );
+		AngleQuaternion( panim->sanim[iMidFrame][g_rootIndex].rot, q1 ); // only used for rotation checking
+		AngleQuaternion( panim->sanim[iSrcFrame][g_rootIndex].rot, q2 );
+
+		Quaternion deltaQ1;
+		QuaternionMA( q1, -1, q0, deltaQ1 );
+		Quaternion deltaQ2;
+		QuaternionMA( q2, -1, q0, deltaQ2 );
+
+		// FIXME: this is still wrong, but it should be slightly more robust
+		RadianEuler a3;
+		if (motiontype & STUDIO_LXR)
+		{
+			Quaternion q4;
+			q4.Init( deltaQ2.x, 0, 0, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+			rot.x = a3.x;
+		}
+		if (motiontype & STUDIO_LYR)
+		{
+			Quaternion q4;
+			q4.Init( 0, deltaQ2.y, 0, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+			rot.y = a3.y;
+		}
+		if (motiontype & STUDIO_LZR)
+		{
+			Quaternion q4;
+			q4.Init( 0, 0, deltaQ2.z, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+
+			// check for possible rotations >180 degrees by looking at the 
+			// halfway point and seeing if it's rotating a different direction
+			// than the shortest path to the end point
+			Quaternion q5;
+			RadianEuler a5;
+			q5.Init( 0, 0, deltaQ1.z, deltaQ1.w );
+			QuaternionNormalize( q5 );
+			QuaternionAngles( q5, a5 );
+			if (a3.z > M_PI) a5.z -= 2*M_PI;
+			if (a3.z < -M_PI) a5.z += 2*M_PI;
+			if (a5.z > M_PI) a5.z -= 2*M_PI;
+			if (a5.z < -M_PI) a5.z += 2*M_PI;
+			if (a5.z > M_PI/4 && a3.z < 0)
+			{
+				a3.z += 2*M_PI;
+			}
+			if (a5.z < -M_PI/4 && a3.z > 0)
+			{
+				a3.z -= 2*M_PI;
+			}
+
+			rot.z = a3.z;
+		}
+	}
+
+	// find movement
+	Vector p0;
+	AngleMatrix(rot, adjmatrix );
+	VectorRotate( pRefAnim->sanim[iRefFrame][g_rootIndex].pos, adjmatrix, p0 );
+
+	Vector p2 = panim->sanim[iSrcFrame][g_rootIndex].pos;
+	Vector p1 = panim->sanim[iMidFrame][g_rootIndex].pos * (1 - s) + panim->sanim[iMidFrame+1][g_rootIndex].pos * s;
+
+	// ConvertToAnimLocal( panim, pos, angles ); // FIXME: unused
+
+	p2 = p2 - p0;
+	p1 = p1 - p0;
+
+	if (!(motiontype & STUDIO_LX)) { p2.x = 0; p1.x = 0; };
+	if (!(motiontype & STUDIO_LY)) { p2.y = 0; p1.y = 0; };
+	if (!(motiontype & STUDIO_LZ)) { p2.z = 0; p1.z = 0; };
+	
+	// printf("%s  %.1f %.1f %.1f\n", g_bonetable[g_rootIndex].name, p2.x, p2.y, p2.z );
+
+	float d1 = p1.Length();
+	float d2 = p2.Length();
+
+	float v0 = -1 * d2 + 4 * d1;
+	float v1 = 3 * d2 - 4 * d1;
+
+	if ( g_verbose )
+	{
+		printf("%s : %d - %d : %.1f %.1f %.1f\n", panim->name, iStartFrame, iEndFrame, p2.x, p2.y, RAD2DEG( rot[2] ) );
+	}
+
+	int numframes = iEndFrame - iStartFrame + 1;
+	if (numframes < 1)
+		return;
+
+	float n = numframes - 1;
+
+	//printf("%f %f : ", v0, v1 );
+
+	if (motiontype & STUDIO_LINEAR)
+	{
+		v0 = v1 = p2.Length();
+	}
+	else if (v0 < 0.0f)
+	{
+		v0 = 0.0;
+		v1 = p2.Length() * 2.0;
+	}
+	else if (v1 < 0.0)
+	{
+		v0 = p2.Length() * 2.0;
+		v1 = 0.0;
+	}
+	else if ((v0+v1) > 0.01 && (fabs(v0-v1) / (v0+v1)) < 0.2)
+	{
+		// if they're within 10% of each other, assum no acceleration
+		v0 = v1 = p2.Length();
+	}
+
+	//printf("%f %f\n", v0, v1 );
+
+	Vector v = p2;
+	VectorNormalize( v );
+
+	Vector A, B, C;
+	if (motiontype & STUDIO_QUADRATIC_MOTION)
+	{
+		SolveInverseQuadratic( 0, 0, 0.5, p1.x, 1.0, p2.x, A.x, B.x, C.x );
+		SolveInverseQuadratic( 0, 0, 0.5, p1.y, 1.0, p2.y, A.y, B.y, C.y );
+		SolveInverseQuadratic( 0, 0, 0.5, p1.z, 1.0, p2.z, A.z, B.z, C.z );
+	}
+
+	Vector	adjpos;
+	RadianEuler	adjangle;
+	matrix3x4_t bonematrix;
+	for (j = 0; j < numframes; j++)
+	{	
+		float t = (j / n);
+
+		if (motiontype & STUDIO_QUADRATIC_MOTION)
+		{
+			adjpos.x = t * t * A.x + t * B.x + C.x;
+			adjpos.y = t * t * A.y + t * B.y + C.y;
+			adjpos.z = t * t * A.z + t * B.z + C.z;
+		}
+		else
+		{
+			VectorScale( v, v0 * t + 0.5 * (v1 - v0) * t * t, adjpos );
+		}
+
+		VectorScale( rot, t, adjangle );
+
+		AngleMatrix( adjangle, adjpos, adjmatrix );
+		MatrixInvert( adjmatrix, adjmatrix );
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].parent == -1)
+			{
+				// printf(" %.1f %.1f %.1f : ", adjpos[0], adjpos[1], RAD2DEG( adjangle[2] ));
+
+				// printf(" %.1f %.1f %.1f\n", adjpos[0], adjpos[1], adjpos[2] );
+
+				AngleMatrix( panim->sanim[j+iStartFrame][k].rot, panim->sanim[j+iStartFrame][k].pos, bonematrix );
+				ConcatTransforms( adjmatrix, bonematrix, bonematrix );
+
+				MatrixAngles( bonematrix, panim->sanim[j+iStartFrame][k].rot, panim->sanim[j+iStartFrame][k].pos );
+				// printf("%d : %.1f %.1f %.1f\n", j, panim->sanim[j+iStartFrame][k].pos.x, panim->sanim[j+iStartFrame][k].pos.y, RAD2DEG( panim->sanim[j+iStartFrame][k].rot.z ) );
+			}
+		}
+	}
+
+	for (; j+iStartFrame < panim->numframes; j++)
+	{
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].parent == -1)
+			{
+				AngleMatrix( panim->sanim[j+iStartFrame][k].rot, panim->sanim[j+iStartFrame][k].pos, bonematrix );
+				ConcatTransforms( adjmatrix, bonematrix, bonematrix );
+				MatrixAngles( bonematrix, panim->sanim[j+iStartFrame][k].rot, panim->sanim[j+iStartFrame][k].pos );
+			}
+		}
+	}
+
+	// create piecewise motion paths
+
+	s_linearmove_t *pmove = &panim->piecewisemove[panim->numpiecewisekeys++];
+
+	pmove->endframe = iEndFrame;
+
+	pmove->flags = motiontype;
+
+	// concatinate xforms
+	if (panim->numpiecewisekeys > 1)
+	{
+		AngleMatrix( adjangle, adjpos, bonematrix );
+		AngleMatrix( pmove[-1].rot, pmove[-1].pos, adjmatrix );
+		ConcatTransforms( adjmatrix, bonematrix, bonematrix );
+		MatrixAngles( bonematrix, pmove[0].rot, pmove[0].pos );
+		pmove->vector = pmove[0].pos - pmove[-1].pos;
+	}
+	else
+	{
+		VectorCopy( adjpos, pmove[0].pos );
+		VectorCopy( adjangle, pmove[0].rot );
+		pmove->vector = pmove[0].pos;
+	}
+	VectorNormalize( pmove->vector );
+
+	// printf("%d : %.1f %.1f %.1f\n", iEndFrame, pmove[0].pos.x, pmove[0].pos.y, RAD2DEG( pmove[0].rot.z ) ); 
+
+	pmove->v0 = v0;
+	pmove->v1 = v1;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: process the "piecewise movement" commands and return where the animation
+//			would move to on a given frame (assuming frame 0 is at the origin)
+//-----------------------------------------------------------------------------
+
+Vector calcPosition( s_animation_t *panim, int iFrame )
+{
+	Vector vecPos;
+	
+	vecPos.Init();
+
+	if (panim->numpiecewisekeys == 0)
+		return vecPos;
+
+	if (panim->numframes == 1)
+		return vecPos;
+
+	int iLoops = 0;
+	while (iFrame >= (panim->numframes - 1))
+	{
+		iLoops++;
+		iFrame = iFrame - (panim->numframes - 1);
+	}
+
+	float	prevframe = 0.0f;
+
+	for (int i = 0; i < panim->numpiecewisekeys; i++)
+	{
+		s_linearmove_t *pmove = &panim->piecewisemove[i];
+
+		if (pmove->endframe >= iFrame)
+		{
+			float f = (iFrame - prevframe) / (pmove->endframe - prevframe);
+
+			float d = pmove->v0 * f + 0.5 * (pmove->v1 - pmove->v0) * f * f;
+
+			vecPos = vecPos + d * pmove->vector;
+			if (iLoops != 0)
+			{
+				s_linearmove_t *pmove = &panim->piecewisemove[panim->numpiecewisekeys - 1];
+				vecPos = vecPos + iLoops * pmove->pos; 
+			}
+			return vecPos;
+		}
+		else
+		{
+			prevframe = pmove->endframe;
+			vecPos = pmove->pos;
+		}
+	}
+	return vecPos;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calculate how far an animation travels between two frames
+//-----------------------------------------------------------------------------
+
+Vector calcMovement( s_animation_t *panim, int iFrom, int iTo )
+{
+	Vector p1 = calcPosition( panim, iFrom );
+	Vector p2 = calcPosition( panim, iTo );
+
+	return p2 - p1;
+}
+
+#if 0
+	// FIXME: add in correct motion!!!
+	int iFrame = pRule->peak - pRule->start - k;
+	if (pRule->start + k > panim->numframes - 1)
+	{
+		iFrame = iFrame + 1;
+	}
+	Vector pos = footfall;
+	if (panim->numframes > 1)
+		pos = pos + panim->piecewisemove[0].pos * (iFrame) / (panim->numframes - 1.0f);
+#endif
+
+	
+//-----------------------------------------------------------------------------
+// Purpose: try to calculate a "missing" frame of animation, i.e the overlapping frame
+//-----------------------------------------------------------------------------
+
+void fixupMissingFrame( s_animation_t *panim )
+{
+	// the animations DIDN'T have the end frame the same as the start frame, so fudge it
+	int size = g_numbones * sizeof( s_bone_t );
+	int j = panim->numframes;
+
+	float scale = 1 / (j - 1.0f);
+
+	panim->sanim[j] = (s_bone_t *)kalloc( 1, size );
+
+	Vector deltapos;
+
+	for (int k = 0; k < g_numbones; k++)
+	{
+		VectorSubtract( panim->sanim[j-1][k].pos, panim->sanim[0][k].pos, deltapos );
+		VectorMA( panim->sanim[j-1][k].pos, scale, deltapos, panim->sanim[j][k].pos );
+		VectorCopy( panim->sanim[0][k].rot, panim->sanim[j][k].rot );
+	}
+
+	panim->numframes = j + 1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: shift the frames of the animation so that it starts on the desired frame
+//-----------------------------------------------------------------------------
+
+void realignLooping( s_animation_t *panim )
+{	
+	int j, k;
+
+	// realign looping animations
+	if (panim->numframes > 1 && panim->looprestart)
+	{
+		if (panim->looprestart >= panim->numframes)
+		{
+			MdlError( "loopstart (%d) out of range for animation %s (%d)", panim->looprestart, panim->name, panim->numframes );
+		}
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			int n;
+
+			Vector	shiftpos[MAXSTUDIOANIMFRAMES];
+			RadianEuler	shiftrot[MAXSTUDIOANIMFRAMES];
+
+			// printf("%f %f %f\n", motion[0], motion[1], motion[2] );
+			for (j = 0; j < panim->numframes - 1; j++)
+			{	
+				n = (j + panim->looprestart) % (panim->numframes - 1);
+				VectorCopy( panim->sanim[n][k].pos, shiftpos[j] );
+				VectorCopy( panim->sanim[n][k].rot, shiftrot[j] );
+			}
+
+			n = panim->looprestart;
+			j = panim->numframes - 1;
+			VectorCopy( panim->sanim[n][k].pos, shiftpos[j] );
+			VectorCopy( panim->sanim[n][k].rot, shiftrot[j] );
+
+			for (j = 0; j < panim->numframes; j++)
+			{	
+				VectorCopy( shiftpos[j], panim->sanim[j][k].pos );
+				VectorCopy( shiftrot[j], panim->sanim[j][k].rot );
+			}
+		}
+	}
+}
+
+void extractUnusedMotion( s_animation_t *panim )
+{
+	int j, k;
+
+	int type = panim->motiontype;
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			float	motion[6];
+			motion[0] = panim->sanim[0][k].pos[0];
+			motion[1] = panim->sanim[0][k].pos[1];
+			motion[2] = panim->sanim[0][k].pos[2];
+			motion[3] = panim->sanim[0][k].rot[0];
+			motion[4] = panim->sanim[0][k].rot[1];
+			motion[5] = panim->sanim[0][k].rot[2];
+
+			for (j = 0; j < panim->numframes; j++)
+			{	
+				if (type & STUDIO_X)
+					panim->sanim[j][k].pos[0] = motion[0];
+				if (type & STUDIO_Y)
+					panim->sanim[j][k].pos[1] = motion[1];
+				if (type & STUDIO_Z)
+					panim->sanim[j][k].pos[2] = motion[2];
+				if (type & STUDIO_XR)
+					panim->sanim[j][k].rot[0] = motion[3];
+				if (type & STUDIO_YR)
+					panim->sanim[j][k].rot[1] = motion[4];
+				if (type & STUDIO_ZR)
+					panim->sanim[j][k].rot[2] = motion[5];
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: find the difference between the src and dest animations, then add that
+//			difference to all the frames of the dest animation.
+//-----------------------------------------------------------------------------
+
+void processMatch( s_animation_t *psrc, s_animation_t *pdest, int flags )
+{
+	int j, k;
+
+	// process "match"
+	Vector delta_pos[MAXSTUDIOSRCBONES];
+	Quaternion delta_q[MAXSTUDIOSRCBONES];
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (flags)
+			VectorSubtract( psrc->sanim[0][k].pos, pdest->sanim[0][k].pos, delta_pos[k] );
+		QuaternionSM( -1, pdest->sanim[0][k].rot, psrc->sanim[0][k].rot, delta_q[k] );
+	}
+
+	// printf("%.2f %.2f %.2f\n", adj.x, adj.y, adj.z );
+	for (j = 0; j < pdest->numframes; j++)
+	{
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (pdest->weight[k] > 0)
+			{
+				if (flags)
+					VectorAdd( pdest->sanim[j][k].pos, delta_pos[k], pdest->sanim[j][k].pos );
+				QuaternionMAAngles( pdest->sanim[j][k].rot, 1.0, delta_q[k], pdest->sanim[j][k].rot );
+			}
+		}	
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: blend the psrc animation overtop the pdest animation, but blend the 
+//			quaternions in world space instead of parent bone space.
+//			Also, blend bone lengths, but only for non root animations.
+//-----------------------------------------------------------------------------
+
+void worldspaceBlend( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags )
+{
+	int j, k, n;
+
+	// process "match"
+	Quaternion srcQ[MAXSTUDIOSRCBONES];
+	Vector srcPos[MAXSTUDIOSRCBONES];
+	Vector tmp;
+
+	matrix3x4_t srcBoneToWorld[MAXSTUDIOBONES];
+	matrix3x4_t destBoneToWorld[MAXSTUDIOBONES];
+
+	if (!flags)
+	{
+		CalcBoneTransforms( psrc, srcframe, srcBoneToWorld );
+		for (k = 0; k < g_numbones; k++)
+		{
+			MatrixAngles( srcBoneToWorld[k], srcQ[k], tmp );
+			srcPos[k] = psrc->sanim[srcframe][k].pos;
+		}
+	}
+
+	Quaternion targetQ, destQ;
+
+	// printf("%.2f %.2f %.2f\n", adj.x, adj.y, adj.z );
+	for (j = 0; j < pdest->numframes; j++)
+	{
+		if (flags)
+		{
+			// pull from a looping source
+			float flCycle = (float)j / (pdest->numframes - 1);
+			flCycle += (float)srcframe / (psrc->numframes - 1);
+			CalcBoneTransformsCycle( psrc, psrc, flCycle, srcBoneToWorld );
+			for (k = 0; k < g_numbones; k++)
+			{
+				MatrixAngles( srcBoneToWorld[k], srcQ[k], tmp );
+
+				n = g_bonetable[k].parent;
+				if (n == -1)
+				{
+					MatrixPosition( srcBoneToWorld[k], srcPos[k] );
+				}
+				else
+				{
+					matrix3x4_t worldToBone;
+					MatrixInvert( srcBoneToWorld[n], worldToBone );
+
+					matrix3x4_t local;
+					ConcatTransforms( worldToBone, srcBoneToWorld[k], local );
+					MatrixPosition( local, srcPos[k] );
+				}
+			}
+		}
+
+
+		CalcBoneTransforms( pdest, j, destBoneToWorld );
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (pdest->weight[k] > 0)
+			{
+				// blend the boneToWorld transforms in world space
+				MatrixAngles( destBoneToWorld[k], destQ, tmp );
+				QuaternionSlerp( destQ, srcQ[k], pdest->weight[k], targetQ );
+
+				AngleMatrix( targetQ, tmp, destBoneToWorld[k] );
+			}
+
+			// back solve
+			n = g_bonetable[k].parent;
+			if (n == -1)
+			{
+				MatrixAngles( destBoneToWorld[k], pdest->sanim[j][k].rot, tmp );
+
+				// FIXME: it's not clear if this should blend position or not....it'd be 
+				// better if weight lists could do quat and pos independently. 
+			}
+			else
+			{
+				matrix3x4_t worldToBone;
+				MatrixInvert( destBoneToWorld[n], worldToBone );
+
+				matrix3x4_t local;
+				ConcatTransforms( worldToBone, destBoneToWorld[k], local );
+				MatrixAngles( local, pdest->sanim[j][k].rot, tmp );
+
+				// blend bone lengths (local space)
+				pdest->sanim[j][k].pos = Lerp( pdest->posweight[k], pdest->sanim[j][k].pos, srcPos[k] );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: match one animations position/orientation to another animations position/orientation
+//-----------------------------------------------------------------------------
+
+void processAutoorigin( s_animation_t *psrc, s_animation_t *pdest, int motiontype, int srcframe, int destframe, int bone )
+{	
+	int j, k;
+	matrix3x4_t adjmatrix;
+
+	matrix3x4_t srcBoneToWorld[MAXSTUDIOBONES];
+	matrix3x4_t destBoneToWorld[MAXSTUDIOBONES];
+
+	CalcBoneTransforms( psrc, srcframe, srcBoneToWorld );
+	CalcBoneTransforms( pdest, destframe, destBoneToWorld );
+
+	// find rotation
+	RadianEuler	rot( 0, 0, 0 );
+
+	Quaternion q0;
+	Quaternion q2;
+	Vector srcPos;
+	Vector destPos;
+
+	MatrixAngles( srcBoneToWorld[bone], q0, srcPos );
+	MatrixAngles( destBoneToWorld[bone], q2, destPos );
+
+	if (motiontype & (STUDIO_LXR | STUDIO_LYR | STUDIO_LZR | STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+	{
+		Quaternion deltaQ2;
+		QuaternionMA( q2, -1, q0, deltaQ2 );
+
+		RadianEuler a3;
+		if (motiontype & (STUDIO_LXR | STUDIO_XR))
+		{
+			Quaternion q4;
+			q4.Init( deltaQ2.x, 0, 0, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+			rot.x = a3.x;
+		}
+		if (motiontype & (STUDIO_LYR | STUDIO_YR))
+		{
+			Quaternion q4;
+			q4.Init( 0, deltaQ2.y, 0, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+			rot.y = a3.y;
+		}
+		if (motiontype & (STUDIO_LZR | STUDIO_ZR))
+		{
+			Quaternion q4;
+			q4.Init( 0, 0, deltaQ2.z, deltaQ2.w );
+			QuaternionNormalize( q4 );
+			QuaternionAngles( q4, a3 );
+			rot.z = a3.z;
+		}
+		if ((motiontype & STUDIO_XR) && (motiontype & STUDIO_YR) && (motiontype & STUDIO_ZR))
+		{
+			QuaternionAngles( deltaQ2, rot );
+		}
+	}
+
+	// find movement
+	Vector p0 = srcPos;
+	Vector p2;
+	AngleMatrix(rot, adjmatrix );
+	MatrixInvert( adjmatrix, adjmatrix );
+	VectorRotate( destPos, adjmatrix, p2 );
+
+	Vector adj = p0 - p2;
+
+	if (!(motiontype & (STUDIO_X | STUDIO_LX)))
+		adj.x = 0;
+	if (!(motiontype & (STUDIO_Y | STUDIO_LY)))
+		adj.y = 0;
+	if (!(motiontype & (STUDIO_Z | STUDIO_LZ)))
+		adj.z = 0;
+
+	PositionMatrix( adj, adjmatrix );
+
+	if (g_verbose && bone != g_rootIndex)
+	{
+		printf("%s aligning to %s - %.2f %.2f %.2f\n", pdest->name, g_bonetable[bone].name, adj.x, adj.y, adj.z );
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			for (j = 0; j < pdest->numframes; j++)
+			{
+				matrix3x4_t bonematrix;
+				AngleMatrix( pdest->sanim[j][k].rot, pdest->sanim[j][k].pos, bonematrix );
+				ConcatTransforms( adjmatrix, bonematrix, bonematrix );
+				MatrixAngles( bonematrix, pdest->sanim[j][k].rot, pdest->sanim[j][k].pos );
+			}
+		}
+	}	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: subtract one animaiton from animation to create an animation of the "difference"
+//-----------------------------------------------------------------------------
+
+void subtractBaseAnimations( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags )
+{
+	int j, k;
+
+ 	// create delta animations
+	s_bone_t src[MAXSTUDIOSRCBONES];
+
+	if (srcframe >= psrc->numframes)
+	{
+		MdlError( "subtract frame %d out of range for %s\n", srcframe, psrc->name );
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		VectorCopy( psrc->sanim[srcframe][k].pos, src[k].pos );
+		VectorCopy( psrc->sanim[srcframe][k].rot, src[k].rot );
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		for (j = 0; j < pdest->numframes; j++)
+		{	
+			if (pdest->weight[k] > 0)
+			{
+				/*
+				printf("%2d : %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					k,
+					src[k].pos[0], src[k].pos[1], src[k].pos[2], 
+					src[k].rot[0], src[k].rot[1], src[k].rot[2] ); 
+
+				printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					RAD2DEG(pdest->sanim[j][k].pos[0]), RAD2DEG(pdest->sanim[j][k].pos[1]), RAD2DEG(pdest->sanim[j][k].pos[2]), 
+					RAD2DEG(pdest->sanim[j][k].rot[0]), RAD2DEG(pdest->sanim[j][k].rot[1]), RAD2DEG(pdest->sanim[j][k].rot[2]) ); 
+				*/
+
+				// calc differences between two rotations
+				if (flags & STUDIO_POST)
+				{
+					// find pdest in src's reference frame  
+					QuaternionSMAngles( -1, src[k].rot, pdest->sanim[j][k].rot, pdest->sanim[j][k].rot );
+					VectorSubtract( pdest->sanim[j][k].pos, src[k].pos, pdest->sanim[j][k].pos );
+				}
+				else
+				{
+					// find src in pdest's reference frame?
+					QuaternionMAAngles( pdest->sanim[j][k].rot, -1, src[k].rot, pdest->sanim[j][k].rot );
+					VectorSubtract( src[k].pos, pdest->sanim[j][k].pos, pdest->sanim[j][k].pos );
+				}
+
+				/*
+				printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					pdest->sanim[j][k].pos[0], pdest->sanim[j][k].pos[1], pdest->sanim[j][k].pos[2], 
+					RAD2DEG(pdest->sanim[j][k].rot[0]), RAD2DEG(pdest->sanim[j][k].rot[1]), RAD2DEG(pdest->sanim[j][k].rot[2]) ); 
+				*/
+			}
+		}
+	}
+
+#if 0
+	// cleanup weightlists
+	for (k = 0; k < g_numbones; k++)
+	{
+		panim->weight[k] = 0.0;
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_weightlist[panim->weightlist].weight[k] > 0.0)
+		{
+			for (j = 0; j < panim->numframes; j++)
+			{	
+				if (fabs(panim->sanim[j][k].pos[0]) > 0.001 || 
+					fabs(panim->sanim[j][k].pos[1]) > 0.001 || 
+					fabs(panim->sanim[j][k].pos[2]) > 0.001 || 
+					fabs(panim->sanim[j][k].rot[0]) > 0.001 || 
+					fabs(panim->sanim[j][k].rot[1]) > 0.001 || 
+					fabs(panim->sanim[j][k].rot[2]) > 0.001)
+				{
+					panim->weight[k] = g_weightlist[panim->weightlist].weight[k];
+					break;
+				}
+			}
+		}
+	}
+#endif
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+void QuaternionSlerp( const RadianEuler &r0, const RadianEuler &r1, float t, RadianEuler &r2 )
+{
+	Quaternion q0, q1, q2;
+	AngleQuaternion( r0, q0 );
+	AngleQuaternion( r1, q1 );
+	QuaternionSlerp( q0, q1, t, q2 );
+	QuaternionAngles( q2, r2 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: subtract each frame running interpolation of the first frame to the last frame
+//-----------------------------------------------------------------------------
+
+void linearDelta( s_animation_t *psrc, s_animation_t *pdest, int srcframe, int flags )
+{
+	int j, k;
+
+ 	// create delta animations
+	s_bone_t src0[MAXSTUDIOSRCBONES];
+	s_bone_t src1[MAXSTUDIOSRCBONES];
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		VectorCopy( psrc->sanim[0][k].pos, src0[k].pos );
+		VectorCopy( psrc->sanim[0][k].rot, src0[k].rot );
+		VectorCopy( psrc->sanim[srcframe][k].pos, src1[k].pos );
+		VectorCopy( psrc->sanim[srcframe][k].rot, src1[k].rot );
+	}
+
+	if (pdest->numframes == 1)
+	{
+		MdlWarning( "%s too short for splinedelta\n", pdest->name );
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		for (j = 0; j < pdest->numframes; j++)
+		{	
+			float s = 1;
+			if (pdest->numframes > 1)
+			{
+				s = (float)j / (pdest->numframes - 1);
+			}
+
+			// make it a spline curve
+			if (flags & STUDIO_AL_SPLINE)
+			{
+				s = 3 * s * s - 2 * s * s * s;
+			}
+
+			if (pdest->weight[k] > 0)
+			{
+				/*
+				printf("%2d : %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					k,
+					src[k].pos[0], src[k].pos[1], src[k].pos[2], 
+					src[k].rot[0], src[k].rot[1], src[k].rot[2] ); 
+
+				printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					RAD2DEG(pdest->sanim[j][k].pos[0]), RAD2DEG(pdest->sanim[j][k].pos[1]), RAD2DEG(pdest->sanim[j][k].pos[2]), 
+					RAD2DEG(pdest->sanim[j][k].rot[0]), RAD2DEG(pdest->sanim[j][k].rot[1]), RAD2DEG(pdest->sanim[j][k].rot[2]) ); 
+				*/
+
+				s_bone_t src;
+
+				src.pos = src0[k].pos * (1 - s) + src1[k].pos * s;
+				QuaternionSlerp( src0[k].rot, src1[k].rot, s, src.rot );
+
+				// calc differences between two rotations
+				if (flags & STUDIO_AL_POST)
+				{
+					// find pdest in src's reference frame  
+					QuaternionSMAngles( -1, src.rot, pdest->sanim[j][k].rot, pdest->sanim[j][k].rot );
+					VectorSubtract( pdest->sanim[j][k].pos, src.pos, pdest->sanim[j][k].pos );
+				}
+				else
+				{
+					// find src in pdest's reference frame?
+					QuaternionMAAngles( pdest->sanim[j][k].rot, -1, src.rot, pdest->sanim[j][k].rot );
+					VectorSubtract( src.pos, pdest->sanim[j][k].pos, pdest->sanim[j][k].pos );
+				}
+
+				/*
+				printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+					pdest->sanim[j][k].pos[0], pdest->sanim[j][k].pos[1], pdest->sanim[j][k].pos[2], 
+					RAD2DEG(pdest->sanim[j][k].rot[0]), RAD2DEG(pdest->sanim[j][k].rot[1]), RAD2DEG(pdest->sanim[j][k].rot[2]) ); 
+				*/
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: turn the animation into a lower fps encoded version
+//-----------------------------------------------------------------------------
+
+void reencodeAnimation( s_animation_t *panim, int frameskip )
+{
+	int j, k, n;
+
+	n = 1;
+	for (j = frameskip; j < panim->numframes; j += frameskip)
+	{	
+		for (k = 0; k < g_numbones; k++)
+		{
+			panim->sanim[n][k] = panim->sanim[j][k];
+		}
+		n++;
+	}
+	panim->numframes = n;
+
+	panim->fps = panim->fps / frameskip;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: clip or pad the animation as nessesary to be a specified number of frames
+//-----------------------------------------------------------------------------
+
+void forceNumframes( s_animation_t *panim, int numframes )
+{
+	int j;
+
+	int size = g_numbones * sizeof( s_bone_t );
+
+	// copy
+	for (j = panim->numframes; j < numframes; j++)
+	{	
+		panim->sanim[j] = (s_bone_t *)kalloc( 1, size );
+		memcpy( panim->sanim[j], panim->sanim[panim->numframes-1], size );
+	}
+
+	panim->numframes = numframes;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: subtract each frame from the previous to calculate the animations derivative
+//-----------------------------------------------------------------------------
+
+void createDerivative( s_animation_t *panim, float scale )
+{
+	int j, k;
+
+	s_bone_t orig[MAXSTUDIOSRCBONES];
+
+	j = panim->numframes - 1;
+	if (panim->flags & STUDIO_LOOPING)
+	{
+		j--;
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		VectorCopy( panim->sanim[j][k].pos, orig[k].pos );
+		VectorCopy( panim->sanim[j][k].rot, orig[k].rot );
+	}
+
+	for (j = panim->numframes - 1; j >= 0; j--)
+	{	
+		s_bone_t *psrc;
+		s_bone_t *pdest;
+
+		if (j - 1 >= 0)
+		{
+			psrc = panim->sanim[j-1];
+		}
+		else
+		{
+			psrc = orig;
+		}
+		pdest = panim->sanim[j];
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (panim->weight[k] > 0)
+			{
+				/*
+				{
+					printf("%2d : %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+						k,
+						psrc[k].pos[0], psrc[k].pos[1], psrc[k].pos[2], 
+						RAD2DEG(psrc[k].rot[0]), RAD2DEG(psrc[k].rot[1]), RAD2DEG(psrc[k].rot[2]) );
+
+					printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+						pdest[k].pos[0], pdest[k].pos[1], pdest[k].pos[2], 
+						RAD2DEG(pdest[k].rot[0]), RAD2DEG(pdest[k].rot[1]), RAD2DEG(pdest[k].rot[2]) );
+				}
+				*/
+
+				// find pdest in src's reference frame  
+				QuaternionSMAngles( -1, psrc[k].rot, pdest[k].rot, pdest[k].rot );
+				VectorSubtract( pdest[k].pos, psrc[k].pos, pdest[k].pos );
+
+				// rescale results (not sure what basis physics system is expecting)
+				{
+					// QuaternionScale( pdest[k].rot, scale, pdest[k].rot );
+					Quaternion q;
+					AngleQuaternion( pdest[k].rot, q );
+					QuaternionScale( q, scale, q );
+					QuaternionAngles( q, pdest[k].rot );
+					VectorScale( pdest[k].pos, scale, pdest[k].pos );
+				}
+
+				/*
+				{
+					printf("     %7.2f %7.2f %7.2f  %7.2f %7.2f %7.2f\n", 
+						pdest[k].pos[0], pdest[k].pos[1], pdest[k].pos[2], 
+						RAD2DEG(pdest[k].rot[0]), RAD2DEG(pdest[k].rot[1]), RAD2DEG(pdest[k].rot[2]) ); 
+				}
+				*/
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: subtract each frame from the previous to calculate the animations derivative
+//-----------------------------------------------------------------------------
+
+void clearAnimations( s_animation_t *panim )
+{
+	panim->flags |= STUDIO_DELTA;
+	panim->flags |= STUDIO_ALLZEROS;
+	
+	panim->numframes = 1;
+	panim->startframe = 0;
+	panim->endframe = 1;
+	
+	int k;
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		panim->sanim[0][k].pos = Vector( 0, 0, 0 );
+		panim->sanim[0][k].rot = RadianEuler( 0, 0, 0 );
+		panim->weight[k] = 0.0;
+		panim->posweight[k] = 0.0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: remove all world rotation from a bone
+//-----------------------------------------------------------------------------
+
+void counterRotateBone( s_animation_t *panim, int iBone, QAngle target )
+{
+	matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+	Vector pos;
+	matrix3x4_t defaultBoneToWorld;
+
+	int j;
+
+	AngleMatrix( target, defaultBoneToWorld );
+
+	for (j = 0; j < panim->numframes; j++)
+	{
+		CalcBoneTransforms( panim, j, boneToWorld );
+
+		MatrixPosition( boneToWorld[iBone], pos );
+		PositionMatrix( pos, defaultBoneToWorld );
+		boneToWorld[iBone] = defaultBoneToWorld;
+
+		solveBone( panim, j, iBone, boneToWorld );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: build transforms in source space, assuming source bones
+//-----------------------------------------------------------------------------
+void BuildRawTransforms( const s_source_t *psource, const char *pAnimationName, 
+	int frame, float scale, Vector const &shift, RadianEuler const &rotate, int flags, matrix3x4_t* boneToWorld )
+{
+	int k;
+	Vector tmp;
+	Vector pos;
+	RadianEuler rot;
+	matrix3x4_t bonematrix;
+	
+	matrix3x4_t rootxform;
+
+	AngleMatrix( rotate, rootxform );
+
+	const s_sourceanim_t *pSourceAnim = FindSourceAnim( psource, pAnimationName );
+	if ( !pSourceAnim )
+	{
+		MdlError( "Unknown animation name %s\n", pAnimationName );
+		return;
+	}
+
+	if ( flags & STUDIO_LOOPING )
+	{
+		if ( frame )
+		{
+			while ( frame < 0)
+				frame += pSourceAnim->numframes;
+			frame = frame % pSourceAnim->numframes;
+		}
+	}
+	else
+	{
+		frame = clamp( frame, 0, pSourceAnim->numframes - 1 );
+	}
+
+	// build source space local to world transforms
+	for (k = 0; k < psource->numbones; k++)
+	{
+		VectorScale( pSourceAnim->rawanim.Element(frame)[k].pos, scale, pos );
+		VectorCopy( pSourceAnim->rawanim.Element(frame)[k].rot, rot );
+
+		if ( psource->localBone[k].parent == -1 )
+		{
+			// translate
+			VectorSubtract( pos, shift, tmp );
+
+			// rotate
+			VectorRotate( tmp, rootxform, pos );
+
+			matrix3x4_t m;
+			AngleMatrix( rot, m );
+			ConcatTransforms( rootxform, m, bonematrix );
+			MatrixAngles( bonematrix, rot );
+			clip_rotations( rot );
+		}
+
+		AngleMatrix( rot, pos, bonematrix );
+
+		if ( psource->localBone[k].parent == -1 )
+		{
+			MatrixCopy( bonematrix, boneToWorld[k] );
+		}
+		else
+		{
+			ConcatTransforms( boneToWorld[psource->localBone[k].parent], bonematrix, boneToWorld[k] );
+			// ConcatTransforms( worldToBone[psource->localBone[k].parent], boneToWorld[k], bonematrix );
+			// B * C => A
+			// C <= B-1 * A
+		}
+	}
+}
+
+
+void BuildRawTransforms( const s_source_t *psource, const char *pAnimationName, int frame, matrix3x4_t* boneToWorld )
+{
+	BuildRawTransforms( psource, pAnimationName, frame, 1.0f, Vector( 0, 0, 0 ), RadianEuler( 0, 0, 0 ), 0, boneToWorld );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: convert source bone animation into global bone animation
+//-----------------------------------------------------------------------------
+void TranslateAnimations( const s_source_t *pSource, const matrix3x4_t *pSrcBoneToWorld, matrix3x4_t *pDestBoneToWorld )
+{
+	matrix3x4_t bonematrix;
+
+	for (int k = 0; k < g_numbones; k++)
+	{
+		int q = pSource->boneGlobalToLocal[k];
+		if ( q == -1 )
+		{
+			// unknown bone, copy over defaults
+			if ( g_bonetable[k].parent >= 0 )
+			{
+				AngleMatrix( g_bonetable[k].rot, g_bonetable[k].pos, bonematrix );
+				ConcatTransforms( pDestBoneToWorld[g_bonetable[k].parent], bonematrix, pDestBoneToWorld[k] );
+			}
+			else
+			{
+				AngleMatrix( g_bonetable[k].rot, g_bonetable[k].pos, pDestBoneToWorld[k] );
+			}
+		}
+		else
+		{
+			ConcatTransforms( pSrcBoneToWorld[q], g_bonetable[k].srcRealign, pDestBoneToWorld[k] );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: convert source bone animation into global bone animation
+//-----------------------------------------------------------------------------
+void ConvertAnimation( const s_source_t *psource, const char *pAnimationName, int frame, float scale, Vector const &shift, RadianEuler const &rotate, s_bone_t *dest )
+{
+	int k;
+	matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+	//matrix3x4_t srcWorldToBone[MAXSTUDIOSRCBONES];
+	matrix3x4_t destBoneToWorld[MAXSTUDIOSRCBONES];
+	matrix3x4_t destWorldToBone[MAXSTUDIOSRCBONES];
+
+	matrix3x4_t bonematrix;
+
+	BuildRawTransforms( psource, pAnimationName, frame, scale, shift, rotate, 0, srcBoneToWorld );
+
+	/*
+	for (k = 0; k < psource->numbones; k++)
+	{
+		MatrixInvert( srcBoneToWorld[k], srcWorldToBone[k] );
+	}
+	*/
+
+	TranslateAnimations( psource, srcBoneToWorld, destBoneToWorld );
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		MatrixInvert( destBoneToWorld[k], destWorldToBone[k] );
+	}
+
+	// convert source_space_local_to_world transforms to shared_space_local_to_world transforms
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( destBoneToWorld[k], bonematrix );
+		}
+		else
+		{
+			// convert my transform into parent relative space
+			ConcatTransforms( destWorldToBone[g_bonetable[k].parent], destBoneToWorld[k], bonematrix );
+
+			// printf("%s : %s\n", psource->localBone[q2].name, psource->localBone[q].name );
+
+			// B * C => A
+			// C <= B-1 * A
+		}
+
+		MatrixAngles( bonematrix, dest[k].rot, dest[k].pos );
+		
+		clip_rotations( dest[k].rot );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: copy the raw animation data from the source files into the individual animations
+//-----------------------------------------------------------------------------
+void RemapAnimations(void)
+{
+	int i, j;
+
+	// copy source animations
+	for (i = 0; i < g_numani; i++)
+	{
+		s_animation_t *panim = g_panimation[i];
+
+		s_source_t *psource = panim->source;
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( psource, panim->animationname );
+		int size = g_numbones * sizeof( s_bone_t );
+
+		int n = panim->startframe - pSourceAnim->startframe;
+		// printf("%s %d:%d\n", g_panimation[i]->filename, g_panimation[i]->startframe, pSourceAnim->startframe );
+		for (j = 0; j < panim->numframes; j++)
+		{
+			panim->sanim[j] = (s_bone_t *)kalloc( 1, size );
+
+			ConvertAnimation( psource, panim->animationname, n + j, panim->scale, panim->adjust, panim->rotation, panim->sanim[j] );
+		}
+	}
+}
+
+void buildAnimationWeights()
+{
+	int i, j, k;
+
+	// rlink animation weights
+	for (i = 0; i < g_numweightlist; i++)
+	{
+		if (i == 0)
+		{
+			// initialize weights
+			for (j = 0; j < g_numbones; j++)
+			{
+				if (g_bonetable[j].parent != -1)
+				{
+					// set child bones to uninitialized
+					g_weightlist[i].weight[j] = -1;
+				}
+				else if (i == 0)
+				{
+					// set root bones to 1
+					g_weightlist[i].weight[j] = 1;
+					g_weightlist[i].posweight[j] = 1;
+				}
+			}
+		}
+		else
+		{
+			// initialize weights
+			for (j = 0; j < g_numbones; j++)
+			{
+				if (g_bonetable[j].parent != -1)
+				{
+					// set child bones to uninitialized
+					g_weightlist[i].weight[j] = g_weightlist[0].weight[j];
+					g_weightlist[i].posweight[j] = g_weightlist[0].posweight[j];
+				}
+				else
+				{
+					// set root bones to 0
+					g_weightlist[i].weight[j] = 0;
+					g_weightlist[i].posweight[j] = 0;
+				}
+			}
+		}
+
+		// match up weights
+		for (j = 0; j < g_weightlist[i].numbones; j++)
+		{
+			k = findGlobalBone( g_weightlist[i].bonename[j] );
+			if (k == -1)
+			{
+				MdlError("unknown bone reference '%s' in weightlist '%s'\n", g_weightlist[i].bonename[j], g_weightlist[i].name );
+			}
+			g_weightlist[i].weight[k] = g_weightlist[i].boneweight[j];
+			g_weightlist[i].posweight[k] = g_weightlist[i].boneposweight[j];
+		}
+	}
+
+	for (i = 0; i < g_numweightlist; i++)
+	{
+		// copy weights forward
+		for (j = 0; j < g_numbones; j++)
+		{
+			if (g_weightlist[i].weight[j] < 0.0)
+			{
+				if (g_bonetable[j].parent != -1)
+				{
+					g_weightlist[i].weight[j] = g_weightlist[i].weight[g_bonetable[j].parent];
+					g_weightlist[i].posweight[j] = g_weightlist[i].posweight[g_bonetable[j].parent];
+				}
+			}
+		}
+	}
+}
+
+void setAnimationWeight( s_animation_t *panim, int index )
+{
+	// copy weightlists to animations
+	for (int k = 0; k < g_numbones; k++)
+	{
+		panim->weight[k] = g_weightlist[index].weight[k];
+		panim->posweight[k] = g_weightlist[index].posweight[k];
+	}
+}
+
+void addDeltas( s_animation_t *panim, int frame, float s, Vector delta_pos[], Quaternion delta_q[] )
+{
+	for (int k = 0; k < g_numbones; k++)
+	{
+		if (panim->weight[k] > 0)
+		{
+			QuaternionSMAngles( s, delta_q[k], panim->sanim[frame][k].rot, panim->sanim[frame][k].rot );
+			VectorMA( panim->sanim[frame][k].pos, s, delta_pos[k], panim->sanim[frame][k].pos );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: find the difference between the overlapping frames and spread out
+//			the difference over multiple frames.
+// start:	negative number, specifies how far back from the end to start blending
+// end:		positive number, specifies how many frames from the beginning to blend
+//-----------------------------------------------------------------------------
+
+void fixupLoopingDiscontinuities( s_animation_t *panim, int start, int end )
+{
+	int j, k, m, n;
+
+	// fix C0 errors on looping animations
+	m = panim->numframes - 1;
+
+	Vector delta_pos[MAXSTUDIOSRCBONES];
+	Quaternion delta_q[MAXSTUDIOSRCBONES];
+
+	// skip if there's nothing to smooth
+	if (m == 0)
+		return;
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		VectorSubtract( panim->sanim[m][k].pos, panim->sanim[0][k].pos, delta_pos[k] );
+		QuaternionMA( panim->sanim[m][k].rot, -1, panim->sanim[0][k].rot, delta_q[k] );
+		QAngle ang;
+		QuaternionAngles( delta_q[k], ang );
+		// printf("%2d  %.1f %.1f %.1f\n", k, ang.x, ang.y, ang.z );
+	}
+
+	// HACK: skip fixup for motion that'll be matched with linear extraction
+	// FIXME: remove when "global" extraction moved into normal ordered processing loop
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			if (panim->motiontype & STUDIO_LX)
+				delta_pos[k].x = 0.0;
+			if (panim->motiontype & STUDIO_LY)
+				delta_pos[k].y = 0.0;
+			if (panim->motiontype & STUDIO_LZ)
+				delta_pos[k].z = 0.0;
+			// FIXME: add rotation
+		}
+	}
+
+	// make sure loop doesn't exceed animation length
+	if (end-start > panim->numframes)
+	{
+		end = panim->numframes + start;
+		if (end < 0)
+		{
+			end = 0;
+			start = -(panim->numframes - 1);
+		}
+	}
+
+	// FIXME: figure out S
+	float s = 0;
+	float nf = end - start;
+	
+	for (j = start + 1; j <= 0; j++)
+	{	
+		n = j - start;
+		s = (n / nf);
+		s = 3 * s * s - 2 * s * s * s;
+		// printf("%d : %d (%lf)\n", m+j, n, -s );
+		addDeltas( panim, m+j, -s, delta_pos, delta_q );
+	}
+
+	for (j = 0; j < end; j++)
+	{	
+		n = end - j;
+		s = (n / nf);
+		s = 3 * s * s - 2 * s * s * s;
+		//printf("%d : %d (%lf)\n", j, n, s );
+		addDeltas( panim, j, s, delta_pos, delta_q );
+	}
+}
+
+
+
+void matchBlend( s_animation_t *pDestAnim, s_animation_t *pSrcAnimation, int iSrcFrame, int iDestFrame, int iPre, int iPost )
+{
+	int j, k;
+
+	if (pDestAnim->flags & STUDIO_LOOPING)
+	{
+		iPre = max( iPre, -pDestAnim->numframes );
+		iPost = min( iPost, pDestAnim->numframes );
+	}
+	else
+	{
+		iPre = max( iPre, -iDestFrame );
+		iPost = min( iPost, pDestAnim->numframes - iDestFrame );
+	}
+
+	Vector delta_pos[MAXSTUDIOSRCBONES];
+	Quaternion delta_q[MAXSTUDIOSRCBONES];
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		VectorSubtract( pSrcAnimation->sanim[iSrcFrame][k].pos, pDestAnim->sanim[iDestFrame][k].pos, delta_pos[k] );
+		QuaternionMA( pSrcAnimation->sanim[iSrcFrame][k].rot, -1, pDestAnim->sanim[iDestFrame][k].rot, delta_q[k] );
+		/*
+		QAngle ang;
+		QuaternionAngles( delta_q[k], ang );
+		printf("%2d  %.1f %.1f %.1f\n", k, ang.x, ang.y, ang.z );
+		*/
+	}
+
+	// HACK: skip fixup for motion that'll be matched with linear extraction
+	// FIXME: remove when "global" extraction moved into normal ordered processing loop
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			if (pDestAnim->motiontype & STUDIO_LX)
+				delta_pos[k].x = 0.0;
+			if (pDestAnim->motiontype & STUDIO_LY)
+				delta_pos[k].y = 0.0;
+			if (pDestAnim->motiontype & STUDIO_LZ)
+				delta_pos[k].z = 0.0;
+			// FIXME: add rotation
+		}
+	}
+
+	// FIXME: figure out S
+	float s = 0;
+
+	for (j = iPre; j <= iPost; j++)
+	{	
+		if (j < 0)
+		{
+			s = j / (float)(iPre-1);
+		}
+		else
+		{
+			s = j / (float)(iPost+1);
+		}
+		s = SimpleSpline( 1 - s );
+		k = iDestFrame + j;
+		if (k < 0)
+		{
+			k += (pDestAnim->numframes - 1);
+		}
+		else
+		{
+			k = k % (pDestAnim->numframes - 1);
+		}
+		//printf("%d : %d (%lf)\n", iDestFrame + j, k, s );
+		addDeltas( pDestAnim, k, s, delta_pos, delta_q );
+		// make sure final frame of a looping animation matches frame 0
+		if ((pDestAnim->flags & STUDIO_LOOPING) && k == 0)
+		{
+			addDeltas( pDestAnim, pDestAnim->numframes - 1, s, delta_pos, delta_q );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: copy the first frame overtop the last frame
+//-----------------------------------------------------------------------------
+
+void forceAnimationLoop( s_animation_t *panim )
+{
+	int k, m, n;
+
+	// force looping animations to be looping
+	if (panim->flags & STUDIO_LOOPING)
+	{
+		n = 0;
+		m = panim->numframes - 1;
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			int type = panim->motiontype;
+
+			if (!(type & STUDIO_LX))
+				panim->sanim[m][k].pos[0] = panim->sanim[n][k].pos[0];
+			if (!(type & STUDIO_LY))
+				panim->sanim[m][k].pos[1] = panim->sanim[n][k].pos[1];
+			if (!(type & STUDIO_LZ))
+				panim->sanim[m][k].pos[2] = panim->sanim[n][k].pos[2];
+
+			if (!(type & STUDIO_LXR))
+				panim->sanim[m][k].rot[0] = panim->sanim[n][k].rot[0];
+			if (!(type & STUDIO_LYR))
+				panim->sanim[m][k].rot[1] = panim->sanim[n][k].rot[1];
+			if (!(type & STUDIO_LZR))
+				panim->sanim[m][k].rot[2] = panim->sanim[n][k].rot[2];
+		}
+	}
+
+	// printf("\n");
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calculate an single bones animation in a different parent's reference frame
+//-----------------------------------------------------------------------------
+
+void localHierarchy( s_animation_t *panim, char *pBonename, char *pParentname, int start, int peak, int tail, int end  )
+{
+	s_localhierarchy_t *pRule;
+
+	pRule = &panim->localhierarchy[ panim->numlocalhierarchy ];
+	panim->numlocalhierarchy++;
+
+	pRule->start = start;
+	pRule->peak = peak;
+	pRule->tail = tail;
+	pRule->end = end;
+
+	if (pRule->start == 0 && pRule->peak == 0 && pRule->tail == 0 && pRule->end == 0)
+	{
+		pRule->tail = panim->numframes - 1;
+		pRule->end = panim->numframes - 1;
+	}
+
+	if (pRule->start != -1 && pRule->peak == -1 && pRule->tail == -1 && pRule->end != -1)
+	{
+		pRule->peak = (pRule->start + pRule->end) / 2;
+		pRule->tail = (pRule->start + pRule->end) / 2;
+	}
+
+	if (pRule->start != -1 && pRule->peak == -1 && pRule->tail != -1)
+	{
+		pRule->peak = (pRule->start + pRule->tail) / 2;
+	}
+
+	if (pRule->peak != -1 && pRule->tail == -1 && pRule->end != -1)
+	{
+		pRule->tail = (pRule->peak + pRule->end) / 2;
+	}
+
+	if (pRule->peak == -1)
+	{
+		pRule->start = 0;
+		pRule->peak = 0;
+	}
+
+	if (pRule->tail == -1)
+	{
+		pRule->tail = panim->numframes - 1;
+		pRule->end = panim->numframes - 1;
+	}
+
+	// check for wrapping
+	if (pRule->peak < pRule->start)
+	{
+		pRule->peak += panim->numframes - 1;
+	}
+	if (pRule->tail < pRule->peak)
+	{
+		pRule->tail += panim->numframes - 1;
+	}
+	if (pRule->end < pRule->tail)
+	{
+		pRule->end += panim->numframes - 1;
+	}
+
+
+	pRule->localData.numerror = pRule->end - pRule->start + 1;
+	if (pRule->end >= panim->numframes)
+		pRule->localData.numerror = pRule->localData.numerror + 2;
+
+	pRule->localData.pError = (s_streamdata_t *)kalloc( pRule->localData.numerror, sizeof( s_streamdata_t ));
+
+	matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+	matrix3x4_t worldToBone;
+	matrix3x4_t local;
+
+	pRule->bone = findGlobalBone( pBonename );
+	if (pRule->bone == -1)
+	{
+		MdlError("anim '%s' references unknown bone '%s' in localhierarchy\n", panim->name, pBonename );
+	}
+
+	if (strlen( pParentname ) == 0)
+	{
+		pRule->newparent = -1;
+	}
+	else
+	{
+		pRule->newparent = findGlobalBone( pParentname );
+		if (pRule->newparent == -1)
+		{
+			MdlError("anim '%s' references unknown bone '%s' in localhierarchy\n", panim->name, pParentname );
+		}
+	}
+
+	int k;
+	const char *pAnimationName = panim->animationname;
+	s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, pAnimationName );
+
+
+	for (k = 0; k < pRule->localData.numerror; k++)
+	{
+		matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+		BuildRawTransforms( panim->source, pAnimationName, k + pRule->start + panim->startframe - pSourceAnim->startframe, panim->scale, panim->adjust, panim->rotation, panim->flags, srcBoneToWorld );
+
+		TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+
+		if (pRule->newparent != -1)
+		{
+			MatrixInvert( boneToWorld[pRule->newparent], worldToBone );
+			ConcatTransforms( worldToBone, boneToWorld[pRule->bone], local );
+		}
+		else
+		{
+			MatrixCopy( boneToWorld[pRule->bone], local );
+		}
+
+		MatrixAngles( local, pRule->localData.pError[k].q, pRule->localData.pError[k].pos );
+
+		/*
+		QAngle ang;
+		QuaternionAngles( pRule->errorData.pError[k].q, ang );
+		printf("%d  %.1f %.1f %.1f : %.1f %.1f %.1f\n", 
+			k,
+			pRule->errorData.pError[k].pos.x, pRule->errorData.pError[k].pos.y, pRule->errorData.pError[k].pos.z, 
+			ang.x, ang.y, ang.z );
+		*/
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: rotate the animation so that it's moving in the specified angle
+//-----------------------------------------------------------------------------
+
+
+void makeAngle( s_animation_t *panim, float angle )
+{
+	float da = 0.0f;
+
+	if (panim->numpiecewisekeys != 0)
+	{
+		// look for movement in total piecewise movement
+		Vector pos = panim->piecewisemove[panim->numpiecewisekeys-1].pos;
+		if (pos[0] != 0 || pos[1] != 0)
+		{
+			float a = atan2( pos[1], pos[0] ) * (180 / M_PI);
+			da = angle - a;
+		}
+
+		for (int i = 0; i < panim->numpiecewisekeys; i++)
+		{
+			VectorYawRotate( panim->piecewisemove[i].pos, da, panim->piecewisemove[i].pos );
+			VectorYawRotate( panim->piecewisemove[i].vector, da, panim->piecewisemove[i].vector );
+		}
+	}
+	else
+	{
+		// look for movement in root bone
+		Vector pos = panim->sanim[(panim->numframes - 1)][g_rootIndex].pos - panim->sanim[0][g_rootIndex].pos;
+		if (pos[0] != 0 || pos[1] != 0)
+		{
+			float a = atan2( pos[1], pos[0] ) * (180 / M_PI);
+			da = angle - a;
+		}
+	}
+
+	/*
+	if (da > -0.01 && da < 0.01)
+		return;
+	*/
+
+	matrix3x4_t rootxform;
+	matrix3x4_t src;
+	matrix3x4_t dest;
+
+	AngleMatrix( QAngle( 0, da, 0), rootxform );
+
+	for (int j = 0; j < panim->numframes; j++)
+	{
+		for (int k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].parent == -1)
+			{
+				AngleMatrix( panim->sanim[j][k].rot, panim->sanim[j][k].pos, src );
+				ConcatTransforms( rootxform, src, dest );
+				MatrixAngles( dest, panim->sanim[j][k].rot, panim->sanim[j][k].pos );
+			}
+		}
+	}
+
+	// FIXME: not finished
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: convert pBoneToWorld back into rot/pos data
+//-----------------------------------------------------------------------------
+
+void solveBone( 
+	s_animation_t *panim,
+	int iFrame,
+	int	iBone,
+	matrix3x4_t* pBoneToWorld
+	)
+{
+	int iParent = g_bonetable[iBone].parent;
+
+	if (iParent == -1)
+	{
+		MatrixAngles( pBoneToWorld[iBone], panim->sanim[iFrame][iBone].rot, panim->sanim[iFrame][iBone].pos );
+		return;
+	}
+
+	matrix3x4_t worldToBone;
+	MatrixInvert( pBoneToWorld[iParent], worldToBone );
+
+	matrix3x4_t local;
+	ConcatTransforms( worldToBone, pBoneToWorld[iBone], local );
+
+	iFrame = iFrame % panim->numframes;
+
+	MatrixAngles( local, panim->sanim[iFrame][iBone].rot, panim->sanim[iFrame][iBone].pos );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calc the influence of a ik rule for a specific point in the animation cycle
+//-----------------------------------------------------------------------------
+
+float IKRuleWeight( s_ikrule_t *pRule, float flCycle )
+{
+	if (pRule->end > 1.0f && flCycle < pRule->start)
+	{
+		flCycle = flCycle + 1.0f;
+	}
+
+	float value = 0.0f;
+	if (flCycle < pRule->start)
+	{
+		return 0.0f;
+	}
+	else if (flCycle < pRule->peak )
+	{
+		value = (flCycle - pRule->start) / (pRule->peak - pRule->start);
+	}
+	else if (flCycle < pRule->tail )
+	{
+		return 1.0f;
+	}
+	else if (flCycle < pRule->end )
+	{
+		value = 1.0f - ((flCycle - pRule->tail) / (pRule->end - pRule->tail));
+	}
+	return 3.0f * value * value - 2.0f * value * value * value;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Lock the ik target to a specific location in order to clean up bad animations (shouldn't be needed).
+//-----------------------------------------------------------------------------
+void fixupIKErrors( s_animation_t *panim, s_ikrule_t *pRule )
+{
+	int k;
+
+	if (pRule->start == 0 && pRule->peak == 0 && pRule->tail == 0 && pRule->end == 0)
+	{
+		pRule->tail = panim->numframes - 1;
+		pRule->end = panim->numframes - 1;
+	}
+
+	// check for wrapping
+	if (pRule->peak < pRule->start)
+	{
+		pRule->peak += panim->numframes - 1;
+	}
+	if (pRule->tail < pRule->peak)
+	{
+		pRule->tail += panim->numframes - 1;
+	}
+	if (pRule->end < pRule->tail)
+	{
+		pRule->end += panim->numframes - 1;
+	}
+
+	if (pRule->contact == -1)
+	{
+		pRule->contact = pRule->peak;
+	}
+
+	if (panim->numframes <= 1)
+		return;
+
+	pRule->errorData.numerror = pRule->end - pRule->start + 1;
+	
+	switch( pRule->type )
+	{
+	case IK_SELF:
+#if 0
+		// this code has never been run.....
+		{
+			matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+			matrix3x4_t worldToBone;
+			matrix3x4_t local;
+			Vector targetPos;
+			Quaternion targetQuat;
+
+			pRule->bone = findGlobalBone( pRule->bonename );
+			if (pRule->bone == -1)
+			{
+				MdlError("unknown bone '%s' in ikrule\n", pRule->bonename );
+			}
+
+			matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+			BuildRawTransforms( panim->source, pRule->contact + panim->startframe - panim->source->startframe, srcBoneToWorld );
+			TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+
+			MatrixInvert( boneToWorld[pRule->bone], worldToBone );
+			ConcatTransforms( worldToBone, boneToWorld[g_ikchain[pRule->chain].link[2].bone], local );
+			MatrixAngles( local, targetQuat, targetPos );
+
+			for (k = 0; k < pRule->errorData.numerror; k++)
+			{
+				BuildRawTransforms( panim->source, k + pRule->start + panim->startframe - panim->source->startframe, srcBoneToWorld );
+				TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+
+				float cycle = (panim->numframes <= 1) ? 0 : (k + pRule->start) / (panim->numframes - 1);
+				float s = IKRuleWeight( pRule, cycle );
+
+				Quaternion curQuat;
+				Vector curPos;
+
+				// convert into rule bone space
+				MatrixInvert( boneToWorld[pRule->bone], worldToBone );
+				ConcatTransforms( worldToBone, boneToWorld[g_ikchain[pRule->chain].link[2].bone], local );
+				MatrixAngles( local, curQuat, curPos );
+
+				// find blended rule bone relative position
+				Vector rulePos = curPos * s + targetPos * (1.0 - s);
+				Quaternion ruleQuat;
+				QuaternionSlerp( curQuat, targetQuat, s, ruleQuat );
+				QuaternionMatrix( ruleQuat, rulePos, local );
+
+				Vector worldPos;
+				VectorTransform( rulePos, boneToWorld[pRule->bone], worldPos );
+
+				// printf("%d (%d) : %.1f %.1f %1.f\n", k + pRule->start, pRule->peak, pos.x, pos.y, pos.z );
+				Studio_SolveIK(
+					g_ikchain[pRule->chain].link[0].bone,
+					g_ikchain[pRule->chain].link[1].bone,
+					g_ikchain[pRule->chain].link[2].bone,
+					worldPos,
+					boneToWorld );
+
+				// slam final matrix
+				// FIXME: this isn't taking into account the IK may have failed
+				ConcatTransforms( boneToWorld[pRule->bone], local, boneToWorld[g_ikchain[pRule->chain].link[2].bone] );
+
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[0].bone, boneToWorld );  
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[1].bone, boneToWorld );  
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[2].bone, boneToWorld );  
+			}
+		}
+#endif
+		break;
+	case IK_WORLD:
+	case IK_GROUND:
+		{
+			matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+
+			int bone = g_ikchain[pRule->chain].link[2].bone;
+			CalcBoneTransforms( panim, pRule->contact, boneToWorld );
+			// FIXME: add in motion
+
+			Vector footfall;
+			MatrixGetColumn( boneToWorld[bone], 3, footfall );
+
+			//printf("%d %d %d %d (%d)\n", pRule->start, pRule->peak, pRule->tail, pRule->end, pRule->errorData.numerror );
+			for (k = 0; k < pRule->errorData.numerror; k++)
+			{
+				CalcBoneTransforms( panim, k + pRule->start, boneToWorld );
+
+				float cycle = (panim->numframes <= 1) ? 0 : (float)(k + pRule->start) / (panim->numframes - 1);
+				float s = IKRuleWeight( pRule, cycle );
+				s = 1.0; // FIXME - the weight rule is wrong
+
+				Vector orig;
+				MatrixPosition( boneToWorld[g_ikchain[pRule->chain].link[2].bone], orig );
+
+				Vector pos = (footfall + calcMovement( panim, k + pRule->start, pRule->contact )) * s + orig * (1.0 - s);
+
+				//printf("%d (%.1f:%.1f) : %.1f %.1f %1.f\n", k + pRule->start, cycle, s, pos.x, pos.y, pos.z );
+
+				Studio_SolveIK(
+					g_ikchain[pRule->chain].link[0].bone,
+					g_ikchain[pRule->chain].link[1].bone,
+					g_ikchain[pRule->chain].link[2].bone,
+					pos,
+					boneToWorld );
+
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[0].bone, boneToWorld );  
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[1].bone, boneToWorld );  
+				solveBone( panim, k + pRule->start, g_ikchain[pRule->chain].link[2].bone, boneToWorld );  
+			}
+		}	
+	}
+	forceAnimationLoop( panim ); // !!!
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: map the vertex animations to their equivalent vertex in the base animations
+//-----------------------------------------------------------------------------
+static void ComputeSideAndScale( const s_flexkey_t &flexKey, s_vertanim_t *pVAnim, float *pSide, float *pScale )
+{
+	*pScale = 1.0f;
+	*pSide = 0.0f;
+
+	if ( flexKey.split > 0.0f )
+	{
+		if ( pVAnim->pos.x > flexKey.split ) 
+		{
+			*pScale = 0.0f;
+		}
+		else if ( pVAnim->pos.x < -flexKey.split ) 
+		{
+			*pScale = 1.0f;
+		}
+		else 
+		{
+			float t = ( flexKey.split - pVAnim->pos.x ) / (2.0 * flexKey.split);
+			*pScale = 3.0f * t * t - 2.0f * t * t * t;
+			// printf( "%.1f : %.2f\n", pSrcAnim->pos.x, *pScale );
+		}
+	}
+	else if ( flexKey.split < 0.0f )
+	{
+		if ( pVAnim->pos.x < flexKey.split) 
+		{
+			*pScale = 0.0f;
+		}
+		else if ( pVAnim->pos.x > -flexKey.split) 
+		{
+			*pScale = 1.0f;
+		}
+		else 
+		{
+			float t = ( flexKey.split - pVAnim->pos.x ) / ( 2.0f * flexKey.split );
+			*pScale = 3.0f * t * t - 2.0f * t * t * t;
+			// printf( "%.1f : %.2f\n", pSrcAnim->pos.x, *pScale );
+		}
+	}
+
+	if ( flexKey.flexpair != 0)
+	{
+		// paired flexes are full scale but variable side to side
+		*pSide = 1.0 - *pScale;
+		*pScale = 1.0;
+	}
+	else
+	{
+		// unpaired flexes are variable scale, one sided
+		*pSide = 0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: map the vertex animations to their equivalent vertex in the base animations
+//-----------------------------------------------------------------------------
+static void ComputeVertexAnimationSpeed( s_flexkey_t& flexKey )
+{
+	// calc max total scale for deltas
+	float flScale = 0.0f;
+	for ( int m = 0; m < flexKey.numvanims; m++ )
+	{
+		float s =flexKey.vanim[m].pos.Length();
+
+		if ( s > flScale )
+		{
+			flScale = s;
+		}
+	}
+	if ( flScale == 0.0f )
+	{
+		flScale = 0.01f;
+	}
+
+	// set 
+	for ( int m = 0; m < flexKey.numvanims; m++ )
+	{
+		if ( flexKey.decay == 0.0f )
+		{
+			flexKey.vanim[m].speed = 1.0f;
+		}
+		else
+		{
+			flexKey.vanim[m].speed = clamp( flexKey.vanim[m].pos.Length() / (flScale * flexKey.decay), 0.0f, 1.0f );
+		}
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: map the vertex animations to their equivalent vertex in the base animations
+//-----------------------------------------------------------------------------
+static void BuildVAnimFlags( s_source_t *pVSource, s_sourceanim_t *pVSourceAnim, int nCurrentFlexKey )
+{
+	pVSourceAnim->vanim_flag = (int *)kalloc( pVSource->numvertices, sizeof( int ));
+	for ( int n = nCurrentFlexKey; n < g_numflexkeys; n++ )
+	{
+		// make sure it's the current flex file and that it's not frame 0 (happens with eyeball stuff).
+		if ( g_flexkey[n].source != pVSource )
+			continue;
+
+		if ( Q_stricmp( g_flexkey[n].animationname, pVSourceAnim->animationname ) )
+			continue;
+
+		const s_sourceanim_t *pAnim = FindSourceAnim( g_flexkey[n].source, g_flexkey[n].animationname );
+		if ( !pAnim )
+			continue;
+
+		if ( pAnim->newStyleVertexAnimations != pVSourceAnim->newStyleVertexAnimations )
+			continue;
+
+		if ( !pAnim->newStyleVertexAnimations && g_flexkey[n].frame == 0 )
+			continue;
+
+		int k = g_flexkey[n].frame;
+		for ( int m = 0; m < pVSourceAnim->numvanims[k]; m++ )
+		{
+			pVSourceAnim->vanim_flag[ pVSourceAnim->vanim[k][m].vertex ] = 1;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Build an array indexed by model vertex which indicates which vanim vertex corresponds best to it
+//-----------------------------------------------------------------------------
+static void BuildModelToVAnimMap( s_source_t *pVSource, s_sourceanim_t *pVSourceAnim, s_loddata_t *pmLodSource, bool bNewVertexAnimations, int *pModelToVAnim )
+{
+	static float imapdist[MAXSTUDIOVERTS];	// distance from src vert to vanim vert
+	static float imapdot[MAXSTUDIOVERTS];	// dot product of src norm to vanim normal
+	Vector tmp;
+
+	// find frame 0 vertices to closest g_model vertex
+	for ( int j = 0; j < pmLodSource->numvertices; j++ )
+	{
+		imapdist[j] = 1E30;
+		imapdot[j] = -1.0;
+		pModelToVAnim[j] = -1;
+	}
+
+	int nMinLod = min( g_minLod, g_ScriptLODs.Count() - 1 );
+
+	for ( int j = 0; j < pVSource->numvertices; j++ )
+	{
+		float flMinDist = 1E30;
+		int n = -1;
+		for ( int k = 0; k < pmLodSource->numvertices; k++ )
+		{
+			// go ahead and skip vertices that are just going to be stripped later
+			// TODO: take this out when the lod clamping stuff gets moved into the LOD code instead of being a post process
+			if ( nMinLod && !( pmLodSource->vertex[k].lodFlag & (0xFFFFFF << nMinLod) ) )
+				continue;
+
+			const Vector& vecModelPos = bNewVertexAnimations ? pVSource->vertex[j].position : pVSourceAnim->vanim[0][j].pos;
+
+			// TODO: Length() gives inconsistent results in release build
+			VectorSubtract( pmLodSource->vertex[k].position, vecModelPos, tmp );
+			float flDist = tmp.LengthSqr();
+			if ( flDist >= 0.15f )
+				continue;
+
+			const Vector& vecModelNormal = bNewVertexAnimations ? pVSource->vertex[j].normal : pVSourceAnim->vanim[0][j].normal;
+			float flDot = DotProduct( pmLodSource->vertex[k].normal, vecModelNormal );
+			if ( flDist < imapdist[k] || ( flDist == imapdist[k] && flDot > imapdot[k]))
+			{
+				imapdist[k] = flDist;
+				imapdot[k] = flDot;
+				pModelToVAnim[k] = j;
+			}
+
+			if ( flDist < flMinDist )
+			{
+				flMinDist = flDist;
+				n = j;
+			}
+		}
+
+		if ( flMinDist > 0.01 )
+		{
+			// printf("vert %d dist %.4f\n", j, minDist );
+			// printf("%.4f %.4f %.4f\n", pvsource->vanim[0][j].pos[0], pvsource->vanim[0][j].pos[1], pvsource->vanim[0][j].pos[2] );
+		}
+
+		// VectorSubtract( modelpos[n], pvsource->vanim[0][j].pos, matchdelta[j] );
+
+		if ( n == -1 )
+		{
+			// printf("no match for animated vertex %d : %.4f %.4f %.4f\n", j, pVSourceAnim->vanim[0][j].pos[0], pVSourceAnim->vanim[0][j].pos[1], pVSourceAnim->vanim[0][j].pos[2] );
+		}
+	}
+
+	/*
+	for (j = 0; j < pmsource->numvertices; j++)
+	{
+	printf("%4d : %7.4f  %7.4f : %5d", j, imapdist[j], imapdot[j], model_to_vanim_vert_imap[j] );
+	printf(" : %8.4f %8.4f %8.4f", modelpos[j][0], modelpos[j][1], modelpos[j][2] );
+	printf("\n");
+	}
+	*/
+
+	/*
+	for (j = 0; j < pmsource->numvertices; j++)
+	{
+	if (fabs( modelpos[j][2] - 64.36) > 0.01)
+	continue;
+
+	printf("%4d : %8.4f %8.4f %8.4f\n", j, modelpos[j][0], modelpos[j][1], modelpos[j][2] );
+	}
+
+	for (j = 0; j < pvsource->numvertices; j++)
+	{
+	if (!pvsource->vanim_flag[j])
+	continue;
+
+	printf("%4d : %8.2f %8.2f %8.2f : ", j, pvsource->vanim[0][j].pos[0], pvsource->vanim[0][j].pos[1], pvsource->vanim[0][j].pos[2] );
+	for (k = 0; k < pmsource->numvertices; k++)
+	{
+	if (model_to_vanim_vert_imap[k] == j)
+	printf(" %d", k );
+	}
+	printf("\n");
+	}
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Build an array indexed by model vertex which indicates which vanim vertex corresponds best to it
+//-----------------------------------------------------------------------------
+static void BuildVAnimMap( s_source_t *pVSource, s_sourceanim_t *pVSourceAnim, s_loddata_t *pmLodSource, const int *pModelToVAnim )
+{
+	// indexed by vertex anim vertex index
+	static int *mapp[MAXSTUDIOVERTS*4];
+
+	// count number of times each vanim vert connectes to a model vert
+	int n = 0;
+	pVSourceAnim->vanim_mapcount = (int *)kalloc( pVSource->numvertices, sizeof( int ) );
+	for ( int j = 0; j < pmLodSource->numvertices; j++ )
+	{
+		if ( pModelToVAnim[j] != -1 )
+		{
+			pVSourceAnim->vanim_mapcount[ pModelToVAnim[j] ]++;
+			n++;
+		}
+	}
+
+	pVSourceAnim->vanim_map = (int **)kalloc( pVSource->numvertices, sizeof( int * ));
+	int *vmap = (int *)kalloc( n, sizeof( int ) );
+
+	// build mapping arrays
+	for ( int j = 0; j < pVSource->numvertices; j++ )
+	{
+		if ( pVSourceAnim->vanim_mapcount[j] )
+		{
+			pVSourceAnim->vanim_map[j] = vmap;
+			mapp[j] = vmap;
+			vmap += pVSourceAnim->vanim_mapcount[j];
+		}
+		else if ( pVSourceAnim->vanim_flag[j] )
+		{
+			// printf("%d animates but no matching vertex\n", j );
+		}
+	}
+
+	for ( int j = 0; j < pmLodSource->numvertices; j++ )
+	{
+		if (pModelToVAnim[j] != -1)
+		{
+			*(mapp[ pModelToVAnim[j] ]++) = j;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the number of unique desination vanims, allocates space for it
+//-----------------------------------------------------------------------------
+static void AllocateDestVAnim( s_flexkey_t &flexKey, s_sourceanim_t *pVSourceAnim )
+{
+	int nVAnimCount = pVSourceAnim->numvanims[ flexKey.frame ];
+	s_vertanim_t *pVAnim = pVSourceAnim->vanim[ flexKey.frame ];
+
+	// frame 0 is special.  Always assume zero vertex animations
+	if ( !pVSourceAnim->newStyleVertexAnimations && flexKey.frame == 0 )
+	{
+		nVAnimCount = 0;
+	}
+
+	// count total possible remapped animations
+	int nNumDestVAnims = 0;
+	for ( int m = 0; m < nVAnimCount; m++)
+	{
+		nNumDestVAnims += pVSourceAnim->vanim_mapcount[ pVAnim[m].vertex ];
+	}
+
+	// allocate room to all possible resulting deltas
+	s_vertanim_t *pDestAnim = (s_vertanim_t *)kalloc( nNumDestVAnims, sizeof( s_vertanim_t ) );
+	flexKey.vanim = pDestAnim;
+	flexKey.vanimtype = STUDIO_VERT_ANIM_NORMAL;	// default
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: map the vertex animations to their equivalent vertex in the base animations
+//-----------------------------------------------------------------------------
+void RemapVertexAnimations(void)
+{
+	int i, j, k;
+	int n, m;
+	s_source_t	*pvsource;					// vertex animation source
+	const char *pAnimationName;
+	s_sourceanim_t *pSourceAnim;
+	s_loddata_t	*pmLodSource;				// original model source
+	Vector		tmp;
+
+	// index by vertex in targets root LOD
+	static int			model_to_vanim_vert_imap[MAXSTUDIOVERTS];		// model vert to vanim vert mapping
+
+	// for all the sources of flexes, find a mapping of vertex animations to base model.
+	// There can be multiple "vertices" in the base model for each animated vertex since vertices 
+	// are duplicated along material boundaries.
+	for ( i = 0; i < g_numflexkeys; i++ )
+	{
+		s_source_t *pVSource = g_flexkey[i].source;
+		s_sourceanim_t *pVSourceAnim = FindSourceAnim( pVSource, g_flexkey[i].animationname );
+
+		// We only do old-style vertex animations
+		if ( pVSourceAnim->newStyleVertexAnimations )
+			continue;
+
+		// skip if it's already been done or if has doesn't have any animations
+		if ( pVSourceAnim->vanim_flag )
+			continue;
+
+		// flag all the vertices that animate (builds the vanim_flag field of the source anim)
+		BuildVAnimFlags( pVSource, pVSourceAnim, i );
+
+		s_loddata_t *pLodData = g_model[ g_flexkey[i].imodel ]->m_pLodData;
+
+		// Map vertex indices specified in the model to ones specified in the vanim data
+		BuildModelToVAnimMap( pVSource, pVSourceAnim, pLodData, false, model_to_vanim_vert_imap );
+
+		// Build the vanim_mapcount, vanim_map fields of the source anim
+		BuildVAnimMap( pVSource, pVSourceAnim, pLodData, model_to_vanim_vert_imap );
+	}
+
+#if 0
+	s_vertanim_t *defaultanims = NULL;
+
+	if (g_defaultflexkey)
+	{
+		defaultanims = g_defaultflexkey->source->vanim[g_defaultflexkey->frame];
+	}
+	else
+	{
+		defaultanims = g_flexkey[0].source->vanim[0];
+	}
+#endif
+
+	// reset model to be default animations
+	if ( g_defaultflexkey )
+	{
+		pvsource = g_defaultflexkey->source;
+		pAnimationName = g_defaultflexkey->animationname;
+		pSourceAnim = FindSourceAnim( pvsource, pAnimationName );
+		pmLodSource = g_model[g_defaultflexkey->imodel]->m_pLodData;
+
+		int numsrcanims = pSourceAnim->numvanims[g_defaultflexkey->frame];
+		s_vertanim_t *psrcanim = pSourceAnim->vanim[g_defaultflexkey->frame];
+
+		for (m = 0; m < numsrcanims; m++)
+		{
+			if ( pSourceAnim->vanim_mapcount[psrcanim->vertex]) // bah, only do it for ones that found a match!
+			{
+				for (n = 0; n < pSourceAnim->vanim_mapcount[psrcanim->vertex]; n++)
+				{
+					// copy "default" pos to original model
+					k = pSourceAnim->vanim_map[psrcanim->vertex][n];
+					VectorCopy( psrcanim->pos, pmLodSource->vertex[k].position );
+					VectorCopy( psrcanim->normal, pmLodSource->vertex[k].normal );
+
+					// copy "default" pos to frame 0 of vertex animation source
+					// FIXME: this needs to copy to all sources of vertex animation.
+					// FIXME: the "default" pose needs to be in each vertex animation source since it's likely that the vertices won't be numbered the same in each file.
+					VectorCopy( psrcanim->pos, pSourceAnim->vanim[0][psrcanim->vertex].pos );
+					VectorCopy( psrcanim->normal, pSourceAnim->vanim[0][psrcanim->vertex].normal );
+				}
+			}
+			psrcanim++;
+		}
+	}
+
+	static bool			doesMove[MAXSTUDIOVERTS];
+	int					numMoved;
+
+	memset( doesMove, 0, MAXSTUDIOVERTS * sizeof( bool ) );
+	numMoved = 0;
+
+	for (i = 0; i < g_numflexkeys; i++)
+	{
+		pvsource = g_flexkey[i].source;
+		pAnimationName = g_flexkey[i].animationname;
+		pSourceAnim = FindSourceAnim( pvsource, pAnimationName );
+		if ( pSourceAnim->newStyleVertexAnimations )
+			continue;
+
+		pmLodSource = g_model[g_flexkey[i].imodel]->m_pLodData;
+
+		// Allocate g_flexkey[i].vanim
+		AllocateDestVAnim( g_flexkey[i], pSourceAnim );
+
+		s_vertanim_t *psrcanim = pSourceAnim->vanim[g_flexkey[i].frame];
+		s_vertanim_t *pdestanim = g_flexkey[i].vanim;
+
+		// frame 0 is special.  Always assume zero vertex animations
+		int numsrcanims = ( g_flexkey[i].frame != 0 ) ? pSourceAnim->numvanims[g_flexkey[i].frame] : 0;
+
+		for (m = 0; m < numsrcanims; m++, psrcanim++)
+		{
+			Vector delta, ndelta;
+			float flSide, flScale;
+			ComputeSideAndScale( g_flexkey[i], psrcanim, &flSide, &flScale );
+
+			// bah, only do it for ones that found a match!
+			if ( flScale <= 0.0f || !pSourceAnim->vanim_mapcount[psrcanim->vertex] )
+				continue;
+
+			j = pSourceAnim->vanim_map[psrcanim->vertex][0];
+
+			//VectorSubtract( psrcanim->pos, pSourceAnim->vanim[0][psrcanim->vertex].pos, tmp );
+			//VectorTransform( tmp, pmsource->bonefixup[k].im, delta );
+			VectorSubtract( psrcanim->pos, pSourceAnim->vanim[0][psrcanim->vertex].pos, delta );
+
+			//VectorSubtract( psrcanim->normal, pSourceAnim->vanim[0][psrcanim->vertex].normal, tmp );
+			//VectorTransform( tmp, pmsource->bonefixup[k].im, ndelta );
+			VectorSubtract( psrcanim->normal, pSourceAnim->vanim[0][psrcanim->vertex].normal, ndelta );
+
+			// if the changes are too small, skip 'em
+			// FIXME: the clamp needs to be paired with the other matching positions.
+			// currently this is set to the float16 min value.  Sucky.
+			if (DotProduct( delta, delta ) <= (0.001f*0.001f) /* 0.0001 */ && DotProduct( ndelta, ndelta ) <= 0.001)
+			{
+				// printf("%4d  %6.4f %6.4f %6.4f\n", pdestanim->vertex, delta.x, delta.y, delta.z );
+				continue;
+			}
+
+			for (n = 0; n < pSourceAnim->vanim_mapcount[psrcanim->vertex]; n++)
+			{
+				pdestanim->vertex = pSourceAnim->vanim_map[psrcanim->vertex][n];
+				VectorScale( delta, flScale, pdestanim->pos );
+				VectorScale( ndelta, flScale, pdestanim->normal );
+				pdestanim->side = flSide;
+
+				// count all the unique verts that actually move
+				if (!doesMove[pdestanim->vertex])
+				{
+					doesMove[pdestanim->vertex] = true;
+					numMoved++;
+				}
+
+				/*
+				printf("%4d  %6.2f %6.2f %6.2f : %4d  %5.2f %5.2f %5.2f\n", 
+				pdestanim->vertex, 
+				// pmsource->vertex[pdestanim->vertex][0], pmsource->vertex[pdestanim->vertex][1], pmsource->vertex[pdestanim->vertex][2],
+				modelpos[pdestanim->vertex][0], modelpos[pdestanim->vertex][1], modelpos[pdestanim->vertex][2],
+				psrcanim->vertex,					
+				pdestanim->pos[0], pdestanim->pos[1], pdestanim->pos[2] );
+				*/
+				g_flexkey[i].numvanims++;
+				pdestanim++;
+			}
+		}
+
+		ComputeVertexAnimationSpeed( g_flexkey[i] );
+	}
+
+	if (numMoved > MAXSTUDIOFLEXVERTS)
+	{
+		MdlError( "Too many flexed verts %d (%d)\n", numMoved, MAXSTUDIOFLEXVERTS );
+	}
+	else if (numMoved > 0 && !g_quiet)
+	{
+		printf("Max flex verts %d\n", numMoved );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: map the vertex animations to their equivalent vertex in the base animations
+//-----------------------------------------------------------------------------
+static int FlexKeysSortFunc( const void *pv1, const void *pv2 ) 
+{
+	const s_flexkey_t *pKey1 = (const s_flexkey_t*)pv1;
+	const s_flexkey_t *pKey2 = (const s_flexkey_t*)pv2;
+
+	if ( pKey1->source != pKey2->source )
+		return (size_t)pKey1->source - (size_t)pKey2->source;
+	return Q_stricmp( pKey1->animationname, pKey2->animationname );
+}
+
+static int SortFlexKeys( s_flexkey_t **ppSortedFlexKeys )
+{
+	int nSortedFlexKeyCount = 0;
+	for ( int i = 0; i < g_numflexkeys; i++ )
+	{
+		s_source_t *pVSource = g_flexkey[i].source;
+		s_sourceanim_t *pVSourceAnim = FindSourceAnim( pVSource, g_flexkey[i].animationname );
+
+		// We only do new-style vertex animations
+		if ( !pVSourceAnim->newStyleVertexAnimations )
+			continue;
+
+		ppSortedFlexKeys[nSortedFlexKeyCount++] = &g_flexkey[i];
+	}
+
+	if ( nSortedFlexKeyCount > 0 )
+	{
+		qsort( ppSortedFlexKeys, nSortedFlexKeyCount, sizeof(s_flexkey_t*), FlexKeysSortFunc );
+	}
+
+	return nSortedFlexKeyCount;
+}
+
+static void RemapVertexAnimationsNewVersion(void)
+{
+	// index by vertex in targets root LOD
+	static int model_to_vanim_vert_imap[MAXSTUDIOVERTS];
+
+	// Sort flexkeys by source
+	s_flexkey_t **ppSortedFlexKeys = (s_flexkey_t**)_alloca( g_numflexkeys * sizeof(s_flexkey_t*) );
+	int nSortedFlexKeyCount = SortFlexKeys( ppSortedFlexKeys );
+	if ( nSortedFlexKeyCount == 0 )
+		return;
+
+	// for all the sources of flexes, find a mapping of vertex animations to base model.
+	// There can be multiple "vertices" in the base model for each animated vertex since vertices 
+	// are duplicated along material boundaries.
+	s_source_t *pVLastSource = NULL;
+	for ( int i = 0; i < nSortedFlexKeyCount; i++ )
+	{
+		s_flexkey_t *pFlexKey = ppSortedFlexKeys[i];
+		s_source_t *pVSource = pFlexKey->source;
+		s_sourceanim_t *pVSourceAnim = FindSourceAnim( pVSource, pFlexKey->animationname );
+		s_loddata_t *pLodSource = g_model[ pFlexKey->imodel ]->m_pLodData;
+
+		if ( pVSource != pVLastSource )
+		{
+			// Map vertex indices specified in the model to ones specified in the vanim data
+			BuildModelToVAnimMap( pVSource, NULL, pLodSource, true, model_to_vanim_vert_imap );
+			pVLastSource = pVSource;
+		}
+
+		// We only do new-style vertex animations
+		Assert( pVSourceAnim->newStyleVertexAnimations );
+
+		// skip if it's already been done or if has doesn't have any animations
+		if ( pVSourceAnim->vanim_flag )
+			continue;
+
+		pVSourceAnim->vanim_flag = (int *)kalloc( pVSource->numvertices, sizeof( int ));
+
+		// flag all the vertices that animate (builds the vanim_flag field of the source anim)
+		int j;
+		for ( j = i+1; j < nSortedFlexKeyCount; ++j )
+		{
+			if ( ( ppSortedFlexKeys[j]->source != pVSource ) || 
+				  Q_stricmp( ppSortedFlexKeys[j]->animationname, pFlexKey->animationname ) )
+				break;
+		}
+
+		for ( ; i < j; ++i )
+		{
+			int k = ppSortedFlexKeys[i]->frame;
+			for ( int m = 0; m < pVSourceAnim->numvanims[k]; m++ )
+			{
+				pVSourceAnim->vanim_flag[ pVSourceAnim->vanim[k][m].vertex ] = 1;
+			}
+		}
+		--i;
+
+		// Build the vanim_mapcount, vanim_map fields of the source anim
+		BuildVAnimMap( pVSource, pVSourceAnim, pLodSource, model_to_vanim_vert_imap );
+	}
+
+	int nNumMoved = 0;
+	static bool	pDoesMove[MAXSTUDIOVERTS];
+	memset( pDoesMove, 0, MAXSTUDIOVERTS * sizeof( bool ) );
+
+	for ( int i = 0; i < g_numflexkeys; i++ )
+	{
+		s_source_t *pVSource = g_flexkey[i].source;
+		s_sourceanim_t *pVSourceAnim = FindSourceAnim( pVSource, g_flexkey[i].animationname );
+		if ( !pVSourceAnim->newStyleVertexAnimations )
+			continue;
+
+		// Allocate g_flexkey[i].vanim
+		AllocateDestVAnim( g_flexkey[i], pVSourceAnim );
+
+		int nNumSrcVAnims = pVSourceAnim->numvanims[ g_flexkey[i].frame ];
+		s_vertanim_t *pSrcVAnim = pVSourceAnim->vanim[ g_flexkey[i].frame ];
+		s_vertanim_t *pDestVAnim = g_flexkey[i].vanim;
+
+		for ( int m = 0; m < nNumSrcVAnims; m++, pSrcVAnim++ )
+		{
+			// bah, only do it for ones that found a match!
+			if ( !pVSourceAnim->vanim_mapcount[pSrcVAnim->vertex] )
+				continue;
+
+			// if the changes are too small, skip 'em
+			// FIXME: the clamp needs to be paired with the other matching positions.
+			// currently this is set to the float16 min value.  Sucky.
+			if ( DotProduct( pSrcVAnim->pos, pSrcVAnim->pos ) <= (0.001f*0.001f) /* 0.0001 */ && DotProduct( pSrcVAnim->normal, pSrcVAnim->normal ) <= 0.001f && pSrcVAnim->wrinkle <= 0.001f )
+			{
+			//	printf("%4d  %6.4f %6.4f %6.4f\n", pDestAnim->vertex, delta.x, delta.y, delta.z );
+				continue;
+			}
+
+			for ( int n = 0; n < pVSourceAnim->vanim_mapcount[pSrcVAnim->vertex]; n++ )
+			{
+				memcpy( pDestVAnim, pSrcVAnim, sizeof(s_vertanim_t) );
+				pDestVAnim->vertex = pVSourceAnim->vanim_map[pSrcVAnim->vertex][n];
+
+				if ( pDestVAnim->wrinkle != 0.0f )
+				{
+					g_flexkey[i].vanimtype = STUDIO_VERT_ANIM_WRINKLE;
+				}
+
+				// count all the unique verts that actually move
+				if ( !pDoesMove[pDestVAnim->vertex] )
+				{
+					pDoesMove[pDestVAnim->vertex] = true;
+					nNumMoved++;
+				}
+
+				g_flexkey[i].numvanims++;
+				pDestVAnim++;
+			}
+		}
+	}
+
+	if ( nNumMoved > MAXSTUDIOFLEXVERTS )
+	{
+		MdlError( "Too many flexed verts %d (%d)\n", nNumMoved, MAXSTUDIOFLEXVERTS );
+	}
+	else if ( nNumMoved > 0 && !g_quiet )
+	{
+		printf("Max flex verts %d\n", nNumMoved );
+	}
+}
+
+
+// Finds the bone index for a particular source
+extern int FindLocalBoneNamed( const s_source_t *pSource, const char *pName );
+
+//-----------------------------------------------------------------------------
+// Purpose: finds the bone index in the global bone table
+//-----------------------------------------------------------------------------
+
+int findGlobalBone( const char *name )
+{
+	name = RenameBone( name );
+	for ( int k = 0; k < g_numbones; k++ )
+	{
+		if ( !Q_stricmp( g_bonetable[k].name, name ) )
+			return k;
+	}
+	
+	return -1;
+}
+
+
+bool IsGlobalBoneXSI( const char *name, const char *bonename )
+{
+	name = RenameBone( name );
+
+	int len = strlen( name );
+
+	int len2 = strlen( bonename );
+	if ( len2 == len && strchr( bonename, '.' ) == NULL && stricmp( bonename, name ) == 0 )
+			return true;
+
+	if (len2 > len)
+	{
+
+		if (bonename[len2-len-1] == '.')
+		{
+			if (stricmp( &bonename[len2-len], name ) == 0)
+			{
+				return true;
+			}
+		}
+	}
+	
+	return false;
+}
+
+
+
+int findGlobalBoneXSI( const char *name )
+{
+	int k;
+
+	name = RenameBone( name );
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (IsGlobalBoneXSI( name, g_bonetable[k].name ))
+		{
+			return k;
+		}
+	}
+	
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Acculumate quaternions and try to find the swept area of rotation 
+//			so that a "midpoint" of the rotation area can be found
+//-----------------------------------------------------------------------------
+
+void findAnimQuaternionAlignment( int k, int i, Quaternion &qBase, Quaternion &qMin, Quaternion &qMax )
+{
+	int j;
+
+	AngleQuaternion( g_panimation[i]->sanim[0][k].rot, qBase );
+	qMin = qBase;
+	float dMin = 1.0;
+	qMax = qBase;
+	float dMax = 1.0;
+	
+	for (j = 1; j < g_panimation[i]->numframes; j++)
+	{
+		Quaternion q;
+
+		AngleQuaternion( g_panimation[i]->sanim[j][k].rot, q );
+		QuaternionAlign( qBase, q, q );
+
+		float d0 = QuaternionDotProduct( q, qBase );
+		float d1 = QuaternionDotProduct( q, qMin );
+		float d2 = QuaternionDotProduct( q, qMax );
+
+		/*
+		if (i != 0) 
+			printf("%f %f %f : %f\n", d0, d1, d2, QuaternionDotProduct( qMin, qMax ) );
+		*/
+		if (d1 >= d0)
+		{
+			if (d0 < dMin)
+			{
+				qMin = q;
+				dMin = d0;
+				if (dMax == 1.0)
+				{
+					QuaternionMA( qBase, -0.01, qMin, qMax );
+					QuaternionAlign( qBase, qMax, qMax );
+				}
+			}
+		}
+		else if (d2 >= d0)
+		{
+			if (d0 < dMax)
+			{
+				qMax = q;
+				dMax = d0;
+			}
+		}
+
+		/*
+		if (i != 0) 
+			printf("%f ", QuaternionDotProduct( qMin, qMax ) );
+		*/
+
+		QuaternionSlerpNoAlign( qMin, qMax, 0.5, qBase );
+		Assert( qBase.IsValid() );
+
+		/*
+		if (i != 0)
+		{
+			QAngle ang;
+			QuaternionAngles( qMin, ang );
+			printf("(%.1f %.1f %.1f) ", ang.x, ang.y, ang.z );
+			QuaternionAngles( qMax, ang );
+			printf("(%.1f %.1f %.1f) ", ang.x, ang.y, ang.z );
+			QuaternionAngles( qBase, ang );
+			printf("(%.1f %.1f %.1f)\n", ang.x, ang.y, ang.z );
+		}
+		*/
+
+		dMin = QuaternionDotProduct( qBase, qMin );
+		dMax = QuaternionDotProduct( qBase, qMax );
+	}
+
+	// printf("%s (%s): %.3f :%.3f\n", g_bonetable[k].name, g_panimation[i]->name, QuaternionDotProduct( qMin, qMax ), QuaternionDotProduct( qMin, qBase ) );
+	/*
+	if (i != 0) 
+		exit(0);
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: For specific bones, try to find the total valid area of rotation so 
+//			that their mid point of rotation can be used at run time to "pre-align"
+//			the quaternions so that rotations > 180 degrees don't get blended the 
+//			"short way round".
+//-----------------------------------------------------------------------------
+
+void limitBoneRotations( void )
+{
+	int i, j, k;
+
+	for (i = 0; i < g_numlimitrotation; i++)
+	{
+		Quaternion qBase;
+
+		k = findGlobalBone( g_limitrotation[i].name );
+		if (k == -1)
+		{
+			MdlError("unknown bone \"%s\" in $limitrotation\n", g_limitrotation[i].name );
+		}
+
+		AngleQuaternion( g_bonetable[k].rot, qBase );
+
+		if (g_limitrotation[i].numseq == 0)
+		{
+			for (j = 0; j < g_numani; j++)
+			{
+				if (!(g_panimation[j]->flags & STUDIO_DELTA) && g_panimation[j]->numframes > 3)
+				{
+					Quaternion qBase2, qMin2, qMax2;
+					findAnimQuaternionAlignment( k, j, qBase2, qMin2, qMax2 );
+
+					QuaternionAdd( qBase, qBase2, qBase );
+				}
+			}
+			QuaternionNormalize( qBase );
+		}
+		else
+		{
+			for (j = 0; j < g_limitrotation[i].numseq; j++)
+			{
+
+			}
+		}
+
+		/*
+		QAngle ang;
+		QuaternionAngles( qBase, ang );
+		printf("%s : (%.1f %.1f %.1f) \n", g_bonetable[k].name, ang.x, ang.y, ang.z );
+		*/
+
+		g_bonetable[k].qAlignment = qBase;
+		g_bonetable[k].flags |= BONE_FIXED_ALIGNMENT;
+
+		// QuaternionAngles( qBase, g_panimation[0]->sanim[0][k].rot );
+	}
+}
+
+
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: For specific bones, try to find the total valid area of rotation so 
+//			that their mid point of rotation can be used at run time to "pre-align"
+//			the quaternions so that rotations > 180 degrees don't get blended the 
+//			"short way round".
+//-----------------------------------------------------------------------------
+
+void limitIKChainLength( void )
+{
+	int i, j, k;
+	matrix3x4_t boneToWorld[MAXSTUDIOSRCBONES];	// bone transformation matrix
+
+	for (k = 0; k < g_numikchains; k++)
+	{
+		bool needsFixup = false;
+		bool hasKnees = false;
+
+		Vector kneeDir = g_ikchain[k].link[0].kneeDir;
+		if (kneeDir.Length() > 0.0)
+		{
+			hasKnees = true;
+		}
+		else
+		{
+			for (i = 0; i < g_numani; i++)
+			{
+				s_animation_t *panim = g_panimation[i];
+
+				if (panim->flags & STUDIO_DELTA)
+					continue;
+
+				if (panim->flags & STUDIO_HIDDEN)
+					continue;
+
+				for (j = 0; j < panim->numframes; j++)
+				{
+					CalcBoneTransforms( panim, j, boneToWorld );
+
+					Vector worldThigh;
+					Vector worldKnee;
+					Vector worldFoot;
+
+					MatrixPosition( boneToWorld[ g_ikchain[k].link[0].bone ], worldThigh );
+					MatrixPosition( boneToWorld[ g_ikchain[k].link[1].bone ], worldKnee );
+					MatrixPosition( boneToWorld[ g_ikchain[k].link[2].bone ], worldFoot );
+
+					float l1 = (worldKnee-worldThigh).Length();
+					float l2 = (worldFoot-worldKnee).Length();
+					float l3 = (worldFoot-worldThigh).Length();
+
+					Vector ikHalf = (worldFoot+worldThigh) * 0.5;
+
+					// FIXME: what to do when the knee completely straight?
+					Vector ikKneeDir = worldKnee - ikHalf;
+					VectorNormalize( ikKneeDir );
+					// ikTargetKnee = ikKnee + ikKneeDir * l1;
+
+					// leg too straight to figure out knee?
+					if (l3 > (l1 + l2) * 0.999)
+					{
+						needsFixup = true;
+					}
+					else
+					{
+						// rotate knee into local space
+						Vector tmp;
+						VectorIRotate( ikKneeDir, boneToWorld[ g_ikchain[k].link[0].bone ], tmp );
+						float bend = (((DotProduct( worldThigh - worldKnee, worldFoot - worldKnee ) ) / (l1 * l3)) + 1) / 2.0;
+						kneeDir += tmp * bend;
+						hasKnees = true;
+					}
+				}
+			}
+		}
+
+		if (!needsFixup)
+			continue;
+
+		if (!hasKnees)
+		{
+			MdlWarning( "ik rules for %s but no clear knee direction\n", g_ikchain[k].name );
+			continue;
+		}
+
+		VectorNormalize( kneeDir );
+		g_ikchain[k].link[0].kneeDir = kneeDir;
+
+		if (g_verbose)
+		{
+			printf("knee %s %f %f %f\n", g_ikchain[k].name, kneeDir.x, kneeDir.y, kneeDir.z );
+		}
+
+#if 0
+		// don't bother for now, storing the knee direction should fix the runtime problems.
+		for (i = 0; i < g_numani; i++)
+		{
+			s_animation_t *panim = g_panimation[i];
+
+			if (panim->flags & STUDIO_DELTA)
+				continue;
+
+			for (j = 0; j < panim->numframes; j++)
+			{
+				CalcBoneTransforms( panim, j, boneToWorld );
+
+				Vector worldFoot;
+				MatrixPosition( boneToWorld[ g_ikchain[k].link[2].bone ], worldFoot );
+
+				Vector targetKneeDir;
+				VectorRotate( kneeDir, boneToWorld[ g_ikchain[k].link[0].bone ], targetKneeDir );
+
+				// run it through the normal IK solver, this should move the foot positions to someplace legal
+				Studio_SolveIK( g_ikchain[k].link[0].bone, g_ikchain[k].link[1].bone, g_ikchain[k].link[2].bone, worldFoot, targetKneeDir, boneToWorld );
+
+				solveBone( panim, j, g_ikchain[k].link[0].bone, boneToWorld );  
+				solveBone( panim, j, g_ikchain[k].link[1].bone, boneToWorld );  
+				solveBone( panim, j, g_ikchain[k].link[2].bone, boneToWorld );  
+			}
+		}
+#endif
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: build "next node" table that links every transition "node" to 
+//			every other transition "node", if possible
+//-----------------------------------------------------------------------------
+void MakeTransitions( )
+{
+	int i, j, k;
+	bool iHit = g_bMultistageGraph;
+
+	// add in direct node transitions
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		if (g_sequence[i].entrynode != g_sequence[i].exitnode)
+		{
+			g_xnode[g_sequence[i].entrynode-1][g_sequence[i].exitnode-1] = g_sequence[i].exitnode;
+			if (g_sequence[i].nodeflags)
+			{
+				g_xnode[g_sequence[i].exitnode-1][g_sequence[i].entrynode-1] = g_sequence[i].entrynode;
+			}
+		}
+	}
+
+	// calculate multi-stage transitions 
+	while (iHit)
+	{
+		iHit = false;
+		for (i = 1; i <= g_numxnodes; i++)
+		{
+			for (j = 1; j <= g_numxnodes; j++)
+			{
+				// if I can't go there directly
+				if (i != j && g_xnode[i-1][j-1] == 0)
+				{
+					for (k = 1; k <= g_numxnodes; k++)
+					{
+						// but I found someone who knows how that I can get to
+						if (g_xnode[k-1][j-1] > 0 && g_xnode[i-1][k-1] > 0)
+						{
+							// then go to them
+							g_xnode[i-1][j-1] = -g_xnode[i-1][k-1];
+							iHit = true;
+							break;
+						}
+					}
+				}
+			}
+		}
+		// reset previous pass so the links can be used in the next pass
+		for (i = 1; i <= g_numxnodes; i++)
+		{
+			for (j = 1; j <= g_numxnodes; j++)
+			{
+				g_xnode[i-1][j-1] = abs( g_xnode[i-1][j-1] );
+			}
+		}
+	}
+
+	// add in allowed "skips"
+	for (i = 0; i < g_numxnodeskips; i++)
+	{
+		g_xnode[g_xnodeskip[i][0]-1][g_xnodeskip[i][1]-1] = 0;
+	}
+
+	if (g_bDumpGraph)
+	{
+		for (j = 1; j <= g_numxnodes; j++)
+		{
+			printf("%2d : %s\n", j, g_xnodename[j] );
+		}
+		printf("    " );
+		for (j = 1; j <= g_numxnodes; j++)
+		{
+			printf("%2d ", j );
+		}
+		printf("\n" );
+
+		for (i = 1; i <= g_numxnodes; i++)
+		{
+			printf("%2d: ", i );
+			for (j = 1; j <= g_numxnodes; j++)
+			{
+				printf("%2d ", g_xnode[i-1][j-1] );
+			}
+			printf("\n" );
+		}
+	}
+}
+
+
+int VectorCompareEpsilon(const Vector& v1, const Vector& v2, float epsilon)
+{
+	int		i;
+	
+	for (i=0 ; i<3 ; i++)
+		if (fabs(v1[i] - v2[i]) > epsilon)
+			return 0;
+			
+	return 1;
+}
+
+int RadianEulerCompareEpsilon(const RadianEuler& v1, const RadianEuler& v2, float epsilon)
+{
+	int		i;
+	
+	for (i=0 ; i<3 ; i++)
+	{
+		// clamp to 2pi
+		float a1 = fmod(v1[i],(float) (2*M_PI));
+		float a2 = fmod(v2[i],(float) (2*M_PI));
+		float delta =  fabs(a1-a2);
+		
+		// use the smaller angle (359 == 1 degree off)
+		if ( delta > M_PI )
+		{
+			delta = 2*M_PI - delta;
+		}
+
+		if (delta > epsilon)
+			return 0;
+	}
+			
+	return 1;
+}
+
+bool AnimationDifferent( const Vector& startPos, const RadianEuler& startRot, const Vector& pos, const RadianEuler& rot )
+{
+	if ( !VectorCompareEpsilon( startPos, pos, 0.01 ) )
+		return true;
+	if ( !RadianEulerCompareEpsilon( startRot, rot, 0.01 ) )
+		return true;
+
+	return false;
+}
+
+bool BoneHasAnimation( const char *pName )
+{
+	bool first = true;
+	Vector pos;
+	RadianEuler rot;
+
+	if ( !g_numani )
+		return false;
+
+	int globalIndex = findGlobalBone( pName );
+
+	// don't check root bones for animation
+	if (globalIndex >= 0 && g_bonetable[globalIndex].parent == -1)
+		return true;
+
+	// find used bones per g_model
+	for (int i = 0; i < g_numani; i++)
+	{
+		s_source_t *psource = g_panimation[i]->source;
+		const char *pAnimationName = g_panimation[i]->animationname;
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( psource, pAnimationName );
+
+		int boneIndex = FindLocalBoneNamed(psource, pName);
+
+		// not in this source?
+		if (boneIndex < 0)
+			continue;
+
+		// this is not right, but enough of the bones are moved unintentionally between
+		// animations that I put this in to catch them.
+		first = true;
+		int n = g_panimation[i]->startframe - pSourceAnim->startframe;
+		// printf("%s %d:%d\n", g_panimation[i]->filename, g_panimation[i]->startframe, psource->startframe );
+		for (int j = 0; j < g_panimation[i]->numframes; j++)
+		{
+			if ( first )
+			{
+				VectorCopy( pSourceAnim->rawanim[j+n][boneIndex].pos, pos );
+				VectorCopy( pSourceAnim->rawanim[j+n][boneIndex].rot, rot );
+				first = false;
+			}
+			else
+			{
+				if ( AnimationDifferent( pos, rot, pSourceAnim->rawanim[j+n][boneIndex].pos, pSourceAnim->rawanim[j+n][boneIndex].rot ) )
+					return true;
+			}
+		}
+	}
+	return false;
+}
+
+bool BoneHasAttachments( char const *pname )
+{
+	for (int k = 0; k < g_numattachments; k++)
+	{
+		if ( !stricmp( g_attachment[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+bool BoneIsProcedural( char const *pname )
+{
+	int k;
+
+	for (k = 0; k < g_numaxisinterpbones; k++)
+	{
+		if (! stricmp( g_axisinterpbones[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+
+	for (k = 0; k < g_numquatinterpbones; k++)
+	{
+		if (IsGlobalBoneXSI( g_quatinterpbones[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+
+	for (k = 0; k < g_numaimatbones; k++)
+	{
+		if (IsGlobalBoneXSI( g_aimatbones[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+
+	for (k = 0; k < g_numjigglebones; k++)
+	{
+		if (! stricmp( g_jigglebones[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+bool BoneIsIK( char const *pname )
+{
+	int k;
+
+	// tag bones used by ikchains 
+	for (k = 0; k < g_numikchains; k++)
+	{
+		if ( !stricmp( g_ikchain[k].bonename, pname ) )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool BoneShouldCollapse( char const *pname )
+{
+	int k;
+
+	for (k = 0; k < g_collapse.Count(); k++)
+	{
+		if (stricmp( g_collapse[k], pname ) == 0)
+		{
+			return true;
+		}
+	}
+
+	return (!BoneHasAnimation( pname ) && !BoneIsProcedural( pname ) && !BoneIsIK( pname ) /* && !BoneHasAttachments( pname ) */);
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Collapse vertex assignments up to parent on bones that are not needed
+//			This can optimize a model substantially if the animator is using
+//			lots of helper bones with no animation.
+//-----------------------------------------------------------------------------
+void CollapseBones( void )
+{
+	int j, k;
+	int count = 0;
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if ( g_bonetable[k].bDontCollapse )
+			continue;
+
+		if ( (g_bonetable[k].flags != 0 || g_bonetable[k].bPreDefined) && !BoneShouldCollapse( g_bonetable[k].name ) )
+		{
+			// printf("skipping %s : %d\n", g_bonetable[k].name, g_bonetable[k].flags );
+			continue;
+		}
+
+		count++;
+
+		if( !g_quiet && g_verbose )
+		{
+			printf("collapsing %s\n", g_bonetable[k].name );
+		}
+
+		g_numbones--;
+		int m = g_bonetable[k].parent;
+
+		for (j = k; j < g_numbones; j++)
+		{
+			g_bonetable[j] = g_bonetable[j+1];
+			if (g_bonetable[j].parent == k)
+			{
+				g_bonetable[j].parent = m;
+			} 
+			else if (g_bonetable[j].parent >= k)
+			{
+				g_bonetable[j].parent = g_bonetable[j].parent - 1;
+			}
+		}
+		k--;
+	}
+
+	if( !g_quiet && count)
+	{
+		printf("Collapsed %d bones\n", count );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: replace all animation, rotation and translation, etc. with a single bone
+//-----------------------------------------------------------------------------
+void MakeStaticProp()
+{
+	int i, j, k;
+	matrix3x4_t rotated;
+
+	AngleMatrix( g_defaultrotation, rotated );
+
+	// FIXME: missing attachment point recalcs!
+
+	// replace bone 0 with "static_prop" bone and attach everything to it.
+	for (i = 0; i < g_numsources; i++)
+	{
+		s_source_t *psource = g_source[i];
+
+		strcpy( psource->localBone[0].name, "static_prop" );
+		psource->localBone[0].parent = -1;
+
+		for (k = 1; k < psource->numbones; k++)
+		{
+			psource->localBone[k].parent = -1;
+		}
+
+		rotated[0][3] = g_defaultadjust[0];
+		rotated[1][3] = g_defaultadjust[1];
+		rotated[2][3] = g_defaultadjust[2];
+
+		Vector mins, maxs;
+		ClearBounds( mins, maxs );
+
+		for (j = 0; j < psource->numvertices; j++)
+		{
+			for (k = 0; k < psource->vertex[j].boneweight.numbones; k++)
+			{
+				// attach everything to root
+				psource->vertex[j].boneweight.bone[k] = 0;
+			}
+
+			// **shift everything into identity space**
+			// position
+			Vector tmp;
+			VectorTransform( psource->vertex[j].position, rotated, tmp );
+			VectorCopy( tmp, psource->vertex[j].position );
+
+			// normal
+			VectorRotate( psource->vertex[j].normal, rotated, tmp );
+			VectorCopy( tmp, psource->vertex[j].normal );
+
+			// tangentS
+			VectorRotate( psource->vertex[j].tangentS.AsVector3D(), rotated, tmp );
+			VectorCopy( tmp, psource->vertex[j].tangentS.AsVector3D() );
+
+			// incrementally compute identity space bbox
+			AddPointToBounds( psource->vertex[j].position, mins, maxs );
+		}
+
+		if ( g_centerstaticprop )
+		{
+			const char *pAttachmentName = "placementOrigin";
+			bool bFound = false;
+			for ( k = 0; k < g_numattachments; k++ )
+			{
+				if ( !Q_stricmp( g_attachment[k].name, pAttachmentName ) )
+				{
+					bFound = true;
+					break;
+				}
+			}
+
+			if ( !bFound )
+			{
+				g_PropCenterOffset = -0.5f * (mins + maxs);
+			}
+
+			for ( j = 0; j < psource->numvertices; j++ )
+			{
+				psource->vertex[j].position += g_PropCenterOffset;
+			}
+
+			if ( !bFound )
+			{
+				// now add an attachment point to store this offset
+				Q_strncpy( g_attachment[g_numattachments].name, pAttachmentName, sizeof(g_attachment[g_numattachments].name) );
+				Q_strncpy( g_attachment[g_numattachments].bonename, "static_prop", sizeof(g_attachment[g_numattachments].name) );
+				g_attachment[g_numattachments].bone = 0;
+				g_attachment[g_numattachments].type = 0;
+				AngleMatrix( vec3_angle, g_PropCenterOffset, g_attachment[g_numattachments].local );
+				g_numattachments++;
+			}
+		}
+
+		// force the animation to be identity
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( psource, "BindPose" );
+		pSourceAnim->rawanim[0][0].pos = Vector( 0, 0, 0 );
+		pSourceAnim->rawanim[0][0].rot = RadianEuler( 0, 0, 0 );
+	
+		// make an identity boneToPose transform
+		AngleMatrix( QAngle( 0, 0, 0 ), psource->boneToPose[0] );
+		
+		// make it all a single frame animation
+		pSourceAnim->numframes = 1;
+		pSourceAnim->startframe = 0;
+		pSourceAnim->endframe = 1;
+	}
+
+	// throw away all animations
+	g_numani = 1;
+	g_panimation[0]->numframes = 1;
+	g_panimation[0]->startframe = 0;
+	g_panimation[0]->endframe = 1;
+	Q_strncpy( g_panimation[0]->animationname, "BindPose", sizeof(g_panimation[0]->animationname) );
+	g_panimation[0]->rotation = RadianEuler( 0, 0, 0 );
+	g_panimation[0]->adjust = Vector( 0, 0, 0 );
+
+	// throw away all vertex animations
+	g_numflexkeys = 0;
+	g_defaultflexkey = NULL;
+
+	// Recalc attachment points:
+	for( i = 0; i < g_numattachments; i++ )
+	{
+		if( g_centerstaticprop && ( i == g_numattachments - 1 ) )
+			continue;
+		
+		ConcatTransforms( rotated, g_attachment[i].local, g_attachment[i].local );
+
+		Q_strncpy( g_attachment[i].bonename, "static_prop", sizeof(g_attachment[i].name) );
+		g_attachment[i].bone = 0;
+		g_attachment[i].type = 0;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Marks the boneref all the way up the bone hierarchy
+//-----------------------------------------------------------------------------
+static void UpdateBonerefRecursive( s_source_t *psource, int nBoneIndex, int nFlags )
+{
+	if ( nFlags == 0 )
+		return;
+
+	psource->boneref[nBoneIndex] |= nFlags;
+
+	// Chain the flag up the parent
+	int n = psource->localBone[nBoneIndex].parent;
+	while (n != -1)
+	{
+		psource->boneref[n] |= psource->boneref[nBoneIndex];
+		n = psource->localBone[n].parent;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns the axis of the bone after remapping.  Axis 0:X, 1:Y, 2:Z
+//          If the bone has a parent, axis is returned as is, if bone does not
+//          have a parent then the $upaxis determines how the axes are mapped.
+//			Only $upaxis Y is supported (see comment in Cmd_UpAxis).
+//-----------------------------------------------------------------------------
+int GetRemappedBoneAxis( int nBoneIndex, int nAxis )
+{
+	if ( nBoneIndex < 0 || nBoneIndex >= g_numbones )
+		return nAxis;
+
+	if ( g_bonetable[nBoneIndex].parent >= 0 )
+		return nAxis;
+
+	// Y Up
+	if ( g_defaultrotation.x == static_cast< float >( M_PI / 2.0f ) && g_defaultrotation.y == 0.0f && g_defaultrotation.z == static_cast< float >( M_PI / 2.0f ) )
+	{
+		static const int nAxisMap[3] = { 1, 2, 0 };
+		return nAxisMap[ nAxis ];
+	}
+
+	// Default Z Up
+	return nAxis;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Map the flex driver bones to the global bone table
+//          Also cleans up any that do not match to a global bone
+//-----------------------------------------------------------------------------
+void MapFlexDriveBonesToGlobalBoneTable()
+{
+	CDmeBoneFlexDriverList *pDmeBoneFlexDriverList = GetElement< CDmeBoneFlexDriverList >( g_hDmeBoneFlexDriverList );
+	if ( !pDmeBoneFlexDriverList )
+		return;
+
+	// Loop backwards so we can remove elements as we go
+	for ( int i = pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Count() - 1; i >= 0; --i )
+	{
+		CDmeBoneFlexDriver *pDmeBoneFlexDriver = pDmeBoneFlexDriverList->m_eBoneFlexDriverList[i];
+		if ( !pDmeBoneFlexDriver )
+		{
+			pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Remove( i );
+			continue;
+		}
+
+		for ( int j = 0; j < g_numbones; ++j )
+		{
+			if ( !Q_stricmp( g_bonetable[j].name, pDmeBoneFlexDriver->m_sBoneName.Get() ) )
+			{
+				if ( g_bonetable[j].flags & BONE_ALWAYS_PROCEDURAL )
+				{
+					MdlWarning( "DmeBoneFlexDriver Bone: %s is marked procedural, Ignoring flex drivers\n", pDmeBoneFlexDriver->m_sBoneName.Get() );
+					pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Remove( i );
+					pDmeBoneFlexDriver = NULL;
+				}
+
+				pDmeBoneFlexDriver->SetValue( "__boneIndex", j );
+				// Map the axis for Y up stuff
+				for ( int k = 0; k < pDmeBoneFlexDriver->m_eControlList.Count(); ++k )
+				{
+					pDmeBoneFlexDriver->m_eControlList[k]->m_nBoneComponent = GetRemappedBoneAxis( j, pDmeBoneFlexDriver->m_eControlList[k]->m_nBoneComponent );
+				}
+				break;
+			}
+		}
+
+		// Was removed because it was referencing a procedural bone
+		if ( !pDmeBoneFlexDriver )
+			continue;
+
+		CDmAttribute *pBoneIndexAttr = pDmeBoneFlexDriver->GetAttribute( "__boneIndex" );
+		if ( pBoneIndexAttr )
+		{
+			pBoneIndexAttr->AddFlag( FATTRIB_DONTSAVE );
+		}
+		else
+		{
+			MdlWarning( "DmeBoneFlexDriver Bone: %s - No Bone Found With That Name, Ignoring\n", pDmeBoneFlexDriver->m_sBoneName.Get() );
+			pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Remove( i );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tag bones in the specified source that are used as a bone flex driver
+//          Also cleans up any empty bone flex driver elements
+//			Also tags the DmeBoneFlexDriverControl with 
+//-----------------------------------------------------------------------------
+void TagFlexDriverBones( s_source_t *pSource )
+{
+	CDmeBoneFlexDriverList *pDmeBoneFlexDriverList = GetElement< CDmeBoneFlexDriverList >( g_hDmeBoneFlexDriverList );
+	if ( !pDmeBoneFlexDriverList )
+		return;
+
+	// Loop backwards so we can remove elements as we go
+	for ( int i = pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Count() - 1; i >= 0; --i )
+	{
+		CDmeBoneFlexDriver *pDmeBoneFlexDriver = pDmeBoneFlexDriverList->m_eBoneFlexDriverList[i];
+		if ( !pDmeBoneFlexDriver )
+		{
+			pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Remove( i );
+			continue;
+		}
+
+		for ( int j = pDmeBoneFlexDriver->m_eControlList.Count() - 1; j >= 0; --j )
+		{
+			CDmeBoneFlexDriverControl *pDmeBoneFlexDriverControl = pDmeBoneFlexDriver->m_eControlList[j];
+			if ( !pDmeBoneFlexDriverControl )
+			{
+				pDmeBoneFlexDriver->m_eControlList.Remove( j );
+				continue;
+			}
+
+			if ( pDmeBoneFlexDriverControl->m_nBoneComponent < STUDIO_BONE_FLEX_TX || pDmeBoneFlexDriverControl->m_nBoneComponent > STUDIO_BONE_FLEX_TZ )
+			{
+				MdlWarning( "DmeBoneFlexDriver Bone: %s - Flex Controller: %s, Bone Component Out Of Range: %d [0-2], Ignoring\n", pDmeBoneFlexDriver->m_sBoneName.Get(), pDmeBoneFlexDriverControl->m_sFlexControllerName.Get(), pDmeBoneFlexDriverControl->m_nBoneComponent.Get() );
+				pDmeBoneFlexDriver->m_eControlList.Remove( j );
+				continue;
+			}
+
+			for ( int k = 0; k < g_numflexcontrollers; ++k )
+			{
+				if ( !Q_stricmp( g_flexcontroller[k].name, pDmeBoneFlexDriverControl->m_sFlexControllerName.Get() ) )
+				{
+					pDmeBoneFlexDriverControl->SetValue( "__flexControlIndex", k );
+					break;
+				}
+			}
+
+			if ( !pDmeBoneFlexDriverControl->HasAttribute( "__flexControlIndex" ) )
+			{
+				MdlWarning( "DmeBoneFlexDriver Bone: %s - No Flex Controller Named: %s, Ignoring\n", pDmeBoneFlexDriver->m_sBoneName.Get(), pDmeBoneFlexDriverControl->m_sFlexControllerName.Get() );
+				pDmeBoneFlexDriver->m_eControlList.Remove( j );
+			}
+		}
+
+		if ( pDmeBoneFlexDriver->m_eControlList.Count() <= 0 )
+		{
+			MdlWarning( "DmeBoneFlexDriver Bone: %s - No Flex Controllers Defined, Ignoring\n", pDmeBoneFlexDriver->m_sBoneName.Get() );
+			pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Remove( i );
+			continue;
+		}
+
+		for ( int j = 0; j < pSource->numbones; ++j )
+		{
+			if ( !Q_stricmp( pSource->localBone[j].name, pDmeBoneFlexDriver->m_sBoneName.Get() ) )
+			{
+				// Mark used by all LODs
+				pSource->boneflags[j] |= BONE_USED_BY_VERTEX_MASK;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: set "boneref" for all the source bones used by vertices, attachments, eyeballs, etc.
+//-----------------------------------------------------------------------------
+void TagUsedBones( )
+{
+	int i, j, k;
+	int n;
+
+	// find used bones per g_model
+	for (i = 0; i < g_numsources; i++)
+	{
+		s_source_t *psource = g_source[i];
+
+		for (k = 0; k < MAXSTUDIOSRCBONES; k++)
+		{
+			psource->boneflags[k] = 0;
+			psource->boneref[k] = 0;
+		}
+
+		if (!psource->isActiveModel)
+			continue;
+
+		// printf("active: %s\n", psource->filename );
+		for (j = 0; j < psource->numvertices; j++)
+		{
+			for (k = 0; k < psource->vertex[j].boneweight.numbones; k++)
+			{
+				psource->boneflags[psource->vertex[j].boneweight.bone[k]] |= BONE_USED_BY_VERTEX_LOD0;
+			}
+		}
+	}
+
+	// find used bones per g_model
+	for (i = 0; i < g_numsources; i++)
+	{
+		s_source_t *psource = g_source[i];
+
+		// FIXME: this is in the wrong place.  The attachment may be rigid and it never defined in a reference file
+		for (k = 0; k < g_numattachments; k++)
+		{
+			for (j = 0; j < psource->numbones; j++)
+			{
+				if ( !stricmp( g_attachment[k].bonename, psource->localBone[j].name ) )
+				{
+					// this bone is a keeper with or without associated vertices
+					// because an attachment point depends on it.
+					if (g_attachment[k].type & IS_RIGID)
+					{
+						for (n = j; n != -1; n = psource->localBone[n].parent)
+						{
+							if (psource->boneflags[n] & BONE_USED_BY_VERTEX_LOD0)
+							{
+								psource->boneflags[n] |= BONE_USED_BY_ATTACHMENT;
+								break;
+							}
+						}
+					}
+					else
+					{
+						psource->boneflags[j] |= BONE_USED_BY_ATTACHMENT;
+					}
+				}
+			}
+		}
+
+		for (k = 0; k < g_numikchains; k++)
+		{
+			for (j = 0; j < psource->numbones; j++)
+			{
+				if ( !stricmp( g_ikchain[k].bonename, psource->localBone[j].name ) )
+				{
+					// this bone is a keeper with or without associated vertices
+					// because a ikchain depends on it.
+					psource->boneflags[j] |= BONE_USED_BY_ATTACHMENT;
+				}
+			}
+		}
+
+		for (k = 0; k < g_nummouths; k++)
+		{
+			for (j = 0; j < psource->numbones; j++)
+			{
+				if ( !stricmp( g_mouth[k].bonename, psource->localBone[j].name ) )
+				{
+					// this bone is a keeper with or without associated vertices
+					// because a mouth shader depends on it.
+					psource->boneflags[j] |= BONE_USED_BY_ATTACHMENT;
+				}
+			}
+		}
+
+		// Tag all bones marked as being used by bonemerge
+		int nBoneMergeCount = g_BoneMerge.Count(); 
+		for ( k = 0; k < nBoneMergeCount; ++k )
+		{
+			for ( j = 0; j < psource->numbones; j++ )
+			{
+				if ( stricmp( g_BoneMerge[k].bonename, psource->localBone[j].name ) )
+					continue;
+
+				psource->boneflags[j] |= BONE_USED_BY_BONE_MERGE;
+			}
+		}
+
+		// Tag bones used as bone flex drivers, these need to be client side only
+		TagFlexDriverBones( psource );
+
+		// NOTE: This must come last; after all flags have been set!
+		// tag bonerefs as being used the union of the boneflags all their children
+		for (k = 0; k < psource->numbones; k++)
+		{
+			UpdateBonerefRecursive( psource, k, psource->boneflags[k] );
+		}
+	}
+
+	// tag all eyeball bones
+	for (i = 0; i < g_nummodelsbeforeLOD; i++)
+	{
+		s_source_t *psource = g_model[i]->source;
+		for (k = 0; k < g_model[i]->numeyeballs; k++)
+		{
+			psource->boneref[g_model[i]->eyeball[k].bone] |= BONE_USED_BY_ATTACHMENT;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: change the names in the source files for bones that max auto-renamed on us
+//-----------------------------------------------------------------------------
+void RenameBones( )
+{
+	int i, j, k;
+
+	// rename source bones if needed
+	for (i = 0; i < g_numsources; i++)
+	{
+		for (j = 0; j < g_source[i]->numbones; j++)
+		{
+			for (k = 0; k < g_numrenamedbones; k++)
+			{
+				if (!stricmp( g_source[i]->localBone[j].name, g_renamedbone[k].from))
+				{
+					strcpy( g_source[i]->localBone[j].name, g_renamedbone[k].to );
+					break;
+				}
+			}
+		}
+	}
+}
+
+
+const char *RenameBone( const char *pName )
+{
+	for ( int k = 0; k < g_numrenamedbones; k++)
+	{
+		if ( !Q_stricmp( pName, g_renamedbone[k].from ) )
+			return g_renamedbone[k].to;
+	}
+	return pName;
+}
+
+
+//-----------------------------------------------------------------------------
+// Tags bones in the global bone table
+//-----------------------------------------------------------------------------
+void TagUsedImportedBones()
+{
+	// NOTE: This has to happen because some bones referenced by bonemerge
+	// can be set up using the importbones feature
+	int k, j;
+
+	// Tag all bones marked as being used by bonemerge
+	int nBoneMergeCount = g_BoneMerge.Count(); 
+	for ( k = 0; k < nBoneMergeCount; ++k )
+	{
+		for ( j = 0; j < g_numbones; j++ )
+		{
+			if ( stricmp( g_BoneMerge[k].bonename, g_bonetable[j].name ) )
+				continue;
+
+			g_bonetable[j].flags |= BONE_USED_BY_BONE_MERGE;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: look through all the sources and build a table of used bones
+//-----------------------------------------------------------------------------
+int BuildGlobalBonetable( )
+{
+	int i, j, k, n;
+	int	iError = 0;
+
+	g_numbones = 0;
+
+	for (i = 0; i < MAXSTUDIOSRCBONES; i++)
+	{
+		SetIdentityMatrix( g_bonetable[i].srcRealign );
+	}
+
+	// insert predefined bones first
+	for (i = 0; i < g_numimportbones; i++)
+	{
+		k = findGlobalBone( g_importbone[i].name );
+		if (k == -1)
+		{
+			k = g_numbones;
+			V_strcpy_safe( g_bonetable[k].name, g_importbone[i].name );
+			if ( strlen( g_importbone[i].parent ) == 0 )
+			{
+				g_bonetable[k].parent = -1;
+			}
+			else
+			{
+				// FIXME: This won't work if the imported bone refers to
+				// another imported bone which is further along in the list
+				g_bonetable[k].parent = findGlobalBone( g_importbone[i].parent );
+				if ( g_bonetable[k].parent == -1 )
+				{
+					Warning("Imported bone %s tried to access parent bone %s and failed!\n",
+						g_importbone[i].name, g_importbone[i].parent );
+				}
+			}
+			g_bonetable[k].bPreDefined = true;
+			g_bonetable[k].rawLocal = g_importbone[i].rawLocal;
+			g_bonetable[k].rawLocalOriginal = g_bonetable[k].rawLocal;
+			g_numbones++;
+		}
+		g_bonetable[k].bDontCollapse = true;
+		g_bonetable[k].srcRealign = g_importbone[i].srcRealign;
+		g_bonetable[k].bPreAligned = true;
+	}
+
+	TagUsedImportedBones();
+
+	// union of all used bones
+	for ( i = 0; i < g_numsources; i++ )
+	{
+		s_source_t *psource = g_source[i];
+
+		// skip sources with no bones
+		if (psource->numbones == 0)
+			continue;
+
+		matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( psource, "BindPose" );
+		if ( !pSourceAnim )
+		{
+			pSourceAnim = &psource->m_Animations[0];
+		}
+		BuildRawTransforms( psource, pSourceAnim->animationname, 0, srcBoneToWorld );
+
+		for ( j = 0; j < psource->numbones; j++ )
+		{
+			if ( g_collapse_bones_aggressive )
+			{
+				if ( psource->boneflags[j] == 0 )
+					continue;
+			}
+			else
+			{
+				if ( psource->boneref[j] == 0 )
+					continue;
+			}
+
+			k = findGlobalBone( psource->localBone[j].name );
+			if (k == -1)
+			{
+				// create new bone
+				k = g_numbones;
+				V_strcpy_safe( g_bonetable[k].name, psource->localBone[j].name );
+				if ((n = psource->localBone[j].parent) != -1)
+					g_bonetable[k].parent		= findGlobalBone( psource->localBone[n].name );
+				else
+					g_bonetable[k].parent		= -1;
+				g_bonetable[k].bonecontroller	= 0;
+				g_bonetable[k].flags			= psource->boneflags[j];
+
+				if ( g_bonetable[k].parent == -1 || !g_bonetable[g_bonetable[k].parent].bPreAligned )
+				{
+					AngleMatrix( pSourceAnim->rawanim[0][j].rot, pSourceAnim->rawanim[0][j].pos, g_bonetable[k].rawLocal );
+					g_bonetable[k].rawLocalOriginal = g_bonetable[k].rawLocal;
+				}
+				else
+				{
+					// convert the local relative position into a realigned relative position
+					matrix3x4_t srcParentBoneToWorld;
+					ConcatTransforms( srcBoneToWorld[n], g_bonetable[g_bonetable[k].parent].srcRealign, srcParentBoneToWorld );
+					matrix3x4_t invSrcParentBoneToWorld;
+					MatrixInvert( srcParentBoneToWorld, invSrcParentBoneToWorld );
+					ConcatTransforms( invSrcParentBoneToWorld, srcBoneToWorld[j], g_bonetable[k].rawLocal );
+				}
+
+				g_bonetable[k].boneToPose.Invalidate();
+
+				// printf("%d : %s (%s)\n", k, g_bonetable[k].name, g_bonetable[g_bonetable[k].parent].name );
+				g_numbones++;
+				continue;
+			}
+				
+			if (g_bOverridePreDefinedBones && g_bonetable[k].bPreDefined)
+			{
+				g_bonetable[k].flags			|= psource->boneflags[j];
+
+				ConcatTransforms( srcBoneToWorld[j], g_bonetable[k].srcRealign, g_bonetable[k].boneToPose ); 
+
+				if (g_bonetable[k].parent == -1)
+				{
+					MatrixCopy( g_bonetable[k].boneToPose, g_bonetable[k].rawLocal );
+				}
+				else
+				{
+					matrix3x4_t tmp;
+					MatrixInvert( g_bonetable[g_bonetable[k].parent].boneToPose, tmp );
+					ConcatTransforms( tmp, g_bonetable[k].boneToPose, g_bonetable[k].rawLocal ); 
+				}
+				continue;
+			}
+
+			// accumlate flags
+			g_bonetable[k].flags |= psource->boneflags[j];
+		}
+	}
+
+	return iError;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void BuildGlobalBoneToPose( )
+{
+	int k;
+
+	// build reference pose
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( g_bonetable[k].rawLocal, g_bonetable[k].boneToPose );
+		}
+		else
+		{
+			ConcatTransforms (g_bonetable[g_bonetable[k].parent].boneToPose, g_bonetable[k].rawLocal, g_bonetable[k].boneToPose);
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void RebuildLocalPose( )
+{
+	int k;
+
+	matrix3x4_t boneToPose[MAXSTUDIOBONES];
+
+	// build reference pose
+	for (k = 0; k < g_numbones; k++)
+	{
+		MatrixCopy( g_bonetable[k].boneToPose, boneToPose[k] );
+	}
+
+	matrix3x4_t poseToBone[MAXSTUDIOBONES];
+
+	// rebuild local pose
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( boneToPose[k], g_bonetable[k].rawLocal );
+		}
+		else
+		{
+			ConcatTransforms (poseToBone[g_bonetable[k].parent], boneToPose[k], g_bonetable[k].rawLocal );
+		}
+		MatrixAngles( g_bonetable[k].rawLocal, g_bonetable[k].rot, g_bonetable[k].pos );
+		MatrixCopy( boneToPose[k], g_bonetable[k].boneToPose );
+		MatrixInvert( boneToPose[k], poseToBone[k] );
+
+		// printf("%d \"%s\" %d\n", k, g_bonetable[k].name, g_bonetable[k].parent );
+	}
+	//exit(0);
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: attach bones to different parents if needed
+//-----------------------------------------------------------------------------
+
+void EnforceHierarchy( )
+{
+	int i, j, k;
+
+	// force changes to hierarchy
+	for (i = 0; i < g_numforcedhierarchy; i++)
+	{
+		j = findGlobalBone( g_forcedhierarchy[i].parentname );
+		k = findGlobalBone( g_forcedhierarchy[i].childname );
+
+		if (j == -1 && strlen( g_forcedhierarchy[i].parentname ) > 0 )
+		{
+			MdlError( "unknown bone: \"%s\" in forced hierarchy\n", g_forcedhierarchy[i].parentname );
+		}
+		if (k == -1)
+		{
+			MdlError( "unknown bone: \"%s\" in forced hierarchy\n", g_forcedhierarchy[i].childname );
+		}
+		
+		/*
+		if (j > k)
+		{
+			MdlError( "parent \"%s\" declared after child \"%s\" in forced hierarchy\n", g_forcedhierarchy[i].parentname, g_forcedhierarchy[i].childname );
+		}
+		*/
+
+		/*
+		if (strlen(g_forcedhierarchy[i].subparentname) != 0)
+		{
+			int n, m;
+
+			m = findGlobalBone( g_forcedhierarchy[i].subparentname );
+			if (m != -1)
+			{
+				MdlError( "inserted bone \"%s\" matches name of existing bone in hierarchy\n", g_forcedhierarchy[i].parentname, g_forcedhierarchy[i].subparentname );
+			}
+
+			printf("inserting bone \"%s\"\n", g_forcedhierarchy[i].subparentname );
+
+			// shift the bone list up
+			for (n = g_numbones; n > k; n--)
+			{
+				g_bonetable[n] = g_bonetable[n-1];
+				if (g_bonetable[n].parent >= k)
+				{
+					g_bonetable[n].parent = g_bonetable[n].parent + 1;
+				}
+				MatrixCopy( boneToPose[n-1], boneToPose[n] );
+			}
+			g_numbones++;
+
+			// add the bone
+			strcpy( g_bonetable[k].name, g_forcedhierarchy[i].subparentname );
+			g_bonetable[k].parent = j;
+			g_bonetable[k].split = true;
+			g_bonetable[k+1].parent = k;
+
+			// split the bone
+			Quaternion q1, q2;
+			Vector p;
+			MatrixAngles( boneToPose[k], q1, p );  // FIXME: badly named!
+
+			// !!!!
+			// QuaternionScale( q1, 0.5, q2 );
+			// q2.Init( 0, 0, 0, 1 );
+			// AngleQuaternion( QAngle( 0, 0, 0 ), q2 );
+			//QuaternionMatrix( q2, p, boneToPose[k] );
+			QuaternionMatrix( q1, p, boneToPose[k] );
+			QuaternionMatrix( q1, p, boneToPose[k+1] );
+		}
+		else
+		*/
+		{
+			g_bonetable[k].parent = j;
+		}
+	}
+
+
+	// resort hierarchy
+	bool bSort = true;
+	int count = 0;
+
+	while (bSort) 
+	{
+		count++;
+		bSort = false;
+		for (i = 0; i < g_numbones; i++)
+		{
+			if (g_bonetable[i].parent > i)
+			{
+				// swap
+				j = g_bonetable[i].parent;
+				s_bonetable_t tmp;
+				tmp = g_bonetable[i];
+				g_bonetable[i] = g_bonetable[j];
+				g_bonetable[j] = tmp;
+
+				// relink parents
+				for (k = i; k < g_numbones; k++)
+				{
+					if (g_bonetable[k].parent == i)
+					{
+						g_bonetable[k].parent = j;
+					} 
+					else if (g_bonetable[k].parent == j)
+					{
+						g_bonetable[k].parent = i;
+					}
+				}
+
+				bSort = true;
+			}
+		}
+		if (count > 1000)
+		{
+			MdlError( "Circular bone hierarchy\n");
+		}
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: find procedural bones and tag for inclusion even if they don't animate
+//-----------------------------------------------------------------------------
+
+void TagProceduralBones( )
+{
+	int j;
+
+	// look for AxisInterp bone definitions
+	int numaxisinterpbones = 0;
+	for (j = 0; j < g_numaxisinterpbones; j++)
+	{
+		g_axisinterpbones[j].bone = findGlobalBone( g_axisinterpbones[j].bonename );
+		g_axisinterpbones[j].control = findGlobalBone( g_axisinterpbones[j].controlname );
+
+		if (g_axisinterpbones[j].bone == -1) 
+		{
+			if (!g_quiet)
+			{
+				printf("axisinterpbone \"%s\" unused\n", g_axisinterpbones[j].bonename );
+			}
+			continue; // optimized out, don't complain
+		}
+
+		if (g_axisinterpbones[j].control == -1)
+		{
+			MdlError( "Missing control bone \"%s\" for procedural bone \"%s\"\n", g_axisinterpbones[j].bonename, g_axisinterpbones[j].controlname );
+		}
+
+		g_bonetable[g_axisinterpbones[j].bone].flags |= BONE_ALWAYS_PROCEDURAL; // ??? what about physics rules
+		g_axisinterpbonemap[numaxisinterpbones++] = j;
+	}
+	g_numaxisinterpbones = numaxisinterpbones;
+
+	// look for QuatInterp bone definitions
+	int numquatinterpbones = 0;
+	for (j = 0; j < g_numquatinterpbones; j++)
+	{
+		g_quatinterpbones[j].bone = findGlobalBoneXSI( g_quatinterpbones[j].bonename );
+		g_quatinterpbones[j].control = findGlobalBoneXSI( g_quatinterpbones[j].controlname );
+
+		if (g_quatinterpbones[j].bone == -1) 
+		{
+			if (!g_quiet && !g_bCreateMakefile )
+			{
+				printf("quatinterpbone \"%s\" unused\n", g_quatinterpbones[j].bonename );
+			}
+			continue; // optimized out, don't complain
+		}
+
+		if (g_quatinterpbones[j].control == -1)
+		{
+			MdlError( "Missing control bone \"%s\" for procedural bone \"%s\"\n", g_quatinterpbones[j].bonename, g_quatinterpbones[j].controlname );
+		}
+
+		g_bonetable[g_quatinterpbones[j].bone].flags |= BONE_ALWAYS_PROCEDURAL; // ??? what about physics rules
+		g_quatinterpbonemap[numquatinterpbones++] = j;
+	}
+	g_numquatinterpbones = numquatinterpbones;
+	// look for AimAt bone definitions
+	int numaimatbones = 0;
+	for (j = 0; j < g_numaimatbones; j++)
+	{
+		g_aimatbones[j].bone =		findGlobalBoneXSI( g_aimatbones[j].bonename );
+
+		if (g_aimatbones[j].bone == -1) 
+		{
+			if (!g_quiet && !g_bCreateMakefile )
+			{
+				printf("<aimconstraint> \"%s\" unused\n", g_aimatbones[j].bonename );
+			}
+			continue; // optimized out, don't complain
+		}
+
+		g_aimatbones[j].parent =	findGlobalBoneXSI( g_aimatbones[j].parentname );
+
+		if (g_aimatbones[j].parent == -1)
+		{
+			MdlError( "Missing parent control bone \"%s\" for procedural bone \"%s\"\n", g_aimatbones[j].parentname, g_aimatbones[j].bonename );
+		}
+
+		// Look for the aim bone as an attachment first
+
+		g_aimatbones[j].aimAttach = -1;
+
+		for ( int ai( 0 ); ai < g_numattachments; ++ai )
+		{
+			if ( strcmp( g_attachment[ ai ].name, g_aimatbones[j].aimname ) == 0 )
+			{
+				g_aimatbones[j].aimAttach = ai;
+				break;
+			}
+		}
+
+		if ( g_aimatbones[j].aimAttach == -1 )
+		{
+			g_aimatbones[j].aimBone = findGlobalBoneXSI( g_aimatbones[j].aimname );
+
+			if ( g_aimatbones[j].aimBone == -1 )
+			{
+				MdlError( "Missing aim control attachment or bone \"%s\" for procedural bone \"%s\"\n",
+					g_aimatbones[j].aimname, g_aimatbones[j].bonename );
+			}
+		}
+
+		g_bonetable[g_aimatbones[j].bone].flags |= BONE_ALWAYS_PROCEDURAL; // ??? what about physics rules
+		g_aimatbonemap[numaimatbones++] = j;
+	}
+
+	// look for Jiggle bone definitions
+	int numjigglebones = 0;
+	for (j = 0; j < g_numjigglebones; j++)
+	{
+		g_jigglebones[j].bone = findGlobalBone( g_jigglebones[j].bonename );
+
+		if (g_jigglebones[j].bone == -1) 
+		{
+			if (!g_quiet)
+			{
+				printf("jigglebone \"%s\" unused\n", g_jigglebones[j].bonename );
+			}
+			continue; // optimized out, don't complain
+		}
+
+		g_bonetable[g_jigglebones[j].bone].flags |= BONE_ALWAYS_PROCEDURAL; // ??? what about physics rules
+		g_jigglebonemap[numjigglebones++] = j;
+	}
+	g_numjigglebones = numjigglebones;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: convert original procedural bone info into correct values for existing skeleton
+//-----------------------------------------------------------------------------
+void RemapProceduralBones( )
+{
+	int j;
+
+	// look for QuatInterp bone definitions
+	for (j = 0; j < g_numquatinterpbones; j++)
+	{
+		s_quatinterpbone_t *pInterp = &g_quatinterpbones[g_quatinterpbonemap[j]];
+
+		int origParent = findGlobalBoneXSI( pInterp->parentname );
+		int origControlParent = findGlobalBoneXSI( pInterp->controlparentname );
+
+		if (origParent == -1)
+		{
+			MdlError( "procedural bone \"%s\", can't find orig parent \"%s\"\n\n", pInterp->bonename, pInterp->parentname );
+		}
+
+		if (origControlParent == -1)
+		{
+			MdlError( "procedural bone \"%s\", can't find control parent \"%s\n\n", pInterp->bonename, pInterp->controlparentname );
+		}
+
+		if ( g_bonetable[pInterp->bone].parent != origParent)
+		{
+			MdlError( "unknown procedural bone parent remapping\n" );
+		}
+
+		if ( g_bonetable[pInterp->control].parent != origControlParent)
+		{
+			MdlError( "procedural bone \"%s\", parent remapping error, control parent was \"%s\", is now \"%s\"\n",
+				pInterp->bonename, 
+				pInterp->controlparentname,
+				g_bonetable[g_bonetable[pInterp->control].parent].name );
+		}
+
+		// remap triggers and movements/rotations due to skeleton changes and realignment
+		for (int k = 0; k < pInterp->numtriggers; k++)
+		{
+			int parent = g_bonetable[pInterp->control].parent;
+
+			// triggers are the "control" bone relative to the control's parent bone
+			if (parent != -1)
+			{
+				matrix3x4_t invControlParentRealign;
+				MatrixInvert( g_bonetable[parent].srcRealign, invControlParentRealign );
+
+				matrix3x4_t srcControlParentBoneToPose;
+				ConcatTransforms( g_bonetable[parent].boneToPose, invControlParentRealign, srcControlParentBoneToPose );
+
+				matrix3x4_t srcControlRelative;
+				QuaternionMatrix( pInterp->trigger[k], srcControlRelative );
+
+				matrix3x4_t srcControlBoneToPose;
+				ConcatTransforms( srcControlParentBoneToPose, srcControlRelative, srcControlBoneToPose );
+
+				matrix3x4_t destControlParentBoneToPose;
+				ConcatTransforms( srcControlParentBoneToPose, g_bonetable[parent].srcRealign, destControlParentBoneToPose );
+
+				matrix3x4_t destControlBoneToPose;
+				ConcatTransforms( srcControlBoneToPose, g_bonetable[pInterp->control].srcRealign, destControlBoneToPose );
+
+				matrix3x4_t invDestControlParentBoneToPose;
+				MatrixInvert( destControlParentBoneToPose, invDestControlParentBoneToPose );
+
+				matrix3x4_t destControlRelative;
+				ConcatTransforms( invDestControlParentBoneToPose, destControlBoneToPose, destControlRelative );
+
+				Vector tmp;
+				MatrixAngles( destControlRelative, pInterp->trigger[k], tmp );
+
+				/*
+				Vector pos;
+				RadianEuler angles;
+
+
+				MatrixAngles( srcControlRelative, angles, pos );
+				printf("srcControlRelative  : %7.2f %7.2f %7.2f\n", RAD2DEG( angles.x ), RAD2DEG( angles.y ), RAD2DEG( angles.z ) );
+
+				MatrixAngles( destControlRelative, angles, pos );
+				printf("destControlRelative : %7.2f %7.2f %7.2f\n", RAD2DEG( angles.x ), RAD2DEG( angles.y ), RAD2DEG( angles.z ) );
+
+				printf("\n");
+				*/
+			}
+
+			// movements are relative to the bone's parent
+			parent = g_bonetable[pInterp->bone].parent;
+			if (parent != -1)
+			{
+				//printf("procedural bone \"%s\"\n", pInterp->bonename );
+				//printf("pre  : %7.2f %7.2f %7.2f\n", pInterp->pos[k].x, pInterp->pos[k].y, pInterp->pos[k].z );
+				// get local transform
+				matrix3x4_t srcParentRelative;
+				QuaternionMatrix( pInterp->quat[k], pInterp->pos[k] + pInterp->basepos, srcParentRelative );
+
+				// get original boneToPose
+				matrix3x4_t invSrcRealign;
+				MatrixInvert( g_bonetable[parent].srcRealign, invSrcRealign );
+				matrix3x4_t origParentBoneToPose;
+				ConcatTransforms( g_bonetable[parent].boneToPose, invSrcRealign, origParentBoneToPose );
+
+				// move bone adjustment into world position
+				matrix3x4_t srcBoneToWorld;
+				ConcatTransforms( origParentBoneToPose, srcParentRelative, srcBoneToWorld );
+
+				// calculate local transform
+				matrix3x4_t parentPoseToBone;
+				MatrixInvert( g_bonetable[parent].boneToPose, parentPoseToBone );
+				matrix3x4_t destBoneToWorld;
+				ConcatTransforms( parentPoseToBone, srcBoneToWorld, destBoneToWorld );
+
+				// save out the local transform
+				MatrixAngles( destBoneToWorld, pInterp->quat[k], pInterp->pos[k] );
+
+				pInterp->pos[k] += g_bonetable[pInterp->control].pos * pInterp->percentage;
+
+				//printf("post : %7.2f %7.2f %7.2f\n", pInterp->pos[k].x, pInterp->pos[k].y, pInterp->pos[k].z );
+			}
+
+		}
+	}
+
+	// look for aimatbones
+	for (j = 0; j < g_numaimatbones; j++)
+	{
+		s_aimatbone_t *pAimAtBone = &g_aimatbones[g_aimatbonemap[j]];
+
+		int origParent =	findGlobalBoneXSI( pAimAtBone->parentname );
+
+		if (origParent == -1)
+		{
+			MdlError( "<aimconstraint> bone \"%s\", can't find parent bone \"%s\"\n\n", pAimAtBone->bonename, pAimAtBone->parentname );
+		}
+
+		int origAim( -1 );
+
+		for ( int ai( 0 ); ai < g_numattachments; ++ai )
+		{
+			if ( strcmp( g_attachment[ ai ].name, pAimAtBone->aimname ) == 0 )
+			{
+				origAim = ai;
+				break;
+			}
+		}
+
+		if (origAim == -1)
+		{
+			MdlError( "<aimconstraint> bone \"%s\", can't find aim bone \"%s\n\n", pAimAtBone->bonename, pAimAtBone->aimname );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: propogate procedural bone usage up its chain
+//-----------------------------------------------------------------------------
+void MarkProceduralBoneChain()
+{
+	int j;
+	int	k;
+	int	fBoneFlags;
+
+	// look for QuatInterp bone definitions
+	for (j = 0; j < g_numquatinterpbones; j++)
+	{
+		s_quatinterpbone_t *pInterp = &g_quatinterpbones[g_quatinterpbonemap[j]];
+	
+		fBoneFlags = g_bonetable[pInterp->bone].flags & BONE_USED_MASK;
+
+		// propogate the procedural bone usage up its hierarchy
+		k = pInterp->control;
+		while (k != -1)
+		{
+			g_bonetable[k].flags |= fBoneFlags;
+			k = g_bonetable[k].parent;
+		}
+
+		// propogate the procedural bone usage up its hierarchy
+		k = pInterp->bone;
+		while (k != -1)
+		{
+			g_bonetable[k].flags |= fBoneFlags;
+			k = g_bonetable[k].parent;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: go through all source files and link local bone indices and global bonetable indicies
+//-----------------------------------------------------------------------------
+static int MapSourcesToGlobalBonetable( )
+{
+	int i, j, k;
+	int	iError = 0;
+
+	// map each source bone list to master list
+	for (i = 0; i < g_numsources; i++)
+	{
+		s_source_t *pSource = g_source[i];
+
+		memset( pSource->boneLocalToGlobal, 0xFF, sizeof(pSource->boneLocalToGlobal) );
+		memset( pSource->boneGlobalToLocal, 0xFF, sizeof(pSource->boneGlobalToLocal) );
+
+		for ( j = 0; j < pSource->numbones; j++ )
+		{
+			k = findGlobalBone( pSource->localBone[j].name );
+			if ( k >= 0 )
+			{
+				pSource->boneLocalToGlobal[j] = k;
+				pSource->boneGlobalToLocal[k] = j;
+				continue;
+			}
+
+			int m = pSource->localBone[j].parent;
+			while ( m != -1 && ( k = findGlobalBone( pSource->localBone[m].name ) ) == -1 )
+			{
+				m = pSource->localBone[m].parent;
+			}
+			if (k == -1)
+			{
+				/*
+				if (!g_quiet)
+				{
+					printf("unable to find connection for collapsed bone \"%s\" \n", pSource->localBone[j].name );
+				}
+				*/
+				k = 0;
+			}
+			pSource->boneLocalToGlobal[j] = k;
+		}
+	}
+	return iError;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: go through bone and find any that arent aligned on the X axis
+//-----------------------------------------------------------------------------
+void RealignBones( )
+{
+	int k;
+
+	int childbone[MAXSTUDIOBONES];
+	for (k = 0; k < g_numbones; k++)
+	{
+		childbone[k] = -1;
+	}
+
+	// force bones with IK rules to realign themselves
+	for (int i = 0; i < g_numikchains; i++)
+	{
+		k = g_ikchain[i].link[0].bone;
+		if (childbone[k] == -1 || childbone[k] == g_ikchain[i].link[1].bone)
+		{
+			childbone[k] = g_ikchain[i].link[1].bone;
+		}
+		else
+		{
+			MdlError("Trying to realign bone \"%s\" with two children \"%s\", \"%s\"\n", 
+				g_bonetable[k].name, g_bonetable[childbone[k]].name, g_bonetable[g_ikchain[i].link[1].bone].name );
+		}
+
+		k = g_ikchain[i].link[1].bone;
+		if (childbone[k] == -1 || childbone[k] == g_ikchain[i].link[2].bone)
+		{
+			childbone[k] = g_ikchain[i].link[2].bone;
+		}
+		else
+		{
+			MdlError("Trying to realign bone \"%s\" with two children \"%s\", \"%s\"\n", 
+				g_bonetable[k].name, g_bonetable[childbone[k]].name, g_bonetable[g_ikchain[i].link[2].bone].name );
+		}
+	}
+
+	if (g_realignbones)
+	{
+		int children[MAXSTUDIOBONES];
+
+		// count children
+		for (k = 0; k < g_numbones; k++)
+		{
+			children[k] = 0;
+		}
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].parent != -1)
+			{
+				children[g_bonetable[k].parent]++;
+			}
+		}
+
+		// if my parent bone only has one child, then tell it to align to me
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].parent != -1 && children[g_bonetable[k].parent] == 1)
+			{
+				childbone[g_bonetable[k].parent] = k;
+			}
+		}
+	}
+
+	matrix3x4_t boneToPose[MAXSTUDIOBONES];
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		MatrixCopy( g_bonetable[k].boneToPose, boneToPose[k] );
+	}
+
+	// look for bones that aren't on a primary X axis
+	for (k = 0; k < g_numbones; k++)
+	{
+		// printf("%s  %.4f %.4f %.4f  (%d)\n", g_bonetable[k].name, g_bonetable[k].pos.x, g_bonetable[k].pos.y, g_bonetable[k].pos.z, children[k] );
+		if (!g_bonetable[k].bPreAligned && childbone[k] != -1)
+		{
+			float d = g_bonetable[childbone[k]].pos.Length();
+
+			// check to see that it's on positive X
+			if (d - g_bonetable[childbone[k]].pos.x > 0.01)
+			{
+				Vector v2;
+				Vector v3;
+				// printf("%s:%s  %.4f %.4f %.4f\n", g_bonetable[k].name, g_bonetable[childbone[k]].name, g_bonetable[childbone[k]].pos.x, g_bonetable[childbone[k]].pos.y, g_bonetable[childbone[k]].pos.z );
+
+				Vector forward, left, up;
+
+				// calc X axis
+				MatrixGetColumn( g_bonetable[childbone[k]].boneToPose, 3, v2 );
+				MatrixGetColumn( g_bonetable[k].boneToPose, 3, v3 );
+				forward = v2 - v3;
+				VectorNormalize( forward );
+
+				// try to align to existing bone/boundingbox by finding most perpendicular 
+				// existing axis and aligning the new Z axis to it.
+				Vector forward2, left2, up2;
+				MatrixGetColumn( boneToPose[k], 0, forward2 );
+				MatrixGetColumn( boneToPose[k], 1, left2 );
+				MatrixGetColumn( boneToPose[k], 2, up2 );
+				float d1 = fabs(DotProduct( forward, forward2 ));
+				float d2 = fabs(DotProduct( forward, left2 ));
+				float d3 = fabs(DotProduct( forward, up2 ));
+				if (d1 <= d2 && d1 <= d3)
+				{
+					up = CrossProduct( forward, forward2 );
+					VectorNormalize( up );
+				}
+				else if (d2 <= d1 && d2 <= d3)
+				{
+					up = CrossProduct( forward, left2 );
+					VectorNormalize( up );
+				}
+				else
+				{
+					up = CrossProduct( forward, up2 );
+					VectorNormalize( up );
+				}
+				left = CrossProduct( up, forward );
+
+				// setup matrix
+				MatrixSetColumn( forward, 0, boneToPose[k] );
+				MatrixSetColumn( left, 1, boneToPose[k] );
+				MatrixSetColumn( up, 2, boneToPose[k] );
+
+				// check orthonormality of matrix
+				d =   fabs( DotProduct( forward, left ) ) 
+					+ fabs( DotProduct( left, up ) ) 
+					+ fabs( DotProduct( up, forward ) )
+					+ fabs( DotProduct( boneToPose[k][0], boneToPose[k][1] ) )
+					+ fabs( DotProduct( boneToPose[k][1], boneToPose[k][2] ) )
+					+ fabs( DotProduct( boneToPose[k][2], boneToPose[k][0] ) );
+
+				if (d > 0.0001)
+				{
+					MdlError( "error with realigning bone %s\n", g_bonetable[k].name );
+				}
+
+				// printf("%f %f %f\n", DotProduct( boneToPose[k][0], boneToPose[k][1] ), DotProduct( boneToPose[k][1], boneToPose[k][2] ), DotProduct( boneToPose[k][2], boneToPose[k][0] ) );
+
+				// printf("%f %f %f\n", DotProduct( forward, left ), DotProduct( left, up ), DotProduct( up, forward ) );
+
+				// VectorMatrix( forward, boneToPose[k] );
+
+				MatrixSetColumn( v3, 3, boneToPose[k] );
+			}
+		}
+	}
+
+	for (int i = 0; i < g_numforcedrealign; i++)
+	{
+		k = findGlobalBone( g_forcedrealign[i].name );
+		if (k == -1)
+		{
+			MdlError( "unknown bone %s in $forcedrealign\n", g_forcedrealign[i].name );
+		}
+
+		matrix3x4_t local;
+		matrix3x4_t tmp;
+
+		AngleMatrix( g_forcedrealign[i].rot, local );
+		ConcatTransforms( boneToPose[k], local, tmp );
+		MatrixCopy( tmp, boneToPose[k] );
+	}
+
+	// build realignment transforms
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (!g_bonetable[k].bPreAligned)
+		{
+			matrix3x4_t poseToBone;
+
+			MatrixInvert( g_bonetable[k].boneToPose, poseToBone );
+			ConcatTransforms( poseToBone, boneToPose[k], g_bonetable[k].srcRealign );
+
+			MatrixCopy( boneToPose[k], g_bonetable[k].boneToPose );
+		}
+	}
+
+	// printf("\n");
+
+	// rebuild default angles, position, etc.
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (!g_bonetable[k].bPreAligned)
+		{
+			matrix3x4_t bonematrix;
+			if (g_bonetable[k].parent == -1)
+			{
+				MatrixCopy( g_bonetable[k].boneToPose, bonematrix );
+			}
+			else
+			{
+				matrix3x4_t poseToBone;
+				// convert my transform into parent relative space
+				MatrixInvert( g_bonetable[g_bonetable[k].parent].boneToPose, poseToBone );
+				ConcatTransforms( poseToBone, g_bonetable[k].boneToPose, bonematrix );
+			}
+
+			MatrixAngles( bonematrix, g_bonetable[k].rot, g_bonetable[k].pos );
+		}
+	}
+
+	// exit(0);
+
+	// printf("\n");
+
+	// build reference pose
+	for (k = 0; k < g_numbones; k++)
+	{
+		matrix3x4_t bonematrix;
+		AngleMatrix( g_bonetable[k].rot, g_bonetable[k].pos, bonematrix );
+		// MatrixCopy( g_bonetable[k].rawLocal, bonematrix );
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( bonematrix, g_bonetable[k].boneToPose );
+		}
+		else
+		{
+			ConcatTransforms (g_bonetable[g_bonetable[k].parent].boneToPose, bonematrix, g_bonetable[k].boneToPose);
+		}
+		/*
+		Vector v1;
+		MatrixGetColumn( g_bonetable[k].boneToPose, 3, v1 );
+		printf("%s  %.4f %.4f %.4f\n", g_bonetable[k].name, v1.x, v1.y, v1.z );
+		*/
+	}
+}
+
+void CenterBonesOnVerts( void )
+{
+	Vector bmin[MAXSTUDIOBONES];
+	Vector bmax[MAXSTUDIOBONES];
+
+	int i, j, k, n;
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		bmin[k] = Vector( 1, 1, 1 ) * 99999999.0;
+		bmax[k] = Vector( 1, 1, 1 ) * -99999999.0;
+	}
+
+	// find domain of all the vertices
+	for (i = 0; i < g_numsources; i++)
+	{
+		s_source_t *pSource = g_source[i];
+		if ( !pSource->vertex )
+			continue;
+
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( pSource, "BindPose" );
+		if ( !pSourceAnim )
+		{
+			pSourceAnim = &pSource->m_Animations[0];
+		}
+		
+		pSource->m_GlobalVertices.AddMultipleToTail( pSource->numvertices );
+
+		Vector	p;
+		for (j = 0; j < pSource->numvertices; j++)
+		{
+			for (n = 0; n < pSource->m_GlobalVertices[j].boneweight.numbones; n++)
+			{
+				k = pSource->m_GlobalVertices[j].boneweight.bone[n];
+				p = pSource->m_GlobalVertices[j].position;
+
+				bmin[k] = bmin[k].Min( p );
+				bmax[k] = bmax[k].Max( p );
+			}
+		}
+	}
+
+	// copy min/maxs up to parent
+	for (k = g_numbones - 1; k >= 0; k--)
+	{
+		if (bmin[k].x > bmax[k].x)
+		{
+			for (j = k + 1; j < g_numbones; j++)
+			{
+				if (g_bonetable[j].parent == k)
+				{
+					bmin[k] = bmin[k].Min( bmin[j] );
+					bmax[k] = bmax[k].Max( bmax[j] );
+				}
+			}
+		}
+	}
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (bmin[k].x <= bmax[k].x)
+		{
+			Vector center = (bmin[k] + bmax[k]) * 0.5;
+	
+			// printf("%d %.1f %.1f %.1f\n", k, center.x, center.y, center.z );
+			matrix3x4_t updateCenter;
+			MatrixCopy( g_bonetable[k].boneToPose, updateCenter );
+			PositionMatrix( center, updateCenter );
+
+			matrix3x4_t invPoseToBone;
+			MatrixInvert( g_bonetable[k].boneToPose, invPoseToBone );
+			ConcatTransforms( invPoseToBone, updateCenter, g_bonetable[k].srcRealign );
+
+			MatrixCopy( updateCenter, g_bonetable[k].boneToPose );
+		}
+	}
+	
+	// rebuild default angles, position, etc.
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (!g_bonetable[k].bPreAligned)
+		{
+			matrix3x4_t bonematrix;
+			if (g_bonetable[k].parent == -1)
+			{
+				MatrixCopy( g_bonetable[k].boneToPose, bonematrix );
+			}
+			else
+			{
+				matrix3x4_t poseToBone;
+				// convert my transform into parent relative space
+				MatrixInvert( g_bonetable[g_bonetable[k].parent].boneToPose, poseToBone );
+				ConcatTransforms( poseToBone, g_bonetable[k].boneToPose, bonematrix );
+			}
+
+			MatrixAngles( bonematrix, g_bonetable[k].rot, g_bonetable[k].pos );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: find all the different bones used in all the source files and map everything
+//			to a common bonetable.
+//-----------------------------------------------------------------------------
+void RemapBones( )
+{
+	int	iError = 0;
+
+	if ( g_staticprop )
+	{
+		MakeStaticProp( );
+	}
+	else if ( g_centerstaticprop )
+	{
+		MdlWarning("Ignoring option $autocenter.  Only supported on $staticprop models!!!\n" );
+	}
+
+	TagUsedBones( );
+
+	RenameBones( );
+
+	iError = BuildGlobalBonetable( );
+
+	BuildGlobalBoneToPose( );
+
+	EnforceHierarchy( );
+
+	{
+		int k, n;
+		for ( k = 0; k < g_numbones; k++ )
+		{
+			// tag parent bones as being in the same way as their children
+			n = g_bonetable[k].parent;
+			while (n != -1)
+			{
+				g_bonetable[n].flags |= g_bonetable[k].flags;
+				n = g_bonetable[n].parent;
+			}
+		}
+	}
+
+	if ( g_collapse_bones || g_numimportbones )
+	{
+		CollapseBones( );
+	}
+
+
+	if ( g_numbones >= MAXSTUDIOBONES )
+	{
+		MdlError( "Too many bones used in model, used %d, max %d\n", g_numbones, MAXSTUDIOBONES );
+	}
+
+	/*
+	for (i = 0; i < g_numbones; i++)
+	{
+		printf("%2d %s %d\n", i, g_bonetable[i].name, g_bonetable[i].parent );
+	}
+	*/
+
+	RebuildLocalPose( );
+
+	TagProceduralBones( );
+
+	if ( iError && !(ignore_warnings) )
+	{
+		MdlError( "Exiting due to errors\n" );
+	}
+	MapSourcesToGlobalBonetable( );
+
+	if ( iError && !(ignore_warnings) )
+	{
+		MdlError( "Exiting due to errors\n" );
+	}
+
+	// Map the bone names to global bone indices for all BoneFlexDrivers
+	MapFlexDriveBonesToGlobalBoneTable();
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calculate the bone to world transforms for a processed animation
+//-----------------------------------------------------------------------------
+void CalcBoneTransforms( s_animation_t *panimation, int frame, matrix3x4_t* pBoneToWorld )
+{
+	CalcBoneTransforms( panimation, g_panimation[0], frame, pBoneToWorld );
+}
+
+
+void CalcBoneTransforms( s_animation_t *panimation, s_animation_t *pbaseanimation, int frame, matrix3x4_t* pBoneToWorld )
+{
+	if ((panimation->flags & STUDIO_LOOPING) && panimation->numframes > 1)
+	{
+		while (frame >= (panimation->numframes - 1))
+		{
+			frame = frame - (panimation->numframes - 1);
+		}
+	}
+	if (frame < 0 || frame >= panimation->numframes)
+	{
+		MdlError("requested out of range frame on animation \"%s\" : %d (%d)\n", panimation->name, frame, panimation->numframes );
+	}
+
+	for (int k = 0; k < g_numbones; k++)
+	{
+		Vector angle;
+		matrix3x4_t bonematrix;
+
+		if (!(panimation->flags & STUDIO_DELTA))
+		{
+			AngleMatrix( panimation->sanim[frame][k].rot, panimation->sanim[frame][k].pos, bonematrix );
+		}
+		else if (pbaseanimation)
+		{
+			Quaternion q1, q2, q3;
+			Vector p3;
+
+			//AngleQuaternion( g_bonetable[k].rot, q1 );
+			AngleQuaternion( pbaseanimation->sanim[0][k].rot, q1 );
+			AngleQuaternion( panimation->sanim[frame][k].rot, q2 );
+
+			float s = panimation->weight[k];
+
+			QuaternionMA( q1, s, q2, q3 );
+			//p3 = g_bonetable[k].pos + s * panimation->sanim[frame][k].pos;
+			p3 = pbaseanimation->sanim[0][k].pos + s * panimation->sanim[frame][k].pos;
+
+			AngleMatrix( q3, p3, bonematrix );
+		}
+		else
+		{
+			Quaternion q1, q2, q3;
+			Vector p3;
+
+			AngleQuaternion( g_bonetable[k].rot, q1 );
+			AngleQuaternion( panimation->sanim[frame][k].rot, q2 );
+
+			float s = panimation->weight[k];
+
+			QuaternionMA( q1, s, q2, q3 );
+			//p3 = g_bonetable[k].pos + s * panimation->sanim[frame][k].pos;
+			p3 = pbaseanimation->sanim[0][k].pos + s * g_bonetable[k].pos;
+
+			AngleMatrix( q3, p3, bonematrix );
+		}
+
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( bonematrix, pBoneToWorld[k] );
+		}
+		else
+		{
+			ConcatTransforms (pBoneToWorld[g_bonetable[k].parent], bonematrix, pBoneToWorld[k]);
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calculate the bone to world transforms for a processed animation
+//-----------------------------------------------------------------------------
+
+void CalcBoneTransformsCycle( s_animation_t *panimation, s_animation_t *pbaseanimation, float flCycle, matrix3x4_t* pBoneToWorld )
+{
+	float fFrame = flCycle * (panimation->numframes - 1);
+	int iFrame = (int)fFrame;
+	float s = (fFrame - iFrame);
+
+	int iFrame1 = iFrame % (panimation->numframes - 1);
+	int iFrame2 = (iFrame + 1) % (panimation->numframes - 1);
+
+	for (int k = 0; k < g_numbones; k++)
+	{
+		Quaternion q1, q2, q3;
+		Vector p3;
+		matrix3x4_t bonematrix;
+
+		// if (!(panimation->flags & STUDIO_DELTA))
+		{
+			AngleQuaternion( panimation->sanim[iFrame1][k].rot, q1 );
+			AngleQuaternion( panimation->sanim[iFrame2][k].rot, q2 );
+			QuaternionSlerp( q1, q2, s, q3 );
+
+			VectorLerp( panimation->sanim[iFrame1][k].pos, panimation->sanim[iFrame2][k].pos, s, p3 );
+
+			AngleMatrix( q3, p3, bonematrix );
+		}
+		/* 
+		else
+		{
+			Vector p3;
+
+			//AngleQuaternion( g_bonetable[k].rot, q1 );
+			AngleQuaternion( pbaseanimation->sanim[0][k].rot, q1 );
+			AngleQuaternion( panimation->sanim[frame][k].rot, q2 );
+
+			float s = panimation->weight[k];
+
+			QuaternionMA( q1, s, q2, q3 );
+			//p3 = g_bonetable[k].pos + s * panimation->sanim[frame][k].pos;
+			p3 = pbaseanimation->sanim[0][k].pos + s * panimation->sanim[frame][k].pos;
+
+			AngleMatrix( q3, p3, bonematrix );
+		}
+		*/
+
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( bonematrix, pBoneToWorld[k] );
+		}
+		else
+		{
+			ConcatTransforms (pBoneToWorld[g_bonetable[k].parent], bonematrix, pBoneToWorld[k]);
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: calculate the bone to world transforms for a processed sequence
+//-----------------------------------------------------------------------------
+
+
+void SlerpBones( 
+	Quaternion q1[MAXSTUDIOBONES], 
+	Vector pos1[MAXSTUDIOBONES], 
+	int sequence, 
+	const Quaternion q2[MAXSTUDIOBONES], 
+	const Vector pos2[MAXSTUDIOBONES], 
+	float s )
+{
+	int			i;
+	Quaternion		q3, q4;
+	float		s1, s2;
+
+	s_sequence_t *pseqdesc = &g_sequence[sequence];
+
+	if (s <= 0.0f) 
+	{
+		return;
+	}
+	else if (s > 1.0f)
+	{
+		s = 1.0f;		
+	}
+
+	if (pseqdesc->flags & STUDIO_DELTA)
+	{
+		for (i = 0; i < g_numbones; i++)
+		{
+
+			s2 = s * pseqdesc->weight[i];	// blend in based on this bones weight
+			if (s2 > 0.0)
+			{
+				if (pseqdesc->flags & STUDIO_POST)
+				{
+					QuaternionMA( q1[i], s2, q2[i], q1[i] );
+
+					// FIXME: are these correct?
+					pos1[i][0] = pos1[i][0] + pos2[i][0] * s2;
+					pos1[i][1] = pos1[i][1] + pos2[i][1] * s2;
+					pos1[i][2] = pos1[i][2] + pos2[i][2] * s2;
+				}
+				else
+				{
+					QuaternionSM( s2, q2[i], q1[i], q1[i] );
+
+					// FIXME: are these correct?
+					pos1[i][0] = pos1[i][0] + pos2[i][0] * s2;
+					pos1[i][1] = pos1[i][1] + pos2[i][1] * s2;
+					pos1[i][2] = pos1[i][2] + pos2[i][2] * s2;
+				}
+			}
+		}
+	}
+	else
+	{
+		for (i = 0; i <g_numbones; i++)
+		{
+			s2 = s * pseqdesc->weight[i];	// blend in based on this animations weights
+			if (s2 > 0.0)
+			{
+				s1 = 1.0 - s2;
+
+				if (g_bonetable[i].flags & BONE_FIXED_ALIGNMENT)
+				{
+					QuaternionSlerpNoAlign( q2[i], q1[i], s1, q3 );
+				}
+				else
+				{
+					QuaternionSlerp( q2[i], q1[i], s1, q3 );
+				}
+				q1[i][0] = q3[0];
+				q1[i][1] = q3[1];
+				q1[i][2] = q3[2];
+				q1[i][3] = q3[3];
+				pos1[i][0] = pos1[i][0] * s1 + pos2[i][0] * s2;
+				pos1[i][1] = pos1[i][1] * s1 + pos2[i][1] * s2;
+				pos1[i][2] = pos1[i][2] * s1 + pos2[i][2] * s2;
+			}
+		}
+	}
+}
+
+
+void CalcPoseSingle( Vector pos[], Quaternion q[], int sequence, float frame )
+{
+	s_sequence_t *pseqdesc = &g_sequence[sequence];
+
+	s_animation_t *panim = pseqdesc->panim[0][0];
+
+	// FIXME: is this modulo correct?
+	int iframe = ((int)frame) % panim->numframes;
+
+	for (int k = 0; k < g_numbones; k++)
+	{
+		// FIXME: this isn't doing a fractional frame
+		AngleQuaternion( panim->sanim[iframe][k].rot, q[k] );
+		pos[k] = panim->sanim[iframe][k].pos;
+	}
+}
+
+void AccumulateSeqLayers( Vector pos[], Quaternion q[], int sequence, float frame, float flWeight );
+
+void AccumulatePose( Vector pos[], Quaternion q[], int sequence, float frame, float flWeight )
+{
+	Vector		pos2[MAXSTUDIOBONES];
+	Quaternion	q2[MAXSTUDIOBONES];
+
+	// printf("accumulate %s : %.1f\n", g_sequence[sequence].name, frame );
+
+	CalcPoseSingle( pos2, q2, sequence, frame );
+
+	SlerpBones( q, pos, sequence, q2, pos2, flWeight );
+
+	AccumulateSeqLayers( pos, q, sequence, frame, flWeight );
+}
+
+void AccumulateSeqLayers( Vector pos[], Quaternion q[], int sequence, float frame, float flWeight )
+{
+	s_sequence_t *pseqdesc = &g_sequence[sequence];
+
+	for (int i = 0; i < pseqdesc->numautolayers; i++)
+	{
+		s_autolayer_t *pLayer = &pseqdesc->autolayer[i];
+
+		float layerFrame = frame;
+		float layerWeight = flWeight;
+
+		if (pLayer->start != pLayer->end)
+		{
+			float s = 1.0;
+			float index;
+
+			if (!(pLayer->flags & STUDIO_AL_POSE))
+			{
+				index = frame;
+			}
+			else
+			{
+				int iPose = pLayer->pose;
+				if (iPose != -1)
+				{
+					index = 0; // undefined?
+				}
+				else
+				{
+					index = 0;
+				}
+			}
+
+			if (index < pLayer->start)
+				continue;
+			if (index >= pLayer->end)
+				continue;
+
+			if (index < pLayer->peak && pLayer->start != pLayer->peak)
+			{
+				s = (index - pLayer->start) / (pLayer->peak - pLayer->start);
+			}
+			else if (index > pLayer->tail && pLayer->end != pLayer->tail)
+			{
+				s = (pLayer->end - index) / (pLayer->end - pLayer->tail);
+			}
+
+			if (pLayer->flags & STUDIO_AL_SPLINE)
+			{
+				s = 3 * s * s - 2 * s * s * s;
+			}
+
+			if ((pLayer->flags & STUDIO_AL_XFADE) && (frame > pLayer->tail))
+			{
+				layerWeight = ( s * flWeight ) / ( 1 - flWeight + s * flWeight );
+			}
+			else if (pLayer->flags & STUDIO_AL_NOBLEND)
+			{
+				layerWeight = s;
+			}
+			else
+			{
+				layerWeight = flWeight * s;
+			}
+
+			if (!(pLayer->flags & STUDIO_AL_POSE))
+			{
+				layerFrame = ((frame - pLayer->start) / (pLayer->end - pLayer->start)) * (g_sequence[pLayer->sequence].panim[0][0]->numframes - 1);
+			}
+			else
+			{
+				layerFrame = (frame / g_sequence[sequence].panim[0][0]->numframes - 1) * (g_sequence[pLayer->sequence].panim[0][0]->numframes - 1);
+			}
+		}
+
+		AccumulatePose( pos, q, pLayer->sequence, layerFrame, layerWeight );
+	}
+}
+
+
+void CalcSeqTransforms( int sequence, int frame, matrix3x4_t* pBoneToWorld )
+{
+	int k;
+	Vector		pos[MAXSTUDIOBONES];
+	Quaternion	q[MAXSTUDIOBONES];
+
+	// CalcPoseSingle( pos, q, 0, 0 );
+	/*
+	for (k = 0; k < g_numbones; k++)
+	{
+		//AngleQuaternion( g_bonetable[k].rot, q[k] );
+		//pos[k] = g_bonetable[k].pos;
+		AngleQuaternion( g_bonetable[k].rot, q[k] );
+		pos[k] = g_bonetable[k].pos;
+	}
+	*/
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		//AngleQuaternion( g_bonetable[k].rot, q[k] );
+		//pos[k] = g_bonetable[k].pos;
+		AngleQuaternion( g_bonetable[k].rot, q[k] );
+		pos[k] = g_bonetable[k].pos;
+	}
+
+
+	AccumulatePose( pos, q, sequence, frame, 1.0 );
+
+	for (k = 0; k < g_numbones; k++)
+	{
+		matrix3x4_t bonematrix;
+
+		QuaternionMatrix( q[k], pos[k], bonematrix );
+
+		if (g_bonetable[k].parent == -1)
+		{
+			MatrixCopy( bonematrix, pBoneToWorld[k] );
+		}
+		else
+		{
+			ConcatTransforms (pBoneToWorld[g_bonetable[k].parent], bonematrix, pBoneToWorld[k]);
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+
+void CalcBonePos( s_animation_t *panimation, int frame, int bone, Vector &pos )
+{
+	matrix3x4_t boneToWorld[MAXSTUDIOSRCBONES];	// bone transformation matrix
+
+	CalcBoneTransforms( panimation, frame, boneToWorld );
+
+	pos.x = boneToWorld[bone][0][3];
+	pos.y = boneToWorld[bone][1][3];
+	pos.z = boneToWorld[bone][2][3];
+}
+
+
+#define SMALL_FLOAT 1e-12
+
+// NOTE: This routine was taken (and modified) from NVidia's BlinnReflection demo
+// Creates basis vectors, based on a vertex and index list.
+// See the NVidia white paper 'GDC2K PerPixel Lighting' for a description
+// of how this computation works
+static void CalcTriangleTangentSpace( s_source_t *pSrc, int v1, int v2, int v3, 
+									  Vector &sVect, Vector &tVect )
+{
+/*
+	static bool firstTime = true;
+	static FILE *fp = NULL;
+	if( firstTime )
+	{
+		firstTime = false;
+		fp = fopen( "crap.out", "w" );
+	}
+*/
+    
+	Vector2D t0( pSrc->vertex[v1].texcoord[0], pSrc->vertex[v1].texcoord[1] );
+	Vector2D t1( pSrc->vertex[v2].texcoord[0], pSrc->vertex[v2].texcoord[1] );
+	Vector2D t2( pSrc->vertex[v3].texcoord[0], pSrc->vertex[v3].texcoord[1] );
+	Vector p0( pSrc->vertex[v1].position[0], pSrc->vertex[v1].position[1], pSrc->vertex[v1].position[2] );
+	Vector p1( pSrc->vertex[v2].position[0], pSrc->vertex[v2].position[1], pSrc->vertex[v2].position[2] );
+	Vector p2( pSrc->vertex[v3].position[0], pSrc->vertex[v3].position[1], pSrc->vertex[v3].position[2] );
+	CalcTriangleTangentSpace( p0, p1, p2, t0, t1, t2, sVect, tVect );
+
+/*
+	// Calculate flat normal
+	Vector flatNormal;
+	edge01 = p1 - p0;
+	edge02 = p2 - p0;
+	CrossProduct( edge02, edge01, flatNormal );
+	VectorNormalize( flatNormal );
+	
+	// Get the average position
+	Vector avgPos = ( p0 + p1 + p2 ) / 3.0f;
+
+	// Draw the svect
+	Vector endS = avgPos + sVect * .2f;
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", endS[0], endS[1], endS[2] );
+	fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", avgPos[0], avgPos[1], avgPos[2] );
+	
+	// Draw the tvect
+	Vector endT = avgPos + tVect * .2f;
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", endT[0], endT[1], endT[2] );
+	fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", avgPos[0], avgPos[1], avgPos[2] );
+	
+	// Draw the normal
+	Vector endN = avgPos + flatNormal * .2f;
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", endN[0], endN[1], endN[2] );
+	fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", avgPos[0], avgPos[1], avgPos[2] );
+	
+	// Draw the wireframe of the triangle in white.
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p0[0], p0[1], p0[2] );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p1[0], p1[1], p1[2] );
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p1[0], p1[1], p1[2] );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p2[0], p2[1], p2[2] );
+	fprintf( fp, "2\n" );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p2[0], p2[1], p2[2] );
+	fprintf( fp, "%f %f %f 1.0 1.0 1.0\n", p0[0], p0[1], p0[2] );
+
+	// Draw a slightly shrunken version of the geometry to hide surfaces
+	Vector tmp0 = p0 - flatNormal * .1f;
+	Vector tmp1 = p1 - flatNormal * .1f;
+	Vector tmp2 = p2 - flatNormal * .1f;
+	fprintf( fp, "3\n" );
+	fprintf( fp, "%f %f %f 0.1 0.1 0.1\n", tmp0[0], tmp0[1], tmp0[2] );
+	fprintf( fp, "%f %f %f 0.1 0.1 0.1\n", tmp1[0], tmp1[1], tmp1[2] );
+	fprintf( fp, "%f %f %f 0.1 0.1 0.1\n", tmp2[0], tmp2[1], tmp2[2] );
+		
+	fflush( fp );
+*/
+}
+
+typedef CUtlVector<int> CIntVector;
+
+void CalcModelTangentSpaces( s_source_t *pSrc )
+{
+	// Build a map from vertex to a list of triangles that share the vert.
+	int meshID;
+	for( meshID = 0; meshID < pSrc->nummeshes; meshID++ )
+	{
+		s_mesh_t *pMesh = &pSrc->mesh[pSrc->meshindex[meshID]];
+		CUtlVector<CIntVector> vertToTriMap;
+		vertToTriMap.AddMultipleToTail( pMesh->numvertices );
+		int triID;
+		for( triID = 0; triID < pMesh->numfaces; triID++ )
+		{
+			s_face_t *pFace = &pSrc->face[triID + pMesh->faceoffset];
+			vertToTriMap[pFace->a].AddToTail( triID );
+			vertToTriMap[pFace->b].AddToTail( triID );
+			vertToTriMap[pFace->c].AddToTail( triID );
+		}
+
+		// Calculate the tangent space for each triangle.
+		CUtlVector<Vector> triSVect;
+		CUtlVector<Vector> triTVect;
+		triSVect.AddMultipleToTail( pMesh->numfaces );
+		triTVect.AddMultipleToTail( pMesh->numfaces );
+		for( triID = 0; triID < pMesh->numfaces; triID++ )
+		{
+			s_face_t *pFace = &pSrc->face[triID + pMesh->faceoffset];
+			CalcTriangleTangentSpace( pSrc, 
+				pMesh->vertexoffset + pFace->a, 
+				pMesh->vertexoffset + pFace->b, 
+				pMesh->vertexoffset + pFace->c, 
+				triSVect[triID], triTVect[triID] );
+		}	
+
+		// calculate an average tangent space for each vertex.
+		int vertID;
+		for( vertID = 0; vertID < pMesh->numvertices; vertID++ )
+		{
+			const Vector &normal = pSrc->vertex[vertID+pMesh->vertexoffset].normal;
+			Vector4D &finalSVect = pSrc->vertex[vertID+pMesh->vertexoffset].tangentS;
+			Vector sVect, tVect;
+
+			sVect.Init( 0.0f, 0.0f, 0.0f );
+			tVect.Init( 0.0f, 0.0f, 0.0f );
+			for( triID = 0; triID < vertToTriMap[vertID].Size(); triID++ )
+			{
+				sVect += triSVect[vertToTriMap[vertID][triID]];
+				tVect += triTVect[vertToTriMap[vertID][triID]];
+			}
+
+			// In the case of zbrush, everything needs to be treated as smooth.
+			if( g_bZBrush )
+			{
+				int vertID2;
+				Vector vertPos1( pSrc->vertex[vertID].position[0], pSrc->vertex[vertID].position[1], pSrc->vertex[vertID].position[2] );
+				for( vertID2 = 0; vertID2 < pMesh->numvertices; vertID2++ )
+				{
+					if( vertID2 == vertID )
+					{
+						continue;
+					}
+					Vector vertPos2( pSrc->vertex[vertID2].position[0], pSrc->vertex[vertID2].position[1], pSrc->vertex[vertID2].position[2] );
+					if( vertPos1 == vertPos2 )
+					{
+						int triID2;
+						for( triID2 = 0; triID2 < vertToTriMap[vertID2].Size(); triID2++ )
+						{
+							sVect += triSVect[vertToTriMap[vertID2][triID2]];
+							tVect += triTVect[vertToTriMap[vertID2][triID2]];
+						}
+					}
+				}
+			}
+
+			// make an orthonormal system.
+			// need to check if we are left or right handed.
+			Vector tmpVect;
+			CrossProduct( sVect, tVect, tmpVect );
+			bool leftHanded = DotProduct( tmpVect, normal ) < 0.0f;
+			if( !leftHanded )
+			{
+				CrossProduct( normal, sVect, tVect );
+				CrossProduct( tVect, normal, sVect );
+				VectorNormalize( sVect );
+				VectorNormalize( tVect );
+				finalSVect[0] = sVect[0];
+				finalSVect[1] = sVect[1];
+				finalSVect[2] = sVect[2];
+				finalSVect[3] = 1.0f;
+			}
+			else
+			{
+				CrossProduct( sVect, normal, tVect );
+				CrossProduct( normal, tVect, sVect );
+				VectorNormalize( sVect );
+				VectorNormalize( tVect );
+				finalSVect[0] = sVect[0];
+				finalSVect[1] = sVect[1];
+				finalSVect[2] = sVect[2];
+				finalSVect[3] = -1.0f;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Generate a model vertex from a source vertex
+//-----------------------------------------------------------------------------
+static void InitRemappedVertex( s_source_t *pSource, matrix3x4_t *pDestBoneToWorld, const s_vertexinfo_t &srcVertex, s_vertexinfo_t &dstVertex )
+{
+	Vector tmp1, tmp2, vdest, ndest;
+
+	memcpy( &dstVertex, &srcVertex, sizeof(s_vertexinfo_t) );
+	dstVertex.boneweight.numbones = 0;
+
+	vdest.Init();
+	ndest.Init();
+
+	int n;
+	for ( n = 0; n < srcVertex.boneweight.numbones; n++ )
+	{
+		// src bone
+		int q = srcVertex.boneweight.bone[n];
+
+		// mapping to global bone
+		int k = pSource->boneLocalToGlobal[q];
+		if ( k == -1 )
+		{
+			VectorCopy( srcVertex.position, vdest );
+			VectorCopy( srcVertex.normal, ndest );
+			break;
+			// printf("%s:%s (%d) missing global\n", psource->filename, psource->localBone[q].name, q );
+		}
+
+		// If the global bone is already in the list, then this vertex
+		// contains influences from multiple local bones which have been collapsed 
+		// into a single global bone
+		int m;
+		for ( m = 0; m < dstVertex.boneweight.numbones; m++ )
+		{
+			if ( k == dstVertex.boneweight.bone[m] )
+			{
+				// bone got collapsed out
+				dstVertex.boneweight.weight[m] += srcVertex.boneweight.weight[n];
+				break;
+			}
+		}
+		if ( m == dstVertex.boneweight.numbones )
+		{
+			// add new bone
+			dstVertex.boneweight.bone[m] = k;
+			dstVertex.boneweight.weight[m] = srcVertex.boneweight.weight[n];
+			dstVertex.boneweight.numbones++;
+		}
+
+		// convert vertex into original models' bone local space
+		VectorITransform( srcVertex.position, pDestBoneToWorld[k], tmp1 );
+		// convert that into global world space using stardard pose
+		VectorTransform( tmp1, g_bonetable[k].boneToPose, tmp2 );
+		// accumulate
+		VectorMA( vdest, srcVertex.boneweight.weight[n], tmp2, vdest );
+
+		// convert normal into original models' bone local space
+		VectorIRotate( srcVertex.normal, pDestBoneToWorld[k], tmp1 );
+		// convert that into global world space using stardard pose
+		VectorRotate( tmp1, g_bonetable[k].boneToPose, tmp2 );
+		// accumulate
+		VectorMA( ndest, srcVertex.boneweight.weight[n], tmp2, ndest );
+	}
+
+	// printf("%d  %.2f %.2f %.2f\n", j, vdest.x, vdest.y, vdest.z );
+
+	// save, normalize
+	VectorCopy( vdest, dstVertex.position );
+	VectorNormalize( ndest );
+	VectorCopy( ndest, dstVertex.normal );
+
+	// FIXME: Remapping will whack tangentS. Need to recompute tangents after remapping
+}
+
+
+//-----------------------------------------------------------------------------
+// When read off disk, s_source_t contains bone indices local to the source
+// we need to make the bone indices use the global bone list
+//-----------------------------------------------------------------------------
+void RemapVerticesToGlobalBones( )
+{
+	matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+	matrix3x4_t destBoneToWorld[MAXSTUDIOSRCBONES];
+
+	for (int i = 0; i < g_numsources; i++)
+	{
+		s_source_t *pSource = g_source[i];
+		if ( !pSource->vertex )
+			continue;
+
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( pSource, "BindPose" );
+		if ( !pSourceAnim )
+		{
+			pSourceAnim = &pSource->m_Animations[0];
+		}
+		BuildRawTransforms( pSource, pSourceAnim->animationname, 0, srcBoneToWorld );
+		TranslateAnimations( pSource, srcBoneToWorld, destBoneToWorld );
+		
+		pSource->m_GlobalVertices.AddMultipleToTail( pSource->numvertices );
+
+		for ( int j = 0; j < pSource->numvertices; j++ )
+		{
+			InitRemappedVertex( pSource, destBoneToWorld, pSource->vertex[j], pSource->m_GlobalVertices[j] );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Links bone controllers
+//-----------------------------------------------------------------------------
+
+static void FindAutolayers()
+{
+	int i;
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		int k;
+		for (k = 0; k < g_sequence[i].numautolayers; k++)
+		{
+			int j;
+			for ( j = 0; j < g_sequence.Count(); j++)
+			{
+				if (stricmp( g_sequence[i].autolayer[k].name, g_sequence[j].name) == 0)
+				{
+					g_sequence[i].autolayer[k].sequence = j;
+					break;
+				}
+			}
+			if (j == g_sequence.Count())
+			{
+				MdlError( "sequence \"%s\" cannot find autolayer sequence \"%s\"\n",
+					g_sequence[i].name, g_sequence[i].autolayer[k].name );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Links bone controllers
+//-----------------------------------------------------------------------------
+
+static void LinkBoneControllers()
+{
+	for (int i = 0; i < g_numbonecontrollers; i++)
+	{
+		int j = findGlobalBone( g_bonecontroller[i].name );
+		if (j == -1)
+		{
+			MdlError("unknown g_bonecontroller link '%s'\n", g_bonecontroller[i].name );
+		}
+		g_bonecontroller[i].bone = j;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Links screen aligned bones
+//-----------------------------------------------------------------------------
+
+static void TagScreenAlignedBones()
+{
+	for (int i = 0; i < g_numscreenalignedbones; i++)
+	{
+		int j = findGlobalBone( g_screenalignedbone[i].name );
+		if (j == -1)
+		{
+			MdlError("unknown g_screenalignedbone link '%s'\n", g_screenalignedbone[i].name );
+		}
+
+		g_bonetable[j].flags |= g_screenalignedbone[i].flags;
+		printf("tagging bone: %s as screen aligned (index %i, flags:%x)\n", g_bonetable[j].name, j, g_bonetable[j].flags );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Links attachments
+//-----------------------------------------------------------------------------
+
+static void LinkAttachments()
+{
+	int i, j, k;
+
+	// attachments may be connected to bones that can be optimized out
+	// so search through all the sources and move to a valid location
+
+	matrix3x4_t boneToPose;
+	matrix3x4_t world;
+	matrix3x4_t poseToBone;
+
+	for (i = 0; i < g_numattachments; i++)
+	{
+		bool found = false;
+		// search through known bones
+		for (k = 0; k < g_numbones; k++)
+		{
+			if ( !stricmp( g_attachment[i].bonename, g_bonetable[k].name ))
+			{
+				g_attachment[i].bone = k;
+				MatrixCopy( g_bonetable[k].boneToPose, boneToPose );
+				MatrixInvert( boneToPose, poseToBone );
+				// printf("%s : %d\n", g_bonetable[k].name, k );
+				found = true;
+				break;
+			}
+		}
+
+		if (!found)
+		{
+			// search all the loaded sources for the first occurance of the named bone
+			for (j = 0; j < g_numsources && !found; j++)
+			{
+				for (k = 0; k < g_source[j]->numbones && !found; k++)
+				{
+					if ( !stricmp( g_attachment[i].bonename, g_source[j]->localBone[k].name ) )
+					{
+						MatrixCopy( g_source[j]->boneToPose[k], boneToPose );
+
+						// check to make sure that this bone is actually referenced in the output model
+						// if not, try parent bone until we find a referenced bone in this chain
+						while (k != -1 && g_source[j]->boneGlobalToLocal[g_source[j]->boneLocalToGlobal[k]] != k)
+						{
+							k = g_source[j]->localBone[k].parent;
+						}
+						if (k == -1)
+						{
+							MdlError( "unable to find valid bone for attachment %s:%s\n", 
+								g_attachment[i].name,
+								g_attachment[i].bonename );
+						}
+
+						MatrixInvert( g_source[j]->boneToPose[k], poseToBone );
+						g_attachment[i].bone = g_source[j]->boneLocalToGlobal[k];
+						found = true;
+					}
+				}
+			}
+		}
+
+		if (!found)
+		{
+			MdlError("unknown attachment link '%s'\n", g_attachment[i].bonename );
+		}
+		// printf("%s: %s / %s\n", g_attachment[i].name, g_attachment[i].bonename, g_bonetable[g_attachment[i].bone].name );
+
+		if (g_attachment[i].type & IS_ABSOLUTE)
+		{
+			MatrixCopy( g_attachment[i].local, world );
+		}
+		else
+		{
+			ConcatTransforms( boneToPose, g_attachment[i].local, world );
+		}
+
+		ConcatTransforms( poseToBone, world, g_attachment[i].local );
+	}
+
+	// flag all bones used by attachments
+	for (i = 0; i < g_numattachments; i++)
+	{
+		j = g_attachment[i].bone;
+		while (j != -1)
+		{
+			g_bonetable[j].flags |= BONE_USED_BY_ATTACHMENT;
+			j = g_bonetable[j].parent;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Links mouths
+//-----------------------------------------------------------------------------
+
+static void LinkMouths()
+{
+	for (int i = 0; i < g_nummouths; i++)
+	{
+		int j;
+		for ( j = 0; j < g_numbones; j++)
+		{
+			if (g_mouth[i].bonename[0] && stricmp( g_mouth[i].bonename, g_bonetable[j].name) == 0)
+				break;
+		}
+		if (j >= g_numbones)
+		{
+			MdlError("unknown mouth link '%s'\n", g_mouth[i].bonename );
+		}
+		g_mouth[i].bone = j;
+	}
+}
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+static float CalcPoseParameterValue( int control, RadianEuler &angle, Vector &pos )
+{
+	switch( control )
+	{
+	case STUDIO_X:
+		return pos.x;
+	case STUDIO_Y:
+		return pos.y;
+	case STUDIO_Z:
+		return pos.z;
+	case STUDIO_XR:
+		return RAD2DEG( angle.x );
+	case STUDIO_YR:
+		return RAD2DEG( angle.y );
+	case STUDIO_ZR:
+		return RAD2DEG( angle.z );
+	}
+	return 0.0;
+}
+
+static void CalcPoseParameters( void )
+{
+	int i;
+	matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+	RadianEuler angles;
+	Vector pos;
+
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		s_sequence_t *pseq = &g_sequence[i];
+
+		for (int iPose = 0; iPose < 2; iPose++)
+		{
+			if (pseq->groupsize[iPose] > 1)
+			{
+				if (pseq->paramattachment[iPose] != -1)
+				{
+					int j0 = pseq->paramindex[iPose];
+					int n0 = pseq->paramattachment[iPose];
+					int k0 = g_attachment[n0].bone;
+
+					matrix3x4_t boneToWorldRel;
+					matrix3x4_t boneToWorldMid;
+					matrix3x4_t worldToBoneMid;
+					matrix3x4_t boneRel;
+
+					// printf("%s\n", pseq->name );
+
+					if (pseq->paramanim == NULL)
+					{
+						pseq->paramanim = g_panimation[0];
+					}
+
+					if (pseq->paramcompanim == NULL)
+					{
+						pseq->paramcompanim = pseq->paramanim;
+					}
+
+
+					// calculate what "zero" looks like to the attachment
+					CalcBoneTransforms( pseq->paramanim, 0, boneToWorld );
+					ConcatTransforms( boneToWorld[k0], g_attachment[n0].local, boneToWorldMid );
+					MatrixAngles( boneToWorldMid, angles, pos );
+					// printf("%s : %s : %6.2f %6.2f %6.2f : %6.2f %6.2f %6.2f\n", pseq->name, g_pose[j0].name, RAD2DEG( angles.x ), RAD2DEG( angles.y ), RAD2DEG( angles.z ), pos.x, pos.y, pos.z );
+					MatrixInvert( boneToWorldMid, worldToBoneMid );
+
+					if ( g_verbose )
+					{
+						printf("%s : %s", pseq->name, g_pose[j0].name );
+					}
+
+					// for 2D animation, figure out what opposite row/column to use
+					// FIXME: make these 2D instead of 2 1D!
+					int m[2];
+					bool found = false;
+					if (pseq->paramcenter != NULL)
+					{
+						for (int i0 = 0; !found && i0 < pseq->groupsize[0]; i0++)
+						{
+							for (int i1 = 0; !found && i1 < pseq->groupsize[1]; i1++)
+							{
+								if (pseq->panim[i0][i1] == pseq->paramcenter)
+								{
+									m[0] = i0;
+									m[1] = i1;
+									found = true;
+								}
+							}
+						}
+					}
+					if (!found)
+					{
+						m[1-iPose] = (pseq->groupsize[1-iPose]) / 2;
+					}
+
+					// find changes to attachment
+					for (m[iPose] = 0; m[iPose] < pseq->groupsize[iPose]; m[iPose]++)
+					{
+						CalcBoneTransforms( pseq->panim[m[0]][m[1]], pseq->paramcompanim, 0, boneToWorld );
+						ConcatTransforms( boneToWorld[k0], g_attachment[n0].local, boneToWorldRel );
+						ConcatTransforms( worldToBoneMid, boneToWorldRel, boneRel );
+						MatrixAngles( boneRel, angles, pos );
+						// printf("%6.2f %6.2f %6.2f : %6.2f %6.2f %6.2f\n", RAD2DEG( angles.x ), RAD2DEG( angles.y ), RAD2DEG( angles.z ), pos.x, pos.y, pos.z );
+
+						float v = CalcPoseParameterValue( pseq->paramcontrol[iPose], angles, pos );
+
+						if ( g_verbose )
+						{
+							printf(" %6.2f", v );
+						}
+
+						if (iPose == 0)
+						{
+							pseq->param0[m[iPose]] = v;
+						}
+						else
+						{
+							pseq->param1[m[iPose]] = v;
+						}
+
+
+						// pseq->param1[i0][i1] = CalcPoseParameterValue( pseq->paramcontrol[1], angles, pos );
+
+						if (m[iPose] == 0)
+						{
+							pseq->paramstart[iPose] = (iPose == 0) ? pseq->param0[m[iPose]] : pseq->param1[m[iPose]];
+						}
+						if (m[iPose] == pseq->groupsize[iPose] - 1)
+						{
+							pseq->paramend[iPose] = (iPose == 0) ? pseq->param0[m[iPose]] : pseq->param1[m[iPose]];
+						}
+					}
+
+					if ( g_verbose )
+					{
+						printf("\n");
+					}
+
+					if (fabs( pseq->paramstart[iPose] - pseq->paramend[iPose]) < 0.01 )
+					{
+						MdlError( "calcblend failed in %s\n", pseq->name );
+					}
+
+					g_pose[j0].min = min( g_pose[j0].min, pseq->paramstart[iPose] );
+					g_pose[j0].max = max( g_pose[j0].max, pseq->paramstart[iPose] );
+					g_pose[j0].min = min( g_pose[j0].min, pseq->paramend[iPose] );
+					g_pose[j0].max = max( g_pose[j0].max, pseq->paramend[iPose] );
+				}
+				else
+				{
+
+					for (int m = 0; m < pseq->groupsize[iPose]; m++)
+					{
+						float f = (m / (float)(pseq->groupsize[iPose] - 1.0));
+						if (iPose == 0)
+						{
+							pseq->param0[m] = pseq->paramstart[iPose] * (1.0 - f) + pseq->paramend[iPose] * f;
+						}
+						else
+						{
+							pseq->param1[m] = pseq->paramstart[iPose] * (1.0 - f) + pseq->paramend[iPose] * f;
+						}
+					}
+				}
+			}
+		}
+	}
+	// exit(0);
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Link ikchains
+//-----------------------------------------------------------------------------
+
+static void LinkIKChains( )
+{
+	int i, k;
+
+	// create IK links
+	for (i = 0; i < g_numikchains; i++)
+	{
+		g_ikchain[i].numlinks = 3;
+
+		k = findGlobalBone( g_ikchain[i].bonename );
+		if (k == -1)
+		{
+			MdlError("unknown bone '%s' in ikchain '%s'\n", g_ikchain[i].bonename, g_ikchain[i].name );
+		}
+		g_ikchain[i].link[2].bone = k;
+		g_bonetable[k].flags |= BONE_USED_BY_ATTACHMENT;
+
+		k = g_bonetable[k].parent;
+		if (k == -1)
+		{
+			MdlError("ikchain '%s' too close to root, no parent knee/elbow\n", g_ikchain[i].name );
+		}
+		g_ikchain[i].link[1].bone = k;
+		g_bonetable[k].flags |= BONE_USED_BY_ATTACHMENT;
+
+		k = g_bonetable[k].parent;
+		if (k == -1)
+		{
+			MdlError("ikchain '%s' too close to root, no parent hip/shoulder\n", g_ikchain[i].name );
+		}
+		g_ikchain[i].link[0].bone = k;
+		g_bonetable[k].flags |= BONE_USED_BY_ATTACHMENT;
+
+		// FIXME: search for toes
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Link ikchains
+//-----------------------------------------------------------------------------
+
+static void LinkIKLocks( )
+{
+	int i, j;
+
+	// create IK links
+	for (i = 0; i < g_numikautoplaylocks; i++)
+	{
+		for (j = 0; j < g_numikchains; j++)
+		{
+			if (stricmp( g_ikchain[j].name, g_ikautoplaylock[i].name) == 0)
+			{
+				break;
+			}
+		}
+		if (j == g_numikchains)
+		{
+			MdlError("unknown chain '%s' in ikautoplaylock\n", g_ikautoplaylock[i].name );
+		}
+
+		g_ikautoplaylock[i].chain = j;
+	}
+
+	int k;
+
+	for (k = 0; k < g_sequence.Count(); k++)
+	{
+		for (i = 0; i < g_sequence[k].numiklocks; i++)
+		{
+			for (j = 0; j < g_numikchains; j++)
+			{
+				if (stricmp( g_ikchain[j].name, g_sequence[k].iklock[i].name) == 0)
+				{
+					break;
+				}
+			}
+			if (j == g_numikchains)
+			{
+				MdlError("unknown chain '%s' in sequence iklock\n", g_sequence[k].iklock[i].name );
+			}
+
+			g_sequence[k].iklock[i].chain = j;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Process IK links
+//-----------------------------------------------------------------------------
+
+s_ikrule_t *FindPrevIKRule( s_animation_t *panim, int iRule )
+{
+	int i, j;
+
+	s_ikrule_t *pRule = &panim->ikrule[iRule];
+
+	for (i = 1; i < panim->numikrules; i++)
+	{
+		j =  ( iRule - i + panim->numikrules) % panim->numikrules;
+		if (panim->ikrule[j].chain == pRule->chain)
+			return &panim->ikrule[j];
+	}
+	return pRule;
+}
+
+s_ikrule_t *FindNextIKRule( s_animation_t *panim, int iRule )
+{
+	int i, j;
+
+	s_ikrule_t *pRule = &panim->ikrule[iRule];
+
+	for (i = 1; i < panim->numikrules; i++)
+	{
+		j =  (iRule + i ) % panim->numikrules;
+		if (panim->ikrule[j].chain == pRule->chain)
+			return &panim->ikrule[j];
+	}
+	return pRule;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: don't allow bones to change their length if they're predefined.
+//			go through all the animations and reset them, but move anything on an ikchain back to where it was.
+//-----------------------------------------------------------------------------
+static void LockBoneLengths()
+{
+	int i, j, k;
+
+	int n;
+
+	if (!g_bLockBoneLengths)
+		return;
+
+	Vector origLocalPos[MAXSTUDIOBONES];
+
+	// find original lengths
+	for (k = 0; k < g_numbones; k++)
+	{
+		MatrixPosition( g_bonetable[k].rawLocalOriginal, origLocalPos[k] );
+
+		if ( g_verbose )
+		{
+			Vector prev, delta;
+			MatrixPosition( g_bonetable[k].rawLocal, prev );
+			delta = prev - origLocalPos[k];
+			printf("%s - %f %f %f\n", g_bonetable[k].name, delta.x, delta.y, delta.z );
+		}
+	}
+
+	for (i = 0; i < g_numani; i++)
+	{
+		s_animation_t *panim = g_panimation[i];
+
+		if (panim->flags & STUDIO_DELTA)
+			continue;
+
+		for (j = 0; j < panim->numframes; j++)
+		{
+			matrix3x4_t boneToWorldOriginal[MAXSTUDIOBONES];
+			matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+
+			// calc original transformations
+			CalcBoneTransforms( panim, j, boneToWorldOriginal );
+
+			// force bones back to original lengths
+			for (k = 0; k < g_numbones; k++)
+			{
+				if (g_bonetable[k].parent != -1)
+				{
+					//Vector delta = panim->sanim[j][k].pos - origLocalPos[k];
+					//printf("%f %f %f\n", delta.x, delta.y, delta.z );
+					panim->sanim[j][k].pos = origLocalPos[k];
+				}
+			}
+
+			// calc new transformations
+			CalcBoneTransforms( panim, j, boneToWorld );
+
+			for (n = 0; n < g_numikchains; n++)
+			{
+				if (panim->weight[g_ikchain[n].link[2].bone] > 0)
+				{
+					Vector worldPos;
+					MatrixPosition( boneToWorldOriginal[g_ikchain[n].link[2].bone], worldPos );
+
+					Studio_SolveIK(
+						g_ikchain[n].link[0].bone,
+						g_ikchain[n].link[1].bone,
+						g_ikchain[n].link[2].bone,
+						worldPos,
+						boneToWorld );
+
+					solveBone( panim, j, g_ikchain[n].link[0].bone, boneToWorld );  
+					solveBone( panim, j, g_ikchain[n].link[1].bone, boneToWorld );  
+					solveBone( panim, j, g_ikchain[n].link[2].bone, boneToWorld );
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: go through all the IK rules and calculate the animated path the IK'd 
+//			end point moves relative to its IK target.
+//-----------------------------------------------------------------------------
+static void ProcessIKRules( )
+{
+	int i, j, k;
+
+	// copy source animations
+	for (i = 0; i < g_numani; i++)
+	{
+		s_animation_t *panim = g_panimation[i];
+		const char *pAnimationName = g_panimation[i]->animationname;
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, pAnimationName );
+
+		for (j = 0; j < panim->numcmds; j++)
+		{
+			if ( panim->cmds[j].cmd == CMD_IKFIXUP )
+			{
+				fixupIKErrors( panim, panim->cmds[j].u.ikfixup.pRule );
+			}
+
+			if (panim->cmds[j].cmd != CMD_IKRULE)
+				continue;
+
+			if (panim->numikrules >= MAXSTUDIOIKRULES)
+			{
+				MdlError("Too many IK rules in %s (%s)\n", panim->name, panim->filename );
+			}
+			s_ikrule_t *pRule = &panim->ikrule[panim->numikrules++];
+
+			// make a copy of the rule;
+			*pRule = *panim->cmds[j].u.ikrule.pRule;
+		}
+
+		for (j = 0; j < panim->numikrules; j++)
+		{
+			s_ikrule_t *pRule = &panim->ikrule[j];
+
+			if (pRule->start == 0 && pRule->peak == 0 && pRule->tail == 0 && pRule->end == 0)
+			{
+				pRule->tail = panim->numframes - 1;
+				pRule->end = panim->numframes - 1;
+			}
+
+			if (pRule->start != -1 && pRule->peak == -1 && pRule->tail == -1 && pRule->end != -1)
+			{
+				pRule->peak = (pRule->start + pRule->end) / 2;
+				pRule->tail = (pRule->start + pRule->end) / 2;
+			}
+
+			if (pRule->start != -1 && pRule->peak == -1 && pRule->tail != -1)
+			{
+				pRule->peak = (pRule->start + pRule->tail) / 2;
+			}
+
+			if (pRule->peak != -1 && pRule->tail == -1 && pRule->end != -1)
+			{
+				pRule->tail = (pRule->peak + pRule->end) / 2;
+			}
+
+			if (pRule->peak == -1)
+			{
+				pRule->start = 0;
+				pRule->peak = 0;
+			}
+
+			if (pRule->tail == -1)
+			{
+				pRule->tail = panim->numframes - 1;
+				pRule->end = panim->numframes - 1;
+			}
+
+			if (pRule->contact == -1)
+			{
+				pRule->contact = pRule->peak;
+			}
+
+			// huh, make up start and end numbers
+			if (pRule->start == -1)
+			{
+				s_ikrule_t *pPrev = FindPrevIKRule( panim, j );
+
+				if (pPrev->slot == pRule->slot)
+				{
+					if (pRule->peak < pPrev->tail)
+					{
+						pRule->start = pRule->peak + (pPrev->tail - pRule->peak) / 2;
+					}
+					else
+					{
+						pRule->start = pRule->peak + (pPrev->tail - pRule->peak + panim->numframes - 1) / 2;
+					}
+					pRule->start = (pRule->start + panim->numframes / 2) % (panim->numframes - 1);
+					pPrev->end = (pRule->start + panim->numframes - 1) % (panim->numframes - 1);
+				}
+				else
+				{
+					pRule->start = pPrev->tail;
+					pPrev->end = pRule->peak;
+				}
+				// printf("%s : %d (%d) : %d %d %d %d\n", panim->name, pRule->chain, panim->numframes - 1, pRule->start, pRule->peak, pRule->tail, pRule->end );
+			}
+
+			// huh, make up start and end numbers
+			if (pRule->end == -1)
+			{
+				s_ikrule_t *pNext = FindNextIKRule( panim, j );
+
+				if (pNext->slot == pRule->slot)
+				{
+					if (pNext->peak < pRule->tail)
+					{
+						pNext->start = pNext->peak + (pRule->tail - pNext->peak) / 2;
+					}
+					else
+					{
+						pNext->start = pNext->peak + (pRule->tail - pNext->peak + panim->numframes - 1) / 2;
+					}
+					pNext->start = (pNext->start + panim->numframes / 2) % (panim->numframes - 1);
+					pRule->end = (pNext->start + panim->numframes - 1) % (panim->numframes - 1);
+				}
+				else
+				{
+					pNext->start = pRule->tail;
+					pRule->end = pNext->peak;
+				}
+				// printf("%s : %d (%d) : %d %d %d %d\n", panim->name, pRule->chain, panim->numframes - 1, pRule->start, pRule->peak, pRule->tail, pRule->end );
+			}
+
+			// check for wrapping
+			if (pRule->peak < pRule->start)
+			{
+				pRule->peak += panim->numframes - 1;
+			}
+			if (pRule->tail < pRule->peak)
+			{
+				pRule->tail += panim->numframes - 1;
+			}
+			if (pRule->end < pRule->tail)
+			{
+				pRule->end += panim->numframes - 1;
+			}
+			if (pRule->contact < pRule->start)
+			{
+				pRule->contact += panim->numframes - 1;
+			}
+
+			/*
+			printf("%s : %d (%d) : %d %d %d %d : %s\n", panim->name, pRule->chain, panim->numframes - 1, pRule->start, pRule->peak, pRule->tail, pRule->end,
+				pRule->usesequence ? "usesequence" : pRule->usesource ? "source" : "" );
+			*/
+
+			pRule->errorData.numerror = pRule->end - pRule->start + 1;
+			if (pRule->end >= panim->numframes)
+				pRule->errorData.numerror = pRule->errorData.numerror + 2;
+
+			pRule->errorData.pError = (s_streamdata_t *)kalloc( pRule->errorData.numerror, sizeof( s_streamdata_t ));
+
+			int n = 0;
+
+			if (pRule->usesequence)
+			{
+				// FIXME: bah, this is horrendously hacky, add a damn back pointer
+				for (n = 0; n < g_sequence.Count(); n++)
+				{
+					if (g_sequence[n].panim[0][0] == panim)
+						break;
+				}
+			}
+
+			switch( pRule->type )
+			{
+			case IK_SELF:
+				{
+					matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+					matrix3x4_t worldToBone;
+					matrix3x4_t local;
+
+					if (strlen(pRule->bonename) == 0)
+					{
+						pRule->bone = -1;
+					}
+					else
+					{
+
+						pRule->bone = findGlobalBone( pRule->bonename );
+						if (pRule->bone == -1)
+						{
+							MdlError("unknown bone '%s' in ikrule\n", pRule->bonename );
+						}
+					}
+
+					for (k = 0; k < pRule->errorData.numerror; k++)
+					{
+						if (pRule->usesequence)
+						{
+							CalcSeqTransforms( n, k + pRule->start, boneToWorld );
+						}
+						else if (pRule->usesource)
+						{
+							matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+							BuildRawTransforms( panim->source, pAnimationName, k + pRule->start + panim->startframe - pSourceAnim->startframe, panim->scale, panim->adjust, panim->rotation, panim->flags, srcBoneToWorld );
+							TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+						}
+						else 
+						{
+							CalcBoneTransforms( panim, k + pRule->start, boneToWorld );
+						}
+
+
+						if (pRule->bone != -1)
+						{
+							MatrixInvert( boneToWorld[pRule->bone], worldToBone );
+							ConcatTransforms( worldToBone, boneToWorld[g_ikchain[pRule->chain].link[2].bone], local );
+						}
+						else
+						{
+							MatrixCopy( boneToWorld[g_ikchain[pRule->chain].link[2].bone], local );
+						}
+
+						MatrixAngles( local, pRule->errorData.pError[k].q, pRule->errorData.pError[k].pos );
+
+						/*
+						QAngle ang;
+						QuaternionAngles( pRule->errorData.pError[k].q, ang );
+						printf("%d  %.1f %.1f %.1f : %.1f %.1f %.1f\n", 
+							k,
+							pRule->errorData.pError[k].pos.x, pRule->errorData.pError[k].pos.y, pRule->errorData.pError[k].pos.z, 
+							ang.x, ang.y, ang.z );
+						*/
+					}
+				}
+				break;
+			case IK_WORLD:
+				break;
+			case IK_ATTACHMENT:
+				{
+					matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+					matrix3x4_t worldToBone;
+					matrix3x4_t local;
+
+					int bone = g_ikchain[pRule->chain].link[2].bone;
+					CalcBoneTransforms( panim, pRule->contact, boneToWorld );
+					// FIXME: add in motion
+
+					// pRule->pos = footfall;
+					// pRule->q = RadianEuler( 0, 0, 0 );
+
+					if (strlen(pRule->bonename) == 0)
+					{
+						if (pRule->bone != -1)
+						{
+							pRule->bone = bone;
+						}
+					}
+					else
+					{
+						pRule->bone = findGlobalBone( pRule->bonename );
+						if (pRule->bone == -1)
+						{
+							MdlError("unknown bone '%s' in ikrule\n", pRule->bonename );
+						}
+					}
+
+					if (pRule->bone != -1)
+					{
+						// FIXME: look for local bones...
+						CalcBoneTransforms( panim, pRule->contact, boneToWorld );
+						MatrixAngles( boneToWorld[pRule->bone], pRule->q, pRule->pos );
+					}
+
+#if 0
+					printf("%d  %.1f %.1f %.1f\n", 
+						pRule->peak,
+						pRule->pos.x, pRule->pos.y, pRule->pos.z );
+#endif
+
+					for (k = 0; k < pRule->errorData.numerror; k++)
+					{
+						int t = k + pRule->start;
+
+						if (pRule->usesequence)
+						{
+							CalcSeqTransforms( n, t, boneToWorld );
+						}
+						else if (pRule->usesource)
+						{
+							matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+							BuildRawTransforms( panim->source, pAnimationName, t + panim->startframe - pSourceAnim->startframe, srcBoneToWorld );
+							TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+						}
+						else 
+						{
+							CalcBoneTransforms( panim, t, boneToWorld );
+						}
+
+						Vector pos = pRule->pos + calcMovement( panim, t, pRule->contact );
+
+						// printf("%2d : %2d : %4.2f %6.1f %6.1f %6.1f\n", k, t, s, pos.x, pos.y, pos.z );
+
+
+						AngleMatrix( pRule->q, pos, local );
+						MatrixInvert( local, worldToBone );
+
+						// calc position error
+						ConcatTransforms( worldToBone, boneToWorld[bone], local );
+						MatrixAngles( local, pRule->errorData.pError[k].q, pRule->errorData.pError[k].pos );
+
+#if 0
+						QAngle ang;
+						QuaternionAngles( pRule->errorData.pError[k].q, ang );
+						printf("%d  %.1f %.1f %.1f : %.1f %.1f %.1f\n", 
+							k + pRule->start,
+							pRule->errorData.pError[k].pos.x, pRule->errorData.pError[k].pos.y, pRule->errorData.pError[k].pos.z, 
+							ang.x, ang.y, ang.z );
+#endif
+					}
+				}
+				break;
+			case IK_GROUND:
+				{
+					matrix3x4_t boneToWorld[MAXSTUDIOBONES];
+					matrix3x4_t worldToBone;
+					matrix3x4_t local;
+
+					int bone = g_ikchain[pRule->chain].link[2].bone;
+
+					if (pRule->usesequence)
+					{
+						CalcSeqTransforms( n, pRule->contact, boneToWorld );
+					}
+					else if (pRule->usesource)
+					{
+						matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+						BuildRawTransforms( panim->source, pAnimationName, pRule->contact + panim->startframe - pSourceAnim->startframe, panim->scale, panim->adjust, panim->rotation, panim->flags, srcBoneToWorld );
+						TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+					}
+					else 
+					{
+						CalcBoneTransforms( panim, pRule->contact, boneToWorld );
+					}
+
+					// FIXME: add in motion
+
+					Vector footfall;
+					VectorTransform( g_ikchain[pRule->chain].center, boneToWorld[bone], footfall );
+					footfall.z = pRule->floor;
+
+					AngleMatrix( RadianEuler( 0, 0, 0 ), footfall, local );
+					MatrixInvert( local, worldToBone );
+
+					pRule->pos = footfall;
+					pRule->q = RadianEuler( 0, 0, 0 );
+					
+#if 0
+					printf("%d  %.1f %.1f %.1f\n", 
+						pRule->peak,
+						pRule->pos.x, pRule->pos.y, pRule->pos.z );
+#endif
+
+					float s;
+					for (k = 0; k < pRule->errorData.numerror; k++)
+					{
+						int t = k + pRule->start;
+						/*
+						if (t > pRule->end)
+						{
+							t = t - (panim->numframes - 1);
+						}
+						*/
+
+						if (pRule->usesequence)
+						{
+							CalcSeqTransforms( n, t, boneToWorld );
+						}
+						else if (pRule->usesource)
+						{
+							matrix3x4_t srcBoneToWorld[MAXSTUDIOSRCBONES];
+							BuildRawTransforms( panim->source, pAnimationName, pRule->contact + panim->startframe - pSourceAnim->startframe, panim->scale, panim->adjust, panim->rotation, panim->flags, srcBoneToWorld );
+							TranslateAnimations( panim->source, srcBoneToWorld, boneToWorld );
+						}
+						else 
+						{
+							CalcBoneTransforms( panim, t, boneToWorld );
+						}
+						Vector pos = pRule->pos + calcMovement( panim, t, pRule->contact );
+						s = 0.0;
+
+						Vector cur;
+						VectorTransform( g_ikchain[pRule->chain].center, boneToWorld[bone], cur );
+						cur.z = pos.z;
+
+						if (t < pRule->start || t >= pRule->end)
+						{
+							// s = (float)(t - pRule->start) / (pRule->peak - pRule->start);
+							// pos = startPos * (1 - s) + pos * s;
+							pos = cur;
+						}
+						else if (t < pRule->peak)
+						{
+							s = (float)(pRule->peak - t) / (pRule->peak - pRule->start);
+							s = 3 * s * s - 2 * s * s * s;
+							pos = pos * (1 - s) + cur * s;
+						}
+						else if (t > pRule->tail)
+						{
+							s = (float)(t - pRule->tail) / (pRule->end - pRule->tail);
+							s = 3 * s * s - 2 * s * s * s;
+							pos = pos * (1 - s) + cur * s;
+							//pos = endPos - calcMovement( panim, t, pRule->tail );
+						}
+
+						//MatrixPosition( boneToWorld[bone], pos );
+						//pos.z = pRule->floor;
+
+						// printf("%2d : %2d : %4.2f %6.1f %6.1f %6.1f\n", k, t, s, pos.x, pos.y, pos.z );
+
+
+						AngleMatrix( pRule->q, pos, local );
+						MatrixInvert( local, worldToBone );
+
+						// calc position error
+						ConcatTransforms( worldToBone, boneToWorld[bone], local );
+						MatrixAngles( local, pRule->errorData.pError[k].q, pRule->errorData.pError[k].pos );
+
+#if 0
+						QAngle ang;
+						QuaternionAngles( pRule->errorData.pError[k].q, ang );
+						printf("%d  %.1f %.1f %.1f : %.1f %.1f %.1f\n", 
+							k + pRule->start,
+							pRule->errorData.pError[k].pos.x, pRule->errorData.pError[k].pos.y, pRule->errorData.pError[k].pos.z, 
+							ang.x, ang.y, ang.z );
+#endif
+					}
+				}
+				break;
+			case IK_RELEASE:
+			case IK_UNLATCH:
+				break;
+			}
+		}
+
+		if ((panim->flags & STUDIO_DELTA) || panim->noAutoIK)
+			continue;
+
+		// auto release ik chains that are moved but not referenced and have no explicit rules
+		int count[16];
+
+		for (j = 0; j < g_numikchains; j++)
+		{
+			count[j] = 0;
+		}
+
+		for (j = 0; j < panim->numikrules; j++)
+		{
+			count[panim->ikrule[j].chain]++;
+		}
+
+		for (j = 0; j < g_numikchains; j++)
+		{
+			if (count[j] == 0 && panim->weight[g_ikchain[j].link[2].bone] > 0.0)
+			{
+				// printf("%s - %s\n", panim->name, g_ikchain[j].name );
+				k = panim->numikrules++;
+				panim->ikrule[k].chain = j;
+				panim->ikrule[k].slot = j;
+				panim->ikrule[k].type = IK_RELEASE;
+				panim->ikrule[k].start = 0;
+				panim->ikrule[k].peak = 0;
+				panim->ikrule[k].tail = panim->numframes - 1;
+				panim->ikrule[k].end = panim->numframes - 1;
+			}
+		}
+	}
+	// exit(0);
+
+
+	// realign IK across multiple animations
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		for (j = 0; j < g_sequence[i].groupsize[0]; j++)
+		{
+			for (k = 0; k < g_sequence[i].groupsize[1]; k++)
+			{
+				g_sequence[i].numikrules = max( g_sequence[i].numikrules, g_sequence[i].panim[j][k]->numikrules );
+			}
+		}
+
+		// check for mismatched ik rules
+		s_animation_t *panim1 = g_sequence[i].panim[0][0];
+		for (j = 0; j < g_sequence[i].groupsize[0]; j++)
+		{
+			for (k = 0; k < g_sequence[i].groupsize[1]; k++)
+			{
+				s_animation_t *panim2 = g_sequence[i].panim[j][k];
+				if (panim1->numikrules != panim2->numikrules)
+				{
+					MdlError( "%s - mismatched number of IK rules: \"%s\" \"%s\"\n", 
+						g_sequence[i].name, panim1->name, panim2->name );
+				}
+				for (int n = 0; n < panim1->numikrules; n++)
+				{
+					if ((panim1->ikrule[n].type != panim2->ikrule[n].type) ||
+						(panim1->ikrule[n].chain != panim2->ikrule[n].chain) ||
+						(panim1->ikrule[n].slot != panim2->ikrule[n].slot))
+					{
+						MdlError( "%s - mismatched IK rule %d: \n\"%s\" : %d %d %d\n\"%s\" : %d %d %d\n", 
+							g_sequence[i].name, n, 
+							panim1->name, panim1->ikrule[n].type, panim1->ikrule[n].chain, panim1->ikrule[n].slot,
+							panim2->name, panim2->ikrule[n].type, panim2->ikrule[n].chain, panim2->ikrule[n].slot );
+					}
+				}
+			}
+		}
+
+		// FIXME: this doesn't check alignment!!!
+		for (j = 0; j < g_sequence[i].groupsize[0]; j++)
+		{
+			for (k = 0; k < g_sequence[i].groupsize[1]; k++)
+			{
+				for (int n = 0; n < g_sequence[i].panim[j][k]->numikrules; n++)
+				{
+					g_sequence[i].panim[j][k]->ikrule[n].index = n;
+				}
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// CompressAnimations
+//-----------------------------------------------------------------------------
+
+static void CompressAnimations( )
+{
+	int i, j, k, n, m;
+
+	// find scales for all bones
+	for (j = 0; j < g_numbones; j++)
+	{
+		// printf("%s : ", g_bonetable[j].name );
+		for (k = 0; k < 6; k++)
+		{
+			float minv, maxv, scale;
+			float total_minv, total_maxv;
+
+			if (k < 3) 
+			{
+				minv = -128.0;
+				maxv = 128.0;
+				total_maxv = total_minv = g_bonetable[j].pos[k];
+			}
+			else
+			{
+				minv = -M_PI / 8.0;
+				maxv = M_PI / 8.0;
+				total_maxv = total_minv = g_bonetable[j].rot[k-3];
+			}
+
+			for (i = 0; i < g_numani; i++)
+			{
+				for (n = 0; n < g_panimation[i]->numframes; n++)
+				{
+					float v = 0.0f;
+					switch(k)
+					{
+					case 0: 
+					case 1: 
+					case 2: 
+						if (g_panimation[i]->flags & STUDIO_DELTA)
+						{
+							v = g_panimation[i]->sanim[n][j].pos[k]; 
+						}
+						else
+						{
+							v = ( g_panimation[i]->sanim[n][j].pos[k] - g_bonetable[j].pos[k] ); 
+
+							if (g_panimation[i]->sanim[n][j].pos[k] < total_minv)
+								total_minv = g_panimation[i]->sanim[n][j].pos[k];
+							if (g_panimation[i]->sanim[n][j].pos[k] > total_maxv)
+								total_maxv = g_panimation[i]->sanim[n][j].pos[k];
+						}
+						break;
+					case 3:
+					case 4:
+					case 5:
+						if (g_panimation[i]->flags & STUDIO_DELTA)
+						{
+							v = g_panimation[i]->sanim[n][j].rot[k-3]; 
+						}
+						else
+						{
+							v = ( g_panimation[i]->sanim[n][j].rot[k-3] - g_bonetable[j].rot[k-3] ); 
+						}
+						while (v >= M_PI)
+							v -= M_PI * 2;
+						while (v < -M_PI)
+							v += M_PI * 2;
+						break;
+					}
+					if (v < minv)
+						minv = v;
+					if (v > maxv)
+						maxv = v;
+				}
+			}
+			if (minv < maxv)
+			{
+				if (-minv> maxv)
+				{
+					scale = minv / -32768.0;
+				}
+				else
+				{
+					scale = maxv / 32767;
+				}
+			}
+			else
+			{
+				scale = 1.0 / 32.0;
+			}
+			switch(k)
+			{
+			case 0: 
+			case 1: 
+			case 2: 
+				g_bonetable[j].posscale[k] = scale;
+				g_bonetable[j].posrange[k] = total_maxv - total_minv;
+				break;
+			case 3:
+			case 4:
+			case 5:
+				// printf("(%.1f %.1f)", RAD2DEG(minv), RAD2DEG(maxv) );
+				// printf("(%.1f)", RAD2DEG(maxv-minv) );
+				g_bonetable[j].rotscale[k-3] = scale;
+				break;
+			}
+			// printf("%.0f ", 1.0 / scale );
+		}
+		// printf("\n" );
+	}
+
+
+	// reduce animations
+	for (i = 0; i < g_numani; i++)
+	{
+		s_animation_t *panim = g_panimation[i];
+		s_source_t *psource = panim->source;
+
+		if (g_bCheckLengths)
+		{
+			printf("%s\n", panim->name ); 
+		}
+
+		// setup animation interior sections
+		int iSectionFrames = panim->numframes;
+		if ( panim->numframes >= g_minSectionFrameLimit )
+		{
+			iSectionFrames = g_sectionFrames;
+			panim->sectionframes = g_sectionFrames;
+			panim->numsections = (int)(panim->numframes / panim->sectionframes) + 2;
+		}
+		else
+		{
+			panim->sectionframes = 0;
+			panim->numsections = 1;
+		}
+
+		for (int w = 0; w < panim->numsections; w++)
+		{
+			int iStartFrame = w * iSectionFrames;
+			int iEndFrame = (w + 1) * iSectionFrames;
+
+			iStartFrame = min( iStartFrame, panim->numframes - 1 );
+			iEndFrame = min( iEndFrame, panim->numframes - 1 );
+
+			// printf("%s : %d %d\n", panim->name, iStartFrame, iEndFrame );
+
+			for (j = 0; j < g_numbones; j++)
+			{
+				for (k = 0; k < 6; k++)
+				{
+					panim->anim[w][j].num[k] = 0;
+					panim->anim[w][j].data[k] = NULL;
+				}
+
+				// skip bones that are always procedural
+				if (g_bonetable[j].flags & BONE_ALWAYS_PROCEDURAL)
+				{
+					// panim->weight[j] = 0.0;
+					continue;
+				}
+
+				// skip bones that have no influence
+				if (panim->weight[j] < 0.001)
+					continue;
+
+				float checkmin[6], checkmax[6];
+				for (k = 0; k < 6; k++)
+				{
+					checkmin[k] = 9999;
+					checkmax[k] = -9999;
+				}
+
+				for (k = 0; k < 6; k++)
+				{
+					mstudioanimvalue_t	*pcount, *pvalue;
+					float v;
+					short value[MAXSTUDIOANIMFRAMES];
+					mstudioanimvalue_t data[MAXSTUDIOANIMFRAMES];
+
+					// find deltas from default pose
+					for (n = 0; n <= iEndFrame - iStartFrame; n++)
+					{
+						s_bone_t *psrcdata = &panim->sanim[n+iStartFrame][j];
+						switch(k)
+						{
+						case 0: /* X Position */
+						case 1: /* Y Position */
+						case 2: /* Z Position */
+							if (panim->flags & STUDIO_DELTA)
+							{
+								value[n] = psrcdata->pos[k] / g_bonetable[j].posscale[k]; 
+								// pre-scale pos delta since format only has room for "overall" weight
+								float r = panim->posweight[j] / panim->weight[j];
+								value[n] *= r;
+							}
+							else
+							{
+								value[n] = ( psrcdata->pos[k] - g_bonetable[j].pos[k] ) / g_bonetable[j].posscale[k]; 
+							}
+
+							checkmin[k] = min( value[n] * g_bonetable[j].posscale[k], checkmin[k] );
+							checkmax[k] = max( value[n] * g_bonetable[j].posscale[k], checkmax[k] );
+							break;
+						case 3: /* X Rotation */
+						case 4: /* Y Rotation */
+						case 5: /* Z Rotation */
+							if (panim->flags & STUDIO_DELTA)
+							{
+								v = psrcdata->rot[k-3]; 
+							}
+							else
+							{
+								v = ( psrcdata->rot[k-3] - g_bonetable[j].rot[k-3] ); 
+							}
+
+							while (v >= M_PI)
+								v -= M_PI * 2;
+							while (v < -M_PI)
+								v += M_PI * 2;
+
+							checkmin[k] = min( v, checkmin[k] );
+							checkmax[k] = max( v, checkmax[k] );
+							value[n] = v / g_bonetable[j].rotscale[k-3]; 
+							break;
+						}
+					}
+					if (n == 0)
+						MdlError("no animation frames: \"%s\"\n", psource->filename );
+
+					// FIXME: this compression algorithm needs work
+
+					// initialize animation RLE block
+					memset( data, 0, sizeof( data ) ); 
+					pcount = data; 
+					pvalue = pcount + 1;
+
+					pcount->num.valid = 1;
+					pcount->num.total = 1;
+					pvalue->value = value[0];
+					pvalue++;
+
+					// build a RLE of deltas from the default pose
+					for (m = 1; m < n; m++)
+					{
+						if (pcount->num.total == 255)
+						{
+							// chain too long, force a new entry
+							pcount = pvalue;
+							pvalue = pcount + 1;
+							pcount->num.valid++;
+							pvalue->value = value[m];
+							pvalue++;
+						} 
+						// insert value if they're not equal, 
+						// or if we're not on a run and the run is less than 3 units
+						else if ((value[m] != value[m-1]) 
+							|| ((pcount->num.total == pcount->num.valid) && ((m < n - 1) && value[m] != value[m+1])))
+						{
+							if (pcount->num.total != pcount->num.valid)
+							{
+								//if (j == 0) printf("%d:%d   ", pcount->num.valid, pcount->num.total ); 
+								pcount = pvalue;
+								pvalue = pcount + 1;
+							}
+							pcount->num.valid++;
+							pvalue->value = value[m];
+							pvalue++;
+						}
+						pcount->num.total++;
+					}
+					//if (j == 0) printf("%d:%d\n", pcount->num.valid, pcount->num.total ); 
+
+					panim->anim[w][j].num[k] = pvalue - data;
+					if (panim->anim[w][j].num[k] == 2 && value[0] == 0)
+					{
+						panim->anim[w][j].num[k] = 0;
+					}
+					else
+					{
+						panim->anim[w][j].data[k] = (mstudioanimvalue_t *)kalloc( pvalue - data, sizeof( mstudioanimvalue_t ) );
+						memmove( panim->anim[w][j].data[k], data, (pvalue - data) * sizeof( mstudioanimvalue_t ) );
+					}
+					// printf("%d(%d) ", g_source[i]->panim[q]->numanim[j][k], n );
+				}
+
+				if (g_bCheckLengths)
+				{
+					char *tmp[6] = { "X", "Y", "Z", "XR", "YR", "ZR" };
+					n = 0;
+					for (k = 0; k < 3; k++)
+					{
+						if (checkmin[k] != 0)
+						{
+							if (n == 0)
+								printf("%s :", g_bonetable[j].name );
+						
+							printf("%s(%.1f: %.1f %.1f) ", tmp[k], g_bonetable[j].pos[k], checkmin[k], checkmax[k] );
+							n = 1;
+						}
+					}
+					if (n)
+						printf("\n");
+				}
+			}
+		}
+
+		if (panim->numsections == 1)
+		{
+			panim->sectionframes = 0;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Compress a single animation stream
+//-----------------------------------------------------------------------------
+
+static void CompressSingle( s_animationstream_t *pStream )
+{
+	int k, n, m;
+
+	if (pStream->numerror == 0)
+		return;
+
+	// printf("%s : ", g_bonetable[j].name );
+	for (k = 0; k < 6; k++)
+	{
+		float minv, maxv, scale;
+		RadianEuler ang;
+
+		if (k < 3) 
+		{
+			minv = -128.0;
+			maxv = 128.0;
+		}
+		else
+		{
+			minv = -M_PI / 8.0;
+			maxv = M_PI / 8.0;
+		}
+
+		for (n = 0; n < pStream->numerror; n++)
+		{
+			float v = 0.0f;
+			switch(k)
+			{
+			case 0: 
+			case 1: 
+			case 2: 
+				v = pStream->pError[n].pos[k];
+				break;
+			case 3:
+			case 4:
+			case 5:
+				QuaternionAngles( pStream->pError[n].q, ang );
+				v = ang[k-3];
+				while (v >= M_PI)
+					v -= M_PI * 2;
+				while (v < -M_PI)
+					v += M_PI * 2;
+				break;
+			}
+			if (v < minv)
+				minv = v;
+			if (v > maxv)
+				maxv = v;
+		}
+		// printf("%f %f\n", minv, maxv );
+		if (minv < maxv)
+		{
+			if (-minv> maxv)
+			{
+				scale = minv / -32768.0;
+			}
+			else
+			{
+				scale = maxv / 32767;
+			}
+		}
+		else
+		{
+			scale = 1.0 / 32.0;
+		}
+
+		pStream->scale[k] = scale;
+		
+		mstudioanimvalue_t	*pcount, *pvalue;
+		float v;
+		short value[MAXSTUDIOANIMFRAMES];
+		mstudioanimvalue_t data[MAXSTUDIOANIMFRAMES];
+
+		// find deltas from default pose
+		for (n = 0; n < pStream->numerror; n++)
+		{
+			switch(k)
+			{
+			case 0: /* X Position */
+			case 1: /* Y Position */
+			case 2: /* Z Position */
+				value[n] = pStream->pError[n].pos[k] / pStream->scale[k]; 
+				break;
+			case 3: /* X Rotation */
+			case 4: /* Y Rotation */
+			case 5: /* Z Rotation */
+				QuaternionAngles( pStream->pError[n].q, ang );
+				v = ang[k-3];
+				while (v >= M_PI)
+					v -= M_PI * 2;
+				while (v < -M_PI)
+					v += M_PI * 2;
+				value[n] = v / pStream->scale[k];
+				break;
+			}
+		}
+
+		// initialize animation RLE block
+		pStream->numanim[k] = 0;
+
+		memset( data, 0, sizeof( data ) ); 
+		pcount = data; 
+		pvalue = pcount + 1;
+
+		pcount->num.valid = 1;
+		pcount->num.total = 1;
+		pvalue->value = value[0];
+		pvalue++;
+
+		// build a RLE of deltas from the default pose
+		for (m = 1; m < n; m++)
+		{
+			if (pcount->num.total == 255)
+			{
+				// chain too long, force a new entry
+				pcount = pvalue;
+				pvalue = pcount + 1;
+				pcount->num.valid++;
+				pvalue->value = value[m];
+				pvalue++;
+			} 
+			// insert value if they're not equal, 
+			// or if we're not on a run and the run is less than 3 units
+			else if ((value[m] != value[m-1]) 
+				|| ((pcount->num.total == pcount->num.valid) && ((m < n - 1) && value[m] != value[m+1])))
+			{
+				if (pcount->num.total != pcount->num.valid)
+				{
+					//if (j == 0) printf("%d:%d   ", pcount->num.valid, pcount->num.total ); 
+					pcount = pvalue;
+					pvalue = pcount + 1;
+				}
+				pcount->num.valid++;
+				pvalue->value = value[m];
+				pvalue++;
+			}
+			pcount->num.total++;
+		}
+		//if (j == 0) printf("%d:%d\n", pcount->num.valid, pcount->num.total ); 
+
+		pStream->numanim[k] = pvalue - data;
+		pStream->anim[k] = (mstudioanimvalue_t *)kalloc( pvalue - data, sizeof( mstudioanimvalue_t ) );
+		memmove( pStream->anim[k], data, (pvalue - data) * sizeof( mstudioanimvalue_t ) );
+		// printf("%d (%d) : %d\n", pRule->numanim[k], n, pRule->errorData.numerror );
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Compress all the IK data
+//-----------------------------------------------------------------------------
+
+static void CompressIKErrors( )
+{
+	int i, j;
+
+	// find scales for all bones
+	for (i = 0; i < g_numani; i++)
+	{
+		for (j = 0; j < g_panimation[i]->numikrules; j++)
+		{
+			s_ikrule_t *pRule = &g_panimation[i]->ikrule[j];
+
+			if (pRule->errorData.numerror == 0)
+				continue;
+
+			CompressSingle( &pRule->errorData );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Compress all the Local Hierarchy data
+//-----------------------------------------------------------------------------
+
+static void CompressLocalHierarchy( )
+{
+	int i, j;
+
+	// find scales for all bones
+	for (i = 0; i < g_numani; i++)
+	{
+		for (j = 0; j < g_panimation[i]->numlocalhierarchy; j++)
+		{
+			s_localhierarchy_t *pRule = &g_panimation[i]->localhierarchy[j];
+
+			if (pRule->localData.numerror == 0)
+				continue;
+
+			CompressSingle( &pRule->localData );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+struct BonePriority_s
+{
+	int m_nGlobalBoneId;
+	float m_nGlobalBoneWeight;
+};
+
+
+//-----------------------------------------------------------------------------
+// Sort by bone weight
+//-----------------------------------------------------------------------------
+int compareBonePriority( const void *a, const void *b )
+{
+	return
+		reinterpret_cast< const BonePriority_s * >( a )->m_nGlobalBoneWeight < reinterpret_cast< const BonePriority_s * >( b )->m_nGlobalBoneWeight ? -1 : 
+		reinterpret_cast< const BonePriority_s * >( a )->m_nGlobalBoneWeight > reinterpret_cast< const BonePriority_s * >( b )->m_nGlobalBoneWeight ?  1 : 0;
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Dump A $definebone line, ensuring any parents are already dumped
+//-----------------------------------------------------------------------------
+void DumpDefineBone( int nBoneId, bool *pBoneDumpedList )
+{
+	Assert( nBoneId < g_numbones );
+
+	if ( pBoneDumpedList[ nBoneId ] )
+		return;
+
+	const s_bonetable_t &bone = g_bonetable[ nBoneId ];
+
+	// Ensure the parent bone is dumped before the child
+	if ( bone.parent >= 0 )
+	{
+		DumpDefineBone( bone.parent, pBoneDumpedList );
+	}
+
+	printf( "$definebone " );
+
+	printf( "\"%s\" ", bone.name );
+	if ( bone.parent != -1 )
+	{
+		printf( "\"%s\" ", g_bonetable[ bone.parent ].name );
+	}
+	else
+	{
+		printf( "\"\" " );
+	}
+
+	Vector pos;
+	QAngle angles;
+
+	pos = bone.pos;
+	angles.Init( RAD2DEG( bone.rot.y ), RAD2DEG( bone.rot.z ), RAD2DEG( bone.rot.x ) );
+	printf( "%f %f %f %f %f %f", pos.x, pos.y, pos.z, angles.x, angles.y, angles.z );
+
+	MatrixAngles( bone.srcRealign, angles, pos );
+	printf( " %f %f %f %f %f %f", pos.x, pos.y, pos.z, angles.x, angles.y, angles.z );
+
+	printf( "\n" );
+
+	pBoneDumpedList[ nBoneId ] = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Dump a $definebones .qci file with the bones in an optimal order
+// i.e. Bones that are removed or replaced in LODs are later in the list
+//      bones that are used all of the time are at the top of the list
+//-----------------------------------------------------------------------------
+void DumpDefineBones()
+{
+	BonePriority_s *pBonePriorityList = reinterpret_cast< BonePriority_s * >( stackalloc( g_numbones * sizeof( BonePriority_s ) ) );
+
+	for ( int i = 0; i < g_numbones; ++i )
+	{
+		BonePriority_s &bonePriority = pBonePriorityList[ i ];
+		bonePriority.m_nGlobalBoneId = i;
+		bonePriority.m_nGlobalBoneWeight = 0.0f;
+	}
+
+	for ( int i = 0; i < g_ScriptLODs.Count(); ++i )
+	{
+		const LodScriptData_t &scriptLOD = g_ScriptLODs[ i ];
+
+		for ( int j = 0; j < scriptLOD.boneReplacements.Count(); ++j )
+		{
+			// Ignore Shadow LOD
+			if ( scriptLOD.switchValue <= 0.0f )
+				continue;
+
+			const int nBoneId = findGlobalBone( scriptLOD.boneReplacements[ j ].GetSrcName() );
+			if ( nBoneId < 0 )
+			{
+				Warning( "Can't Find BoneReplacement Bone %s\n", scriptLOD.boneReplacements[ j ].GetSrcName() );
+				continue;
+			}
+
+			pBonePriorityList[ nBoneId ].m_nGlobalBoneWeight += scriptLOD.switchValue;
+		}
+	}
+
+	// bones used by hitboxes and attachments should always go first since they're used by the server
+	for ( int i = 0; i < g_numbones; ++i )
+	{
+		if ( g_bonetable[i].flags & (BONE_USED_BY_HITBOX | BONE_USED_BY_ATTACHMENT | BONE_USED_BY_BONE_MERGE ))
+		{
+			pBonePriorityList[ i ].m_nGlobalBoneWeight = -1.0f;
+		}
+	}
+
+	qsort( pBonePriorityList, g_numbones, sizeof( BonePriority_s ), compareBonePriority );
+
+	bool *pBoneDumpedList = reinterpret_cast< bool * >( stackalloc( g_numbones * sizeof( bool ) ) );
+	memset( pBoneDumpedList, 0, g_numbones * sizeof( bool ) );
+
+	for (int i = 0; i < g_numbones; i++)
+	{
+		const BonePriority_s &bonePriority = pBonePriorityList[ i ];
+		const int nBoneId = bonePriority.m_nGlobalBoneId;
+
+		if (g_bonetable[ nBoneId ].flags & BONE_ALWAYS_PROCEDURAL)
+		{
+			pBoneDumpedList[ nBoneId ] = true;
+			continue;
+		}
+
+		DumpDefineBone( nBoneId, pBoneDumpedList );
+	}
+}
+
+
+void ReLinkAttachments()
+{
+	int	i;
+	int	j;
+	int	k;
+
+	// relink per-model attachments, eyeballs
+	for (i = 0; i < g_nummodelsbeforeLOD; i++)
+	{
+		s_source_t *psource = g_model[i]->source;
+		for (j = 0; j < g_model[i]->numattachments; j++)
+		{
+			k = findGlobalBone( g_model[i]->attachment[j].bonename );
+			if (k == -1)
+			{
+				MdlError("unknown model attachment link '%s'\n", g_model[i]->attachment[j].bonename );
+			}
+			g_model[i]->attachment[j].bone = j;
+		}
+
+		for (j = 0; j < g_model[i]->numeyeballs; j++)
+		{
+			g_model[i]->eyeball[j].bone = psource->boneLocalToGlobal[g_model[i]->eyeball[j].bone];
+		}
+	}
+}
+
+void CheckEyeballSetup()
+{
+
+	for (int i = 0; i < g_nummodelsbeforeLOD; i++)
+	{
+		for (int j = 0; j < g_model[i]->numeyeballs; j++)
+		{
+			s_eyeball_t *peyeball = &g_model[i]->eyeball[j];
+			if (peyeball->upperlidflexdesc == -1)
+			{
+//				MdlWarning( "eyeball %s missing upperlid data\n", peyeball->name );
+
+				int dummy = Add_Flexdesc( "dummy_eyelid" );
+
+				peyeball->upperlidflexdesc = dummy;
+				peyeball->upperflexdesc[0] = dummy;
+				peyeball->uppertarget[0] = -1;
+				peyeball->upperflexdesc[1] = dummy;
+				peyeball->uppertarget[1] = 0;
+				peyeball->upperflexdesc[2] = dummy;
+				peyeball->uppertarget[2] = 1;
+			}
+
+			if (peyeball->lowerlidflexdesc == -1)
+			{
+//				MdlWarning( "eyeball %s missing lower data\n", peyeball->name );
+
+				int dummy = Add_Flexdesc( "dummy_eyelid" );
+
+				peyeball->lowerlidflexdesc = dummy;
+				peyeball->lowerflexdesc[0] = dummy;
+				peyeball->lowertarget[0] = -1;
+				peyeball->lowerflexdesc[1] = dummy;
+				peyeball->lowertarget[1] = 0;
+				peyeball->lowerflexdesc[2] = dummy;
+				peyeball->lowertarget[2] = 1;
+			}
+		}
+	}
+
+
+}
+
+void SetupHitBoxes()
+{
+	int i;
+	int	j;
+	int	k;
+	int	n;
+
+	// set hitgroups
+	for (k = 0; k < g_numbones; k++)
+	{
+		g_bonetable[k].group = -9999;
+	}
+	for (j = 0; j < g_numhitgroups; j++)
+	{
+		k = findGlobalBone( g_hitgroup[j].name );
+		if (k != -1)
+		{
+			g_bonetable[k].group = g_hitgroup[j].group;
+		}
+		else
+		{
+			MdlError( "cannot find bone %s for hitgroup %d\n", g_hitgroup[j].name, g_hitgroup[j].group );
+		}
+	}
+	for (k = 0; k < g_numbones; k++)
+	{
+		if (g_bonetable[k].group == -9999)
+		{
+			if (g_bonetable[k].parent != -1)
+				g_bonetable[k].group = g_bonetable[g_bonetable[k].parent].group;
+			else
+				g_bonetable[k].group = 0;
+		}
+	}
+
+	if ( g_hitboxsets.Size() == 0 )
+	{
+		int index = g_hitboxsets.AddToTail();
+
+		s_hitboxset *set = &g_hitboxsets[ index ];
+		memset( set, 0, sizeof( *set) );
+		strcpy( set->hitboxsetname, "default" );
+
+		gflags |= STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX;
+
+		// find intersection box volume for each bone
+		for (k = 0; k < g_numbones; k++)
+		{
+			for (j = 0; j < 3; j++)
+			{
+				if (g_bUseBoneInBBox)
+				{
+					g_bonetable[k].bmin[j] = 0.0;
+					g_bonetable[k].bmax[j] = 0.0;
+				}
+				else
+				{
+					g_bonetable[k].bmin[j] = 9999.0;
+					g_bonetable[k].bmax[j] = -9999.0;
+				}
+			}
+		}
+		// try all the connect vertices
+		for (i = 0; i < g_nummodelsbeforeLOD; i++)
+		{
+			s_loddata_t *pLodData = g_model[i]->m_pLodData;
+			if ( !pLodData )
+				continue;
+
+			Vector	p;
+			for (j = 0; j < pLodData->numvertices; j++)
+			{
+				for (n = 0; n < pLodData->vertex[j].boneweight.numbones; n++)
+				{
+					k = pLodData->vertex[j].boneweight.bone[n];
+					VectorITransform( pLodData->vertex[j].position, g_bonetable[k].boneToPose, p );
+
+					if (p[0] < g_bonetable[k].bmin[0]) g_bonetable[k].bmin[0] = p[0];
+					if (p[1] < g_bonetable[k].bmin[1]) g_bonetable[k].bmin[1] = p[1];
+					if (p[2] < g_bonetable[k].bmin[2]) g_bonetable[k].bmin[2] = p[2];
+					if (p[0] > g_bonetable[k].bmax[0]) g_bonetable[k].bmax[0] = p[0];
+					if (p[1] > g_bonetable[k].bmax[1]) g_bonetable[k].bmax[1] = p[1];
+					if (p[2] > g_bonetable[k].bmax[2]) g_bonetable[k].bmax[2] = p[2];
+				}
+			}
+		}
+		// add in all your children as well
+		for (k = 0; k < g_numbones; k++)
+		{
+			if ((j = g_bonetable[k].parent) != -1)
+			{
+				if (g_bonetable[k].pos[0] < g_bonetable[j].bmin[0]) g_bonetable[j].bmin[0] = g_bonetable[k].pos[0];
+				if (g_bonetable[k].pos[1] < g_bonetable[j].bmin[1]) g_bonetable[j].bmin[1] = g_bonetable[k].pos[1];
+				if (g_bonetable[k].pos[2] < g_bonetable[j].bmin[2]) g_bonetable[j].bmin[2] = g_bonetable[k].pos[2];
+				if (g_bonetable[k].pos[0] > g_bonetable[j].bmax[0]) g_bonetable[j].bmax[0] = g_bonetable[k].pos[0];
+				if (g_bonetable[k].pos[1] > g_bonetable[j].bmax[1]) g_bonetable[j].bmax[1] = g_bonetable[k].pos[1];
+				if (g_bonetable[k].pos[2] > g_bonetable[j].bmax[2]) g_bonetable[j].bmax[2] = g_bonetable[k].pos[2];
+			}
+		}
+
+		for (k = 0; k < g_numbones; k++)
+		{
+			if (g_bonetable[k].bmin[0] < g_bonetable[k].bmax[0] - 1
+				&& g_bonetable[k].bmin[1] < g_bonetable[k].bmax[1] - 1
+				&& g_bonetable[k].bmin[2] < g_bonetable[k].bmax[2] - 1)
+			{
+				set->hitbox[set->numhitboxes].bone = k;
+				set->hitbox[set->numhitboxes].group = g_bonetable[k].group;
+				VectorCopy( g_bonetable[k].bmin, set->hitbox[set->numhitboxes].bmin );
+				VectorCopy( g_bonetable[k].bmax, set->hitbox[set->numhitboxes].bmax );
+
+				if (dump_hboxes)
+				{
+					printf("$hbox %d \"%s\" %.2f %.2f %.2f  %.2f %.2f %.2f\n",
+						set->hitbox[set->numhitboxes].group,
+						g_bonetable[set->hitbox[set->numhitboxes].bone].name, 
+						set->hitbox[set->numhitboxes].bmin[0], set->hitbox[set->numhitboxes].bmin[1], set->hitbox[set->numhitboxes].bmin[2],
+						set->hitbox[set->numhitboxes].bmax[0], set->hitbox[set->numhitboxes].bmax[1], set->hitbox[set->numhitboxes].bmax[2] );
+
+				}
+				set->numhitboxes++;
+			}
+		}
+	}
+	else
+	{
+		gflags &= ~STUDIOHDR_FLAGS_AUTOGENERATED_HITBOX;
+
+		for (int s = 0; s < g_hitboxsets.Size(); s++ )
+		{
+			s_hitboxset *set = &g_hitboxsets[ s ];
+
+			for (j = 0; j < set->numhitboxes; j++)
+			{
+				k = findGlobalBone( set->hitbox[j].name );
+				if (k != -1)
+				{
+					set->hitbox[j].bone = k;
+				}
+				else
+				{
+					MdlError( "cannot find bone %s for bbox\n", set->hitbox[j].name );
+				}
+			}
+		}
+	}
+
+	for (int s = 0; s < g_hitboxsets.Size(); s++ )
+	{
+		s_hitboxset *set = &g_hitboxsets[ s ];
+
+		// flag all bones used by hitboxes
+		for (j = 0; j < set->numhitboxes; j++)
+		{
+			k = set->hitbox[j].bone;
+			while (k != -1)
+			{
+				g_bonetable[k].flags |= BONE_USED_BY_HITBOX;
+				k = g_bonetable[k].parent;
+			}
+		}
+	}
+}
+
+void SetupFullBoneRenderBounds( CUtlVector<CBoneRenderBounds> &boneRenderBounds )
+{
+	boneRenderBounds.SetSize( g_numbones );
+
+
+	// First, add the ones already calculated from vertices.
+	for ( int i=0; i < g_numbones; i++ )
+	{
+		CBoneRenderBounds *pOut = &boneRenderBounds[i];
+		pOut->m_Mins = g_bonetable[i].bmin;
+		pOut->m_Maxs = g_bonetable[i].bmax;
+	}
+
+	// Note: shared animation files will need to include the hitboxes or else their sequence
+	// boxes won't use this stuff.
+	// Now add hitboxes.
+	for ( int i=0; i < g_hitboxsets.Count(); i++ )
+	{
+		const s_hitboxset *pSet = &g_hitboxsets[i];
+		
+		for ( int k=0; k < pSet->numhitboxes; k++ )
+		{
+			const s_bbox_t *pIn = &pSet->hitbox[k];
+
+			if ( pIn->bone >= 0 )
+			{
+				CBoneRenderBounds *pOut = &boneRenderBounds[pIn->bone];
+				VectorMin( pIn->bmin, pOut->m_Mins, pOut->m_Mins );
+				VectorMax( pIn->bmax, pOut->m_Maxs, pOut->m_Maxs );
+			}
+		}
+	}
+}
+
+
+void CalcSequenceBoundingBoxes()
+{
+	int i;
+	int	j;
+	int	k;
+	int	n;
+	int	m;
+
+	CUtlVector<CBoneRenderBounds> boneRenderBounds;
+	SetupFullBoneRenderBounds( boneRenderBounds );
+
+	// find bounding box for each g_sequence
+	for (i = 0; i < g_numani; i++)
+	{
+		Vector bmin, bmax;
+		
+		// find intersection box volume for each bone
+		for (j = 0; j < 3; j++)
+		{
+			bmin[j] = 9999.0;
+			bmax[j] = -9999.0;
+		}
+
+		for (j = 0; j < g_panimation[i]->numframes; j++)
+		{
+			matrix3x4_t bonetransform[MAXSTUDIOBONES];	// bone transformation matrix
+			matrix3x4_t posetransform[MAXSTUDIOBONES];	// bone transformation matrix
+			matrix3x4_t bonematrix;						// local transformation matrix
+			Vector pos;
+
+			CalcBoneTransforms( g_panimation[i], j, bonetransform );
+
+			for (k = 0; k < g_numbones; k++)
+			{
+				MatrixInvert( g_bonetable[k].boneToPose, bonematrix );
+				ConcatTransforms (bonetransform[k], bonematrix, posetransform[k]);
+			}
+
+			// include hitboxes as well.
+			for (k = 0; k < g_numbones; k++)
+			{
+				Vector tmpMin, tmpMax;
+				TransformAABB( bonetransform[k], boneRenderBounds[k].m_Mins, boneRenderBounds[k].m_Maxs, tmpMin, tmpMax );
+				VectorMin( tmpMin, bmin, bmin );
+				VectorMax( tmpMax, bmax, bmax );
+			}
+
+			// include vertices
+			for (k = 0; k < g_nummodelsbeforeLOD; k++)
+			{
+				s_loddata_t *pLodData = g_model[k]->m_pLodData;
+
+				// skip blank empty model
+				if ( !pLodData )
+					continue;
+
+				for (n = 0; n < pLodData->numvertices; n++)
+				{
+					Vector tmp;
+					pos = Vector( 0, 0, 0 );
+					for (m = 0; m < pLodData->vertex[n].boneweight.numbones; m++)
+					{
+						VectorTransform( pLodData->vertex[n].position, posetransform[pLodData->vertex[n].boneweight.bone[m]], tmp ); // bug: should use all bones!
+						VectorMA( pos, pLodData->vertex[n].boneweight.weight[m], tmp, pos );
+					}
+
+					VectorMin( pos, bmin, bmin );
+					VectorMax( pos, bmax, bmax );
+				}
+			}
+		}
+
+		if (bmin.x < g_vecMinWorldspace.x || bmin.y < g_vecMinWorldspace.y || bmin.z < g_vecMinWorldspace.z || bmax.x > g_vecMaxWorldspace.x || bmax.y > g_vecMaxWorldspace.y || bmax.z > g_vecMaxWorldspace.z)
+		{
+			MdlWarning("%s : bounding box out of range : %.0f %.0f %.0f : %.0f %.0f %.0f\n", 
+				g_panimation[i]->name, 
+				bmin.x, bmin.y, bmin.z, bmax.z, bmax.y, bmax.z );
+
+			VectorMax( bmin, g_vecMinWorldspace, bmin );
+			VectorMin( bmax, g_vecMaxWorldspace, bmax );
+		}
+
+		VectorCopy( bmin, g_panimation[i]->bmin );
+		VectorCopy( bmax, g_panimation[i]->bmax );
+
+		/*
+		printf("%s : %.0f %.0f %.0f %.0f %.0f %.0f\n", 
+			g_panimation[i]->name, bmin[0], bmax[0], bmin[1], bmax[1], bmin[2], bmax[2] );
+		*/
+
+		// printf("%s  %.2f\n", g_sequence[i].name, g_sequence[i].panim[0]->pos[9][0][0] / g_bonetable[9].pos[0] );
+	}
+
+	for (i = 0; i < g_sequence.Count(); i++)
+	{
+		Vector bmin, bmax;
+		
+		// find intersection box volume for each bone
+		for (j = 0; j < 3; j++)
+		{
+			bmin[j] = 9999.0;
+			bmax[j] = -9999.0;
+		}
+
+		for (j = 0; j < g_sequence[i].groupsize[0]; j++)
+		{
+			for (k = 0; k < g_sequence[i].groupsize[1]; k++)
+			{
+				s_animation_t *panim = g_sequence[i].panim[j][k];
+
+				if (panim->bmin[0] < bmin[0]) bmin[0] = panim->bmin[0];
+				if (panim->bmin[1] < bmin[1]) bmin[1] = panim->bmin[1];
+				if (panim->bmin[2] < bmin[2]) bmin[2] = panim->bmin[2];
+				if (panim->bmax[0] > bmax[0]) bmax[0] = panim->bmax[0];
+				if (panim->bmax[1] > bmax[1]) bmax[1] = panim->bmax[1];
+				if (panim->bmax[2] > bmax[2]) bmax[2] = panim->bmax[2];
+			}
+		}
+
+		VectorCopy( bmin, g_sequence[i].bmin );
+		VectorCopy( bmax, g_sequence[i].bmax );
+	}
+}
+
+void SetIlluminationPosition()
+{
+	// find center of domain
+	if (!illumpositionset)
+	{
+		// Only use the 0th sequence; that should be the idle sequence
+		VectorFill( illumposition, 0 );
+		if (g_sequence.Count() != 0)
+		{
+			VectorAdd( g_sequence[0].bmin, g_sequence[0].bmax, illumposition );
+			illumposition *= 0.5f;
+		}
+		illumpositionset = true;
+	}
+}
+
+void SimplifyModel()
+{
+	if (g_sequence.Count() == 0 && g_numincludemodels == 0)
+	{
+		MdlError( "model has no sequences\n");
+	}
+
+	// have to load the lod sources before remapping bones so that the remap
+	// happens for all LODs.
+	LoadLODSources();
+
+	RemapBones();
+
+	LinkIKChains();
+
+	LinkIKLocks();
+
+	RealignBones();
+
+	ConvertBoneTreeCollapsesToReplaceBones();
+
+	// export bones
+	if (g_definebones)
+	{
+		DumpDefineBones();
+		exit( 0 );
+	}
+
+	// translate:
+	// replacebone "bone0" "bone1"
+	// replacebone "bone1" "bone2"
+	// replacebone "bone2" "bone3"
+	// to:
+	// replacebone "bone0" "bone3"
+	// replacebone "bone1" "bone3"
+	// replacebone "bone2" "bone3"
+	FixupReplacedBones();  
+
+	RemapVerticesToGlobalBones();
+
+	if (g_bCenterBonesOnVerts)
+	{
+		CenterBonesOnVerts();
+	}
+	
+	// remap lods to root, building aggregate final pools
+	// mark bones used by an lod
+	UnifyLODs();
+	
+	if ( g_bPrintBones )
+	{
+		printf( "Hardware bone usage:\n" );
+	}
+	SpewBoneUsageStats();
+
+	MarkParentBoneLODs();
+
+	if ( g_bPrintBones )
+	{
+		printf( "CPU bone usage:\n" );
+	}
+	SpewBoneUsageStats();
+
+	RemapAnimations();
+
+	processAnimations();
+
+	limitBoneRotations();
+
+	limitIKChainLength();
+
+	RemapProceduralBones();
+
+	MakeTransitions();
+	RemapVertexAnimations();
+	RemapVertexAnimationsNewVersion();
+
+	FindAutolayers();
+
+	// link bonecontrollers
+	LinkBoneControllers();
+
+	// link screen aligned bones
+	TagScreenAlignedBones();
+
+	// link attachments
+	LinkAttachments();
+
+	// link mouths
+	LinkMouths();
+
+	// procedural bone needs to propogate its bone usage up its chain
+	// ensures runtime sets up dependent bone hierarchy
+	MarkProceduralBoneChain();
+
+	LockBoneLengths();
+
+	ProcessIKRules();
+
+	CompressIKErrors( );
+
+	CompressLocalHierarchy( );
+
+	CalcPoseParameters();
+
+	ReLinkAttachments();
+
+	CheckEyeballSetup();
+
+	SetupHitBoxes();
+
+	CompressAnimations( );
+
+	CalcSequenceBoundingBoxes();
+
+	SetIlluminationPosition();
+
+	if ( g_bBuildPreview )
+	{
+		gflags |= STUDIOHDR_FLAGS_BUILT_IN_PREVIEW_MODE;
+	}
+}
+
+
+
+
+
diff --git a/utils/studiomdl/studiomdl.cpp b/utils/studiomdl/studiomdl.cpp
new file mode 100644
index 0000000..4441617
--- /dev/null
+++ b/utils/studiomdl/studiomdl.cpp
@@ -0,0 +1,10448 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+
+//
+// studiomdl.c: generates a studio .mdl file from a .qc script
+// models/<scriptname>.mdl.
+//
+
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+#include <windows.h>
+#undef GetCurrentDirectory
+
+#include <Shlwapi.h> // PathCanonicalize
+#pragma comment( lib, "shlwapi" )
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+#include <direct.h>
+#include "istudiorender.h"
+#include "filesystem_tools.h"
+#include "tier2/fileutils.h"
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#define EXTERN
+#include "studio.h"
+#include "studiomdl.h"
+#include "collisionmodel.h"
+#include "optimize.h"
+#include "byteswap.h"
+#include "studiobyteswap.h"
+#include "tier1/strtools.h"
+#include "bspflags.h"
+#include "tier0/icommandline.h"
+#include "utldict.h"
+#include "tier1/utlsortvector.h"
+#include "bitvec.h"
+#include "appframework/appframework.h"
+#include "datamodel/idatamodel.h"
+#include "materialsystem/materialsystem_config.h"
+#include "vstdlib/cvar.h"
+#include "tier1/tier1.h"
+#include "tier2/tier2.h"
+#include "tier3/tier3.h"
+#include "datamodel/dmelementfactoryhelper.h"
+#include "mdlobjects/dmeboneflexdriver.h"
+#include "movieobjects/dmeanimationset.h"
+#include "movieobjects/dmemdlmakefile.h"
+#include "movieobjects/dmevertexdata.h"
+#include "movieobjects/dmecombinationoperator.h"
+#include "dmserializers/idmserializers.h"
+#include "tier2/p4helpers.h"
+#include "p4lib/ip4.h"
+#include "mdllib/mdllib.h"
+#include "perfstats.h"
+#include "worldsize.h"
+
+bool g_collapse_bones = false;
+bool g_collapse_bones_aggressive = false;
+bool g_quiet = false;
+bool g_badCollide = false;
+bool g_IHVTest = false;
+bool g_bCheckLengths = false;
+bool g_bPrintBones = false;
+bool g_bPerf = false;
+bool g_bDumpGraph = false;
+bool g_bMultistageGraph = false;
+bool g_verbose = false;
+bool g_bCreateMakefile = false;
+bool g_bHasModelName = false;
+bool g_bZBrush = false;
+bool g_bVerifyOnly = false;
+bool g_bUseBoneInBBox = true;
+bool g_bLockBoneLengths = false;
+bool g_bOverridePreDefinedBones = false;
+int g_minLod = 0;
+int g_numAllowedRootLODs = 0;
+bool g_bNoWarnings = false;
+int g_maxWarnings = -1;
+bool g_bX360 = false;
+bool g_bBuildPreview = false;
+bool g_bCenterBonesOnVerts = false;
+bool g_bDumpMaterials = false;
+bool g_bStripLods = false;
+bool g_bMakeVsi = false;
+float g_flDefaultMotionRollback = 0.3f;
+int g_minSectionFrameLimit = 120;
+int g_sectionFrames = 30;
+bool g_bNoAnimblockStall = false;
+
+char g_path[MAX_PATH];
+Vector g_vecMinWorldspace = Vector( MIN_COORD_INTEGER, MIN_COORD_INTEGER, MIN_COORD_INTEGER );
+Vector g_vecMaxWorldspace = Vector( MAX_COORD_INTEGER, MAX_COORD_INTEGER, MAX_COORD_INTEGER );
+DmElementHandle_t g_hDmeBoneFlexDriverList = DMELEMENT_HANDLE_INVALID;
+
+enum RunMode
+{
+	RUN_MODE_BUILD,
+	RUN_MODE_STRIP_MODEL,
+	RUN_MODE_STRIP_VHV
+} g_eRunMode = RUN_MODE_BUILD;
+
+bool g_bNoP4 = false;
+
+
+CUtlVector< s_hitboxset > g_hitboxsets;
+CUtlVector< char >	g_KeyValueText;
+CUtlVector<s_flexcontrollerremap_t> g_FlexControllerRemap;
+CCheckUVCmd g_StudioMdlCheckUVCmd;
+
+
+//-----------------------------------------------------------------------------
+// Parsed data from a .qc or .dmx file
+//-----------------------------------------------------------------------------
+struct IKLock_t
+{
+	CUtlString m_Name;
+	float m_flPosWeight;
+	float m_flLocalQWeight;
+};
+
+struct SequenceOption_t
+{
+	bool m_bSnap : 1;
+	bool m_bIsDelta : 1;
+	bool m_bIsWorldSpace : 1;
+	bool m_bIsPost : 1;
+	bool m_bIsPreDelta : 1;
+	bool m_bIsAutoplay : 1;
+	bool m_bIsRealTime : 1;
+	bool m_bIsHidden : 1;
+	float m_flFadeInTime;
+	float m_flFadeOutTime;
+	int m_nBlendWidth;
+	CUtlVector< CUtlString > m_AutoLayers;
+	CUtlVector< IKLock_t > m_IKLocks;
+};
+
+struct CmdSequence_t
+{
+	CUtlString m_Name;
+	CUtlString m_FileName;
+	SequenceOption_t m_Options;
+};
+
+
+//-----------------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------------
+void AddBodyFlexData( s_source_t *pSource, int imodel );
+void AddBodyAttachments( s_source_t *pSource );
+void AddBodyFlexRules( s_source_t *pSource );
+
+//-----------------------------------------------------------------------------
+//  Stuff for writing a makefile to build models incrementally.
+//-----------------------------------------------------------------------------
+CUtlVector<CUtlSymbol> m_CreateMakefileDependencies;
+
+void CreateMakefile_AddDependency( const char *pFileName )
+{
+	EnsureDependencyFileCheckedIn( pFileName );
+
+	if( !g_bCreateMakefile )
+	{
+		return;
+	}
+
+	CUtlSymbol sym( pFileName );
+	int i;
+	for( i = 0; i < m_CreateMakefileDependencies.Count(); i++ )
+	{
+		if( m_CreateMakefileDependencies[i] == sym )
+		{
+			return;
+		}
+	}
+	m_CreateMakefileDependencies.AddToTail( sym );
+}
+
+void EnsureDependencyFileCheckedIn( const char *pFileName )
+{
+	// Early out: if no p4
+	if ( g_bNoP4 )
+		return;
+
+	char pFullPath[MAX_PATH];
+	if ( !GetGlobalFilePath( pFileName, pFullPath, sizeof(pFullPath) ) )
+	{
+		MdlWarning( "Model dependency file '%s' is missing.\n", pFileName );
+		return;
+	}
+
+	Q_FixSlashes( pFullPath );
+	char bufCanonicalPath[ MAX_PATH ] = {0};
+	PathCanonicalize( bufCanonicalPath, pFullPath );
+	CP4AutoAddFile p4_add_dep_file( bufCanonicalPath );
+}
+
+void StudioMdl_ScriptLoadedCallback( char const *pFilenameLoaded, char const *pIncludedFromFileName, int nIncludeLineNumber )
+{
+	EnsureDependencyFileCheckedIn( pFilenameLoaded );
+}
+
+void CreateMakefile_OutputMakefile( void )
+{
+	if( !g_bHasModelName )
+	{
+		MdlError( "Can't write makefile since a target mdl hasn't been specified!" );
+	}
+	FILE *fp = fopen( "makefile.tmp", "a" );
+	if( !fp )
+	{
+		MdlError( "can't open makefile.tmp!\n" );
+	}
+	char mdlname[MAX_PATH];
+	V_strcpy_safe( mdlname, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		V_strcat_safe( mdlname, "platform_" );
+//		V_strcat_safe( mdlname, g_pPlatformName );
+//		V_strcat_safe( mdlname, "/" );	
+//	}
+	V_strcat_safe( mdlname, "models/" );	
+	V_strcat_safe( mdlname, outname );
+	Q_StripExtension( mdlname, mdlname, sizeof( mdlname ) );
+	V_strcat_safe( mdlname, ".mdl" );
+	Q_FixSlashes( mdlname );
+
+	fprintf( fp, "%s:", mdlname );
+	int i;
+	for( i = 0; i < m_CreateMakefileDependencies.Count(); i++ )
+	{
+		fprintf( fp, " %s", m_CreateMakefileDependencies[i].String() );
+	}
+	fprintf( fp, "\n" );
+	char mkdirpath[MAX_PATH];
+	V_strcpy_safe( mkdirpath, mdlname );
+	Q_StripFilename( mkdirpath );
+	fprintf( fp, "\tmkdir \"%s\"\n", mkdirpath );
+	fprintf( fp, "\t%s -quiet %s\n\n", CommandLine()->GetParm( 0 ), fullpath );
+	fclose( fp );
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+
+static bool g_bFirstWarning = true;
+
+void TokenError( const char *fmt, ... )
+{
+	static char output[1024];
+	va_list		args;
+
+	char *pFilename;
+	int iLineNumber;
+
+	if (GetTokenizerStatus( &pFilename, &iLineNumber ))
+	{
+		va_start( args, fmt );
+		vsprintf( output, fmt, args );
+
+		MdlError( "%s(%d): - %s", pFilename, iLineNumber, output );
+	}
+	else
+	{
+		va_start( args, fmt );
+		vsprintf( output, fmt, args );
+		MdlError( "%s", output );
+	}
+}
+
+void MdlError( const char *fmt, ... )
+{
+	static char output[1024];
+	static char *knownExtensions[] = {".mdl", ".ani", ".phy", ".sw.vtx", ".dx80.vtx", ".dx90.vtx", ".vvd"};
+	char		fileName[MAX_PATH];
+	char		baseName[MAX_PATH];
+	va_list		args;
+
+	Assert( 0 );
+	if (g_quiet)
+	{
+		if (g_bFirstWarning)
+		{
+			printf("%s :\n", fullpath );
+			g_bFirstWarning = false;
+		}
+		printf("\t");
+	}
+
+	printf("ERROR: ");
+	va_start( args, fmt );
+	vprintf( fmt, args );
+
+	// delete premature files
+	// unforunately, content is built without verification
+	// ensuring that targets are not available, prevents check-in
+	if (g_bHasModelName)
+	{
+		// undescriptive errors in batch processes could be anonymous
+		printf("ERROR: Aborted Processing on '%s'\n", outname);
+
+		V_strcpy_safe( fileName, gamedir );
+		V_strcat_safe( fileName, "models/" );	
+		V_strcat_safe( fileName, outname );
+		Q_FixSlashes( fileName );
+		Q_StripExtension( fileName, baseName, sizeof( baseName ) );
+
+		for (int i=0; i<ARRAYSIZE(knownExtensions); i++)
+		{
+			V_strcpy_safe( fileName, baseName);
+			V_strcat_safe( fileName, knownExtensions[i] );
+
+			// really need filesystem concept here
+//			g_pFileSystem->RemoveFile( fileName );
+			unlink( fileName );
+		}
+	}
+
+	exit( -1 );
+}
+
+
+void MdlWarning( const char *fmt, ... )
+{
+	va_list args;
+	static char output[1024];
+
+	if (g_bNoWarnings || g_maxWarnings == 0)
+		return;
+
+	WORD old = SetConsoleTextColor( 1, 1, 0, 1 );
+
+	if (g_quiet)
+	{
+		if (g_bFirstWarning)
+		{
+			printf("%s :\n", fullpath );
+			g_bFirstWarning = false;
+		}
+		printf("\t");
+	}
+
+	Assert( 0 );
+
+	printf("WARNING: ");
+	va_start( args, fmt );
+	vprintf( fmt, args );
+
+	if (g_maxWarnings > 0)
+		g_maxWarnings--;
+
+	if (g_maxWarnings == 0)
+	{
+		if (g_quiet)
+		{
+			printf("\t");
+		}
+		printf("suppressing further warnings...\n");
+	}
+
+	RestoreConsoleTextColor( old );
+}
+
+SpewRetval_t MdlSpewOutputFunc( SpewType_t type, char const *pMsg )
+{
+	if ((( type == SPEW_MESSAGE ) || (type == SPEW_LOG )) && g_quiet)
+	{
+		// suppress
+	}
+	else if (type == SPEW_WARNING)
+	{
+		MdlWarning( "%s", pMsg );
+	}
+	else
+	{
+		return CmdLib_SpewOutputFunc( type, pMsg );
+	}
+
+	return SPEW_CONTINUE;
+}
+
+
+#ifndef _DEBUG
+
+void MdlHandleCrash( const char *pMessage, bool bAssert )
+{
+	static LONG crashHandlerCount = 0;
+	if ( InterlockedIncrement( &crashHandlerCount ) == 1 )
+	{
+		MdlError( "'%s' (assert: %d)\n", pMessage, bAssert );
+	}
+
+	InterlockedDecrement( &crashHandlerCount );
+}
+
+
+// This is called if we crash inside our crash handler. It just terminates the process immediately.
+LONG __stdcall MdlSecondExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo )
+{
+	TerminateProcess( GetCurrentProcess(), 2 );
+	return EXCEPTION_EXECUTE_HANDLER; // (never gets here anyway)
+}
+
+
+void MdlExceptionFilter( unsigned long code )
+{
+	// This is called if we crash inside our crash handler. It just terminates the process immediately.
+	SetUnhandledExceptionFilter( MdlSecondExceptionFilter );
+
+	//DWORD code = ExceptionInfo->ExceptionRecord->ExceptionCode;
+
+	#define ERR_RECORD( name ) { name, #name }
+	struct
+	{
+		int code;
+		char *pReason;
+	} errors[] =
+	{
+		ERR_RECORD( EXCEPTION_ACCESS_VIOLATION ),
+		ERR_RECORD( EXCEPTION_ARRAY_BOUNDS_EXCEEDED ),
+		ERR_RECORD( EXCEPTION_BREAKPOINT ),
+		ERR_RECORD( EXCEPTION_DATATYPE_MISALIGNMENT ),
+		ERR_RECORD( EXCEPTION_FLT_DENORMAL_OPERAND ),
+		ERR_RECORD( EXCEPTION_FLT_DIVIDE_BY_ZERO ),
+		ERR_RECORD( EXCEPTION_FLT_INEXACT_RESULT ),
+		ERR_RECORD( EXCEPTION_FLT_INVALID_OPERATION ),
+		ERR_RECORD( EXCEPTION_FLT_OVERFLOW ),
+		ERR_RECORD( EXCEPTION_FLT_STACK_CHECK ),
+		ERR_RECORD( EXCEPTION_FLT_UNDERFLOW ),
+		ERR_RECORD( EXCEPTION_ILLEGAL_INSTRUCTION ),
+		ERR_RECORD( EXCEPTION_IN_PAGE_ERROR ),
+		ERR_RECORD( EXCEPTION_INT_DIVIDE_BY_ZERO ),
+		ERR_RECORD( EXCEPTION_INT_OVERFLOW ),
+		ERR_RECORD( EXCEPTION_INVALID_DISPOSITION ),
+		ERR_RECORD( EXCEPTION_NONCONTINUABLE_EXCEPTION ),
+		ERR_RECORD( EXCEPTION_PRIV_INSTRUCTION ),
+		ERR_RECORD( EXCEPTION_SINGLE_STEP ),
+		ERR_RECORD( EXCEPTION_STACK_OVERFLOW ),
+		ERR_RECORD( EXCEPTION_ACCESS_VIOLATION ),
+	};
+
+	int nErrors = sizeof( errors ) / sizeof( errors[0] );
+	{
+		int i;
+		for ( i=0; i < nErrors; i++ )
+		{
+			if ( errors[i].code == code )
+				MdlHandleCrash( errors[i].pReason, true );
+		}
+
+		if ( i == nErrors )
+		{
+			MdlHandleCrash( "Unknown reason", true );
+		}
+	}
+
+	TerminateProcess( GetCurrentProcess(), 1 );
+}
+
+#endif
+
+/*
+=================
+=================
+*/
+
+int k_memtotal;
+void *kalloc( int num, int size )
+{
+	// printf( "calloc( %d, %d )\n", num, size );
+	// printf( "%d ", num * size );
+	int nMemSize = num * size;
+	k_memtotal += nMemSize;
+
+	// ensure memory alignment on maximum of ALIGN
+	nMemSize += 511;
+	void *ptr = malloc( nMemSize );
+	memset( ptr, 0, nMemSize );
+	ptr = (byte *)((int)((byte *)ptr + 511) & ~511);
+	return ptr;
+}
+
+void kmemset( void *ptr, int value, int size )
+{
+	// printf( "kmemset( %x, %d, %d )\n", ptr, value, size );
+	memset( ptr, value, size );
+	return;
+}
+
+
+int verify_atoi( const char *token )
+{
+	if (token[0] != '-' && (token[0] < '0' || token[0] > '9'))
+	{
+		TokenError( "expecting number, got \"%s\"\n", token );
+	}
+	return atoi( token );
+}
+
+float verify_atof( const char *token )
+{
+	if (token[0] != '-' && token[0] != '.' && (token[0] < '0' || token[0] > '9'))
+	{
+		TokenError( "expecting number, got \"%s\"\n", token );
+	}
+	return atof( token );
+}
+
+float verify_atof_with_null( const char *token )
+{
+	if (strcmp( token, ".." ) == 0)
+		return -1;
+
+	if (token[0] != '-' && token[0] != '.' && (token[0] < '0' || token[0] > '9'))
+	{
+		TokenError( "expecting number, got \"%s\"\n", token );
+	}
+	return atof( token );
+}
+
+//-----------------------------------------------------------------------------
+// Key value block
+//-----------------------------------------------------------------------------
+static void AppendKeyValueText( CUtlVector< char > *pKeyValue, const char *pString )
+{
+	int nLen = strlen(pString);
+	int nFirst = pKeyValue->AddMultipleToTail( nLen );
+	memcpy( pKeyValue->Base() + nFirst, pString, nLen );
+}
+
+int	KeyValueTextSize( CUtlVector< char > *pKeyValue )
+{
+	return pKeyValue->Count();
+}
+
+const char *KeyValueText( CUtlVector< char > *pKeyValue )
+{
+	return pKeyValue->Base();
+}
+
+void Option_KeyValues( CUtlVector< char > *pKeyValue );
+
+//-----------------------------------------------------------------------------
+// Read global input into common string
+//-----------------------------------------------------------------------------
+
+bool GetLineInput( void )
+{
+	while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL) 
+	{
+		g_iLinecount++;
+		// skip comments
+		if (g_szLine[0] == '/' && g_szLine[1] == '/')
+			continue;
+
+		return true;
+	}
+	return false;
+}
+
+
+/*
+=================
+=================
+*/
+
+
+
+
+int lookupControl( char *string )
+{
+	if (stricmp(string,"X")==0) return STUDIO_X;
+	if (stricmp(string,"Y")==0) return STUDIO_Y;
+	if (stricmp(string,"Z")==0) return STUDIO_Z;
+	if (stricmp(string,"XR")==0) return STUDIO_XR;
+	if (stricmp(string,"YR")==0) return STUDIO_YR;
+	if (stricmp(string,"ZR")==0) return STUDIO_ZR;
+
+	if (stricmp(string,"LX")==0) return STUDIO_LX;
+	if (stricmp(string,"LY")==0) return STUDIO_LY;
+	if (stricmp(string,"LZ")==0) return STUDIO_LZ;
+	if (stricmp(string,"LXR")==0) return STUDIO_LXR;
+	if (stricmp(string,"LYR")==0) return STUDIO_LYR;
+	if (stricmp(string,"LZR")==0) return STUDIO_LZR;
+
+	if (stricmp(string,"LM")==0) return STUDIO_LINEAR;
+	if (stricmp(string,"LQ")==0) return STUDIO_QUADRATIC_MOTION;
+
+	return -1;
+}
+
+
+
+/*
+=================
+=================
+*/
+
+int LookupPoseParameter( char *name )
+{
+	int i;
+	for ( i = 0; i < g_numposeparameters; i++)
+	{
+		if (!stricmp( name, g_pose[i].name))
+		{
+			return i;
+		}
+	}
+	V_strcpy_safe( g_pose[i].name, name );
+	g_numposeparameters = i + 1;
+
+	if (g_numposeparameters > MAXSTUDIOPOSEPARAM)
+	{
+		TokenError( "too many pose parameters (max %d)\n", MAXSTUDIOPOSEPARAM );
+	}
+
+	return i;
+}
+
+
+//-----------------------------------------------------------------------------
+// Stuff for writing a makefile to build models incrementally.
+//-----------------------------------------------------------------------------
+s_sourceanim_t *FindSourceAnim( s_source_t *pSource, const char *pAnimName )
+{
+	int nCount = pSource->m_Animations.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		s_sourceanim_t *pAnim = &pSource->m_Animations[i];
+		if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
+			return pAnim;
+	}
+	return NULL;
+}
+
+const s_sourceanim_t *FindSourceAnim( const s_source_t *pSource, const char *pAnimName )
+{
+	if ( !pAnimName[0] )
+		return NULL;
+
+	int nCount = pSource->m_Animations.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		const s_sourceanim_t *pAnim = &pSource->m_Animations[i];
+		if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
+			return pAnim;
+	}
+	return NULL;
+}
+
+s_sourceanim_t *FindOrAddSourceAnim( s_source_t *pSource, const char *pAnimName )
+{
+	if ( !pAnimName[0] )
+		return NULL;
+
+	int nCount = pSource->m_Animations.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		s_sourceanim_t *pAnim = &pSource->m_Animations[i];
+		if ( !Q_stricmp( pAnimName, pAnim->animationname ) )
+			return pAnim;
+	}
+
+	int nIndex = pSource->m_Animations.AddToTail();
+	s_sourceanim_t *pAnim = &pSource->m_Animations[nIndex];
+	memset( pAnim, 0, sizeof(s_sourceanim_t) );
+	Q_strncpy( pAnim->animationname, pAnimName, sizeof(pAnim->animationname) );
+	return pAnim;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the $boneflexdriver command
+// QC: $boneflexdriver <bone name> <tx|ty|tz> <flex controller name> <min> <max>
+//-----------------------------------------------------------------------------
+void Cmd_BoneFlexDriver()
+{
+	CDisableUndoScopeGuard undoDisable;	// Turn of Dme undo
+
+	// Find or create the DmeBoneFlexDriverList
+	CDmeBoneFlexDriverList *pDmeBoneFlexDriverList = GetElement< CDmeBoneFlexDriverList >( g_hDmeBoneFlexDriverList );
+	if ( !pDmeBoneFlexDriverList )
+	{
+		pDmeBoneFlexDriverList = CreateElement< CDmeBoneFlexDriverList >( "boneDriverFlexList", DMFILEID_INVALID );
+		if ( pDmeBoneFlexDriverList )
+		{
+			g_hDmeBoneFlexDriverList = pDmeBoneFlexDriverList->GetHandle();
+		}
+	}
+
+	if ( !pDmeBoneFlexDriverList )
+	{
+		MdlError( "%s: Couldn't find or create DmeBoneDriverFlexList\n", "$boneflexdriver" );
+		return;
+	}
+
+	// <bone name>
+	GetToken( false );
+	CDmeBoneFlexDriver *pDmeBoneFlexDriver = pDmeBoneFlexDriverList->FindOrCreateBoneFlexDriver( token );
+	if ( !pDmeBoneFlexDriver )
+	{
+		MdlError( "%s: Couldn't find or create DmeBoneFlexDriver for bone \"%s\"\n", "$boneflexdriver", token );
+		return;
+	}
+
+	// <tx|ty|tz|rx|ry|rz>
+	GetToken( false );
+	const char *ppszComponentTypeList[] = { "tx", "ty", "tz" };
+	int nBoneComponent = -1;
+	for ( int i = 0; i < ARRAYSIZE( ppszComponentTypeList ); ++i )
+	{
+		if ( StringHasPrefix( token, ppszComponentTypeList[i] ) )
+		{
+			nBoneComponent = i;
+			break;
+		}
+	}
+
+	if ( nBoneComponent < STUDIO_BONE_FLEX_TX || nBoneComponent > STUDIO_BONE_FLEX_TZ )
+	{
+		TokenError( "%s: Invalid bone component, must be one of <tx|ty|tz>\n", "$boneflexdriver" );
+		return;
+	}
+
+	// <flex controller name>
+	GetToken( false );
+	CDmeBoneFlexDriverControl *pDmeBoneFlexDriverControl = pDmeBoneFlexDriver->FindOrCreateControl( token );
+	if ( !pDmeBoneFlexDriverControl )
+	{
+		MdlError( "%s: Couldn't find or create DmeBoneFlexDriverControl for bone \"%s\"\n", "$boneflexdriver", token );
+		return;
+	}
+
+	pDmeBoneFlexDriverControl->m_nBoneComponent = nBoneComponent;
+
+	// <min>
+	GetToken( false );
+	pDmeBoneFlexDriverControl->m_flMin = verify_atof( token );
+
+	// <max>
+	GetToken( false );
+	pDmeBoneFlexDriverControl->m_flMax = verify_atof( token );
+} 
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the $checkuv command
+// QC: $checkuv [0to1] [overlap] [inverse] [gutter <res> <min>]
+//-----------------------------------------------------------------------------
+void Cmd_CheckUV()
+{
+	g_StudioMdlCheckUVCmd.ClearCheck( CCheckUVCmd::CHECK_UV_ALL_FLAGS );
+
+	while ( TokenAvailable() && GetToken( false ) )
+	{
+		if ( !V_stricmp( token, "0to1" ) )
+		{
+			g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_NORMALIZED );
+		}
+		else if ( !V_stricmp( token, "overlap" ) )
+		{
+			g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_OVERLAP );
+		}
+		else if ( !V_stricmp( token, "inverse" ) )
+		{
+			g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_INVERSE );
+		}
+		else if ( !V_stricmp( token, "gutter" ) )
+		{
+			g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_FLAG_GUTTER );
+			if ( TokenAvailable() && GetToken( false ) )
+			{
+				if ( V_isdigit( *token ) )
+				{
+					const int nOptRes = V_atoi( token );
+					if ( nOptRes <= 0 )
+					{
+						MdlError( "$checkuv: Invalid resolution, \"%s\", for gutter check specified, must be > 0\n", token );
+						return;
+					}
+
+					g_StudioMdlCheckUVCmd.m_nOptGutterTexWidth = nOptRes;
+					g_StudioMdlCheckUVCmd.m_nOptGutterTexHeight = nOptRes;
+
+					if ( TokenAvailable() && GetToken( false ) )
+					{
+						if ( V_isdigit( *token ) )
+						{
+							const int nOptMin = V_atoi( token );
+							if ( nOptMin <= 0 )
+							{
+								MdlError( "$checkuv: Invalid minimum, \"%s\", for gutter check specified, must be > 0\n", token );
+								return;
+							}
+
+							g_StudioMdlCheckUVCmd.m_nOptGutterMin = nOptMin;
+						}
+						else
+						{
+							UnGetToken();
+						}
+					}
+				}
+				else
+				{
+					UnGetToken();
+				}
+			}
+		}
+		else
+		{
+			MdlError( "$checkuv: Unknown argument \"%s\", expected one of [ 0to1, overlap, inverse, gutter ]\n", token );
+			return;
+		}
+	}
+
+	if ( !g_StudioMdlCheckUVCmd.DoAnyCheck() )
+	{
+		g_StudioMdlCheckUVCmd.SetCheck( CCheckUVCmd::CHECK_UV_ALL_FLAGS );
+	}
+}
+
+
+void Cmd_PoseParameter( )
+{
+	if ( g_numposeparameters >= MAXSTUDIOPOSEPARAM )
+	{
+		TokenError( "too many pose parameters (max %d)\n", MAXSTUDIOPOSEPARAM );
+	}
+
+	int i = LookupPoseParameter( token );
+
+	// name
+	GetToken (false);
+	V_strcpy_safe( g_pose[i].name, token );
+
+	if ( TokenAvailable() )
+	{
+		// min
+		GetToken (false);
+		g_pose[i].min = verify_atof (token);
+	}
+
+	if ( TokenAvailable() )
+	{
+		// max
+		GetToken (false);
+		g_pose[i].max = verify_atof (token);
+	}
+
+	while ( TokenAvailable() )
+	{
+		GetToken (false);
+
+		if ( !Q_stricmp( token, "wrap" ) )
+		{
+			g_pose[i].flags |= STUDIO_LOOPING;
+			g_pose[i].loop = g_pose[i].max - g_pose[i].min;
+		}
+		else if ( !Q_stricmp( token, "loop" ) )
+		{
+			g_pose[i].flags |= STUDIO_LOOPING;
+			GetToken (false);
+			g_pose[i].loop = verify_atof( token );
+		}
+	}
+}
+
+
+/*
+=================
+=================
+*/
+
+int LookupTexture( const char *pTextureName, bool bRelativePath )
+{
+	char pTextureNoExt[MAX_PATH];
+	char pTextureBase[MAX_PATH];
+	char pTextureBase2[MAX_PATH];
+	Q_StripExtension( pTextureName, pTextureNoExt, sizeof(pTextureNoExt) );
+	Q_FileBase( pTextureName, pTextureBase, sizeof(pTextureBase) );
+
+	int nFlags = bRelativePath ? RELATIVE_TEXTURE_PATH_SPECIFIED : 0;
+	int i;
+	for ( i = 0; i < g_numtextures; i++ ) 
+	{
+		if ( g_texture[i].flags == nFlags )
+		{
+			if ( !Q_stricmp( pTextureNoExt, g_texture[i].name ) )
+				return i;
+			continue;
+		}
+
+		// Comparing relative vs non-relative
+		if ( bRelativePath )
+		{
+			if ( !Q_stricmp( pTextureBase, g_texture[i].name ) )
+				return i;
+			continue;
+		}
+
+		// Comparing non-relative vs relative
+		Q_FileBase( g_texture[i].name, pTextureBase2, sizeof(pTextureBase2) );
+		if ( !Q_stricmp( pTextureNoExt, pTextureBase2 ) )
+			return i;
+	}
+
+	if ( i >= MAXSTUDIOSKINS )
+	{
+		MdlError("Too many materials used, max %d\n", ( int )MAXSTUDIOSKINS );
+	}
+
+	Q_strncpy( g_texture[i].name, pTextureNoExt, sizeof(g_texture[i].name) );
+	g_texture[i].material = -1;
+	g_texture[i].flags = nFlags;
+	g_numtextures++;
+	return i;
+}
+
+
+void Cmd_RenameMaterial( void )
+{
+	char from[256];
+	char to[256];
+
+	GetToken( false );
+	V_strcpy_safe( from, token );
+
+	GetToken( false );
+	V_strcpy_safe( to, token );
+
+	int i;
+	for (i = 0; i < g_numtextures; i++) 
+	{
+		if (stricmp( g_texture[i].name, from ) == 0) 
+		{
+			V_strcpy_safe( g_texture[i].name, to );
+			return;
+		}
+	}
+	MdlError( "unknown material \"%s\" in rename\n", from );
+}
+
+
+int UseTextureAsMaterial( int textureindex )
+{
+	if ( g_texture[textureindex].material == -1 )
+	{
+		if (g_bDumpMaterials)
+		{
+			printf("material %d %d %s\n", textureindex, g_nummaterials, g_texture[textureindex].name );
+		}
+		g_material[g_nummaterials] = textureindex;
+		g_texture[textureindex].material = g_nummaterials++;
+	}
+
+	return g_texture[textureindex].material;
+}
+
+int MaterialToTexture( int material )
+{
+	int i;
+	for (i = 0; i < g_numtextures; i++)
+	{
+		if (g_texture[i].material == material)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+//Wrong name for the use of it.
+void scale_vertex( Vector &org )
+{
+	org[0] = org[0] * g_currentscale;
+	org[1] = org[1] * g_currentscale;
+	org[2] = org[2] * g_currentscale;
+}
+
+
+
+void SetSkinValues( )
+{
+	int			i, j;
+	int			index;
+
+	// Check all textures to see if we have relative paths specified
+	for (i = 0; i < g_numtextures; i++)
+	{
+		if ( g_texture[i].flags & RELATIVE_TEXTURE_PATH_SPECIFIED )
+		{
+			// Add an empty path to prepend if anything specifies a relative path
+			cdtextures[numcdtextures] = 0;
+			++numcdtextures;
+			break;
+		}
+	}
+
+	if ( numcdtextures == 0 )
+	{
+		char szName[MAX_PATH];
+
+		// strip down till it finds "models"
+		V_strcpy_safe( szName, fullpath );
+		while (szName[0] != '\0' && strnicmp( "models", szName, 6 ) != 0)
+		{
+			strcpy( &szName[0], &szName[1] );
+		}
+		if (szName[0] != '\0')
+		{
+			Q_StripFilename( szName );
+			V_strcat_safe( szName, "/" );
+		}
+		else
+		{
+//			if( *g_pPlatformName )
+//			{
+//				V_strcat_safe( szName, "platform_" );
+//				V_strcat_safe( szName, g_pPlatformName );
+//				V_strcat_safe( szName, "/" );	
+//			}
+			V_strcpy_safe( szName, "models/" );	
+			V_strcat_safe( szName, outname );
+			Q_StripExtension( szName, szName, sizeof( szName ) );
+			V_strcat_safe( szName, "/" );
+		}
+		cdtextures[0] = strdup( szName );
+		numcdtextures = 1;
+	}
+
+	for (i = 0; i < g_numtextures; i++)
+	{
+		char szName[256];
+		Q_StripExtension( g_texture[i].name, szName, sizeof( szName ) );
+		Q_strncpy( g_texture[i].name, szName, sizeof( g_texture[i].name ) );
+	}
+
+	// build texture groups
+	for (i = 0; i < MAXSTUDIOSKINS; i++)
+	{
+		for (j = 0; j < MAXSTUDIOSKINS; j++)
+		{
+			g_skinref[i][j] = j;
+		}
+	}
+	index = 0;
+	for (i = 0; i < g_numtexturelayers[0]; i++)
+	{
+		for (j = 0; j < g_numtexturereps[0]; j++)
+		{
+			g_skinref[i][g_texturegroup[0][0][j]] = g_texturegroup[0][i][j];
+		}
+	}
+
+	if (i != 0)
+	{
+		g_numskinfamilies = i;
+	}
+	else
+	{
+		g_numskinfamilies = 1;
+	}
+	g_numskinref = g_numtextures;
+
+	// printf ("width: %i  height: %i\n",width, height);
+	/*
+	printf ("adjusted width: %i height: %i  top : %i  left: %i\n",
+			pmesh->skinwidth, pmesh->skinheight, pmesh->skintop, pmesh->skinleft );
+	*/
+}
+
+/*
+=================
+=================
+*/
+
+
+int LookupXNode( char *name )
+{
+	int i;
+	for ( i = 1; i <= g_numxnodes; i++)
+	{
+		if (stricmp( name, g_xnodename[i] ) == 0)
+		{
+			return i;
+		}
+	}
+	g_xnodename[i] = strdup( name );
+	g_numxnodes = i;
+	return i;
+}
+
+
+/*
+=================
+=================
+*/
+
+char	g_szFilename[1024];
+FILE	*g_fpInput;
+char	g_szLine[4096];
+int		g_iLinecount;
+
+
+void Build_Reference( s_source_t *pSource, const char *pAnimName )
+{
+	int		i, parent;
+	Vector	angle;
+
+	s_sourceanim_t *pReferenceAnim = FindSourceAnim( pSource, pAnimName );
+	for (i = 0; i < pSource->numbones; i++)
+	{
+		matrix3x4_t m;
+		if ( pReferenceAnim )
+		{
+			AngleMatrix( pReferenceAnim->rawanim[0][i].rot, m );
+			m[0][3] = pReferenceAnim->rawanim[0][i].pos[0];
+			m[1][3] = pReferenceAnim->rawanim[0][i].pos[1];
+			m[2][3] = pReferenceAnim->rawanim[0][i].pos[2];
+		}
+		else
+		{
+			SetIdentityMatrix( m );
+		}
+
+		parent = pSource->localBone[i].parent;
+		if (parent == -1) 
+		{
+			// scale the done pos.
+			// calc rotational matrices
+			MatrixCopy( m, pSource->boneToPose[i] );
+		}
+		else 
+		{
+			// calc compound rotational matrices
+			// FIXME : Hey, it's orthogical so inv(A) == transpose(A)
+			Assert( parent < i );
+			ConcatTransforms( pSource->boneToPose[parent], m, pSource->boneToPose[i] );
+		}
+		// printf("%3d %f %f %f\n", i, psource->bonefixup[i].worldorg[0], psource->bonefixup[i].worldorg[1], psource->bonefixup[i].worldorg[2] );
+		/*
+		AngleMatrix( angle, m );
+		printf("%8.4f %8.4f %8.4f\n", m[0][0], m[1][0], m[2][0] );
+		printf("%8.4f %8.4f %8.4f\n", m[0][1], m[1][1], m[2][1] );
+		printf("%8.4f %8.4f %8.4f\n", m[0][2], m[1][2], m[2][2] );
+		*/
+	}
+}
+
+
+
+
+int Grab_Nodes( s_node_t *pnodes )
+{
+	int index;
+	char name[1024];
+	int parent;
+	int numbones = 0;
+
+	for (index = 0; index < MAXSTUDIOSRCBONES; index++)
+	{
+		pnodes[index].parent = -1;
+	}
+
+	while (GetLineInput()) 
+	{
+		if (sscanf( g_szLine, "%d \"%[^\"]\" %d", &index, name, &parent ) == 3)
+		{
+			// check for duplicated bones
+			/*
+			if (strlen(pnodes[index].name) != 0)
+			{
+				MdlError( "bone \"%s\" exists more than once\n", name );
+			}
+			*/
+			
+			V_strcpy_safe( pnodes[index].name, name );
+			pnodes[index].parent = parent;
+			if (index > numbones)
+			{
+				numbones = index;
+			}
+		}
+		else 
+		{
+			return numbones + 1;
+		}
+	}
+	MdlError( "Unexpected EOF at line %d\n", g_iLinecount );
+	return 0;
+}
+
+
+
+
+void clip_rotations( RadianEuler& rot )
+{
+	int j;
+	// clip everything to : -M_PI <= x < M_PI
+
+	for (j = 0; j < 3; j++) {
+		while (rot[j] >= M_PI) 
+			rot[j] -= M_PI*2;
+		while (rot[j] < -M_PI) 
+			rot[j] += M_PI*2;
+	}
+}
+
+
+void clip_rotations( Vector& rot )
+{
+	int j;
+	// clip everything to : -180 <= x < 180
+
+	for (j = 0; j < 3; j++) {
+		while (rot[j] >= 180) 
+			rot[j] -= 180*2;
+		while (rot[j] < -180) 
+			rot[j] += 180*2;
+	}
+}
+
+
+
+/*
+=================
+Cmd_Eyeposition
+=================
+*/
+void Cmd_Eyeposition (void)
+{
+// rotate points into frame of reference so g_model points down the positive x
+// axis
+	//	FIXME: these coords are bogus
+	GetToken (false);
+	eyeposition[1] = verify_atof (token);
+
+	GetToken (false);
+	eyeposition[0] = -verify_atof (token);
+
+	GetToken (false);
+	eyeposition[2] = verify_atof (token);
+}
+
+
+//-----------------------------------------------------------------------------
+// Cmd_MaxEyeDeflection
+//-----------------------------------------------------------------------------
+void Cmd_MaxEyeDeflection()
+{
+	GetToken( false );
+	g_flMaxEyeDeflection = cosf( verify_atof( token ) * M_PI / 180.0f );
+}
+
+
+//-----------------------------------------------------------------------------
+// Cmd_Illumposition
+//-----------------------------------------------------------------------------
+void Cmd_Illumposition( void )
+{
+	GetToken( false );
+	illumposition[0] = verify_atof( token );
+
+	GetToken( false );
+	illumposition[1] = verify_atof( token );
+
+	GetToken( false );
+	illumposition[2] = verify_atof( token );
+
+	if ( TokenAvailable() )
+	{
+		GetToken( false );
+
+		Q_strncpy( g_attachment[g_numattachments].name, "__illumPosition", sizeof(g_attachment[g_numattachments].name) );
+		Q_strncpy( g_attachment[g_numattachments].bonename, token, sizeof(g_attachment[g_numattachments].bonename) );
+		AngleMatrix( QAngle( 0, 0, 0 ), illumposition, g_attachment[g_numattachments].local );
+		g_attachment[g_numattachments].type |= IS_RIGID;
+
+		g_illumpositionattachment = g_numattachments + 1;
+		++g_numattachments;
+	}
+	else
+	{
+		g_illumpositionattachment = 0;
+
+		// rotate points into frame of reference so 
+		// g_model points down the positive x axis
+		// FIXME: these coords are bogus
+		float flTemp = illumposition[0];
+		illumposition[0] = -illumposition[1];
+		illumposition[1] = flTemp;
+	}
+
+	illumpositionset = true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process Cmd_Modelname
+//-----------------------------------------------------------------------------
+void ProcessModelName( const char *pModelName )
+{
+	// Abort early if modelname is too big
+	// - actually that's okay, it's just an identifier and can be truncated
+
+	g_bHasModelName = true;
+	Q_strncpy( outname, pModelName, sizeof( outname ) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse Cmd_Modelname
+//-----------------------------------------------------------------------------
+void Cmd_Modelname (void)
+{
+	GetToken (false);
+	if ( token[0] == '/' || token[0] == '\\' )
+	{
+		MdlWarning( "$modelname key has slash as first character. Removing.\n" );
+		ProcessModelName( &token[1] );
+	}
+	else
+	{
+		ProcessModelName( token );
+	}
+}
+
+void Cmd_Autocenter()
+{
+	g_centerstaticprop = true;
+}
+
+/*
+===============
+===============
+*/
+
+
+//-----------------------------------------------------------------------------
+// Parse the body command from a .qc file
+//-----------------------------------------------------------------------------
+void ProcessOptionStudio( s_model_t *pmodel, const char *pFullPath, CDmeSourceSkin *pSkin )
+{
+	Q_strncpy( pmodel->filename, pFullPath, sizeof(pmodel->filename) );
+
+	if ( pSkin->m_flScale != 0.0f )
+	{
+		pmodel->scale = g_currentscale = pSkin->m_flScale;
+	}
+	else
+	{
+		pmodel->scale = g_currentscale = g_defaultscale;
+	}
+
+	// load source
+	pmodel->source = Load_Source( pmodel->filename, "", pSkin->m_bFlipTriangles, true );
+
+	// Reset currentscale to whatever global we currently have set
+	// g_defaultscale gets set in Cmd_ScaleUp everytime the $scale command is used.
+	g_currentscale = g_defaultscale;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse the studio options from a .qc file
+//-----------------------------------------------------------------------------
+bool ParseOptionStudio( CDmeSourceSkin *pSkin )
+{
+	if ( !GetToken( false ) ) 
+		return false;
+
+	pSkin->SetRelativeFileName( token );
+	while ( TokenAvailable() )
+	{
+		GetToken(false);
+		if ( !Q_stricmp( "reverse", token ) )
+		{
+			pSkin->m_bFlipTriangles = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( "scale", token ) )
+		{
+			GetToken(false);
+			pSkin->m_flScale = verify_atof( token );
+			continue;
+		}
+
+		if ( !Q_stricmp( "faces", token ) )
+		{
+			GetToken( false );
+			GetToken( false );
+			continue;
+		}
+
+		if ( !Q_stricmp( "bias", token ) )
+		{
+			GetToken( false );
+			continue;
+		}
+
+		if ( !Q_stricmp( "{", token ) )
+		{
+			UnGetToken( );
+			break;
+		}
+
+		MdlError("unknown command \"%s\"\n", token );
+		return false;
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse + process the studio options from a .qc file
+//-----------------------------------------------------------------------------
+void Option_Studio( s_model_t *pmodel )
+{
+	CDmeSourceSkin *pSourceSkin = CreateElement< CDmeSourceSkin >( "" );
+
+	// Set defaults
+	pSourceSkin->m_flScale = g_defaultscale;
+
+	if ( ParseOptionStudio( pSourceSkin ) )
+	{
+		ProcessOptionStudio( pmodel, pSourceSkin->GetRelativeFileName(), pSourceSkin );
+	}
+	DestroyElement( pSourceSkin );
+}
+
+
+int Option_Blank( )
+{
+	g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
+
+	g_source[g_numsources] = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
+	g_model[g_nummodels]->source = g_source[g_numsources];
+	g_numsources++;
+
+	g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
+
+	V_strcpy_safe( g_model[g_nummodels]->name, "blank" );
+
+	g_bodypart[g_numbodyparts].nummodels++;
+	g_nummodels++;
+	return 0;
+}
+
+
+void Cmd_Bodygroup( )
+{
+	int is_started = 0;
+
+	if ( !GetToken( false ) ) 
+		return;
+
+	if (g_numbodyparts == 0) 
+	{
+		g_bodypart[g_numbodyparts].base = 1;
+	}
+	else 
+	{
+		g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
+	}
+	V_strcpy_safe( g_bodypart[g_numbodyparts].name, token );
+
+	do
+	{
+		GetToken (true);
+		if (endofscript)
+			return;
+		else if (token[0] == '{')
+		{
+			is_started = 1;
+		}
+		else if (token[0] == '}')
+		{
+			break;
+		}
+		else if (stricmp("studio", token ) == 0)
+		{
+			g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
+			g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
+			g_bodypart[g_numbodyparts].nummodels++;
+		
+			Option_Studio( g_model[g_nummodels] );
+
+			// Body command should add any flex commands in the source loaded
+			if ( g_model[g_nummodels]->source )
+			{
+				AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
+				AddBodyAttachments( g_model[g_nummodels]->source );
+			}
+
+			g_nummodels++;
+		}
+		else if (stricmp("blank", token ) == 0)
+		{
+			Option_Blank( );
+		}
+		else
+		{
+			MdlError("unknown bodygroup option: \"%s\"\n", token );
+		}
+	} while (1);
+
+	g_numbodyparts++;
+	return;
+}
+
+
+//-----------------------------------------------------------------------------
+// Add A Body Flex Rule
+//-----------------------------------------------------------------------------
+void AddBodyFlexFetchRule(
+	s_source_t *pSource,
+	s_flexrule_t *pRule,
+	int rawIndex,
+	const CUtlVector< int > &pRawIndexToRemapSourceIndex,
+	const CUtlVector< int > &pRawIndexToRemapLocalIndex,
+	const CUtlVector< int > &pRemapSourceIndexToGlobalFlexControllerIndex )
+{
+	// Lookup the various indices of the requested input to fetch
+	// Relative to the remapped controls in the current s_source_t
+	const int remapSourceIndex = pRawIndexToRemapSourceIndex[ rawIndex ];
+	// Relative to the specific remapped control
+	const int remapLocalIndex = pRawIndexToRemapLocalIndex[ rawIndex ];
+	// The global flex controller index that the user ultimately twiddles
+	const int globalFlexControllerIndex = pRemapSourceIndexToGlobalFlexControllerIndex[ remapSourceIndex ];
+
+	// Get the Remap record
+	s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[ remapSourceIndex ];
+	switch ( remap.m_RemapType )
+	{
+	case FLEXCONTROLLER_REMAP_PASSTHRU:
+		// Easy As!
+		pRule->op[ pRule->numops ].op = STUDIO_FETCH1;
+		pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
+		pRule->numops++;
+		break;
+
+	case FLEXCONTROLLER_REMAP_EYELID:
+		if ( remapLocalIndex == 0 )
+		{
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = remap.m_EyesUpDownFlexController >= 0 ? remap.m_EyesUpDownFlexController : -1;
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = remap.m_BlinkController >= 0 ? remap.m_BlinkController : -1;
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = globalFlexControllerIndex;	// CloseLid
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_DME_LOWER_EYELID;
+			pRule->op[ pRule->numops ].d.index = remap.m_MultiIndex;	// CloseLidV
+			pRule->numops++;
+		}
+		else
+		{
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = remap.m_EyesUpDownFlexController >= 0 ? remap.m_EyesUpDownFlexController : -1;
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = remap.m_BlinkController >= 0 ? remap.m_BlinkController : -1;
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = globalFlexControllerIndex;	// CloseLid
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_DME_UPPER_EYELID;
+			pRule->op[ pRule->numops ].d.index = remap.m_MultiIndex;	// CloseLidV
+			pRule->numops++;
+		}
+		break;
+
+	case FLEXCONTROLLER_REMAP_2WAY:
+		// A little trickier... local index 0 is on the left, local index 1 is on the right
+		// Left Equivalent RemapVal( -1.0, 0.0, 0.0, 1.0 )
+		// Right Equivalent RemapVal( 0.0, 1.0, 0.0, 1.0 )
+		if ( remapLocalIndex == 0 )
+		{
+			pRule->op[ pRule->numops ].op = STUDIO_2WAY_0;
+			pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
+			pRule->numops++;
+		}
+		else
+		{
+			pRule->op[ pRule->numops ].op = STUDIO_2WAY_1;
+			pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
+			pRule->numops++;
+		}
+		break;
+
+	case FLEXCONTROLLER_REMAP_NWAY:
+		{
+			int nRemapCount = remap.m_RawControls.Count();
+			float flStep = ( nRemapCount > 2 ) ? 2.0f / ( nRemapCount - 1 ) : 0.0f;
+
+			if ( remapLocalIndex == 0 )
+			{
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = -11.0f;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = -10.0f;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = -1.0f;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = -1.0f + flStep;
+				pRule->numops++;
+			}
+			else if ( remapLocalIndex == nRemapCount - 1 )
+			{
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = 1.0f - flStep;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = 1.0f;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = 10.0f;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = 11.0f;
+				pRule->numops++;
+			}
+			else
+			{
+				float flPeak = remapLocalIndex * flStep - 1.0f;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = flPeak - flStep;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = flPeak;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = flPeak;
+				pRule->numops++;
+
+				pRule->op[ pRule->numops ].op = STUDIO_CONST;
+				pRule->op[ pRule->numops ].d.value = flPeak + flStep;
+				pRule->numops++;
+			}
+
+			pRule->op[ pRule->numops ].op = STUDIO_CONST;
+			pRule->op[ pRule->numops ].d.value = remap.m_MultiIndex;
+			pRule->numops++;
+
+			pRule->op[ pRule->numops ].op = STUDIO_NWAY;
+			pRule->op[ pRule->numops ].d.index = globalFlexControllerIndex;
+			pRule->numops++;
+		}
+		break;
+	default:
+		Assert( 0 );
+		// This is an error condition
+		pRule->op[ pRule->numops ].op = STUDIO_CONST;
+		pRule->op[ pRule->numops ].d.value = 1.0f;
+		pRule->numops++;
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Add A Body Flex Rule
+//-----------------------------------------------------------------------------
+void AddBodyFlexRule(
+	s_source_t *pSource,
+	s_combinationrule_t &rule,
+	int nFlexDesc,
+	const CUtlVector< int > &pRawIndexToRemapSourceIndex,
+	const CUtlVector< int > &pRawIndexToRemapLocalIndex,
+	const CUtlVector< int > &pRemapSourceIndexToGlobalFlexControllerIndex )
+{
+	if ( g_numflexrules >= MAXSTUDIOFLEXRULES )
+		MdlError( "Line %d: Too many flex rules, max %d",
+			g_iLinecount, MAXSTUDIOFLEXRULES );
+
+	s_flexrule_t *pRule = &g_flexrule[g_numflexrules++];
+	pRule->flex = nFlexDesc;
+
+	// This will multiply the combination together
+	const int nCombinationCount = rule.m_Combination.Count();
+	if ( nCombinationCount )
+	{
+		for ( int j = 0; j < nCombinationCount; ++j )
+		{
+			// Handle any controller remapping
+			AddBodyFlexFetchRule( pSource, pRule, rule.m_Combination[ j ],
+				pRawIndexToRemapSourceIndex, pRawIndexToRemapLocalIndex,
+				pRemapSourceIndexToGlobalFlexControllerIndex );
+		}
+
+		if ( nCombinationCount > 1 )
+		{
+			pRule->op[ pRule->numops ].op = STUDIO_COMBO;
+			pRule->op[ pRule->numops ].d.index = nCombinationCount;
+			pRule->numops++;
+		}
+	}
+
+	// This will multiply in the suppressors
+	int nDominators = rule.m_Dominators.Count();
+	for ( int j = 0; j < nDominators; ++j )
+	{
+		const int nFactorCount = rule.m_Dominators[j].Count();
+		if ( nFactorCount )
+		{
+			for ( int k = 0; k < nFactorCount; ++k )
+			{
+				AddBodyFlexFetchRule( pSource, pRule, rule.m_Dominators[ j ][ k ],
+					pRawIndexToRemapSourceIndex, pRawIndexToRemapLocalIndex,
+					pRemapSourceIndexToGlobalFlexControllerIndex );
+			}
+
+			pRule->op[ pRule->numops ].op = STUDIO_DOMINATE;
+			pRule->op[ pRule->numops ].d.index = nFactorCount;
+			pRule->numops++;
+		}
+	}
+}
+	
+
+//-----------------------------------------------------------------------------
+// Adds flex controller data to a particular source
+//-----------------------------------------------------------------------------
+void AddFlexControllers(
+	s_source_t *pSource )
+{
+	CUtlVector< int > &r2s = pSource->m_rawIndexToRemapSourceIndex;
+	CUtlVector< int > &r2l = pSource->m_rawIndexToRemapLocalIndex;
+	CUtlVector< int > &l2i = pSource->m_leftRemapIndexToGlobalFlexControllIndex;
+	CUtlVector< int > &r2i = pSource->m_rightRemapIndexToGlobalFlexControllIndex;
+
+	// Number of Raw controls in this source
+	const int nRawControlCount = pSource->m_CombinationControls.Count();
+	// Initialize rawToRemapIndices
+	r2s.SetSize( nRawControlCount );
+	r2l.SetSize( nRawControlCount );
+	for ( int i = 0; i < nRawControlCount; ++i )
+	{
+		r2s[ i ] = -1;
+		r2l[ i ] = -1;
+	}
+
+	// Number of Remapped Controls in this source
+	const int nRemappedControlCount = pSource->m_FlexControllerRemaps.Count();
+	l2i.SetSize( nRemappedControlCount );
+	r2i.SetSize( nRemappedControlCount );
+
+	for ( int i = 0; i < nRemappedControlCount; ++i )
+	{
+		s_flexcontrollerremap_t &remapControl = pSource->m_FlexControllerRemaps[ i ];
+
+		// Number of Raw Controls In This Remapped Control
+		const int nRemappedRawControlCount = remapControl.m_RawControls.Count();
+
+		// Figure out the mapping from raw to remapped
+		for ( int j = 0; j < nRemappedRawControlCount; ++j )
+		{
+			for ( int k = 0; k < nRawControlCount; ++k )
+			{
+				if ( remapControl.m_RawControls[ j ] == pSource->m_CombinationControls[ k ].name )
+				{
+					Assert( r2s[ k ] == -1 );
+					Assert( r2l[ k ] == -1 );
+					r2s[ k ] = i;	// The index of the remapped control
+					r2l[ k ] = j;	// The index of which control this is in the remap
+					break;
+				}
+			}
+		}
+
+		if ( remapControl.m_bIsStereo )
+		{
+			// The controls have to be named 'right_' and 'left_' and right has to be first for
+			// hlfaceposer to recognize them
+
+			// See if we can add two more flex controllers
+			if ( ( g_numflexcontrollers + 1 ) >= MAXSTUDIOFLEXCTRL)
+				MdlError( "Line %d: Too many flex controllers, max %d, cannot add split control %s from source %s",
+					g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
+
+			s_flexcontroller_t *pController;
+
+			int nLen = remapControl.m_Name.Length();
+			char *pTemp = (char*)_alloca( nLen + 7 );	// 'left_' && 'right_'
+
+			memcpy( pTemp + 6, remapControl.m_Name.Get(), nLen + 1 );
+			memcpy( pTemp, "right_", 6 );
+			pTemp[nLen + 6] = '\0';
+
+			remapControl.m_RightIndex = g_numflexcontrollers;
+			r2i[ i ] = g_numflexcontrollers;
+			pController = &g_flexcontroller[g_numflexcontrollers++];	
+			Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
+			Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
+
+			if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
+			{
+				pController->min = -1.0f;
+				pController->max = 1.0f;
+			}
+			else
+			{
+				pController->min = 0.0f;
+				pController->max = 1.0f;
+			}
+
+			memcpy( pTemp + 5, remapControl.m_Name.Get(), nLen + 1 );
+			memcpy( pTemp, "left_", 5 );
+			pTemp[nLen + 5] = '\0';
+
+			remapControl.m_LeftIndex = g_numflexcontrollers;
+			l2i[ i ] = g_numflexcontrollers;
+			pController = &g_flexcontroller[g_numflexcontrollers++];	
+			Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
+			Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
+
+			if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
+			{
+				pController->min = -1.0f;
+				pController->max = 1.0f;
+			}
+			else
+			{
+				pController->min = 0.0f;
+				pController->max = 1.0f;
+			}
+		}
+		else
+		{
+			// See if we can add one more flex controller
+			if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
+				MdlError( "Line %d: Too many flex controllers, max %d, cannot add control %s from source %s",
+					g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
+
+			remapControl.m_Index = g_numflexcontrollers;
+			r2i[ i ] = g_numflexcontrollers;
+			l2i[ i ] = g_numflexcontrollers;
+			s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];	
+			Q_strncpy( pController->name, remapControl.m_Name.Get(), sizeof( pController->name ) );
+			Q_strncpy( pController->type, remapControl.m_Name.Get(), sizeof( pController->type ) );
+
+			if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_2WAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
+			{
+				pController->min = -1.0f;
+				pController->max = 1.0f;
+			}
+			else
+			{
+				pController->min = 0.0f;
+				pController->max = 1.0f;
+			}
+		}
+
+		if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_NWAY || remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
+		{
+			if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
+				MdlError( "Line %d: Too many flex controllers, max %d, cannot add value control for nWay %s from source %s",
+				g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
+
+			remapControl.m_MultiIndex = g_numflexcontrollers;
+			s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];	
+			const int nLen = remapControl.m_Name.Length();
+			char *pTemp = ( char * )_alloca( nLen + 6 + 1 ); // 'multi_' + 1 for the NULL
+
+			memcpy( pTemp, "multi_", 6 );
+			memcpy( pTemp + 6, remapControl.m_Name.Get(), nLen + 1 );
+			pTemp[nLen+6] = '\0';
+			Q_strncpy( pController->name, pTemp, sizeof( pController->name ) );
+			Q_strncpy( pController->type, pTemp, sizeof( pController->type ) );
+
+			pController->min = -1.0f;
+			pController->max = 1.0f;
+		}
+
+		if ( remapControl.m_RemapType == FLEXCONTROLLER_REMAP_EYELID )
+		{
+			// Make a blink controller
+
+			if ( g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
+				MdlError( "Line %d: Too many flex controllers, max %d, cannot add value control for nWay %s from source %s",
+				g_iLinecount, MAXSTUDIOFLEXCTRL, remapControl.m_Name.Get(), pSource->filename );
+
+			remapControl.m_BlinkController = g_numflexcontrollers;
+			s_flexcontroller_t *pController = &g_flexcontroller[g_numflexcontrollers++];	
+
+			Q_strncpy( pController->name, "blink", sizeof( pController->name ) );
+			Q_strncpy( pController->type, "blink", sizeof( pController->type ) );
+
+			pController->min = 0.0f;
+			pController->max = 1.0f;
+		}
+	}
+
+#ifdef _DEBUG
+	for ( int j = 0; j != nRawControlCount; ++j )
+	{
+		Assert( r2s[ j ] != -1 );
+		Assert( r2l[ j ] != -1 );
+	}
+#endif // def _DEBUG
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds flex controller remappers
+//-----------------------------------------------------------------------------
+void AddBodyFlexRemaps( s_source_t *pSource )
+{
+	int nCount = pSource->m_FlexControllerRemaps.Count();
+	for( int i = 0; i < nCount; ++i )
+	{
+		int k = g_FlexControllerRemap.AddToTail();
+		s_flexcontrollerremap_t &remap = g_FlexControllerRemap[k];
+		remap = pSource->m_FlexControllerRemaps[i];
+	}
+}					 
+
+
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+void AddBodyFlexRules( s_source_t *pSource )
+{
+	const int nRemapCount = pSource->m_FlexControllerRemaps.Count();
+	for ( int i = 0; i < nRemapCount; ++i )
+	{
+		s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[ i ];
+		if ( remap.m_RemapType == FLEXCONTROLLER_REMAP_EYELID && !remap.m_EyesUpDownFlexName.IsEmpty() )
+		{
+			for ( int j = 0; j < g_numflexcontrollers; ++j )
+			{
+				if ( !Q_strcmp( g_flexcontroller[ j ].name, remap.m_EyesUpDownFlexName.Get() ) )
+				{
+					Assert( remap.m_EyesUpDownFlexController == -1 );
+					remap.m_EyesUpDownFlexController = j;
+					break;
+				}
+			}
+		}
+	}
+
+	const int nCount = pSource->m_CombinationRules.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		s_combinationrule_t &rule = pSource->m_CombinationRules[i];
+		s_flexkey_t &flexKey = g_flexkey[ pSource->m_nKeyStartIndex + rule.m_nFlex ];
+		AddBodyFlexRule( pSource, rule, flexKey.flexdesc,
+			pSource->m_rawIndexToRemapSourceIndex, pSource->m_rawIndexToRemapLocalIndex, pSource->m_leftRemapIndexToGlobalFlexControllIndex );
+		if ( flexKey.flexpair != 0 )
+		{
+			AddBodyFlexRule( pSource, rule, flexKey.flexpair,
+				pSource->m_rawIndexToRemapSourceIndex, pSource->m_rawIndexToRemapLocalIndex, pSource->m_rightRemapIndexToGlobalFlexControllIndex );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Process a body command
+//-----------------------------------------------------------------------------
+void AddBodyFlexData( s_source_t *pSource, int imodel )
+{
+	pSource->m_nKeyStartIndex = g_numflexkeys;
+
+	// Add flex keys
+	int nCount = pSource->m_FlexKeys.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		s_flexkey_t &key = pSource->m_FlexKeys[i];
+
+		if ( g_numflexkeys >= MAXSTUDIOFLEXKEYS )
+			MdlError( "Line %d: Too many flex keys, max %d, cannot add flexKey %s from source %s",
+				g_iLinecount, MAXSTUDIOFLEXKEYS, key.animationname, pSource->filename );
+
+		memcpy( &g_flexkey[g_numflexkeys], &key, sizeof(s_flexkey_t) );
+		g_flexkey[g_numflexkeys].imodel = imodel;
+
+		// flexpair was set up in AddFlexKey
+		if ( key.flexpair )
+		{
+			char mod[512];
+			Q_snprintf( mod, sizeof(mod), "%sL", key.animationname );
+			g_flexkey[g_numflexkeys].flexdesc = Add_Flexdesc( mod );
+			Q_snprintf( mod, sizeof(mod), "%sR", key.animationname );
+			g_flexkey[g_numflexkeys].flexpair = Add_Flexdesc( mod );
+		}
+		else
+		{
+			g_flexkey[g_numflexkeys].flexdesc = Add_Flexdesc( key.animationname );
+			g_flexkey[g_numflexkeys].flexpair = 0;
+		}
+
+		++g_numflexkeys;
+	}
+
+	AddFlexControllers( pSource );
+
+	AddBodyFlexRemaps( pSource );
+}
+
+//-----------------------------------------------------------------------------
+// Comparison operator for s_attachment_t
+//-----------------------------------------------------------------------------
+bool s_attachment_t::operator==( const s_attachment_t &rhs ) const
+{
+	if ( Q_strcmp( name, rhs.name ) )
+		return false;
+
+	if ( Q_stricmp( bonename, rhs.bonename ) ||
+		bone != rhs.bone ||
+		type != rhs.type ||
+		flags != rhs.flags ||
+		Q_memcmp( local.Base(), rhs.local.Base(), sizeof( local ) ) )
+	{
+		RadianEuler iEuler, jEuler;
+		Vector iPos, jPos;
+		MatrixAngles( local, iEuler, iPos );
+		MatrixAngles( rhs.local, jEuler, jPos );
+		MdlWarning(
+			"Attachments with the same name but different parameters found\n"
+			"  %s: ParentBone: %s Type: %d Flags: 0x%08x P: %6.2f %6.2f %6.2f R: %6.2f %6.2f %6.2f\n"
+			"  %s: ParentBone: %s Type: %d Flags: 0x%08x P: %6.2f %6.2f %6.2f R: %6.2f %6.2f %6.2f\n",
+			name, bonename, type, flags,
+			iPos.x, iPos.y, iPos.z, RAD2DEG( iEuler.x ), RAD2DEG( iEuler.y ), RAD2DEG( iEuler.z ),
+			rhs.name, rhs.bonename, rhs.type, rhs.flags,
+			jPos.x, jPos.y, jPos.z, RAD2DEG( jEuler.x ), RAD2DEG( jEuler.y ), RAD2DEG( jEuler.z ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Add attachments from the s_source_t that aren't already present in the
+// global attachment list.  At this point, the attachments aren't linked
+// to the bone, but since that is done by string matching on the bone name
+// the test for an attachment being a duplicate is still valid this early.
+//-----------------------------------------------------------------------------
+void AddBodyAttachments( s_source_t *pSource )
+{
+	for ( int i = 0; i < pSource->m_Attachments.Count(); ++i )
+	{
+		const s_attachment_t &sourceAtt = pSource->m_Attachments[i];
+
+		bool bDuplicate = false;
+
+		for ( int j = 0; j < g_numattachments; ++j )
+		{
+			if ( sourceAtt == g_attachment[j] )
+			{
+				bDuplicate = true;
+				break;
+			}
+		}
+
+		if ( bDuplicate )
+			continue;
+
+		if ( g_numattachments >= ARRAYSIZE( g_attachment ) )
+		{
+			MdlWarning( "Too Many Attachments (Max %d), Ignoring Attachment %s:%s\n",
+				ARRAYSIZE( g_attachment ), pSource->filename, pSource->m_Attachments[i].name );
+			continue;;
+		}
+
+		memcpy( &g_attachment[g_numattachments], &( pSource->m_Attachments[i] ), sizeof( s_attachment_t ) );
+		++g_numattachments;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Process a body command
+//-----------------------------------------------------------------------------
+void ProcessCmdBody( const char *pFullPath, CDmeSourceSkin *pSkin )
+{
+	if ( g_numbodyparts == 0 ) 
+	{
+		g_bodypart[g_numbodyparts].base = 1;
+	}
+	else 
+	{
+		g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
+	}
+	Q_strncpy( g_bodypart[g_numbodyparts].name, pSkin->m_SkinName.Get(), sizeof(g_bodypart[g_numbodyparts].name) );
+
+	g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
+	g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
+	g_bodypart[g_numbodyparts].nummodels = 1;
+
+	ProcessOptionStudio( g_model[g_nummodels], pFullPath, pSkin );
+
+	// Body command should add any flex commands in the source loaded
+	if ( g_model[g_nummodels]->source )
+	{
+		AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
+		AddBodyAttachments( g_model[g_nummodels]->source );
+		AddBodyFlexRules( g_model[ g_nummodels ]->source );
+	}
+
+	g_nummodels++;
+	g_numbodyparts++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse the body command from a .qc file
+//-----------------------------------------------------------------------------
+void Cmd_Body( )
+{
+	if ( !GetToken(false) ) 
+		return;
+
+	CDmeSourceSkin *pSourceSkin = CreateElement< CDmeSourceSkin >( "" );
+
+	// Set defaults
+	pSourceSkin->m_flScale = g_defaultscale;
+
+	pSourceSkin->m_SkinName = token;
+	if ( ParseOptionStudio( pSourceSkin ) )
+	{
+		ProcessCmdBody( pSourceSkin->GetRelativeFileName(), pSourceSkin );
+	}
+	DestroyElement( pSourceSkin );
+}
+
+
+
+/*
+===============
+===============
+*/
+
+void Grab_Animation( s_source_t *pSource, const char *pAnimName )
+{
+	Vector pos;
+	RadianEuler rot;
+	char cmd[1024];
+	int index;
+	int	t = -99999999;
+	int size;
+
+	s_sourceanim_t *pAnim = FindOrAddSourceAnim( pSource, pAnimName );
+	pAnim->startframe = -1;
+
+	size = pSource->numbones * sizeof( s_bone_t );
+
+	while ( GetLineInput() ) 
+	{
+		if ( sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &rot[0], &rot[1], &rot[2] ) == 7 )
+		{
+			if ( pAnim->startframe < 0 )
+			{
+				MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
+			}
+
+			scale_vertex( pos );
+			VectorCopy( pos, pAnim->rawanim[t][index].pos );
+			VectorCopy( rot, pAnim->rawanim[t][index].rot );
+
+			clip_rotations( rot ); // !!!
+			continue;
+		}
+		
+		if ( sscanf( g_szLine, "%1023s %d", cmd, &index ) == 0 )
+		{
+			MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
+			continue;
+		}
+
+		if ( !Q_stricmp( cmd, "time" ) ) 
+		{
+			t = index;
+			if ( pAnim->startframe == -1 )
+			{
+				pAnim->startframe = t;
+			}
+			if ( t < pAnim->startframe )
+			{
+				MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
+			}
+			if ( t > pAnim->endframe )
+			{
+				pAnim->endframe = t;
+			}
+			t -= pAnim->startframe;
+
+			if ( t >= pAnim->rawanim.Count())
+			{
+				s_bone_t *ptr = NULL;
+				pAnim->rawanim.AddMultipleToTail( t - pAnim->rawanim.Count() + 1, &ptr );
+			}
+
+			if ( pAnim->rawanim[t] != NULL )
+			{
+				continue;
+			}
+
+			pAnim->rawanim[t] = (s_bone_t *)kalloc( 1, size );
+
+			// duplicate previous frames keys
+			if ( t > 0 && pAnim->rawanim[t-1] )
+			{
+				for ( int j = 0; j < pSource->numbones; j++ )
+				{
+					VectorCopy( pAnim->rawanim[t-1][j].pos, pAnim->rawanim[t][j].pos );
+					VectorCopy( pAnim->rawanim[t-1][j].rot, pAnim->rawanim[t][j].rot );
+				}
+			}
+			continue;
+		}
+		
+		if ( !Q_stricmp( cmd, "end" ) ) 
+		{
+			pAnim->numframes = pAnim->endframe - pAnim->startframe + 1;
+
+			for ( t = 0; t < pAnim->numframes; t++ )
+			{
+				if ( pAnim->rawanim[t] == NULL)
+				{
+					MdlError( "%s is missing frame %d\n", pSource->filename, t + pAnim->startframe );
+				}
+			}
+
+			Build_Reference( pSource, pAnimName );
+			return;
+		}
+
+		MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
+	}
+
+	MdlError( "unexpected EOF: %s\n", pSource->filename );
+}
+
+
+
+
+
+int Option_Activity( s_sequence_t *psequence )
+{
+	qboolean found;
+
+	found = false;
+
+	GetToken(false);
+	V_strcpy_safe( psequence->activityname, token );
+
+	GetToken(false);
+	psequence->actweight = verify_atoi(token);
+
+	if ( psequence->actweight == 0 )
+	{
+		TokenError( "Activity %s has a zero weight (weights must be integers > 0)\n", psequence->activityname );
+	}
+
+	return 0;
+}
+
+
+int Option_ActivityModifier( s_sequence_t *psequence )
+{
+	GetToken(false);
+	V_strcpy_safe( psequence->activitymodifier[ psequence->numactivitymodifiers++ ].name, token );
+
+	return 0;
+}
+
+
+/*
+===============
+===============
+*/
+
+
+int Option_Event ( s_sequence_t *psequence )
+{
+	if (psequence->numevents + 1 >= MAXSTUDIOEVENTS)
+	{
+		TokenError("too many events\n");
+	}
+
+	GetToken (false);
+	
+	V_strcpy_safe( psequence->event[psequence->numevents].eventname, token );
+
+	GetToken( false );
+	psequence->event[psequence->numevents].frame = verify_atoi( token );
+
+	psequence->numevents++;
+
+	// option token
+	if (TokenAvailable())
+	{
+		GetToken( false );
+		if (token[0] == '}') // opps, hit the end
+			return 1;
+		// found an option
+		V_strcpy_safe( psequence->event[psequence->numevents-1].options, token );
+	}
+
+	return 0;
+}
+
+
+
+void Option_IKRule( s_ikrule_t *pRule )
+{
+	// chain
+	GetToken( false );
+
+	int i;
+	for ( i = 0; i < g_numikchains; i++)
+	{
+		if (stricmp( token, g_ikchain[i].name ) == 0)
+		{
+			break;
+		}
+	}
+	if (i >= g_numikchains)
+	{
+		TokenError( "unknown chain \"%s\" in ikrule\n", token );
+	}
+	pRule->chain = i;
+	// default slot
+	pRule->slot = i;
+
+	// type
+	GetToken( false );
+	if (stricmp( token, "touch" ) == 0)
+	{
+		pRule->type = IK_SELF;
+
+		// bone
+		GetToken( false );
+		V_strcpy_safe( pRule->bonename, token );
+	}
+	else if (stricmp( token, "footstep" ) == 0)
+	{
+		pRule->type = IK_GROUND;
+
+		pRule->height = g_ikchain[pRule->chain].height;
+		pRule->floor = g_ikchain[pRule->chain].floor;
+		pRule->radius = g_ikchain[pRule->chain].radius;
+	}
+	else if (stricmp( token, "attachment" ) == 0)
+	{
+		pRule->type = IK_ATTACHMENT;
+
+		// name of attachment
+		GetToken( false );
+		V_strcpy_safe( pRule->attachment, token );
+	}
+	else if (stricmp( token, "release" ) == 0)
+	{
+		pRule->type = IK_RELEASE;
+	}
+	else if (stricmp( token, "unlatch" ) == 0)
+	{
+		pRule->type = IK_UNLATCH;
+	}
+
+	pRule->contact = -1;
+
+	while (TokenAvailable())
+	{
+		GetToken( false );
+		if (stricmp( token, "height" ) == 0)
+		{
+			GetToken( false );
+			pRule->height = verify_atof( token );
+		}
+		else if (stricmp( token, "target" ) == 0)
+		{
+			// slot
+			GetToken( false );
+			pRule->slot = verify_atoi( token );
+		}
+		else if (stricmp( token, "range" ) == 0)
+		{
+			// ramp
+			GetToken( false );
+			if (token[0] == '.')
+				pRule->start = -1;
+			else
+				pRule->start = verify_atoi( token );
+
+			GetToken( false );
+			if (token[0] == '.')
+				pRule->peak = -1;
+			else
+				pRule->peak = verify_atoi( token );
+	
+			GetToken( false );
+			if (token[0] == '.')
+				pRule->tail = -1;
+			else
+				pRule->tail = verify_atoi( token );
+
+			GetToken( false );
+			if (token[0] == '.')
+				pRule->end = -1;
+			else
+				pRule->end = verify_atoi( token );
+		}
+		else if (stricmp( token, "floor" ) == 0)
+		{
+			GetToken( false );
+			pRule->floor = verify_atof( token );
+		}
+		else if (stricmp( token, "pad" ) == 0)
+		{
+			GetToken( false );
+			pRule->radius = verify_atof( token ) / 2.0f;
+		}
+		else if (stricmp( token, "radius" ) == 0)
+		{
+			GetToken( false );
+			pRule->radius = verify_atof( token );
+		}
+		else if (stricmp( token, "contact" ) == 0)
+		{
+			GetToken( false );
+			pRule->contact = verify_atoi( token );
+		}
+		else if (stricmp( token, "usesequence" ) == 0)
+		{
+			pRule->usesequence = true;
+			pRule->usesource = false;
+		}
+		else if (stricmp( token, "usesource" ) == 0)
+		{
+			pRule->usesequence = false;
+			pRule->usesource = true;
+		}
+		else if (stricmp( token, "fakeorigin" ) == 0)
+		{
+			GetToken( false );
+			pRule->pos.x = verify_atof( token );
+			GetToken( false );
+			pRule->pos.y = verify_atof( token );
+			GetToken( false );
+			pRule->pos.z = verify_atof( token );
+
+			pRule->bone = -1;
+		}
+		else if (stricmp( token, "fakerotate" ) == 0)
+		{
+			QAngle ang;
+
+			GetToken( false );
+			ang.x = verify_atof( token );
+			GetToken( false );
+			ang.y = verify_atof( token );
+			GetToken( false );
+			ang.z = verify_atof( token );
+
+			AngleQuaternion( ang, pRule->q );
+
+			pRule->bone = -1;
+		}
+		else if (stricmp( token, "bone" ) == 0)
+		{
+			V_strcpy_safe( pRule->bonename, token );
+		}
+		else
+		{
+			UnGetToken();
+			return;
+		}
+	}
+}
+
+
+/*
+=================
+Cmd_Origin
+=================
+*/
+void Cmd_Origin (void)
+{
+	GetToken (false);
+	g_defaultadjust.x = verify_atof (token);
+
+	GetToken (false);
+	g_defaultadjust.y = verify_atof (token);
+
+	GetToken (false);
+	g_defaultadjust.z = verify_atof (token);
+
+	if (TokenAvailable())
+	{
+		GetToken (false);
+		g_defaultrotation.z = DEG2RAD( verify_atof( token ) + 90);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the default root rotation so that the Y axis is up instead of the Z axis (for Maya)
+//-----------------------------------------------------------------------------
+void ProcessUpAxis( const RadianEuler &angles )
+{
+	g_defaultrotation = angles;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Set the default root rotation so that the Y axis is up instead of the Z axis (for Maya)
+//-----------------------------------------------------------------------------
+void Cmd_UpAxis( void )
+{
+	// We want to create a rotation that rotates from the art space
+	// (specified by the up direction) to a z up space
+	// Note: x, -x, -y are untested
+	RadianEuler angles( 0.0f, 0.0f, M_PI / 2.0f );
+	GetToken (false);
+	if (!Q_stricmp( token, "x" ))
+	{
+		// rotate 90 degrees around y to move x into z
+		angles.x = 0.0f;
+		angles.y = M_PI / 2.0f;
+	}
+	else if (!Q_stricmp( token, "-x" ))
+	{
+		// untested
+		angles.x = 0.0f;
+		angles.y = -M_PI / 2.0f;
+	}
+	else if (!Q_stricmp( token, "y" ))
+	{
+		// rotate 90 degrees around x to move y into z
+		angles.x = M_PI / 2.0f;
+		angles.y = 0.0f;
+	}
+	else if (!Q_stricmp( token, "-y" ))
+	{
+		// untested
+		angles.x = -M_PI / 2.0f;
+		angles.y = 0.0f;
+	}
+	else if (!Q_stricmp( token, "z" ))
+	{
+		// there's still a built in 90 degree Z rotation :(
+		angles.x = 0.0f;
+		angles.y = 0.0f;
+	}
+	else if (!Q_stricmp( token, "-z" ))
+	{
+		// there's still a built in 90 degree Z rotation :(
+		angles.x = 0.0f;
+		angles.y = 0.0f;
+	}
+	else
+	{
+		TokenError( "unknown $upaxis option: \"%s\"\n", token );
+		return;
+	}
+
+	ProcessUpAxis( angles );
+}
+
+
+/*
+=================
+=================
+*/
+void Cmd_ScaleUp (void)
+{
+	GetToken (false);
+	g_defaultscale = verify_atof (token);
+
+	g_currentscale = g_defaultscale;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Sets how what size chunks to cut the animations into
+//-----------------------------------------------------------------------------
+void Cmd_AnimBlockSize( void )
+{
+	GetToken( false );
+	g_animblocksize = verify_atoi( token );
+	if (g_animblocksize < 1024)
+	{
+		g_animblocksize *= 1024;
+	}
+	while (TokenAvailable())
+	{
+		GetToken( false );
+		if (!Q_stricmp( token, "nostall" ))
+		{
+			g_bNoAnimblockStall = true;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+static void FlipFacing( s_source_t *pSrc )
+{
+	unsigned short tmp;
+
+	int i, j;
+	for( i = 0; i < pSrc->nummeshes; i++ )
+	{
+		s_mesh_t *pMesh = &pSrc->mesh[i];
+		for( j = 0; j < pMesh->numfaces; j++ )
+		{
+			s_face_t &f = pSrc->face[pMesh->faceoffset + j];
+			tmp = f.b;  f.b  = f.c;  f.c  = tmp;
+		}
+	}
+}
+
+
+// Processes source comment line and extracts information about the data file
+void ProcessSourceComment( s_source_t *psource, const char *pCommentString )
+{
+	if ( char const *szSceneComment = StringAfterPrefix( pCommentString, "// SCENE=" ) )
+	{
+		char szScene[1024];
+		Q_strncpy( szScene, szSceneComment, ARRAYSIZE( szScene ) );
+
+		Q_FixSlashes( szScene );
+
+		ProcessOriginalContentFile( psource->filename, szScene );
+	}
+}
+
+// Processes original content file "szOriginalContentFile" that was used to generate
+// data file "szDataFile"
+void ProcessOriginalContentFile( char const *szDataFile, char const *szOriginalContentFile )
+{
+	// Early out: if no p4
+	if ( g_bNoP4 )
+		return;
+
+	char const *szContentDirRootEnd = strstr( szDataFile, "\\content\\" );
+	char const *szSceneName = strstr( szOriginalContentFile, "\\content\\" );
+	if ( szContentDirRootEnd && szSceneName )
+	{
+		char chScenePath[ MAX_PATH ] = {0};
+		Q_snprintf( chScenePath, sizeof( chScenePath ) - 1, "%.*s%s",
+			szContentDirRootEnd - szDataFile, szDataFile, szSceneName );
+		EnsureDependencyFileCheckedIn( chScenePath );
+	}
+	else if ( szContentDirRootEnd && !szSceneName )
+	{
+		// Assume relative path
+		char chScenePath[ MAX_PATH ] = {0};
+		Q_snprintf( chScenePath, sizeof( chScenePath ) - 1, "%.*s%s",
+			max( strrchr( szDataFile, '\\' ), strrchr( szDataFile, '/' ) ) + 1 - szDataFile,
+			szDataFile, szOriginalContentFile );
+		EnsureDependencyFileCheckedIn( chScenePath );
+	}
+	else
+	{
+		MdlWarning( "ProcessOriginalContentFile for '%s' cannot detect scene source file from '%s'!\n", szDataFile, szOriginalContentFile );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Checks to see if the model source was already loaded
+//-----------------------------------------------------------------------------
+static s_source_t *FindCachedSource( const char* name, const char* xext )
+{
+	int i;
+
+	if( xext[0] )
+	{
+		// we know what extension is necessary. . look for it.
+		Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.%s", cddir[numdirs], name, xext );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+	}
+	else
+	{
+		// we don't know what extension to use, so look for all of 'em.
+		Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.vrm", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+		Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.smd", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+		Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.dmx", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+		Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.xml", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+		Q_snprintf (g_szFilename, sizeof(g_szFilename), "%s%s.obj", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if ( !Q_stricmp( g_szFilename, g_source[i]->filename ) )
+				return g_source[i];
+		}
+		/*
+		sprintf (g_szFilename, "%s%s.vta", cddir[numdirs], name );
+		for (i = 0; i < g_numsources; i++)
+		{
+			if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
+				return g_source[i];
+		}
+		*/
+	}
+
+	// Not found
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Loads an animation/model source
+//-----------------------------------------------------------------------------
+s_source_t *Load_Source( const char *name, const char *ext, bool reverse, bool isActiveModel )
+{
+	if ( g_numsources >= MAXSTUDIOSEQUENCES )
+		TokenError( "Load_Source( %s ) - overflowed g_numsources.", name );
+
+	Assert(name);
+	int namelen = strlen(name) + 1;
+	char* pTempName = (char*)_alloca( namelen );
+	char xext[32];
+	int result = false;
+
+	V_strncpy( pTempName, name, namelen );
+	Q_ExtractFileExtension( pTempName, xext, sizeof( xext ) );
+
+	if (xext[0] == '\0')
+	{
+		V_strcpy_safe( xext, ext );
+	}
+	else
+	{
+		Q_StripExtension( pTempName, pTempName, namelen );
+	}
+
+	s_source_t* pSource = FindCachedSource( pTempName, xext );
+	if (pSource)
+	{
+		if (isActiveModel)
+			pSource->isActiveModel = true;
+		
+		return pSource;
+	}
+
+	g_source[g_numsources] = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
+	V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
+
+
+	if (isActiveModel)
+	{
+		g_source[g_numsources]->isActiveModel = true;
+	}
+
+	char const * load_extensions[] = { "vrm", "smd", "sma", "phys", "vta", "obj", "dmx", "xml" };
+	int ( *load_procs[] )( s_source_t * ) = { Load_VRM, Load_SMD, Load_SMD, Load_SMD, Load_VTA, Load_OBJ, Load_DMX, Load_DMX };
+
+	Assert( ARRAYSIZE(load_extensions) == ARRAYSIZE(load_procs) );
+	for ( int kk = 0; kk < ARRAYSIZE( load_extensions ); ++ kk )
+	{
+		if ( ( !result && xext[0] == '\0' ) || Q_stricmp( xext, load_extensions[kk] ) == 0)
+		{
+			Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.%s", cddir[numdirs], pTempName, load_extensions[kk] );
+			V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
+			result = (load_procs[kk])( g_source[g_numsources] );
+			
+			if ( result )
+				EnsureDependencyFileCheckedIn( g_source[g_numsources]->filename );
+		}
+	}
+
+	if (!g_bCreateMakefile && !result)
+	{
+		if (xext[0] == '\0')
+			TokenError( "could not load file '%s%s'\n", cddir[numdirs], pTempName );
+		else
+			TokenError( "could not load file '%s%s.%s'\n", cddir[numdirs], pTempName, xext );
+	}
+
+	if ( g_source[g_numsources]->numbones == 0 )
+	{
+		TokenError( "missing all bones in file '%s'\n", g_source[g_numsources]->filename );
+	}
+
+	// copy over default settings of when the model was loaded (since there's no actual animation for some of the systems)
+	VectorCopy( g_defaultadjust, g_source[g_numsources]->adjust );
+	g_source[g_numsources]->scale = 1.0f;
+	g_source[g_numsources]->rotation = g_defaultrotation;
+
+
+	g_numsources++;
+	if( reverse )
+	{
+		FlipFacing( g_source[g_numsources-1] );
+	}
+
+	return g_source[g_numsources-1];
+}
+
+
+s_sequence_t *LookupSequence( const char *name )
+{
+	int i;
+	for ( i = 0; i < g_sequence.Count(); ++i )
+	{
+		if ( !Q_stricmp( g_sequence[i].name, name ) )
+			return &g_sequence[i];
+	}
+	return NULL;
+}
+
+
+s_animation_t *LookupAnimation( const char *name )
+{
+	int i;
+	for ( i = 0; i < g_numani; i++)
+	{
+		if ( !Q_stricmp( g_panimation[i]->name, name ) )
+			return g_panimation[i];
+	}
+
+	s_sequence_t *pseq = LookupSequence( name );
+	return pseq ? pseq->panim[0][0] : NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: parse order dependant s_animcmd_t token for $animations
+//-----------------------------------------------------------------------------
+int ParseCmdlistToken( int &numcmds, s_animcmd_t *cmds )
+{
+	if (numcmds >= MAXSTUDIOCMDS)
+	{
+		return false;
+	}
+	s_animcmd_t *pcmd = &cmds[numcmds];
+	if (stricmp("fixuploop", token ) == 0)
+	{
+		pcmd->cmd = CMD_FIXUP;
+
+		GetToken( false );
+		pcmd->u.fixuploop.start = verify_atoi( token );
+		GetToken( false );
+		pcmd->u.fixuploop.end = verify_atoi( token );
+	}
+	else if (strnicmp("weightlist", token, 6 ) == 0)
+	{
+		GetToken( false );
+
+		int i;
+		for ( i = 1; i < g_numweightlist; i++)
+		{
+			if (stricmp( g_weightlist[i].name, token ) == 0)
+			{
+				break;
+			}
+		}
+		if (i == g_numweightlist)
+		{
+			TokenError( "unknown weightlist '%s\'\n", token );
+		}
+		pcmd->cmd = CMD_WEIGHTS;
+		pcmd->u.weightlist.index = i;
+	}
+	else if (stricmp("subtract", token ) == 0)
+	{
+		pcmd->cmd = CMD_SUBTRACT;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown subtract animation '%s\'\n", token );
+		}
+
+		pcmd->u.subtract.ref = extanim;
+
+		GetToken( false );
+		pcmd->u.subtract.frame = verify_atoi( token );
+
+		pcmd->u.subtract.flags |= STUDIO_POST;
+	}
+	else if (stricmp("presubtract", token ) == 0) // FIXME: rename this to something better
+	{
+		pcmd->cmd = CMD_SUBTRACT;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown presubtract animation '%s\'\n", token );
+		}
+
+		pcmd->u.subtract.ref = extanim;
+
+		GetToken( false );
+		pcmd->u.subtract.frame = verify_atoi( token );
+	}
+	else if (stricmp( "alignto", token ) == 0)
+	{
+		pcmd->cmd = CMD_AO;
+
+		pcmd->u.ao.pBonename = NULL;
+
+		GetToken( false );
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown alignto animation '%s\'\n", token );
+		}
+
+		pcmd->u.ao.ref = extanim;
+		pcmd->u.ao.motiontype = STUDIO_X | STUDIO_Y;
+		pcmd->u.ao.srcframe = 0;
+		pcmd->u.ao.destframe = 0;
+	}
+	else if (stricmp( "align", token ) == 0)
+	{
+		pcmd->cmd = CMD_AO;
+
+		pcmd->u.ao.pBonename = NULL;
+
+		GetToken( false );
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown align animation '%s\'\n", token );
+		}
+
+		pcmd->u.ao.ref = extanim;
+
+		// motion type to match
+		pcmd->u.ao.motiontype = 0;
+		GetToken( false );
+		int ctrl;
+		while ((ctrl = lookupControl( token )) != -1)
+		{
+			pcmd->u.ao.motiontype |= ctrl;
+			GetToken( false );
+		}
+		if (pcmd->u.ao.motiontype == 0)
+		{
+			TokenError( "missing controls on align\n" );
+		}
+
+		// frame of reference animation to match
+		pcmd->u.ao.srcframe = verify_atoi( token );
+
+		// against what frame of the current animation
+		GetToken( false );
+		pcmd->u.ao.destframe = verify_atoi( token );
+	}
+	else if (stricmp( "alignboneto", token ) == 0)
+	{
+		pcmd->cmd = CMD_AO;
+
+		GetToken( false );
+		pcmd->u.ao.pBonename = strdup( token );
+		
+		GetToken( false );
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown alignboneto animation '%s\'\n", token );
+		}
+
+		pcmd->u.ao.ref = extanim;
+		pcmd->u.ao.motiontype = STUDIO_X | STUDIO_Y;
+		pcmd->u.ao.srcframe = 0;
+		pcmd->u.ao.destframe = 0;
+	}
+	else if (stricmp( "alignbone", token ) == 0)
+	{
+		pcmd->cmd = CMD_AO;
+
+		GetToken( false );
+		pcmd->u.ao.pBonename = strdup( token );
+		
+		GetToken( false );
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown alignboneto animation '%s\'\n", token );
+		}
+
+		pcmd->u.ao.ref = extanim;
+
+		// motion type to match
+		pcmd->u.ao.motiontype = 0;
+		GetToken( false );
+		int ctrl;
+		while ((ctrl = lookupControl( token )) != -1)
+		{
+			pcmd->u.ao.motiontype |= ctrl;
+			GetToken( false );
+		}
+		if (pcmd->u.ao.motiontype == 0)
+		{
+			TokenError( "missing controls on align\n" );
+		}
+
+		// frame of reference animation to match
+		pcmd->u.ao.srcframe = verify_atoi( token );
+
+		// against what frame of the current animation
+		GetToken( false );
+		pcmd->u.ao.destframe = verify_atoi( token );
+	}
+	else if (stricmp( "match", token ) == 0)
+	{
+		pcmd->cmd = CMD_MATCH;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown match animation '%s\'\n", token );
+		}
+
+		pcmd->u.match.ref = extanim;
+	}
+	else if (stricmp( "matchblend", token ) == 0)
+	{
+		pcmd->cmd = CMD_MATCHBLEND;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			MdlError( "unknown match animation '%s\'\n", token );
+		}
+
+		pcmd->u.match.ref = extanim;
+
+		// frame of reference animation to match
+		GetToken( false );
+		pcmd->u.match.srcframe = verify_atoi( token );
+
+		// against what frame of the current animation
+		GetToken( false );
+		pcmd->u.match.destframe = verify_atoi( token );
+
+		// backup and starting match in here
+		GetToken( false );
+		pcmd->u.match.destpre = verify_atoi( token );
+
+		// continue blending match till here
+		GetToken( false );
+		pcmd->u.match.destpost = verify_atoi( token );
+
+	}
+	else if (stricmp( "worldspaceblend", token ) == 0)
+	{
+		pcmd->cmd = CMD_WORLDSPACEBLEND;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown worldspaceblend animation '%s\'\n", token );
+		}
+
+		pcmd->u.world.ref = extanim;
+		pcmd->u.world.startframe = 0;
+		pcmd->u.world.loops = false;
+	}
+	else if (stricmp( "worldspaceblendloop", token ) == 0)
+	{
+		pcmd->cmd = CMD_WORLDSPACEBLEND;
+
+		GetToken( false );
+
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown worldspaceblend animation '%s\'\n", token );
+		}
+
+		pcmd->u.world.ref = extanim;
+
+		GetToken( false );
+		pcmd->u.world.startframe = atoi( token );
+
+		pcmd->u.world.loops = true;
+	}
+	else if (stricmp( "rotateto", token ) == 0)
+	{
+		pcmd->cmd = CMD_ANGLE;
+
+		GetToken( false );
+		pcmd->u.angle.angle = verify_atof( token );
+	}
+	else if (stricmp( "ikrule", token ) == 0)
+	{
+		pcmd->cmd = CMD_IKRULE;
+
+		pcmd->u.ikrule.pRule = (s_ikrule_t *)kalloc( 1, sizeof( s_ikrule_t ) );
+
+		Option_IKRule( pcmd->u.ikrule.pRule );
+	}
+	else if (stricmp( "ikfixup", token ) == 0)
+	{
+		pcmd->cmd = CMD_IKFIXUP;
+
+		pcmd->u.ikfixup.pRule = (s_ikrule_t *)kalloc( 1, sizeof( s_ikrule_t ) );
+
+		Option_IKRule( pcmd->u.ikrule.pRule );
+	}
+	else if (stricmp( "walkframe", token ) == 0)
+	{
+		pcmd->cmd = CMD_MOTION;
+
+		// frame
+		GetToken( false );
+		pcmd->u.motion.iEndFrame = verify_atoi( token );
+
+		// motion type to match
+		pcmd->u.motion.motiontype = 0;
+		while (TokenAvailable())
+		{
+			GetToken( false );
+			int ctrl = lookupControl( token );
+			if (ctrl != -1)
+			{
+				pcmd->u.motion.motiontype |= ctrl;
+			}
+			else
+			{
+				UnGetToken();
+				break;
+			}
+		}
+
+		/*
+		GetToken( false ); // X
+		pcmd->u.motion.x = verify_atof( token );
+
+		GetToken( false ); // Y
+		pcmd->u.motion.y = verify_atof( token );
+
+		GetToken( false ); // A
+		pcmd->u.motion.zr = verify_atof( token );
+		*/
+	}
+	else if (stricmp( "walkalignto", token ) == 0)
+	{
+		pcmd->cmd = CMD_REFMOTION;
+
+		GetToken( false );
+		pcmd->u.motion.iEndFrame = verify_atoi( token );
+
+		pcmd->u.motion.iSrcFrame = pcmd->u.motion.iEndFrame;
+
+		GetToken( false ); // reference animation
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown alignto animation '%s\'\n", token );
+		}
+		pcmd->u.motion.pRefAnim = extanim;
+
+		pcmd->u.motion.iRefFrame = 0;
+
+		// motion type to match
+		pcmd->u.motion.motiontype = 0;
+		while (TokenAvailable())
+		{
+			GetToken( false );
+			int ctrl = lookupControl( token );
+			if (ctrl != -1)
+			{
+				pcmd->u.motion.motiontype |= ctrl;
+			}
+			else
+			{
+				UnGetToken();
+				break;
+			}
+		}
+
+
+		/*
+		GetToken( false ); // X
+		pcmd->u.motion.x = verify_atof( token );
+
+		GetToken( false ); // Y
+		pcmd->u.motion.y = verify_atof( token );
+
+		GetToken( false ); // A
+		pcmd->u.motion.zr = verify_atof( token );
+		*/
+	}
+	else if (stricmp( "walkalign", token ) == 0)
+	{
+		pcmd->cmd = CMD_REFMOTION;
+
+		// end frame to apply motion over
+		GetToken( false );
+		pcmd->u.motion.iEndFrame = verify_atoi( token );
+
+		// reference animation
+		GetToken( false );
+		s_animation_t *extanim = LookupAnimation( token );
+		if (extanim == NULL)
+		{
+			TokenError( "unknown alignto animation '%s\'\n", token );
+		}
+		pcmd->u.motion.pRefAnim = extanim;
+
+		// motion type to match
+		pcmd->u.motion.motiontype = 0;
+		while (TokenAvailable())
+		{
+			GetToken( false );
+			int ctrl = lookupControl( token );
+			if (ctrl != -1)
+			{
+				pcmd->u.motion.motiontype |= ctrl;
+			}
+			else
+			{
+				break;
+			}
+		}
+		if (pcmd->u.motion.motiontype == 0)
+		{
+			TokenError( "missing controls on walkalign\n" );
+		}
+
+		// frame of reference animation to match
+		pcmd->u.motion.iRefFrame = verify_atoi( token );
+
+		// against what frame of the current animation
+		GetToken( false );
+		pcmd->u.motion.iSrcFrame = verify_atoi( token );
+	}
+	else if (stricmp("derivative", token ) == 0)
+	{
+		pcmd->cmd = CMD_DERIVATIVE;
+
+		// get scale
+		GetToken( false );
+		pcmd->u.derivative.scale = verify_atof( token );
+	}
+	else if (stricmp("noanimation", token ) == 0)
+	{
+		pcmd->cmd = CMD_NOANIMATION;
+	}
+	else if (stricmp("lineardelta", token ) == 0)
+	{
+		pcmd->cmd = CMD_LINEARDELTA;
+		pcmd->u.linear.flags |= STUDIO_AL_POST;
+	}
+	else if (stricmp("splinedelta", token ) == 0)
+	{
+		pcmd->cmd = CMD_LINEARDELTA;
+		pcmd->u.linear.flags |= STUDIO_AL_POST;
+		pcmd->u.linear.flags |= STUDIO_AL_SPLINE;
+	}
+	else if (stricmp("compress", token ) == 0)
+	{
+		pcmd->cmd = CMD_COMPRESS;
+
+		// get frames to skip
+		GetToken( false );
+		pcmd->u.compress.frames = verify_atoi( token );
+	}
+	else if (stricmp("numframes", token ) == 0)
+	{
+		pcmd->cmd = CMD_NUMFRAMES;
+
+		// get frames to force
+		GetToken( false );
+		pcmd->u.compress.frames = verify_atoi( token );
+	}
+	else if (stricmp("counterrotate", token ) == 0)
+	{
+		pcmd->cmd = CMD_COUNTERROTATE;
+
+		// get bone name
+		GetToken( false );
+		pcmd->u.counterrotate.pBonename = strdup( token );
+	}
+	else if (stricmp("counterrotateto", token ) == 0)
+	{
+		pcmd->cmd = CMD_COUNTERROTATE;
+
+		pcmd->u.counterrotate.bHasTarget = true;
+
+		// get pitch
+		GetToken( false );
+		pcmd->u.counterrotate.targetAngle[0] = verify_atof( token );
+
+		// get yaw
+		GetToken( false );
+		pcmd->u.counterrotate.targetAngle[1] = verify_atof( token );
+
+		// get roll
+		GetToken( false );
+		pcmd->u.counterrotate.targetAngle[2] = verify_atof( token );
+
+		// get bone name
+		GetToken( false );
+		pcmd->u.counterrotate.pBonename = strdup( token );
+	}
+	else if (stricmp("localhierarchy", token ) == 0)
+	{
+		pcmd->cmd = CMD_LOCALHIERARCHY;
+
+		// get bone name
+		GetToken( false );
+		pcmd->u.localhierarchy.pBonename = strdup( token );
+
+		// get parent name
+		GetToken( false );
+		pcmd->u.localhierarchy.pParentname = strdup( token );
+
+		pcmd->u.localhierarchy.start = -1;
+		pcmd->u.localhierarchy.peak = -1;
+		pcmd->u.localhierarchy.tail = -1;
+		pcmd->u.localhierarchy.end = -1;
+
+		if (TokenAvailable())
+		{
+			GetToken( false );
+			if (stricmp( token, "range" ) == 0)
+			{
+				//
+				GetToken( false );
+				pcmd->u.localhierarchy.start = verify_atof_with_null( token );
+
+				//
+				GetToken( false );
+				pcmd->u.localhierarchy.peak = verify_atof_with_null( token );
+
+				//
+				GetToken( false );
+				pcmd->u.localhierarchy.tail = verify_atof_with_null( token );
+
+				//
+				GetToken( false );
+				pcmd->u.localhierarchy.end = verify_atof_with_null( token );
+			}
+			else
+			{
+				UnGetToken();
+			}
+		}
+	}
+	else
+	{
+		return false;
+	}
+	numcmds++;
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: parse order independant s_animation_t token for $animations
+//-----------------------------------------------------------------------------
+bool ParseAnimationToken( s_animation_t *panim )
+{
+	if ( !Q_stricmp( "if", token ) )
+	{
+		// fixme: add expression evaluation
+		GetToken( false );
+		if (atoi( token ) == 0 && stricmp( token, "true" ) != 0)
+		{
+			GetToken(true);
+			if (token[0] == '{')
+			{
+				int depth = 1;
+				while (TokenAvailable() && depth > 0)
+				{
+					GetToken( true );
+					if (stricmp("{", token ) == 0)
+					{
+						depth++;
+					}
+					else if (stricmp("}", token ) == 0)
+					{
+						depth--;
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	if ( !Q_stricmp( "fps", token ) )
+	{
+		GetToken( false );
+		panim->fps = verify_atof( token );
+		if ( panim->fps <= 0.0f )
+		{
+			TokenError( "ParseAnimationToken:  fps (%f from '%s') <= 0.0\n", panim->fps, token );
+		}
+		return true;
+	}
+	
+	if ( !Q_stricmp( "origin", token ) )
+	{
+		GetToken (false);
+		panim->adjust.x = verify_atof (token);
+
+		GetToken (false);
+		panim->adjust.y = verify_atof (token);
+
+		GetToken (false);
+		panim->adjust.z = verify_atof (token);
+		return true;
+	}
+	
+	if ( !Q_stricmp( "rotate", token ) )
+	{
+		GetToken( false );
+		// FIXME: broken for Maya
+		panim->rotation.z = DEG2RAD( verify_atof( token ) + 90 );
+		return true;
+	}
+	
+	if ( !Q_stricmp( "angles", token ) )
+	{
+		GetToken( false );
+		panim->rotation.x = DEG2RAD( verify_atof( token ) );
+		GetToken( false );
+		panim->rotation.y = DEG2RAD( verify_atof( token ) );
+		GetToken( false );
+		panim->rotation.z = DEG2RAD( verify_atof( token ) + 90.0f);
+		return true;
+	}
+	
+	if ( !Q_stricmp( "scale", token ) )
+	{
+		GetToken( false );
+		panim->scale = verify_atof( token );
+		return true;
+	}
+	
+	if ( !Q_strnicmp( "loop", token, 4 ) )
+	{
+		panim->flags |= STUDIO_LOOPING;
+		return true;
+	}
+	
+	if ( !Q_strnicmp( "startloop", token, 5 ) )
+	{
+		GetToken( false );
+		panim->looprestart = verify_atoi( token );
+		panim->flags |= STUDIO_LOOPING;
+		return true;
+	}
+	
+	if ( !Q_stricmp( "fudgeloop", token ) )
+	{
+		panim->fudgeloop = true;
+		panim->flags |= STUDIO_LOOPING;
+		return true;
+	}
+	
+	if ( !Q_strnicmp( "snap", token, 4 ) )
+	{
+		panim->flags |= STUDIO_SNAP;
+		return true;
+	}
+	
+	if ( !Q_strnicmp( "frame", token, 5 ) )
+	{
+		GetToken( false );
+		panim->startframe = verify_atoi( token );
+		GetToken( false );
+		panim->endframe = verify_atoi( token );
+
+		// NOTE: This always affects the first source anim read in
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, panim->animationname );
+		if ( pSourceAnim )
+		{
+			if ( panim->startframe < pSourceAnim->startframe )
+			{
+				panim->startframe = pSourceAnim->startframe;
+			}
+
+			if ( panim->endframe > pSourceAnim->endframe )
+			{
+				panim->endframe = pSourceAnim->endframe;
+			}
+		}
+
+		if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
+		{
+			TokenError( "end frame before start frame in %s", panim->name );
+		}
+
+		panim->numframes = panim->endframe - panim->startframe + 1;
+
+		return true;
+	}
+
+	if ( !Q_stricmp( "blockname", token ) )
+	{
+		GetToken( false );
+		s_sourceanim_t *pSourceAnim = FindSourceAnim( panim->source, token );
+
+		// NOTE: This always affects the first source anim read in
+		if ( pSourceAnim )
+		{
+			panim->startframe = pSourceAnim->startframe;
+			panim->endframe = pSourceAnim->endframe;
+
+			if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
+			{
+				TokenError( "end frame before start frame in %s", panim->name );
+			}
+
+			panim->numframes = panim->endframe - panim->startframe + 1;
+			Q_strncpy( panim->animationname, token, sizeof(panim->animationname) );
+		}
+		else
+		{
+			MdlError( "Requested unknown animation block name %s\n", token );
+		}
+		return true;
+	}
+
+	if ( !Q_stricmp( "post", token ) )
+	{
+		panim->flags |= STUDIO_POST;
+		return true;
+	}
+	
+	if ( !Q_stricmp( "noautoik", token ) )
+	{
+		panim->noAutoIK = true;
+		return true;
+	}
+	
+	if ( !Q_stricmp( "autoik", token ) )
+	{
+		panim->noAutoIK = false;
+		return true;
+	}
+	
+	if ( ParseCmdlistToken( panim->numcmds, panim->cmds ) )
+		return true;
+
+	if ( !Q_stricmp( "cmdlist", token ) )
+	{
+		GetToken( false ); // A
+
+		int i;
+		for ( i = 0; i < g_numcmdlists; i++)
+		{
+			if (stricmp( g_cmdlist[i].name, token) == 0)
+			{
+				break;
+			}
+		}
+		if (i == g_numcmdlists)
+			TokenError( "unknown cmdlist %s\n", token );
+
+		for (int j = 0; j < g_cmdlist[i].numcmds; j++)
+		{
+			if (panim->numcmds >= MAXSTUDIOCMDS)
+			{
+				TokenError("Too many cmds in %s\n", panim->name );
+			}
+			panim->cmds[panim->numcmds++] = g_cmdlist[i].cmds[j];
+		}
+		return true;
+	}
+
+	if ( !Q_stricmp( "motionrollback", token ) )
+	{
+		GetToken( false );
+		panim->motionrollback = atof( token );
+		return true;
+	}
+
+	if ( !Q_stricmp( "noanimblock", token ) )
+	{
+		panim->disableAnimblocks = true;
+		return true;
+	}
+
+	if ( !Q_stricmp( "noanimblockstall", token ) )
+	{
+		panim->isFirstSectionLocal = true;
+		return true;
+	}
+
+	if ( lookupControl( token ) != -1 )
+	{
+		panim->motiontype |= lookupControl( token );
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: create named order dependant s_animcmd_t blocks, used as replicated token list for $animations
+//-----------------------------------------------------------------------------
+
+void Cmd_Cmdlist( )
+{
+	int depth = 0;
+
+	// name
+	GetToken(false);
+	V_strcpy_safe( g_cmdlist[g_numcmdlists].name, token );
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+		else if (ParseCmdlistToken( g_cmdlist[g_numcmdlists].numcmds, g_cmdlist[g_numcmdlists].cmds ))
+		{
+
+		}
+		else
+		{
+			TokenError( "unknown command: %s\n", token );
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	};
+
+	g_numcmdlists++;
+}
+
+int ParseAnimation( s_animation_t *panim, bool isAppend );
+int ParseEmpty( void );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: allocate an entry for $animation
+//-----------------------------------------------------------------------------
+void Cmd_Animation( )
+{
+	// name
+	GetToken(false);
+
+	s_animation_t *panim = LookupAnimation( token );
+
+	if (panim != NULL)
+	{
+		if (!panim->isOverride)
+		{
+			TokenError( "Duplicate animation name \"%s\"\n", token );
+		}
+		else
+		{
+			panim->doesOverride = true;
+			ParseEmpty();
+			return;
+		}
+	}
+
+	// allocate animation entry
+	g_panimation[g_numani] = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
+	g_panimation[g_numani]->index = g_numani;
+	panim = g_panimation[g_numani];
+	V_strcpy_safe( panim->name, token );
+	g_numani++;
+
+	// filename
+	GetToken(false);
+	V_strcpy_safe( panim->filename, token );
+
+	panim->source = Load_Source( panim->filename, "" );
+	if ( panim->source->m_Animations.Count() )
+	{
+		s_sourceanim_t *pSourceAnim = &panim->source->m_Animations[0];
+		panim->startframe = pSourceAnim->startframe;
+		panim->endframe = pSourceAnim->endframe;
+		Q_strncpy( panim->animationname, pSourceAnim->animationname, sizeof(panim->animationname) );
+	}
+	else
+	{
+		panim->startframe = 0;
+		panim->endframe = 0;
+		Q_strncpy( panim->animationname, "", sizeof(panim->animationname) );
+	}
+	VectorCopy( g_defaultadjust, panim->adjust );
+	panim->rotation = g_defaultrotation;
+	panim->scale = 1.0f;
+	panim->fps = 30.0;
+	panim->motionrollback = g_flDefaultMotionRollback;
+
+	ParseAnimation( panim, false );
+
+	panim->numframes = panim->endframe - panim->startframe + 1;
+
+	//CheckAutoShareAnimationGroup( panim->name );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: wrapper for parsing $animation tokens
+//-----------------------------------------------------------------------------
+
+int ParseAnimation( s_animation_t *panim, bool isAppend )
+{
+	int depth = 0;
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return 1;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+		else if (ParseAnimationToken( panim ))
+		{
+
+		}
+		else
+		{
+			TokenError( "Unknown animation option\'%s\'\n", token );
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	};
+
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: create a virtual $animation command from a $sequence reference
+//-----------------------------------------------------------------------------
+s_animation_t *Cmd_ImpliedAnimation( s_sequence_t *psequence, const char *filename )
+{
+	// allocate animation entry
+	g_panimation[g_numani] = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
+	g_panimation[g_numani]->index = g_numani;
+	s_animation_t *panim = g_panimation[g_numani];
+	g_numani++;
+
+	panim->isImplied = true;
+
+	panim->startframe = 0;
+	panim->endframe = MAXSTUDIOANIMFRAMES - 1;
+
+	V_strcpy_safe( panim->name, "@" );
+	V_strcat_safe( panim->name, psequence->name );
+	V_strcpy_safe( panim->filename, filename );
+
+	VectorCopy( g_defaultadjust, panim->adjust );
+	panim->scale = 1.0f;
+	panim->rotation = g_defaultrotation;
+	panim->fps = 30;
+	panim->motionrollback = g_flDefaultMotionRollback;
+
+	//panim->source = Load_Source( panim->filename, "smd" );
+	panim->source = Load_Source( panim->filename, "" );
+	if ( panim->source->m_Animations.Count() )
+	{
+		s_sourceanim_t *pSourceAnim = &panim->source->m_Animations[0];
+		Q_strncpy( panim->animationname, panim->source->m_Animations[0].animationname, sizeof(panim->animationname) );
+		if ( panim->startframe < pSourceAnim->startframe )
+		{
+			panim->startframe = pSourceAnim->startframe;
+		}
+		
+		if ( panim->endframe > pSourceAnim->endframe )
+		{
+			panim->endframe = pSourceAnim->endframe;
+		}
+	}
+	else
+	{
+		Q_strncpy( panim->animationname, "", sizeof( panim->animationname ) );
+	}
+
+	if ( !g_bCreateMakefile && panim->endframe < panim->startframe )
+	{
+		TokenError( "end frame before start frame in %s", panim->name );
+	}
+
+	panim->numframes = panim->endframe - panim->startframe + 1;
+
+	//CheckAutoShareAnimationGroup( panim->name );
+
+	return panim;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: copy globally reavent $animation options from one $animation to another
+//-----------------------------------------------------------------------------
+
+void CopyAnimationSettings( s_animation_t *pdest, s_animation_t *psrc )
+{
+	pdest->fps = psrc->fps;
+
+	VectorCopy( psrc->adjust, pdest->adjust );
+	pdest->scale = psrc->scale;
+	pdest->rotation = psrc->rotation;
+
+	pdest->motiontype = psrc->motiontype;
+
+	//Adrian - Hey! Revisit me later.
+	/*if (pdest->startframe < psrc->startframe)
+		pdest->startframe = psrc->startframe;
+	
+	if (pdest->endframe > psrc->endframe)
+		pdest->endframe = psrc->endframe;
+	
+	if (pdest->endframe < pdest->startframe)
+		TokenError( "fixedup end frame before start frame in %s", pdest->name );
+
+	pdest->numframes = pdest->endframe - pdest->startframe + 1;*/
+
+	for (int i = 0; i < psrc->numcmds; i++)
+	{
+		if (pdest->numcmds >= MAXSTUDIOCMDS)
+		{
+			TokenError("Too many cmds in %s\n", pdest->name );
+		}
+		pdest->cmds[pdest->numcmds++] = psrc->cmds[i];
+	}
+}
+
+int ParseSequence( s_sequence_t *pseq, bool isAppend );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: allocate an entry for $sequence
+//-----------------------------------------------------------------------------
+s_sequence_t *ProcessCmdSequence( const char *pSequenceName )
+{
+	s_animation_t *panim = LookupAnimation( pSequenceName );
+
+	// allocate sequence
+	if ( panim != NULL )
+	{
+		if ( !panim->isOverride )
+		{
+			TokenError( "Duplicate sequence name \"%s\"\n", pSequenceName );
+		}
+		else
+		{
+			panim->doesOverride = true;
+			return NULL;
+		}
+	}
+
+	if ( g_sequence.Count() >= MAXSTUDIOSEQUENCES )
+	{
+		TokenError("Too many sequences (%d max)\n", MAXSTUDIOSEQUENCES );
+	}
+
+	s_sequence_t *pseq = &g_sequence[ g_sequence.AddToTail() ];
+	memset( pseq, 0, sizeof( s_sequence_t ) );
+
+	// initialize sequence
+	Q_strncpy( pseq->name, pSequenceName, sizeof(pseq->name) );
+
+	pseq->actweight = 0;
+	pseq->activityname[0] = '\0';
+	pseq->activity = -1; // -1 is the default for 'no activity'
+
+	pseq->paramindex[0] = -1;
+	pseq->paramindex[1] = -1;
+
+	pseq->groupsize[0] = 0;
+	pseq->groupsize[1] = 0;
+
+	pseq->fadeintime = 0.2;
+	pseq->fadeouttime = 0.2;
+	return pseq;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process the sequence command
+//-----------------------------------------------------------------------------
+void Cmd_Sequence( )
+{
+	if ( !GetToken(false) ) 
+		return;
+
+	// Find existing sequences
+	const char *pSequenceName = token;
+	s_animation_t *panim = LookupAnimation( pSequenceName );
+	if ( panim != NULL && panim->isOverride )
+	{
+		ParseEmpty( );
+	}
+
+	s_sequence_t *pseq = ProcessCmdSequence( pSequenceName );
+	if ( pseq )
+	{
+		ParseSequence( pseq, false );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Performs processing on a sequence
+//-----------------------------------------------------------------------------
+void ProcessSequence( s_sequence_t *pseq, int numblends, s_animation_t **animations, bool isAppend )
+{
+	if (isAppend)
+		return;
+
+	if ( numblends == 0 )
+	{
+		TokenError("no animations found\n");
+	}
+
+	if ( pseq->groupsize[0] == 0 )
+	{
+		if (numblends < 4)
+		{
+			pseq->groupsize[0] = numblends;
+			pseq->groupsize[1] = 1;
+		}
+		else
+		{
+			int i = sqrt( (float) numblends );
+			if (i * i == numblends)
+			{
+				pseq->groupsize[0] = i;
+				pseq->groupsize[1] = i;
+			}
+			else
+			{
+				TokenError( "non-square (%d) number of blends without \"blendwidth\" set\n", numblends );
+			}
+		}
+	}
+	else
+	{
+		pseq->groupsize[1] = numblends / pseq->groupsize[0];
+
+		if (pseq->groupsize[0] * pseq->groupsize[1] != numblends)
+		{
+			TokenError( "missing animation blends. Expected %d, found %d\n", 
+				pseq->groupsize[0] * pseq->groupsize[1], numblends );
+		}
+	}
+
+	for (int i = 0; i < numblends; i++)
+	{
+		int j = i % pseq->groupsize[0];
+		int k = i / pseq->groupsize[0];
+
+		pseq->panim[j][k] = animations[i];
+
+		if (i > 0 && animations[i]->isImplied)
+		{
+			CopyAnimationSettings( animations[i], animations[0] );
+		}
+		animations[i]->isImplied = false; // don't copy any more commands
+		pseq->flags |= animations[i]->flags;
+	}
+
+	pseq->numblends = numblends;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: parse options unique to $sequence
+//-----------------------------------------------------------------------------
+int ParseSequence( s_sequence_t *pseq, bool isAppend )
+{
+	int depth = 0;
+	s_animation_t *animations[64];
+	int i, j, n;
+	int numblends = 0;
+
+	if (isAppend)
+	{
+		animations[0] = pseq->panim[0][0];
+	}
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return 1;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+		/*
+		else if (stricmp("deform", token ) == 0)
+		{
+			Option_Deform( pseq );
+		}
+		*/
+
+		else if (stricmp("event", token ) == 0)
+		{
+			depth -= Option_Event( pseq );
+		}
+		else if (stricmp("activity", token ) == 0)
+		{
+			Option_Activity( pseq );
+		}
+		else if (stricmp("activitymodifier", token ) == 0)
+		{
+			Option_ActivityModifier( pseq );
+		}
+		else if (strnicmp( token, "ACT_", 4 ) == 0)
+		{
+			UnGetToken( );
+			Option_Activity( pseq );
+		}
+
+		else if (stricmp("snap", token ) == 0)
+		{
+			pseq->flags |= STUDIO_SNAP;
+		}
+
+		else if (stricmp("blendwidth", token ) == 0)
+		{
+			GetToken( false );
+			pseq->groupsize[0] = verify_atoi( token );
+		}
+
+		else if (stricmp("blend", token ) == 0)
+		{
+			i = 0;
+			if (pseq->paramindex[0] != -1)
+			{
+				i = 1;
+			}
+
+			GetToken( false );
+			j = LookupPoseParameter( token );
+			pseq->paramindex[i] = j;
+			pseq->paramattachment[i] = -1;
+			GetToken( false );
+			pseq->paramstart[i] = verify_atof( token );
+			GetToken( false );
+			pseq->paramend[i] = verify_atof( token );
+
+			g_pose[j].min  = min( g_pose[j].min, pseq->paramstart[i] );
+			g_pose[j].min  = min( g_pose[j].min, pseq->paramend[i] );
+			g_pose[j].max  = max( g_pose[j].max, pseq->paramstart[i] );
+			g_pose[j].max  = max( g_pose[j].max, pseq->paramend[i] );
+		}
+		else if (stricmp("calcblend", token ) == 0)
+		{
+			i = 0;
+			if (pseq->paramindex[0] != -1)
+			{
+				i = 1;
+			}
+
+			GetToken( false );
+			j = LookupPoseParameter( token );
+			pseq->paramindex[i] = j;
+
+			GetToken( false );
+			pseq->paramattachment[i] = LookupAttachment( token );
+			if (pseq->paramattachment[i] == -1)
+			{
+				TokenError( "Unknown calcblend attachment \"%s\"\n", token );
+			}
+
+			GetToken( false );
+			pseq->paramcontrol[i] = lookupControl( token );
+		}
+		else if (stricmp("blendref", token ) == 0)
+		{
+			GetToken( false );
+			pseq->paramanim = LookupAnimation( token );
+			if (pseq->paramanim == NULL)
+			{
+				TokenError( "Unknown blendref animation \"%s\"\n", token );
+			}
+		}
+		else if (stricmp("blendcomp", token ) == 0)
+		{
+			GetToken( false );
+			pseq->paramcompanim = LookupAnimation( token );
+			if (pseq->paramcompanim == NULL)
+			{
+				TokenError( "Unknown blendcomp animation \"%s\"\n", token );
+			}
+		}
+		else if (stricmp("blendcenter", token ) == 0)
+		{
+			GetToken( false );
+			pseq->paramcenter = LookupAnimation( token );
+			if (pseq->paramcenter == NULL)
+			{
+				TokenError( "Unknown blendcenter animation \"%s\"\n", token );
+			}
+		}
+		else if (stricmp("node", token ) == 0)
+		{
+			GetToken( false );
+			pseq->entrynode = pseq->exitnode = LookupXNode( token );
+		}
+		else if (stricmp("transition", token ) == 0)
+		{
+			GetToken( false );
+			pseq->entrynode = LookupXNode( token );
+			GetToken( false );
+			pseq->exitnode = LookupXNode( token );
+		}
+		else if (stricmp("rtransition", token ) == 0)
+		{
+			GetToken( false );
+			pseq->entrynode = LookupXNode( token );
+			GetToken( false );
+			pseq->exitnode = LookupXNode( token );
+			pseq->nodeflags |= 1;
+		}
+		else if (stricmp("exitphase", token ) == 0)
+		{
+			GetToken( false );
+			pseq->exitphase = verify_atof( token );
+		}
+		else if (stricmp("delta", token) == 0)
+		{
+			pseq->flags |= STUDIO_DELTA;
+			pseq->flags |= STUDIO_POST;
+		}
+		else if (stricmp("worldspace", token) == 0)
+		{
+			pseq->flags |= STUDIO_WORLD;
+			pseq->flags |= STUDIO_POST;
+		}
+		else if (stricmp("post", token) == 0) // remove
+		{
+			pseq->flags |= STUDIO_POST; 
+		}
+		else if (stricmp("predelta", token) == 0)
+		{
+			pseq->flags |= STUDIO_DELTA;
+		}
+		else if (stricmp("autoplay", token) == 0)
+		{
+			pseq->flags |= STUDIO_AUTOPLAY;
+		}
+		else if (stricmp( "fadein", token ) == 0)
+		{
+			GetToken( false );
+			pseq->fadeintime = verify_atof( token );
+		}
+		else if (stricmp( "fadeout", token ) == 0)
+		{
+			GetToken( false );
+			pseq->fadeouttime = verify_atof( token );
+		}
+		else if (stricmp( "realtime", token ) == 0)
+		{
+			pseq->flags |= STUDIO_REALTIME;
+		}
+		else if (stricmp( "posecycle", token ) == 0)
+		{
+			pseq->flags |= STUDIO_CYCLEPOSE;
+
+			GetToken( false );
+			pseq->cycleposeindex = LookupPoseParameter( token );
+		}
+		else if (stricmp( "hidden", token ) == 0)
+		{
+			pseq->flags |= STUDIO_HIDDEN;
+		}
+		else if (stricmp( "addlayer", token ) == 0)
+		{
+			GetToken( false );
+			V_strcpy_safe( pseq->autolayer[pseq->numautolayers].name, token );
+			pseq->numautolayers++;
+		}
+		else if (stricmp( "iklock", token ) == 0)
+		{
+			GetToken(false);
+			V_strcpy_safe( pseq->iklock[pseq->numiklocks].name, token );
+
+			GetToken(false);
+			pseq->iklock[pseq->numiklocks].flPosWeight = verify_atof( token );
+
+			GetToken(false);
+			pseq->iklock[pseq->numiklocks].flLocalQWeight = verify_atof( token );
+		
+			pseq->numiklocks++;
+		}
+		else if (stricmp( "keyvalues", token ) == 0)
+		{
+			Option_KeyValues( &pseq->KeyValue );
+		}
+		else if (stricmp( "blendlayer", token ) == 0)
+		{
+			pseq->autolayer[pseq->numautolayers].flags = 0;
+
+			GetToken( false );
+			V_strcpy_safe( pseq->autolayer[pseq->numautolayers].name, token );
+
+			GetToken( false );
+			pseq->autolayer[pseq->numautolayers].start = verify_atof( token );
+
+			GetToken( false );
+			pseq->autolayer[pseq->numautolayers].peak = verify_atof( token );
+
+			GetToken( false );
+			pseq->autolayer[pseq->numautolayers].tail = verify_atof( token );
+
+			GetToken( false );
+			pseq->autolayer[pseq->numautolayers].end = verify_atof( token );
+
+			while (TokenAvailable( ))
+			{
+				GetToken( false );
+				if (stricmp( "xfade", token ) == 0)
+				{
+					pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_XFADE;
+				}
+				else if (stricmp( "spline", token ) == 0)
+				{
+					pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_SPLINE;
+				}
+				else if (stricmp( "noblend", token ) == 0)
+				{
+					pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_NOBLEND;
+				}
+				else if (stricmp( "poseparameter", token ) == 0)
+				{
+					pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_POSE;
+					GetToken( false );
+					pseq->autolayer[pseq->numautolayers].pose = LookupPoseParameter( token );
+				}
+				else if (stricmp( "local", token ) == 0)
+				{
+					pseq->autolayer[pseq->numautolayers].flags |= STUDIO_AL_LOCAL;
+					pseq->flags |= STUDIO_LOCAL;
+				}
+				else
+				{
+					UnGetToken();
+					break;
+				}
+			}
+
+			pseq->numautolayers++;
+		}
+		else if ((numblends || isAppend) && ParseAnimationToken( animations[0] ))
+		{
+
+		}
+		else if (!isAppend)
+		{
+			// assume it's an animation reference
+			// first look up an existing animation
+			for (n = 0; n < g_numani; n++)
+			{
+				if (stricmp( token, g_panimation[n]->name ) == 0)
+				{
+					animations[numblends++] = g_panimation[n];
+					break;
+				}
+			}
+
+			if (n >= g_numani)
+			{
+				// assume it's an implied animation
+				animations[numblends++] = Cmd_ImpliedAnimation( pseq, token );
+			}
+			// hack to allow animation commands to refer to same sequence
+			if (numblends == 1)
+			{
+				pseq->panim[0][0] = animations[0];
+			}
+
+		}
+		else
+		{
+			TokenError( "unknown command \"%s\"\n", token );
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	}
+
+	ProcessSequence( pseq, numblends, animations, isAppend );
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: throw away all the options for a specific sequence or animation
+//-----------------------------------------------------------------------------
+
+int ParseEmpty( )
+{
+	int depth = 0;
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return 1;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	}
+
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: append commands to either a sequence or an animation
+//-----------------------------------------------------------------------------
+void Cmd_Append( )
+{
+	GetToken(false);
+
+
+	s_sequence_t *pseq = LookupSequence( token );
+
+	if (pseq)
+	{
+		ParseSequence( pseq, true );
+		return;
+	}
+	else
+	{
+		s_animation_t *panim = LookupAnimation( token );
+
+		if (panim)
+		{
+			ParseAnimation( panim, true );
+			return;
+		}
+	}
+	TokenError( "unknown append animation %s\n", token );
+}
+
+
+
+void Cmd_Prepend( )
+{
+	GetToken(false);
+
+	s_sequence_t *pseq = LookupSequence( token );
+	int count = 0;
+	s_animation_t *panim = NULL;
+	int iRet =  false;
+
+	if (pseq)
+	{
+		panim = pseq->panim[0][0];
+		count = panim->numcmds;
+		iRet = ParseSequence( pseq, true );
+	}
+	else
+	{
+		panim = LookupAnimation( token );
+		if (panim)
+		{
+			count = panim->numcmds;
+			iRet = ParseAnimation( panim, true );
+		}
+	}
+	if (panim && count != panim->numcmds)
+	{
+		s_animcmd_t tmp;
+		tmp = panim->cmds[panim->numcmds - 1];
+		int i;
+		for (i = panim->numcmds - 1; i > 0; i--)
+		{
+			panim->cmds[i] = panim->cmds[i-1];
+		}
+		panim->cmds[0] = tmp;
+		return;
+	}
+	TokenError( "unknown prepend animation \"%s\"\n", token );
+}
+
+void Cmd_Continue( )
+{
+	GetToken(false);
+
+	s_sequence_t *pseq = LookupSequence( token );
+
+	if (pseq)
+	{
+		GetToken(true);
+		UnGetToken();
+		if (token[0] != '$')
+			ParseSequence( pseq, true );
+		return;
+	}
+	else
+	{
+		s_animation_t *panim = LookupAnimation( token );
+
+		if (panim)
+		{
+			GetToken(true);
+			UnGetToken();
+			if (token[0] != '$')
+				ParseAnimation( panim, true );
+			return;
+		}
+	}
+	TokenError( "unknown continue animation %s\n", token );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: foward declare an empty sequence
+//-----------------------------------------------------------------------------
+
+void Cmd_DeclareSequence( void )
+{
+	if (g_sequence.Count() >= MAXSTUDIOSEQUENCES)
+	{
+		TokenError("Too many sequences (%d max)\n", MAXSTUDIOSEQUENCES );
+	}
+
+	s_sequence_t *pseq = &g_sequence[ g_sequence.AddToTail() ];
+	memset( pseq, 0, sizeof( s_sequence_t ) );
+	pseq->flags = STUDIO_OVERRIDE;
+
+	// initialize sequence
+	GetToken( false );
+	V_strcpy_safe( pseq->name, token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: foward declare an empty sequence
+//-----------------------------------------------------------------------------
+void Cmd_DeclareAnimation( void )
+{
+	if (g_numani >= MAXSTUDIOANIMS)
+	{
+		TokenError("Too many animations (%d max)\n", MAXSTUDIOANIMS );
+	}
+
+	// allocate animation entry
+	s_animation_t *panim = (s_animation_t *)kalloc( 1, sizeof( s_animation_t ) );
+	g_panimation[g_numani] = panim;
+	panim->index = g_numani;
+	panim->flags = STUDIO_OVERRIDE;
+	g_numani++;
+	
+	// initialize animation
+	GetToken( false );
+	V_strcpy_safe( panim->name, token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: create named list of boneweights
+//-----------------------------------------------------------------------------
+void Option_Weightlist( s_weightlist_t *pweightlist )
+{
+	int depth = 0;
+	int i;
+
+	pweightlist->numbones = 0;
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+		else if (stricmp("posweight", token ) == 0)
+		{
+			i = pweightlist->numbones - 1;
+			if (i < 0)
+			{
+				MdlError( "Error with specifing bone Position weight \'%s:%s\'\n", pweightlist->name, pweightlist->bonename[i] );
+			}
+			GetToken( false );
+			pweightlist->boneposweight[i] = verify_atof( token );
+			if (pweightlist->boneweight[i] == 0 && pweightlist->boneposweight[i] > 0)
+			{
+				MdlError( "Non-zero Position weight with zero Rotation weight not allowed \'%s:%s %f %f\'\n", 
+					pweightlist->name, pweightlist->bonename[i], pweightlist->boneweight[i], pweightlist->boneposweight[i] );
+			}
+		}
+		else
+		{
+			i = pweightlist->numbones++;
+			if (i >= MAXWEIGHTSPERLIST)
+			{
+				TokenError("Too many bones (%d) in weightlist '%s'\n", i, pweightlist->name );
+			}
+			pweightlist->bonename[i] = strdup( token );
+			GetToken( false );
+			pweightlist->boneweight[i] = verify_atof( token );
+			pweightlist->boneposweight[i] = pweightlist->boneweight[i];
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	};
+}
+
+
+void Cmd_Weightlist( )
+{
+	int i;
+
+	if (!GetToken(false)) 
+		return;
+
+	if (g_numweightlist >= MAXWEIGHTLISTS)
+	{
+		TokenError( "Too many weightlist commands (%d)\n", MAXWEIGHTLISTS );
+	}
+
+	for (i = 1; i < g_numweightlist; i++)
+	{
+		if (stricmp( g_weightlist[i].name, token ) == 0)
+		{
+			TokenError( "Duplicate weightlist '%s'\n", token );
+		}
+	}
+
+	V_strcpy_safe( g_weightlist[i].name, token );
+
+	Option_Weightlist( &g_weightlist[g_numweightlist] );
+
+	g_numweightlist++;
+}
+
+void Cmd_DefaultWeightlist( )
+{
+	Option_Weightlist( &g_weightlist[0] );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Option_Eyeball( s_model_t *pmodel )
+{
+	Vector	tmp;
+	int i, j;
+	int mesh_material;
+	char szMeshMaterial[256];
+
+	s_eyeball_t *eyeball = &(pmodel->eyeball[pmodel->numeyeballs++]);
+
+	// name
+	GetToken (false);
+	V_strcpy_safe( eyeball->name, token );
+
+	// bone name
+	GetToken (false);
+	for (i = 0; i < pmodel->source->numbones; i++)
+	{
+		if ( !Q_stricmp( pmodel->source->localBone[i].name, token ) )
+		{
+			eyeball->bone = i;
+			break;
+		}
+	}
+	if (!g_bCreateMakefile && i >= pmodel->source->numbones)
+	{
+		TokenError( "unknown eyeball bone \"%s\"\n", token );
+	}
+
+	// X
+	GetToken (false);
+	tmp[0] = verify_atof (token);
+
+	// Y
+	GetToken (false);
+	tmp[1] = verify_atof (token);
+
+	// Z
+	GetToken (false);
+	tmp[2] = verify_atof (token);
+
+	// mesh material 
+	GetToken (false);
+	Q_strncpy( szMeshMaterial, token, sizeof(szMeshMaterial) );
+	mesh_material = UseTextureAsMaterial( LookupTexture( token ) );
+
+	// diameter
+	GetToken (false);
+	eyeball->radius = verify_atof (token) / 2.0;
+
+	// Z angle offset
+	GetToken (false);
+	eyeball->zoffset = tan( DEG2RAD( verify_atof (token) ) );
+
+	// iris material (no longer used, but we need to remove the token)
+	GetToken (false);
+
+	// pupil scale
+	GetToken (false);
+	eyeball->iris_scale = 1.0 / verify_atof( token );
+	
+	VectorCopy( tmp, eyeball->org );
+
+	for (i = 0; i < pmodel->source->nummeshes; i++)
+	{
+		j = pmodel->source->meshindex[i]; // meshes are internally stored by material index
+
+		if (j == mesh_material)
+		{
+			eyeball->mesh = i; // FIXME: should this be pre-adjusted?
+			break;
+		}
+	}
+
+	if (!g_bCreateMakefile && i >= pmodel->source->nummeshes)
+	{
+		TokenError("can't find eyeball texture \"%s\" on model\n", szMeshMaterial );
+	}
+	
+	// translate eyeball into bone space
+	VectorITransform( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->org );
+
+	matrix3x4_t vtmp;
+	AngleMatrix( g_defaultrotation, vtmp );
+
+	VectorIRotate( Vector( 0, 0, 1 ), vtmp, tmp );
+	VectorIRotate( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->up );
+
+	VectorIRotate( Vector( 1, 0, 0 ), vtmp, tmp );
+	VectorIRotate( tmp, pmodel->source->boneToPose[eyeball->bone], eyeball->forward );
+
+	// these get overwritten by "eyelid" data
+	eyeball->upperlidflexdesc = -1;
+	eyeball->lowerlidflexdesc = -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Option_Spherenormals( s_source_t *psource )
+{
+	Vector	pos;
+	int i, j;
+	int mesh_material;
+	char szMeshMaterial[256];
+
+	// mesh material 
+	GetToken (false);
+	V_strcpy_safe( szMeshMaterial, token );
+	mesh_material = UseTextureAsMaterial( LookupTexture( token ) );
+
+	// X
+	GetToken (false);
+	pos[0] = verify_atof (token);
+
+	// Y
+	GetToken (false);
+	pos[1] = verify_atof (token);
+
+	// Z
+	GetToken (false);
+	pos[2] = verify_atof (token);
+
+	for (i = 0; i < psource->nummeshes; i++)
+	{
+		j = psource->meshindex[i]; // meshes are internally stored by material index
+
+		if (j == mesh_material)
+		{
+			s_vertexinfo_t *vertex = &psource->vertex[psource->mesh[i].vertexoffset];
+
+			for (int k = 0; k < psource->mesh[i].numvertices; k++)
+			{
+				Vector n = vertex[k].position - pos;
+				VectorNormalize( n );
+				if (DotProduct( n, vertex[k].normal ) < 0.0)
+				{
+					vertex[k].normal = -1 * n;
+				}
+				else
+				{
+					vertex[k].normal = n;
+				}
+#if 0
+				vertex[k].normal[0] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
+				vertex[k].normal[1] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
+				vertex[k].normal[2] += 0.5f * ( 2.0f * ( ( float )rand() ) / ( float )VALVE_RAND_MAX ) - 1.0f;
+				VectorNormalize( vertex[k].normal );
+#endif
+			}
+			break;
+		}
+	}
+
+	if (i >= psource->nummeshes)
+	{
+		TokenError("can't find spherenormal texture \"%s\" on model\n", szMeshMaterial );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int Add_Flexdesc( const char *name )
+{
+	int flexdesc;
+	for ( flexdesc = 0; flexdesc < g_numflexdesc; flexdesc++)
+	{
+		if (stricmp( name, g_flexdesc[flexdesc].FACS ) == 0)
+		{
+			break;
+		}
+	}
+
+	if (flexdesc >= MAXSTUDIOFLEXDESC)
+	{
+		TokenError( "Too many flex types, max %d\n", MAXSTUDIOFLEXDESC );
+	}
+
+	if (flexdesc == g_numflexdesc)
+	{
+		V_strcpy_safe( g_flexdesc[flexdesc].FACS, name );
+
+		g_numflexdesc++;
+	}
+	return flexdesc;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Option_Flex( char *name, char *vtafile, int imodel, float pairsplit )
+{
+	if (g_numflexkeys >= MAXSTUDIOFLEXKEYS)
+	{
+		TokenError( "Too many flexes, max %d\n", MAXSTUDIOFLEXKEYS );
+	}
+
+	int flexdesc, flexpair;
+	
+	if (pairsplit != 0)
+	{
+		char mod[256];
+		sprintf( mod, "%sR", name );
+		flexdesc = Add_Flexdesc( mod );
+
+		sprintf( mod, "%sL", name );
+		flexpair = Add_Flexdesc( mod );
+	}
+	else
+	{
+		flexdesc = Add_Flexdesc( name );
+		flexpair = 0;
+	}
+
+	// initialize
+	g_flexkey[g_numflexkeys].imodel = imodel;
+	g_flexkey[g_numflexkeys].flexdesc = flexdesc;
+	g_flexkey[g_numflexkeys].target0 = 0.0;
+	g_flexkey[g_numflexkeys].target1 = 1.0;
+	g_flexkey[g_numflexkeys].target2 = 10;
+	g_flexkey[g_numflexkeys].target3 = 11;
+	g_flexkey[g_numflexkeys].split = pairsplit;
+	g_flexkey[g_numflexkeys].flexpair = flexpair;
+	g_flexkey[g_numflexkeys].decay = 1.0;
+
+	while (TokenAvailable())
+	{
+		GetToken(false);
+
+		if (stricmp( token, "frame") == 0)
+		{
+			GetToken (false);
+
+			g_flexkey[g_numflexkeys].frame = verify_atoi( token );
+		}
+		else if (stricmp( token, "position") == 0)
+		{
+			GetToken (false);
+			g_flexkey[g_numflexkeys].target1 = verify_atof( token );
+		}
+		else if (stricmp( token, "split") == 0)
+		{
+			GetToken (false);
+			g_flexkey[g_numflexkeys].split = verify_atof( token );
+		}
+		else if (stricmp( token, "decay") == 0)
+		{
+			GetToken (false);
+			g_flexkey[g_numflexkeys].decay = verify_atof( token );
+		}
+		else
+		{
+			TokenError( "unknown option: %s", token );
+		}
+
+	}
+
+	if (g_numflexkeys > 1)
+	{
+		if (g_flexkey[g_numflexkeys-1].flexdesc == g_flexkey[g_numflexkeys].flexdesc)
+		{
+			g_flexkey[g_numflexkeys-1].target2 = g_flexkey[g_numflexkeys-1].target1;
+			g_flexkey[g_numflexkeys-1].target3 = g_flexkey[g_numflexkeys].target1;
+			g_flexkey[g_numflexkeys].target0 = g_flexkey[g_numflexkeys-1].target1;
+		}
+	}
+
+	// link to source
+	s_source_t *pSource = Load_Source( vtafile, "vta" );
+	g_flexkey[g_numflexkeys].source = pSource;
+	if ( pSource->m_Animations.Count() )
+	{
+		Q_strncpy( g_flexkey[g_numflexkeys].animationname, pSource->m_Animations[0].animationname, sizeof( g_flexkey[g_numflexkeys].animationname ) );
+	}
+	else
+	{
+		g_flexkey[g_numflexkeys].animationname[0] = 0;
+	}
+	g_numflexkeys++;
+	// this needs to be per model.
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds combination data to the source
+//-----------------------------------------------------------------------------
+int FindSourceFlexKey( s_source_t *pSource, const char *pName )
+{
+	int nCount = pSource->m_FlexKeys.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !Q_stricmp( pSource->m_FlexKeys[i].animationname, pName ) )
+			return i;
+	}
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds flexkey data to a particular source
+//-----------------------------------------------------------------------------
+void AddFlexKey( s_source_t *pSource, CDmeCombinationOperator *pComboOp, const char *pFlexKeyName )
+{
+	// See if the delta state is already accounted for
+	if ( FindSourceFlexKey( pSource, pFlexKeyName ) >= 0 )
+		return;
+
+	int i = pSource->m_FlexKeys.AddToTail();
+
+	s_flexkey_t &key = pSource->m_FlexKeys[i];
+	memset( &key, 0, sizeof(key) );
+
+	key.target0 = 0.0f;
+	key.target1 = 1.0f;
+	key.target2 = 10.0f;
+	key.target3 = 11.0f;
+	key.decay = 1.0f;
+	key.source = pSource;
+
+	Q_strncpy( key.animationname, pFlexKeyName, sizeof(key.animationname) );
+	key.flexpair = pComboOp->IsDeltaStateStereo( pFlexKeyName );	// Signal used by AddBodyFlexData
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds combination data to the source
+//-----------------------------------------------------------------------------
+void AddCombination( s_source_t *pSource, CDmeCombinationOperator *pCombination )
+{
+	// Define the remapped controls
+	int nControlCount = pCombination->GetRawControlCount();
+	for ( int i = 0; i < nControlCount; ++i )
+	{
+		int m = pSource->m_CombinationControls.AddToTail();
+		s_combinationcontrol_t &control = pSource->m_CombinationControls[m];
+		Q_strncpy( control.name, pCombination->GetRawControlName( i ), sizeof(control.name) );
+	}
+
+	// Define the combination + domination rules
+	int nTargetCount = pCombination->GetOperationTargetCount();
+	for ( int i = 0; i < nTargetCount; ++i )
+	{
+		int nOpCount = pCombination->GetOperationCount( i );
+		for ( int j = 0; j < nOpCount; ++j )
+		{
+			CDmElement *pDeltaState = pCombination->GetOperationDeltaState( i, j );
+			if ( !pDeltaState )
+				continue;
+
+			int nFlex = FindSourceFlexKey( pSource, pDeltaState->GetName() );
+			if ( nFlex < 0 )
+				continue;
+
+			int k = pSource->m_CombinationRules.AddToTail();
+			s_combinationrule_t &rule = pSource->m_CombinationRules[k];
+			rule.m_nFlex = nFlex;
+			rule.m_Combination = pCombination->GetOperationControls( i, j );
+			int nDominatorCount = pCombination->GetOperationDominatorCount( i, j );
+			for ( int l = 0; l < nDominatorCount; ++l )
+			{
+				int m = rule.m_Dominators.AddToTail();
+				rule.m_Dominators[m] = pCombination->GetOperationDominator( i, j, l );
+			}
+		}
+	}
+
+	// Define the remapping controls
+	nControlCount = pCombination->GetControlCount();
+	for ( int i = 0; i < nControlCount; ++i )
+	{
+		int k = pSource->m_FlexControllerRemaps.AddToTail();
+		s_flexcontrollerremap_t &remap = pSource->m_FlexControllerRemaps[k];
+		remap.m_Name = pCombination->GetControlName( i );
+		remap.m_bIsStereo = pCombination->IsStereoControl( i );
+		remap.m_Index = -1;			// Don't know this right now
+		remap.m_LeftIndex = -1;		// Don't know this right now
+		remap.m_RightIndex = -1;	// Don't know this right now
+		remap.m_MultiIndex = -1;	// Don't know this right now
+		remap.m_EyesUpDownFlexController = -1;
+		remap.m_BlinkController = -1;
+
+		int nRemapCount = pCombination->GetRawControlCount( i );
+		if ( pCombination->IsEyelidControl( i ) )
+		{
+			remap.m_RemapType = FLEXCONTROLLER_REMAP_EYELID;
+
+			// Save the eyes_updown flex for later
+			const char *pEyesUpDownFlexName = pCombination->GetEyesUpDownFlexName( i );
+			remap.m_EyesUpDownFlexName = pEyesUpDownFlexName ? pEyesUpDownFlexName : "eyes_updown";
+		}
+		else
+		{
+			switch( nRemapCount )
+			{
+			case 0:
+			case 1:
+				remap.m_RemapType = FLEXCONTROLLER_REMAP_PASSTHRU;
+				break;
+			case 2:
+				remap.m_RemapType = FLEXCONTROLLER_REMAP_2WAY;
+				break;
+			default:
+				remap.m_RemapType = FLEXCONTROLLER_REMAP_NWAY;
+				break;
+			}
+		}
+
+		Assert( nRemapCount != 0 );
+		for ( int j = 0; j < nRemapCount; ++j )
+		{
+			const char *pRemapName = pCombination->GetRawControlName( i, j );
+			remap.m_RawControls.AddToTail( pRemapName );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Option_Eyelid( int imodel )
+{
+	char type[256];
+	char vtafile[256];
+
+	// type
+	GetToken (false);
+	V_strcpy_safe( type, token );
+
+	// source
+	GetToken (false);
+	V_strcpy_safe( vtafile, token );
+
+	int lowererframe = 0;
+	int neutralframe = 0;
+	int raiserframe = 0;
+	float lowerertarget = 0.0f;
+	float neutraltarget = 0.0f;
+	float raisertarget = 0.0f;
+	int lowererdesc = 0;
+	int neutraldesc = 0;
+	int raiserdesc = 0;
+	int basedesc;
+	float split = 0;
+	char szEyeball[64] = {""};
+
+	basedesc = g_numflexdesc;
+	V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, type );
+
+	while (TokenAvailable())
+	{
+		GetToken(false);
+
+		char localdesc[256];
+		V_strcpy_safe( localdesc, type );
+		V_strcat_safe( localdesc, "_" );
+		V_strcat_safe( localdesc, token );
+
+		if (stricmp( token, "lowerer") == 0)
+		{
+			GetToken (false);
+			lowererframe = verify_atoi( token );
+			GetToken (false);
+			lowerertarget = verify_atof( token );
+			lowererdesc = g_numflexdesc;
+			V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
+		}
+		else if (stricmp( token, "neutral") == 0)
+		{
+			GetToken (false);
+			neutralframe = verify_atoi( token );
+			GetToken (false);
+			neutraltarget = verify_atof( token );
+			neutraldesc = g_numflexdesc;
+			V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
+		}
+		else if (stricmp( token, "raiser") == 0)
+		{
+			GetToken (false);
+			raiserframe = verify_atoi( token );
+			GetToken (false);
+			raisertarget = verify_atof( token );
+			raiserdesc = g_numflexdesc;
+			V_strcpy_safe( g_flexdesc[g_numflexdesc++].FACS, localdesc );
+		}
+		else if (stricmp( token, "split") == 0)
+		{
+			GetToken (false);
+			split = verify_atof( token );
+		}
+		else if (stricmp( token, "eyeball") == 0)
+		{
+			GetToken (false);
+			V_strcpy_safe( szEyeball, token );
+		}
+		else
+		{
+			TokenError( "unknown option: %s", token );
+		}
+	}
+
+	s_source_t *pSource = Load_Source( vtafile, "vta" );
+	g_flexkey[g_numflexkeys+0].source = pSource;
+	g_flexkey[g_numflexkeys+0].frame = lowererframe;
+	g_flexkey[g_numflexkeys+0].flexdesc = basedesc;
+	g_flexkey[g_numflexkeys+0].imodel = imodel;
+	g_flexkey[g_numflexkeys+0].split = split;
+	g_flexkey[g_numflexkeys+0].target0 = -11;
+	g_flexkey[g_numflexkeys+0].target1 = -10;
+	g_flexkey[g_numflexkeys+0].target2 = lowerertarget;
+	g_flexkey[g_numflexkeys+0].target3 = neutraltarget;
+	g_flexkey[g_numflexkeys+0].decay = 0.0;
+	if ( pSource->m_Animations.Count() > 0 )
+	{
+		Q_strncpy( g_flexkey[g_numflexkeys+0].animationname, pSource->m_Animations[0].animationname, sizeof(g_flexkey[g_numflexkeys+0].animationname) );
+	}
+	else
+	{
+		g_flexkey[g_numflexkeys+0].animationname[0] = 0;
+	}
+
+	g_flexkey[g_numflexkeys+1].source = g_flexkey[g_numflexkeys+0].source;
+	Q_strncpy( g_flexkey[g_numflexkeys+1].animationname, g_flexkey[g_numflexkeys+0].animationname, sizeof(g_flexkey[g_numflexkeys+1].animationname) );
+	g_flexkey[g_numflexkeys+1].frame = neutralframe;
+	g_flexkey[g_numflexkeys+1].flexdesc = basedesc;
+	g_flexkey[g_numflexkeys+1].imodel = imodel;
+	g_flexkey[g_numflexkeys+1].split = split;
+	g_flexkey[g_numflexkeys+1].target0 = lowerertarget;
+	g_flexkey[g_numflexkeys+1].target1 = neutraltarget;
+	g_flexkey[g_numflexkeys+1].target2 = neutraltarget;
+	g_flexkey[g_numflexkeys+1].target3 = raisertarget;
+	g_flexkey[g_numflexkeys+1].decay = 0.0;
+
+	g_flexkey[g_numflexkeys+2].source = g_flexkey[g_numflexkeys+0].source;
+	Q_strncpy( g_flexkey[g_numflexkeys+2].animationname, g_flexkey[g_numflexkeys+0].animationname, sizeof(g_flexkey[g_numflexkeys+2].animationname) );
+	g_flexkey[g_numflexkeys+2].frame = raiserframe;
+	g_flexkey[g_numflexkeys+2].flexdesc = basedesc;
+	g_flexkey[g_numflexkeys+2].imodel = imodel;
+	g_flexkey[g_numflexkeys+2].split = split;
+	g_flexkey[g_numflexkeys+2].target0 = neutraltarget;
+	g_flexkey[g_numflexkeys+2].target1 = raisertarget;
+	g_flexkey[g_numflexkeys+2].target2 = 10;
+	g_flexkey[g_numflexkeys+2].target3 = 11;
+	g_flexkey[g_numflexkeys+2].decay = 0.0;
+	g_numflexkeys += 3;
+
+	s_model_t *pmodel = g_model[imodel];
+	for (int i = 0; i < pmodel->numeyeballs; i++)
+	{
+		s_eyeball_t *peyeball = &(pmodel->eyeball[i]);
+
+		if (szEyeball[0] != '\0')
+		{
+			if (stricmp( peyeball->name, szEyeball ) != 0)
+				continue;
+		}
+
+		if (fabs( lowerertarget ) > peyeball->radius)
+		{
+			TokenError( "Eyelid \"%s\" lowerer out of range (+-%.1f)\n", type, peyeball->radius );
+		}
+		if (fabs( neutraltarget ) > peyeball->radius)
+		{
+			TokenError( "Eyelid \"%s\" neutral out of range (+-%.1f)\n", type, peyeball->radius );
+		}
+		if (fabs( raisertarget ) > peyeball->radius)
+		{
+			TokenError( "Eyelid \"%s\" raiser  out of range (+-%.1f)\n", type, peyeball->radius );
+		}
+
+		switch( type[0] )
+		{
+		case 'u':
+			peyeball->upperlidflexdesc	= basedesc;
+			peyeball->upperflexdesc[0]	= lowererdesc; 
+			peyeball->uppertarget[0]	= lowerertarget;
+			peyeball->upperflexdesc[1]	= neutraldesc; 
+			peyeball->uppertarget[1]	= neutraltarget;
+			peyeball->upperflexdesc[2]	= raiserdesc; 
+			peyeball->uppertarget[2]	= raisertarget;
+			break;
+		case 'l':
+			peyeball->lowerlidflexdesc	= basedesc;
+			peyeball->lowerflexdesc[0]	= lowererdesc; 
+			peyeball->lowertarget[0]	= lowerertarget;
+			peyeball->lowerflexdesc[1]	= neutraldesc; 
+			peyeball->lowertarget[1]	= neutraltarget;
+			peyeball->lowerflexdesc[2]	= raiserdesc; 
+			peyeball->lowertarget[2]	= raisertarget;
+			break;
+		}
+	}
+}
+
+/*
+=================
+=================
+*/
+int Option_Mouth( s_model_t *pmodel )
+{
+	// index
+	GetToken (false);
+	int index = verify_atoi( token );
+	if (index >= g_nummouths)
+		g_nummouths = index + 1;
+
+	// flex controller name
+	GetToken (false);
+	g_mouth[index].flexdesc = Add_Flexdesc( token );
+
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_mouth[index].bonename, token );
+
+	// vector
+	GetToken (false);
+	g_mouth[index].forward[0] = verify_atof( token );
+	GetToken (false);
+	g_mouth[index].forward[1] = verify_atof( token );
+	GetToken (false);
+	g_mouth[index].forward[2] = verify_atof( token );
+	return 0;
+}
+
+
+
+void Option_Flexcontroller( s_model_t *pmodel )
+{
+	char type[256];
+	float range_min = 0.0f;
+	float range_max = 1.0f;
+
+	// g_flex
+	GetToken (false);
+	V_strcpy_safe( type, token );
+
+	while (TokenAvailable())
+	{
+		GetToken(false);
+
+		if (stricmp( token, "range") == 0)
+		{
+			GetToken(false);
+			range_min = verify_atof( token );
+
+			GetToken(false);
+			range_max = verify_atof( token );
+		}
+		else
+		{
+			if (g_numflexcontrollers >= MAXSTUDIOFLEXCTRL)
+			{
+				TokenError( "Too many flex controllers, max %d\n", MAXSTUDIOFLEXCTRL );
+			}
+
+			V_strcpy_safe( g_flexcontroller[g_numflexcontrollers].name, token );
+			V_strcpy_safe( g_flexcontroller[g_numflexcontrollers].type, type );
+			g_flexcontroller[g_numflexcontrollers].min = range_min;
+			g_flexcontroller[g_numflexcontrollers].max = range_max;
+			g_numflexcontrollers++;
+		}
+	}
+
+	// this needs to be per model.
+}
+
+void Option_Flexrule( s_model_t *pmodel, char *name )
+{
+	int precedence[32];
+	precedence[ STUDIO_CONST ] = 	0;
+	precedence[ STUDIO_FETCH1 ] =	0;
+	precedence[ STUDIO_FETCH2 ] =	0;
+	precedence[ STUDIO_ADD ] =		1;
+	precedence[ STUDIO_SUB ] =		1;
+	precedence[ STUDIO_MUL ] =		2;
+	precedence[ STUDIO_DIV ] =		2;
+	precedence[ STUDIO_NEG ] =		4;
+	precedence[ STUDIO_EXP ] =		3;
+	precedence[ STUDIO_OPEN ] =		0;	// only used in token parsing
+	precedence[ STUDIO_CLOSE ] =	0;
+	precedence[ STUDIO_COMMA ] =	0;
+	precedence[ STUDIO_MAX ] =		5;
+	precedence[ STUDIO_MIN ] =		5;
+
+	s_flexop_t stream[MAX_OPS];
+	int i = 0;
+	s_flexop_t stack[MAX_OPS];
+	int j = 0;
+	int k = 0;
+
+	s_flexrule_t *pRule = &g_flexrule[g_numflexrules++];
+
+	if (g_numflexrules > MAXSTUDIOFLEXRULES)
+	{
+		TokenError( "Too many flex rules (max %d)\n", MAXSTUDIOFLEXRULES );
+	}
+
+	int flexdesc;
+	for ( flexdesc = 0; flexdesc < g_numflexdesc; flexdesc++)
+	{
+		if (stricmp( name, g_flexdesc[flexdesc].FACS ) == 0)
+		{
+			break;
+		}
+	}
+
+	if (flexdesc >= g_numflexdesc)
+	{
+		TokenError( "Rule for unknown flex %s\n", name );
+	}
+
+	pRule->flex = flexdesc;
+	pRule->numops = 0;
+
+	// = 
+	GetToken(false);
+
+	// parse all the tokens
+	bool linecontinue = false;
+	while ( linecontinue || TokenAvailable())
+	{
+		GetExprToken(linecontinue);
+
+		linecontinue = false;
+
+		if ( token[0] == '\\' )
+		{
+			if (!GetToken(false) || token[0] != '\\')
+			{
+				TokenError( "unknown expression token '\\%s\n", token );
+			}
+			linecontinue = true;
+		}
+		else if ( token[0] == '(' )
+		{
+			stream[i++].op = STUDIO_OPEN;
+		}
+		else if ( token[0] == ')' )
+		{
+			stream[i++].op = STUDIO_CLOSE;
+		}
+		else if ( token[0] == '+' )
+		{
+			stream[i++].op = STUDIO_ADD;
+		}
+		else if ( token[0] == '-' )
+		{
+			stream[i].op = STUDIO_SUB;
+			if (i > 0)
+			{
+				switch( stream[i-1].op )
+				{
+				case STUDIO_OPEN:
+				case STUDIO_ADD:
+				case STUDIO_SUB:
+				case STUDIO_MUL:
+				case STUDIO_DIV:
+				case STUDIO_COMMA:
+					// it's a unary if it's preceded by a "(+-*/,"?
+					stream[i].op = STUDIO_NEG;
+					break;
+				}
+			}
+			i++;
+		}
+		else if ( token[0] == '*' )
+		{
+			stream[i++].op = STUDIO_MUL;
+		}
+		else if ( token[0] == '/' )
+		{
+			stream[i++].op = STUDIO_DIV;
+		}
+		else if ( V_isdigit( token[0] ))
+		{
+			stream[i].op = STUDIO_CONST;
+			stream[i++].d.value = verify_atof( token );
+		}
+		else if ( token[0] == ',' )
+		{
+			stream[i++].op = STUDIO_COMMA;
+		}
+		else if ( stricmp( token, "max" ) == 0)
+		{
+			stream[i++].op = STUDIO_MAX;
+		}
+		else if ( stricmp( token, "min" ) == 0)
+		{
+			stream[i++].op = STUDIO_MIN;
+		}
+		else 
+		{
+			if (token[0] == '%')
+			{
+				GetExprToken(false);
+
+				for (k = 0; k < g_numflexdesc; k++)
+				{
+					if (stricmp( token, g_flexdesc[k].FACS ) == 0)
+					{
+						stream[i].op = STUDIO_FETCH2;
+						stream[i++].d.index = k;
+						break;
+					}
+				}
+				if (k >= g_numflexdesc)
+				{
+					TokenError( "unknown flex %s\n", token );
+				}
+			}
+			else
+			{
+				for (k = 0; k < g_numflexcontrollers; k++)
+				{
+					if (stricmp( token, g_flexcontroller[k].name ) == 0)
+					{
+						stream[i].op = STUDIO_FETCH1;
+						stream[i++].d.index = k;
+						break;
+					}
+				}
+				if (k >= g_numflexcontrollers)
+				{
+					TokenError( "unknown controller %s\n", token );
+				}
+			}
+		}
+	}
+
+	if (i > MAX_OPS)
+	{
+		TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
+	}
+
+	if (0)
+	{
+		printf("%s = ", g_flexdesc[pRule->flex].FACS );
+		for ( k = 0; k < i; k++)
+		{
+			switch( stream[k].op )
+			{
+			case STUDIO_CONST: printf("%f ", stream[k].d.value ); break;
+			case STUDIO_FETCH1: printf("%s ", g_flexcontroller[stream[k].d.index].name ); break;
+			case STUDIO_FETCH2: printf("[%d] ", stream[k].d.index ); break;
+			case STUDIO_ADD: printf("+ "); break;
+			case STUDIO_SUB: printf("- "); break;
+			case STUDIO_MUL: printf("* "); break;
+			case STUDIO_DIV: printf("/ "); break;
+			case STUDIO_NEG: printf("neg "); break;
+			case STUDIO_MAX: printf("max "); break;
+			case STUDIO_MIN: printf("min "); break;
+			case STUDIO_COMMA: 	printf(", "); break; // error
+			case STUDIO_OPEN: 	printf("( " ); break; // error
+			case STUDIO_CLOSE: 	printf(") " ); break; // error
+			default:
+				printf("err%d ", stream[k].op ); break;
+			}
+		}
+		printf("\n");
+		// exit(1);
+	}
+
+	j = 0;
+	for (k = 0; k < i; k++)
+	{
+		if (j >= MAX_OPS)
+		{
+			TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
+		}
+		switch( stream[k].op )
+		{
+		case STUDIO_CONST:
+		case STUDIO_FETCH1:
+		case STUDIO_FETCH2:
+			pRule->op[pRule->numops++] = stream[k];
+			break;
+		case STUDIO_OPEN:
+			stack[j++] = stream[k];
+			break;
+		case STUDIO_CLOSE:
+			// pop all operators off of the stack until an open paren
+			while (j > 0 && stack[j-1].op != STUDIO_OPEN)
+			{
+				pRule->op[pRule->numops++] = stack[j-1];
+				j--;
+			}
+			if (j == 0)
+			{
+				TokenError( "unmatched closed parentheses\n" );
+			}
+			if (j > 0) 
+				j--;
+			break;
+		case STUDIO_COMMA:
+			// pop all operators off of the stack until an open paren
+			while (j > 0 && stack[j-1].op != STUDIO_OPEN)
+			{
+				pRule->op[pRule->numops++] = stack[j-1];
+				j--;
+			}
+			// push operator onto the stack
+			stack[j++] = stream[k];
+			break;
+		case STUDIO_ADD:
+		case STUDIO_SUB:
+		case STUDIO_MUL:
+		case STUDIO_DIV:
+			// pop all operators off of the stack that have equal or higher precedence
+			while (j > 0 && precedence[stream[k].op] <= precedence[stack[j-1].op])
+			{
+				pRule->op[pRule->numops++] = stack[j-1];
+				j--;
+			}
+			// push operator onto the stack
+			stack[j++] = stream[k];
+			break;
+		case STUDIO_NEG:
+			if (stream[k+1].op == STUDIO_CONST)
+			{
+				// change sign of constant, skip op
+				stream[k+1].d.value = -stream[k+1].d.value;
+			}
+			else
+			{
+				// push operator onto the stack
+				stack[j++] = stream[k];
+			}
+			break;
+		case STUDIO_MAX:
+		case STUDIO_MIN:
+			// push operator onto the stack
+			stack[j++] = stream[k];
+			break;
+		}
+		if (pRule->numops >= MAX_OPS)
+			TokenError("expression for \"%s\" too complicated\n", g_flexdesc[pRule->flex].FACS );
+	}
+	// pop all operators off of the stack
+	while (j > 0)
+	{
+		pRule->op[pRule->numops++] = stack[j-1];
+		j--;
+		if (pRule->numops >= MAX_OPS)
+			TokenError("expression for \"%s\" too complicated\n", g_flexdesc[pRule->flex].FACS );
+	}
+
+	// reprocess the operands, eating commas for all functions
+	int numCommas = 0;
+	j = 0;
+	for (k = 0; k < pRule->numops; k++)
+	{
+		switch( pRule->op[k].op )
+		{
+		case STUDIO_MAX:
+		case STUDIO_MIN:
+			if (pRule->op[j-1].op != STUDIO_COMMA)
+			{
+				TokenError( "missing comma\n");
+			}
+			// eat the comma operator
+			numCommas--;
+			pRule->op[j-1] = pRule->op[k];
+			break;
+		case STUDIO_COMMA:
+			numCommas++;
+			pRule->op[j++] = pRule->op[k];
+			break;
+		default:
+			pRule->op[j++] = pRule->op[k];
+			break;
+		}
+	}
+	pRule->numops = j;
+	if (numCommas != 0)
+	{
+		TokenError( "too many comma's\n" );
+	}
+
+	if (pRule->numops > MAX_OPS)
+	{
+		TokenError("expression %s too complicated\n", g_flexdesc[pRule->flex].FACS );
+	}
+
+	if (0)
+	{
+		printf("%s = ", g_flexdesc[pRule->flex].FACS );
+		for ( i = 0; i < pRule->numops; i++)
+		{
+			switch( pRule->op[i].op )
+			{
+			case STUDIO_CONST: printf("%f ", pRule->op[i].d.value ); break;
+			case STUDIO_FETCH1: printf("%s ", g_flexcontroller[pRule->op[i].d.index].name ); break;
+			case STUDIO_FETCH2: printf("[%d] ", pRule->op[i].d.index ); break;
+			case STUDIO_ADD: printf("+ "); break;
+			case STUDIO_SUB: printf("- "); break;
+			case STUDIO_MUL: printf("* "); break;
+			case STUDIO_DIV: printf("/ "); break;
+			case STUDIO_NEG: printf("neg "); break;
+			case STUDIO_MAX: printf("max "); break;
+			case STUDIO_MIN: printf("min "); break;
+			case STUDIO_COMMA: 	printf(", "); break; // error
+			case STUDIO_OPEN: 	printf("( " ); break; // error
+			case STUDIO_CLOSE: 	printf(") " ); break; // error
+			default:
+				printf("err%d ", pRule->op[i].op ); break;
+			}
+		}
+		printf("\n");
+		// exit(1);
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Cmd_Model( )
+{
+	g_model[g_nummodels] = (s_model_t *)kalloc( 1, sizeof( s_model_t ) );
+	
+	// name
+	if (!GetToken(false)) 
+		return;
+	V_strcpy_safe( g_model[g_nummodels]->name, token );
+
+	// fake g_bodypart stuff
+	if (g_numbodyparts == 0) 
+	{
+		g_bodypart[g_numbodyparts].base = 1;
+	}
+	else 
+	{
+		g_bodypart[g_numbodyparts].base = g_bodypart[g_numbodyparts-1].base * g_bodypart[g_numbodyparts-1].nummodels;
+	}
+	V_strcpy_safe( g_bodypart[g_numbodyparts].name, token );
+
+	g_bodypart[g_numbodyparts].pmodel[g_bodypart[g_numbodyparts].nummodels] = g_model[g_nummodels];
+	g_bodypart[g_numbodyparts].nummodels = 1;
+	g_numbodyparts++;
+
+	Option_Studio( g_model[g_nummodels] );
+
+	if ( g_model[g_nummodels]->source )
+	{
+		// Body command should add any flex commands in the source loaded
+		AddBodyFlexData( g_model[g_nummodels]->source, g_nummodels );
+		AddBodyAttachments( g_model[g_nummodels]->source );
+	}
+	
+	int depth = 0;
+	while (1)
+	{
+		char FAC[256], vtafile[256];
+		if (depth > 0)
+		{
+			if( !GetToken(true) ) 
+				break;
+		}
+		else
+		{
+			if ( !TokenAvailable() ) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if ( endofscript )
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return;
+		}
+		if ( !Q_stricmp("{", token ) )
+		{
+			depth++;
+		}
+		else if ( !Q_stricmp("}", token ) )
+		{
+			depth--;
+		}
+		else if ( !Q_stricmp( "eyeball", token ) )
+		{
+			Option_Eyeball( g_model[g_nummodels] );
+		}
+		else if ( !Q_stricmp( "eyelid", token ) )
+		{
+			Option_Eyelid( g_nummodels );
+		}
+		else if ( !Q_stricmp( "flex", token ) )
+		{
+			// g_flex
+			GetToken (false);
+			V_strcpy_safe( FAC, token );
+			if (depth == 0)
+			{
+				// file
+				GetToken (false);
+				V_strcpy_safe( vtafile, token );
+			}
+			Option_Flex( FAC, vtafile, g_nummodels, 0.0 ); // FIXME: this needs to point to a model used, not loaded!!!
+		}
+		else if ( !Q_stricmp( "flexpair", token ) )
+		{
+			// g_flex
+			GetToken (false);
+			V_strcpy_safe( FAC, token );
+
+			GetToken( false );
+			float split = atof( token );
+
+			if (depth == 0)
+			{
+				// file
+				GetToken (false);
+				V_strcpy_safe( vtafile, token );
+			}
+			Option_Flex( FAC, vtafile, g_nummodels, split ); // FIXME: this needs to point to a model used, not loaded!!!
+		}
+		else if ( !Q_stricmp( "defaultflex", token ) )
+		{
+			if (depth == 0)
+			{
+				// file
+				GetToken (false);
+				V_strcpy_safe( vtafile, token );
+			}
+
+			// g_flex
+			Option_Flex( "default", vtafile, g_nummodels, 0.0 ); // FIXME: this needs to point to a model used, not loaded!!!
+			g_defaultflexkey = &g_flexkey[g_numflexkeys-1];
+		}
+		else if ( !Q_stricmp( "flexfile", token ) )
+		{
+			// file
+			GetToken (false);
+			V_strcpy_safe( vtafile, token );
+		}
+		else if ( !Q_stricmp( "localvar", token ) )
+		{
+			while (TokenAvailable())
+			{
+				GetToken( false );
+				Add_Flexdesc( token );
+			}
+		}
+		else if ( !Q_stricmp( "mouth", token ) )
+		{
+			Option_Mouth( g_model[g_nummodels] );
+		}
+		else if ( !Q_stricmp( "flexcontroller", token ) )
+		{
+			Option_Flexcontroller( g_model[g_nummodels] );
+		}
+		else if ( token[0] == '%' )
+		{
+			Option_Flexrule( g_model[g_nummodels], &token[1] );
+		}
+		else if ( !Q_stricmp("attachment", token ) )
+		{
+		// 	Option_Attachment( g_model[g_nummodels] );
+		}
+		else if ( !Q_stricmp( token, "spherenormals" ) )
+		{
+			Option_Spherenormals( g_model[g_nummodels]->source );
+		}
+		else
+		{
+			TokenError( "unknown model option \"%s\"\n", token );
+		}
+
+		if (depth < 0)
+		{
+			TokenError("missing {\n");
+		}
+	};
+
+	// Actually connect up the expressions between the Dme Flex Controllers & Flex Descriptors
+	// In case there was data added by some other eyeball command (like eyelid)
+	AddBodyFlexRules( g_model[ g_nummodels ]->source );
+
+	g_nummodels++;
+}
+
+
+void Cmd_FakeVTA( void )
+{
+	int depth = 0;
+
+	GetToken( false );
+
+	s_source_t *psource = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
+	g_source[g_numsources] = psource;
+	V_strcpy_safe( g_source[g_numsources]->filename, token );
+	g_numsources++;
+
+	while (1)
+	{
+		if (depth > 0)
+		{
+			if(!GetToken(true)) 
+			{
+				break;
+			}
+		}
+		else
+		{
+			if (!TokenAvailable()) 
+			{
+				break;
+			}
+			else 
+			{
+				GetToken (false);
+			}
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return;
+		}
+		if (stricmp("{", token ) == 0)
+		{
+			depth++;
+		}
+		else if (stricmp("}", token ) == 0)
+		{
+			depth--;
+		}
+		else if (stricmp("appendvta", token ) == 0)
+		{
+			char filename[256];
+			// file
+			GetToken (false);
+			V_strcpy_safe( filename, token );
+			
+			GetToken( false );
+			int frame = verify_atoi( token );
+
+			AppendVTAtoOBJ( psource, filename, frame );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_IKChain( )
+{
+	if (!GetToken(false)) 
+		return;
+
+	int i;
+	for ( i = 0; i < g_numikchains; i++)
+	{
+		if (stricmp( token, g_ikchain[i].name ) == 0)
+		{
+			break;
+		}
+	}
+	if (i < g_numikchains)
+	{
+		if (!g_quiet)
+		{
+			printf("duplicate ikchain \"%s\" ignored\n", token );
+		}
+		while (TokenAvailable())
+		{
+			GetToken(false);
+		}
+		return;
+	}
+
+	V_strcpy_safe( g_ikchain[g_numikchains].name, token );
+
+	GetToken(false);
+	V_strcpy_safe( g_ikchain[g_numikchains].bonename, token );
+
+	g_ikchain[g_numikchains].axis = STUDIO_Z;
+	g_ikchain[g_numikchains].value = 0.0;
+	g_ikchain[g_numikchains].height = 18.0;
+	g_ikchain[g_numikchains].floor = 0.0;
+	g_ikchain[g_numikchains].radius = 0.0;
+
+	while (TokenAvailable())
+	{
+		GetToken(false);
+
+		if (lookupControl( token ) != -1)
+		{
+			g_ikchain[g_numikchains].axis = lookupControl( token );
+			GetToken(false);
+			g_ikchain[g_numikchains].value = verify_atof( token );
+		}
+		else if (stricmp( "height", token ) == 0)
+		{
+			GetToken(false);
+			g_ikchain[g_numikchains].height = verify_atof( token );
+		}
+		else if (stricmp( "pad", token ) == 0)
+		{
+			GetToken(false);
+			g_ikchain[g_numikchains].radius = verify_atof( token ) / 2.0;
+		}
+		else if (stricmp( "floor", token ) == 0)
+		{
+			GetToken(false);
+			g_ikchain[g_numikchains].floor = verify_atof( token );
+		}
+		else if (stricmp( "knee", token ) == 0)
+		{
+			GetToken(false);
+			g_ikchain[g_numikchains].link[0].kneeDir.x = verify_atof( token );
+			GetToken(false);
+			g_ikchain[g_numikchains].link[0].kneeDir.y = verify_atof( token );
+			GetToken(false);
+			g_ikchain[g_numikchains].link[0].kneeDir.z = verify_atof( token );
+		}
+		else if (stricmp( "center", token ) == 0)
+		{
+			GetToken(false);
+			g_ikchain[g_numikchains].center.x = verify_atof( token );
+			GetToken(false);
+			g_ikchain[g_numikchains].center.y = verify_atof( token );
+			GetToken(false);
+			g_ikchain[g_numikchains].center.z = verify_atof( token );
+		}
+	}
+	g_numikchains++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+
+void Cmd_IKAutoplayLock( )
+{
+	GetToken(false);
+	V_strcpy_safe( g_ikautoplaylock[g_numikautoplaylocks].name, token );
+
+	GetToken(false);
+	g_ikautoplaylock[g_numikautoplaylocks].flPosWeight = verify_atof( token );
+
+	GetToken(false);
+	g_ikautoplaylock[g_numikautoplaylocks].flLocalQWeight = verify_atof( token );
+	
+	g_numikautoplaylocks++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_Root ()
+{
+	if (GetToken (false))
+	{
+		V_strcpy_safe( rootname, token );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_Controller (void)
+{
+	if (GetToken (false))
+	{
+		if (!stricmp("mouth",token))
+		{
+			g_bonecontroller[g_numbonecontrollers].inputfield = 4;
+		}
+		else
+		{
+			g_bonecontroller[g_numbonecontrollers].inputfield = verify_atoi(token);
+		}
+		if (GetToken(false))
+		{
+			V_strcpy_safe( g_bonecontroller[g_numbonecontrollers].name, token );
+			GetToken(false);
+			if ((g_bonecontroller[g_numbonecontrollers].type = lookupControl(token)) == -1) 
+			{
+				MdlWarning("unknown g_bonecontroller type '%s'\n", token );
+				return;
+			}
+			GetToken(false);
+			g_bonecontroller[g_numbonecontrollers].start = verify_atof( token );
+			GetToken(false);
+			g_bonecontroller[g_numbonecontrollers].end = verify_atof( token );
+
+			if (g_bonecontroller[g_numbonecontrollers].type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
+			{
+				if (((int)(g_bonecontroller[g_numbonecontrollers].start + 360) % 360) == ((int)(g_bonecontroller[g_numbonecontrollers].end + 360) % 360))
+				{
+					g_bonecontroller[g_numbonecontrollers].type |= STUDIO_RLOOP;
+				}
+			}
+			g_numbonecontrollers++;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+// Debugging function that enumerate all a models bones to stdout.
+static void SpewBones()
+{
+	MdlWarning("g_numbones %i\n",g_numbones);
+
+	for ( int i = g_numbones; --i >= 0; )
+	{
+		printf("%s\n",g_bonetable[i].name);
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_ScreenAlign ( void )
+{
+	if (GetToken (false))
+	{
+		
+		Assert( g_numscreenalignedbones < MAXSTUDIOSRCBONES );
+
+		V_strcpy_safe( g_screenalignedbone[g_numscreenalignedbones].name, token );
+		g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_SPHERE;
+
+		if( GetToken( false ) )
+		{
+			if( !stricmp( "sphere", token )  )
+			{
+				g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_SPHERE;				
+			}
+			else if( !stricmp( "cylinder", token ) )
+			{
+				g_screenalignedbone[g_numscreenalignedbones].flags = BONE_SCREEN_ALIGN_CYLINDER;				
+			}
+		}
+
+		g_numscreenalignedbones++;
+
+	} else
+	{
+		TokenError( "$screenalign: expected bone name\n" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_BBox (void)
+{
+	GetToken (false);
+	bbox[0][0] = verify_atof( token );
+
+	GetToken (false);
+	bbox[0][1] = verify_atof( token );
+
+	GetToken (false);
+	bbox[0][2] = verify_atof( token );
+
+	GetToken (false);
+	bbox[1][0] = verify_atof( token );
+
+	GetToken (false);
+	bbox[1][1] = verify_atof( token );
+
+	GetToken (false);
+	bbox[1][2] = verify_atof( token );
+
+	g_wrotebbox = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_CBox (void)
+{
+	GetToken (false);
+	cbox[0][0] = verify_atof( token );
+
+	GetToken (false);
+	cbox[0][1] = verify_atof( token );
+
+	GetToken (false);
+	cbox[0][2] = verify_atof( token );
+
+	GetToken (false);
+	cbox[1][0] = verify_atof( token );
+
+	GetToken (false);
+	cbox[1][1] = verify_atof( token );
+
+	GetToken (false);
+	cbox[1][2] = verify_atof( token );
+
+	g_wrotecbox = true;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_Gamma (void)
+{
+	GetToken (false);
+	g_gamma = verify_atof( token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_TextureGroup( )
+{
+	if( g_bCreateMakefile )
+	{
+		return;
+	}
+	int i;
+	int depth = 0;
+	int index = 0;
+	int group = 0;
+
+
+	if (!GetToken(false)) 
+		return;
+
+	if (g_numskinref == 0)
+		g_numskinref = g_numtextures;
+
+	while (1)
+	{
+		if(!GetToken(true)) 
+		{
+			break;
+		}
+
+		if (endofscript)
+		{
+			if (depth != 0)
+			{
+				TokenError("missing }\n" );
+			}
+			return;
+		}
+		if (token[0] == '{')
+		{
+			depth++;
+		}
+		else if (token[0] == '}')
+		{
+			depth--;
+			if (depth == 0)
+				break;
+			group++;
+			index = 0;
+		}
+		else if (depth == 2)
+		{
+			i = UseTextureAsMaterial( LookupTexture( token ) );
+			g_texturegroup[g_numtexturegroups][group][index] = i;
+			if (group != 0)
+				g_texture[i].parent = g_texturegroup[g_numtexturegroups][0][index];
+			index++;
+			g_numtexturereps[g_numtexturegroups] = index;
+			g_numtexturelayers[g_numtexturegroups] = group + 1;
+		}
+	}
+
+	g_numtexturegroups++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Cmd_Hitgroup( )
+{
+	GetToken (false);
+	g_hitgroup[g_numhitgroups].group = verify_atoi( token );
+	GetToken (false);
+	V_strcpy_safe( g_hitgroup[g_numhitgroups].name, token );
+	g_numhitgroups++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_Hitbox( )
+{
+	bool autogenerated = false;
+	if ( g_hitboxsets.Size() == 0 )
+	{
+		g_hitboxsets.AddToTail();
+		autogenerated = true;
+	}
+
+	// Last one
+	s_hitboxset *set = &g_hitboxsets[ g_hitboxsets.Size() - 1 ];
+	if ( autogenerated )
+	{
+		memset( set, 0, sizeof( *set ) );
+
+		// fill in name if it wasn't specified in the .qc
+		V_strcpy_safe( set->hitboxsetname, "default" );
+	}
+
+	GetToken (false);
+	set->hitbox[set->numhitboxes].group = verify_atoi( token );
+	
+	// Grab the bone name:
+	GetToken (false);
+	V_strcpy_safe( set->hitbox[set->numhitboxes].name, token );
+
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmin[0] = verify_atof( token );
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmin[1] = verify_atof( token );
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmin[2] = verify_atof( token );
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmax[0] = verify_atof( token );
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmax[1] = verify_atof( token );
+	GetToken (false);
+	set->hitbox[set->numhitboxes].bmax[2] = verify_atof( token );
+
+	//Scale hitboxes
+	scale_vertex( set->hitbox[set->numhitboxes].bmin );
+	scale_vertex( set->hitbox[set->numhitboxes].bmax );
+	// clear out the hitboxname:
+	memset( set->hitbox[set->numhitboxes].hitboxname, 0, sizeof( set->hitbox[set->numhitboxes].hitboxname ) );
+
+	// Grab the hit box name if present:
+	if( TokenAvailable() )
+	{
+		GetToken (false);
+		V_strcpy_safe( set->hitbox[set->numhitboxes].hitboxname, token );
+	}
+
+
+	set->numhitboxes++;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_HitboxSet( void )
+{
+	// Add a new hitboxset
+	s_hitboxset *set = &g_hitboxsets[ g_hitboxsets.AddToTail() ];
+	GetToken( false );
+	memset( set, 0, sizeof( *set ) );
+	V_strcpy_safe( set->hitboxsetname, token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Assigns a default surface property to the entire model
+//-----------------------------------------------------------------------------
+struct SurfacePropName_t
+{
+	char m_pJointName[128];
+	char m_pSurfaceProp[128];
+};
+
+static char								s_pDefaultSurfaceProp[128] = {"default"};
+static CUtlVector<SurfacePropName_t>	s_JointSurfaceProp;
+
+//-----------------------------------------------------------------------------
+// Assigns a default surface property to the entire model
+//-----------------------------------------------------------------------------
+void Cmd_SurfaceProp ()
+{
+	GetToken (false);
+	V_strcpy_safe( s_pDefaultSurfaceProp, token );
+}	
+
+
+//-----------------------------------------------------------------------------
+// Assigns a surface property to a particular joint
+//-----------------------------------------------------------------------------
+void Cmd_JointSurfaceProp ()
+{
+	// Get joint name...
+	GetToken (false);
+
+	// Search for the name in our list
+	int i;
+	for ( i = s_JointSurfaceProp.Count(); --i >= 0; )
+	{
+		if (!stricmp(s_JointSurfaceProp[i].m_pJointName, token))
+		{
+			break;
+		}
+	}
+
+	// Add new entry if we haven't seen this name before
+	if (i < 0)
+	{
+		i = s_JointSurfaceProp.AddToTail();
+		V_strcpy_safe( s_JointSurfaceProp[i].m_pJointName, token );
+	}
+
+	// surface property name
+	GetToken(false);
+	V_strcpy_safe( s_JointSurfaceProp[i].m_pSurfaceProp, token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the default surface prop name
+//-----------------------------------------------------------------------------
+char* GetDefaultSurfaceProp ( )
+{
+	return s_pDefaultSurfaceProp;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns surface property for a given joint
+//-----------------------------------------------------------------------------
+static char* FindSurfaceProp ( const char* pJointName )
+{
+	for ( int i = s_JointSurfaceProp.Count(); --i >= 0; )
+	{
+		if (!stricmp(s_JointSurfaceProp[i].m_pJointName, pJointName))
+		{
+			return s_JointSurfaceProp[i].m_pSurfaceProp;
+		}
+	}
+
+	return 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns surface property for a given joint
+//-----------------------------------------------------------------------------
+char* GetSurfaceProp ( const char* pJointName )
+{
+	while( pJointName )
+	{
+		// First try to find this joint
+		char* pSurfaceProp = FindSurfaceProp( pJointName );
+		if (pSurfaceProp)
+			return pSurfaceProp;
+
+		// If we can't find the joint, then find it's parent...
+		if (!g_numbones)
+			return s_pDefaultSurfaceProp;
+
+		int i = findGlobalBone( pJointName );
+
+		if ((i >= 0) && (g_bonetable[i].parent >= 0))
+		{
+			pJointName = g_bonetable[g_bonetable[i].parent].name;
+		}
+		else
+		{
+			pJointName = 0;
+		}
+	}
+
+	// No match, return the default one
+	return s_pDefaultSurfaceProp;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns surface property for a given joint
+//-----------------------------------------------------------------------------
+void ConsistencyCheckSurfaceProp ( )
+{
+	for ( int i = s_JointSurfaceProp.Count(); --i >= 0; )
+	{
+		int j = findGlobalBone( s_JointSurfaceProp[i].m_pJointName );
+
+		if (j < 0)
+		{
+			MdlWarning("You specified a joint surface property for joint\n"
+				"    \"%s\" which either doesn't exist or was optimized out.\n", s_JointSurfaceProp[i].m_pJointName );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Assigns a default contents to the entire model
+//-----------------------------------------------------------------------------
+struct ContentsName_t
+{
+	char m_pJointName[128];
+	int m_nContents;
+};
+
+static int s_nDefaultContents = CONTENTS_SOLID;
+static CUtlVector<ContentsName_t>	s_JointContents;
+
+
+//-----------------------------------------------------------------------------
+// Parse contents flags
+//-----------------------------------------------------------------------------
+static void ParseContents( int *pAddFlags, int *pRemoveFlags )
+{
+	*pAddFlags = 0;
+	*pRemoveFlags = 0;
+	do 
+	{
+		GetToken (false);
+
+		if ( !stricmp( token, "grate" ) )
+		{
+			*pAddFlags |= CONTENTS_GRATE;
+			*pRemoveFlags |= CONTENTS_SOLID;
+		}
+		else if ( !stricmp( token, "ladder" ) )
+		{
+			*pAddFlags |= CONTENTS_LADDER;
+		}
+		else if ( !stricmp( token, "solid" ) )
+		{
+			*pAddFlags |= CONTENTS_SOLID;
+		}
+		else if ( !stricmp( token, "monster" ) )
+		{
+			*pAddFlags |= CONTENTS_MONSTER;
+		}
+		else if ( !stricmp( token, "notsolid" ) )
+		{
+			*pRemoveFlags |= CONTENTS_SOLID;
+		}
+	} while (TokenAvailable());
+}
+
+
+//-----------------------------------------------------------------------------
+// Assigns a default contents to the entire model
+//-----------------------------------------------------------------------------
+void Cmd_Contents()
+{
+	int nAddFlags, nRemoveFlags;
+	ParseContents( &nAddFlags, &nRemoveFlags );
+	s_nDefaultContents |= nAddFlags;
+	s_nDefaultContents &= ~nRemoveFlags;
+}
+
+
+//-----------------------------------------------------------------------------
+// Assigns contents to a particular joint
+//-----------------------------------------------------------------------------
+void Cmd_JointContents ()
+{
+	// Get joint name...
+	GetToken (false);
+
+	// Search for the name in our list
+	int i;
+	for ( i = s_JointContents.Count(); --i >= 0; )
+	{
+		if (!stricmp(s_JointContents[i].m_pJointName, token))
+		{
+			break;
+		}
+	}
+
+	// Add new entry if we haven't seen this name before
+	if (i < 0)
+	{
+		i = s_JointContents.AddToTail();
+		V_strcpy_safe( s_JointContents[i].m_pJointName, token );
+	}
+
+	int nAddFlags, nRemoveFlags;
+	ParseContents( &nAddFlags, &nRemoveFlags );
+	s_JointContents[i].m_nContents = CONTENTS_SOLID;
+	s_JointContents[i].m_nContents |= nAddFlags;
+	s_JointContents[i].m_nContents &= ~nRemoveFlags;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the default contents
+//-----------------------------------------------------------------------------
+int GetDefaultContents( )
+{
+	return s_nDefaultContents;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns contents for a given joint
+//-----------------------------------------------------------------------------
+static int FindContents( const char* pJointName )
+{
+	for ( int i = s_JointContents.Count(); --i >= 0; )
+	{
+		if (!stricmp(s_JointContents[i].m_pJointName, pJointName))
+		{
+			return s_JointContents[i].m_nContents;
+		}
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns contents for a given joint
+//-----------------------------------------------------------------------------
+int GetContents( const char* pJointName )
+{
+	while( pJointName )
+	{
+		// First try to find this joint
+		int nContents = FindContents( pJointName );
+		if (nContents != -1)
+			return nContents;
+
+		// If we can't find the joint, then find it's parent...
+		if (!g_numbones)
+			return s_nDefaultContents;
+
+		int i = findGlobalBone( pJointName );
+
+		if ((i >= 0) && (g_bonetable[i].parent >= 0))
+		{
+			pJointName = g_bonetable[g_bonetable[i].parent].name;
+		}
+		else
+		{
+			pJointName = 0;
+		}
+	}
+
+	// No match, return the default one
+	return s_nDefaultContents;
+}
+
+
+//-----------------------------------------------------------------------------
+// Checks specified contents
+//-----------------------------------------------------------------------------
+void ConsistencyCheckContents( )
+{
+	for ( int i = s_JointContents.Count(); --i >= 0; )
+	{
+		int j = findGlobalBone( s_JointContents[i].m_pJointName );
+
+		if (j < 0)
+		{
+			MdlWarning("You specified a joint contents for joint\n"
+				"    \"%s\" which either doesn't exist or was optimized out.\n", s_JointSurfaceProp[i].m_pJointName );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Cmd_BoneMerge( )
+{
+	if( g_bCreateMakefile )
+		return;
+
+	int nIndex = g_BoneMerge.AddToTail();
+
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_BoneMerge[nIndex].bonename, token );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Cmd_Attachment( )
+{
+	if( g_bCreateMakefile )
+		return;
+
+	// name
+	GetToken (false);
+	V_strcpy_safe( g_attachment[g_numattachments].name, token );
+
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_attachment[g_numattachments].bonename, token );
+
+	Vector tmp;
+
+	// position
+	GetToken (false);
+	tmp.x = verify_atof( token );
+	GetToken (false);
+	tmp.y = verify_atof( token );
+	GetToken (false);
+	tmp.z = verify_atof( token );
+
+	scale_vertex( tmp );
+	// identity matrix
+	AngleMatrix( QAngle( 0, 0, 0 ), g_attachment[g_numattachments].local );
+
+	while (TokenAvailable())
+	{
+		GetToken (false);
+
+		if (stricmp(token,"absolute") == 0)
+		{
+			g_attachment[g_numattachments].type |= IS_ABSOLUTE;
+			AngleIMatrix( g_defaultrotation, g_attachment[g_numattachments].local );
+			// AngleIMatrix( Vector( 0, 0, 0 ), g_attachment[g_numattachments].local );
+		}
+		else if (stricmp(token,"rigid") == 0)
+		{
+			g_attachment[g_numattachments].type |= IS_RIGID;
+		}
+		else if (stricmp(token,"world_align") == 0)
+		{
+			g_attachment[g_numattachments].flags |= ATTACHMENT_FLAG_WORLD_ALIGN;
+		}
+		else if (stricmp(token,"rotate") == 0)
+		{
+			QAngle angles;
+			for (int i = 0; i < 3; ++i)
+			{
+				if (!TokenAvailable())
+					break;
+
+				GetToken(false);
+				angles[i] = verify_atof( token );
+			}
+			AngleMatrix( angles, g_attachment[g_numattachments].local );
+		}
+		else if (stricmp(token,"x_and_z_axes") == 0)
+		{
+			int i;
+			Vector xaxis, yaxis, zaxis;
+			for (i = 0; i < 3; ++i)
+			{
+				if (!TokenAvailable())
+					break;
+
+				GetToken(false);
+				xaxis[i] = verify_atof( token );
+			}
+			for (i = 0; i < 3; ++i)
+			{
+				if (!TokenAvailable())
+					break;
+
+				GetToken(false);
+				zaxis[i] = verify_atof( token );
+			}
+			VectorNormalize( xaxis );
+			VectorMA( zaxis, -DotProduct( zaxis, xaxis ), xaxis, zaxis );
+			VectorNormalize( zaxis );
+			CrossProduct( zaxis, xaxis, yaxis );
+			MatrixSetColumn( xaxis, 0, g_attachment[g_numattachments].local );
+			MatrixSetColumn( yaxis, 1, g_attachment[g_numattachments].local );
+			MatrixSetColumn( zaxis, 2, g_attachment[g_numattachments].local );
+			MatrixSetColumn( vec3_origin, 3, g_attachment[g_numattachments].local );
+		}
+		else
+		{
+			TokenError("unknown attachment (%s) option: ", g_attachment[g_numattachments].name, token );
+		}
+	}
+
+	g_attachment[g_numattachments].local[0][3] = tmp.x;
+	g_attachment[g_numattachments].local[1][3] = tmp.y;
+	g_attachment[g_numattachments].local[2][3] = tmp.z;
+
+	g_numattachments++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+int LookupAttachment( char *name )
+{
+	int i;
+	for (i = 0; i < g_numattachments; i++)
+	{
+		if (stricmp( g_attachment[i].name, name ) == 0)
+		{
+			return i;
+		}
+	}
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void Cmd_Renamebone( )
+{
+	// from
+	GetToken (false);
+	V_strcpy_safe( g_renamedbone[g_numrenamedbones].from, token );
+
+	// to
+	GetToken (false);
+	V_strcpy_safe( g_renamedbone[g_numrenamedbones].to, token );
+
+	g_numrenamedbones++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+
+void Cmd_Skiptransition( )
+{
+	int nskips = 0;
+	int list[10];
+
+	while (TokenAvailable())
+	{
+		GetToken (false);
+		list[nskips++] = LookupXNode( token );
+	}
+
+	for (int i = 0; i < nskips; i++)
+	{
+		for (int j = 0; j < nskips; j++)
+		{
+			if (list[i] != list[j])
+			{
+				g_xnodeskip[g_numxnodeskips][0] = list[i];
+				g_xnodeskip[g_numxnodeskips][1] = list[j];
+				g_numxnodeskips++;
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// The following code is all related to LODs
+//
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Parse replacemodel command, causes an LOD to use a new model
+//-----------------------------------------------------------------------------
+
+static void Cmd_ReplaceModel( LodScriptData_t& lodData )
+{
+	int i = lodData.modelReplacements.AddToTail();
+	CLodScriptReplacement_t& newReplacement = lodData.modelReplacements[i];
+
+	// from
+	GetToken( false );
+
+	// Strip off extensions for the source...
+	char* pDot = strrchr( token, '.' );
+	if (pDot)
+	{
+		*pDot = 0;
+	}
+
+	if (!FindCachedSource( token, "" ))
+	{
+		// must have prior knowledge of the from
+		TokenError( "Unknown replace model '%s'\n", token );
+	}
+
+	newReplacement.SetSrcName( token );
+
+	// to
+	GetToken( false );
+	newReplacement.SetDstName( token );
+
+	// check for "reverse"
+	bool reverse =  false;
+	if( TokenAvailable() && GetToken( false ) )
+	{
+		if( stricmp( "reverse", token ) == 0 )
+		{
+			reverse = true;
+		}
+		else
+		{
+			TokenError( "\"%s\" unexpected\n", token );
+		}
+	}
+
+	// If the LOD system tells us to replace "blank", let's forget
+	// we ever read this. Have to do it here so parsing works
+	if( !stricmp( newReplacement.GetSrcName(), "blank" ) )
+	{
+		lodData.modelReplacements.FastRemove( i );
+		return;
+	}
+
+	// Load the source right here baby! That way its bones will get converted
+	if ( !lodData.IsStrippedFromModel() )
+	{
+		newReplacement.m_pSource = Load_Source( newReplacement.GetDstName(), "smd", reverse, false );
+	}
+	else if ( !g_quiet )
+	{
+		printf( "Stripped lod \"%s\" @ %.1f\n", newReplacement.GetDstName(), lodData.switchValue );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Parse removemodel command, causes an LOD to stop using a model
+//-----------------------------------------------------------------------------
+
+static void Cmd_RemoveModel( LodScriptData_t& lodData )
+{
+	int i = lodData.modelReplacements.AddToTail();
+	CLodScriptReplacement_t& newReplacement = lodData.modelReplacements[i];
+
+	// from
+	GetToken( false );
+
+	// Strip off extensions...
+	char* pDot = strrchr( token, '.' );
+	if (pDot)
+		*pDot = 0;
+
+	newReplacement.SetSrcName( token );
+
+	// to
+	newReplacement.SetDstName( "" );
+
+	// If the LOD system tells us to replace "blank", let's forget
+	// we ever read this. Have to do it here so parsing works
+	if( !stricmp( newReplacement.GetSrcName(), "blank" ) )
+	{
+		lodData.modelReplacements.FastRemove( i );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Parse replacebone command, causes a part of an LOD model to use a different bone
+//-----------------------------------------------------------------------------
+
+static void Cmd_ReplaceBone( LodScriptData_t& lodData )
+{
+	int i = lodData.boneReplacements.AddToTail();
+	CLodScriptReplacement_t& newReplacement = lodData.boneReplacements[i];
+
+	// from
+	GetToken( false );
+	newReplacement.SetSrcName( token );
+
+	// to
+	GetToken( false );
+	newReplacement.SetDstName( token );
+}
+
+//-----------------------------------------------------------------------------
+// Parse bonetreecollapse command, causes the entire subtree to use the same bone as the node
+//-----------------------------------------------------------------------------
+
+static void Cmd_BoneTreeCollapse( LodScriptData_t& lodData )
+{
+	int i = lodData.boneTreeCollapses.AddToTail();
+	CLodScriptReplacement_t& newCollapse = lodData.boneTreeCollapses[i];
+
+	// from
+	GetToken( false );
+	newCollapse.SetSrcName( token );
+}
+
+//-----------------------------------------------------------------------------
+// Parse replacematerial command, causes a material to be used in place of another
+//-----------------------------------------------------------------------------
+
+static void Cmd_ReplaceMaterial( LodScriptData_t& lodData )
+{
+	int i = lodData.materialReplacements.AddToTail();
+	CLodScriptReplacement_t& newReplacement = lodData.materialReplacements[i];
+
+	// from
+	GetToken( false );
+	newReplacement.SetSrcName( token );
+
+	// to
+	GetToken( false );
+	newReplacement.SetDstName( token );
+
+	if ( !lodData.IsStrippedFromModel() )
+	{
+		// make sure it goes into the master list
+		UseTextureAsMaterial( LookupTexture( token ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Parse removemesh command, causes a mesh to not be used anymore
+//-----------------------------------------------------------------------------
+
+static void Cmd_RemoveMesh( LodScriptData_t& lodData )
+{
+	int i = lodData.meshRemovals.AddToTail();
+	CLodScriptReplacement_t& newReplacement = lodData.meshRemovals[i];
+
+	// from
+	GetToken( false );
+	Q_FixSlashes( token );
+	newReplacement.SetSrcName( token );
+}
+
+void Cmd_LOD( const char *cmdname )
+{
+	if ( gflags & STUDIOHDR_FLAGS_HASSHADOWLOD )
+	{
+		MdlError( "Model can only have one $shadowlod and it must be the last lod in the .qc (%d) : %s\n", g_iLinecount, g_szLine );
+	}
+
+	int i = g_ScriptLODs.AddToTail();
+	LodScriptData_t& newLOD = g_ScriptLODs[i];
+
+	if( g_ScriptLODs.Count() > MAX_NUM_LODS )
+	{
+		MdlError( "Too many LODs (MAX_NUM_LODS==%d)\n", ( int )MAX_NUM_LODS );
+	}
+
+	// Shadow lod reserves -1 as switch value
+	// which uniquely identifies a shadow lod
+	newLOD.switchValue = -1.0f;
+
+	bool isShadowCall = ( !stricmp( cmdname, "$shadowlod" ) ) ? true : false;
+
+	if ( isShadowCall )
+	{
+		if ( TokenAvailable() )
+		{
+			GetToken( false );
+			MdlWarning( "(%d) : %s:  Ignoring switch value on %s command line\n", g_iLinecount, cmdname, g_szLine );
+		}
+
+		// Disable facial animation by default
+		newLOD.EnableFacialAnimation( false );
+	}
+	else
+	{
+		if ( TokenAvailable() )
+		{
+			GetToken( false );
+			newLOD.switchValue = verify_atof( token );
+			if ( newLOD.switchValue < 0.0f )
+			{
+				MdlError( "Negative switch value reserved for $shadowlod (%d) : %s\n", g_iLinecount, g_szLine );
+			}
+		}
+		else
+		{
+			MdlError( "Expected LOD switch value (%d) : %s\n", g_iLinecount, g_szLine );
+		}
+	}
+
+	GetToken( true );
+	if( stricmp( "{", token ) != 0 )
+	{
+		MdlError( "\"{\" expected while processing %s (%d) : %s", cmdname, g_iLinecount, g_szLine );
+	}
+
+	// In case we are stripping all lods and it's not Lod0, strip it
+	if ( i && g_bStripLods )
+		newLOD.StripFromModel( true );
+
+	while( 1 )
+	{
+		GetToken( true );
+		if( stricmp( "replacemodel", token ) == 0 )
+		{
+			Cmd_ReplaceModel(newLOD);
+		}
+		else if( stricmp( "removemodel", token ) == 0 )
+		{
+			Cmd_RemoveModel(newLOD);
+		}
+		else if( stricmp( "replacebone", token ) == 0 )
+		{
+			Cmd_ReplaceBone( newLOD );
+		}
+		else if( stricmp( "bonetreecollapse", token ) == 0 )
+		{
+			Cmd_BoneTreeCollapse( newLOD );
+		}
+		else if( stricmp( "replacematerial", token ) == 0 )
+		{
+			Cmd_ReplaceMaterial( newLOD );
+		}
+		else if( stricmp( "removemesh", token ) == 0 )
+		{
+			Cmd_RemoveMesh( newLOD );
+		}
+		else if( stricmp( "nofacial", token ) == 0 )
+		{
+			newLOD.EnableFacialAnimation( false );
+		}
+		else if( stricmp( "facial", token ) == 0 )
+		{
+			if (isShadowCall)
+			{
+				// facial animation has no reasonable purpose on a shadow lod
+				TokenError( "Facial animation is not allowed for $shadowlod\n" );
+			}
+
+			newLOD.EnableFacialAnimation( true );
+		}
+		else if ( stricmp( "use_shadowlod_materials", token ) == 0 )
+		{
+			if (isShadowCall)
+			{
+				gflags |= STUDIOHDR_FLAGS_USE_SHADOWLOD_MATERIALS;
+			}
+		}
+		else if( stricmp( "}", token ) == 0 )
+		{
+			break;
+		}
+		else
+		{
+			MdlError( "invalid input while processing %s (%d) : %s", cmdname, g_iLinecount, g_szLine );
+		}
+	}
+
+	// If the LOD is stripped, then forget we saw it
+	if ( newLOD.IsStrippedFromModel() )
+	{
+		g_ScriptLODs.FastRemove( i );
+	}
+}
+
+void Cmd_ShadowLOD( void )
+{
+	if (!g_quiet)
+	{
+		printf( "Processing $shadowlod\n" );
+	}
+
+	// Act like it's a regular lod entry
+	Cmd_LOD( "$shadowlod" );
+
+	// Mark .mdl as having shadow lod (we also check above that we have only one of these
+	// and that it's the last entered lod )
+	gflags |= STUDIOHDR_FLAGS_HASSHADOWLOD;
+}
+
+
+//-----------------------------------------------------------------------------
+// A couple commands related to translucency sorting
+//-----------------------------------------------------------------------------
+void Cmd_Opaque( )
+{
+	// Force Opaque has precedence
+	gflags |= STUDIOHDR_FLAGS_FORCE_OPAQUE;
+	gflags &= ~STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS;
+}
+
+void Cmd_TranslucentTwoPass( )
+{
+	// Force Opaque has precedence
+	if ((gflags & STUDIOHDR_FLAGS_FORCE_OPAQUE) == 0)
+	{
+		gflags |= STUDIOHDR_FLAGS_TRANSLUCENT_TWOPASS;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Indicates the model be rendered with ambient boost heuristic (first used on Alyx in Episode 1)
+//-----------------------------------------------------------------------------
+void Cmd_AmbientBoost()
+{
+	gflags |= STUDIOHDR_FLAGS_AMBIENT_BOOST;
+}
+
+//-----------------------------------------------------------------------------
+// Indicates the model should not cast shadows (useful for first-person models as used in L4D)
+//-----------------------------------------------------------------------------
+void Cmd_DoNotCastShadows()
+{
+	gflags |= STUDIOHDR_FLAGS_DO_NOT_CAST_SHADOWS;
+}
+
+//-----------------------------------------------------------------------------
+// Indicates the model should cast texutre-based shadows in vrad (NOTE: only applicable to prop_static)
+//-----------------------------------------------------------------------------
+void Cmd_CastTextureShadows()
+{
+	gflags |= STUDIOHDR_FLAGS_CAST_TEXTURE_SHADOWS;
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates the model should not fade out even if the level or fallback settings say to
+//-----------------------------------------------------------------------------
+void Cmd_NoForcedFade()
+{
+	gflags |= STUDIOHDR_FLAGS_NO_FORCED_FADE;
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates the model should not use the bone origin when calculating bboxes, sequence boxes, etc.
+//-----------------------------------------------------------------------------
+void Cmd_SkipBoneInBBox()
+{
+	g_bUseBoneInBBox = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Indicates the model will lengthen the viseme check to always include two phonemes
+//-----------------------------------------------------------------------------
+void Cmd_ForcePhonemeCrossfade()
+{
+	gflags |= STUDIOHDR_FLAGS_FORCE_PHONEME_CROSSFADE;
+}
+
+//-----------------------------------------------------------------------------
+// Indicates the model should keep pre-defined bone lengths regardless of animation changes
+//-----------------------------------------------------------------------------
+void Cmd_LockBoneLengths()
+{
+	g_bLockBoneLengths = true;
+}
+
+//-----------------------------------------------------------------------------
+// Indicates the model should replace pre-defined bone lengths and default orientations
+//-----------------------------------------------------------------------------
+void Cmd_UnlockDefineBones()
+{
+	g_bOverridePreDefinedBones = true;
+}
+
+//-----------------------------------------------------------------------------
+// Mark this model as obsolete so that it'll show the obsolete material in game.
+//-----------------------------------------------------------------------------
+void Cmd_Obsolete( )
+{
+	// Force Opaque has precedence
+	gflags |= STUDIOHDR_FLAGS_OBSOLETE;
+}
+
+//-----------------------------------------------------------------------------
+// The bones should be moved so that they center themselves on the verts they own.
+//-----------------------------------------------------------------------------
+void Cmd_CenterBonesOnVerts( )
+{
+	// force centering on bones
+	g_bCenterBonesOnVerts = true;
+}
+
+//-----------------------------------------------------------------------------
+// How far back should simple motion extract pull back from the last frame
+//-----------------------------------------------------------------------------
+void Cmd_MotionExtractionRollBack( )
+{
+	GetToken( false );
+	g_flDefaultMotionRollback = atof( token );
+}
+
+//-----------------------------------------------------------------------------
+// rules for breaking up long animations into multiple sub anims
+//-----------------------------------------------------------------------------
+void Cmd_SectionFrames( )
+{
+	GetToken( false );
+	g_sectionFrames = atof( token );
+	GetToken( false );
+	g_minSectionFrameLimit = atoi( token );
+}
+
+
+//-----------------------------------------------------------------------------
+// world space clamping boundaries for animations
+//-----------------------------------------------------------------------------
+void Cmd_ClampWorldspace( )
+{
+	GetToken (false);
+	g_vecMinWorldspace[0] = verify_atof( token );
+
+	GetToken (false);
+	g_vecMinWorldspace[1] = verify_atof( token );
+
+	GetToken (false);
+	g_vecMinWorldspace[2] = verify_atof( token );
+
+	GetToken (false);
+	g_vecMaxWorldspace[0] = verify_atof( token );
+
+	GetToken (false);
+	g_vecMaxWorldspace[1] = verify_atof( token );
+
+	GetToken (false);
+	g_vecMaxWorldspace[2] = verify_atof( token );
+}
+
+//-----------------------------------------------------------------------------
+// Key value block!
+//-----------------------------------------------------------------------------
+void Option_KeyValues( CUtlVector< char > *pKeyValue )
+{
+	// Simply read in the block between { }s as text 
+	// and plop it out unchanged into the .mdl file. 
+	// Make sure to respect the fact that we may have nested {}s
+	int nLevel = 1;
+
+	if ( !GetToken( true ) )
+		return;
+
+	if ( token[0] != '{' )
+		return;
+
+	AppendKeyValueText( pKeyValue, "mdlkeyvalue\n{\n" );
+
+	while ( GetToken(true) )
+	{
+		if ( !stricmp( token, "}" ) )
+		{
+			nLevel--;
+			if ( nLevel <= 0 )
+				break;
+			AppendKeyValueText( pKeyValue, " }\n" );
+		}
+		else if ( !stricmp( token, "{" ) )
+		{
+			AppendKeyValueText( pKeyValue, "{\n" );
+			nLevel++;
+		}
+		else
+		{
+			// tokens inside braces are quoted
+			if ( nLevel > 1 )
+			{
+				AppendKeyValueText( pKeyValue, "\"" );
+				AppendKeyValueText( pKeyValue, token );
+				AppendKeyValueText( pKeyValue, "\" " );
+			}
+			else
+			{
+				AppendKeyValueText( pKeyValue, token );
+				AppendKeyValueText( pKeyValue, " " );
+			}
+		}
+	}
+
+	if ( nLevel >= 1 )
+	{
+		TokenError( "Keyvalue block missing matching braces.\n" );
+	}
+
+	AppendKeyValueText( pKeyValue, "}\n" );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: force a specific parent child relationship
+//-----------------------------------------------------------------------------
+
+void Cmd_ForcedHierarchy( )
+{
+	// child name
+	GetToken (false);
+	V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].childname, token );
+
+	// parent name
+	GetToken (false);
+	V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].parentname, token );
+
+	g_numforcedhierarchy++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: insert a virtual bone between a child and parent (currently unsupported)
+//-----------------------------------------------------------------------------
+
+void Cmd_InsertHierarchy( )
+{
+	// child name
+	GetToken (false);
+	V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].childname, token );
+
+	// subparent name
+	GetToken (false);
+	V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].subparentname, token );
+
+	// parent name
+	GetToken (false);
+	V_strcpy_safe( g_forcedhierarchy[g_numforcedhierarchy].parentname, token );
+
+	g_numforcedhierarchy++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: rotate a specific bone
+//-----------------------------------------------------------------------------
+
+void Cmd_ForceRealign( )
+{
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_forcedrealign[g_numforcedrealign].name, token );
+
+	// skip
+	GetToken (false);
+
+	// X axis
+	GetToken (false);
+	g_forcedrealign[g_numforcedrealign].rot.x = DEG2RAD( verify_atof( token ) );
+
+	// Y axis
+	GetToken (false);
+	g_forcedrealign[g_numforcedrealign].rot.y = DEG2RAD( verify_atof( token ) );
+
+	// Z axis
+	GetToken (false);
+	g_forcedrealign[g_numforcedrealign].rot.z = DEG2RAD( verify_atof( token ) );
+
+	g_numforcedrealign++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: specify a bone to allow > 180 but < 360 rotation (forces a calculated "mid point" to rotation)
+//-----------------------------------------------------------------------------
+
+void Cmd_LimitRotation( )
+{
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_limitrotation[g_numlimitrotation].name, token );
+
+	while (TokenAvailable())
+	{
+		// sequence name
+		GetToken (false);
+		// This was a call to strcpyn but since sequencename is an array of char*
+		// it was passing sizeof(char*) as the number of characters to copy, which
+		// makes no sense. Commenting out until a better idea comes along.
+		Assert( 0 );
+		//V_strcpy_safe( g_limitrotation[g_numlimitrotation].sequencename[g_limitrotation[g_numlimitrotation].numseq++], token );
+	}
+
+	g_numlimitrotation++;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: specify bones to store, even if nothing references them
+//-----------------------------------------------------------------------------
+
+void Cmd_DefineBone( )
+{
+	// bone name
+	GetToken (false);
+	V_strcpy_safe( g_importbone[g_numimportbones].name, token );
+
+	// parent name
+	GetToken (false);
+	V_strcpy_safe( g_importbone[g_numimportbones].parent, token );
+
+	Vector pos;
+	QAngle angles;
+
+	// default pos
+	GetToken (false);
+	pos.x = verify_atof( token );
+	GetToken (false);
+	pos.y = verify_atof( token );
+	GetToken (false);
+	pos.z = verify_atof( token );
+	GetToken (false);
+	angles.x = verify_atof( token );
+	GetToken (false);
+	angles.y = verify_atof( token );
+	GetToken (false);
+	angles.z = verify_atof( token );
+	AngleMatrix( angles, pos, g_importbone[g_numimportbones].rawLocal );
+
+	if (TokenAvailable())
+	{
+		g_importbone[g_numimportbones].bPreAligned = true;
+		// realign pos
+		GetToken (false);
+		pos.x = verify_atof( token );
+		GetToken (false);
+		pos.y = verify_atof( token );
+		GetToken (false);
+		pos.z = verify_atof( token );
+		GetToken (false);
+		angles.x = verify_atof( token );
+		GetToken (false);
+		angles.y = verify_atof( token );
+		GetToken (false);
+		angles.z = verify_atof( token );
+
+		AngleMatrix( angles, pos, g_importbone[g_numimportbones].srcRealign );
+	}
+	else
+	{
+		SetIdentityMatrix( g_importbone[g_numimportbones].srcRealign );
+	}
+
+	g_numimportbones++;
+}
+
+
+//----------------------------------------------------------------------------------------------
+float ParseJiggleStiffness( void )
+{
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting stiffness value\n" );
+		return 0.0f;
+	}
+
+	float stiffness = verify_atof( token );
+	
+	const float minStiffness = 0.0f;
+	const float maxStiffness = 1000.0f;
+
+	return clamp( stiffness, minStiffness, maxStiffness );
+}
+
+
+//----------------------------------------------------------------------------------------------
+float ParseJiggleDamping( void )
+{
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting damping value\n" );
+		return 0.0f;
+	}
+
+	float damping = verify_atof( token );
+
+	const float minDamping = 0.0f;
+	const float maxDamping = 10.0f;
+
+	return clamp( damping, minDamping, maxDamping );
+}
+
+
+//----------------------------------------------------------------------------------------------
+bool ParseJiggleAngleConstraint( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= JIGGLE_HAS_ANGLE_CONSTRAINT;
+
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting angle value\n" );
+		return false;
+	}
+	
+	jiggleInfo->data.angleLimit = verify_atof( token ) * M_PI / 180.0f;
+	
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+bool ParseJiggleYawConstraint( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= JIGGLE_HAS_YAW_CONSTRAINT;
+	
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting minimum yaw value\n" );
+		return false;	
+	}
+
+	jiggleInfo->data.minYaw = verify_atof( token ) * M_PI / 180.0f;
+
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting maximum yaw value\n" );
+		return false;
+	}
+
+	jiggleInfo->data.maxYaw = verify_atof( token ) * M_PI / 180.0f;
+	
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+bool ParseJigglePitchConstraint( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= JIGGLE_HAS_PITCH_CONSTRAINT;
+
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting minimum pitch value\n" );
+		return false;	
+	}
+
+	jiggleInfo->data.minPitch = verify_atof( token ) * M_PI / 180.0f;
+
+	if ( !GetToken( false ) )
+	{
+		MdlError( "$jigglebone: expecting maximum pitch value\n" );
+		return false;
+	}
+
+	jiggleInfo->data.maxPitch = verify_atof( token ) * M_PI / 180.0f;
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse common parameters.
+ * This assumes a token has already been read, and returns true if
+ * the token is recognized and parsed.
+ */
+bool ParseCommonJiggle( s_jigglebone_t *jiggleInfo )
+{
+	if (!stricmp( token, "tip_mass" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;
+		}
+
+		jiggleInfo->data.tipMass = verify_atof( token );
+	}
+	else if (!stricmp( token, "length" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;
+		}
+
+		jiggleInfo->data.length = verify_atof( token );
+	}
+	else if (!stricmp( token, "angle_constraint" ))
+	{
+		if (ParseJiggleAngleConstraint( jiggleInfo ) == false)
+		{
+			return false;
+		}
+	}
+	else if (!stricmp( token, "yaw_constraint" ))
+	{
+		if (ParseJiggleYawConstraint( jiggleInfo ) == false)
+		{
+			return false;
+		}
+	}
+	else if (!stricmp( token, "yaw_friction" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;
+		}
+
+		jiggleInfo->data.yawFriction = verify_atof( token );
+	}
+	else if (!stricmp( token, "yaw_bounce" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;
+		}
+
+		jiggleInfo->data.yawBounce = verify_atof( token );
+	}
+	else if (!stricmp( token, "pitch_constraint" ))
+	{
+		if (ParseJigglePitchConstraint( jiggleInfo ) == false)
+		{
+			return false;
+		}
+	}
+	else if (!stricmp( token, "pitch_friction" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;		
+		}
+
+		jiggleInfo->data.pitchFriction = verify_atof( token );
+	}
+	else if (!stricmp( token, "pitch_bounce" ))
+	{
+		if ( !GetToken( false ) )
+		{
+			return false;		
+		}
+
+		jiggleInfo->data.pitchBounce = verify_atof( token );
+	}
+	else
+	{
+		// unknown token
+		MdlError( "$jigglebone: invalid syntax '%s'\n", token );
+		return false;
+	}
+	
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse parameters for is_flexible subsection
+ */
+bool ParseFlexibleJiggle( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= (JIGGLE_IS_FLEXIBLE | JIGGLE_HAS_LENGTH_CONSTRAINT);
+	
+	bool gotOpenBracket = false;	
+	while (true)
+	{
+		if (GetToken( true ) == false)
+		{
+			MdlError( "$jigglebone:is_flexible: parse error\n" );
+			return false;
+		}
+
+		if (!stricmp( token, "{" ))
+		{
+			gotOpenBracket = true;
+		}
+		else if (!gotOpenBracket)
+		{
+			MdlError( "$jigglebone:is_flexible: missing '{'\n" );
+			return false;
+		}
+		else if (!stricmp( token, "}" ))
+		{
+			// definition complete
+			break;
+		}
+		else if (!stricmp( token, "yaw_stiffness" ))
+		{
+			jiggleInfo->data.yawStiffness = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "yaw_damping" ))
+		{
+			jiggleInfo->data.yawDamping = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "pitch_stiffness" ))
+		{
+			jiggleInfo->data.pitchStiffness = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "pitch_damping" ))
+		{
+			jiggleInfo->data.pitchDamping = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "along_stiffness" ))
+		{
+			jiggleInfo->data.alongStiffness = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "along_damping" ))
+		{
+			jiggleInfo->data.alongDamping = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "allow_length_flex" ))
+		{
+			jiggleInfo->data.flags &= ~JIGGLE_HAS_LENGTH_CONSTRAINT;
+		}
+		else if (ParseCommonJiggle( jiggleInfo ) == false)
+		{
+			MdlError( "$jigglebone:is_flexible: invalid syntax '%s'\n", token );
+			return false;
+		}
+	}
+	
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse parameters for is_rigid subsection
+ */
+bool ParseRigidJiggle( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= (JIGGLE_IS_RIGID | JIGGLE_HAS_LENGTH_CONSTRAINT);
+
+	bool gotOpenBracket = false;	
+	while (true)
+	{
+		if (GetToken( true ) == false)
+		{
+			MdlError( "$jigglebone:is_rigid: parse error\n" );
+			return false;
+		}
+
+		if (!stricmp( token, "{" ))
+		{
+			gotOpenBracket = true;
+		}
+		else if (!gotOpenBracket)
+		{
+			MdlError( "$jigglebone:is_rigid: missing '{'\n" );
+			return false;
+		}
+		else if (!stricmp( token, "}" ))
+		{
+			// definition complete
+			break;
+		}
+		else if (ParseCommonJiggle( jiggleInfo ) == false)
+		{
+			MdlError( "$jigglebone:is_rigid: invalid syntax '%s'\n", token );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse parameters for has_base_spring subsection
+ */
+bool ParseBaseSpringJiggle( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= JIGGLE_HAS_BASE_SPRING;
+
+	bool gotOpenBracket = false;	
+	while (true)
+	{
+		if (GetToken( true ) == false)
+		{
+			MdlError( "$jigglebone:has_base_spring: parse error\n" );
+			return false;
+		}
+
+		if (!stricmp( token, "{" ))
+		{
+			gotOpenBracket = true;
+		}
+		else if (!gotOpenBracket)
+		{
+			MdlError( "$jigglebone:has_base_spring: missing '{'\n" );
+			return false;
+		}
+		else if (!stricmp( token, "}" ))
+		{
+			// definition complete
+			break;
+		}
+		else if (!stricmp( token, "stiffness" ))
+		{
+			jiggleInfo->data.baseStiffness = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "damping" ))
+		{
+			jiggleInfo->data.baseDamping = ParseJiggleStiffness();
+		}
+		else if (!stricmp( token, "left_constraint" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMinLeft = verify_atof( token );
+
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMaxLeft = verify_atof( token );
+		}
+		else if (!stricmp( token, "left_friction" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseLeftFriction = verify_atof( token );
+		}
+		else if (!stricmp( token, "up_constraint" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMinUp = verify_atof( token );
+
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMaxUp = verify_atof( token );
+		}
+		else if (!stricmp( token, "up_friction" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseUpFriction = verify_atof( token );
+		}
+		else if (!stricmp( token, "forward_constraint" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMinForward = verify_atof( token );
+
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMaxForward = verify_atof( token );
+		}
+		else if (!stricmp( token, "forward_friction" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseForwardFriction = verify_atof( token );
+		}
+		else if (!stricmp( token, "base_mass" ))
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.baseMass = verify_atof( token );
+		}
+		else if (ParseCommonJiggle( jiggleInfo ) == false)
+		{
+			MdlError( "$jigglebone:has_base_spring: invalid syntax '%s'\n", token );
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse parameters for is_boing subsection
+ */
+bool ParseBoing( s_jigglebone_t *jiggleInfo )
+{
+	jiggleInfo->data.flags |= JIGGLE_IS_BOING;
+
+	// default values
+	jiggleInfo->data.boingImpactSpeed = 100.0f;
+	jiggleInfo->data.boingImpactAngle = 0.7071f;
+	jiggleInfo->data.boingDampingRate = 0.25f;
+	jiggleInfo->data.boingFrequency = 30.0f;
+	jiggleInfo->data.boingAmplitude = 0.35f;
+
+	bool gotOpenBracket = false;	
+	while ( true )
+	{
+		if ( GetToken( true ) == false )
+		{
+			MdlError( "$jigglebone:is_boing: parse error\n" );
+			return false;
+		}
+
+		if ( !stricmp( token, "{" ) )
+		{
+			gotOpenBracket = true;
+		}
+		else if ( !gotOpenBracket )
+		{
+			MdlError( "$jigglebone:is_boing: missing '{'\n" );
+			return false;
+		}
+		else if ( !stricmp( token, "}" ) )
+		{
+			// definition complete
+			break;
+		}
+		else if ( !stricmp( token, "impact_speed" ) )
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.boingImpactSpeed = verify_atof( token );
+		}
+		else if ( !stricmp( token, "impact_angle" ) )
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.boingImpactAngle = cos( DEG2RAD( verify_atof( token ) ) );
+		}
+		else if ( !stricmp( token, "damping_rate" ) )
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.boingDampingRate = verify_atof( token );
+		}
+		else if ( !stricmp( token, "frequency" ) )
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.boingFrequency = verify_atof( token );
+		}
+		else if ( !stricmp( token, "amplitude" ) )
+		{
+			if ( !GetToken( false ) )
+			{
+				return false;
+			}
+
+			jiggleInfo->data.boingAmplitude = verify_atof( token );
+		}
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------------------------------
+/**
+ * Parse $jigglebone parameters
+ */
+void Cmd_JiggleBone( void )
+{
+	struct s_jigglebone_t *jiggleInfo = &g_jigglebones[ g_numjigglebones ];
+
+	// bone name
+	GetToken( false );
+	V_strcpy_safe( jiggleInfo->bonename, token );
+
+	// default values
+	memset( &jiggleInfo->data, 0, sizeof( mstudiojigglebone_t ) );
+	jiggleInfo->data.length = 10.0f;
+	jiggleInfo->data.yawStiffness = 100.0f;
+	jiggleInfo->data.pitchStiffness = 100.0f;
+	jiggleInfo->data.alongStiffness = 100.0f;
+	jiggleInfo->data.baseStiffness = 100.0f;
+	jiggleInfo->data.baseMinUp = -100.0f;
+	jiggleInfo->data.baseMaxUp = 100.0f;
+	jiggleInfo->data.baseMinLeft = -100.0f;
+	jiggleInfo->data.baseMaxLeft = 100.0f;
+	jiggleInfo->data.baseMinForward = -100.0f;
+	jiggleInfo->data.baseMaxForward = 100.0f;
+
+	bool gotOpenBracket = false;	
+	while (true)
+	{
+		if (GetToken( true ) == false)
+		{
+			MdlError( "$jigglebone: parse error\n" );
+			return;
+		}
+		
+		if (!stricmp( token, "{" ))
+		{
+			gotOpenBracket = true;
+		}
+		else if (!gotOpenBracket)
+		{
+			MdlError( "$jigglebone: missing '{'\n" );
+			return;				
+		}
+		else if (!stricmp( token, "}" ))
+		{
+			// definition complete
+			break;
+		}
+		else if (!stricmp( token, "is_flexible" ))
+		{
+			if (ParseFlexibleJiggle( jiggleInfo ) == false)
+			{
+				return;
+			}
+		}
+		else if (!stricmp( token, "is_rigid" ))
+		{
+			if (ParseRigidJiggle( jiggleInfo ) == false)
+			{
+				return;
+			}
+		}
+		else if (!stricmp( token, "has_base_spring" ))
+		{
+			if (ParseBaseSpringJiggle( jiggleInfo ) == false)
+			{
+				return;
+			}
+		}	
+		else if ( !stricmp( token, "is_boing" ) )
+		{
+			if ( ParseBoing( jiggleInfo ) == false )
+			{
+				return;
+			}
+		}	
+		else
+		{
+			MdlError( "$jigglebone: invalid syntax '%s'\n", token );
+			return;				
+		}
+	}
+
+	if (!g_quiet)
+		Msg( "Marking bone %s as a jiggle bone\n", jiggleInfo->bonename );
+
+	g_numjigglebones++;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: specify bones to store, even if nothing references them
+//-----------------------------------------------------------------------------
+
+void Cmd_IncludeModel( )
+{
+	GetToken( false );
+	V_strcpy_safe( g_includemodel[g_numincludemodels].name, "models/" );
+	V_strcat_safe( g_includemodel[g_numincludemodels].name, token );
+	g_numincludemodels++;
+}
+
+
+/*
+=================
+=================
+*/
+
+void Grab_Vertexanimation( s_source_t *psource, const char *pAnimName )
+{
+	char	cmd[1024];
+	int		index;
+	Vector	pos;
+	Vector	normal;
+	int		t = -1;
+	int		count = 0;
+	static s_vertanim_t	tmpvanim[MAXSTUDIOVERTS*4];
+
+	s_sourceanim_t *pAnim = FindSourceAnim( psource, pAnimName );
+	if ( !pAnim )
+	{
+		MdlError( "Unknown animation %s(%d) : %s\n", pAnimName, g_iLinecount, g_szLine );
+	}
+
+	while (GetLineInput()) 
+	{
+		if (sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &normal[0], &normal[1], &normal[2] ) == 7)
+		{
+			if ( pAnim->startframe < 0 )
+			{
+				MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
+			}
+
+			if (t < 0)
+			{
+				MdlError( "VTA Frame Sync (%d) : %s", g_iLinecount, g_szLine );
+			}
+
+			tmpvanim[count].vertex = index;
+			VectorCopy( pos, tmpvanim[count].pos );
+			VectorCopy( normal, tmpvanim[count].normal );
+			count++;
+
+			if ( index >= psource->numvertices )
+			{
+				psource->numvertices = index + 1;
+			}
+		}
+		else
+		{
+			// flush data
+
+			if (count)
+			{
+				pAnim->numvanims[t] = count;
+
+				pAnim->vanim[t] = (s_vertanim_t *)kalloc( count, sizeof( s_vertanim_t ) );
+
+				memcpy( pAnim->vanim[t], tmpvanim, count * sizeof( s_vertanim_t ) );
+			}
+			else if (t > 0)
+			{
+				pAnim->numvanims[t] = 0;
+			}
+
+			// next command
+			if (sscanf( g_szLine, "%1023s %d", cmd, &index ))
+			{
+				if (stricmp( cmd, "time" ) == 0) 
+				{
+					t = index;
+					count = 0;
+
+					if ( t < pAnim->startframe )
+					{
+						MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
+					}
+					if ( t > pAnim->endframe )
+					{
+						MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
+					}
+
+					t -= pAnim->startframe;
+				}
+				else if ( !Q_stricmp( cmd, "end" ) ) 
+				{
+					pAnim->numframes = pAnim->endframe - pAnim->startframe + 1;
+					return;
+				}
+				else
+				{
+					MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
+				}
+			}
+			else
+			{
+				MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
+			}
+		}
+	}
+	MdlError( "unexpected EOF: %s\n", psource->filename );
+}
+
+bool GetGlobalFilePath( const char *pSrc, char *pFullPath, int nMaxLen )
+{
+	char	pFileName[1024];
+	Q_strncpy( pFileName, ExpandPath( (char*)pSrc ), sizeof(pFileName) );
+
+	// This is kinda gross. . . doing the same work in cmdlib on SafeOpenRead.
+	int nPathLength;
+	if( CmdLib_HasBasePath( pFileName, nPathLength ) )
+	{
+		char tmp[1024];
+		int i;
+
+		int nNumBasePaths = CmdLib_GetNumBasePaths();
+		for( i = 0; i < nNumBasePaths; i++ )
+		{
+			V_strcpy_safe( tmp, CmdLib_GetBasePath( i ) );
+			V_strcat_safe( tmp, pFileName + nPathLength );
+
+			struct _stat buf;
+			int rt = _stat( tmp, &buf );
+			if ( rt != -1 && ( buf.st_size > 0 ) && ( ( buf.st_mode & _S_IFDIR ) == 0 ) )
+			{
+				Q_strncpy( pFullPath, tmp, nMaxLen );
+				return true;
+			}
+		}
+		return false;
+	}
+
+	struct _stat buf;
+	int rt = _stat( pFileName, &buf );
+	if ( rt != -1 && ( buf.st_size > 0 ) && ( ( buf.st_mode & _S_IFDIR ) == 0 )	)
+	{
+		Q_strncpy( pFullPath, pFileName, nMaxLen );
+		return true;
+	}
+	return false;
+}
+
+
+int OpenGlobalFile( char *src )
+{
+	int		time1;
+	char	filename[1024];
+
+	V_strcpy_safe( filename, ExpandPath( src ) );
+
+	int pathLength;
+	int numBasePaths = CmdLib_GetNumBasePaths();
+	// This is kinda gross. . . doing the same work in cmdlib on SafeOpenRead.
+	if( CmdLib_HasBasePath( filename, pathLength ) )
+	{
+		char tmp[1024];
+		int i;
+		for( i = 0; i < numBasePaths; i++ )
+		{
+			V_strcpy_safe( tmp, CmdLib_GetBasePath( i ) );
+			V_strcat_safe( tmp, filename + pathLength );
+			if( g_bCreateMakefile )
+			{
+				CreateMakefile_AddDependency( tmp );
+				return 0;
+			}
+			
+			time1 = FileTime( tmp );
+			if( time1 != -1 )
+			{
+				if ((g_fpInput = fopen(tmp, "r" ) ) == 0) 
+				{
+					MdlWarning( "reader: could not open file '%s'\n", src );
+					return 0;
+				}
+				else
+				{
+					return 1;
+				}
+			}
+		}
+		return 0;
+	}
+	else
+	{
+		time1 = FileTime (filename);
+		if (time1 == -1)
+			return 0;
+
+		if( g_bCreateMakefile )
+		{
+			CreateMakefile_AddDependency( filename );
+			return 0;
+		}
+		if ((g_fpInput = fopen(filename, "r" ) ) == 0) 
+		{
+			MdlWarning( "reader: could not open file '%s'\n", src );
+			return 0;
+		}
+
+		return 1;
+	}
+}
+
+
+
+int Load_VTA( s_source_t *psource )
+{
+	char	cmd[1024];
+	int		option;
+
+	if (!OpenGlobalFile( psource->filename ))
+		return 0;
+
+	if (!g_quiet)
+		printf ("VTA MODEL %s\n", psource->filename);
+
+	g_iLinecount = 0;
+	while (GetLineInput()) 
+	{
+		g_iLinecount++;
+		sscanf( g_szLine, "%s %d", cmd, &option );
+		if (stricmp( cmd, "version" ) == 0) 
+		{
+			if (option != 1) 
+			{
+				MdlError("bad version\n");
+			}
+		}
+		else if (stricmp( cmd, "nodes" ) == 0) 
+		{
+			psource->numbones = Grab_Nodes( psource->localBone );
+		}
+		else if (stricmp( cmd, "skeleton" ) == 0) 
+		{
+			Grab_Animation( psource, "VertexAnimation" );
+		}
+		else if (stricmp( cmd, "vertexanimation" ) == 0) 
+		{
+			Grab_Vertexanimation( psource, "VertexAnimation" );
+		}
+		else 
+		{
+			MdlWarning("unknown studio command \"%s\"\n", cmd );
+		}
+	}
+	fclose( g_fpInput );
+
+	return 1;
+}
+
+
+void Grab_AxisInterpBones( )
+{
+	char	cmd[1024], tmp[1025];
+	Vector	basepos;
+	s_axisinterpbone_t *pAxis = NULL;
+	s_axisinterpbone_t *pBone = &g_axisinterpbones[g_numaxisinterpbones];
+
+	while (GetLineInput()) 
+	{
+		if (IsEnd( g_szLine )) 
+		{
+			return;
+		}
+		int i = sscanf( g_szLine, "%1023s \"%[^\"]\" \"%[^\"]\" \"%[^\"]\" \"%[^\"]\" %d", cmd, pBone->bonename, tmp, pBone->controlname, tmp, &pBone->axis );
+		if (i == 6 && stricmp( cmd, "bone") == 0)
+		{
+			// printf( "\"%s\" \"%s\" \"%s\" \"%s\"\n", cmd, pBone->bonename, tmp, pBone->controlname );
+			pAxis = pBone;
+			pBone->axis = pBone->axis - 1;	// MAX uses 1..3, engine 0..2
+			g_numaxisinterpbones++;
+			pBone = &g_axisinterpbones[g_numaxisinterpbones];
+		}
+		else if (stricmp( cmd, "display" ) == 0)
+		{
+			// skip all display info
+		}
+		else if (stricmp( cmd, "type" ) == 0)
+		{
+			// skip all type info
+		}
+		else if (stricmp( cmd, "basepos" ) == 0)
+		{
+			i = sscanf( g_szLine, "basepos %f %f %f", &basepos.x, &basepos.y, &basepos.z );
+			// skip all type info
+		}
+		else if (stricmp( cmd, "axis" ) == 0)
+		{
+			Vector pos;
+			QAngle rot;
+			int j;
+			i = sscanf( g_szLine, "axis %d %f %f %f %f %f %f", &j, &pos[0], &pos[1], &pos[2], &rot[2], &rot[0], &rot[1] );
+			if (i == 7)
+			{
+				VectorAdd( basepos, pos, pAxis->pos[j] );
+				AngleQuaternion( rot, pAxis->quat[j] );
+			}
+		}
+	}
+}
+
+
+bool Grab_AimAtBones( )
+{
+	s_aimatbone_t *pAimAtBone( &g_aimatbones[g_numaimatbones] );
+
+	// Already know it's <aimconstraint> in the first string, otherwise wouldn't be here
+	if ( sscanf( g_szLine, "%*s %127s %127s %127s", pAimAtBone->bonename, pAimAtBone->parentname, pAimAtBone->aimname ) == 3 )
+	{
+		g_numaimatbones++;
+
+		char	cmd[1024];
+		Vector	vector;
+
+		while ( GetLineInput() ) 
+		{
+			g_iLinecount++;
+
+			if (IsEnd( g_szLine )) 
+			{
+				return false;
+			}
+
+			if ( sscanf( g_szLine, "%1024s %f %f %f", cmd, &vector[0], &vector[1], &vector[2] ) != 4 )
+			{
+				// Allow blank lines to be skipped without error
+				bool allSpace( true );
+				for ( const char *pC( g_szLine ); *pC != '\0' && pC < ( g_szLine + 4096 ); ++pC )
+				{
+					if ( !V_isspace( *pC ) )
+					{
+						allSpace = false;
+						break;
+					}
+				}
+
+				if ( allSpace )
+				{
+					continue;
+				}
+
+				return true;
+			}
+
+			if ( stricmp( cmd, "<aimvector>" ) == 0)
+			{
+				// Make sure these are unit length on read
+				VectorNormalize( vector );
+				pAimAtBone->aimvector = vector;
+			}
+			else if ( stricmp( cmd, "<upvector>" ) == 0)
+			{
+				// Make sure these are unit length on read
+				VectorNormalize( vector );
+				pAimAtBone->upvector = vector;
+			}
+			else if ( stricmp( cmd, "<basepos>" ) == 0)
+			{
+				pAimAtBone->basepos = vector;
+			}
+			else
+			{
+				return true;
+			}
+		}
+	}
+
+	// If we get here, we're at EOF
+	return false;
+}
+
+
+
+void Grab_QuatInterpBones( )
+{
+	char	cmd[1024];
+	Vector	basepos;
+	RadianEuler	rotateaxis( 0.0f, 0.0f, 0.0f );
+	RadianEuler	jointorient( 0.0f, 0.0f, 0.0f );
+	s_quatinterpbone_t *pAxis = NULL;
+	s_quatinterpbone_t *pBone = &g_quatinterpbones[g_numquatinterpbones];
+
+	while (GetLineInput()) 
+	{
+		g_iLinecount++;
+		if (IsEnd( g_szLine )) 
+		{
+			return;
+		}
+
+		int i = sscanf( g_szLine, "%s %s %s %s %s", cmd, pBone->bonename, pBone->parentname, pBone->controlparentname, pBone->controlname );
+
+		while ( i == 4 && stricmp( cmd, "<aimconstraint>" ) == 0 )
+		{
+			// If Grab_AimAtBones() returns false, there file is at EOF
+			if ( !Grab_AimAtBones() )
+			{
+				return;
+			}
+
+			// Grab_AimAtBones will read input into g_szLine same as here until it gets a line it doesn't understand, at which point
+			// it will exit leaving that line in g_szLine, so check for the end and scan the current buffer again and continue on with 
+			// the normal QuatInterpBones process
+
+			i = sscanf( g_szLine, "%s %s %s %s %s", cmd, pBone->bonename, pBone->parentname, pBone->controlparentname, pBone->controlname );
+		}
+
+		if (i == 5 && stricmp( cmd, "<helper>") == 0)
+		{
+			// printf( "\"%s\" \"%s\" \"%s\" \"%s\"\n", cmd, pBone->bonename, tmp, pBone->controlname );
+			pAxis = pBone;
+			g_numquatinterpbones++;
+			pBone = &g_quatinterpbones[g_numquatinterpbones];
+		}
+		else if ( i > 0 )
+		{
+			// There was a bug before which could cause the same command to be parsed twice
+			// because if the sscanf above completely fails, it will return 0 and not 
+			// change the contents of cmd, so i should be greater than 0 in order for
+			// any of these checks to be valid... Still kind of buggy as these checks
+			// do case insensitive stricmp but then the sscanf does case sensitive
+			// matching afterwards... Should probably change those to
+			// sscanf( g_szLine, "%*s %f ... ) etc...
+
+			if ( stricmp( cmd, "<display>" ) == 0)
+			{
+				// skip all display info
+				Vector size;
+				float distance;
+
+				i = sscanf( g_szLine, "<display> %f %f %f %f", 
+					&size[0], &size[1], &size[2],
+					&distance );
+
+				if (i == 4)
+				{
+					pAxis->percentage = distance / 100.0;
+					pAxis->size = size;
+				}
+				else
+				{
+					MdlError( "Line %d: Unable to parse procedual <display> bone: %s", g_iLinecount, g_szLine );
+				}
+			}
+			else if ( stricmp( cmd, "<basepos>" ) == 0)
+			{
+				i = sscanf( g_szLine, "<basepos> %f %f %f", &basepos.x, &basepos.y, &basepos.z );
+				// skip all type info
+			}
+			else if ( stricmp( cmd, "<rotateaxis>" ) == 0)
+			{
+				i = sscanf( g_szLine, "%*s %f %f %f", &rotateaxis.x, &rotateaxis.y, &rotateaxis.z );
+				rotateaxis.x = DEG2RAD( rotateaxis.x );
+				rotateaxis.y = DEG2RAD( rotateaxis.y );
+				rotateaxis.z = DEG2RAD( rotateaxis.z );
+			}
+			else if ( stricmp( cmd, "<jointorient>" ) == 0)
+			{
+				i = sscanf( g_szLine, "%*s %f %f %f", &jointorient.x, &jointorient.y, &jointorient.z );
+				jointorient.x = DEG2RAD( jointorient.x );
+				jointorient.y = DEG2RAD( jointorient.y );
+				jointorient.z = DEG2RAD( jointorient.z );
+			}
+			else if ( stricmp( cmd, "<trigger>" ) == 0)
+			{
+				float tolerance;
+				RadianEuler trigger;
+				Vector pos;
+				RadianEuler ang;
+
+				QAngle rot;
+				int j;
+				i = sscanf( g_szLine, "<trigger> %f %f %f %f %f %f %f %f %f %f", 
+					&tolerance,
+					&trigger.x, &trigger.y, &trigger.z,
+					&ang.x, &ang.y, &ang.z,
+					&pos.x, &pos.y, &pos.z );
+
+				if (i == 10)
+				{
+					trigger.x = DEG2RAD( trigger.x );
+					trigger.y = DEG2RAD( trigger.y );
+					trigger.z = DEG2RAD( trigger.z );
+					ang.x = DEG2RAD( ang.x );
+					ang.y = DEG2RAD( ang.y );
+					ang.z = DEG2RAD( ang.z );
+
+					Quaternion q;
+					AngleQuaternion( ang, q );
+
+					if ( rotateaxis.x != 0.0 || rotateaxis.y != 0.0 || rotateaxis.z != 0.0 )
+					{
+						Quaternion q1;
+						Quaternion q2;
+						AngleQuaternion( rotateaxis, q1 );
+						QuaternionMult( q1, q, q2 );
+						q = q2;
+					}
+
+					if ( jointorient.x != 0.0 || jointorient.y != 0.0 || jointorient.z != 0.0 )
+					{
+						Quaternion q1;
+						Quaternion q2;
+						AngleQuaternion( jointorient, q1 );
+						QuaternionMult( q, q1, q2 );
+						q = q2;
+					}
+
+					j = pAxis->numtriggers++;
+					pAxis->tolerance[j] = DEG2RAD( tolerance );
+					AngleQuaternion( trigger, pAxis->trigger[j] );
+					VectorAdd( basepos, pos, pAxis->pos[j] );
+					pAxis->quat[j] = q;
+				}
+				else
+				{
+					MdlError( "Line %d: Unable to parse procedual <trigger> bone: %s", g_iLinecount, g_szLine );
+				}
+			}
+			else
+			{
+				MdlError( "Line %d: Unable to parse procedual bone data: %s", g_iLinecount, g_szLine );
+			}
+		}
+		else
+		{
+			// Allow blank lines to be skipped without error
+			bool allSpace( true );
+			for ( const char *pC( g_szLine ); *pC != '\0' && pC < ( g_szLine + 4096 ); ++pC )
+			{
+				if ( !V_isspace( *pC ) )
+				{
+					allSpace = false;
+					break;
+				}
+			}
+
+			if ( !allSpace )
+			{
+				MdlError( "Line %d: Unable to parse procedual bone data: %s", g_iLinecount, g_szLine );
+			}
+		}
+	}
+}
+
+
+void Load_ProceduralBones( )
+{
+	char	filename[256];
+	char	cmd[1024];
+	int		option;
+
+	GetToken( false );
+	V_strcpy_safe( filename, token );
+
+	if (!OpenGlobalFile( filename ))
+		return;
+
+	g_iLinecount = 0;
+
+	char ext[32];
+	Q_ExtractFileExtension( filename, ext, sizeof( ext ) );
+
+	if (stricmp( ext, "vrd") == 0)
+	{
+		Grab_QuatInterpBones( );
+	}
+	else
+	{
+		while (GetLineInput()) 
+		{
+			g_iLinecount++;
+			sscanf( g_szLine, "%s %d", cmd, &option );
+			if (stricmp( cmd, "version" ) == 0) 
+			{
+				if (option != 1) 
+				{
+					MdlError("bad version\n");
+				}
+			}
+			else if (stricmp( cmd, "proceduralbones" ) == 0) 
+			{
+				Grab_AxisInterpBones( );
+			}
+		}
+	}
+	fclose( g_fpInput );
+}
+
+
+void Cmd_CD()
+{
+	if (cdset)
+		MdlError ("Two $cd in one model");
+	cdset = true;
+	GetToken (false);
+	V_strcpy_safe (cddir[0], token);
+	V_strcat_safe (cddir[0], "/" );
+	numdirs = 0;
+}
+
+
+void Cmd_CDMaterials()
+{
+	while (TokenAvailable())
+	{
+		GetToken (false);
+		
+		char szPath[512];
+		Q_strncpy( szPath, token, sizeof( szPath ) );
+
+		int len = strlen( szPath );
+		if ( len > 0 && szPath[len-1] != '/' && szPath[len-1] != '\\' )
+		{
+			Q_strncat( szPath, "/", sizeof( szPath ), COPY_ALL_CHARACTERS );
+		}
+
+		Q_FixSlashes( szPath );
+		cdtextures[numcdtextures] = strdup( szPath );
+		numcdtextures++;
+	}
+}
+
+
+void Cmd_Pushd()
+{
+	GetToken(false);
+
+	V_strcpy_safe( cddir[numdirs+1], cddir[numdirs] );
+	V_strcat_safe( cddir[numdirs+1], token );
+	V_strcat_safe( cddir[numdirs+1], "/" );
+	numdirs++;
+}
+
+void Cmd_Popd()
+{
+	if (numdirs > 0)
+		numdirs--;
+}
+
+void Cmd_CollisionModel()
+{
+	DoCollisionModel( false );
+}
+
+void Cmd_CollisionJoints()
+{
+	DoCollisionModel( true );
+}
+
+void Cmd_ExternalTextures()
+{
+	MdlWarning( "ignoring $externaltextures, obsolete..." );
+}
+
+void Cmd_ClipToTextures()
+{
+	clip_texcoords = 1;
+}
+
+void Cmd_CollapseBones()
+{
+	g_collapse_bones = true;
+}
+
+void Cmd_CollapseBonesAggressive()
+{
+	g_collapse_bones = true;
+	g_collapse_bones_aggressive = true;
+}
+
+void Cmd_AlwaysCollapse()
+{
+	g_collapse_bones = true;
+	GetToken(false);
+	g_collapse.AddToTail( strdup( token ) );
+}
+
+void Cmd_CalcTransitions()
+{
+	g_bMultistageGraph = true;
+}
+
+void Cmd_StaticProp()
+{
+	g_staticprop = true;
+	gflags |= STUDIOHDR_FLAGS_STATIC_PROP;
+}
+
+void Cmd_ZBrush()
+{
+	g_bZBrush = true;
+}
+
+void Cmd_RealignBones()
+{
+	g_realignbones = true;
+}
+
+void Cmd_BaseLOD()
+{
+	Cmd_LOD( "$lod" );
+}
+
+void Cmd_KeyValues()
+{
+	Option_KeyValues( &g_KeyValueText );
+}
+
+void Cmd_ConstDirectionalLight()
+{
+	gflags |= STUDIOHDR_FLAGS_CONSTANT_DIRECTIONAL_LIGHT_DOT;
+
+	GetToken (false);
+	g_constdirectionalightdot = (byte)( verify_atof(token) * 255.0f );
+}
+
+void Cmd_MinLOD()
+{
+	GetToken( false );
+	g_minLod = atoi( token );
+
+	// "minlod" rules over "allowrootlods"
+	if ( g_numAllowedRootLODs > 0 && g_numAllowedRootLODs < g_minLod )
+	{
+		MdlWarning( "$minlod %d overrides $allowrootlods %d, proceeding with $allowrootlods %d.\n", g_minLod, g_numAllowedRootLODs, g_minLod );
+		g_numAllowedRootLODs = g_minLod;
+	}
+}
+
+void Cmd_AllowRootLODs()
+{
+	GetToken( false );
+	g_numAllowedRootLODs = atoi( token );
+
+	// Root LOD restriction has to obey "minlod" request
+	if ( g_numAllowedRootLODs > 0 && g_numAllowedRootLODs < g_minLod )
+	{
+		MdlWarning( "$allowrootlods %d is conflicting with $minlod %d, proceeding with $allowrootlods %d.\n", g_numAllowedRootLODs, g_minLod, g_minLod );
+		g_numAllowedRootLODs = g_minLod;
+	}
+}
+
+
+void Cmd_BoneSaveFrame( )
+{
+	s_bonesaveframe_t tmp;
+
+	// bone name
+	GetToken( false );
+	V_strcpy_safe( tmp.name, token );
+
+	tmp.bSavePos = false;
+	tmp.bSaveRot = false;
+	while (TokenAvailable(  ))
+	{
+		GetToken( false );
+		if (stricmp( "position", token ) == 0)
+		{
+			tmp.bSavePos = true;
+		}
+		else if (stricmp( "rotation", token ) == 0)
+		{
+			tmp.bSaveRot = true;
+		}
+		else
+		{
+			MdlError( "unknown option \"%s\" on $bonesaveframe : %s\n", token, tmp.name );
+		}
+	}
+
+	g_bonesaveframe.AddToTail( tmp );
+}
+
+
+//
+// This is the master list of the commands a QC file supports.
+// To add a new command to the QC files, add it here.
+//
+struct
+{
+	char *m_pName;
+	void (*m_pCmd)();
+} g_Commands[] =
+{
+	{ "$cd", Cmd_CD },
+	{ "$modelname", Cmd_Modelname },
+	{ "$cdmaterials", Cmd_CDMaterials },
+	{ "$pushd", Cmd_Pushd },
+	{ "$popd", Cmd_Popd },
+	{ "$scale", Cmd_ScaleUp },
+	{ "$root", Cmd_Root },
+	{ "$controller", Cmd_Controller },
+	{ "$screenalign", Cmd_ScreenAlign },
+	{ "$model", Cmd_Model },
+	{ "$collisionmodel", Cmd_CollisionModel },
+	{ "$collisionjoints", Cmd_CollisionJoints },
+	{ "$collisiontext", Cmd_CollisionText },
+	{ "$body", Cmd_Body },
+	{ "$bodygroup", Cmd_Bodygroup },
+	{ "$animation", Cmd_Animation },
+	{ "$autocenter", Cmd_Autocenter },
+	{ "$sequence", Cmd_Sequence },
+	{ "$append", Cmd_Append },
+	{ "$prepend", Cmd_Prepend  },
+	{ "$continue", Cmd_Continue  },
+	{ "$declaresequence", Cmd_DeclareSequence  },
+	{ "$declareanimation", Cmd_DeclareAnimation },
+	{ "$cmdlist", Cmd_Cmdlist },
+	{ "$animblocksize", Cmd_AnimBlockSize },
+	{ "$weightlist", Cmd_Weightlist },
+	{ "$defaultweightlist", Cmd_DefaultWeightlist },
+	{ "$ikchain", Cmd_IKChain },
+	{ "$ikautoplaylock", Cmd_IKAutoplayLock },
+	{ "$eyeposition", Cmd_Eyeposition },
+	{ "$illumposition", Cmd_Illumposition },
+	{ "$origin", Cmd_Origin },
+	{ "$upaxis", Cmd_UpAxis },
+	{ "$bbox", Cmd_BBox },
+	{ "$cbox", Cmd_CBox },
+	{ "$gamma", Cmd_Gamma },
+	{ "$texturegroup", Cmd_TextureGroup },
+	{ "$hgroup", Cmd_Hitgroup },
+	{ "$hbox", Cmd_Hitbox },
+	{ "$hboxset", Cmd_HitboxSet },
+	{ "$surfaceprop", Cmd_SurfaceProp },
+	{ "$jointsurfaceprop", Cmd_JointSurfaceProp },
+	{ "$contents", Cmd_Contents },
+	{ "$jointcontents", Cmd_JointContents },
+	{ "$attachment", Cmd_Attachment },
+	{ "$bonemerge", Cmd_BoneMerge },
+	{ "$externaltextures", Cmd_ExternalTextures },
+	{ "$cliptotextures", Cmd_ClipToTextures },
+	{ "$renamebone", Cmd_Renamebone },
+	{ "$collapsebones", Cmd_CollapseBones },
+	{ "$collapsebonesaggressive", Cmd_CollapseBonesAggressive },
+	{ "$alwayscollapse", Cmd_AlwaysCollapse },
+	{ "$proceduralbones", Load_ProceduralBones },
+	{ "$skiptransition", Cmd_Skiptransition },
+	{ "$calctransitions", Cmd_CalcTransitions },
+	{ "$staticprop", Cmd_StaticProp },
+	{ "$zbrush", Cmd_ZBrush },
+	{ "$realignbones", Cmd_RealignBones },
+	{ "$forcerealign", Cmd_ForceRealign },
+	{ "$lod", Cmd_BaseLOD },
+	{ "$shadowlod", Cmd_ShadowLOD },
+	{ "$poseparameter", Cmd_PoseParameter },
+	{ "$heirarchy", Cmd_ForcedHierarchy },
+	{ "$hierarchy", Cmd_ForcedHierarchy },
+	{ "$insertbone", Cmd_InsertHierarchy },
+	{ "$limitrotation", Cmd_LimitRotation },
+	{ "$definebone", Cmd_DefineBone },
+	{ "$jigglebone", Cmd_JiggleBone },
+	{ "$includemodel", Cmd_IncludeModel },
+	{ "$opaque", Cmd_Opaque },
+	{ "$mostlyopaque", Cmd_TranslucentTwoPass },
+//	{ "$platform", Cmd_Platform },
+	{ "$keyvalues", Cmd_KeyValues },
+	{ "$obsolete", Cmd_Obsolete },
+	{ "$renamematerial", Cmd_RenameMaterial },
+	{ "$fakevta", Cmd_FakeVTA },
+	{ "$noforcedfade", Cmd_NoForcedFade },
+	{ "$skipboneinbbox", Cmd_SkipBoneInBBox },
+	{ "$forcephonemecrossfade", Cmd_ForcePhonemeCrossfade },
+	{ "$lockbonelengths", Cmd_LockBoneLengths },
+	{ "$unlockdefinebones", Cmd_UnlockDefineBones },
+	{ "$constantdirectionallight", Cmd_ConstDirectionalLight },
+	{ "$minlod", Cmd_MinLOD },
+	{ "$allowrootlods", Cmd_AllowRootLODs },
+	{ "$bonesaveframe", Cmd_BoneSaveFrame },
+	{ "$ambientboost", Cmd_AmbientBoost },
+	{ "$centerbonesonverts", Cmd_CenterBonesOnVerts },
+	{ "$donotcastshadows", Cmd_DoNotCastShadows },
+	{ "$casttextureshadows", Cmd_CastTextureShadows },
+	{ "$motionrollback", Cmd_MotionExtractionRollBack },
+	{ "$sectionframes", Cmd_SectionFrames },
+	{ "$clampworldspace", Cmd_ClampWorldspace },
+	{ "$maxeyedeflection", Cmd_MaxEyeDeflection },
+	{ "$boneflexdriver", Cmd_BoneFlexDriver },
+	{ "$checkuv", Cmd_CheckUV }
+};
+
+
+/*
+===============
+ParseScript
+===============
+*/
+void ParseScript (void)
+{
+	while (1)
+	{
+		GetToken (true);
+		if (endofscript)
+			return;
+
+		// Check all the commands we know about.
+		int i;
+		for ( i=0; i < ARRAYSIZE( g_Commands ); i++ )
+		{
+			if ( !stricmp( g_Commands[i].m_pName, token ) )
+			{
+				g_Commands[i].m_pCmd();
+				break;
+			}
+		}
+		if ( i == ARRAYSIZE( g_Commands ) )
+		{
+			if( !g_bCreateMakefile )
+			{
+				TokenError("bad command %s\n", token);
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Generate the model name
+//-----------------------------------------------------------------------------
+bool GenerateModelName( CDmeMDLMakefile *pMDLMakeFile )
+{
+	// The model name is implicit in the makefile name
+	// NOTE: Model name is relative to the 'models' directory
+	char pOutputFullPath[MAX_PATH];
+	pMDLMakeFile->GetOutputName( pOutputFullPath, sizeof(pOutputFullPath) );
+	Q_SetExtension( pOutputFullPath, ".mdl", sizeof( pOutputFullPath) );
+
+	char pModelSubDir[MAX_PATH];
+	GetModSubdirectory( "models", pModelSubDir, sizeof(pModelSubDir) );
+
+	char pRelativePath[MAX_PATH];
+	if ( !Q_MakeRelativePath( pOutputFullPath, pModelSubDir, pRelativePath, sizeof(pRelativePath) ) )
+	{
+		MdlError( "Makefile \"%s\" doesn't lie under the correct vproject \"%s\"!\n",
+			pOutputFullPath, pModelSubDir );
+		return false;
+	}
+
+	ProcessModelName( pRelativePath );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process skins
+//-----------------------------------------------------------------------------
+bool GenerateSkin( CDmeMDLMakefile *pMDLMakeFile )
+{
+	CUtlVector< CDmeHandle< CDmeSourceSkin > > bodies;
+	pMDLMakeFile->GetSources< CDmeSourceSkin >( bodies );
+	int nCount = bodies.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !bodies[i] )
+			continue;
+
+		char pFullPath[MAX_PATH];
+		pMDLMakeFile->GetSourceFullPath( bodies[i], pFullPath, sizeof(pFullPath) );
+
+		// Empty strings are ignored
+		if ( !pFullPath[0] )
+			continue;
+
+		ProcessCmdBody( pFullPath, bodies[i] );
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Process animations
+//-----------------------------------------------------------------------------
+bool GenerateAnimations( CDmeMDLMakefile *pMDLMakeFile )
+{
+	CUtlVector< CDmeHandle< CDmeSourceAnimation > > animationFiles;
+	pMDLMakeFile->GetSources< CDmeSourceAnimation >( animationFiles );
+
+	int nCount = animationFiles.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !animationFiles[i] )
+			continue;
+
+		char pFullPath[MAX_PATH];
+		pMDLMakeFile->GetSourceFullPath( animationFiles[i], pFullPath, sizeof(pFullPath) );
+
+		// Empty strings are ignored
+		if ( !pFullPath[0] )
+			continue;
+
+		// Totally spoof the animation info.. not sure where to get it from yet
+		// assume it's an animation reference
+		// first look up an existing animation
+		s_sequence_t *pseq = ProcessCmdSequence( animationFiles[i]->m_AnimationName );
+		if ( !pseq )
+			continue;
+
+		int n;
+		s_animation_t *animations[64];
+		int numblends = 0;
+		for ( n = 0; n < g_numani; n++ )
+		{
+			if ( !Q_stricmp( pFullPath, g_panimation[n]->name ) )
+			{
+				animations[numblends++] = g_panimation[n];
+				break;
+			}
+		}
+
+		if ( n >= g_numani )
+		{
+			// assume it's an implied animation
+			animations[numblends++] = Cmd_ImpliedAnimation( pseq, pFullPath );
+		}
+		// hack to allow animation commands to refer to same sequence
+		if ( numblends == 1 )
+		{
+			pseq->panim[0][0] = animations[0];
+		}
+
+		// Look up the source animation from the animation name
+		for ( int j = 0; j < numblends; ++j )
+		{
+			s_sourceanim_t *pSourceAnim = FindSourceAnim( animations[j]->source, animationFiles[i]->m_SourceAnimationName );
+
+			// NOTE: This always affects the first source anim read in
+			if ( pSourceAnim )
+			{
+				animations[j]->startframe = pSourceAnim->startframe;
+				animations[j]->endframe = pSourceAnim->endframe;
+
+				if ( !g_bCreateMakefile && animations[j]->endframe < animations[j]->startframe )
+				{
+					TokenError( "end frame before start frame in %s", animations[j]->name );
+				}
+
+				animations[j]->numframes = animations[j]->endframe - animations[j]->startframe + 1;
+				Q_strncpy( animations[j]->animationname, animationFiles[i]->m_SourceAnimationName, sizeof(animations[j]->animationname) );
+			}
+			else
+			{
+				MdlError( "Requested unknown animation block name %s\n", animationFiles[i]->m_SourceAnimationName.Get() );
+			}
+		}
+
+		ProcessSequence( pseq, numblends, animations, false );
+	}
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Parse the MDL makefile
+//-----------------------------------------------------------------------------
+void ParseMDLMakeFile( CDmeMDLMakefile *pMDLMakeFile )
+{
+	if ( !GenerateModelName( pMDLMakeFile ) )
+		return;
+
+	// All DMX files have Y as the up axis
+	RadianEuler angles( M_PI / 2.0f, 0.0f, M_PI / 2.0f );
+	ProcessUpAxis( angles );
+
+	// Process bodies
+	if ( !GenerateSkin( pMDLMakeFile ) )
+		return;
+
+	// Process animations
+	if ( !GenerateAnimations( pMDLMakeFile ) )
+		return;
+}
+
+
+// Used by the CheckSurfaceProps.py script.
+// They specify the .mdl file and it prints out all the surface props that the model uses.
+bool HandlePrintSurfaceProps( int &returnValue )
+{
+	const char *pFilename = CommandLine()->ParmValue( "-PrintSurfaceProps", (const char*)NULL );
+	if ( pFilename )
+	{
+		CUtlVector<char> buf;
+
+		FILE *fp = fopen( pFilename, "rb" );
+		if ( fp )
+		{
+			fseek( fp, 0, SEEK_END );
+			buf.SetSize( ftell( fp ) );
+			fseek( fp, 0, SEEK_SET );
+			fread( buf.Base(), 1, buf.Count(), fp );
+
+			fclose( fp );
+
+			studiohdr_t *pHdr = (studiohdr_t*)buf.Base();
+
+			Studio_ConvertStudioHdrToNewVersion( pHdr );
+
+			if ( pHdr->version == STUDIO_VERSION )
+			{
+				for ( int i=0; i < pHdr->numbones; i++ )
+				{
+					mstudiobone_t *pBone = pHdr->pBone( i );
+					printf( "%s\n", pBone->pszSurfaceProp() );
+				}
+
+				returnValue = 0;
+			}
+			else
+			{
+				printf( "-PrintSurfaceProps: '%s' is wrong version (%d should be %d).\n", 
+					pFilename, pHdr->version, STUDIO_VERSION );
+				returnValue = 1;
+			}
+		}
+		else
+		{
+			printf( "-PrintSurfaceProps: can't open '%s'\n", pFilename );
+			returnValue = 1;
+		}
+
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+// Used by the modelstats.pl script.
+// They specify the .mdl file and it prints out perf info.
+bool HandleMdlReport( int &returnValue )
+{
+	const char *pFilename = CommandLine()->ParmValue( "-mdlreport", (const char*)NULL );
+	if ( pFilename )
+	{
+		CUtlVector<char> buf;
+
+		FILE *fp = fopen( pFilename, "rb" );
+		if ( fp )
+		{
+			fseek( fp, 0, SEEK_END );
+			buf.SetSize( ftell( fp ) );
+			fseek( fp, 0, SEEK_SET );
+			fread( buf.Base(), 1, buf.Count(), fp );
+
+			fclose( fp );
+
+			studiohdr_t *pHdr = (studiohdr_t*)buf.Base();
+
+			Studio_ConvertStudioHdrToNewVersion( pHdr );
+
+			if ( pHdr->version == STUDIO_VERSION )
+			{
+				int flags = SPEWPERFSTATS_SHOWPERF;
+				if( CommandLine()->CheckParm( "-mdlreportspreadsheet", NULL ) )
+				{
+					flags |= SPEWPERFSTATS_SPREADSHEET;
+				}
+				SpewPerfStats( pHdr, pFilename, flags );
+
+				returnValue = 0;
+			}
+			else
+			{
+				printf( "-mdlreport: '%s' is wrong version (%d should be %d).\n", 
+					pFilename, pHdr->version, STUDIO_VERSION );
+				returnValue = 1;
+			}
+		}
+		else
+		{
+			printf( "-mdlreport: can't open '%s'\n", pFilename );
+			returnValue = 1;
+		}
+
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}
+
+void UsageAndExit()
+{
+	MdlError( "Bad or missing options\n"
+		"usage: studiomdl [options] <file.qc>\n"
+		"options:\n"
+		"[-a <normal_blend_angle>]\n"
+		"[-checklengths]\n"
+		"[-d] - dump glview files\n"
+		"[-definebones]\n"
+		"[-f] - flip all triangles\n"
+		"[-fullcollide] - don't truncate really big collisionmodels\n"
+		"[-game <gamedir>]\n"
+		"[-h] - dump hboxes\n"
+		"[-i] - ignore warnings\n"
+		"[-minlod <lod>] - truncate to highest detail <lod>\n"
+		"[-n] - tag bad normals\n"
+		"[-perf] report perf info upon compiling model\n"
+		"[-printbones]\n"
+		"[-printgraph]\n"
+		"[-quiet] - operate silently\n"
+		"[-r] - tag reversed\n"
+		"[-t <texture>]\n"
+		"[-x360] - generate xbox360 output\n"
+		"[-nox360] - disable xbox360 output(default)\n"
+		"[-nowarnings] - disable warnings\n"
+		"[-dumpmaterials] - dump out material names\n"
+		"[-mdlreport] model.mdl - report perf info\n"
+		"[-mdlreportspreadsheet] - report perf info as a comma-delimited spreadsheet\n"
+		"[-striplods] - use only lod0\n"
+		"[-overridedefinebones] - equivalent to specifying $unlockdefinebones in .qc file\n"
+		"[-stripmodel] - process binary model files and strip extra lod data\n"
+		"[-stripvhv] - strip hardware verts to match the stripped model\n"
+		"[-vsi] - generate stripping information .vsi file - can be used on .mdl files too\n"
+		);
+}
+
+#ifndef _DEBUG
+
+LONG __stdcall VExceptionFilter( struct _EXCEPTION_POINTERS *ExceptionInfo )
+{
+	MdlExceptionFilter( ExceptionInfo->ExceptionRecord->ExceptionCode );
+	return EXCEPTION_EXECUTE_HANDLER; // (never gets here anyway)
+}
+
+#endif
+/*
+==============
+main
+==============
+*/
+
+
+//-----------------------------------------------------------------------------
+// The application object
+//-----------------------------------------------------------------------------
+class CStudioMDLApp : public CDefaultAppSystemGroup< CSteamAppSystemGroup >
+{
+	typedef CDefaultAppSystemGroup< CSteamAppSystemGroup > BaseClass;
+
+public:
+	// Methods of IApplication
+	virtual bool Create();
+	virtual bool PreInit( );
+	virtual int Main();
+	virtual void PostShutdown();
+
+private:
+	int Main_StripModel();
+	int Main_StripVhv();
+	int Main_MakeVsi();
+
+private:
+	bool ParseArguments();
+};
+
+static bool CStudioMDLApp_SuggestGameInfoDirFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories )
+{
+	const char *pProcessFileName = NULL;
+	int nParmCount = CommandLine()->ParmCount();
+	if ( nParmCount > 1 )
+	{
+		pProcessFileName = CommandLine()->GetParm( nParmCount - 1 );
+	}
+
+	if ( pProcessFileName )
+	{
+		Q_MakeAbsolutePath( pchPathBuffer, nBufferLength, pProcessFileName );
+
+		if ( pbBubbleDirectories )
+			*pbBubbleDirectories = true;
+
+		return true;
+	}
+
+	return false;
+}
+
+int main( int argc, char **argv )
+{
+	SetSuggestGameInfoDirFn( CStudioMDLApp_SuggestGameInfoDirFn );
+
+	CStudioMDLApp s_ApplicationObject;
+	CSteamApplication s_SteamApplicationObject( &s_ApplicationObject );
+	return AppMain( argc, argv, &s_SteamApplicationObject );
+}
+
+
+//-----------------------------------------------------------------------------
+// The application object
+//-----------------------------------------------------------------------------
+bool CStudioMDLApp::Create()
+{
+	InstallSpewFunction();
+	// override the default spew function
+	SpewOutputFunc( MdlSpewOutputFunc );
+
+ 	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
+
+#ifndef _DEBUG
+	SetUnhandledExceptionFilter( VExceptionFilter );
+#endif
+
+	if ( CommandLine()->ParmCount() == 1 )
+	{
+		UsageAndExit();
+		return false;
+	}
+
+	int nReturnValue;
+	if ( HandlePrintSurfaceProps( nReturnValue ) )
+		return false;
+
+	if ( !ParseArguments() )
+		return false;
+
+	AppSystemInfo_t appSystems[] = 
+	{
+		{ "vstdlib.dll",			PROCESS_UTILS_INTERFACE_VERSION },
+		{ "materialsystem.dll",		MATERIAL_SYSTEM_INTERFACE_VERSION },
+		{ "studiorender.dll",		STUDIO_RENDER_INTERFACE_VERSION },
+		{ "mdllib.dll",				MDLLIB_INTERFACE_VERSION },
+		{ "", "" }	// Required to terminate the list
+	};
+	
+	AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION );
+	AddSystem( g_pDmElementFramework, VDMELEMENTFRAMEWORK_VERSION );
+	AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION );
+
+	// Add in the locally-defined studio data cache
+	AppModule_t	studioDataCacheModule = LoadModule( Sys_GetFactoryThis() );
+	AddSystem( studioDataCacheModule, STUDIO_DATA_CACHE_INTERFACE_VERSION );
+
+	// Add the P4 module separately so that if it is absent (say in the SDK) then the other system will initialize properly
+	if ( !CommandLine()->FindParm( "-nop4" ) )
+	{
+		AppModule_t p4Module = LoadModule( "p4lib.dll" );
+		AddSystem( p4Module, P4_INTERFACE_VERSION );
+	}
+
+	bool bOk = AddSystems( appSystems );
+	if ( !bOk )
+		return false;
+
+	IMaterialSystem *pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
+	if ( !pMaterialSystem )
+		return false;
+
+	pMaterialSystem->SetShaderAPI( "shaderapiempty.dll" );
+
+	return true;
+}
+
+bool CStudioMDLApp::PreInit( )
+{
+	CreateInterfaceFn factory = GetFactory();
+	ConnectTier1Libraries( &factory, 1 );
+	ConnectTier2Libraries( &factory, 1 );
+	ConnectTier3Libraries( &factory, 1 );
+
+	if ( !g_pFullFileSystem || !g_pDataModel || !g_pMaterialSystem || !g_pStudioRender )
+	{
+		Warning( "StudioMDL is missing a required interface!\n" );
+		return false;
+	}
+
+	if ( !SetupSearchPaths( g_path, false, true ) )
+		return false;
+
+	// NOTE: This is necessary to get the cmdlib filesystem stuff to work.
+	g_pFileSystem = g_pFullFileSystem;
+
+	// NOTE: This is stuff copied out of cmdlib necessary to get 
+	// the tools in cmdlib working
+	FileSystem_SetupStandardDirectories( g_path, GetGameInfoPath() );
+	return true;
+}
+
+
+void CStudioMDLApp::PostShutdown()
+{
+	DisconnectTier3Libraries();
+	DisconnectTier2Libraries();
+	DisconnectTier1Libraries();
+}
+
+
+//-----------------------------------------------------------------------------
+// Method which parses arguments
+//-----------------------------------------------------------------------------
+bool CStudioMDLApp::ParseArguments()
+{
+	g_currentscale = g_defaultscale = 1.0;
+	g_defaultrotation = RadianEuler( 0, 0, M_PI / 2 );
+
+	// skip weightlist 0
+	g_numweightlist = 1;
+
+	eyeposition = Vector( 0, 0, 0 );
+	gflags = 0;
+	numrep = 0;
+	tag_reversed = 0;
+	tag_normals = 0;
+
+	normal_blend = cos( DEG2RAD( 2.0 ));
+
+	g_gamma = 2.2;
+
+	g_staticprop = false;
+	g_centerstaticprop = false;
+
+	g_realignbones = false;
+	g_constdirectionalightdot = 0;
+
+	g_bDumpGLViewFiles = false;
+	g_quiet = false;
+
+	g_illumpositionattachment = 0;
+	g_flMaxEyeDeflection = 0.0f;
+
+	int argc = CommandLine()->ParmCount();
+	int i;
+	for ( i = 1; i < argc - 1; i++ ) 
+	{
+		const char *pArgv = CommandLine()->GetParm( i );
+		if ( pArgv[0] != '-' ) 
+			continue;
+
+		if ( !Q_stricmp( pArgv, "-allowdebug" ) )
+		{
+			// Ignore, used by interface system to catch debug builds checked into release tree
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-mdlreport" ) )
+		{
+			// Will reparse later, ignore rest of arguments.
+			return true;
+		}
+
+		if ( !Q_stricmp( pArgv, "-mdlreportspreadsheet" ) )
+		{
+			// Will reparse later, ignore for now.
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-ihvtest" ) )
+		{
+			++i;
+			g_IHVTest = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-overridedefinebones" ) )
+		{
+			g_bOverridePreDefinedBones = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-striplods" ) )
+		{
+			g_bStripLods = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-stripmodel" ) )
+		{
+			g_eRunMode = RUN_MODE_STRIP_MODEL;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-stripvhv" ) )
+		{
+			g_eRunMode = RUN_MODE_STRIP_VHV;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-vsi" ) )
+		{
+			g_bMakeVsi = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-quiet" ) )
+		{
+			g_quiet = true;
+			g_verbose = false;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-verbose" ) )
+		{
+			g_quiet = false;
+			g_verbose = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-fullcollide" ) )
+		{
+			g_badCollide = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-checklengths" ) )
+		{
+			g_bCheckLengths = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-printbones" ) )
+		{
+			g_bPrintBones = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-perf" ) )
+		{
+			g_bPerf = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-printgraph" ) )
+		{
+			g_bDumpGraph = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-definebones" ) )
+		{
+			g_definebones = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-makefile" ) )
+		{
+			g_bCreateMakefile = true;
+			g_quiet = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-verify" ) )
+		{
+			g_bVerifyOnly = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-minlod" ) )
+		{
+			g_minLod = atoi( CommandLine()->GetParm( ++i ) );
+			continue;
+		}
+
+		if (!Q_stricmp( pArgv, "-x360"))
+		{
+			StudioByteSwap::ActivateByteSwapping( true ); // Set target to big endian
+			g_bX360  = true;
+			continue;
+		}
+
+		if (!Q_stricmp( pArgv, "-nox360"))
+		{
+			g_bX360  = false;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-nowarnings" ) )
+		{
+			g_bNoWarnings = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-maxwarnings" ) )
+		{
+			g_maxWarnings = atoi( CommandLine()->GetParm( ++i ) );
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-preview" ) )
+		{
+			g_bBuildPreview = true;
+			continue;
+		}
+
+		if ( !Q_stricmp( pArgv, "-dumpmaterials" ) )
+		{
+			g_bDumpMaterials = true;
+			continue;
+		}
+
+		if ( pArgv[1] && pArgv[2] == '\0' )
+		{
+			switch( pArgv[1] )
+			{
+			case 't':
+				i++;
+				V_strcpy_safe( defaulttexture[numrep], pArgv );
+				if (i < argc - 2 && CommandLine()->GetParm(i + 1)[0] != '-') 
+				{
+					i++;
+					V_strcpy_safe( sourcetexture[numrep], pArgv );
+					printf("Replacing %s with %s\n", sourcetexture[numrep], defaulttexture[numrep] );
+				}
+				printf( "Using default texture: %s\n", defaulttexture[numrep] );
+				numrep++;
+				break;
+			case 'r':
+				tag_reversed = 1;
+				break;
+			case 'n':
+				tag_normals = 1;
+				break;
+			case 'a':
+				i++;
+				normal_blend = cos( DEG2RAD( verify_atof( pArgv ) ) );
+				break;
+			case 'h':
+				dump_hboxes = 1;
+				break;
+			case 'i':
+				ignore_warnings = 1;
+				break;
+			case 'd':
+				g_bDumpGLViewFiles = true;
+				break;
+//			case 'p':
+//				i++;
+//				V_strcpy_safe( qproject, pArgv );
+//				break;
+			}
+		}
+	}	
+
+	if ( i >= argc )
+	{
+		// misformed arguments
+		// otherwise generating unintended results
+		UsageAndExit();
+		return false;
+	}
+	
+	const char *pArgv = CommandLine()->GetParm( i );
+	Q_strncpy( g_path, pArgv, sizeof(g_path) );
+	if ( Q_IsAbsolutePath( g_path ) )
+	{
+		// Set the working directory to be the path of the qc file
+		// so the relative-file fopen code works
+		char pQCDir[MAX_PATH];
+		Q_ExtractFilePath( g_path, pQCDir, sizeof(pQCDir) );
+		_chdir( pQCDir );
+	}
+	Q_StripExtension( pArgv, outname, sizeof( outname ) );
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: search through the "GamePath" key and create a mirrored version in the content path searches
+//-----------------------------------------------------------------------------
+
+void AddContentPaths( )
+{
+	// look for the "content" in the path to the initial QC file
+	char *match = "content\\";
+	char *sp = strstr( qdir, match );
+	if (!sp)
+		return;
+
+	// copy off everything before and including "content"
+	char pre[1024];
+	strncpy( pre, qdir, sp - qdir + strlen( match ) );
+	pre[sp - qdir + strlen( match )] = '\0';
+	sp = sp + strlen( match );
+
+	// copy off everything folling the word after "content"
+	char post[1024];
+	sp = strstr( sp+1, "\\" );
+	V_strcpy_safe( post, sp );
+
+	// get a copy of the game search paths
+	char paths[1024];
+	g_pFullFileSystem->GetSearchPath( "GAME", false, paths, sizeof( paths ) );
+	if (!g_quiet)
+		printf("all paths:%s\n", paths );
+
+	// pull out the game names and insert them into a content path string
+	sp = strstr( paths, "game\\" );
+	while (sp)
+	{
+		char temp[1024];
+		sp = sp + 5;
+		char *sz = strstr( sp, "\\" );
+		if (!sz)
+			return;
+
+		V_strcpy_safe( temp, pre );
+		strncat( temp, sp, sz - sp );
+		V_strcat_safe( temp, post );
+		sp = sz;
+		sp = strstr( sp, "game\\" );
+		CmdLib_AddBasePath( temp );
+		if (!g_quiet)
+			printf("content:%s\n", temp );
+	}
+}
+
+
+	
+//-----------------------------------------------------------------------------
+// The application object
+//-----------------------------------------------------------------------------
+int CStudioMDLApp::Main()
+{
+	const bool bP4DLLExists = g_pFullFileSystem->FileExists( "p4lib.dll", "EXECUTABLE_PATH" );
+
+	// No p4 mode if specified on the command line or no p4lib.dll found
+	if ( ( CommandLine()->FindParm( "-nop4" ) ) || ( !bP4DLLExists ) )
+	{
+		g_bNoP4 = true;
+		g_p4factory->SetDummyMode( true );
+	}
+
+	// Set the named changelist
+	g_p4factory->SetOpenFileChangeList( "StudioMDL Auto Checkout" );
+
+	// This bit of hackery allows us to access files on the harddrive
+	g_pFullFileSystem->AddSearchPath( "", "LOCAL", PATH_ADD_TO_HEAD ); 
+
+	MaterialSystem_Config_t config;
+	g_pMaterialSystem->OverrideConfig( config, false );
+
+	int nReturnValue;
+	if ( HandleMdlReport( nReturnValue ) )
+		return false;
+
+	// Don't bother with undo here
+	g_pDataModel->SetUndoEnabled( false );
+
+	// look for the "content\hl2x" string in the qdir and add what should be the correct path as an alternate
+	// FIXME: add these to an envvar if folks are using complicated directory mappings instead of defaults
+	char *match = "content\\hl2x\\";
+	char *sp = strstr( qdir, match );
+	if (sp)
+	{
+		char temp[1024];
+		strncpy( temp, qdir, sp - qdir + strlen( match ) );
+		temp[sp - qdir + strlen( match )] = '\0';
+		CmdLib_AddBasePath( temp );
+		V_strcat_safe( temp, "..\\..\\..\\..\\main\\content\\hl2\\" );
+		CmdLib_AddBasePath( temp );
+	}
+
+	AddContentPaths();
+
+	if (!g_quiet)
+	{
+		printf("qdir:    \"%s\"\n", qdir );
+		printf("gamedir: \"%s\"\n", gamedir );
+		printf("g_path:  \"%s\"\n", g_path );
+	}
+
+	switch ( g_eRunMode )
+	{
+	case RUN_MODE_STRIP_MODEL:
+		return Main_StripModel();
+	
+	case RUN_MODE_STRIP_VHV:
+		return Main_StripVhv();
+	
+	case RUN_MODE_BUILD:
+	default:
+		break;
+	}
+
+	const char *pExt = Q_GetFileExtension( g_path );
+
+	// Look for the presence of a .mdl file (only -vsi is currently supported for .mdl files)
+	if ( pExt && !Q_stricmp( pExt, "mdl" ) )
+	{
+		if ( g_bMakeVsi )
+			return Main_MakeVsi();
+		
+		printf( "ERROR: .qc or .dmx file should be specified to build.\n" );
+		return 1;
+	}
+
+
+	if ( !g_quiet )
+		printf( "Building binary model files...\n" );
+
+	// Look for the presence of a .dmx file of the same name
+	// If so, load it first
+	CDmeMDLMakefile *pMDLMakeFile = NULL;
+	
+	if ( pExt && !Q_stricmp( pExt, "dmx" ) )
+	{
+		CDmElement *pRoot;
+		if ( g_pDataModel->RestoreFromFile( g_path, NULL, NULL, &pRoot ) != DMFILEID_INVALID )
+		{
+			pMDLMakeFile = CastElement<CDmeMDLMakefile>( pRoot );
+		}
+	};
+
+	Q_FileBase( g_path, g_path, sizeof( g_path ) );
+	Q_DefaultExtension( g_path, pMDLMakeFile ? ".dmx" : ".qc", sizeof( g_path ) );
+	if (!g_quiet)
+	{
+		printf( "Working on \"%s\"\n", g_path );
+	}
+
+	// Turn on checking for special single character tokens while parsing
+	SetCheckSingleCharTokens( true );
+	SetSingleCharTokenList( "{}()," );
+
+	// Set up script loading callback, discarding default callback
+	( void ) SetScriptLoadedCallback( StudioMdl_ScriptLoadedCallback );
+
+	// load the script
+	if ( !pMDLMakeFile )
+	{
+		LoadScriptFile(g_path);
+	}
+
+	V_strcpy_safe( fullpath, g_path );
+	V_strcpy_safe( fullpath, ExpandPath( fullpath ) );
+	V_strcpy_safe( fullpath, ExpandArg( fullpath ) );
+	
+	// default to having one entry in the LOD list that doesn't do anything so
+	// that we don't have to do any special cases for the first LOD.
+	g_ScriptLODs.Purge();
+	g_ScriptLODs.AddToTail(); // add an empty one
+	g_ScriptLODs[0].switchValue = 0.0f;
+	
+	//
+	// parse it
+	//
+	ClearModel();
+
+//	V_strcpy_safe( g_pPlatformName, "" );
+	if ( pMDLMakeFile )
+	{
+		ParseMDLMakeFile( pMDLMakeFile );
+	}
+	else
+	{
+		ParseScript();
+	}
+
+	if ( !g_bCreateMakefile )
+	{
+		SetSkinValues();
+
+		SimplifyModel();
+
+		ConsistencyCheckSurfaceProp();
+		ConsistencyCheckContents();
+
+		CollisionModel_Build();
+
+		// ValidateSharedAnimationGroups();
+
+		WriteModelFiles();
+	}
+
+	if ( pMDLMakeFile )
+	{
+		DestroyElement( pMDLMakeFile );
+		pMDLMakeFile = NULL;
+	}
+
+	if ( g_bCreateMakefile )
+	{
+		CreateMakefile_OutputMakefile();
+	}
+	else if ( g_bMakeVsi )
+	{
+		Q_snprintf( g_path, ARRAYSIZE( g_path ), "%smodels/%s", gamedir, outname );
+		Main_MakeVsi();
+	}
+
+	if (!g_quiet)
+	{
+		printf("\nCompleted \"%s\"\n", g_path);
+	}
+
+	g_pDataModel->UnloadFile( DMFILEID_INVALID );
+
+	return 0;
+}
+
+
+
+
+
+//
+// WriteFileToDisk
+//	Equivalent to g_pFullFileSystem->WriteFile( pFileName, pPath, buf ), but works
+//	for relative paths.
+//
+bool WriteFileToDisk( const char *pFileName, const char *pPath, CUtlBuffer &buf )
+{
+	// For some reason calling full filesystem will write into hl2 root dir
+	// return g_pFullFileSystem->WriteFile( pFileName, pPath, buf );
+
+	FILE *f = fopen( pFileName, "wb" );
+	if ( !f )
+		return false;
+
+	fwrite( buf.Base(), 1, buf.TellPut(), f );
+	fclose( f );
+	return true;
+}
+
+//
+// WriteBufferToFile
+//	Helper to concatenate file base and extension.
+//
+bool WriteBufferToFile( CUtlBuffer &buf, const char *szFilebase, const char *szExt )
+{
+	char szFilename[ 1024 ];
+	Q_snprintf( szFilename, ARRAYSIZE( szFilename ), "%s%s", szFilebase, szExt );
+	return WriteFileToDisk( szFilename, NULL, buf );
+}
+
+
+//
+// LoadBufferFromFile
+//	Loads the buffer from file, return true on success, false otherwise.
+//  If bError is true prints an error upon failure.
+//
+bool LoadBufferFromFile( CUtlBuffer &buffer, char const *szFilebase, char const *szExt, bool bError = true )
+{
+	char szFilename[1024];
+	Q_snprintf( szFilename, ARRAYSIZE( szFilename ), "%s%s", szFilebase, szExt );
+
+	if ( g_pFullFileSystem->ReadFile( szFilename, NULL, buffer ) )
+		return true;
+
+	if ( bError )
+		MdlError( "Failed to open '%s'!\n", szFilename );
+
+	return false;
+}
+
+
+bool Load3ModelBuffers( CUtlBuffer &bufMDL, CUtlBuffer &bufVVD, CUtlBuffer &bufVTX, char const *szFilebase )
+{
+	// Load up the mdl file
+	if ( !LoadBufferFromFile( bufMDL, szFilebase, ".mdl" ) )
+		return false;
+
+	// Load up the vvd file
+	if ( !LoadBufferFromFile( bufVVD, szFilebase, ".vvd" ) )
+		return false;
+
+	// Load up the dx90.vtx file
+	if ( !LoadBufferFromFile( bufVTX, szFilebase, ".dx90.vtx" ) )
+		return false;
+
+	return true;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+//
+// Studiomdl hooks to call the stripping routines:
+//	Main_StripVhv
+//	Main_StripModel
+//
+//////////////////////////////////////////////////////////////////////////
+
+int CStudioMDLApp::Main_StripVhv()
+{
+	if ( !g_quiet )
+	{
+		printf( "Stripping vhv data...\n" );
+	}
+
+	if ( !mdllib )
+	{
+		printf( "ERROR: mdllib is not available!\n" );
+		return 1;
+	}
+
+	Q_StripExtension( g_path, g_path, sizeof( g_path ) );
+	char *pExt = g_path + strlen( g_path );
+	*pExt = 0;
+
+	//
+	// ====== Load files
+	//
+
+	// Load up the vhv file
+	CUtlBuffer bufVHV;
+	if ( !LoadBufferFromFile( bufVHV, g_path, ".vhv" ) )
+		return 1;
+
+	// Load up the info.strip file
+	CUtlBuffer bufRemapping;
+	if ( !LoadBufferFromFile( bufRemapping, g_path, ".info.strip", false ) &&
+		 !LoadBufferFromFile( bufRemapping, g_path, ".vsi" ) )
+		return 1;
+
+	//
+	// ====== Process file contents
+	//
+
+	bool bResult = false;
+	{
+		SpewActivate( "mdllib", 3 );
+
+		IMdlStripInfo *pMdlStripInfo = NULL;
+		
+		if ( mdllib->CreateNewStripInfo( &pMdlStripInfo ) )
+		{
+			pMdlStripInfo->UnSerialize( bufRemapping );
+			bResult = pMdlStripInfo->StripHardwareVertsBuffer( bufVHV );
+		}
+
+		if ( pMdlStripInfo )
+			pMdlStripInfo->DeleteThis();
+	}
+
+	if ( !bResult )
+	{
+		printf( "ERROR: stripping failed!\n" );
+		return 1;
+	}
+
+	//
+	// ====== Save out processed data
+	//
+
+	// Save vhv
+	if ( !WriteBufferToFile( bufVHV, g_path, ".vhv.strip" ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+
+	return 0;
+}
+
+int CStudioMDLApp::Main_MakeVsi()
+{
+	if ( !mdllib )
+	{
+		printf( "ERROR: mdllib is not available!\n" );
+		return 1;
+	}
+
+	Q_StripExtension( g_path, g_path, sizeof( g_path ) );
+	char *pExt = g_path + strlen( g_path );
+	*pExt = 0;
+
+	// Load up the files
+	CUtlBuffer bufMDL;
+	CUtlBuffer bufVVD;
+	CUtlBuffer bufVTX;
+	if ( !Load3ModelBuffers( bufMDL, bufVVD, bufVTX, g_path ) )
+		return 1;
+
+	//
+	// ====== Process file contents
+	//
+
+	CUtlBuffer bufMappingTable;
+	bool bResult = false;
+	{
+		if ( !g_quiet )
+		{
+			printf( "---------------------\n" );
+			printf( "Generating .vsi stripping information...\n" );
+			
+			SpewActivate( "mdllib", 3 );
+		}
+
+		IMdlStripInfo *pMdlStripInfo = NULL;
+
+		bResult =
+			mdllib->StripModelBuffers( bufMDL, bufVVD, bufVTX, &pMdlStripInfo ) &&
+			pMdlStripInfo->Serialize( bufMappingTable );
+
+		if ( pMdlStripInfo )
+			pMdlStripInfo->DeleteThis();
+	}
+
+	if ( !bResult )
+	{
+		printf( "ERROR: stripping failed!\n" );
+		return 1;
+	}
+
+	//
+	// ====== Save out processed data
+	//
+
+	// Save remapping data using "P4 edit -> save -> P4 add"  approach
+	sprintf( pExt, ".vsi" );
+	CP4AutoEditAddFile _auto_edit_vsi( g_path );
+	
+	if ( !WriteFileToDisk( g_path, NULL, bufMappingTable ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+	else if ( !g_quiet )
+	{
+		printf( "Generated .vsi stripping information.\n" );
+	}
+
+	return 0;
+}
+
+int CStudioMDLApp::Main_StripModel()
+{
+	if ( !g_quiet )
+	{
+		printf( "Stripping binary model files...\n" );
+	}
+
+	if ( !mdllib )
+	{
+		printf( "ERROR: mdllib is not available!\n" );
+		return 1;
+	}
+
+	Q_FileBase( g_path, g_path, sizeof( g_path ) );
+	char *pExt = g_path + strlen( g_path );
+	*pExt = 0;
+
+	// Load up the files
+	CUtlBuffer bufMDL;
+	CUtlBuffer bufVVD;
+	CUtlBuffer bufVTX;
+	if ( !Load3ModelBuffers( bufMDL, bufVVD, bufVTX, g_path ) )
+		return 1;
+
+	//
+	// ====== Process file contents
+	//
+
+	CUtlBuffer bufMappingTable;
+	bool bResult = false;
+	{
+		SpewActivate( "mdllib", 3 );
+
+		IMdlStripInfo *pMdlStripInfo = NULL;
+		
+		bResult =
+			mdllib->StripModelBuffers( bufMDL, bufVVD, bufVTX, &pMdlStripInfo ) &&
+			pMdlStripInfo->Serialize( bufMappingTable );
+
+		if ( pMdlStripInfo )
+			pMdlStripInfo->DeleteThis();
+	}
+
+	if ( !bResult )
+	{
+		printf( "ERROR: stripping failed!\n" );
+		return 1;
+	}
+
+	//
+	// ====== Save out processed data
+	//
+
+	// Save mdl
+	sprintf( pExt, ".mdl.strip" );
+	if ( !WriteFileToDisk( g_path, NULL, bufMDL ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+
+	// Save vvd
+	sprintf( pExt, ".vvd.strip" );
+	if ( !WriteFileToDisk( g_path, NULL, bufVVD ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+
+	// Save vtx
+	sprintf( pExt, ".vtx.strip" );
+	if ( !WriteFileToDisk( g_path, NULL, bufVTX ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+
+	// Save remapping data
+	sprintf( pExt, ".info.strip" );
+	if ( !WriteFileToDisk( g_path, NULL, bufMappingTable ) )
+	{
+		printf( "ERROR: Failed to save '%s'!\n", g_path );
+		return 1;
+	}
+
+	return 0;
+}
diff --git a/utils/studiomdl/studiomdl.h b/utils/studiomdl/studiomdl.h
new file mode 100644
index 0000000..413860e
--- /dev/null
+++ b/utils/studiomdl/studiomdl.h
@@ -0,0 +1,1602 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+#ifndef STUDIOMDL_H
+#define STUDIOMDL_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include <stdio.h>
+#include "basetypes.h"
+#include "tier1/utlvector.h"
+#include "tier1/utlsymbol.h"
+#include "tier1/utlstring.h"
+#include "mathlib/vector.h"
+#include "studio.h"
+#include "datamodel/dmelementhandle.h"
+#include "checkuv.h"
+
+struct LodScriptData_t;
+struct s_flexkey_t;
+struct s_flexcontroller_t;
+struct s_flexcontrollerremap_t;
+struct s_combinationrule_t;
+struct s_combinationcontrol_t;
+class CDmeVertexDeltaData;
+class CDmeCombinationOperator;
+
+#define IDSTUDIOHEADER			(('T'<<24)+('S'<<16)+('D'<<8)+'I')
+														// little-endian "IDST"
+#define IDSTUDIOANIMGROUPHEADER	(('G'<<24)+('A'<<16)+('D'<<8)+'I')
+														// little-endian "IDAG"
+
+
+#define STUDIO_QUADRATIC_MOTION 0x00002000
+
+#define MAXSTUDIOANIMFRAMES		5000	// max frames per animation
+#define MAXSTUDIOANIMS			2000	// total animations
+#define MAXSTUDIOSEQUENCES		1524	// total sequences
+#define MAXSTUDIOSRCBONES		512		// bones allowed at source movement
+#define MAXSTUDIOMODELS			32		// sub-models per model
+#define MAXSTUDIOBODYPARTS		32
+#define MAXSTUDIOMESHES			256
+#define MAXSTUDIOEVENTS			1024
+#define MAXSTUDIOFLEXKEYS		512
+#define MAXSTUDIOFLEXRULES		1024
+#define MAXSTUDIOBONEWEIGHTS	3
+#define MAXSTUDIOCMDS			64
+#define MAXSTUDIOMOVEKEYS		64
+#define MAXSTUDIOIKRULES		64
+#define MAXSTUDIONAME			128
+
+#ifndef EXTERN
+#define EXTERN extern
+#endif
+
+EXTERN	char		outname[MAX_PATH];
+//EXTERN	char		g_pPlatformName[1024];
+EXTERN  qboolean	cdset;
+EXTERN  int			numdirs;
+EXTERN	char		cddir[32][MAX_PATH];
+EXTERN	int			numcdtextures;
+EXTERN	char *		cdtextures[16];
+EXTERN  char		fullpath[1024];
+
+EXTERN	char		rootname[MAXSTUDIONAME];		// name of the root bone
+EXTERN	float		g_defaultscale;
+EXTERN  float		g_currentscale;
+EXTERN  RadianEuler	g_defaultrotation;
+
+
+EXTERN	char		defaulttexture[16][MAX_PATH];
+EXTERN	char		sourcetexture[16][MAX_PATH];
+
+EXTERN	int			numrep;
+
+EXTERN	int			tag_reversed;
+EXTERN	int			tag_normals;
+EXTERN	float		normal_blend;
+EXTERN	int			dump_hboxes;
+EXTERN	int			ignore_warnings;
+
+EXTERN	Vector		eyeposition;
+EXTERN	float		g_flMaxEyeDeflection;
+EXTERN	int			g_illumpositionattachment;
+EXTERN	Vector		illumposition;
+EXTERN	int			illumpositionset;
+EXTERN	int			gflags;
+EXTERN	Vector		bbox[2];
+EXTERN	Vector		cbox[2];
+EXTERN	bool		g_wrotebbox;
+EXTERN	bool		g_wrotecbox;
+
+EXTERN	int			clip_texcoords;
+EXTERN	bool		g_staticprop;
+EXTERN	bool		g_centerstaticprop;
+
+EXTERN	bool		g_realignbones;
+EXTERN	bool		g_definebones;
+
+EXTERN  byte		g_constdirectionalightdot;
+
+// Methods associated with the key value text block
+extern CUtlVector< char >	g_KeyValueText;
+int		KeyValueTextSize( CUtlVector< char > *pKeyValue );
+const char *KeyValueText( CUtlVector< char > *pKeyValue );
+
+extern vec_t Q_rint (vec_t in);
+
+extern void WriteModelFiles(void);
+void *kalloc( int num, int size );
+
+// --------------------------------------------------------------------
+
+template< class T >
+class CUtlVectorAuto : public CUtlVector< T >
+{
+	// typedef CUtlVectorAuto< T, CUtlVector<T > > BaseClass;
+public:
+	T& operator[]( int i );
+};
+
+template< typename T >
+inline T& CUtlVectorAuto<T>::operator[]( int i )
+{
+	EnsureCount( i + 1 );
+	Assert( IsValidIndex(i) );
+	return Base()[i];
+}
+
+// --------------------------------------------------------------------
+
+struct s_trianglevert_t
+{
+	int					vertindex;
+	int					normindex;		// index into normal array
+	int					s,t;
+	float				u,v;
+};
+
+struct s_boneweight_t
+{
+	int		numbones;
+
+	int		bone[MAXSTUDIOBONEWEIGHTS];
+	float	weight[MAXSTUDIOBONEWEIGHTS];
+};
+
+
+struct s_tmpface_t
+{
+	int	material;
+	unsigned long		a, b, c;
+	unsigned long		ta, tb, tc;
+	unsigned long		na, nb, nc;
+};
+
+struct s_face_t
+{
+	unsigned long		a, b, c;
+};
+
+
+struct s_vertexinfo_t
+{
+	int				material;
+	int				mesh;
+	Vector			position;	
+	Vector			normal;
+	Vector4D		tangentS;
+	Vector2D		texcoord;
+	s_boneweight_t	boneweight;
+};
+
+
+//============================================================================
+
+// dstudiobone_t bone[MAXSTUDIOBONES];
+struct s_bonefixup_t
+{
+	matrix3x4_t m;	
+};
+
+EXTERN int g_numbones;
+struct s_bonetable_t
+{
+	char			name[MAXSTUDIONAME];	// bone name for symbolic links
+	int		 		parent;		// parent bone
+	bool			split;
+	int				bonecontroller;	// -1 == 0
+	Vector			pos;		// default pos
+	Vector			posscale;	// pos values scale
+	RadianEuler		rot;		// default pos
+	Vector			rotscale;	// rotation values scale
+	int				group;		// hitgroup
+	Vector			bmin, bmax;	// bounding box
+	bool			bPreDefined;
+	matrix3x4_t		rawLocalOriginal; // original transform of preDefined bone
+	matrix3x4_t		rawLocal;
+	matrix3x4_t		srcRealign;
+	bool			bPreAligned;
+	matrix3x4_t		boneToPose;
+	int				flags;
+	int				proceduralindex;
+	int				physicsBoneIndex;
+	int				surfacePropIndex;
+	Quaternion		qAlignment;
+	bool			bDontCollapse;
+	Vector			posrange;
+};
+EXTERN	s_bonetable_t g_bonetable[MAXSTUDIOSRCBONES];
+extern int findGlobalBone( const char *name );	// finds a named bone in the global bone table
+
+EXTERN int g_numrenamedbones;
+struct s_renamebone_t
+{
+	char			from[MAXSTUDIONAME];
+	char			to[MAXSTUDIONAME];
+};
+EXTERN s_renamebone_t g_renamedbone[MAXSTUDIOSRCBONES];
+const char *RenameBone( const char *pName ); // returns new name if available, else return pName.
+
+EXTERN int g_numimportbones;
+struct s_importbone_t
+{
+	char			name[MAXSTUDIONAME];
+	char			parent[MAXSTUDIONAME];
+	matrix3x4_t		rawLocal;
+	bool			bPreAligned;
+	matrix3x4_t		srcRealign;
+};
+EXTERN s_importbone_t g_importbone[MAXSTUDIOSRCBONES];
+
+
+EXTERN int g_numincludemodels;
+struct s_includemodel_t
+{
+	char			name[MAXSTUDIONAME];
+};
+EXTERN s_includemodel_t g_includemodel[128];
+
+struct s_bbox_t
+{
+	char			name[MAXSTUDIONAME];		// bone name
+	char			hitboxname[MAXSTUDIONAME];	// hitbox name
+	int				bone;
+	int				group;		// hitgroup
+	int				model;
+	Vector			bmin, bmax;	// bounding box
+};
+
+#define MAXSTUDIOHITBOXSETNAME 64
+
+struct s_hitboxset
+{
+	char		hitboxsetname[ MAXSTUDIOHITBOXSETNAME ];
+	
+	int			numhitboxes;
+
+	s_bbox_t	hitbox[MAXSTUDIOSRCBONES];
+};
+
+extern CUtlVector< s_hitboxset > g_hitboxsets;
+
+EXTERN int g_numhitgroups;
+struct s_hitgroup_t
+{
+	int				models;
+	int				group;
+	char			name[MAXSTUDIONAME];	// bone name
+};
+EXTERN s_hitgroup_t g_hitgroup[MAXSTUDIOSRCBONES];
+
+
+struct s_bonecontroller_t
+{
+	char	name[MAXSTUDIONAME];
+	int		bone;
+	int		type;
+	int		inputfield;
+	float	start;
+	float	end;
+};
+
+EXTERN s_bonecontroller_t g_bonecontroller[MAXSTUDIOSRCBONES];
+EXTERN int g_numbonecontrollers;
+
+struct s_screenalignedbone_t
+{
+	char	name[MAXSTUDIONAME];
+	int		flags;
+};
+
+EXTERN s_screenalignedbone_t g_screenalignedbone[MAXSTUDIOSRCBONES];
+EXTERN int g_numscreenalignedbones;
+
+struct s_attachment_t
+{
+	char	name[MAXSTUDIONAME];
+	char	bonename[MAXSTUDIONAME];
+	int		bone;
+	int		type;
+	int		flags;
+	matrix3x4_t	local;
+	int		found;	// a owning bone has been flagged
+
+	bool operator==( const s_attachment_t &rhs ) const;
+};
+
+
+#define IS_ABSOLUTE		0x0001
+#define IS_RIGID		0x0002
+
+EXTERN s_attachment_t g_attachment[MAXSTUDIOSRCBONES];
+EXTERN int g_numattachments;
+
+struct s_bonemerge_t
+{
+	char	bonename[MAXSTUDIONAME];
+};
+
+EXTERN CUtlVector< s_bonemerge_t > g_BoneMerge;
+
+struct s_mouth_t
+{
+	char	bonename[MAXSTUDIONAME];
+	int		bone;
+	Vector	forward;
+	int		flexdesc;
+};
+
+EXTERN s_mouth_t g_mouth[MAXSTUDIOSRCBONES]; // ?? skins?
+EXTERN int g_nummouths;
+
+struct s_node_t
+{
+	char			name[MAXSTUDIONAME];
+	int				parent;
+};
+
+struct s_bone_t
+{
+	Vector			pos;
+	RadianEuler		rot;
+};
+
+struct s_linearmove_t
+{
+	int				endframe;	// frame when pos, rot is valid.
+	int				flags;		// type of motion.  Only linear, linear accel, and linear decel is allowed
+	float			v0;
+	float			v1;
+	Vector			vector;		// movement vector
+	Vector			pos;	// final position
+	RadianEuler		rot;		// final rotation
+};
+
+
+#define CMD_WEIGHTS	1
+#define CMD_SUBTRACT 2
+#define CMD_AO		3
+#define CMD_MATCH	4
+#define CMD_FIXUP	5
+#define CMD_ANGLE	6
+#define CMD_IKFIXUP	7
+#define CMD_IKRULE	8
+#define CMD_MOTION	9
+#define CMD_REFMOTION	10
+#define CMD_DERIVATIVE 11
+#define	CMD_NOANIMATION 12
+#define CMD_LINEARDELTA 13
+#define CMD_SPLINEDELTA 14
+#define CMD_COMPRESS 15
+#define CMD_NUMFRAMES 16
+#define CMD_COUNTERROTATE 17
+#define CMD_SETBONE 18
+#define CMD_WORLDSPACEBLEND 19
+#define CMD_MATCHBLEND 20
+#define CMD_LOCALHIERARCHY 21
+
+struct s_animation_t;
+struct s_ikrule_t;
+
+
+struct s_motion_t
+{
+	int				motiontype;
+	int				iStartFrame;// starting frame to apply motion over
+	int				iEndFrame;	// end frame to apply motion over
+	int				iSrcFrame;	// frame that matches the "reference" animation
+	s_animation_t	*pRefAnim;	// animation to match
+	int				iRefFrame;	// reference animation's frame to match
+};
+
+
+struct s_animcmd_t
+{
+	int cmd;
+	union 
+	{
+		struct
+		{
+			int				index;	
+		} weightlist;
+
+		struct
+		{
+			s_animation_t	*ref;
+			int				frame;
+			int				flags;
+		} subtract;
+
+		struct
+		{
+			s_animation_t	*ref;
+			int				motiontype;
+			int				srcframe;
+			int				destframe;
+			char			*pBonename;
+		} ao;
+
+		struct
+		{
+			s_animation_t	*ref;
+			int				srcframe;
+			int				destframe;
+			int				destpre;
+			int				destpost;
+		} match;
+
+		struct
+		{
+			s_animation_t	*ref;
+			int				startframe;
+			int				loops;
+		} world;
+
+		struct 
+		{
+			int				start;
+			int				end;
+		} fixuploop;
+
+		struct 
+		{
+			float			angle;
+		} angle;
+
+		struct
+		{
+			s_ikrule_t		*pRule;
+		} ikfixup;
+
+		struct
+		{
+			s_ikrule_t		*pRule;
+		} ikrule;
+
+		struct
+		{
+			float			scale;
+		} derivative;
+
+		struct
+		{
+			int				flags;
+		} linear;
+
+		struct
+		{
+			int				frames;
+		} compress;
+
+		struct
+		{
+			int				frames;
+		} numframes;
+
+		struct
+		{
+			char			*pBonename;
+			bool			bHasTarget;
+			float 			targetAngle[3];
+		} counterrotate;
+
+		struct
+		{
+			char			*pBonename;
+			char			*pParentname;
+			int				start;
+			int				peak;
+			int				tail;
+			int				end;
+		} localhierarchy;
+
+		struct s_motion_t	motion;
+	} u;
+};
+
+struct s_streamdata_t
+{
+	Vector pos;
+	Quaternion q;
+};
+
+
+struct s_animationstream_t
+{
+	// source animations
+	int					numerror;
+	s_streamdata_t		*pError;
+	// compressed animations
+	float				scale[6];
+	int					numanim[6];
+	mstudioanimvalue_t	*anim[6];
+};
+
+struct s_ikrule_t
+{
+	int		chain;
+
+	int		index;
+	int		type;
+	int		slot;
+	char	bonename[MAXSTUDIONAME];
+	char	attachment[MAXSTUDIONAME];
+	int		bone;
+	Vector	pos;
+	Quaternion q;
+	float	height;
+	float	floor;
+	float	radius;
+
+	int		start;
+	int		peak;
+	int		tail;
+	int		end;
+
+	int		contact;
+
+	bool	usesequence;
+	bool	usesource;
+
+	int		flags;
+
+	s_animationstream_t errorData;
+};
+
+struct s_localhierarchy_t
+{
+	int		bone;
+	int		newparent;
+
+	int		start;
+	int		peak;
+	int		tail;
+	int		end;
+
+	s_animationstream_t localData;
+};
+
+
+struct s_source_t;
+EXTERN	int g_numani;
+struct s_compressed_t
+{
+	int					num[6];
+	mstudioanimvalue_t *data[6];
+};
+
+struct s_animation_t
+{
+	bool			isImplied;
+	bool			isOverride;
+	bool			doesOverride;
+	int				index;
+	char			name[MAXSTUDIONAME];
+	char			filename[MAX_PATH];
+
+	/*
+	int				animsubindex;
+
+	// For sharing outside of current .mdl file
+	bool			shared_group_checkvalidity;
+	bool			shared_group_valid;
+	char			shared_animgroup_file[ MAX_PATH ]; // share file name
+	char			shared_animgroup_name[ MAXSTUDIONAME ]; // group name in share file
+	int				shared_group_subindex;
+	studioanimhdr_t *shared_group_header;
+	*/
+
+	float			fps;
+	int				startframe;
+	int				endframe;
+	int				flags;
+	// animations processed (time shifted, linearized, and bone adjusted ) from source animations
+	CUtlVectorAuto< s_bone_t * > sanim; // [MAXSTUDIOANIMFRAMES]; // [frame][bones];
+
+	int				motiontype;
+
+	int				fudgeloop;
+	int				looprestart; // new starting frame for looping animations
+
+	// piecewise linear motion
+	int				numpiecewisekeys;
+	s_linearmove_t	piecewisemove[MAXSTUDIOMOVEKEYS];
+
+	// default adjustments
+	Vector			adjust;
+	float			scale; // ????
+	RadianEuler		rotation; 
+
+	s_source_t		*source;
+	char			animationname[MAX_PATH];
+
+	Vector 			bmin;
+	Vector			bmax;
+
+	int				numframes;
+
+	// compressed animation data
+	int				numsections;
+	int				sectionframes;
+	CUtlVectorAuto< CUtlVectorAuto< s_compressed_t > > anim;
+
+	// int				weightlist;
+	float			weight[MAXSTUDIOSRCBONES];
+	float			posweight[MAXSTUDIOSRCBONES];
+
+	int				numcmds;
+	s_animcmd_t		cmds[MAXSTUDIOCMDS];
+
+	int				numikrules;
+	s_ikrule_t		ikrule[MAXSTUDIOIKRULES];
+	bool			noAutoIK;
+
+	int				numlocalhierarchy;
+	s_localhierarchy_t localhierarchy[MAXSTUDIOIKRULES];
+
+	float			motionrollback;
+
+	bool			disableAnimblocks;		// no demand loading
+	bool			isFirstSectionLocal;	// first block of a section isn't demand loaded
+};
+EXTERN	s_animation_t *g_panimation[MAXSTUDIOANIMS];
+
+
+EXTERN  int	g_numcmdlists;
+struct s_cmdlist_t
+{
+	char			name[MAXSTUDIONAME];
+	int				numcmds;
+	s_animcmd_t		cmds[MAXSTUDIOCMDS];
+};
+EXTERN	s_cmdlist_t g_cmdlist[MAXSTUDIOANIMS];
+
+
+struct s_iklock_t
+{
+	char			name[MAXSTUDIONAME];
+	int				chain;
+	float			flPosWeight;
+	float			flLocalQWeight;
+};
+
+EXTERN	int g_numikautoplaylocks;
+EXTERN	s_iklock_t g_ikautoplaylock[16];
+
+
+struct s_event_t
+{
+	int				event;
+	int				frame;
+	char			options[64];
+	char			eventname[MAXSTUDIONAME];
+};
+
+struct s_autolayer_t
+{
+	char			name[MAXSTUDIONAME];
+	int				sequence;
+	int				flags;
+	int				pose;
+	float			start;
+	float			peak;
+	float			tail;
+	float			end;
+};
+
+
+class s_sequence_t
+{
+public:
+	char			name[MAXSTUDIONAME];
+	char			activityname[MAXSTUDIONAME];	// index into the string table, the name of this activity.
+
+	int				flags;
+	// float			fps;
+	// int				numframes;
+
+	int				activity;
+	int				actweight;
+
+	int				numevents;
+	s_event_t		event[MAXSTUDIOEVENTS];
+
+	int				numblends;
+	int				groupsize[2];
+	CUtlVectorAuto< CUtlVectorAuto< s_animation_t * > > panim; // [MAXSTUDIOBLENDS][MAXSTUDIOBLENDS];
+
+	int				paramindex[2];
+	float			paramstart[2];
+	float			paramend[2];
+	int				paramattachment[2];
+	int				paramcontrol[2];
+	CUtlVectorAuto< float >param0; // [MAXSTUDIOBLENDS];
+	CUtlVectorAuto< float >param1; // [MAXSTUDIOBLENDS];
+	s_animation_t	*paramanim;
+	s_animation_t	*paramcompanim;
+	s_animation_t	*paramcenter;
+
+	// Vector			automovepos[MAXSTUDIOANIMATIONS];
+	// Vector			automoveangle[MAXSTUDIOANIMATIONS];
+
+	int				animindex;
+
+	Vector 			bmin;
+	Vector			bmax;
+
+	float			fadeintime;
+	float			fadeouttime;
+
+	int				entrynode;
+	int				exitnode;
+	int				nodeflags;
+	float			entryphase;
+	float			exitphase;
+
+	int				numikrules;
+
+	int				numautolayers;
+	s_autolayer_t	autolayer[64];
+
+	float			weight[MAXSTUDIOSRCBONES];
+
+	s_iklock_t		iklock[64];
+	int				numiklocks;
+
+	int				cycleposeindex;
+
+	CUtlVector< char > KeyValue;
+};
+EXTERN	CUtlVector< s_sequence_t > g_sequence;
+//EXTERN	int g_numseq;
+
+
+EXTERN int g_numanimblocks;
+struct s_animblock_t
+{
+	int		iStartAnim;
+	int		iEndAnim;
+	byte	*start;
+	byte	*end;
+};
+EXTERN s_animblock_t g_animblock[MAXSTUDIOANIMBLOCKS];
+EXTERN int g_animblocksize;
+EXTERN char g_animblockname[260];
+
+
+EXTERN int g_numposeparameters;
+struct s_poseparameter_t
+{
+	char	name[MAXSTUDIONAME];
+	float	min;
+	float	max;
+	int		flags;
+	float	loop;
+};
+EXTERN s_poseparameter_t g_pose[32]; // FIXME: this shouldn't be hard coded
+
+
+EXTERN int g_numxnodes;
+EXTERN char *g_xnodename[100];
+EXTERN int g_xnode[100][100];
+EXTERN int g_numxnodeskips;
+EXTERN int g_xnodeskip[10000][2];
+
+struct rgb_t
+{
+	byte r, g, b;
+};
+struct rgb2_t
+{
+	float r, g, b, a;
+};
+
+// FIXME: what about texture overrides inline with loading models
+enum TextureFlags_t
+{
+	RELATIVE_TEXTURE_PATH_SPECIFIED = 0x1
+};
+
+struct s_texture_t
+{
+	char	name[MAX_PATH];
+	int		flags;
+	int		parent;
+	int		material;
+	float	width;
+	float	height;
+	float	dPdu;
+	float	dPdv;
+};
+EXTERN	s_texture_t g_texture[MAXSTUDIOSKINS];
+EXTERN	int g_numtextures;
+EXTERN	int	g_material[MAXSTUDIOSKINS]; // link into texture array
+EXTERN  int g_nummaterials;
+
+EXTERN  float g_gamma;
+EXTERN	int g_numskinref;
+EXTERN  int g_numskinfamilies;
+EXTERN  int g_skinref[256][MAXSTUDIOSKINS]; // [skin][skinref], returns texture index
+EXTERN	int g_numtexturegroups;
+EXTERN	int g_numtexturelayers[32];
+EXTERN	int g_numtexturereps[32];
+EXTERN  int g_texturegroup[32][32][32];
+
+struct s_mesh_t
+{
+	int numvertices;
+	int	vertexoffset;
+
+	int numfaces;
+	int	faceoffset;
+};
+
+
+struct s_vertanim_t
+{
+	int		vertex;
+	float	speed;
+	float	side;
+	Vector	pos;
+	Vector	normal;
+	float	wrinkle;
+};
+
+struct s_lodvertexinfo_t : public s_vertexinfo_t
+{
+	int lodFlag;
+};
+
+// processed aggregate lod pools
+struct s_loddata_t
+{
+	int					numvertices;
+	s_lodvertexinfo_t	*vertex;
+
+	int					numfaces;
+	s_face_t			*face;
+
+	s_mesh_t			mesh[MAXSTUDIOSKINS];
+
+	// remaps verts from an lod's source mesh to this all-lod processed aggregate pool
+	int					*pMeshVertIndexMaps[MAX_NUM_LODS];
+};
+
+// Animations stored in raw off-disk source files.  Raw data should be not processed.
+class s_sourceanim_t
+{
+public:
+	char animationname[MAX_PATH];
+	int numframes;
+	int startframe;
+	int endframe;
+	CUtlVectorAuto< s_bone_t * >rawanim;
+
+	// vertex animation
+	bool			newStyleVertexAnimations;	// new style doesn't store a base pose in vertex anim[0]
+	int				*vanim_mapcount;	// local verts map to N target verts
+	int				**vanim_map;		// local vertices to target vertices mapping list
+	int				*vanim_flag;		// local vert does animate
+
+	int				numvanims[MAXSTUDIOANIMFRAMES];
+	s_vertanim_t	*vanim[MAXSTUDIOANIMFRAMES];	// [frame][vertex]
+};
+
+// raw off-disk source files.  Raw data should be not processed.
+struct s_source_t
+{
+	char	filename[MAX_PATH];
+	int 	time;	// time stamp
+
+	bool	isActiveModel;
+
+	// local skeleton hierarchy
+	int numbones;
+	s_node_t localBone[MAXSTUDIOSRCBONES];
+	matrix3x4_t boneToPose[MAXSTUDIOSRCBONES];	// converts bone local data into initial pose data
+
+	// bone remapping
+	int boneflags[MAXSTUDIOSRCBONES];	// attachment, vertex, etc flags for this bone
+	int boneref[MAXSTUDIOSRCBONES];		// flags for this and child bones
+	int	boneLocalToGlobal[MAXSTUDIOSRCBONES]; // bonemap : local bone to world bone mapping
+	int	boneGlobalToLocal[MAXSTUDIOSRCBONES]; // boneimap : world bone to local bone mapping
+
+	int	texmap[MAXSTUDIOSKINS*4];		// map local MAX materials to unique textures
+
+	// per material mesh
+	int				nummeshes;
+	int				meshindex[MAXSTUDIOSKINS];	// mesh to skin index
+	s_mesh_t		mesh[MAXSTUDIOSKINS];
+
+	// vertices defined in "local" space (not remapped to global bones)
+	int				numvertices;
+	s_vertexinfo_t	*vertex;
+
+	// vertices defined in "global" space (remapped to global bones)
+	CUtlVector< s_vertexinfo_t > m_GlobalVertices;
+
+	int numfaces;
+	s_face_t *face;						// vertex indexs per face
+
+	// raw skeletal animation
+	CUtlVector< s_sourceanim_t > m_Animations;
+	// default adjustments
+	Vector			adjust;
+	float			scale; // ????
+	RadianEuler		rotation; 
+
+
+	// Flex keys stored in the source data
+	CUtlVector< s_flexkey_t > m_FlexKeys;
+
+	// Combination controls stored in the source data
+	CUtlVector< s_combinationcontrol_t > m_CombinationControls;
+
+	// Combination rules stored in the source data
+	CUtlVector< s_combinationrule_t > m_CombinationRules;
+
+	// Flexcontroller remaps
+	CUtlVector< s_flexcontrollerremap_t > m_FlexControllerRemaps;
+
+	// Attachment points stored in the SMD/DMX/etc. file
+	CUtlVector< s_attachment_t > m_Attachments;
+
+	// Information about how flex controller remaps map into flex rules
+	int m_nKeyStartIndex;	// The index at which the flex keys for this model start in the global list
+	CUtlVector< int > m_rawIndexToRemapSourceIndex;
+	CUtlVector< int > m_rawIndexToRemapLocalIndex;
+	CUtlVector< int > m_leftRemapIndexToGlobalFlexControllIndex;
+	CUtlVector< int > m_rightRemapIndexToGlobalFlexControllIndex;
+};
+
+
+EXTERN int g_numsources;
+EXTERN s_source_t *g_source[MAXSTUDIOSEQUENCES];
+
+struct s_eyeball_t
+{
+	char	name[MAXSTUDIONAME];
+	int		index;
+	int		bone;
+	Vector	org;
+	float	zoffset;
+	float	radius;
+	Vector	up;
+	Vector	forward;
+
+	int		mesh;
+	float	iris_scale;
+
+	int		upperlidflexdesc;
+	int		upperflexdesc[3];
+	float	uppertarget[3];
+
+	int		lowerlidflexdesc;
+	int		lowerflexdesc[3];
+	float	lowertarget[3];
+
+	int		m_flags;
+
+	enum StudioMdlEyeBallFlags
+	{
+		STUDIOMDL_EYELID_DME = 1 << 0
+	};
+};
+
+struct s_model_t
+{
+	char name[MAXSTUDIONAME];
+	char filename[MAX_PATH];
+
+	// needs local scaling and rotation paramaters
+	s_source_t	 *source; // index into source table
+
+	float scale;	// UNUSED
+
+	float boundingradius;
+
+	Vector boundingbox[MAXSTUDIOSRCBONES][2];
+
+	int	numattachments;
+	s_attachment_t	attachment[32];
+
+	int numeyeballs;
+	s_eyeball_t		eyeball[4];
+
+	int	numflexes;
+	int flexoffset;
+
+	// References to sources which are the LODs for this model
+	CUtlVector< s_source_t* > m_LodSources;
+
+	// processed aggregate lod data
+	s_loddata_t		*m_pLodData;
+};
+
+EXTERN	int g_nummodels;
+EXTERN	int g_nummodelsbeforeLOD;
+EXTERN	s_model_t *g_model[MAXSTUDIOMODELS];
+
+
+struct s_flexdesc_t
+{
+	char FACS[MAXSTUDIONAME];	// FACS identifier
+};
+EXTERN int g_numflexdesc;
+EXTERN s_flexdesc_t g_flexdesc[MAXSTUDIOFLEXDESC];
+int Add_Flexdesc( const char *name );
+
+
+struct s_flexcontroller_t
+{
+	char name[MAXSTUDIONAME];
+	char type[MAXSTUDIONAME];
+	float min;
+	float max;
+};
+EXTERN int g_numflexcontrollers;
+EXTERN s_flexcontroller_t g_flexcontroller[MAXSTUDIOFLEXCTRL];
+
+struct s_flexcontrollerremap_t
+{
+	CUtlString m_Name;
+	FlexControllerRemapType_t m_RemapType;
+	bool m_bIsStereo;
+	CUtlVector< CUtlString > m_RawControls;
+	int m_Index;		///< The model relative index of the slider control for value for this if it's not split, -1 otherwise
+	int m_LeftIndex;	///< The model relative index of the left slider control for this if it's split, -1 otherwise
+	int m_RightIndex;	///< The model relative index of the right slider control for this if it's split, -1 otherwise
+	int m_MultiIndex;	///< The model relative index of the value slider control for this if it's multi, -1 otherwise
+	CUtlString m_EyesUpDownFlexName;	// The name of the eyes up/down flex controller
+	int m_EyesUpDownFlexController;		// The global index of the Eyes Up/Down Flex Controller
+	int m_BlinkController;				// The global index of the Blink Up/Down Flex Controller
+};
+
+extern CUtlVector<s_flexcontrollerremap_t> g_FlexControllerRemap;
+
+
+struct s_flexkey_t
+{
+	int	 flexdesc;
+	int	 flexpair;
+	
+	s_source_t	 *source; // index into source table
+	char animationname[MAX_PATH];
+
+	int	imodel;
+	int	frame;
+
+	float	target0;
+	float	target1;
+	float	target2;
+	float	target3;
+
+	int		original;
+	float	split;
+
+	float	decay;
+
+	// extracted and remapped vertex animations
+	int				numvanims;
+	s_vertanim_t	*vanim;
+	int				vanimtype;
+	int	weighttable;
+};
+EXTERN int g_numflexkeys;
+EXTERN s_flexkey_t g_flexkey[MAXSTUDIOFLEXKEYS];
+EXTERN s_flexkey_t *g_defaultflexkey;
+
+#define MAX_OPS 512
+
+struct s_flexop_t
+{
+	int		op;
+	union 
+	{
+		int		index;
+		float	value;
+	} d;
+};
+
+struct s_flexrule_t
+{
+	int		flex;
+	int		numops;
+	s_flexop_t op[MAX_OPS];
+};
+
+EXTERN int g_numflexrules;
+EXTERN s_flexrule_t g_flexrule[MAXSTUDIOFLEXRULES];
+
+struct s_combinationcontrol_t
+{
+	char name[MAX_PATH];
+};
+
+struct s_combinationrule_t
+{
+	// The 'ints' here are indices into the m_Controls array
+	CUtlVector< int > m_Combination;
+	CUtlVector< CUtlVector< int > > m_Dominators;
+
+	// The index into the flexkeys to put the result in
+	// (should affect both left + right if the key is sided)
+	int m_nFlex;
+};
+
+EXTERN	Vector g_defaultadjust;
+
+struct s_bodypart_t
+{
+	char				name[MAXSTUDIONAME];
+	int					nummodels;
+	int					base;
+	s_model_t			*pmodel[MAXSTUDIOMODELS];
+};
+
+EXTERN	int g_numbodyparts;
+EXTERN	s_bodypart_t g_bodypart[MAXSTUDIOBODYPARTS];
+
+
+#define MAXWEIGHTLISTS	128
+#define MAXWEIGHTSPERLIST	(MAXSTUDIOBONES)
+
+struct s_weightlist_t
+{
+	// weights, indexed by numbones per weightlist
+	char			name[MAXSTUDIONAME];
+	int				numbones;
+	char			*bonename[MAXWEIGHTSPERLIST];
+	float			boneweight[MAXWEIGHTSPERLIST];
+	float			boneposweight[MAXWEIGHTSPERLIST];
+
+	// weights, indexed by global bone index
+	float			weight[MAXSTUDIOBONES];
+	float			posweight[MAXSTUDIOBONES];
+};
+
+EXTERN	int	g_numweightlist;
+EXTERN	s_weightlist_t g_weightlist[MAXWEIGHTLISTS];
+
+struct s_iklink_t
+{
+	int		bone;
+	Vector	kneeDir;
+};
+
+struct s_ikchain_t
+{
+	char			name[MAXSTUDIONAME];
+	char			bonename[MAXSTUDIONAME];
+	int				axis;
+	float			value;
+	int				numlinks;
+	s_iklink_t		link[10]; // hip, knee, ankle, toes...
+	float			height;
+	float			radius;
+	float			floor;
+	Vector			center;
+};
+
+EXTERN	int g_numikchains;
+EXTERN	s_ikchain_t g_ikchain[16];
+
+
+struct s_jigglebone_t
+{
+	int				flags;
+	char			bonename[MAXSTUDIONAME];
+	int				bone;
+
+	mstudiojigglebone_t data;	// the actual jiggle properties
+};
+
+EXTERN int g_numjigglebones;
+EXTERN s_jigglebone_t g_jigglebones[MAXSTUDIOBONES];
+EXTERN int g_jigglebonemap[MAXSTUDIOBONES]; // map used jigglebone's to source jigglebonebone's
+
+
+struct s_axisinterpbone_t
+{
+	int				flags;
+	char			bonename[MAXSTUDIONAME];
+	int				bone;
+	char			controlname[MAXSTUDIONAME];
+	int				control;
+	int				axis;
+	Vector			pos[6];
+	Quaternion		quat[6];
+};
+
+EXTERN int g_numaxisinterpbones;
+EXTERN s_axisinterpbone_t g_axisinterpbones[MAXSTUDIOBONES];
+EXTERN int g_axisinterpbonemap[MAXSTUDIOBONES]; // map used axisinterpbone's to source axisinterpbone's
+
+struct s_quatinterpbone_t
+{
+	int				flags;
+	char			bonename[MAXSTUDIONAME];
+	int				bone;
+	char			parentname[MAXSTUDIONAME];
+	// int				parent;
+	char			controlparentname[MAXSTUDIONAME];
+	// int				controlparent;
+	char			controlname[MAXSTUDIONAME];
+	int				control;
+	int				numtriggers;
+	Vector			size;
+	Vector			basepos;
+	float			percentage;
+	float			tolerance[32];
+	Quaternion		trigger[32];
+	Vector			pos[32];
+	Quaternion		quat[32];
+};
+
+EXTERN int g_numquatinterpbones;
+EXTERN s_quatinterpbone_t g_quatinterpbones[MAXSTUDIOBONES];
+EXTERN int g_quatinterpbonemap[MAXSTUDIOBONES]; // map used quatinterpbone's to source axisinterpbone's
+
+
+struct s_aimatbone_t
+{
+	char			bonename[MAXSTUDIONAME];
+	int				bone;
+	char			parentname[MAXSTUDIONAME];
+	int				parent;
+	char			aimname[MAXSTUDIONAME];
+	int				aimAttach;
+	int				aimBone;
+	Vector			aimvector;
+	Vector			upvector;
+	Vector			basepos;
+};
+
+EXTERN int g_numaimatbones;
+EXTERN s_aimatbone_t g_aimatbones[MAXSTUDIOBONES];
+EXTERN int g_aimatbonemap[MAXSTUDIOBONES]; // map used aimatpbone's to source aimatpbone's (may be optimized out)
+
+
+struct s_forcedhierarchy_t
+{
+	char			parentname[MAXSTUDIONAME];
+	char			childname[MAXSTUDIONAME];
+	char			subparentname[MAXSTUDIONAME];
+};
+
+EXTERN int g_numforcedhierarchy;
+EXTERN s_forcedhierarchy_t g_forcedhierarchy[MAXSTUDIOBONES];
+
+struct s_forcedrealign_t
+{
+	char			name[MAXSTUDIONAME];
+	RadianEuler		rot;
+};
+EXTERN int g_numforcedrealign;
+EXTERN s_forcedrealign_t g_forcedrealign[MAXSTUDIOBONES];
+
+struct s_limitrotation_t
+{
+	char			name[MAXSTUDIONAME];
+	int				numseq;
+	char			*sequencename[64];
+};
+
+EXTERN int g_numlimitrotation;
+EXTERN s_limitrotation_t g_limitrotation[MAXSTUDIOBONES];
+
+extern int BuildTris (s_trianglevert_t (*x)[3], s_mesh_t *y, byte **ppdata );
+
+
+struct s_bonesaveframe_t
+{
+	char		name[ MAXSTUDIOHITBOXSETNAME ];
+	bool		bSavePos;
+	bool		bSaveRot;
+};
+
+EXTERN CUtlVector< s_bonesaveframe_t > g_bonesaveframe;
+
+int OpenGlobalFile( char *src );
+bool GetGlobalFilePath( const char *pSrc, char *pFullPath, int nMaxLen );
+s_source_t *Load_Source( char const *filename, const char *ext, bool reverse = false, bool isActiveModel = false );
+int Load_VRM( s_source_t *psource );
+int Load_SMD( s_source_t *psource );
+int Load_VTA( s_source_t *psource );
+int Load_OBJ( s_source_t *psource );
+int Load_DMX( s_source_t *psource );
+int AppendVTAtoOBJ( s_source_t *psource, char *filename, int frame );
+void Build_Reference( s_source_t *psource, const char *pAnimName );
+int Grab_Nodes( s_node_t *pnodes );
+void Grab_Animation( s_source_t *psource, const char *pAnimName );
+
+// Processes source comment line and extracts information about the data file
+void ProcessSourceComment( s_source_t *psource, const char *pCommentString );
+
+// Processes original content file "szOriginalContentFile" that was used to generate
+// data file "szDataFile"
+void ProcessOriginalContentFile( const char *szDataFile, const char *szOriginalContentFile );
+
+//-----------------------------------------------------------------------------
+// Utility methods to get or add animation data from sources
+//-----------------------------------------------------------------------------
+s_sourceanim_t *FindSourceAnim( s_source_t *pSource, const char *pAnimName );
+const s_sourceanim_t *FindSourceAnim( const s_source_t *pSource, const char *pAnimName );
+s_sourceanim_t *FindOrAddSourceAnim( s_source_t *pSource, const char *pAnimName );
+
+// Adds flexkey data to a particular source
+void AddFlexKey( s_source_t *pSource, CDmeCombinationOperator *pComboOp, const char *pFlexKeyName );
+
+// Adds combination data to the source
+void AddCombination( s_source_t *pSource, CDmeCombinationOperator *pCombination );
+
+int LookupTexture( const char *pTextureName, bool bRelativePath = false );
+int UseTextureAsMaterial( int textureindex );
+int MaterialToTexture( int material );
+
+int LookupAttachment( char *name );
+
+void ClearModel (void);
+void SimplifyModel (void);
+void CollapseBones (void);
+
+void adjust_vertex( float *org );
+void scale_vertex( Vector &org );
+void clip_rotations( RadianEuler& rot );
+void clip_rotations( Vector& rot );
+
+void *kalloc( int num, int size );
+void kmemset( void *ptr, int value, int size );
+char *stristr( const char *string, const char *string2 );
+
+void CalcBoneTransforms( s_animation_t *panimation, int frame, matrix3x4_t* pBoneToWorld );
+void CalcBoneTransforms( s_animation_t *panimation, s_animation_t *pbaseanimation, int frame, matrix3x4_t* pBoneToWorld );
+void CalcBoneTransformsCycle( s_animation_t *panimation, s_animation_t *pbaseanimation, float flCycle, matrix3x4_t* pBoneToWorld );
+
+void BuildRawTransforms( const s_source_t *psource, const char *pAnimationName, int frame, float scale, Vector const &shift, RadianEuler const &rotate, int flags, matrix3x4_t* boneToWorld );
+void BuildRawTransforms( const s_source_t *psource, const char *pAnimationName, int frame, matrix3x4_t* boneToWorld );
+
+void TranslateAnimations( const s_source_t *pSource, const matrix3x4_t *pSrcBoneToWorld, matrix3x4_t *pDestBoneToWorld );
+
+// Returns surface property for a given joint
+char* GetSurfaceProp ( char const* pJointName );
+int GetContents ( char const* pJointName );
+char* GetDefaultSurfaceProp ( );
+int GetDefaultContents( );
+
+// Did we read 'end'
+bool IsEnd( char const* pLine );
+
+// Parses an LOD command
+void Cmd_LOD( char const *cmdname );
+void Cmd_ShadowLOD( void );
+
+// Fixes up the LOD source files
+void FixupLODSources();
+
+// Get model LOD source
+s_source_t* GetModelLODSource( const char *pModelName, 
+						const LodScriptData_t& scriptLOD, bool* pFound );
+
+
+void LoadLODSources( void );
+void ConvertBoneTreeCollapsesToReplaceBones( void );
+void FixupReplacedBones( void );
+void UnifyLODs( void );
+void SpewBoneUsageStats( void );
+void MarkParentBoneLODs( void );
+//void CheckAutoShareAnimationGroup( char const *animation_name );
+
+/*
+=================
+=================
+*/
+
+extern bool GetLineInput(void);
+extern char	g_szFilename[1024];
+extern FILE	*g_fpInput;
+extern char	g_szLine[4096];
+extern int	g_iLinecount;
+
+extern int g_min_faces, g_max_faces;
+extern float g_min_resolution, g_max_resolution;
+
+EXTERN	int g_numverts;
+EXTERN	Vector g_vertex[MAXSTUDIOVERTS];
+EXTERN	s_boneweight_t g_bone[MAXSTUDIOVERTS];
+
+EXTERN	int g_numnormals;
+EXTERN	Vector g_normal[MAXSTUDIOVERTS];
+
+EXTERN	int g_numtexcoords;
+EXTERN	Vector2D g_texcoord[MAXSTUDIOVERTS];
+
+EXTERN	int g_numfaces;
+EXTERN	s_tmpface_t g_face[MAXSTUDIOTRIANGLES];
+EXTERN	s_face_t g_src_uface[MAXSTUDIOTRIANGLES];	// max res unified faces
+
+struct v_unify_t
+{
+	int	refcount;
+	int	lastref;
+	int	firstref;
+	int	v;
+	int m;
+	int n;
+	int t;
+	v_unify_t *next;
+};
+
+EXTERN	v_unify_t *v_list[MAXSTUDIOVERTS];
+EXTERN	v_unify_t v_listdata[MAXSTUDIOVERTS];
+EXTERN	int numvlist;
+
+int SortAndBalanceBones( int iCount, int iMaxCount, int bones[], float weights[] );
+void Grab_Vertexanimation( s_source_t *psource, const char *pAnimationName );
+extern void BuildIndividualMeshes( s_source_t *psource );
+
+//-----------------------------------------------------------------------------
+// A little class used to deal with replacement commands
+//-----------------------------------------------------------------------------
+
+class CLodScriptReplacement_t
+{
+public:
+	void SetSrcName( const char *pSrcName )
+	{
+		if( m_pSrcName )
+		{
+			delete [] m_pSrcName;
+		}
+		m_pSrcName = new char[strlen( pSrcName ) + 1];
+		strcpy( m_pSrcName, pSrcName );
+	}
+	void SetDstName( const char *pDstName )
+	{
+		if( m_pDstName )
+		{
+			delete [] m_pDstName;
+		}
+		m_pDstName = new char[strlen( pDstName ) + 1];
+		strcpy( m_pDstName, pDstName );
+	}
+
+	const char *GetSrcName( void ) const 
+	{
+		return m_pSrcName;
+	}
+	const char *GetDstName( void ) const
+	{
+		return m_pDstName;
+	}
+	CLodScriptReplacement_t()
+	{
+		m_pSrcName = NULL;
+		m_pDstName = NULL;
+		m_pSource = 0;
+	}
+	~CLodScriptReplacement_t()
+	{
+		delete [] m_pSrcName;
+		delete [] m_pDstName;
+	}
+
+	s_source_t*	m_pSource;
+
+private:
+	char *m_pSrcName;
+	char *m_pDstName;
+	bool m_bReverse;
+};
+
+
+struct LodScriptData_t
+{
+public:
+	float switchValue;
+	CUtlVector<CLodScriptReplacement_t> modelReplacements;
+	CUtlVector<CLodScriptReplacement_t> boneReplacements;
+	CUtlVector<CLodScriptReplacement_t> boneTreeCollapses;
+	CUtlVector<CLodScriptReplacement_t> materialReplacements;
+	CUtlVector<CLodScriptReplacement_t> meshRemovals;
+
+
+	void EnableFacialAnimation( bool val )
+	{
+		m_bFacialAnimation = val;
+	}
+	bool GetFacialAnimationEnabled() const 
+	{
+		return m_bFacialAnimation;
+	}
+
+	void StripFromModel( bool val )
+	{
+		m_bStrippedFromModel = val;
+	}
+	bool IsStrippedFromModel() const
+	{
+		return m_bStrippedFromModel;
+	}
+	
+	LodScriptData_t()
+	{
+		m_bFacialAnimation = true;
+		m_bStrippedFromModel = false;
+	}
+
+private:
+	bool m_bFacialAnimation;
+	bool m_bStrippedFromModel;
+};
+
+EXTERN CUtlVector<LodScriptData_t> g_ScriptLODs;
+
+extern bool g_collapse_bones;
+extern bool g_collapse_bones_aggressive;
+extern bool g_quiet;
+extern bool g_verbose;
+extern bool g_bCheckLengths;
+extern bool g_bPrintBones;
+extern bool g_bPerf;
+extern bool g_bFast;
+extern bool g_bDumpGraph;
+extern bool g_bMultistageGraph;
+extern bool g_bCreateMakefile;
+extern bool g_bZBrush;
+extern bool g_bVerifyOnly;
+extern bool g_bUseBoneInBBox;
+extern bool g_bLockBoneLengths;
+extern bool g_bOverridePreDefinedBones;
+extern bool g_bX360;
+extern int g_minLod;
+extern int g_numAllowedRootLODs;
+extern bool g_bBuildPreview;
+extern bool g_bCenterBonesOnVerts;
+extern float g_flDefaultMotionRollback;
+extern int g_minSectionFrameLimit;
+extern int g_sectionFrames;
+extern bool g_bNoAnimblockStall;
+
+extern Vector g_vecMinWorldspace;
+extern Vector g_vecMaxWorldspace;
+
+EXTERN CUtlVector< char * >g_collapse;
+
+extern float GetCollisionModelMass();
+
+// List of defined bone flex drivers
+extern DmElementHandle_t g_hDmeBoneFlexDriverList;
+
+// the first time these are called, the name of the model/QC file is printed so that when 
+// running in batch mode, no echo, when dumping to a file, it can be determined which file is broke.
+void MdlError( PRINTF_FORMAT_STRING char const *pMsg, ... );
+void MdlWarning( PRINTF_FORMAT_STRING char const *pMsg, ... );
+
+void CreateMakefile_AddDependency( const char *pFileName );
+void EnsureDependencyFileCheckedIn( const char *pFileName );
+
+bool ComparePath( const char *a, const char *b );
+
+byte IsByte( int val );
+char IsChar( int val );
+int IsInt24( int val );
+short IsShort( int val );
+unsigned short IsUShort( int val );
+
+
+extern CCheckUVCmd g_StudioMdlCheckUVCmd;
+
+
+#endif // STUDIOMDL_H
+
diff --git a/utils/studiomdl/studiomdl.vpc b/utils/studiomdl/studiomdl.vpc
new file mode 100644
index 0000000..123d35c
--- /dev/null
+++ b/utils/studiomdl/studiomdl.vpc
@@ -0,0 +1,151 @@
+//-----------------------------------------------------------------------------
+//	STUDIOMDL.VPC
+//
+//	Project Script
+//-----------------------------------------------------------------------------
+
+$Macro SRCDIR		"..\.."
+$Macro OUTBINDIR	"$SRCDIR\..\game\bin"
+
+$Include "$SRCDIR\vpc_scripts\source_exe_con_base.vpc"
+
+$Configuration
+{
+	$Compiler
+	{
+		$AdditionalIncludeDirectories		"$BASE,..\common,..\nvtristriplib,$SRCDIR\Game_Shared"
+		$PreprocessorDefinitions			"$BASE;PROTECTED_THINGS_DISABLE"
+	}
+
+	$Linker
+	{
+		$AdditionalDependencies				"$BASE winmm.lib"
+	}
+}
+
+$Project "Studiomdl"
+{
+	$Folder	"Source Files"
+	{
+		$File	"$SRCDIR\public\bone_setup.cpp"
+		$File	"..\common\cmdlib.cpp"
+		$File	"collisionmodel.cpp"
+		$File	"$SRCDIR\public\CollisionUtils.cpp"
+		$File	"dmxsupport.cpp"
+		$File	"$SRCDIR\public\filesystem_helpers.cpp"
+		$File	"$SRCDIR\public\filesystem_init.cpp"
+		$File	"..\common\FileSystem_Tools.cpp"
+		$File	"HardwareMatrixState.cpp"
+		$File	"HardwareVertexCache.cpp"
+		$File	"$SRCDIR\public\interpolatortypes.cpp"
+		$File	"$SRCDIR\public\mdlobjects\mdlobjects.cpp"
+		$File	"$SRCDIR\public\movieobjects\movieobjects_compiletools.cpp"
+		$File	"mrmsupport.cpp"
+		$File	"objsupport.cpp"
+		$File	"optimize.cpp"
+		$File	"perfstats.cpp"
+		$File	"..\common\physdll.cpp"
+		$File	"..\common\scriplib.cpp"
+		$File	"simplify.cpp"
+		$File	"$SRCDIR\public\studio.cpp"
+		$File	"$SRCDIR\common\studiobyteswap.cpp"
+		$File	"studiomdl.cpp"
+		$File	"UnifyLODs.cpp"
+		$File	"v1support.cpp"
+		$File	"write.cpp"
+		$File	"checkuv.cpp"
+	}
+
+	$Folder	"Header Files"
+	{
+		$File	"..\common\cmdlib.h"
+		$File	"collisionmodel.h"
+		$File	"FileBuffer.h"
+		$File	"..\common\FileSystem_Tools.h"
+		$File	"HardwareMatrixState.h"
+		$File	"HardwareVertexCache.h"
+		$File	"..\NvTriStripLib\NvTriStrip.h"
+		$File	"perfstats.h"
+		$File	"..\common\physdll.h"
+		$File	"..\common\scriplib.h"
+		$File	"studiomdl.h"
+		$File	"checkuv.h"
+	}
+
+	$Folder	"Public Header Files"
+	{
+		$File	"$SRCDIR\public\gametrace.h"
+		$File	"$SRCDIR\public\filesystem.h"
+		$File	"$SRCDIR\public\filesystem_helpers.h"
+		$File	"$SRCDIR\public\cmodel.h"
+		$File	"$SRCDIR\public\mathlib\amd3dx.h"
+		$File	"$SRCDIR\public\basehandle.h"
+		$File	"$SRCDIR\public\tier0\basetypes.h"
+		$File	"$SRCDIR\public\bitvec.h"
+		$File	"$SRCDIR\public\bone_accessor.h"
+		$File	"$SRCDIR\public\bone_setup.h"
+		$File	"$SRCDIR\public\bspflags.h"
+		$File	"$SRCDIR\public\tier1\byteswap.h"
+		$File	"$SRCDIR\public\tier1\characterset.h"
+		$File	"$SRCDIR\public\CollisionUtils.h"
+		$File	"$SRCDIR\public\tier0\commonmacros.h"
+		$File	"$SRCDIR\public\mathlib\compressed_vector.h"
+		$File	"$SRCDIR\public\const.h"
+		$File	"$SRCDIR\public\vphysics\constraints.h"
+		$File	"$SRCDIR\public\tier0\dbg.h"
+		$File	"$SRCDIR\public\tier0\fasttimer.h"
+		$File	"$SRCDIR\public\appframework\IAppSystem.h"
+		$File	"$SRCDIR\public\tier0\icommandline.h"
+		$File	"$SRCDIR\public\ihandleentity.h"
+		$File	"$SRCDIR\public\materialsystem\imaterial.h"
+		$File	"$SRCDIR\public\materialsystem\imaterialsystem.h"
+		$File	"$SRCDIR\public\materialsystem\imaterialvar.h"
+		$File	"$SRCDIR\public\tier1\interface.h"
+		$File	"$SRCDIR\public\istudiorender.h"
+		$File	"$SRCDIR\public\tier1\KeyValues.h"
+		$File	"$SRCDIR\public\materialsystem\materialsystem_config.h"
+		$File	"$SRCDIR\public\mathlib\mathlib.h"
+		$File	"$SRCDIR\public\tier0\memdbgoff.h"
+		$File	"$SRCDIR\public\tier0\memdbgon.h"
+		$File	"$SRCDIR\public\phyfile.h"
+		$File	"$SRCDIR\public\optimize.h"
+		$File	"$SRCDIR\public\tier0\platform.h"
+		$File	"$SRCDIR\public\tier0\protected_things.h"
+		$File	"$SRCDIR\public\vstdlib\random.h"
+		$File	"$SRCDIR\common\studiobyteswap.h"
+		$File	"$SRCDIR\public\string_t.h"
+		$File	"$SRCDIR\public\tier1\strtools.h"
+		$File	"$SRCDIR\public\studio.h"
+		$File	"$SRCDIR\public\tier3\tier3.h"
+		$File	"$SRCDIR\public\tier1\utlbuffer.h"
+		$File	"$SRCDIR\public\tier1\utldict.h"
+		$File	"$SRCDIR\public\tier1\utllinkedlist.h"
+		$File	"$SRCDIR\public\tier1\utlmemory.h"
+		$File	"$SRCDIR\public\tier1\utlrbtree.h"
+		$File	"$SRCDIR\public\tier1\utlsymbol.h"
+		$File	"$SRCDIR\public\tier1\utlvector.h"
+		$File	"$SRCDIR\public\vcollide.h"
+		$File	"$SRCDIR\public\vcollide_parse.h"
+		$File	"$SRCDIR\public\mathlib\vector.h"
+		$File	"$SRCDIR\public\mathlib\vector2d.h"
+		$File	"$SRCDIR\public\mathlib\vector4d.h"
+		$File	"$SRCDIR\public\mathlib\vmatrix.h"
+		$File	"$SRCDIR\public\vphysics_interface.h"
+		$File	"$SRCDIR\public\mathlib\vplane.h"
+		$File	"$SRCDIR\public\tier0\vprof.h"
+		$File	"$SRCDIR\public\vstdlib\vstdlib.h"
+	}
+	
+	$Folder	"Link Libraries"
+	{
+		$Lib appframework
+		$Lib datamodel
+		$Lib dmserializers
+		$Lib mathlib
+		$Lib mdlobjects
+		$Lib movieobjects
+		$Lib nvtristrip
+		$Lib tier2
+		$Lib tier3
+	}
+}
diff --git a/utils/studiomdl/tristrip.cpp b/utils/studiomdl/tristrip.cpp
new file mode 100644
index 0000000..2a42836
--- /dev/null
+++ b/utils/studiomdl/tristrip.cpp
@@ -0,0 +1,350 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+// tristrip - convert triangle list into tristrips and fans
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+
+#include "cmdlib.h"
+#include "lbmlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "..\..\engine\studio.h"
+#include "studiomdl.h"
+
+int		used[MAXSTUDIOTRIANGLES];
+
+// the command list holds counts and s/t values that are valid for
+// every frame
+short	commands[MAXSTUDIOTRIANGLES * 13];
+int		numcommands;
+
+// all frames will have their vertexes rearranged and expanded
+// so they are in the order expected by the command list
+
+int		allverts, alltris;
+
+int		stripverts[MAXSTUDIOTRIANGLES+2];
+int		striptris[MAXSTUDIOTRIANGLES+2];
+int		stripcount;
+
+int		neighbortri[MAXSTUDIOTRIANGLES][3];
+int		neighboredge[MAXSTUDIOTRIANGLES][3];
+
+
+s_trianglevert_t (*triangles)[3];
+s_mesh_t *pmesh;
+
+
+void	FindNeighbor (int starttri, int startv)
+{
+	s_trianglevert_t			m1, m2;
+	int			j;
+	s_trianglevert_t	*last, *check;
+	int			k;
+
+	// used[starttri] |= (1 << startv);
+
+	last = &triangles[starttri][0];
+
+	m1 = last[(startv+1)%3];
+	m2 = last[(startv+0)%3];
+
+	for (j=starttri+1, check=&triangles[starttri+1][0] ; j<pmesh->numtris ; j++, check += 3)
+	{
+		if (used[j] == 7)
+			continue;
+		for (k=0 ; k<3 ; k++)
+		{
+			if (memcmp(&check[k],&m1,sizeof(m1)))
+				continue;
+			if (memcmp(&check[ (k+1)%3 ],&m2,sizeof(m2)))
+				continue;
+
+			neighbortri[starttri][startv] = j;
+			neighboredge[starttri][startv] = k;
+
+			neighbortri[j][k] = starttri;
+			neighboredge[j][k] = startv;
+
+			used[starttri] |= (1 << startv);
+			used[j] |= (1 << k);
+			return;
+		}
+	}
+}
+
+
+/*
+================
+StripLength
+================
+*/
+int	StripLength (int starttri, int startv)
+{
+	int			j;
+	int			k;
+
+	used[starttri] = 2;
+
+	stripverts[0] = (startv)%3;
+	stripverts[1] = (startv+1)%3;
+	stripverts[2] = (startv+2)%3;
+
+	striptris[0] = starttri;
+	striptris[1] = starttri;
+	striptris[2] = starttri;
+	stripcount = 3;
+
+	while( 1 )
+	{
+		if (stripcount & 1)
+		{
+			j = neighbortri[starttri][(startv+1)%3];
+			k = neighboredge[starttri][(startv+1)%3];
+		}
+		else
+		{
+			j = neighbortri[starttri][(startv+2)%3];
+			k = neighboredge[starttri][(startv+2)%3];
+		}
+		if (j == -1 || used[j])
+			goto done;
+
+		stripverts[stripcount] = (k+2)%3;
+		striptris[stripcount] = j;
+		stripcount++;
+
+		used[j] = 2;
+
+		starttri = j;
+		startv = k;
+	}
+
+done:
+
+	// clear the temp used flags
+	for (j=0 ; j<pmesh->numtris ; j++)
+		if (used[j] == 2)
+			used[j] = 0;
+
+	return stripcount;
+}
+
+/*
+===========
+FanLength
+===========
+*/
+int	FanLength (int starttri, int startv)
+{
+	int		j;
+	int		k;
+
+	used[starttri] = 2;
+
+	stripverts[0] = (startv)%3;
+	stripverts[1] = (startv+1)%3;
+	stripverts[2] = (startv+2)%3;
+
+	striptris[0] = starttri;
+	striptris[1] = starttri;
+	striptris[2] = starttri;
+	stripcount = 3;
+
+	while( 1 )
+	{
+		j = neighbortri[starttri][(startv+2)%3];
+		k = neighboredge[starttri][(startv+2)%3];
+
+		if (j == -1 || used[j])
+			goto done;
+
+		stripverts[stripcount] = (k+2)%3;
+		striptris[stripcount] = j;
+		stripcount++;
+
+		used[j] = 2;
+
+		starttri = j;
+		startv = k;
+	}
+
+done:
+
+	// clear the temp used flags
+	for (j=0 ; j<pmesh->numtris ; j++)
+		if (used[j] == 2)
+			used[j] = 0;
+
+	return stripcount;
+}
+
+
+/*
+================
+BuildTris
+
+Generate a list of trifans or strips
+for the model, which holds for all frames
+================
+*/
+int	numcommandnodes;
+
+int BuildTris (s_trianglevert_t (*x)[3], s_mesh_t *y, byte **ppdata )
+{
+	int		i, j, k, m;
+	int		startv;
+	int		len, bestlen, besttype;
+	int		bestverts[MAXSTUDIOTRIANGLES];
+	int		besttris[MAXSTUDIOTRIANGLES];
+	int		peak[MAXSTUDIOTRIANGLES];
+	int		type;
+	int		total = 0;
+	long 	t;
+	int		maxlen;
+
+	triangles = x;
+	pmesh = y;
+
+
+	t = time( NULL );
+
+	for (i=0 ; i<pmesh->numtris ; i++)
+	{
+		neighbortri[i][0] = neighbortri[i][1] = neighbortri[i][2] = -1;
+		used[i] = 0;
+		peak[i] = pmesh->numtris;
+	}
+
+	// printf("finding neighbors\n");
+	for (i=0 ; i<pmesh->numtris; i++)
+	{
+		for (k = 0; k < 3; k++)
+		{
+			if (used[i] & (1 << k))
+				continue;
+
+			FindNeighbor( i, k );
+		}
+		// printf("%d", used[i] );
+	}
+	// printf("\n");
+
+	//
+	// build tristrips
+	//
+	numcommandnodes = 0;
+	numcommands = 0;
+	memset (used, 0, sizeof(used));
+
+	for (i=0 ; i<pmesh->numtris ;)
+	{
+		// pick an unused triangle and start the trifan
+		if (used[i])
+		{
+			i++;
+			continue;
+		}
+
+		maxlen = 9999;
+		bestlen = 0;
+		m = 0;
+		for (k = i; k < pmesh->numtris && bestlen < 127; k++)
+		{
+			int localpeak = 0;
+
+			if (used[k])
+				continue;
+
+			if (peak[k] <= bestlen)
+				continue;
+
+			m++;
+			for (type = 0 ; type < 2 ; type++)
+			{
+				for (startv =0 ; startv < 3 ; startv++)
+				{
+					if (type == 1)
+						len = FanLength (k, startv);
+					else
+						len = StripLength (k, startv);
+					if (len > 127)
+					{
+						// skip these, they are too long to encode
+					}
+					else if (len > bestlen)
+					{
+						besttype = type;
+						bestlen = len;
+						for (j=0 ; j<bestlen ; j++)
+						{
+							besttris[j] = striptris[j];
+							bestverts[j] = stripverts[j];
+						}
+						// printf("%d %d\n", k, bestlen );
+					}
+					if (len > localpeak)
+						localpeak = len;
+				}
+			}
+			peak[k] = localpeak;
+			if (localpeak == maxlen)
+				break;
+		}
+		total += (bestlen - 2);
+
+		// printf("%d (%d) %d\n", bestlen, pmesh->numtris - total, i );
+
+		maxlen = bestlen;
+
+		// mark the tris on the best strip as used
+		for (j=0 ; j<bestlen ; j++)
+			used[besttris[j]] = 1;
+
+		if (besttype == 1)
+			commands[numcommands++] = -bestlen;
+		else
+			commands[numcommands++] = bestlen;
+
+		for (j=0 ; j<bestlen ; j++)
+		{
+			s_trianglevert_t *tri;
+
+			tri = &triangles[besttris[j]][bestverts[j]];
+
+			commands[numcommands++] = tri->vertindex;
+			commands[numcommands++] = tri->normindex;
+			commands[numcommands++] = tri->s;
+			commands[numcommands++] = tri->t;
+		}
+		// printf("%d ", bestlen - 2 );
+		numcommandnodes++;
+
+		if (t != time(NULL))
+		{
+			printf("%2d%%\r", (total * 100) / pmesh->numtris );
+			t = time(NULL);
+		}
+	}
+
+	commands[numcommands++] = 0;		// end of list marker
+
+	*ppdata = (byte *)commands;
+
+	// printf("%d %d %d\n", numcommandnodes, numcommands, pmesh->numtris  );
+	return numcommands * sizeof( short );
+}
+
diff --git a/utils/studiomdl/v1support.cpp b/utils/studiomdl/v1support.cpp
new file mode 100644
index 0000000..a6ac369
--- /dev/null
+++ b/utils/studiomdl/v1support.cpp
@@ -0,0 +1,393 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//=============================================================================//
+
+//
+// studiomdl.c: generates a studio .mdl file from a .qc script
+// sources/<scriptname>.mdl.
+//
+
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <math.h>
+
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+
+// The current version of the SMD file being parsed
+// Yes, I know this file is called 'v1support' and there's never actually
+// been a v > 1 but now there is
+// (actually, there was a while when we were using developing progressive mesh 
+// stuff in the middle of HL2 development, but most all that code has long since 
+// been deleted)
+int g_smdVersion = 1;
+
+int lookup_index( s_source_t *psource, int material, Vector& vertex, Vector& normal, Vector2D texcoord, int iCount, int bones[], float weights[] )
+{
+	int i, j;
+
+	for (i = 0; i < numvlist; i++) 
+	{
+		if (v_listdata[i].m == material
+			&& DotProduct( g_normal[i], normal ) > normal_blend
+			&& VectorCompare( g_vertex[i], vertex )
+			&& g_texcoord[i][0] == texcoord[0]
+			&& g_texcoord[i][1] == texcoord[1])
+		{
+			if (g_bone[i].numbones == iCount)
+			{
+				for (j = 0; j < iCount; j++)
+				{
+					if (g_bone[i].bone[j] != bones[j] || g_bone[i].weight[j] != weights[j])
+						break;
+				}
+				if (j == iCount)
+				{
+					v_listdata[i].lastref = numvlist;
+					return i;
+				}
+			}
+		}
+	}
+	if (i >= MAXSTUDIOVERTS) {
+		MdlError( "too many indices in source: \"%s\"\n", psource->filename);
+	}
+
+	VectorCopy( vertex, g_vertex[i] );
+	VectorCopy( normal, g_normal[i] );
+	Vector2Copy( texcoord, g_texcoord[i] );
+
+    g_bone[i].numbones = iCount;
+	for ( j = 0; j < iCount; j++)
+	{
+		g_bone[i].bone[j] = bones[j];
+		g_bone[i].weight[j] = weights[j];
+	}
+
+	v_listdata[i].v = i;
+	v_listdata[i].m = material;
+	v_listdata[i].n = i;
+	v_listdata[i].t = i;
+
+	v_listdata[i].firstref = numvlist;
+	v_listdata[i].lastref = numvlist;
+
+	numvlist = i + 1;
+	return i;
+}
+
+
+void ParseFaceData( s_source_t *psource, int material, s_face_t *pFace )
+{
+	int index[3] = {};
+	int i, j;
+	Vector p;
+	Vector normal;
+	Vector2D t;
+	int		iCount, bones[MAXSTUDIOSRCBONES];
+	float   weights[MAXSTUDIOSRCBONES];
+	int bone;
+
+	for (j = 0; j < 3; j++) 
+	{
+		memset( g_szLine, 0, sizeof( g_szLine ) );
+
+		if (!GetLineInput()) 
+		{
+			MdlError("%s: error on g_szLine %d: %s", g_szFilename, g_iLinecount, g_szLine );
+		}
+
+		iCount = 0;
+
+		i = sscanf( g_szLine, "%d %f %f %f %f %f %f %f %f %d %d %f %d %f %d %f %d %f",
+			&bone, 
+			&p[0], &p[1], &p[2], 
+			&normal[0], &normal[1], &normal[2], 
+			&t[0], &t[1],
+			&iCount,
+			&bones[0], &weights[0], &bones[1], &weights[1], &bones[2], &weights[2], &bones[3], &weights[3] );
+			
+		if (i < 9) 
+			continue;
+
+		if (bone < 0 || bone >= psource->numbones) 
+		{
+			MdlError("bogus bone index\n%d %s :\n%s", g_iLinecount, g_szFilename, g_szLine );
+		}
+
+		//Scale face pos
+		scale_vertex( p );
+		
+		// continue parsing more bones.
+		// FIXME: don't we have a built in parser that'll do this?
+		if (iCount > 4)
+		{
+			int k;
+			int ctr = 0;
+			char *token;
+			for (k = 0; k < 18; k++)
+			{
+				while (g_szLine[ctr] == ' ')
+				{
+					ctr++;
+				}
+				token = strtok( &g_szLine[ctr], " " );
+				ctr += strlen( token ) + 1;
+			}
+			for (k = 4; k < iCount && k < MAXSTUDIOSRCBONES; k++)
+			{
+				while (g_szLine[ctr] == ' ')
+				{
+					ctr++;
+				}
+				token = strtok( &g_szLine[ctr], " " );
+				ctr += strlen( token ) + 1;
+
+				bones[k] = atoi(token);
+
+				token = strtok( &g_szLine[ctr], " " );
+				ctr += strlen( token ) + 1;
+			
+				weights[k] = atof(token);
+			}
+			// printf("%d ", iCount );
+
+			//printf("\n");
+			//exit(1);
+		}
+
+		// adjust_vertex( p );
+		// scale_vertex( p );
+
+		// move vertex position to object space.
+		// VectorSubtract( p, psource->bonefixup[bone].worldorg, tmp );
+		// VectorTransform(tmp, psource->bonefixup[bone].im, p );
+
+		// move normal to object space.
+		// VectorCopy( normal, tmp );
+		// VectorTransform(tmp, psource->bonefixup[bone].im, normal );
+		// VectorNormalize( normal );
+
+		// invert v
+		t[1] = 1.0 - t[1];
+
+		if (i == 9 || iCount == 0)
+		{
+			iCount = 1;
+			bones[0] = bone;
+			weights[0] = 1.0;
+		}
+		else
+		{
+			iCount = SortAndBalanceBones( iCount, MAXSTUDIOBONEWEIGHTS, bones, weights );
+		}
+
+
+		index[j] = lookup_index( psource, material, p, normal, t, iCount, bones, weights );
+	}
+
+	// pFace->material = material; // BUG
+	pFace->a		= index[0];
+	pFace->b		= index[2];
+	pFace->c		= index[1];
+	Assert( ((pFace->a & 0xF0000000) == 0) && ((pFace->b & 0xF0000000) == 0) && 
+		((pFace->c & 0xF0000000) == 0) );
+}
+
+void Grab_Triangles( s_source_t *psource )
+{
+	int		i;
+	Vector	vmin, vmax;
+
+	vmin[0] = vmin[1] = vmin[2] = 99999;
+	vmax[0] = vmax[1] = vmax[2] = -99999;
+
+	g_numfaces = 0;
+	numvlist = 0;
+ 
+	//
+	// load the base triangles
+	//
+	int texture;
+	int material;
+	char texturename[MAX_PATH];
+
+	while (1) 
+	{
+		if (!GetLineInput()) 
+			break;
+
+		// check for end
+		if (IsEnd( g_szLine )) 
+			break;
+
+		// Look for extra junk that we may want to avoid...
+		int nLineLength = strlen( g_szLine );
+		if (nLineLength >= sizeof( texturename ))
+		{
+			MdlWarning("Unexpected data at line %d, (need a texture name) ignoring...\n", g_iLinecount );
+			continue;
+		}
+
+		// strip off trailing smag
+		V_strcpy_safe( texturename, g_szLine );
+		for (i = strlen( texturename ) - 1; i >= 0 && ! V_isgraph( texturename[i] ); i--)
+		{
+		}
+		texturename[i + 1] = '\0';
+
+		// funky texture overrides
+		for (i = 0; i < numrep; i++)  
+		{
+			if (sourcetexture[i][0] == '\0') 
+			{
+				V_strcpy_safe( texturename, defaulttexture[i] );
+				break;
+			}
+			if (stricmp( texturename, sourcetexture[i]) == 0) 
+			{
+				V_strcpy_safe( texturename, defaulttexture[i] );
+				break;
+			}
+		}
+
+		if (texturename[0] == '\0')
+		{
+			// weird source problem, skip them
+			GetLineInput();
+			GetLineInput();
+			GetLineInput();
+			continue;
+		}
+
+		if (stricmp( texturename, "null.bmp") == 0 || stricmp( texturename, "null.tga") == 0 || stricmp( texturename, "debug/debugempty" ) == 0)
+		{
+			// skip all faces with the null texture on them.
+			GetLineInput();
+			GetLineInput();
+			GetLineInput();
+			continue;
+		}
+
+		texture = LookupTexture( texturename, ( g_smdVersion > 1 ) );
+		psource->texmap[texture] = texture;	// hack, make it 1:1
+		material = UseTextureAsMaterial( texture );
+
+		s_face_t f;
+		ParseFaceData( psource, material, &f );
+
+		// remove degenerate triangles
+		if (f.a == f.b || f.b == f.c || f.a == f.c)
+		{
+			// printf("Degenerate triangle %d %d %d\n", f.a, f.b, f.c );
+			continue;
+		}
+	
+		g_src_uface[g_numfaces] = f;
+		g_face[g_numfaces].material = material;
+		g_numfaces++;
+	}
+
+	BuildIndividualMeshes( psource );
+}
+
+
+int Load_SMD ( s_source_t *psource )
+{
+	char	cmd[1024];
+	int		option;
+
+	// Reset smdVersion
+	g_smdVersion = 1;
+
+	if (!OpenGlobalFile( psource->filename ))
+		return 0;
+
+	if( !g_quiet )
+	{
+		printf ("SMD MODEL %s\n", psource->filename);
+	}
+
+	g_iLinecount = 0;
+
+	while (GetLineInput()) 
+	{
+		int numRead = sscanf( g_szLine, "%s %d", cmd, &option );
+
+		// Blank line
+		if ((numRead == EOF) || (numRead == 0))
+			continue;
+
+		if (stricmp( cmd, "version" ) == 0) 
+		{
+			if (option < 1 || option > 2) 
+			{
+				MdlError("bad version\n");
+			}
+			g_smdVersion = option;
+		}
+		else if (stricmp( cmd, "nodes" ) == 0) 
+		{
+			psource->numbones = Grab_Nodes( psource->localBone );
+		}
+		else if (stricmp( cmd, "skeleton" ) == 0) 
+		{
+			Grab_Animation( psource, "BindPose" );
+		}
+		else if (stricmp( cmd, "triangles" ) == 0) 
+		{
+			Grab_Triangles( psource );
+		}
+		else if (stricmp( cmd, "vertexanimation" ) == 0) 
+		{
+			Grab_Vertexanimation( psource, "BindPose" );
+		}
+		else if ((strncmp( cmd, "//", 2 ) == 0) || (strncmp( cmd, ";", 1 ) == 0) || (strncmp( cmd, "#", 1 ) == 0))
+		{
+			ProcessSourceComment( psource, cmd );
+			continue;
+		}
+		else 
+		{
+			MdlWarning("unknown studio command \"%s\"\n", cmd );
+		}
+	}
+	fclose( g_fpInput );
+
+	return 1;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/utils/studiomdl/write.cpp b/utils/studiomdl/write.cpp
new file mode 100644
index 0000000..d3867f4
--- /dev/null
+++ b/utils/studiomdl/write.cpp
@@ -0,0 +1,4586 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+//
+// write.c: writes a studio .mdl file
+//
+
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4237 )
+#pragma warning( disable : 4305 )
+
+
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <limits.h>
+
+#include "cmdlib.h"
+#include "scriplib.h"
+#include "mathlib/mathlib.h"
+#include "studio.h"
+#include "studiomdl.h"
+#include "collisionmodel.h"
+#include "optimize.h"
+#include "studiobyteswap.h"
+#include "byteswap.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "mdlobjects/dmeboneflexdriver.h"
+#include "perfstats.h"
+
+#include "tier1/smartptr.h"
+#include "tier2/p4helpers.h"
+
+int totalframes = 0;
+float totalseconds = 0;
+extern int numcommandnodes;
+
+// WriteFile is the only externally visible function in this file.
+// pData points to the current location in an output buffer and pStart is
+// the beginning of the buffer.
+
+bool FixupToSortedLODVertexes( studiohdr_t *pStudioHdr );
+bool Clamp_RootLOD(  studiohdr_t *phdr );
+static void WriteAllSwappedFiles( const char *filename );
+
+/*
+============
+WriteModel
+============
+*/
+
+static byte *pData;
+static byte *pStart;
+static byte *pBlockData;
+static byte *pBlockStart;
+
+#undef ALIGN4
+#undef ALIGN16
+#undef ALIGN32
+#define ALIGN4( a ) a = (byte *)((int)((byte *)a + 3) & ~ 3)
+#define ALIGN16( a ) a = (byte *)((int)((byte *)a + 15) & ~ 15)
+#define ALIGN32( a ) a = (byte *)((int)((byte *)a + 31) & ~ 31)
+#define ALIGN64( a ) a = (byte *)((int)((byte *)a + 63) & ~ 63)
+#define ALIGN512( a ) a = (byte *)((int)((byte *)a + 511) & ~ 511)
+// make sure kalloc aligns to maximum alignment size
+
+#define FILEBUFFER (8 * 1024 * 1024)
+
+void WriteSeqKeyValues( mstudioseqdesc_t *pseqdesc, CUtlVector< char > *pKeyValue );
+
+//-----------------------------------------------------------------------------
+// Purpose: stringtable is a session global string table.
+//-----------------------------------------------------------------------------
+
+struct stringtable_t
+{
+	byte	*base;
+	int		*ptr;
+	const char	*string;
+	int		dupindex;
+	byte	*addr;
+};
+
+static int numStrings;
+static stringtable_t strings[32768];
+
+static void BeginStringTable(  )
+{
+	strings[0].base = NULL;
+	strings[0].ptr = NULL;
+	strings[0].string = "";
+	strings[0].dupindex = -1;
+	numStrings = 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: add a string to the file-global string table.
+//			Keep track of fixup locations
+//-----------------------------------------------------------------------------
+static void AddToStringTable( void *base, int *ptr, const char *string )
+{
+	for (int i = 0; i < numStrings; i++)
+	{
+		if (!string || !strcmp( string, strings[i].string ))
+		{
+			strings[numStrings].base = (byte *)base;
+			strings[numStrings].ptr = ptr;
+			strings[numStrings].string = string;
+			strings[numStrings].dupindex = i;
+			numStrings++;
+			return;
+		}
+	}
+
+	strings[numStrings].base = (byte *)base;
+	strings[numStrings].ptr = ptr;
+	strings[numStrings].string = string;
+	strings[numStrings].dupindex = -1;
+	numStrings++;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Write out stringtable
+//			fixup local pointers
+//-----------------------------------------------------------------------------
+static byte *WriteStringTable( byte *pData )
+{
+	// force null at first address
+	strings[0].addr = pData;
+	*pData = '\0';
+	pData++;
+
+	// save all the rest
+	for (int i = 1; i < numStrings; i++)
+	{
+		if (strings[i].dupindex == -1)
+		{
+			// not in table yet
+			// calc offset relative to local base
+			*strings[i].ptr = pData - strings[i].base;
+			// keep track of address in case of duplication
+			strings[i].addr = pData;
+			// copy string data, add a terminating \0
+			strcpy( (char *)pData, strings[i].string );
+			pData += strlen( strings[i].string );
+			*pData = '\0';
+			pData++;
+		}
+		else
+		{
+			// already in table, calc offset of existing string relative to local base
+			*strings[i].ptr = strings[strings[i].dupindex].addr - strings[i].base;
+		}
+	}
+	ALIGN4( pData );
+	return pData;
+}
+
+
+// compare function for qsort below
+static int BoneNameCompare( const void *elem1, const void *elem2 )
+{
+	int index1 = *(byte *)elem1;
+	int index2 = *(byte *)elem2;
+
+	// compare bones by name
+	return strcmpi( g_bonetable[index1].name, g_bonetable[index2].name );
+}
+
+
+static void WriteBoneInfo( studiohdr_t *phdr )
+{
+	int i, j, k;
+	mstudiobone_t *pbone;
+	mstudiobonecontroller_t *pbonecontroller;
+	mstudioattachment_t *pattachment;
+	mstudiobbox_t *pbbox;
+
+	// save bone info
+	pbone = (mstudiobone_t *)pData;
+	phdr->numbones = g_numbones;
+	phdr->boneindex = pData - pStart;
+
+	char* pSurfacePropName = GetDefaultSurfaceProp( );
+	AddToStringTable( phdr, &phdr->surfacepropindex, pSurfacePropName );
+	phdr->contents = GetDefaultContents();
+
+	for (i = 0; i < g_numbones; i++) 
+	{
+		AddToStringTable( &pbone[i], &pbone[i].sznameindex, g_bonetable[i].name );
+		pbone[i].parent			= g_bonetable[i].parent;
+		pbone[i].flags			= g_bonetable[i].flags;
+		pbone[i].procindex		= 0;
+		pbone[i].physicsbone	= g_bonetable[i].physicsBoneIndex;
+		pbone[i].pos			= g_bonetable[i].pos;
+		pbone[i].rot			= g_bonetable[i].rot;
+		pbone[i].posscale		= g_bonetable[i].posscale;
+		pbone[i].rotscale		= g_bonetable[i].rotscale;
+		MatrixInvert( g_bonetable[i].boneToPose, pbone[i].poseToBone );
+		pbone[i].qAlignment		= g_bonetable[i].qAlignment;
+
+		AngleQuaternion( RadianEuler( g_bonetable[i].rot[0], g_bonetable[i].rot[1], g_bonetable[i].rot[2] ), pbone[i].quat );
+		QuaternionAlign( pbone[i].qAlignment, pbone[i].quat, pbone[i].quat );
+
+		pSurfacePropName = GetSurfaceProp( g_bonetable[i].name );
+		AddToStringTable( &pbone[i], &pbone[i].surfacepropidx, pSurfacePropName );
+		pbone[i].contents = GetContents( g_bonetable[i].name );
+	}
+
+	pData += g_numbones * sizeof( mstudiobone_t );
+	ALIGN4( pData );
+
+	// save procedural bone info
+	if (g_numaxisinterpbones)
+	{
+		mstudioaxisinterpbone_t *pProc = (mstudioaxisinterpbone_t *)pData;
+		for (i = 0; i < g_numaxisinterpbones; i++)
+		{
+			j = g_axisinterpbonemap[i];
+			k = g_axisinterpbones[j].bone;
+			pbone[k].procindex		= (byte *)&pProc[i] - (byte *)&pbone[k];
+			pbone[k].proctype		= STUDIO_PROC_AXISINTERP;
+			// printf("bone %d %d\n", j, pbone[k].procindex );
+			pProc[i].control		= g_axisinterpbones[j].control;
+			pProc[i].axis			= g_axisinterpbones[j].axis;
+			for (k = 0; k < 6; k++)
+			{
+				VectorCopy( g_axisinterpbones[j].pos[k], pProc[i].pos[k] );
+				pProc[i].quat[k] = g_axisinterpbones[j].quat[k];
+			}
+		}
+		pData += g_numaxisinterpbones * sizeof( mstudioaxisinterpbone_t );
+		ALIGN4( pData );
+	}
+
+	if (g_numquatinterpbones)
+	{
+		mstudioquatinterpbone_t *pProc = (mstudioquatinterpbone_t *)pData;
+		pData += g_numquatinterpbones * sizeof( mstudioquatinterpbone_t );
+		ALIGN4( pData );
+
+		for (i = 0; i < g_numquatinterpbones; i++)
+		{
+			j = g_quatinterpbonemap[i];
+			k = g_quatinterpbones[j].bone;
+			pbone[k].procindex		= (byte *)&pProc[i] - (byte *)&pbone[k];
+			pbone[k].proctype		= STUDIO_PROC_QUATINTERP;
+			// printf("bone %d %d\n", j, pbone[k].procindex );
+			pProc[i].control		= g_quatinterpbones[j].control;
+
+			mstudioquatinterpinfo_t *pTrigger = (mstudioquatinterpinfo_t *)pData;
+			pProc[i].numtriggers	= g_quatinterpbones[j].numtriggers;
+			pProc[i].triggerindex	= (byte *)pTrigger - (byte *)&pProc[i];
+			pData += pProc[i].numtriggers * sizeof( mstudioquatinterpinfo_t );
+
+			for (k = 0; k < pProc[i].numtriggers; k++)
+			{
+				pTrigger[k].inv_tolerance	= 1.0 / g_quatinterpbones[j].tolerance[k];
+				pTrigger[k].trigger		= g_quatinterpbones[j].trigger[k];
+				pTrigger[k].pos			= g_quatinterpbones[j].pos[k];
+				pTrigger[k].quat		= g_quatinterpbones[j].quat[k];
+			}
+		}
+	}
+
+	if (g_numjigglebones)
+	{
+		mstudiojigglebone_t *jiggleInfo = (mstudiojigglebone_t *)pData;
+		
+		for (i = 0; i < g_numjigglebones; i++)
+		{
+			j = g_jigglebonemap[i];
+			k = g_jigglebones[j].bone;
+			pbone[k].procindex		= (byte *)&jiggleInfo[i] - (byte *)&pbone[k];
+			pbone[k].proctype		= STUDIO_PROC_JIGGLE;
+			
+			jiggleInfo[i] = g_jigglebones[j].data;
+		}
+		pData += g_numjigglebones * sizeof( mstudiojigglebone_t );
+		ALIGN4( pData );
+	}
+
+	// write aim at bones
+	if (g_numaimatbones)
+	{
+		mstudioaimatbone_t *pProc = (mstudioaimatbone_t *)pData;
+		for (i = 0; i < g_numaimatbones; i++)
+		{
+			j = g_aimatbonemap[i];
+			k = g_aimatbones[j].bone;
+			pbone[k].procindex		= (byte *)&pProc[i] - (byte *)&pbone[k];
+			pbone[k].proctype		= g_aimatbones[j].aimAttach == -1 ? STUDIO_PROC_AIMATBONE : STUDIO_PROC_AIMATATTACH;
+			pProc[i].parent			= g_aimatbones[j].parent;
+			pProc[i].aim			= g_aimatbones[j].aimAttach == -1 ? g_aimatbones[j].aimBone : g_aimatbones[j].aimAttach;
+			pProc[i].aimvector		= g_aimatbones[j].aimvector;
+			pProc[i].upvector		= g_aimatbones[j].upvector;
+			pProc[i].basepos		= g_aimatbones[j].basepos;
+		}
+		pData += g_numaimatbones * sizeof( mstudioaimatbone_t );
+		ALIGN4( pData );
+	}
+
+	// map g_bonecontroller to bones
+	for (i = 0; i < g_numbones; i++) 
+	{
+		for (j = 0; j < 6; j++)	
+		{
+			pbone[i].bonecontroller[j] = -1;
+		}
+	}
+	
+	for (i = 0; i < g_numbonecontrollers; i++) 
+	{
+		j = g_bonecontroller[i].bone;
+		switch( g_bonecontroller[i].type & STUDIO_TYPES )
+		{
+		case STUDIO_X:
+			pbone[j].bonecontroller[0] = i;
+			break;
+		case STUDIO_Y:
+			pbone[j].bonecontroller[1] = i;
+			break;
+		case STUDIO_Z:
+			pbone[j].bonecontroller[2] = i;
+			break;
+		case STUDIO_XR:
+			pbone[j].bonecontroller[3] = i;
+			break;
+		case STUDIO_YR:
+			pbone[j].bonecontroller[4] = i;
+			break;
+		case STUDIO_ZR:
+			pbone[j].bonecontroller[5] = i;
+			break;
+		default:
+			MdlError("unknown g_bonecontroller type\n");
+		}
+	}
+
+	// save g_bonecontroller info
+	pbonecontroller = (mstudiobonecontroller_t *)pData;
+	phdr->numbonecontrollers = g_numbonecontrollers;
+	phdr->bonecontrollerindex = pData - pStart;
+
+	for (i = 0; i < g_numbonecontrollers; i++) 
+	{
+		pbonecontroller[i].bone			= g_bonecontroller[i].bone;
+		pbonecontroller[i].inputfield	= g_bonecontroller[i].inputfield;
+		pbonecontroller[i].type			= g_bonecontroller[i].type;
+		pbonecontroller[i].start		= g_bonecontroller[i].start;
+		pbonecontroller[i].end			= g_bonecontroller[i].end;
+	}
+	pData += g_numbonecontrollers * sizeof( mstudiobonecontroller_t );
+	ALIGN4( pData );
+
+	// save attachment info
+	pattachment = (mstudioattachment_t *)pData;
+	phdr->numlocalattachments = g_numattachments;
+	phdr->localattachmentindex = pData - pStart;
+
+	for (i = 0; i < g_numattachments; i++) 
+	{
+		pattachment[i].localbone			= g_attachment[i].bone;
+		AddToStringTable( &pattachment[i], &pattachment[i].sznameindex, g_attachment[i].name );
+		MatrixCopy( g_attachment[i].local, pattachment[i].local );
+		pattachment[i].flags = g_attachment[i].flags;
+	}
+	pData += g_numattachments * sizeof( mstudioattachment_t );
+	ALIGN4( pData );
+	
+	// save hitbox sets
+	phdr->numhitboxsets = g_hitboxsets.Size();
+
+	// Remember start spot
+	mstudiohitboxset_t *hitboxset = (mstudiohitboxset_t *)pData;
+	phdr->hitboxsetindex = pData - pStart;
+
+	pData += phdr->numhitboxsets * sizeof( mstudiohitboxset_t );
+	ALIGN4( pData );
+
+	for ( int s = 0; s < g_hitboxsets.Size(); s++, hitboxset++ )
+	{
+		s_hitboxset *set = &g_hitboxsets[ s ];
+
+		AddToStringTable( hitboxset, &hitboxset->sznameindex, set->hitboxsetname );
+
+		hitboxset->numhitboxes = set->numhitboxes;
+		hitboxset->hitboxindex = ( pData - (byte *)hitboxset );
+
+		// save bbox info
+		pbbox = (mstudiobbox_t *)pData;
+		for (i = 0; i < hitboxset->numhitboxes; i++) 
+		{
+			pbbox[i].bone				= set->hitbox[i].bone;
+			pbbox[i].group				= set->hitbox[i].group;
+			VectorCopy( set->hitbox[i].bmin, pbbox[i].bbmin );
+			VectorCopy( set->hitbox[i].bmax, pbbox[i].bbmax );
+			pbbox[i].szhitboxnameindex = 0;
+			AddToStringTable( &(pbbox[i]), &(pbbox[i].szhitboxnameindex), set->hitbox[i].hitboxname );	
+		}
+
+		pData += hitboxset->numhitboxes * sizeof( mstudiobbox_t );
+		ALIGN4( pData );
+	}
+	byte *pBoneTable = pData;
+	phdr->bonetablebynameindex = (pData - pStart);
+
+	// make a table in bone order and sort it with qsort
+	for ( i = 0; i < phdr->numbones; i++ )
+	{
+		pBoneTable[i] = i;
+	}
+	qsort( pBoneTable, phdr->numbones, sizeof(byte), BoneNameCompare );
+	pData += phdr->numbones * sizeof( byte );
+	ALIGN4( pData );
+}
+
+// load a preexisting model to remember its sequence names and indices
+CUtlVector< CUtlString > g_vecPreexistingSequences;
+void LoadPreexistingSequenceOrder( const char *pFilename )
+{
+	g_vecPreexistingSequences.RemoveAll();
+
+	if ( !FileExists( pFilename ) )
+		return;
+
+	Msg( "Loading preexisting model: %s\n", pFilename );
+
+	studiohdr_t *pStudioHdr;
+	int len = LoadFile((char*)pFilename, (void **)&pStudioHdr);
+
+	if ( len && pStudioHdr && pStudioHdr->SequencesAvailable() )
+	{
+		Msg( "   Found %i preexisting sequences.\n", pStudioHdr->GetNumSeq() );
+
+		for ( int i=0; i<pStudioHdr->GetNumSeq(); i++ )
+		{
+			//Msg( "   Sequence %i : \"%s\"\n", i, pStudioHdr->pSeqdesc(i).pszLabel() );
+			g_vecPreexistingSequences.AddToTail( pStudioHdr->pSeqdesc(i).pszLabel() );
+		}
+	}
+	else
+	{
+		MdlWarning( "Zero-size file or no sequences.\n" );
+	}
+}
+
+static void WriteSequenceInfo( studiohdr_t *phdr )
+{
+	int i, j, k;
+
+	mstudioseqdesc_t	*pseqdesc;
+	mstudioseqdesc_t	*pbaseseqdesc;
+	mstudioevent_t		*pevent;
+	byte				*ptransition;
+
+	// write models to disk with this flag set false. This will force
+	// the sequences to be indexed by activity whenever the g_model is loaded
+	// from disk.
+	phdr->activitylistversion = 0;
+	phdr->eventsindexed = 0;
+
+	// save g_sequence info
+	pseqdesc = (mstudioseqdesc_t *)pData;
+	pbaseseqdesc = pseqdesc;
+	phdr->numlocalseq = g_sequence.Count();
+	phdr->localseqindex = (pData - pStart);
+	pData += g_sequence.Count() * sizeof( mstudioseqdesc_t );
+
+	bool bErrors = false;
+
+
+	// build a table to remap new sequence indices to match the preexisting model
+	bool bUseSeqOrderRemapping = false;
+	int nSeqOrderRemappingTable[MAXSTUDIOSEQUENCES];
+	for (i=0; i<MAXSTUDIOSEQUENCES; i++)
+		nSeqOrderRemappingTable[i] = -1;
+
+	bool bAllowSequenceRemoval = false;
+
+	if ( g_vecPreexistingSequences.Count() )
+	{
+
+		if ( g_sequence.Count() < g_vecPreexistingSequences.Count() && !bAllowSequenceRemoval )
+		{
+			Msg( "\n" );
+			MdlWarning( "This model has fewer sequences than its predecessor.\nPlease confirm sequence deletion: [y/n] " );
+			int nInput = 0;
+			do { nInput = getchar(); } while ( nInput != 121 /* y */ && nInput != 110 /* n */ );
+
+			if ( nInput == 110 )
+			{
+				MdlError( "Model contains fewer sequences than its predecessor!\n" );
+			}
+			else if ( nInput == 121 )
+			{
+				bAllowSequenceRemoval = true;
+			}
+		}
+
+		{
+			Msg( "Building sequence index remapping table...\n" );
+			
+			CUtlVector<int> vecNewIndices;
+			vecNewIndices.RemoveAll();
+
+			// map current sequences to their old indices
+			for (i = 0; i < g_sequence.Count(); i++ )
+			{
+				int nIdx = g_vecPreexistingSequences.Find( g_sequence[i].name );
+				if ( nIdx >= 0 )
+				{
+					nSeqOrderRemappingTable[nIdx] = i;
+				}
+				else
+				{
+					if ( i < g_vecPreexistingSequences.Count() )
+					{
+						Msg( "  Found new sequence \"%s\" using index of old sequence \"%s\".\n", g_sequence[i].name, g_vecPreexistingSequences[i].String() );
+					}
+					else
+					{
+						Msg( "  Found new sequence \"%s\".\n", g_sequence[i].name );
+					}
+					
+					vecNewIndices.AddToTail(i);
+				}
+			}
+
+			// slot new sequences into unused indices
+			while ( vecNewIndices.Count() )
+			{
+				for (i = 0; i < MAXSTUDIOSEQUENCES; i++ )
+				{
+					if ( nSeqOrderRemappingTable[i] == -1 )
+					{
+						nSeqOrderRemappingTable[i] = vecNewIndices[0];
+						vecNewIndices.Remove(0);
+						break;
+					}
+				}
+			}
+
+			// verify no indices are undefined
+			for (i = 0; i < g_sequence.Count(); i++ )
+			{
+				if ( nSeqOrderRemappingTable[i] == -1 )
+				{
+					if ( bAllowSequenceRemoval )
+					{
+						do
+						{
+							for ( int nB=i; nB<g_vecPreexistingSequences.Count(); nB++ )
+							{
+								nSeqOrderRemappingTable[nB] = nSeqOrderRemappingTable[nB+1];
+							}
+						}
+						while (nSeqOrderRemappingTable[i] == -1);
+					}
+					else
+					{
+						MdlError( "Failed to reorder sequence indices.\n" );
+					}
+
+				}
+				else if ( nSeqOrderRemappingTable[i] != i )
+				{
+					bUseSeqOrderRemapping = true;
+				}
+			}
+
+			if ( bUseSeqOrderRemapping )
+			{
+				Msg( "Sequence indices need re-ordering.\n" );
+			}
+			else
+			{
+				Msg( "No re-ordering required.\n" );
+			}
+		}
+	}	
+
+	// build an inverted remapping table so autolayer sequence indices can find their sources later
+	int nSeqOrderRemappingTableInv[MAXSTUDIOSEQUENCES];
+	if ( bUseSeqOrderRemapping )
+	{
+		for (i=0; i<MAXSTUDIOSEQUENCES; i++)
+			nSeqOrderRemappingTableInv[nSeqOrderRemappingTable[i]] = i;
+	}
+	
+	int m;
+	for (m = 0; m < g_sequence.Count(); m++, pseqdesc++) 
+	{
+
+		if ( bUseSeqOrderRemapping )
+		{
+			i = nSeqOrderRemappingTable[m];
+			if ( i != m )
+			{
+				Msg( "   Remapping sequence %i to index %i (%s) to retain existing order.\n", i, m, g_sequence[i].name );
+			}
+		}
+		else
+		{
+			i = m;
+		}
+
+		byte *pSequenceStart = (byte *)pseqdesc;
+
+		AddToStringTable( pseqdesc, &pseqdesc->szlabelindex, g_sequence[i].name );
+		AddToStringTable( pseqdesc, &pseqdesc->szactivitynameindex, g_sequence[i].activityname );
+
+		pseqdesc->baseptr		= pStart - (byte *)pseqdesc;
+
+		pseqdesc->flags			= g_sequence[i].flags;
+
+		pseqdesc->numblends		= g_sequence[i].numblends;
+		pseqdesc->groupsize[0]	= g_sequence[i].groupsize[0];
+		pseqdesc->groupsize[1]	= g_sequence[i].groupsize[1];
+
+		pseqdesc->paramindex[0]	= g_sequence[i].paramindex[0];
+		pseqdesc->paramstart[0] = g_sequence[i].paramstart[0];
+		pseqdesc->paramend[0]	= g_sequence[i].paramend[0];
+		pseqdesc->paramindex[1]	= g_sequence[i].paramindex[1];
+		pseqdesc->paramstart[1] = g_sequence[i].paramstart[1];
+		pseqdesc->paramend[1]	= g_sequence[i].paramend[1];
+
+		if (g_sequence[i].groupsize[0] > 1 || g_sequence[i].groupsize[1] > 1)
+		{
+			// save posekey values
+			float *pposekey			= (float *)pData;
+			pseqdesc->posekeyindex	= (pData - pSequenceStart);
+			pData += (pseqdesc->groupsize[0] + pseqdesc->groupsize[1]) * sizeof( float );
+			for (j = 0; j < pseqdesc->groupsize[0]; j++)
+			{
+				*(pposekey++) = g_sequence[i].param0[j];
+				// printf("%.2f ", g_sequence[i].param0[j] );
+			}
+			for (j = 0; j < pseqdesc->groupsize[1]; j++)
+			{
+				*(pposekey++) = g_sequence[i].param1[j];
+				// printf("%.2f ", g_sequence[i].param1[j] );
+			}
+			// printf("\n" );
+		}
+
+		// pseqdesc->motiontype	= g_sequence[i].motiontype;
+		// pseqdesc->motionbone	= 0; // g_sequence[i].motionbone;
+		// VectorCopy( g_sequence[i].linearmovement, pseqdesc->linearmovement );
+
+		pseqdesc->activity		= g_sequence[i].activity;
+		pseqdesc->actweight		= g_sequence[i].actweight;
+
+		pseqdesc->bbmin			= g_sequence[i].bmin;
+		pseqdesc->bbmax			= g_sequence[i].bmax;
+
+		pseqdesc->fadeintime	= g_sequence[i].fadeintime;
+		pseqdesc->fadeouttime	= g_sequence[i].fadeouttime;
+
+		pseqdesc->localentrynode	= g_sequence[i].entrynode; 
+		pseqdesc->localexitnode		= g_sequence[i].exitnode;
+		//pseqdesc->entryphase	= g_sequence[i].entryphase;
+		//pseqdesc->exitphase		= g_sequence[i].exitphase;
+		pseqdesc->nodeflags		= g_sequence[i].nodeflags;
+
+		// save events
+		pevent					= (mstudioevent_t *)pData;
+		pseqdesc->numevents		= g_sequence[i].numevents;
+		pseqdesc->eventindex	= (pData - pSequenceStart);
+		pData += pseqdesc->numevents * sizeof( mstudioevent_t );
+		for (j = 0; j < g_sequence[i].numevents; j++)
+		{
+			k = g_sequence[i].panim[0][0]->numframes - 1;
+
+			if (g_sequence[i].event[j].frame <= k)
+				pevent[j].cycle		= g_sequence[i].event[j].frame / ((float)k);
+			else if (k == 0 && g_sequence[i].event[j].frame == 0)
+				pevent[j].cycle		= 0;
+			else
+			{
+				MdlWarning("Event %d (frame %d) out of range in %s\n", g_sequence[i].event[j].event, g_sequence[i].event[j].frame, g_sequence[i].name );
+				bErrors = true;
+			}
+
+			//Adrian - Remove me once we phase out the old event system.
+			if ( V_isdigit( g_sequence[i].event[j].eventname[0] ) )
+			{
+				 pevent[j].event = atoi( g_sequence[i].event[j].eventname );
+				 pevent[j].type = 0;
+				 pevent[j].szeventindex = 0;
+			}
+			else
+			{
+				 AddToStringTable( &pevent[j], &pevent[j].szeventindex, g_sequence[i].event[j].eventname );
+				 pevent[j].type = NEW_EVENT_STYLE;
+			}
+				 						
+			
+			// printf("%4d : %d %f\n", pevent[j].event, g_sequence[i].event[j].frame, pevent[j].cycle );
+			// AddToStringTable( &pevent[j], &pevent[j].szoptionindex, g_sequence[i].event[j].options );
+			strcpy( pevent[j].options, g_sequence[i].event[j].options );
+		}
+		ALIGN4( pData );
+
+		// save ikrules
+		pseqdesc->numikrules	= g_sequence[i].numikrules;
+
+		// save autolayers
+		mstudioautolayer_t *pautolayer			= (mstudioautolayer_t *)pData;
+		pseqdesc->numautolayers	= g_sequence[i].numautolayers;
+		pseqdesc->autolayerindex = (pData - pSequenceStart);
+		pData += pseqdesc->numautolayers * sizeof( mstudioautolayer_t );
+		for (j = 0; j < g_sequence[i].numautolayers; j++)
+		{
+			pautolayer[j].iSequence = g_sequence[i].autolayer[j].sequence;
+			pautolayer[j].iPose		= g_sequence[i].autolayer[j].pose;
+			pautolayer[j].flags		= g_sequence[i].autolayer[j].flags;
+
+			// autolayer indices are stored by index, so remap them now using the invertex lookup table
+			if ( bUseSeqOrderRemapping )
+			{
+				int nRemapAutoLayer = nSeqOrderRemappingTableInv[ pautolayer[j].iSequence ];
+				if ( nRemapAutoLayer != pautolayer[j].iSequence )
+				{
+					Msg( "       Autolayer remapping index %i to %i.\n", pautolayer[j].iSequence, nRemapAutoLayer );
+					pautolayer[j].iSequence = nRemapAutoLayer;
+				}
+			}
+
+			if (!(pautolayer[j].flags & STUDIO_AL_POSE))
+			{
+				pautolayer[j].start		= g_sequence[i].autolayer[j].start / (g_sequence[i].panim[0][0]->numframes - 1);
+				pautolayer[j].peak		= g_sequence[i].autolayer[j].peak / (g_sequence[i].panim[0][0]->numframes - 1);
+				pautolayer[j].tail		= g_sequence[i].autolayer[j].tail / (g_sequence[i].panim[0][0]->numframes - 1);
+				pautolayer[j].end		= g_sequence[i].autolayer[j].end / (g_sequence[i].panim[0][0]->numframes - 1);
+			}
+			else
+			{
+				pautolayer[j].start		= g_sequence[i].autolayer[j].start;
+				pautolayer[j].peak		= g_sequence[i].autolayer[j].peak;
+				pautolayer[j].tail		= g_sequence[i].autolayer[j].tail;
+				pautolayer[j].end		= g_sequence[i].autolayer[j].end;
+			}
+		}
+
+
+		// save boneweights
+		float *pweight = 0;
+		j = 0;
+		// look up previous sequence weights and try to find a match
+		for (k = 0; k < m; k++)
+		{
+			j = 0;
+			// only check newer boneweights than the last one
+			if (pseqdesc[k-m].pBoneweight( 0 ) > pweight)
+			{
+				pweight = pseqdesc[k-m].pBoneweight( 0 );
+				for (j = 0; j < g_numbones; j++)
+				{
+					// we're not walking the linear sequence list if we're remapping, so we need to remap this check
+					int nRemap = k;
+					if ( bUseSeqOrderRemapping )
+						nRemap = nSeqOrderRemappingTable[k];
+
+					if (g_sequence[i].weight[j] != g_sequence[nRemap].weight[j])
+						break;
+				}
+				if (j == g_numbones)
+					break;
+			}
+		}
+
+		// check to see if all the bones matched
+		if (j < g_numbones)
+		{
+			// allocate new block
+			//printf("new %08x\n", pData );
+			pweight						= (float *)pData;
+			pseqdesc->weightlistindex = (pData - pSequenceStart);
+			pData += g_numbones * sizeof( float );
+			for (j = 0; j < g_numbones; j++)
+			{
+				pweight[j] = g_sequence[i].weight[j];
+			}
+		}
+		else
+		{
+			// use previous boneweight
+			//printf("prev %08x\n", pweight );
+			pseqdesc->weightlistindex = ((byte *)pweight - pSequenceStart);
+		}
+
+
+		// save iklocks
+		mstudioiklock_t *piklock	= (mstudioiklock_t *)pData;
+		pseqdesc->numiklocks		= g_sequence[i].numiklocks;
+		pseqdesc->iklockindex		= (pData - pSequenceStart);
+		pData += pseqdesc->numiklocks * sizeof( mstudioiklock_t );
+		ALIGN4( pData );
+
+		for (j = 0; j < pseqdesc->numiklocks; j++)
+		{
+			piklock->chain			= g_sequence[i].iklock[j].chain;
+			piklock->flPosWeight	= g_sequence[i].iklock[j].flPosWeight;
+			piklock->flLocalQWeight	= g_sequence[i].iklock[j].flLocalQWeight;
+			piklock++;
+		}
+
+		// Write animation blend parameters
+		short *blends = ( short * )pData;
+		pseqdesc->animindexindex = ( pData - pSequenceStart );
+		pData += ( g_sequence[i].groupsize[0] * g_sequence[i].groupsize[1] ) * sizeof( short );
+		ALIGN4( pData );
+
+		for ( j = 0; j < g_sequence[i].groupsize[0] ; j++ )
+		{
+			for ( k = 0; k < g_sequence[i].groupsize[1]; k++ )
+			{
+				// height value * width of row + width value
+				int offset = k * g_sequence[i].groupsize[0] + j;
+
+				if ( g_sequence[i].panim[j][k] )
+				{
+					int animindex = g_sequence[i].panim[j][k]->index;
+
+					Assert( animindex >= 0 && animindex < SHRT_MAX );
+
+					blends[ offset ] = (short)animindex;
+				}
+				else
+				{
+					blends[ offset ] = 0;
+				}
+			}
+		}
+
+		// Write cycle overrides
+		pseqdesc->cycleposeindex = g_sequence[i].cycleposeindex;
+
+		WriteSeqKeyValues( pseqdesc, &g_sequence[i].KeyValue );
+	}
+
+	if (bErrors)
+	{
+		MdlError( "Exiting due to Errors\n");
+	}
+
+	// save transition graph
+	int *pxnodename = (int *)pData;
+	phdr->localnodenameindex = (pData - pStart);
+	pData += g_numxnodes * sizeof( *pxnodename );
+	ALIGN4( pData );
+	for (i = 0; i < g_numxnodes; i++)
+	{
+		AddToStringTable( phdr, pxnodename, g_xnodename[i+1] );
+		// printf("%d : %s\n", i, g_xnodename[i+1] );
+		pxnodename++;
+	}
+
+	ptransition	= (byte *)pData;
+	phdr->numlocalnodes = g_numxnodes;
+	phdr->localnodeindex = pData - pStart;
+	pData += g_numxnodes * g_numxnodes * sizeof( byte );
+	ALIGN4( pData );
+	for (i = 0; i < g_numxnodes; i++)
+	{
+//		printf("%2d (%12s) : ", i + 1, g_xnodename[i+1] );
+		for (j = 0; j < g_numxnodes; j++)
+		{
+			*ptransition++ = g_xnode[i][j];
+//			printf(" %2d", g_xnode[i][j] );
+		}
+//		printf("\n" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Stub implementation
+// Input  : *group - 
+//-----------------------------------------------------------------------------
+
+const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *modelname ) const
+{
+	return NULL;
+}
+
+virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const
+{
+	return NULL;
+}
+
+const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
+{
+	return (studiohdr_t *)cache;
+}
+
+byte *studiohdr_t::GetAnimBlock( int i ) const
+{
+	return NULL;
+}
+
+int	studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
+{
+	return 0;
+}
+
+
+int rawanimbytes = 0;
+int animboneframes = 0;
+
+int numAxis[4] = { 0, 0, 0, 0 };
+int numPos[4] = { 0, 0, 0, 0 };
+int useRaw = 0;
+
+void WriteAnimationData( s_animation_t *srcanim, mstudioanimdesc_t *destanimdesc, byte *&pLocalData, byte *&pExtData )
+{
+	int j, k, n;
+
+	byte *pData = NULL;
+
+	for (int w = 0; w < srcanim->numsections; w++)
+	{
+		bool bUseExtData = false;
+		pData = pLocalData;
+
+		if (pExtData != NULL && !srcanim->disableAnimblocks && !(w == 0 && srcanim->isFirstSectionLocal))
+		{
+			pData = pExtData;
+			bUseExtData = true;
+		}
+
+		mstudioanim_t	*destanim = (mstudioanim_t *)pData;
+		byte	*pStartSection = pData;
+		pData += sizeof( *destanim );
+
+		destanim->bone = 255;
+
+		mstudioanim_t	*prevanim = NULL;
+
+		// save animation value info
+		for (j = 0; j < g_numbones; j++)
+		{
+			// destanim->weight = srcanim->weight[j];
+			// printf( "%s %.1f\n", g_bonetable[j].name, destanim->weight );
+			destanim->flags = 0;
+			s_compressed_t *psrcdata = &srcanim->anim[w][j];
+
+			numPos[ (psrcdata->num[0] != 0) + (psrcdata->num[1] != 0) + (psrcdata->num[2] != 0) ]++;
+			numAxis[ (psrcdata->num[3] != 0) + (psrcdata->num[4] != 0) + (psrcdata->num[5] != 0) ]++;
+
+			if (psrcdata->num[0] + psrcdata->num[1] + psrcdata->num[2] + psrcdata->num[3] + psrcdata->num[4] + psrcdata->num[5] == 0)
+			{
+				// no animation, skip
+				continue;
+			}
+
+			destanim->bone = j;
+
+			// copy flags over if delta animation
+			if (srcanim->flags & STUDIO_DELTA)
+			{
+				destanim->flags |= STUDIO_ANIM_DELTA;
+			}
+
+			if ((srcanim->numframes == 1) || (psrcdata->num[0] <= 2 && psrcdata->num[1] <= 2 && psrcdata->num[2] <= 2 && psrcdata->num[3] <= 2 && psrcdata->num[4] <= 2 && psrcdata->num[5] <= 2))
+			{
+				// printf("%d : %d %d %d : %d %d %d\n", j, psrcdata->num[0], psrcdata->num[1], psrcdata->num[2], psrcdata->num[3], psrcdata->num[4], psrcdata->num[5] );
+				// single frame, if animation detected just store as raw
+				int iFrame = min( w * srcanim->sectionframes, srcanim->numframes - 1 );
+				if (psrcdata->num[3] != 0 || psrcdata->num[4] != 0 || psrcdata->num[5] != 0)
+				{
+					Quaternion q;
+					AngleQuaternion( srcanim->sanim[iFrame][j].rot, q );
+					*((Quaternion64 *)pData) = q;
+					pData += sizeof( Quaternion64 );
+					rawanimbytes += sizeof( Quaternion64 );
+					destanim->flags |= STUDIO_ANIM_RAWROT2;
+				}
+
+				if (psrcdata->num[0] != 0 || psrcdata->num[1] != 0 || psrcdata->num[2] != 0)
+				{
+					*((Vector48 *)pData) = srcanim->sanim[iFrame][j].pos;
+					pData += sizeof( Vector48 );
+					rawanimbytes += sizeof( Vector48 );
+					destanim->flags |= STUDIO_ANIM_RAWPOS;
+				}
+			}
+			else
+			{
+				// look to see if storing raw quat's would have taken less space
+				if (psrcdata->num[3] >= srcanim->numframes && psrcdata->num[4] >= srcanim->numframes && psrcdata->num[5] >= srcanim->numframes)
+				{
+					useRaw++;
+				}
+
+				mstudioanim_valueptr_t *posvptr	= NULL;
+				mstudioanim_valueptr_t *rotvptr	= NULL;
+
+				// allocate room for rotation ptrs
+				rotvptr	= (mstudioanim_valueptr_t *)pData;
+				pData += sizeof( *rotvptr );
+
+				// skip all position info if there's no animation
+				if (psrcdata->num[0] != 0 || psrcdata->num[1] != 0 || psrcdata->num[2] != 0)
+				{
+					posvptr	= (mstudioanim_valueptr_t *)pData;
+					pData += sizeof( *posvptr );
+				}
+
+				mstudioanimvalue_t	*destanimvalue = (mstudioanimvalue_t *)pData;
+
+				if (rotvptr)
+				{
+					// store rotation animations
+					for (k = 3; k < 6; k++)
+					{
+						if (psrcdata->num[k] == 0)
+						{
+							rotvptr->offset[k-3] = 0;
+						}
+						else
+						{
+							rotvptr->offset[k-3] = ((byte *)destanimvalue - (byte *)rotvptr);
+							for (n = 0; n < psrcdata->num[k]; n++)
+							{
+								destanimvalue->value = psrcdata->data[k][n].value;
+								destanimvalue++;
+							}
+						}
+					}
+					destanim->flags |= STUDIO_ANIM_ANIMROT;
+				}
+
+				if (posvptr)
+				{
+					// store position animations
+					for (k = 0; k < 3; k++)
+					{
+						if (psrcdata->num[k] == 0)
+						{
+							posvptr->offset[k] = 0;
+						}
+						else
+						{
+							posvptr->offset[k] = ((byte *)destanimvalue - (byte *)posvptr);
+							for (n = 0; n < psrcdata->num[k]; n++)
+							{
+								destanimvalue->value = psrcdata->data[k][n].value;
+								destanimvalue++;
+							}
+						}
+					}
+					destanim->flags |= STUDIO_ANIM_ANIMPOS;
+				}
+				rawanimbytes += ((byte *)destanimvalue - pData);
+				pData = (byte *)destanimvalue;
+			}
+
+			prevanim					= destanim;
+			destanim->nextoffset		= pData - (byte *)destanim;
+			destanim					= (mstudioanim_t *)pData;
+			pData						+= sizeof( *destanim );
+		}
+
+		if (prevanim)
+		{
+			prevanim->nextoffset		= 0;
+		}
+
+		ALIGN4( pData );
+
+		// write into anim blocks if needed
+		if (destanimdesc->sectionindex)
+		{
+			if (bUseExtData)
+			{
+				if (g_numanimblocks && pData - g_animblock[g_numanimblocks-1].start > g_animblocksize)
+				{
+					// advance to next animblock
+					g_animblock[g_numanimblocks-1].end = pStartSection;
+					g_animblock[g_numanimblocks].start = pStartSection;
+					g_numanimblocks++;
+				}
+
+				destanimdesc->pSection(w)->animblock = g_numanimblocks - 1;
+				destanimdesc->pSection(w)->animindex = pStartSection - g_animblock[g_numanimblocks-1].start;
+			}
+			else
+			{
+				destanimdesc->pSection(w)->animblock = 0;
+				destanimdesc->pSection(w)->animindex = pStartSection - (byte *)destanimdesc;
+			}
+			// printf("%s (%d) : %d:%d\n", srcanim->name, w, destanimdesc->pSection(w)->animblock, destanimdesc->pSection(w)->animindex );
+		}
+
+		if (!bUseExtData)
+		{
+			pLocalData = pData;
+		}
+		else
+		{
+			pExtData = pData;
+		}
+	}
+}
+
+
+byte *WriteIkErrors( s_animation_t *srcanim, byte *pData )
+{
+	int j, k;
+
+	// write IK error keys
+	mstudioikrule_t *pikruledata = (mstudioikrule_t *)pData;
+	pData += srcanim->numikrules * sizeof( *pikruledata );
+	ALIGN4( pData );
+
+	for (j = 0; j < srcanim->numikrules; j++)
+	{
+		mstudioikrule_t *pikrule = pikruledata + j;
+
+		pikrule->index	= srcanim->ikrule[j].index;
+
+		pikrule->chain	= srcanim->ikrule[j].chain;
+		pikrule->bone	= srcanim->ikrule[j].bone;
+		pikrule->type	= srcanim->ikrule[j].type;
+		pikrule->slot	= srcanim->ikrule[j].slot;
+		pikrule->pos	= srcanim->ikrule[j].pos;
+		pikrule->q		= srcanim->ikrule[j].q;
+		pikrule->height	= srcanim->ikrule[j].height;
+		pikrule->floor	= srcanim->ikrule[j].floor;
+		pikrule->radius = srcanim->ikrule[j].radius;
+
+		if (srcanim->numframes > 1.0)
+		{
+			pikrule->start	= srcanim->ikrule[j].start / (srcanim->numframes - 1.0f);
+			pikrule->peak	= srcanim->ikrule[j].peak / (srcanim->numframes - 1.0f);
+			pikrule->tail	= srcanim->ikrule[j].tail / (srcanim->numframes - 1.0f);
+			pikrule->end	= srcanim->ikrule[j].end / (srcanim->numframes - 1.0f);
+			pikrule->contact= srcanim->ikrule[j].contact / (srcanim->numframes - 1.0f);
+		}
+		else
+		{
+			pikrule->start	= 0.0f;
+			pikrule->peak	= 0.0f;
+			pikrule->tail	= 1.0f;
+			pikrule->end	= 1.0f;
+			pikrule->contact= 0.0f;
+		}
+
+		/*
+		printf("%d %d %d %d : %.2f %.2f %.2f %.2f\n", 
+			srcanim->ikrule[j].start, srcanim->ikrule[j].peak, srcanim->ikrule[j].tail, srcanim->ikrule[j].end, 
+			pikrule->start, pikrule->peak, pikrule->tail, pikrule->end );
+		*/
+
+		pikrule->iStart = srcanim->ikrule[j].start;
+
+#if 0
+		// uncompressed
+		pikrule->ikerrorindex = (pData - (byte*)pikrule);
+		mstudioikerror_t *perror = (mstudioikerror_t *)pData;
+		pData += srcanim->ikrule[j].numerror * sizeof( *perror );
+
+		for (k = 0; k < srcanim->ikrule[j].numerror; k++)
+		{
+			perror[k].pos = srcanim->ikrule[j].pError[k].pos;
+			perror[k].q = srcanim->ikrule[j].pError[k].q;
+		}
+#endif
+#if 1
+		// skip writting the header if there's no IK data
+		for (k = 0; k < 6; k++)
+		{
+			if (srcanim->ikrule[j].errorData.numanim[k]) break;
+		}
+
+		if (k == 6)
+			continue;
+
+		// compressed
+		pikrule->compressedikerrorindex = (pData - (byte*)pikrule);
+		mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pData;
+		pData += sizeof( *pCompressed );
+
+		for (k = 0; k < 6; k++)
+		{
+			pCompressed->scale[k] = srcanim->ikrule[j].errorData.scale[k];
+			pCompressed->offset[k] = (pData - (byte*)pCompressed);
+			int size = srcanim->ikrule[j].errorData.numanim[k] * sizeof( mstudioanimvalue_t );
+			memmove( pData, srcanim->ikrule[j].errorData.anim[k], size );
+			pData += size;
+		}
+
+		if (strlen( srcanim->ikrule[j].attachment ) > 0)
+		{
+			// don't use string table, we're probably not in the same file.
+			int size = strlen( srcanim->ikrule[j].attachment ) + 1;
+			strcpy( (char *)pData, srcanim->ikrule[j].attachment );
+			pikrule->szattachmentindex = pData - (byte *)pikrule;
+			pData += size;
+		}
+
+		ALIGN4( pData );
+
+#endif
+		// AddToStringTable( pikrule, &pikrule->szattachmentindex, srcanim->ikrule[j].attachment );
+	}
+
+	return pData;
+}
+
+
+
+
+
+
+byte *WriteLocalHierarchy( s_animation_t *srcanim, byte *pData )
+{
+	int j, k;
+
+	// write hierarchy  keys
+	mstudiolocalhierarchy_t *pHierarchyData = (mstudiolocalhierarchy_t *)pData;
+	pData += srcanim->numlocalhierarchy * sizeof( *pHierarchyData );
+	ALIGN4( pData );
+
+	for (j = 0; j < srcanim->numlocalhierarchy; j++)
+	{
+		mstudiolocalhierarchy_t *pHierarchy = pHierarchyData + j;
+
+		pHierarchy->iBone	= srcanim->localhierarchy[j].bone;
+		pHierarchy->iNewParent	= srcanim->localhierarchy[j].newparent;
+
+		if (srcanim->numframes > 1.0)
+		{
+			pHierarchy->start	= srcanim->localhierarchy[j].start / (srcanim->numframes - 1.0f);
+			pHierarchy->peak	= srcanim->localhierarchy[j].peak / (srcanim->numframes - 1.0f);
+			pHierarchy->tail	= srcanim->localhierarchy[j].tail / (srcanim->numframes - 1.0f);
+			pHierarchy->end		= srcanim->localhierarchy[j].end / (srcanim->numframes - 1.0f);
+		}
+		else
+		{
+			pHierarchy->start	= 0.0f;
+			pHierarchy->peak	= 0.0f;
+			pHierarchy->tail	= 1.0f;
+			pHierarchy->end		= 1.0f;
+		}
+
+		pHierarchy->iStart = srcanim->localhierarchy[j].start;
+
+#if 0
+		// uncompressed
+		pHierarchy->ikerrorindex = (pData - (byte*)pHierarchy);
+		mstudioikerror_t *perror = (mstudioikerror_t *)pData;
+		pData += srcanim->ikrule[j].numerror * sizeof( *perror );
+
+		for (k = 0; k < srcanim->ikrule[j].numerror; k++)
+		{
+			perror[k].pos = srcanim->ikrule[j].pError[k].pos;
+			perror[k].q = srcanim->ikrule[j].pError[k].q;
+		}
+#endif
+#if 1
+		// skip writting the header if there's no IK data
+		for (k = 0; k < 6; k++)
+		{
+			if (srcanim->localhierarchy[j].localData.numanim[k]) break;
+		}
+
+		if (k == 6)
+			continue;
+
+		// compressed
+		pHierarchy->localanimindex = (pData - (byte*)pHierarchy);
+		mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pData;
+		pData += sizeof( *pCompressed );
+
+		for (k = 0; k < 6; k++)
+		{
+			pCompressed->scale[k] = srcanim->localhierarchy[j].localData.scale[k];
+			pCompressed->offset[k] = (pData - (byte*)pCompressed);
+			int size = srcanim->localhierarchy[j].localData.numanim[k] * sizeof( mstudioanimvalue_t );
+			memmove( pData, srcanim->localhierarchy[j].localData.anim[k], size );
+			pData += size;
+		}
+
+		ALIGN4( pData );
+
+#endif
+		// AddToStringTable( pHierarchy, &pHierarchy->szattachmentindex, srcanim->ikrule[j].attachment );
+	}
+
+	return pData;
+}
+
+
+static byte *WriteAnimations( byte *pData, byte *pStart, studiohdr_t *phdr )
+{
+	int i, j;
+
+	mstudioanimdesc_t	*panimdesc;
+
+	// save animations
+	panimdesc = (mstudioanimdesc_t *)pData;
+	if( phdr )
+	{
+		phdr->numlocalanim = g_numani;
+		phdr->localanimindex = (pData - pStart);
+	}
+	pData += g_numani * sizeof( *panimdesc );
+	ALIGN4( pData );
+	//      ------------ ------- ------- : ------- (-------)
+	if( g_verbose )
+	{
+		printf("   animation       x       y       ips    angle\n");
+	}
+
+	for (i = 0; i < g_numani; i++) 
+	{
+		s_animation_t *srcanim = g_panimation[ i ];
+		mstudioanimdesc_t *destanim = &panimdesc[i];
+		Assert( srcanim );
+
+		AddToStringTable( destanim, &destanim->sznameindex, srcanim->name );
+
+		destanim->baseptr	= pStart - (byte *)destanim;
+		destanim->fps		= srcanim->fps;
+		destanim->flags		= srcanim->flags;
+
+		destanim->sectionframes = srcanim->sectionframes;
+
+		totalframes				+= srcanim->numframes;
+		totalseconds			+= srcanim->numframes / srcanim->fps;
+
+		destanim->numframes	= srcanim->numframes;
+
+		// destanim->motiontype = srcanim->motiontype;	
+		// destanim->motionbone = srcanim->motionbone;
+		// VectorCopy( srcanim->linearpos, destanim->linearpos );
+
+		j = srcanim->numpiecewisekeys - 1;
+		if (srcanim->piecewisemove[j].pos[0] != 0 || srcanim->piecewisemove[j].pos[1] != 0) 
+		{
+			float t = (srcanim->numframes - 1) / srcanim->fps;
+
+			float r = 1 / t;
+			
+			float a = atan2( srcanim->piecewisemove[j].pos[1], srcanim->piecewisemove[j].pos[0] ) * (180 / M_PI);
+			float d = sqrt( DotProduct( srcanim->piecewisemove[j].pos, srcanim->piecewisemove[j].pos ) );
+			if( g_verbose )
+			{
+				printf("%12s %7.2f %7.2f : %7.2f (%7.2f) %.1f\n", srcanim->name, srcanim->piecewisemove[j].pos[0], srcanim->piecewisemove[j].pos[1], d * r, a, t );
+			}
+		}
+
+		if (srcanim->numsections > 1)
+		{
+			destanim->sectionindex = pData - (byte *)destanim;
+			pData += srcanim->numsections * sizeof( mstudioanimsections_t );
+		}
+
+		// VectorCopy( srcanim->linearrot, destanim->linearrot );
+		// destanim->automoveposindex = srcanim->automoveposindex;
+		// destanim->automoveangleindex = srcanim->automoveangleindex;
+
+		// align all animation data to cache line boundaries
+		ALIGN16( pData );
+		ALIGN16( pBlockData );
+
+		if (pBlockStart)
+		{
+			// allocate the first block if needed
+			if (g_numanimblocks == 0)
+			{
+				g_numanimblocks = 1;
+				g_animblock[g_numanimblocks].start = pBlockData;
+				g_numanimblocks++;
+			}
+		}
+
+		if (!pBlockStart || (g_bonesaveframe.Count() == 0 && srcanim->numframes == 1))
+		{
+			// hack
+			srcanim->disableAnimblocks = true;
+		}
+		else if (g_bNoAnimblockStall)
+		{
+			srcanim->isFirstSectionLocal = true;
+		}
+	
+		// block zero is relative to me
+		g_animblock[0].start = (byte *)(destanim);
+
+		byte *pAnimData = NULL;
+		byte *pIkData = NULL;
+		byte *pLocalHierarchy = NULL;
+		byte *pBlockEnd = pBlockData;
+
+		if (srcanim->disableAnimblocks || srcanim->isFirstSectionLocal)
+		{
+			destanim->animblock	= 0;
+			pAnimData = pData;
+			WriteAnimationData( srcanim, destanim, pData, pBlockEnd );
+			pIkData = pData;
+			pLocalHierarchy = WriteIkErrors( srcanim, pIkData );
+			pData = WriteLocalHierarchy( srcanim, pLocalHierarchy );
+		}
+		else
+		{
+			pAnimData = pBlockEnd;
+			WriteAnimationData( srcanim, destanim, pData, pBlockEnd );
+			if ( destanim->sectionindex )
+			{
+				// if sections were written, don't move the data already written to the last block
+				pBlockData = pBlockEnd;
+			}
+			destanim->animblock = g_numanimblocks-1;
+			pIkData = pBlockEnd;
+			pLocalHierarchy = WriteIkErrors( srcanim, pIkData );
+			pBlockEnd = WriteLocalHierarchy( srcanim, pLocalHierarchy );
+		}
+
+		// printf("%d %x %x %x   %s : %d\n", g_numanimblocks - 1, g_animblock[g_numanimblocks-1].start, pBlockData, pBlockEnd, srcanim->name, srcanim->numsections );
+
+		if (pBlockData != pBlockEnd && pBlockEnd - g_animblock[g_numanimblocks-1].start > g_animblocksize)
+		{
+			g_animblock[g_numanimblocks-1].end = pBlockData;
+			g_animblock[g_numanimblocks].start = pBlockData;
+			g_numanimblocks++;
+			destanim->animblock	= g_numanimblocks-1;
+		}
+
+		destanim->animindex = pAnimData - g_animblock[destanim->animblock].start;
+
+		if ( srcanim->numikrules )
+		{
+			destanim->numikrules = srcanim->numikrules;
+			if (destanim->animblock == 0)
+			{
+				destanim->ikruleindex = pIkData - g_animblock[destanim->animblock].start;
+			}
+			else
+			{
+				destanim->animblockikruleindex = pIkData - g_animblock[destanim->animblock].start;
+			}
+		}
+		if ( srcanim->numlocalhierarchy )
+		{
+			destanim->numlocalhierarchy = srcanim->numlocalhierarchy;
+			destanim->localhierarchyindex = pLocalHierarchy - g_animblock[destanim->animblock].start;
+		}
+
+		if (g_numanimblocks)
+		{
+			g_animblock[g_numanimblocks-1].end = pBlockEnd;
+			pBlockData = pBlockEnd;
+		}
+
+		// printf("%s : %d:%d\n", srcanim->name, destanim->animblock, destanim->animindex );
+
+		// printf("raw bone data %d : %s\n", (byte *)destanimvalue - pData, srcanim->name);
+	}
+
+	if( !g_quiet )
+	{
+		/*
+		for (i = 0; i < g_numanimblocks; i++)
+		{
+			printf("%2d (%3d:%3d): %d\n", i, g_animblock[i].iStartAnim, g_animblock[i].iEndAnim, g_animblock[i].end - g_animblock[i].start );
+		}
+		*/
+	}
+
+	if( !g_quiet )
+	{
+		/*
+		printf("raw anim data %d : %d\n", rawanimbytes, animboneframes );
+		printf("pos  %d %d %d %d\n", numPos[0], numPos[1], numPos[2], numPos[3] );
+		printf("axis %d %d %d %d : %d\n", numAxis[0], numAxis[1], numAxis[2], numAxis[3], useRaw );
+		*/
+	}
+
+	// write movement keys
+	for (i = 0; i < g_numani; i++) 
+	{
+		s_animation_t *anim = g_panimation[ i ];
+
+		// panimdesc[i].entrancevelocity = anim->entrancevelocity;
+		panimdesc[i].nummovements = anim->numpiecewisekeys;
+		if (panimdesc[i].nummovements)
+		{
+			panimdesc[i].movementindex = pData - (byte*)&panimdesc[i];
+
+			mstudiomovement_t	*pmove = (mstudiomovement_t *)pData;
+			pData += panimdesc[i].nummovements * sizeof( *pmove );
+			ALIGN4( pData );
+
+			for (j = 0; j < panimdesc[i].nummovements; j++)
+			{
+				pmove[j].endframe		= anim->piecewisemove[j].endframe;
+				pmove[j].motionflags	= anim->piecewisemove[j].flags;
+				pmove[j].v0				= anim->piecewisemove[j].v0;
+				pmove[j].v1				= anim->piecewisemove[j].v1;
+				pmove[j].angle			= RAD2DEG( anim->piecewisemove[j].rot[2] );
+				VectorCopy( anim->piecewisemove[j].vector, pmove[j].vector );
+				VectorCopy( anim->piecewisemove[j].pos, pmove[j].position );
+			}
+		}
+	}
+
+	// only write zero frames if the animation data is demand loaded
+	if (!pBlockStart)
+		return pData;
+
+
+	// calculate what bones should be have zero frame saved out
+	if (g_bonesaveframe.Count() == 0)
+	{
+		for (j = 0; j < g_numbones; j++)
+		{
+			if ((g_bonetable[j].parent == -1) || (g_bonetable[j].posrange.Length() > 2.0))
+			{
+				g_bonetable[j].flags |= BONE_HAS_SAVEFRAME_POS;
+			}
+			g_bonetable[j].flags |= BONE_HAS_SAVEFRAME_ROT;
+
+			if ((!g_quiet) && (g_bonetable[j].flags & (BONE_HAS_SAVEFRAME_POS | BONE_HAS_SAVEFRAME_ROT)))
+			{
+				printf("$BoneSaveFrame \"%s\"", g_bonetable[j].name );
+				if (g_bonetable[j].flags & BONE_HAS_SAVEFRAME_POS)
+					printf(" position" );
+				if (g_bonetable[j].flags & BONE_HAS_SAVEFRAME_ROT)
+					printf(" rotation" );
+				printf("\n");
+			}
+		}
+	}
+	else
+	{
+		for (i = 0; i < g_bonesaveframe.Count(); i++)
+		{
+			j = findGlobalBone( g_bonesaveframe[i].name );
+
+			if (j != -1)
+			{
+				if (g_bonesaveframe[i].bSavePos)
+				{
+					g_bonetable[j].flags |= BONE_HAS_SAVEFRAME_POS;
+				}
+				if (g_bonesaveframe[i].bSaveRot)
+				{
+					g_bonetable[j].flags |= BONE_HAS_SAVEFRAME_ROT;
+				}
+			}
+		}
+	}
+
+	for (j = 0; j < g_numbones; j++)
+	{
+		phdr->pBone(j)->flags |= g_bonetable[j].flags;
+	}
+
+	ALIGN4( pData );
+
+	// write zero frames
+	for (i = 0; i < g_numani; i++) 
+	{
+		s_animation_t *anim = g_panimation[ i ];
+
+		if (panimdesc[i].animblock != 0)
+		{
+			panimdesc[i].zeroframeindex = pData - (byte *)&panimdesc[i];
+
+			int k = min( panimdesc[i].numframes - 1, 9 );
+			if (panimdesc[i].flags & STUDIO_LOOPING)
+			{
+				k = min( (panimdesc[i].numframes - 1) / 2, k );
+			}
+			panimdesc[i].zeroframespan = k;
+			if (k > 2)
+			{
+				panimdesc[i].zeroframecount = min( (panimdesc[i].numframes - 1) / panimdesc[i].zeroframespan, 3 ); // save frames 0..24 frames
+			}
+			if (panimdesc[i].zeroframecount < 1)
+				panimdesc[i].zeroframecount = 1;
+
+			for (j = 0; j < g_numbones; j++)
+			{
+				if (g_bonetable[j].flags & BONE_HAS_SAVEFRAME_POS)
+				{
+					for (int n = 0; n < panimdesc[i].zeroframecount; n++)
+					{
+						*(Vector48 *)pData = anim->sanim[panimdesc[i].zeroframespan*n][j].pos;
+						pData += sizeof( Vector48 );
+					}
+				}
+				if (g_bonetable[j].flags & BONE_HAS_SAVEFRAME_ROT)
+				{
+					for (int n = 0; n < panimdesc[i].zeroframecount; n++)
+					{
+						Quaternion q;
+						AngleQuaternion( anim->sanim[panimdesc[i].zeroframespan*n][j].rot, q );
+						*((Quaternion64 *)pData) = q;
+						pData += sizeof( Quaternion64 );
+					}
+				}
+			}
+		}
+	}
+
+	ALIGN4( pData );
+
+	return pData;
+}
+
+
+
+static void WriteTextures( studiohdr_t *phdr )
+{
+	int i, j;
+	short	*pref;
+
+	// save texture info
+	mstudiotexture_t *ptexture = (mstudiotexture_t *)pData;
+	phdr->numtextures = g_nummaterials;
+	phdr->textureindex = pData - pStart;
+	pData += g_nummaterials * sizeof( mstudiotexture_t );
+	for (i = 0; i < g_nummaterials; i++) 
+	{
+		j = g_material[i];
+		AddToStringTable( &ptexture[i], &ptexture[i].sznameindex, g_texture[j].name );
+	}
+	ALIGN4( pData );
+
+	int *cdtextureoffset = (int *)pData;
+	phdr->numcdtextures = numcdtextures;
+	phdr->cdtextureindex = pData - pStart;
+	pData += numcdtextures * sizeof( int );
+	for (i = 0; i < numcdtextures; i++) 
+	{
+		AddToStringTable( phdr, &cdtextureoffset[i], cdtextures[i] );
+	}
+	ALIGN4( pData );
+
+	// save texture directory info
+	phdr->skinindex = (pData - pStart);
+	phdr->numskinref = g_numskinref;
+	phdr->numskinfamilies = g_numskinfamilies;
+	pref = (short *)pData;
+
+	for (i = 0; i < phdr->numskinfamilies; i++) 
+	{
+		for (j = 0; j < phdr->numskinref; j++) 
+		{
+			*pref = g_skinref[i][j];
+			pref++;
+		}
+	}
+	pData = (byte *)pref;
+	ALIGN4( pData );
+}
+
+
+//-----------------------------------------------------------------------------
+// Write source bone transforms
+//-----------------------------------------------------------------------------
+static void WriteBoneTransforms( studiohdr2_t *phdr, mstudiobone_t *pBone )
+{
+	matrix3x4_t identity;
+	SetIdentityMatrix( identity );
+
+	int nTransformCount = 0;
+	for (int i = 0; i < g_numbones; i++)
+	{
+		if ( g_bonetable[i].flags & BONE_ALWAYS_PROCEDURAL )
+			continue;
+		int nParent = g_bonetable[i].parent;
+
+		// Transformation is necessary if either you or your parent was realigned
+		if ( MatricesAreEqual( identity, g_bonetable[i].srcRealign ) &&
+			 ( ( nParent < 0 ) || MatricesAreEqual( identity, g_bonetable[nParent].srcRealign ) ) )
+			continue;
+
+		++nTransformCount;
+	}
+	
+	// save bone transform info
+	mstudiosrcbonetransform_t *pSrcBoneTransform = (mstudiosrcbonetransform_t *)pData;
+	phdr->numsrcbonetransform = nTransformCount;
+	phdr->srcbonetransformindex = pData - pStart;
+	pData += nTransformCount * sizeof( mstudiosrcbonetransform_t );
+	int bt = 0;
+	for ( int i = 0; i < g_numbones; i++ )
+	{
+		if ( g_bonetable[i].flags & BONE_ALWAYS_PROCEDURAL )
+			continue;
+		int nParent = g_bonetable[i].parent;
+		if ( MatricesAreEqual( identity, g_bonetable[i].srcRealign ) &&
+			( ( nParent < 0 ) || MatricesAreEqual( identity, g_bonetable[nParent].srcRealign ) ) )
+			continue;
+							   
+		// What's going on here?
+		// So, when we realign a bone, we want to do it in a way so that the child bones
+		// have the same bone->world transform. If we take T as the src realignment transform
+		// for the parent, P is the parent to world, and C is the child to parent, we expect 
+		// the child->world is constant after realignment:
+		//		CtoW = P * C = ( P * T ) * ( T^-1 * C )
+		// therefore Cnew = ( T^-1 * C )
+		if ( nParent >= 0 )
+		{
+			MatrixInvert( g_bonetable[nParent].srcRealign, pSrcBoneTransform[bt].pretransform );
+		}
+		else
+		{
+			SetIdentityMatrix( pSrcBoneTransform[bt].pretransform );
+		}
+		MatrixCopy( g_bonetable[i].srcRealign, pSrcBoneTransform[bt].posttransform );
+		AddToStringTable( &pSrcBoneTransform[bt], &pSrcBoneTransform[bt].sznameindex, g_bonetable[i].name );
+		++bt;
+	}
+	ALIGN4( pData );
+
+	if (g_numbones > 1)
+	{
+		// write second bone table
+		phdr->linearboneindex = pData - (byte *)phdr;
+		mstudiolinearbone_t *pLinearBone =  (mstudiolinearbone_t *)pData;
+		pData += sizeof( *pLinearBone );
+
+		pLinearBone->numbones = g_numbones;
+
+#define WRITE_BONE_BLOCK( type, srcfield, dest, destindex ) \
+		type *##dest = (type *)pData; \
+		pLinearBone->##destindex = pData - (byte *)pLinearBone; \
+		pData += g_numbones * sizeof( *##dest ); \
+		ALIGN4( pData ); \
+		for ( int i = 0; i < g_numbones; i++) \
+			dest##[i] = pBone[i].##srcfield;
+
+		WRITE_BONE_BLOCK( int, flags, pFlags, flagsindex );
+		WRITE_BONE_BLOCK( int, parent, pParent, parentindex );
+		WRITE_BONE_BLOCK( Vector, pos, pPos, posindex );
+		WRITE_BONE_BLOCK( Quaternion, quat, pQuat, quatindex );
+		WRITE_BONE_BLOCK( RadianEuler, rot, pRot, rotindex );
+		WRITE_BONE_BLOCK( matrix3x4_t, poseToBone, pPoseToBone, posetoboneindex );
+		WRITE_BONE_BLOCK( Vector, posscale, pPoseScale, posscaleindex );
+		WRITE_BONE_BLOCK( Vector, rotscale, pRotScale, rotscaleindex );
+		WRITE_BONE_BLOCK( Quaternion, qAlignment, pQAlignment, qalignmentindex );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Write the bone flex drivers
+//-----------------------------------------------------------------------------
+static void WriteBoneFlexDrivers( studiohdr2_t *pStudioHdr2 )
+{
+	ALIGN4( pData );
+
+	pStudioHdr2->m_nBoneFlexDriverCount = 0;
+	pStudioHdr2->m_nBoneFlexDriverIndex = 0;
+
+	CDmeBoneFlexDriverList *pDmeBoneFlexDriverList = GetElement< CDmeBoneFlexDriverList >( g_hDmeBoneFlexDriverList );
+	if ( !pDmeBoneFlexDriverList )
+		return;
+
+	const int nBoneFlexDriverCount = pDmeBoneFlexDriverList->m_eBoneFlexDriverList.Count();
+	if ( nBoneFlexDriverCount <= 0 )
+		return;
+
+	mstudioboneflexdriver_t *pBoneFlexDriver = (mstudioboneflexdriver_t *)pData;
+	pStudioHdr2->m_nBoneFlexDriverCount = nBoneFlexDriverCount;
+	pStudioHdr2->m_nBoneFlexDriverIndex = pData - (byte *)pStudioHdr2;
+	pData += nBoneFlexDriverCount * sizeof( mstudioboneflexdriver_t );
+	ALIGN4( pData );
+
+	for ( int i = 0; i < nBoneFlexDriverCount; ++i )
+	{
+		CDmeBoneFlexDriver *pDmeBoneFlexDriver = pDmeBoneFlexDriverList->m_eBoneFlexDriverList[i];
+		Assert( pDmeBoneFlexDriver );
+		Assert( pDmeBoneFlexDriver->m_eControlList.Count() > 0 );
+		Assert( pDmeBoneFlexDriver->GetValue< int >( "__boneIndex", -1 ) >= 0 );
+
+		pBoneFlexDriver->m_nBoneIndex = pDmeBoneFlexDriver->GetValue< int >( "__boneIndex", 0 );
+		pBoneFlexDriver->m_nControlCount = pDmeBoneFlexDriver->m_eControlList.Count();
+		pBoneFlexDriver->m_nControlIndex = pData - (byte *)pBoneFlexDriver;
+
+		mstudioboneflexdrivercontrol_t *pControl = reinterpret_cast< mstudioboneflexdrivercontrol_t * >( pData );
+
+		for ( int j = 0; j < pBoneFlexDriver->m_nControlCount; ++j )
+		{
+			CDmeBoneFlexDriverControl *pDmeControl = pDmeBoneFlexDriver->m_eControlList[j];
+			Assert( pDmeControl );
+			Assert( pDmeControl->GetValue< int >( "__flexControlIndex", -1 ) >= 0 );
+			Assert( pDmeControl->m_nBoneComponent >= STUDIO_BONE_FLEX_TX );
+			Assert( pDmeControl->m_nBoneComponent <= STUDIO_BONE_FLEX_TZ );
+
+			pControl[j].m_nFlexControllerIndex = pDmeControl->GetValue< int >( "__flexControlIndex", 0 );
+			pControl[j].m_nBoneComponent = pDmeControl->m_nBoneComponent;
+			pControl[j].m_flMin = pDmeControl->m_flMin;
+			pControl[j].m_flMax = pDmeControl->m_flMax;
+		}
+
+		pData += pBoneFlexDriver->m_nControlCount * sizeof( mstudioboneflexdrivercontrol_t );
+		ALIGN4( pData );
+
+		++pBoneFlexDriver;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Write the processed vertices
+//-----------------------------------------------------------------------------
+static void WriteVertices( studiohdr_t *phdr )
+{
+	char			fileName[MAX_PATH];
+	byte			*pStart;
+	byte			*pData;
+	int				i;
+	int				j;
+	int				k;
+	int				cur;
+
+	if (!g_nummodelsbeforeLOD)
+		return;
+
+	V_strcpy_safe( fileName, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		strcat( fileName, "platform_" );
+//		strcat( fileName, g_pPlatformName );
+//		strcat( fileName, "/" );	
+//	}
+	V_strcat_safe( fileName, "models/" );	
+	V_strcat_safe( fileName, outname );
+	Q_StripExtension( fileName, fileName, sizeof( fileName ) );
+	V_strcat_safe( fileName, ".vvd" );
+
+	if ( !g_quiet )
+	{
+		printf ("---------------------\n");
+		printf ("writing %s:\n", fileName);
+	}
+
+	pStart = (byte *)kalloc( 1, FILEBUFFER );
+	pData  = pStart;
+
+	vertexFileHeader_t *fileHeader = (vertexFileHeader_t *)pData;
+	pData += sizeof(vertexFileHeader_t);
+
+	fileHeader->id        = MODEL_VERTEX_FILE_ID;
+	fileHeader->version   = MODEL_VERTEX_FILE_VERSION;
+	fileHeader->checksum  = phdr->checksum;
+
+	// data has no fixes and requires no fixes
+	fileHeader->numFixups       = 0;
+	fileHeader->fixupTableStart = 0;
+
+	// unfinalized during first pass, fixed during second pass
+	// data can be considered as single lod at lod 0
+	fileHeader->numLODs = 1;
+	fileHeader->numLODVertexes[0] = 0;
+
+	// store vertexes grouped by mesh order
+	ALIGN16( pData );
+	fileHeader->vertexDataStart  = pData-pStart;
+	for (i = 0; i < g_nummodelsbeforeLOD; i++) 
+	{
+		s_loddata_t *pLodData = g_model[i]->m_pLodData;
+
+		// skip blank empty model
+		if (!pLodData)
+			continue;
+
+		// save vertices
+		ALIGN16( pData );
+		cur = (int)pData;
+		mstudiovertex_t *pVert = (mstudiovertex_t *)pData;
+		pData += pLodData->numvertices * sizeof( mstudiovertex_t );
+		for (j = 0; j < pLodData->numvertices; j++)
+		{
+//			printf( "saving bone weight %d for model %d at 0x%p\n",
+//				j, i, &pbone[j] );
+
+			const s_vertexinfo_t &lodVertex = pLodData->vertex[j];
+			VectorCopy( lodVertex.position, pVert[j].m_vecPosition );
+			VectorCopy( lodVertex.normal, pVert[j].m_vecNormal );
+			Vector2DCopy( lodVertex.texcoord, pVert[j].m_vecTexCoord );
+
+			mstudioboneweight_t *pBoneWeight = &pVert[j].m_BoneWeights;
+			memset( pBoneWeight, 0, sizeof( mstudioboneweight_t ) );
+			pBoneWeight->numbones = lodVertex.boneweight.numbones;
+			for (k = 0; k < pBoneWeight->numbones; k++)
+			{
+				pBoneWeight->bone[k]   = lodVertex.boneweight.bone[k];
+				pBoneWeight->weight[k] = lodVertex.boneweight.weight[k];
+			}
+		}
+
+		fileHeader->numLODVertexes[0] += pLodData->numvertices;
+
+		if (!g_quiet)
+		{
+			printf( "vertices   %7d bytes (%d vertices)\n", (int)(pData - cur), pLodData->numvertices );
+		}
+	}
+
+	// store tangents grouped by mesh order
+	ALIGN4( pData );
+	fileHeader->tangentDataStart = pData-pStart;
+	for (i = 0; i < g_nummodelsbeforeLOD; i++) 
+	{
+		s_loddata_t *pLodData = g_model[i]->m_pLodData;
+
+		// skip blank empty model
+		if (!pLodData)
+			continue;
+
+		// save tangent space S
+		ALIGN4( pData );
+		cur = (int)pData;
+		Vector4D *ptangents = (Vector4D *)pData;
+		pData += pLodData->numvertices * sizeof( Vector4D );
+		for (j = 0; j < pLodData->numvertices; j++)
+		{
+			Vector4DCopy( pLodData->vertex[j].tangentS, ptangents[j] );
+#ifdef _DEBUG
+			float w = ptangents[j].w;
+			Assert( w == 1.0f || w == -1.0f );
+#endif
+		}
+
+		if (!g_quiet)
+		{
+			printf( "tangents   %7d bytes (%d vertices)\n", (int)(pData - cur), pLodData->numvertices );
+		}
+	}
+
+	if (!g_quiet)
+	{
+		printf( "total      %7d bytes\n", pData - pStart );
+	}
+
+	// fileHeader->length = pData - pStart;
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile( fileName, pStart, pData - pStart );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Computes the maximum absolute value of any component of all vertex animation
+// pos (x,y,z) normal (x,y,z) or wrinkle
+//
+// Returns the fixed point scale and also sets appropriate values & flags in
+// passed studiohdr_t
+//-----------------------------------------------------------------------------
+float ComputeVertAnimFixedPointScale( studiohdr_t *pStudioHdr )
+{
+	float flVertAnimRange = 0.0f;
+
+	for ( int j = 0; j < g_numflexkeys; ++j )
+	{
+		if ( g_flexkey[j].numvanims <= 0 )
+			continue;
+
+		const bool bWrinkleVAnim = ( g_flexkey[j].vanimtype == STUDIO_VERT_ANIM_WRINKLE );
+
+		s_vertanim_t *pVertAnim = g_flexkey[j].vanim;
+
+		for ( int k = 0; k < g_flexkey[j].numvanims; ++k )
+		{
+			if ( fabs( pVertAnim->pos.x ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->pos.x );
+			}
+
+			if ( fabs( pVertAnim->pos.y ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->pos.y );
+			}
+
+			if ( fabs( pVertAnim->pos.z ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->pos.z );
+			}
+
+			if ( fabs( pVertAnim->normal.x ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->normal.x );
+			}
+
+			if ( fabs( pVertAnim->normal.y ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->normal.y );
+			}
+
+			if ( fabs( pVertAnim->normal.z ) > flVertAnimRange )
+			{
+				flVertAnimRange = fabs( pVertAnim->normal.z );
+			}
+
+			if ( bWrinkleVAnim )
+			{
+				if ( fabs( pVertAnim->wrinkle ) > flVertAnimRange )
+				{
+					flVertAnimRange = fabs( pVertAnim->wrinkle );
+				}
+			}
+
+			pVertAnim++;
+		}
+	}
+
+	// Legacy value
+	float flVertAnimFixedPointScale = 1.0 / 4096.0f;
+
+	if ( flVertAnimRange > 0.0f )
+	{
+		if ( flVertAnimRange > 32767 )
+		{
+			MdlWarning( "Flex value too large: %.2f, Max: 32767\n", flVertAnimRange );
+
+			flVertAnimFixedPointScale = 1.0f;
+		}
+		else
+		{
+			const float flTmpScale = flVertAnimRange / 32767.0f;
+			if ( flTmpScale > flVertAnimFixedPointScale )
+			{
+				flVertAnimFixedPointScale = flTmpScale;
+			}
+		}
+	}
+
+	if ( flVertAnimFixedPointScale != 1.0f / 4096.0f )
+	{
+		pStudioHdr->flags |= STUDIOHDR_FLAGS_VERT_ANIM_FIXED_POINT_SCALE;
+		pStudioHdr->flVertAnimFixedPointScale = flVertAnimFixedPointScale;
+	}
+
+	return flVertAnimFixedPointScale;
+}
+
+
+static void WriteModel( studiohdr_t *phdr )
+{
+	int i, j, k, m;
+	mstudiobodyparts_t	*pbodypart;
+	mstudiomodel_t		*pmodel;
+	s_source_t			*psource;
+	mstudiovertanim_t	*pvertanim;
+	s_vertanim_t		*pvanim;
+
+	int cur	= (int)pData;
+
+	// vertex data is written to external file, offsets kept internal
+	// track expected external base to store proper offsets
+	byte *externalVertexIndex   = 0;
+	byte *externalTangentsIndex = 0;
+
+	// write bodypart info
+	pbodypart = (mstudiobodyparts_t *)pData;
+	phdr->numbodyparts = g_numbodyparts;
+	phdr->bodypartindex = pData - pStart;
+	pData += g_numbodyparts * sizeof( mstudiobodyparts_t );
+
+	pmodel = (mstudiomodel_t *)pData;
+	pData += g_nummodelsbeforeLOD * sizeof( mstudiomodel_t );
+
+	for (i = 0, j = 0; i < g_numbodyparts; i++)
+	{
+		AddToStringTable( &pbodypart[i], &pbodypart[i].sznameindex, g_bodypart[i].name );
+		pbodypart[i].nummodels		= g_bodypart[i].nummodels;
+		pbodypart[i].base			= g_bodypart[i].base;
+		pbodypart[i].modelindex		= ((byte *)&pmodel[j]) - (byte *)&pbodypart[i];
+		j += g_bodypart[i].nummodels;
+	}
+	ALIGN4( pData );
+
+	// write global flex names
+	mstudioflexdesc_t *pflexdesc = (mstudioflexdesc_t *)pData;
+	phdr->numflexdesc			= g_numflexdesc;
+	phdr->flexdescindex			= pData - pStart;
+	pData += g_numflexdesc * sizeof( mstudioflexdesc_t );
+	ALIGN4( pData );
+
+	for (j = 0; j < g_numflexdesc; j++)
+	{
+		// printf("%d %s\n", j, g_flexdesc[j].FACS );
+		AddToStringTable( pflexdesc, &pflexdesc->szFACSindex, g_flexdesc[j].FACS );
+		pflexdesc++;
+	}
+
+	// write global flex controllers
+	mstudioflexcontroller_t *pflexcontroller = (mstudioflexcontroller_t *)pData;
+	phdr->numflexcontrollers	= g_numflexcontrollers;
+	phdr->flexcontrollerindex	= pData - pStart;
+	pData += g_numflexcontrollers * sizeof( mstudioflexcontroller_t );
+	ALIGN4( pData );
+
+	for (j = 0; j < g_numflexcontrollers; j++)
+	{
+		AddToStringTable( pflexcontroller, &pflexcontroller->sznameindex, g_flexcontroller[j].name );
+		AddToStringTable( pflexcontroller, &pflexcontroller->sztypeindex, g_flexcontroller[j].type );
+		pflexcontroller->min = g_flexcontroller[j].min;
+		pflexcontroller->max = g_flexcontroller[j].max;
+		pflexcontroller->localToGlobal = -1;
+		pflexcontroller++;
+	}
+
+	// write flex rules
+	mstudioflexrule_t *pflexrule = (mstudioflexrule_t *)pData;
+	phdr->numflexrules			= g_numflexrules;
+	phdr->flexruleindex			= pData - pStart;
+	pData += g_numflexrules * sizeof( mstudioflexrule_t );
+	ALIGN4( pData );
+
+	for (j = 0; j < g_numflexrules; j++)
+	{
+		pflexrule->flex		= g_flexrule[j].flex;
+		pflexrule->numops	= g_flexrule[j].numops;
+		pflexrule->opindex	= (pData - (byte *)pflexrule);
+
+		mstudioflexop_t *pflexop = (mstudioflexop_t *)pData;
+
+		for (i = 0; i < pflexrule->numops; i++)
+		{
+			pflexop[i].op = g_flexrule[j].op[i].op;
+			pflexop[i].d.index = g_flexrule[j].op[i].d.index;
+		}
+
+		pData += sizeof( mstudioflexop_t ) * pflexrule->numops;
+		ALIGN4( pData );
+
+		pflexrule++;
+	}
+
+	// write global flex controller information
+
+	mstudioflexcontrollerui_t *pFlexControllerUI = (mstudioflexcontrollerui_t *)pData;
+	phdr->numflexcontrollerui	= 0;
+	phdr->flexcontrolleruiindex	= pData - pStart;
+
+	// Loop through all defined controllers and create a UI structure for them
+	// All actual controllers will be defined as a member of some ui structure
+	// and all actual controllers can only be a member of one ui structure
+	bool *pControllerHandled = ( bool * )_alloca( g_numflexcontrollers * sizeof( bool ) );
+	memset( pControllerHandled, 0, g_numflexcontrollers * sizeof( bool ) );
+
+	for ( j = 0; j < g_numflexcontrollers; ++j )
+	{
+		// Don't handle controls twice
+		if ( pControllerHandled[ j ] )
+			continue;
+
+		const s_flexcontroller_t &flexcontroller = g_flexcontroller[ j ];
+
+		bool found = false;
+
+		// See if this controller is in the remap table
+		for ( k = 0; k < g_FlexControllerRemap.Count(); ++k )
+		{
+			s_flexcontrollerremap_t &remap = g_FlexControllerRemap[ k ];
+			if ( j == remap.m_Index || j == remap.m_LeftIndex || j == remap.m_RightIndex || j == remap.m_MultiIndex )
+			{
+				AddToStringTable( pFlexControllerUI, &pFlexControllerUI->sznameindex, remap.m_Name );
+
+				pFlexControllerUI->stereo = remap.m_bIsStereo;
+				if ( pFlexControllerUI->stereo )
+				{
+					Assert( !pControllerHandled[ remap.m_LeftIndex ] );
+					pFlexControllerUI->szindex0 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						remap.m_LeftIndex * sizeof( mstudioflexcontroller_t ) );
+					pControllerHandled[ remap.m_LeftIndex ] = true;
+
+					Assert( !pControllerHandled[ remap.m_RightIndex ] );
+					pFlexControllerUI->szindex1 = ( 
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						remap.m_RightIndex * sizeof( mstudioflexcontroller_t ) );
+					pControllerHandled[ remap.m_RightIndex ] = true;
+				}
+				else
+				{
+					Assert( !pControllerHandled[ remap.m_Index ] );
+					pFlexControllerUI->szindex0 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						remap.m_Index * sizeof( mstudioflexcontroller_t ) );
+					pControllerHandled[ remap.m_Index ] = true;
+					pFlexControllerUI->szindex1 = ( 0 );
+				}
+
+				pFlexControllerUI->remaptype = remap.m_RemapType;
+				if ( pFlexControllerUI->remaptype == FLEXCONTROLLER_REMAP_NWAY || pFlexControllerUI->remaptype == FLEXCONTROLLER_REMAP_EYELID )
+				{
+					Assert( remap.m_MultiIndex != -1 );
+					Assert( !pControllerHandled[ remap.m_MultiIndex ] );
+					pFlexControllerUI->szindex2 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						remap.m_MultiIndex * sizeof( mstudioflexcontroller_t ) );
+					pControllerHandled[ remap.m_MultiIndex ] = true;
+				}
+				else
+				{
+					pFlexControllerUI->szindex2 = 0;
+				}
+
+				found = true;
+				break;
+			}
+		}
+
+		if ( !found )
+		{
+			pFlexControllerUI->remaptype = FLEXCONTROLLER_REMAP_PASSTHRU;
+			pFlexControllerUI->szindex2 = 0;	// Unused in this case
+
+			if ( j < g_numflexcontrollers - 1 &&
+				StringAfterPrefixCaseSensitive( flexcontroller.name, "right_" ) &&
+				StringAfterPrefixCaseSensitive( g_flexcontroller[ j + 1 ].name, "left_" ) &&
+				!Q_strcmp( StringAfterPrefixCaseSensitive( flexcontroller.name, "right_" ), StringAfterPrefixCaseSensitive( g_flexcontroller[ j + 1 ].name, "left_" ) ) )
+			{
+				AddToStringTable( pFlexControllerUI, &pFlexControllerUI->sznameindex, flexcontroller.name + 6 );
+
+				pFlexControllerUI->stereo = true;
+
+				Assert( !pControllerHandled[ j + 1 ] );
+				pFlexControllerUI->szindex0 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						( j + 1 ) * sizeof( mstudioflexcontroller_t ) );
+				pControllerHandled[ j + 1 ] = true;
+
+				Assert( !pControllerHandled[ j ] );
+				pFlexControllerUI->szindex1 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						j * sizeof( mstudioflexcontroller_t ) );
+				pControllerHandled[ j ] = true;
+			}
+			else if ( j > 0 &&
+				StringAfterPrefixCaseSensitive( flexcontroller.name, "left_" ) &&
+				StringAfterPrefixCaseSensitive( g_flexcontroller[ j - 1 ].name, "right_" ) &&
+				!Q_strcmp( StringAfterPrefixCaseSensitive( flexcontroller.name, "left_" ), StringAfterPrefixCaseSensitive( g_flexcontroller[ j - 1 ].name, "right_" ) ) )
+			{
+				AddToStringTable( pFlexControllerUI, &pFlexControllerUI->sznameindex, flexcontroller.name + 5 );
+
+				pFlexControllerUI->stereo = true;
+
+				Assert( !pControllerHandled[ j ] );
+				pFlexControllerUI->szindex0 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						j * sizeof( mstudioflexcontroller_t ) );
+				pControllerHandled[ j ] = true;
+
+				Assert( !pControllerHandled[ j - 1 ] );
+				pFlexControllerUI->szindex1 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						( j - 1 ) * sizeof( mstudioflexcontroller_t ) );
+				pControllerHandled[ j - 1 ] = true;
+			}
+			else
+			{
+				AddToStringTable( pFlexControllerUI, &pFlexControllerUI->sznameindex, flexcontroller.name );
+				pFlexControllerUI->stereo = false;
+				pFlexControllerUI->szindex0 = (
+						phdr->flexcontrollerindex - int( pData - pStart ) +
+						j * sizeof( mstudioflexcontroller_t ) );
+				pFlexControllerUI->szindex1 = 0;	// Unused in this case
+				pControllerHandled[ j ] = true;
+			}
+		}
+
+		phdr->numflexcontrollerui++;
+		pData += sizeof( mstudioflexcontrollerui_t );
+		++pFlexControllerUI;
+	}
+	ALIGN4( pData );
+
+#ifdef _DEBUG
+	for ( j = 0; j < g_numflexcontrollers; ++j )
+	{
+		Assert( pControllerHandled[ j ] );
+	}
+#endif // _DEBUG
+
+	// write ik chains
+	mstudioikchain_t *pikchain = (mstudioikchain_t *)pData;
+	phdr->numikchains			= g_numikchains;
+	phdr->ikchainindex			= pData - pStart;
+	pData += g_numikchains * sizeof( mstudioikchain_t );
+	ALIGN4( pData );
+
+	for (j = 0; j < g_numikchains; j++)
+	{
+		AddToStringTable( pikchain, &pikchain->sznameindex, g_ikchain[j].name );
+		pikchain->numlinks		= g_ikchain[j].numlinks;
+
+		mstudioiklink_t *piklink = (mstudioiklink_t *)pData;
+		pikchain->linkindex		= (pData - (byte *)pikchain);
+		pData += pikchain->numlinks * sizeof( mstudioiklink_t );
+
+		for (i = 0; i < pikchain->numlinks; i++)
+		{
+			piklink[i].bone = g_ikchain[j].link[i].bone;
+			piklink[i].kneeDir = g_ikchain[j].link[i].kneeDir;
+		}
+
+		pikchain++;
+	}
+
+	// save autoplay locks
+	mstudioiklock_t *piklock = (mstudioiklock_t *)pData;
+	phdr->numlocalikautoplaylocks	= g_numikautoplaylocks;
+	phdr->localikautoplaylockindex	= pData - pStart;
+	pData += g_numikautoplaylocks * sizeof( mstudioiklock_t );
+	ALIGN4( pData );
+
+	for (j = 0; j < g_numikautoplaylocks; j++)
+	{
+		piklock->chain			= g_ikautoplaylock[j].chain;
+		piklock->flPosWeight	= g_ikautoplaylock[j].flPosWeight;
+		piklock->flLocalQWeight	= g_ikautoplaylock[j].flLocalQWeight;
+		piklock++;
+	}
+
+	// save mouth info
+	mstudiomouth_t *pmouth = (mstudiomouth_t *)pData;
+	phdr->nummouths = g_nummouths;
+	phdr->mouthindex = pData - pStart;
+	pData += g_nummouths * sizeof( mstudiomouth_t );
+	ALIGN4( pData );
+
+	for (i = 0; i < g_nummouths; i++) {
+		pmouth[i].bone			= g_mouth[i].bone;
+		VectorCopy( g_mouth[i].forward, pmouth[i].forward );
+		pmouth[i].flexdesc = g_mouth[i].flexdesc;
+	}
+
+	// save pose parameters
+	mstudioposeparamdesc_t *ppose = (mstudioposeparamdesc_t *)pData;
+	phdr->numlocalposeparameters = g_numposeparameters;
+	phdr->localposeparamindex = pData - pStart;
+	pData += g_numposeparameters * sizeof( mstudioposeparamdesc_t );
+	ALIGN4( pData );
+
+	for (i = 0; i < g_numposeparameters; i++)
+	{
+		AddToStringTable( &ppose[i], &ppose[i].sznameindex, g_pose[i].name );
+		ppose[i].start	= g_pose[i].min;
+		ppose[i].end	= g_pose[i].max;
+		ppose[i].flags	= g_pose[i].flags;
+		ppose[i].loop	= g_pose[i].loop;
+	}
+
+	if( !g_quiet )
+	{
+		printf("ik/pose    %7d bytes\n", (int)(pData - cur) );
+	}
+	cur = (int)pData;
+
+	const float flVertAnimFixedPointScale = ComputeVertAnimFixedPointScale( phdr );
+
+	// write model
+	for (i = 0; i < g_nummodelsbeforeLOD; i++) 
+	{
+		int n = 0;
+
+		byte *pModelStart = (byte *)(&pmodel[i]);
+		
+		strcpy( pmodel[i].name, g_model[i]->filename );
+		// AddToStringTable( &pmodel[i], &pmodel[i].sznameindex, g_model[i]->filename );
+
+		// pmodel[i].mrmbias = g_model[i]->mrmbias;
+		// pmodel[i].minresolution = g_model[i]->minresolution;
+		// pmodel[i].maxresolution = g_model[i]->maxresolution;
+
+		// save bbox info
+		
+		psource = g_model[i]->source;
+		s_loddata_t *pLodData = g_model[i]->m_pLodData;
+
+		// save mesh info
+		if (pLodData)
+		{
+			pmodel[i].numvertices = pLodData->numvertices;
+		}
+		else
+		{
+			// empty model
+			pmodel[i].numvertices = 0;
+		}
+
+		if ( pmodel[i].numvertices >= MAXSTUDIOVERTS )
+		{
+			// We have to check this here so that we don't screw up decal
+			// vert caching in the runtime.
+			MdlError( "Too many verts in model. (%d verts, MAXSTUDIOVERTS==%d)\n", 
+				pmodel[i].numvertices, ( int )MAXSTUDIOVERTS );
+		}
+
+		mstudiomesh_t *pmesh = (mstudiomesh_t *)pData;
+		pmodel[i].meshindex = (pData - pModelStart);
+		pData += psource->nummeshes * sizeof( mstudiomesh_t );
+		ALIGN4( pData );
+
+		pmodel[i].nummeshes = psource->nummeshes;
+		for (m = 0; m < pmodel[i].nummeshes; m++)
+		{
+			n = psource->meshindex[m];
+
+			pmesh[m].material     = n;
+			pmesh[m].modelindex   = (byte *)&pmodel[i] - (byte *)&pmesh[m];
+			pmesh[m].numvertices  = pLodData->mesh[n].numvertices;
+			pmesh[m].vertexoffset = pLodData->mesh[n].vertexoffset;
+		}
+
+		// set expected base offsets to external data
+		ALIGN16( externalVertexIndex );
+		pmodel[i].vertexindex = (int)externalVertexIndex; 
+		externalVertexIndex += pmodel[i].numvertices * sizeof(mstudiovertex_t);
+
+		// set expected base offsets to external data
+		ALIGN4( externalTangentsIndex );
+		pmodel[i].tangentsindex = (int)externalTangentsIndex;
+		externalTangentsIndex += pmodel[i].numvertices * sizeof( Vector4D );
+
+		cur = (int)pData;
+
+		// save eyeballs
+		mstudioeyeball_t *peyeball;
+		peyeball					= (mstudioeyeball_t *)pData;
+		pmodel[i].numeyeballs		= g_model[i]->numeyeballs;
+		pmodel[i].eyeballindex		= pData - pModelStart;
+		pData += g_model[i]->numeyeballs * sizeof( mstudioeyeball_t );
+			
+		ALIGN4( pData );
+		for (j = 0; j < g_model[i]->numeyeballs; j++)
+		{
+			k = g_model[i]->eyeball[j].mesh;
+			pmesh[k].materialtype		= 1;	// FIXME: tag custom material
+			pmesh[k].materialparam		= j;	// FIXME: tag custom material
+
+			peyeball[j].bone			= g_model[i]->eyeball[j].bone;
+			VectorCopy( g_model[i]->eyeball[j].org, peyeball[j].org );
+			peyeball[j].zoffset			= g_model[i]->eyeball[j].zoffset;
+			peyeball[j].radius			= g_model[i]->eyeball[j].radius;
+			VectorCopy( g_model[i]->eyeball[j].up, peyeball[j].up );
+			VectorCopy( g_model[i]->eyeball[j].forward, peyeball[j].forward );
+			peyeball[j].iris_scale		= g_model[i]->eyeball[j].iris_scale;
+
+			for (k = 0; k < 3; k++)
+			{
+				peyeball[j].upperflexdesc[k]	= g_model[i]->eyeball[j].upperflexdesc[k];
+				peyeball[j].lowerflexdesc[k]	= g_model[i]->eyeball[j].lowerflexdesc[k];
+				peyeball[j].uppertarget[k]		= g_model[i]->eyeball[j].uppertarget[k];
+				peyeball[j].lowertarget[k]		= g_model[i]->eyeball[j].lowertarget[k];
+			}
+
+			peyeball[j].upperlidflexdesc	= g_model[i]->eyeball[j].upperlidflexdesc;
+			peyeball[j].lowerlidflexdesc	= g_model[i]->eyeball[j].lowerlidflexdesc;
+		}	
+
+		if ( !g_quiet )
+		{
+			printf("eyeballs   %7d bytes (%d eyeballs)\n", (int)(pData - cur), g_model[i]->numeyeballs );
+		}
+
+		// move flexes into individual meshes
+		cur = (int)pData;
+		for (m = 0; m < pmodel[i].nummeshes; m++)
+		{
+			int numflexkeys[MAXSTUDIOFLEXKEYS];
+			pmesh[m].numflexes = 0;
+
+			// initialize array
+			for (j = 0; j < g_numflexkeys; j++)
+			{
+				numflexkeys[j] = 0;
+			}
+
+			// count flex instances per mesh
+			for (j = 0; j < g_numflexkeys; j++)
+			{
+				if (g_flexkey[j].imodel == i)
+				{
+					for (k = 0; k < g_flexkey[j].numvanims; k++)
+					{
+						n = g_flexkey[j].vanim[k].vertex - pmesh[m].vertexoffset;
+						if (n >= 0 && n < pmesh[m].numvertices)
+						{
+							if (numflexkeys[j]++ == 0)
+							{
+								pmesh[m].numflexes++;
+							}
+						}
+					}
+				}
+			}
+
+			if (pmesh[m].numflexes)
+			{
+				pmesh[m].flexindex	= ( pData - (byte *)&pmesh[m] );
+				mstudioflex_t *pflex = (mstudioflex_t *)pData;
+				pData += pmesh[m].numflexes * sizeof( mstudioflex_t );
+				ALIGN4( pData );
+
+				for (j = 0; j < g_numflexkeys; j++)
+				{
+					if (!numflexkeys[j])
+						continue;
+
+					pflex->flexdesc		= g_flexkey[j].flexdesc;
+					pflex->target0		= g_flexkey[j].target0;
+					pflex->target1		= g_flexkey[j].target1;
+					pflex->target2		= g_flexkey[j].target2;
+					pflex->target3		= g_flexkey[j].target3;
+					pflex->numverts		= numflexkeys[j];
+					pflex->vertindex	= (pData - (byte *)pflex);
+					pflex->flexpair		= g_flexkey[j].flexpair;
+					pflex->vertanimtype	= g_flexkey[j].vanimtype;
+
+					// printf("%d %d %s : %f %f %f %f\n", j, g_flexkey[j].flexdesc, g_flexdesc[g_flexkey[j].flexdesc].FACS, g_flexkey[j].target0, g_flexkey[j].target1, g_flexkey[j].target2, g_flexkey[j].target3 );
+					// if (j < 9) printf("%d %d %s : %d (%d) %f\n", j, g_flexkey[j].flexdesc, g_flexdesc[g_flexkey[j].flexdesc].FACS, g_flexkey[j].numvanims, pflex->numverts, g_flexkey[j].target );
+
+					// printf("%d %d : %d %f\n", j, g_flexkey[j].flexnum, g_flexkey[j].numvanims, g_flexkey[j].target );
+
+					pvanim = g_flexkey[j].vanim;
+
+					bool bWrinkleVAnim = ( pflex->vertanimtype == STUDIO_VERT_ANIM_WRINKLE );
+					int nVAnimDeltaSize = bWrinkleVAnim ? sizeof(mstudiovertanim_wrinkle_t) : sizeof(mstudiovertanim_t);
+
+					pvertanim = (mstudiovertanim_t *)pData;
+					pData += pflex->numverts * nVAnimDeltaSize;
+					ALIGN4( pData );
+				
+					for ( k = 0; k < g_flexkey[j].numvanims; k++ )
+					{
+						n = g_flexkey[j].vanim[k].vertex - pmesh[m].vertexoffset;
+						if ( n >= 0 && n < pmesh[m].numvertices )
+						{
+							pvertanim->index = n;
+							pvertanim->speed = 255.0F*pvanim->speed;
+							pvertanim->side  = 255.0F*pvanim->side;
+
+							pvertanim->SetDeltaFloat( pvanim->pos );
+							pvertanim->SetNDeltaFloat( pvanim->normal );
+							
+							if ( bWrinkleVAnim )
+							{
+								( (mstudiovertanim_wrinkle_t*)pvertanim )->SetWrinkleFixed( pvanim->wrinkle, flVertAnimFixedPointScale );
+							}
+
+							pvertanim = (mstudiovertanim_t*)( (byte*)pvertanim + nVAnimDeltaSize );
+
+							/*
+							if ((tmp - pvanim->pos).Length() > 0.1)
+							{	
+								pvertanim->delta.x = pvanim->pos.x;
+								printf("%f %f %f  : %f %f %f\n", 
+									pvanim->pos[0], pvanim->pos[1], pvanim->pos[2],
+									tmp.x, tmp.y, tmp.z );
+							}
+							*/
+							// if (j < 9) printf("%d %.2f %.2f %.2f\n", n, pvanim->pos[0], pvanim->pos[1], pvanim->pos[2] );
+						}
+						// printf("%d %.2f %.2f %.2f\n", pvanim->vertex, pvanim->pos[0], pvanim->pos[1], pvanim->pos[2] );
+						pvanim++;
+					}
+					pflex++;
+				}
+			}
+		}
+
+		if( !g_quiet )
+		{
+			printf("flexes     %7d bytes (%d flexes)\n", (int)(pData - cur), g_numflexkeys );
+		}
+		cur = (int)pData;
+	}
+
+
+	ALIGN4( pData );
+
+	mstudiomodelgroup_t *pincludemodel = (mstudiomodelgroup_t *)pData;
+	phdr->numincludemodels = g_numincludemodels;
+	phdr->includemodelindex = pData - pStart;
+	pData += g_numincludemodels * sizeof( mstudiomodelgroup_t );
+
+	for (i = 0; i < g_numincludemodels; i++)
+	{
+		AddToStringTable( pincludemodel, &pincludemodel->sznameindex, g_includemodel[i].name );
+		pincludemodel++;
+	}
+
+	// save animblock group info
+	mstudioanimblock_t *panimblock = (mstudioanimblock_t *)pData;
+	phdr->numanimblocks = g_numanimblocks;
+	phdr->animblockindex = pData - pStart;
+	pData += phdr->numanimblocks * sizeof( mstudioanimblock_t );
+	ALIGN4( pData );
+
+	for (i = 1; i < g_numanimblocks; i++) 
+	{
+		panimblock[i].datastart = g_animblock[i].start - pBlockStart;
+		panimblock[i].dataend = g_animblock[i].end - pBlockStart;
+		// printf("block %d : %x %x (%d)\n", i, panimblock[i].datastart, panimblock[i].dataend, panimblock[i].dataend - panimblock[i].datastart );
+	}
+	AddToStringTable( phdr, &phdr->szanimblocknameindex, g_animblockname );
+}
+
+static void AssignMeshIDs( studiohdr_t *pStudioHdr )
+{
+	int					i;
+	int					j;
+	int					m;
+	int					numMeshes;
+	mstudiobodyparts_t	*pStudioBodyPart;
+	mstudiomodel_t		*pStudioModel;
+	mstudiomesh_t		*pStudioMesh;
+
+	numMeshes = 0;
+	for (i=0; i<pStudioHdr->numbodyparts; i++)
+	{
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+		for (j=0; j<pStudioBodyPart->nummodels; j++)
+		{
+			pStudioModel = pStudioBodyPart->pModel(j);
+			for (m=0; m<pStudioModel->nummeshes; m++)
+			{				
+				// get each mesh
+				pStudioMesh = pStudioModel->pMesh(m);
+				pStudioMesh->meshid = numMeshes + m;
+			}
+			numMeshes += pStudioModel->nummeshes;
+		}
+	}
+}
+
+	
+void LoadMaterials( studiohdr_t *phdr )
+{
+	int					i, j;
+
+	// get index of each material
+	if( phdr->textureindex != 0 )
+	{
+		for( i = 0; i < phdr->numtextures; i++ )
+		{
+			char szPath[256];
+			IMaterial *pMaterial = NULL;
+			// search through all specified directories until a valid material is found
+			for( j = 0; j < phdr->numcdtextures && IsErrorMaterial( pMaterial ); j++ )
+			{
+				strcpy( szPath, phdr->pCdtexture( j ) );
+				strcat( szPath, phdr->pTexture( i )->pszName( ) );
+
+				pMaterial = g_pMaterialSystem->FindMaterial( szPath, TEXTURE_GROUP_OTHER, false );
+			}
+			if( IsErrorMaterial( pMaterial ) && !g_quiet )
+			{
+				// hack - if it isn't found, go through the motions of looking for it again
+				// so that the materialsystem will give an error.
+				for( j = 0; j < phdr->numcdtextures; j++ )
+				{
+					strcpy( szPath, phdr->pCdtexture( j ) );
+					strcat( szPath, phdr->pTexture( i )->pszName( ) );
+					g_pMaterialSystem->FindMaterial( szPath, TEXTURE_GROUP_OTHER, true );
+				}
+			}
+
+			phdr->pTexture( i )->material = pMaterial;
+
+			// FIXME: hack, needs proper client side material system interface
+			bool found = false;
+			IMaterialVar *clientShaderVar = pMaterial->FindVar( "$clientShader", &found, false );
+			if( found )
+			{
+				if (stricmp( clientShaderVar->GetStringValue(), "MouthShader") == 0)
+				{
+					phdr->pTexture( i )->flags = 1;
+				}
+				phdr->pTexture( i )->used = 1;
+			}
+		}
+	}
+}
+
+
+void WriteKeyValues( studiohdr_t *phdr, CUtlVector< char > *pKeyValue )
+{
+	phdr->keyvalueindex = (pData - pStart);
+	phdr->keyvaluesize = KeyValueTextSize( pKeyValue );
+	if (phdr->keyvaluesize)
+	{
+		memcpy(	pData, KeyValueText( pKeyValue ), phdr->keyvaluesize );
+
+		// Add space for a null terminator
+		pData[phdr->keyvaluesize] = 0;
+		++phdr->keyvaluesize;
+
+		pData += phdr->keyvaluesize * sizeof( char );
+	}
+	ALIGN4( pData );
+}
+
+
+void WriteSeqKeyValues( mstudioseqdesc_t *pseqdesc, CUtlVector< char > *pKeyValue )
+{
+	pseqdesc->keyvalueindex = (pData - (byte *)pseqdesc);
+	pseqdesc->keyvaluesize = KeyValueTextSize( pKeyValue );
+	if (pseqdesc->keyvaluesize)
+	{
+		memcpy(	pData, KeyValueText( pKeyValue ), pseqdesc->keyvaluesize );
+
+		// Add space for a null terminator
+		pData[pseqdesc->keyvaluesize] = 0;
+		++pseqdesc->keyvaluesize;
+
+		pData += pseqdesc->keyvaluesize * sizeof( char );
+	}
+	ALIGN4( pData );
+}
+
+
+void EnsureFileDirectoryExists( const char *pFilename )
+{
+	char dirName[MAX_PATH];
+	Q_strncpy( dirName, pFilename, sizeof( dirName ) );
+	Q_FixSlashes( dirName );
+	char *pLastSlash = strrchr( dirName, CORRECT_PATH_SEPARATOR );
+	if ( pLastSlash )
+	{
+		*pLastSlash = 0;
+
+		if ( _access( dirName, 0 ) != 0 )
+		{
+			char cmdLine[512];
+			Q_snprintf( cmdLine, sizeof( cmdLine ), "md \"%s\"", dirName );
+			system( cmdLine );
+		}
+	}
+}
+
+
+void WriteModelFiles(void)
+{
+	FileHandle_t modelouthandle = 0;
+	FileHandle_t blockouthandle = 0;
+	CPlainAutoPtr< CP4File > spFileBlockOut, spFileModelOut;
+	int			total = 0;
+	int			i;
+	char		filename[MAX_PATH];
+	studiohdr_t *phdr;
+	studiohdr_t *pblockhdr = 0;
+
+	pStart = (byte *)kalloc( 1, FILEBUFFER );
+
+	pBlockData = NULL;
+	pBlockStart = NULL;
+
+	Q_StripExtension( outname, outname, sizeof( outname ) );
+		
+	if (g_animblocksize != 0)
+	{
+		// write the non-default g_sequence group data to separate files
+		sprintf( g_animblockname, "models/%s.ani", outname );
+
+		V_strcpy_safe( filename, gamedir );
+		V_strcat_safe( filename, g_animblockname );	
+
+		EnsureFileDirectoryExists( filename );
+
+		if (!g_bVerifyOnly)
+		{
+			spFileBlockOut.Attach( g_p4factory->AccessFile( filename ) );
+			spFileBlockOut->Edit();
+
+			// Create the directory hierarchy for the ANI
+			char parentdir[MAX_PATH];	 
+			V_strcpy_safe( parentdir, filename );
+			V_StripFilename( parentdir );
+			g_pFullFileSystem->CreateDirHierarchy( parentdir );
+
+			blockouthandle = SafeOpenWrite( filename );
+		}
+
+		pBlockStart = (byte *)kalloc( 1, FILEBUFFER );
+		pBlockData = pBlockStart;
+
+		pblockhdr = (studiohdr_t *)pBlockData;
+		pblockhdr->id = IDSTUDIOANIMGROUPHEADER;
+		pblockhdr->version = STUDIO_VERSION;
+
+		pBlockData += sizeof( *pblockhdr ); 
+	}
+
+//
+// write the g_model output file
+//
+	phdr = (studiohdr_t *)pStart;
+
+	phdr->id = IDSTUDIOHEADER;
+	phdr->version = STUDIO_VERSION;
+
+	V_strcat_safe (outname, ".mdl");
+
+	// strcpy( outname, ExpandPath( outname ) );
+
+	V_strcpy_safe( filename, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		strcat( filename, "platform_" );
+//		strcat( filename, g_pPlatformName );
+//		strcat( filename, "/" );
+//	}
+	V_strcat_safe( filename, "models/" );	
+	V_strcat_safe( filename, outname );	
+
+	
+	// Create the directory.
+	EnsureFileDirectoryExists( filename );
+
+
+	if( !g_quiet )
+	{
+		printf ("---------------------\n");
+		printf ("writing %s:\n", filename);
+	}
+
+	LoadPreexistingSequenceOrder( filename );
+
+	if (!g_bVerifyOnly)
+	{
+		spFileModelOut.Attach( g_p4factory->AccessFile( filename ) );
+		spFileModelOut->Edit();
+
+		// Create the directory hierarchy for the MDL
+		char parentdir[MAX_PATH];	 
+		V_strcpy_safe( parentdir, filename );
+		V_StripFilename( parentdir );
+		g_pFullFileSystem->CreateDirHierarchy( parentdir );
+
+		modelouthandle = SafeOpenWrite (filename);
+	}
+
+	phdr->eyeposition = eyeposition;
+	phdr->illumposition = illumposition;
+
+	if ( !g_wrotebbox && g_sequence.Count() > 0)
+	{
+		VectorCopy( g_sequence[0].bmin, bbox[0] );
+		VectorCopy( g_sequence[0].bmax, bbox[1] );
+		CollisionModel_ExpandBBox( bbox[0], bbox[1] );
+		VectorCopy( bbox[0], g_sequence[0].bmin );
+		VectorCopy( bbox[1], g_sequence[0].bmax );
+	}
+	if ( !g_wrotecbox )
+	{
+		// no default clipping box, just use per-sequence box
+		VectorCopy( vec3_origin, cbox[0] );
+		VectorCopy( vec3_origin, cbox[1] );
+	}
+
+	phdr->hull_min = bbox[0]; 
+	phdr->hull_max = bbox[1]; 
+	phdr->view_bbmin = cbox[0]; 
+	phdr->view_bbmax = cbox[1]; 
+
+	phdr->flags = gflags;
+	phdr->mass = GetCollisionModelMass();	
+	phdr->constdirectionallightdot = g_constdirectionalightdot;
+
+	if ( g_numAllowedRootLODs > 0 )
+	{
+		phdr->numAllowedRootLODs = g_numAllowedRootLODs;
+	}
+
+	pData = (byte *)phdr + sizeof( studiohdr_t );
+
+	// FIXME: Remove when we up the model version
+	phdr->studiohdr2index = ( pData - pStart );
+	studiohdr2_t* phdr2 = (studiohdr2_t*)pData;
+	memset( phdr2, 0, sizeof(studiohdr2_t) );
+	pData = (byte*)phdr2 + sizeof(studiohdr2_t);
+
+	phdr2->illumpositionattachmentindex = g_illumpositionattachment;
+	phdr2->flMaxEyeDeflection = g_flMaxEyeDeflection;
+
+	BeginStringTable( );
+
+	// Copy the full path for compatibility with older programs
+	//V_strcpy_safe( phdr->name, V_UnqualifiedFileName( outname ) );
+	V_strcpy_safe( phdr->name, outname );
+	AddToStringTable( phdr2, &phdr2->sznameindex, outname );
+
+	WriteBoneInfo( phdr );
+	if( !g_quiet )
+	{
+		printf("bones      %7d bytes (%d)\n", pData - pStart - total, g_numbones );
+	}
+	total = pData - pStart;
+
+	pData = WriteAnimations( pData, pStart, phdr );
+	if( !g_quiet )
+	{
+		printf("animations %7d bytes (%d anims) (%d frames) [%d:%02d]\n", pData - pStart - total, g_numani, totalframes, (int)totalseconds / 60, (int)totalseconds % 60 );
+	}
+	total  = pData - pStart;
+
+	WriteSequenceInfo( phdr );
+	if( !g_quiet )
+	{
+		printf("sequences  %7d bytes (%d seq) \n", pData - pStart - total, g_sequence.Count() );
+	}
+	total  = pData - pStart;
+
+	WriteModel( phdr );
+	/*
+	if( !g_quiet )
+	{
+		printf("models     %7d bytes\n", pData - pStart - total );
+	}
+	*/
+	total  = pData - pStart;
+
+	WriteTextures( phdr );
+	if( !g_quiet )
+	{
+ 		printf("textures   %7d bytes\n", pData - pStart - total );
+	}
+	total  = pData - pStart;
+
+	WriteKeyValues( phdr, &g_KeyValueText );
+	if( !g_quiet )
+	{
+		printf("keyvalues  %7d bytes\n", pData - pStart - total );
+	}
+	total  = pData - pStart;
+
+	WriteBoneTransforms( phdr2, phdr->pBone( 0 ) );
+	if( !g_quiet )
+	{
+		printf("bone transforms  %7d bytes\n", pData - pStart - total );
+	}
+	total  = pData - pStart;
+	if ( total > FILEBUFFER )
+	{
+		MdlError( "file exceeds %d bytes (%d)", FILEBUFFER, total );
+	}
+
+	WriteBoneFlexDrivers( phdr2 );
+	if ( !g_quiet )
+	{
+		printf("bone flex driver %7d bytes\n", pData - pStart - total );
+	}
+	total  = pData - pStart;
+	if ( total > FILEBUFFER )
+	{
+		MdlError( "file exceeds %d bytes (%d)", FILEBUFFER, total );
+	}
+
+	pData = WriteStringTable( pData );
+
+	total  = pData - pStart;
+	if ( total > FILEBUFFER )
+	{
+		MdlError( "file exceeds %d bytes (%d)", FILEBUFFER, total );
+	}
+
+	phdr->checksum = 0;
+	for (i = 0; i < total; i += 4)
+	{
+		// TODO: does this need something more than a simple shift left and add checksum?
+		phdr->checksum = (phdr->checksum << 1) + ((phdr->checksum & 0x8000000) ? 1 : 0) + *((long *)(pStart + i));
+	}
+
+	if (g_bVerifyOnly)
+		return;
+
+	CollisionModel_Write( phdr->checksum );
+
+	if( !g_quiet )
+	{
+		printf("collision  %7d bytes\n", pData - pStart - total );
+	}
+
+	AssignMeshIDs( phdr );
+
+	phdr->length = pData - pStart;
+	if( !g_quiet )
+	{
+		printf("total      %7d\n", phdr->length );
+	}
+	if ( phdr->length > FILEBUFFER )
+	{
+		MdlError( "file exceeds %d bytes (%d)", FILEBUFFER, total );
+	}
+
+	// Load materials for this model via the material system so that the
+	// optimizer can ask questions about the materials.
+	LoadMaterials( phdr );
+
+	SafeWrite( modelouthandle, pStart, phdr->length );
+
+	g_pFileSystem->Close(modelouthandle);
+	if ( spFileModelOut.IsValid() ) spFileModelOut->Add();
+
+	if (pBlockStart)
+	{
+		pblockhdr->length = pBlockData - pBlockStart;
+
+		if ( g_bX360 )
+		{
+			// Before writing this .ani, write the byteswapped version
+			void *pOutBase = kalloc(1, pblockhdr->length + BYTESWAP_ALIGNMENT_PADDING);
+			int finalSize = StudioByteSwap::ByteswapANI( phdr, pOutBase, pBlockStart, pblockhdr->length );
+			if ( finalSize == 0 )
+			{
+				MdlError("Aborted ANI byteswap on '%s':\n", g_animblockname);
+			}
+
+			char outname[ MAX_PATH ];
+			Q_StripExtension( g_animblockname, outname, sizeof( outname ) );
+			Q_strcat( outname, ".360.ani", sizeof( outname ) );
+			
+			{
+				CP4AutoEditAddFile autop4( outname );
+				SaveFile( outname, pOutBase, finalSize );
+			}
+		}
+
+		SafeWrite( blockouthandle, pBlockStart, pblockhdr->length );
+		g_pFileSystem->Close( blockouthandle );
+		if ( spFileBlockOut.IsValid() ) spFileBlockOut->Add();
+
+
+		if ( !g_quiet )
+		{
+			printf ("---------------------\n");
+			printf("writing %s:\n", g_animblockname);
+			printf("blocks	   %7d\n", g_numanimblocks );
+			printf("total      %7d\n", pblockhdr->length );
+		}
+	}
+
+	if (phdr->numbodyparts != 0)
+	{
+		// vertices have become an external peer data store
+		// write now prior to impending vertex access from any further code
+		// vertex accessors hide shifting vertex data
+		WriteVertices( phdr );
+
+	#ifdef _DEBUG
+		int bodyPartID;
+		for( bodyPartID = 0; bodyPartID < phdr->numbodyparts; bodyPartID++ )
+		{
+			mstudiobodyparts_t *pBodyPart = phdr->pBodypart( bodyPartID );
+			int modelID;
+			for( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
+			{
+				mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
+				const mstudio_modelvertexdata_t *vertData = pModel->GetVertexData();
+				Assert( vertData ); // This can only return NULL on X360 for now
+				int vertID;
+				for( vertID = 0; vertID < pModel->numvertices; vertID++ )
+				{
+					Vector4D *pTangentS = vertData->TangentS( vertID );
+					Assert( pTangentS->w == -1.0f || pTangentS->w == 1.0f );
+				}
+			}
+		}
+	#endif
+
+		if ( !g_StudioMdlCheckUVCmd.CheckUVs( g_source, g_numsources ) )
+		{
+			MdlError( "UV checks failed\n" );
+		}
+
+		OptimizedModel::WriteOptimizedFiles( phdr, g_bodypart );
+
+		// now have external finalized vtx (windings) and vvd (vertexes)
+		// re-open files, sort vertexes, perform fixups, and rewrite
+		// purposely isolated as a post process for stability
+		if (!FixupToSortedLODVertexes( phdr ))
+		{
+			MdlError("Aborted vertex sort fixup on '%s':\n", filename);
+		}
+
+		if (!Clamp_RootLOD( phdr ))
+		{
+			MdlError("Aborted root lod shift '%s':\n", filename);
+		}
+	}
+
+	if ( g_bX360 )
+	{
+		// now all files have been finalized and fixed up.
+		// re-open the files once more and swap all little-endian 
+		// data to big-endian format to produce Xbox360 files.
+		WriteAllSwappedFiles( filename );
+	}
+
+	// NOTE!  If you don't want to go through the effort of loading studiorender for perf reasons,
+	// make sure spewFlags ends up being zero.
+	unsigned int spewFlags = SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS;
+
+	if ( g_bPerf )
+	{
+		spewFlags |= SPEWPERFSTATS_SHOWPERF;
+	}
+	if( spewFlags )
+	{
+		SpewPerfStats( phdr, filename, spewFlags );
+	}
+}
+
+const vertexFileHeader_t * mstudiomodel_t::CacheVertexData( void * pModelData )
+{
+	static vertexFileHeader_t	*pVertexHdr;
+	char						filename[MAX_PATH];
+
+	Assert( pModelData == NULL );
+
+	if (pVertexHdr)
+	{
+		// studiomdl is a single model process, can simply persist data in static
+		goto hasData;
+	}
+
+	// load and persist the vertex file
+	V_strcpy_safe( filename, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		strcat( filename, "platform_" );
+//		strcat( filename, g_pPlatformName );
+//		strcat( filename, "/" );	
+//	}
+	V_strcat_safe( filename, "models/" );	
+	V_strcat_safe( filename, outname );
+	Q_StripExtension( filename, filename, sizeof( filename ) );
+	V_strcat_safe( filename, ".vvd" );
+
+	LoadFile(filename, (void**)&pVertexHdr);
+
+	// check id
+	if (pVertexHdr->id != MODEL_VERTEX_FILE_ID)
+	{
+		MdlError("Error Vertex File: '%s' (id %d should be %d)\n", filename, pVertexHdr->id, MODEL_VERTEX_FILE_ID);
+	}
+
+	// check version
+	if (pVertexHdr->version != MODEL_VERTEX_FILE_VERSION)
+	{
+		MdlError("Error Vertex File: '%s' (version %d should be %d)\n", filename, pVertexHdr->version, MODEL_VERTEX_FILE_VERSION);
+	}
+
+hasData:
+	return pVertexHdr;
+}
+
+typedef struct
+{
+	int meshVertID;
+	int	finalMeshVertID;
+	int	vertexOffset;
+	int	lodFlags;
+} usedVertex_t;
+
+typedef struct
+{
+	int	offsets[MAX_NUM_LODS];
+	int	numVertexes[MAX_NUM_LODS];
+} lodMeshInfo_t;
+
+typedef struct
+{
+	usedVertex_t	*pVertexList;
+	unsigned short	*pVertexMap;
+	int				numVertexes;
+	lodMeshInfo_t	lodMeshInfo;
+} vertexPool_t;
+
+#define ALIGN(b,s)		(((unsigned int)(b)+(s)-1)&~((s)-1))
+
+//-----------------------------------------------------------------------------
+// FindVertexOffsets
+// 
+// Iterate sorted vertex list to determine mesh starts and counts.
+//-----------------------------------------------------------------------------
+void FindVertexOffsets(int vertexOffset, int offsets[MAX_NUM_LODS], int counts[MAX_NUM_LODS], int numLods, const usedVertex_t *pVertexList, int numVertexes)
+{
+	int lodFlags;
+	int	i;
+	int	j;
+	int	k;
+
+	// vertexOffset uniquely identifies a single mesh's vertexes in lod vertex sorted list
+	// lod vertex list is sorted from lod N..lod 0
+	for (i=numLods-1; i>=0; i--)
+	{
+		offsets[i] = 0;
+		counts[i]  = 0;
+
+		lodFlags = (1<<(i+1))-1;
+		for (j=0; j<numVertexes; j++)
+		{
+			// determine start of mesh at desired lod
+			if (pVertexList[j].lodFlags > lodFlags)
+				continue;
+			if (pVertexList[j].vertexOffset != vertexOffset)
+				continue;
+
+			for (k=j; k<numVertexes; k++)
+			{
+				// determine end of mesh at desired lod
+				if (pVertexList[k].vertexOffset != vertexOffset)
+					break;
+				if (!(pVertexList[k].lodFlags & (1<<i)))
+					break;
+			}
+
+			offsets[i] = j;
+			counts[i]  = k-j;
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// _CompareUsedVertexes
+// 
+// qsort callback
+//-----------------------------------------------------------------------------
+static int _CompareUsedVertexes(const void *a, const void *b)
+{
+	usedVertex_t	*pVertexA;
+	usedVertex_t	*pVertexB;
+	int				sort;
+	int				lodA;
+	int				lodB;
+
+	pVertexA = (usedVertex_t*)a;
+	pVertexB = (usedVertex_t*)b;
+
+	// determine highest (lowest detail) lod
+	// forces grouping into discrete MAX_NUM_LODS sections
+	lodA = Q_log2(pVertexA->lodFlags);
+	lodB = Q_log2(pVertexB->lodFlags);
+
+	// descending sort (LodN..Lod0)
+	sort = lodB-lodA;
+	if (sort)
+		return sort;
+
+	// within same lod, sub sort (ascending) by mesh
+	sort = pVertexA->vertexOffset - pVertexB->vertexOffset;
+	if (sort)
+		return sort;
+	
+	// within same mesh, sub sort (ascending) by vertex
+	sort = pVertexA->meshVertID - pVertexB->meshVertID;
+	return sort;
+}
+
+//-----------------------------------------------------------------------------
+// BuildSortedVertexList
+// 
+// Generates the sorted vertex list. Routine is purposely serial to
+// ensure vertex integrity.
+//-----------------------------------------------------------------------------
+bool BuildSortedVertexList(const studiohdr_t *pStudioHdr, const void *pVtxBuff, vertexPool_t **ppVertexPools, int *pNumVertexPools, usedVertex_t **ppVertexList, int *pNumVertexes)
+{
+	OptimizedModel::FileHeader_t		*pVtxHdr;
+	OptimizedModel::BodyPartHeader_t	*pBodyPartHdr;
+	OptimizedModel::ModelHeader_t		*pModelHdr;
+	OptimizedModel::ModelLODHeader_t	*pModelLODHdr;
+	OptimizedModel::MeshHeader_t		*pMeshHdr;
+	OptimizedModel::StripGroupHeader_t	*pStripGroupHdr;
+	OptimizedModel::Vertex_t			*pStripVertex;
+	mstudiobodyparts_t					*pStudioBodyPart;
+	mstudiomodel_t						*pStudioModel;
+	mstudiomesh_t						*pStudioMesh;
+	usedVertex_t						*usedVertexes;
+	vertexPool_t						*pVertexPools;
+	vertexPool_t						*pPool;
+	usedVertex_t						*pVertexList;
+	int									*pVertexes;
+	unsigned short						*pVertexMap;
+	int									index;
+	int									currLod;
+	int									vertexOffset;
+	int									i,j,k,m,n,p;
+	int									poolStart;
+	int									numVertexPools;
+	int									numVertexes;
+	int									numMeshVertexes;
+	int									offsets[MAX_NUM_LODS];
+	int									counts[MAX_NUM_LODS];
+	int									finalMeshVertID;
+	int									baseMeshVertID;
+
+	*ppVertexPools   = NULL;
+	*pNumVertexPools = 0;
+	*ppVertexList    = NULL;
+	*pNumVertexes    = 0;
+
+	pVtxHdr = (OptimizedModel::FileHeader_t*)pVtxBuff; 
+
+	// determine number of vertex pools
+	if (pStudioHdr->numbodyparts != pVtxHdr->numBodyParts)
+		return false;
+	numVertexPools = 0;
+	for (i=0; i<pVtxHdr->numBodyParts; i++)
+	{
+		pBodyPartHdr    = pVtxHdr->pBodyPart(i);
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+		if (pStudioBodyPart->nummodels != pBodyPartHdr->numModels)
+			return false;
+
+		// the model's subordinate lods only reference from a single top level pool 
+		// no new verts are created for sub lods
+		// each model's subordinate mesh dictates its own vertex pool
+		for (j=0; j<pBodyPartHdr->numModels; j++)
+		{
+			pStudioModel    = pStudioBodyPart->pModel(j);
+			numVertexPools += pStudioModel->nummeshes;
+		}
+	}
+
+	// allocate pools
+	pVertexPools = (vertexPool_t*)malloc(numVertexPools*sizeof(vertexPool_t));
+	memset(pVertexPools, 0, numVertexPools*sizeof(vertexPool_t));
+
+	// iterate lods, mark referenced indexes
+	numVertexPools = 0;
+	for (i=0; i<pVtxHdr->numBodyParts; i++)
+	{
+		pBodyPartHdr    = pVtxHdr->pBodyPart(i);
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+
+		for (j=0; j<pBodyPartHdr->numModels; j++)
+		{
+			pModelHdr    = pBodyPartHdr->pModel(j);
+			pStudioModel = pStudioBodyPart->pModel(j);
+
+			// allocate each mesh's vertex list
+			poolStart = numVertexPools;
+			for (k=0; k<pStudioModel->nummeshes; k++)
+			{
+				// track the expected relative offset into a flattened vertex list
+				vertexOffset = 0;
+				for (m=0; m<poolStart+k; m++)
+					vertexOffset += pVertexPools[m].numVertexes;
+
+				pStudioMesh = pStudioModel->pMesh(k);
+				numMeshVertexes = pStudioMesh->numvertices;
+				if (numMeshVertexes)
+				{
+					usedVertexes = (usedVertex_t*)malloc(numMeshVertexes*sizeof(usedVertex_t));
+					pVertexMap   = (unsigned short*)malloc(numMeshVertexes*sizeof(unsigned short));
+
+					for (n=0; n<numMeshVertexes; n++)
+					{
+						// setup mapping
+						// due to the hierarchial layout, the vertID's map per mesh's pool
+						// a linear layout of the vertexes requires a unique signature to achieve a remap
+						// the offset and index form a unique signature
+						usedVertexes[n].meshVertID      = n;
+						usedVertexes[n].finalMeshVertID = -1;
+						usedVertexes[n].vertexOffset    = vertexOffset;
+						usedVertexes[n].lodFlags        = 0;
+						pVertexMap[n]                   = n;
+					}
+				
+					pVertexPools[numVertexPools].pVertexList = usedVertexes;
+					pVertexPools[numVertexPools].pVertexMap  = pVertexMap;
+				}
+				pVertexPools[numVertexPools].numVertexes = numMeshVertexes;
+				numVertexPools++;
+			}
+
+			// iterate all lods
+			for (currLod=0; currLod<pVtxHdr->numLODs; currLod++)
+			{
+				pModelLODHdr = pModelHdr->pLOD(currLod);
+
+				if (pModelLODHdr->numMeshes != pStudioModel->nummeshes)
+					return false;
+
+				for (k=0; k<pModelLODHdr->numMeshes; k++)
+				{
+					pMeshHdr      = pModelLODHdr->pMesh(k);
+					pStudioMesh   = pStudioModel->pMesh(k);
+					for (m=0; m<pMeshHdr->numStripGroups; m++)
+					{
+						pStripGroupHdr = pMeshHdr->pStripGroup(m);
+						
+						// sanity check the indexes have 100% coverage of the vertexes
+						pVertexes = (int*)malloc(pStripGroupHdr->numVerts*sizeof(int));
+						memset(pVertexes, 0xFF, pStripGroupHdr->numVerts*sizeof(int));
+
+						for (n=0; n<pStripGroupHdr->numIndices; n++)
+						{
+							index = *pStripGroupHdr->pIndex(n);
+							if (index < 0 || index >= pStripGroupHdr->numVerts)
+								return false;
+							pVertexes[index] = index;
+						}
+
+						// sanity check for coverage
+						for (n=0; n<pStripGroupHdr->numVerts; n++)
+						{
+							if (pVertexes[n] != n)
+								return false;
+						}
+
+						free(pVertexes);
+
+						// iterate vertexes
+						pPool = &pVertexPools[poolStart + k];
+						for (n=0; n<pStripGroupHdr->numVerts; n++)
+						{
+							pStripVertex = pStripGroupHdr->pVertex(n);
+							if (pStripVertex->origMeshVertID < 0 || pStripVertex->origMeshVertID >= pPool->numVertexes)
+								return false;
+
+							// arrange binary flags for numerical sorting
+							// the lowest detail lod's verts at the top, the root lod's verts at the bottom
+							pPool->pVertexList[pStripVertex->origMeshVertID].lodFlags |= 1<<currLod;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// flatten the vertex pool hierarchy into a linear sequence
+	numVertexes = 0;
+	for (i=0; i<numVertexPools; i++)
+		numVertexes += pVertexPools[i].numVertexes;
+	pVertexList = (usedVertex_t*)malloc(numVertexes*sizeof(usedVertex_t));
+	numVertexes  = 0;
+	for (i=0; i<numVertexPools; i++)
+	{
+		pPool = &pVertexPools[i];
+		for (j=0; j<pPool->numVertexes; j++)
+		{
+			if (!pPool->pVertexList[j].lodFlags)
+			{
+				// found an orphaned vertex that is unreferenced at any lod strip winding
+				// don't know how these occur or who references them
+				// cannot cull the orphaned vertexes, otherwise vertex counts are wrong
+				// every vertex must be remapped
+				// force the vertex to belong to the lowest lod 
+				// lod flags must be nonzero for proper sorted runs
+				pPool->pVertexList[j].lodFlags = 1<<(pVtxHdr->numLODs-1);
+			}
+		}
+
+		memcpy(&pVertexList[numVertexes], pPool->pVertexList, pPool->numVertexes*sizeof(usedVertex_t));
+		numVertexes += pPool->numVertexes;
+	}
+
+	// sort the vertexes based on lod flags
+	// the sort dictates the linear sequencing of the .vvd data file
+	// the vtx file indexes get remapped to the new sort order
+	qsort(pVertexList, numVertexes, sizeof(usedVertex_t), _CompareUsedVertexes);
+	
+	// build a mapping table from mesh relative indexes to the flat lod sorted array
+	vertexOffset = 0;
+	for (i=0; i<numVertexPools; i++)
+	{
+		pPool = &pVertexPools[i];
+		for (j=0; j<pPool->numVertexes; j++)
+		{
+			// scan flattened sorted vertexes
+			for (k=0; k<numVertexes; k++)
+			{
+				if (pVertexList[k].vertexOffset == vertexOffset && pVertexList[k].meshVertID == j)
+					break;
+			}
+			pPool->pVertexMap[j] = k;
+		}
+		vertexOffset += pPool->numVertexes;
+	}
+
+	// build offsets and counts that identifies mesh's distribution across lods
+	// calc final fixed vertex location if vertexes were gathered to mesh order from lod sorted list
+	finalMeshVertID = 0;
+	poolStart = 0; 
+	for (i=0; i<pStudioHdr->numbodyparts; i++)
+	{
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+		for (j=0; j<pStudioBodyPart->nummodels; j++)
+		{
+			pStudioModel = pStudioBodyPart->pModel(j);
+			for (m=0; m<pStudioModel->nummeshes; m++)
+			{
+				// track the expected offset into linear vertexes
+				vertexOffset = 0;
+				for (n=0; n<poolStart+m; n++)
+					vertexOffset += pVertexPools[n].numVertexes;
+
+				// vertexOffset works as unique key to identify vertexes for a specific mesh
+				// a mesh's verts are distributed, but guaranteed sequential in the lod sorted vertex list
+				// determine base index and offset and run length for target mesh for all lod levels
+				FindVertexOffsets(vertexOffset, offsets, counts, pVtxHdr->numLODs, pVertexList, numVertexes);
+
+				for (n=0; n<pVtxHdr->numLODs; n++)
+				{
+					if (!counts[n])
+						offsets[n] = 0;
+
+					pVertexPools[poolStart+m].lodMeshInfo.offsets[n]     = offsets[n];
+					pVertexPools[poolStart+m].lodMeshInfo.numVertexes[n] = counts[n];
+				}
+
+				// iterate using calced offsets to walk each mesh
+				// set its expected final vertex id, which is its "gathered" index relative to mesh
+				baseMeshVertID = finalMeshVertID;
+				for (n=pVtxHdr->numLODs-1; n>=0; n--)
+				{
+					// iterate each vert in the mesh
+					// vertex id is relative to
+					for (p=0; p<counts[n]; p++)
+					{
+						pVertexList[offsets[n] + p].finalMeshVertID = finalMeshVertID - baseMeshVertID;
+						finalMeshVertID++;
+					}
+				}
+			}
+			poolStart += pStudioModel->nummeshes;
+		}
+	}
+
+	// safety check
+	// every referenced vertex should have been remapped correctly
+	// some models do have orphaned vertexes, ignore these
+	for (i=0; i<numVertexes; i++)
+	{
+		if (pVertexList[i].lodFlags && pVertexList[i].finalMeshVertID == -1)
+		{
+			// should never happen, data occured in unknown manner
+			// don't build corrupted data
+			return false;
+		}
+	}
+
+	// provide generated tables
+	*ppVertexPools   = pVertexPools;
+	*pNumVertexPools = numVertexPools;
+	*ppVertexList    = pVertexList;
+	*pNumVertexes    = numVertexes;
+
+	// success
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// FixupVVDFile
+// 
+// VVD files get vertexes remapped to a flat lod sorted order.
+//-----------------------------------------------------------------------------
+bool FixupVVDFile(const char *fileName,  const studiohdr_t *pStudioHdr, const void *pVtxBuff, const vertexPool_t *pVertexPools, int numVertexPools, const usedVertex_t *pVertexList, int numVertexes)
+{	
+	OptimizedModel::FileHeader_t	*pVtxHdr;
+	vertexFileHeader_t				*pFileHdr_old;
+	vertexFileHeader_t				*pFileHdr_new;
+	mstudiobodyparts_t				*pStudioBodyPart;
+	mstudiomodel_t					*pStudioModel;
+	mstudiomesh_t					*pStudioMesh;
+	mstudiovertex_t					*pVertex_old;
+	mstudiovertex_t					*pVertex_new;
+	Vector4D						*pTangent_new;
+	Vector4D						*pTangent_old;
+	mstudiovertex_t					**pFlatVertexes;
+	Vector4D						**pFlatTangents;
+	vertexFileFixup_t				*pFixupTable;
+	const lodMeshInfo_t				*pLodMeshInfo;
+	byte							*pStart_new;
+	byte							*pData_new;
+	byte							*pStart_base;
+	byte							*pVertexBase_old;
+	byte							*pTangentBase_old;
+	void							*pVvdBuff;
+	int								i;
+	int								j;
+	int								k;
+	int								n;
+	int								p;
+	int								numFixups;
+	int								numFlat;
+	int								oldIndex;
+	int								mask;
+	int								maxCount;
+	int								numMeshes;
+	int								numOutFixups;
+
+	pVtxHdr = (OptimizedModel::FileHeader_t*)pVtxBuff; 
+
+	LoadFile((char*)fileName, &pVvdBuff);
+
+	pFileHdr_old = (vertexFileHeader_t*)pVvdBuff;
+	if (pFileHdr_old->numLODs != 1)
+	{
+		// file has wrong expected state
+		return false;
+	}
+
+	// meshes need relocation fixup from lod order back to mesh order
+	numFixups = 0;
+	numMeshes = 0;
+	for (i=0; i<pStudioHdr->numbodyparts; i++)
+	{
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+		for (j=0; j<pStudioBodyPart->nummodels; j++)
+		{
+			pStudioModel = pStudioBodyPart->pModel(j);
+			for (k=0; k<pStudioModel->nummeshes; k++)
+			{
+				pStudioMesh = pStudioModel->pMesh(k);
+				if (!pStudioMesh->numvertices)
+				{
+					// no vertexes for this mesh, skip it
+					continue;
+				}
+				for (n=pVtxHdr->numLODs-1; n>=0; n--)
+				{
+					pLodMeshInfo = &pVertexPools[numMeshes+k].lodMeshInfo;
+					if (!pLodMeshInfo->numVertexes[n])
+					{
+						// no vertexes for this portion of the mesh at this lod, skip it
+						continue;
+					}
+					numFixups++;
+				}
+			}
+			numMeshes += k;
+		}
+	}
+	if (numMeshes == 1 || numFixups == 1 || pVtxHdr->numLODs == 1)
+	{
+		// no fixup required for a single mesh
+		// no fixup required for single lod
+		// no fixup required when mesh data is contiguous as expected
+		numFixups = 0;
+	}
+
+	pStart_base = (byte*)malloc(FILEBUFFER);
+	memset(pStart_base, 0, FILEBUFFER);
+	pStart_new  = (byte*)ALIGN(pStart_base,16);
+	pData_new   = pStart_new;
+
+	// setup headers
+	pFileHdr_new = (vertexFileHeader_t*)pData_new;
+	pData_new += sizeof(vertexFileHeader_t);
+
+	// clone and fixup new header
+	*pFileHdr_new = *pFileHdr_old;
+	pFileHdr_new->numLODs   = pVtxHdr->numLODs;
+	pFileHdr_new->numFixups = numFixups;
+
+	// skip new fixup table
+	pData_new   = (byte*)ALIGN(pData_new, 4);
+	pFixupTable = (vertexFileFixup_t*)pData_new;
+	pFileHdr_new->fixupTableStart = pData_new - pStart_new;
+	pData_new += numFixups*sizeof(vertexFileFixup_t);
+
+	// skip new vertex data
+	pData_new    = (byte*)ALIGN(pData_new, 16);
+	pVertex_new  = (mstudiovertex_t*)pData_new;
+	pFileHdr_new->vertexDataStart = pData_new - pStart_new;
+	pData_new += numVertexes*sizeof(mstudiovertex_t);
+
+	// skip new tangent data
+	pData_new    = (byte*)ALIGN(pData_new, 16);
+	pTangent_new = (Vector4D*)pData_new;
+	pFileHdr_new->tangentDataStart = pData_new - pStart_new;
+	pData_new += numVertexes*sizeof(Vector4D);
+
+	pVertexBase_old  = (byte*)pFileHdr_old + pFileHdr_old->vertexDataStart;
+	pTangentBase_old = (byte*)pFileHdr_old + pFileHdr_old->tangentDataStart;
+
+	// determine number of aggregate verts towards root lod
+	// loader can truncate read according to desired root lod
+	maxCount = -1;
+	for (n=pVtxHdr->numLODs-1; n>=0; n--)
+	{
+		mask = 1<<n;
+		for (p=0; p<numVertexes; p++)
+		{
+			if (mask & pVertexList[p].lodFlags)
+			{
+				if (maxCount < p)
+					maxCount = p;
+			}
+		}
+		pFileHdr_new->numLODVertexes[n] = maxCount+1;
+	}
+	for (n=pVtxHdr->numLODs; n<MAX_NUM_LODS; n++)
+	{
+		// ripple the last valid lod entry all the way down
+		pFileHdr_new->numLODVertexes[n] = pFileHdr_new->numLODVertexes[pVtxHdr->numLODs-1];
+	}
+	
+	// build mesh relocation fixup table
+	if (numFixups)
+	{
+		numMeshes    = 0;
+		numOutFixups = 0;
+		for (i=0; i<pStudioHdr->numbodyparts; i++)
+		{
+			pStudioBodyPart = pStudioHdr->pBodypart(i);
+			for (j=0; j<pStudioBodyPart->nummodels; j++)
+			{
+				pStudioModel = pStudioBodyPart->pModel(j);
+				for (k=0; k<pStudioModel->nummeshes; k++)
+				{
+					pStudioMesh = pStudioModel->pMesh(k);
+					if (!pStudioMesh->numvertices)
+					{
+						// not vertexes for this mesh, skip it
+						continue;
+					}
+					for (n=pVtxHdr->numLODs-1; n>=0; n--)
+					{
+						pLodMeshInfo = &pVertexPools[numMeshes+k].lodMeshInfo;
+						if (!pLodMeshInfo->numVertexes[n])
+						{
+							// no vertexes for this portion of the mesh at this lod, skip it
+							continue;
+						}
+						pFixupTable[numOutFixups].lod            = n;
+						pFixupTable[numOutFixups].numVertexes    = pLodMeshInfo->numVertexes[n];
+						pFixupTable[numOutFixups].sourceVertexID = pLodMeshInfo->offsets[n];
+						numOutFixups++;
+					}
+				}
+				numMeshes += pStudioModel->nummeshes;
+			}
+		}
+
+		if (numOutFixups != numFixups)
+		{
+			// logic sync error, final calc should match precalc, otherwise memory corruption
+			return false;
+		}
+	}
+
+	// generate offsets to vertexes
+	numFlat = 0;
+	pFlatVertexes = (mstudiovertex_t**)malloc(numVertexes*sizeof(mstudiovertex_t*));
+	pFlatTangents = (Vector4D**)malloc(numVertexes*sizeof(Vector4D*));
+	for (i=0; i<pStudioHdr->numbodyparts; i++)
+	{
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+		for (j=0; j<pStudioBodyPart->nummodels; j++)
+		{
+			pStudioModel = pStudioBodyPart->pModel(j);
+			pVertex_old  = (mstudiovertex_t*)&pVertexBase_old[pStudioModel->vertexindex];
+			pTangent_old = (Vector4D*)&pTangentBase_old[pStudioModel->tangentsindex];
+			for (k=0; k<pStudioModel->nummeshes; k++)
+			{
+				// get each mesh's vertexes
+				pStudioMesh = pStudioModel->pMesh(k);
+				for (n=0; n<pStudioMesh->numvertices; n++)
+				{
+					// old vertex pools are per model, seperated per mesh by a start offset
+					// vertexes are then isolated subpools per mesh
+					// build the flat linear array of lookup pointers
+					pFlatVertexes[numFlat] = &pVertex_old[pStudioMesh->vertexoffset + n];
+					pFlatTangents[numFlat] = &pTangent_old[pStudioMesh->vertexoffset + n];
+					numFlat++;
+				}
+			}
+		}
+	}
+
+	// write in lod sorted order
+	for (i=0; i<numVertexes; i++)
+	{
+		// iterate sorted order, remap old vert location to new vert location
+		oldIndex = pVertexList[i].vertexOffset + pVertexList[i].meshVertID;
+		
+		memcpy(&pVertex_new[i], pFlatVertexes[oldIndex], sizeof(mstudiovertex_t));
+		memcpy(&pTangent_new[i], pFlatTangents[oldIndex], sizeof(Vector4D));
+	}
+
+	// pFileHdr_new->length =  pData_new-pStart_new;
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile((char*)fileName, pStart_new, pData_new-pStart_new);
+	}
+
+	free(pStart_base);
+	free(pFlatVertexes);
+	free(pFlatTangents);
+
+	// success
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// FixupVTXFile
+// 
+// VTX files get their windings remapped.
+//-----------------------------------------------------------------------------
+bool FixupVTXFile(const char *fileName, const studiohdr_t *pStudioHdr, const vertexPool_t *pVertexPools, int numVertexPools, const usedVertex_t *pVertexList, int numVertexes)
+{
+	OptimizedModel::FileHeader_t		*pVtxHdr;
+	OptimizedModel::BodyPartHeader_t	*pBodyPartHdr;
+	OptimizedModel::ModelHeader_t		*pModelHdr;
+	OptimizedModel::ModelLODHeader_t	*pModelLODHdr;
+	OptimizedModel::MeshHeader_t		*pMeshHdr;
+	OptimizedModel::StripGroupHeader_t	*pStripGroupHdr;
+	OptimizedModel::Vertex_t			*pStripVertex;
+	int									currLod;
+	int									vertexOffset;
+	mstudiobodyparts_t					*pStudioBodyPart;
+	mstudiomodel_t						*pStudioModel;
+	int									i,j,k,m,n;
+	int									poolStart;
+	int									VtxLen;
+	int									newMeshVertID;
+	void								*pVtxBuff;
+
+	VtxLen  = LoadFile((char*)fileName, &pVtxBuff);
+	pVtxHdr = (OptimizedModel::FileHeader_t*)pVtxBuff; 
+
+	// iterate all lod's windings
+	poolStart = 0;
+	for (i=0; i<pVtxHdr->numBodyParts; i++)
+	{
+		pBodyPartHdr    = pVtxHdr->pBodyPart(i);
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+
+		for (j=0; j<pBodyPartHdr->numModels; j++)
+		{
+			pModelHdr    = pBodyPartHdr->pModel(j);
+			pStudioModel = pStudioBodyPart->pModel(j);
+
+			// iterate all lods
+			for (currLod=0; currLod<pVtxHdr->numLODs; currLod++)
+			{
+				pModelLODHdr = pModelHdr->pLOD(currLod);
+
+				if (pModelLODHdr->numMeshes != pStudioModel->nummeshes)
+					return false;
+
+				for (k=0; k<pModelLODHdr->numMeshes; k++)
+				{
+					// track the expected relative offset into the flat vertexes
+					vertexOffset = 0;
+					for (m=0; m<poolStart+k; m++)
+						vertexOffset += pVertexPools[m].numVertexes;
+
+					pMeshHdr = pModelLODHdr->pMesh(k);
+					for (m=0; m<pMeshHdr->numStripGroups; m++)
+					{
+						pStripGroupHdr = pMeshHdr->pStripGroup(m);
+						
+						for (n=0; n<pStripGroupHdr->numVerts; n++)
+						{
+							pStripVertex = pStripGroupHdr->pVertex(n);
+
+							// remap old mesh relative vertex index to absolute flat sorted list
+							newMeshVertID = pVertexPools[poolStart+k].pVertexMap[pStripVertex->origMeshVertID];
+
+							// map to expected final fixed vertex locations
+							// final fixed vertex location is performed by runtime loading code
+							newMeshVertID = pVertexList[newMeshVertID].finalMeshVertID;
+
+							// fixup to expected 
+							pStripVertex->origMeshVertID = newMeshVertID;
+						}
+					}
+				}
+			}
+			poolStart += pStudioModel->nummeshes;
+		}
+	}
+
+	// pVtxHdr->length = VtxLen;
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile((char*)fileName, pVtxBuff, VtxLen);
+	}
+
+	free(pVtxBuff);
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// FixupMDLFile
+// 
+// MDL files get flexes/vertex/tangent data offsets fixed
+//-----------------------------------------------------------------------------
+bool FixupMDLFile(const char *fileName, studiohdr_t *pStudioHdr, const void *pVtxBuff, const vertexPool_t *pVertexPools, int numVertexPools, const usedVertex_t *pVertexList, int numVertexes)
+{
+	OptimizedModel::FileHeader_t	*pVtxHdr;
+	const lodMeshInfo_t				*pLodMeshInfo;
+	mstudiobodyparts_t				*pStudioBodyPart;
+	mstudiomodel_t					*pStudioModel;
+	mstudiomesh_t					*pStudioMesh;
+	mstudioflex_t					*pStudioFlex;
+	mstudiovertanim_t				*pStudioVertAnim;
+	int								newMeshVertID;
+	int								i;
+	int								j;
+	int								m;
+	int								n;
+	int								p;
+	int								numLODs;
+	int								numMeshes;
+	int								total;
+
+	pVtxHdr = (OptimizedModel::FileHeader_t*)pVtxBuff;
+
+	numLODs = pVtxHdr->numLODs; 
+
+	numMeshes = 0;
+	for (i=0; i<pStudioHdr->numbodyparts; i++)
+	{
+		pStudioBodyPart = pStudioHdr->pBodypart(i);
+
+		for (j=0; j<pStudioBodyPart->nummodels; j++)
+		{
+			pStudioModel = pStudioBodyPart->pModel(j);
+
+			for (m=0; m<pStudioModel->nummeshes; m++)
+			{				
+				// get each mesh
+				pStudioMesh  = pStudioModel->pMesh(m);
+				pLodMeshInfo = &pVertexPools[numMeshes+m].lodMeshInfo;
+
+				for (n=0; n<numLODs; n++)
+				{
+					// the root lod, contains all the lower detail lods verts
+					// tally the verts that are at each lod
+					total = 0;
+					for (p=n; p<numLODs; p++)
+						total += pLodMeshInfo->numVertexes[p];
+
+					// embed the fixup for loader
+					pStudioMesh->vertexdata.numLODVertexes[n] = total;
+				}
+				for (p=n; p<MAX_NUM_LODS; p++)
+				{
+					// duplicate last valid lod to end of list
+					pStudioMesh->vertexdata.numLODVertexes[p] = pStudioMesh->vertexdata.numLODVertexes[numLODs-1];
+				}
+
+				// fix the flexes
+				for (n=0; n<pStudioMesh->numflexes; n++)
+				{
+					pStudioFlex = pStudioMesh->pFlex(n);
+
+					byte *pvanim = pStudioFlex->pBaseVertanim();
+					int nVAnimSizeBytes = pStudioFlex->VertAnimSizeBytes();
+
+					for (p=0; p<pStudioFlex->numverts; p++, pvanim += nVAnimSizeBytes )
+					{
+						pStudioVertAnim = (mstudiovertanim_t*)( pvanim );
+
+						if (pStudioVertAnim->index < 0 || pStudioVertAnim->index >= pStudioMesh->numvertices)
+							return false;
+
+						// remap old mesh relative vertex index to absolute flat sorted list
+						newMeshVertID = pVertexPools[numMeshes+m].pVertexMap[pStudioVertAnim->index];
+
+						// map to expected final fixed vertex locations
+						// final fixed vertex location is performed by runtime loading code
+						newMeshVertID = pVertexList[newMeshVertID].finalMeshVertID;
+
+						// fixup to expected 
+						pStudioVertAnim->index = newMeshVertID;
+					}
+				}
+			}
+			numMeshes += pStudioModel->nummeshes;
+		}
+	}
+
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile((char*)fileName, (void*)pStudioHdr, pStudioHdr->length);
+	}
+
+	// success
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// FixupToSortedLODVertexes
+// 
+// VVD files get vertexes fixed to a flat sorted order, ascending in lower detail lod usage
+// VTX files get their windings remapped to the sort.
+//-----------------------------------------------------------------------------
+bool FixupToSortedLODVertexes(studiohdr_t *pStudioHdr)
+{
+	char							filename[MAX_PATH];
+	char							tmpFileName[MAX_PATH];
+	void							*pVtxBuff;
+	usedVertex_t					*pVertexList;
+	vertexPool_t					*pVertexPools;
+	int								numVertexes;
+	int								numVertexPools;
+	int								VtxLen;
+	int								i;
+	const char						*vtxPrefixes[] = {".dx80.vtx", ".dx90.vtx", ".sw.vtx"};
+
+	V_strcpy_safe( filename, gamedir );
+//	if( *g_pPlatformName )
+//	{
+//		strcat( filename, "platform_" );
+//		strcat( filename, g_pPlatformName );
+//		strcat( filename, "/" );	
+//	}
+	V_strcat_safe( filename, "models/" );	
+	V_strcat_safe( filename, outname );
+	Q_StripExtension( filename, filename, sizeof( filename ) );
+
+	// determine lod usage per vertex
+	// all vtx files enumerate model's lod verts, but differ in their mesh makeup
+	// use xxx.dx80.vtx to establish which vertexes are used by each lod
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".dx80.vtx" );
+	VtxLen = LoadFile( tmpFileName, &pVtxBuff );
+
+	// build the sorted vertex tables
+	if (!BuildSortedVertexList(pStudioHdr, pVtxBuff, &pVertexPools, &numVertexPools, &pVertexList, &numVertexes))
+	{
+		// data sync error
+		return false;
+	}
+
+	// fixup ???.vvd
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".vvd" );
+	if (!FixupVVDFile(tmpFileName, pStudioHdr, pVtxBuff, pVertexPools, numVertexPools, pVertexList, numVertexes))
+	{
+		// data error
+		return false;
+	}
+
+	for (i=0; i<ARRAYSIZE(vtxPrefixes); i++)
+	{
+		// fixup ???.vtx
+		V_strcpy_safe( tmpFileName, filename );
+		V_strcat_safe( tmpFileName, vtxPrefixes[i] );
+		if (!FixupVTXFile(tmpFileName, pStudioHdr, pVertexPools, numVertexPools, pVertexList, numVertexes))
+		{
+			// data error
+			return false;
+		}
+	}
+
+	// fixup ???.mdl
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".mdl" );
+	if (!FixupMDLFile(tmpFileName, pStudioHdr, pVtxBuff, pVertexPools, numVertexPools, pVertexList, numVertexes))
+	{
+		// data error
+		return false;
+	}
+
+	// free the tables
+	for (i=0; i<numVertexPools; i++)
+	{
+		if (pVertexPools[i].pVertexList)
+			free(pVertexPools[i].pVertexList);
+		if (pVertexPools[i].pVertexMap)
+			free(pVertexPools[i].pVertexMap);
+	}
+	if (numVertexPools)
+		free(pVertexPools);
+	free(pVtxBuff);
+
+	// success
+	return true;
+}
+
+
+byte IsByte( int val )
+{
+	if (val < 0 || val > 0xFF)
+	{
+		MdlError("byte conversion out of range %d\n", val );
+	}
+	return val;
+}
+
+char IsChar( int val )
+{
+	if (val < -0x80 || val > 0x7F)
+	{
+		MdlError("char conversion out of range %d\n", val );
+	}
+	return val;
+}
+
+int IsInt24( int val )
+{
+	if (val < -0x800000 || val > 0x7FFFFF)
+	{
+		MdlError("int24 conversion out of range %d\n", val );
+	}
+	return val;
+}
+
+
+short IsShort( int val )
+{
+	if (val < -0x8000 || val > 0x7FFF)
+	{
+		MdlError("short conversion out of range %d\n", val );
+	}
+	return val;
+}
+
+unsigned short IsUShort( int val )
+{
+	if (val < 0 || val > 0xFFFF)
+	{
+		MdlError("ushort conversion out of range %d\n", val );
+	}
+	return val;
+}
+
+
+bool Clamp_MDL_LODS( const char *fileName, int rootLOD )
+{
+	studiohdr_t *pStudioHdr;
+	int			len;
+
+	len  = LoadFile((char*)fileName, (void **)&pStudioHdr);
+
+	Studio_SetRootLOD( pStudioHdr, rootLOD );
+
+#if 0
+	// shift down bone LOD masks
+	int iBone;
+	for ( iBone = 0; iBone < pStudioHdr->numbones; iBone++)
+	{
+		mstudiobone_t *pBone = pStudioHdr->pBone( iBone );
+
+		int nLodID;
+		for ( nLodID = 0; nLodID < rootLOD; nLodID++)
+		{
+			int iLodMask = BONE_USED_BY_VERTEX_LOD0 << nLodID;
+
+			if (pBone->flags & (BONE_USED_BY_VERTEX_LOD0 << rootLOD))
+			{
+				pBone->flags = pBone->flags | iLodMask;
+			}
+			else
+			{
+				pBone->flags = pBone->flags & (~iLodMask);
+			}
+		}
+	}
+#endif
+
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile( (char *)fileName, pStudioHdr, len );
+	}
+
+	return true;
+}
+
+
+
+
+bool Clamp_VVD_LODS( const char *fileName, int rootLOD )
+{
+	vertexFileHeader_t *pTempVvdHdr;
+	int			len;
+
+	len  = LoadFile((char*)fileName, (void **)&pTempVvdHdr);
+
+	int newLength = Studio_VertexDataSize( pTempVvdHdr, rootLOD, true );
+
+	// printf("was %d now %d\n", len, newLength );
+
+	vertexFileHeader_t *pNewVvdHdr = (vertexFileHeader_t *)calloc( newLength, 1 );
+
+	Studio_LoadVertexes( pTempVvdHdr, pNewVvdHdr, rootLOD, true );
+
+	if (!g_quiet)
+	{
+		printf ("---------------------\n");
+		printf ("writing %s:\n", fileName);
+		printf( "vertices   (%d vertices)\n", pNewVvdHdr->numLODVertexes[ 0 ] );
+	}
+
+	// pNewVvdHdr->length = newLength;
+
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile( (char *)fileName, pNewVvdHdr, newLength );
+	}
+
+	return true;
+}
+
+
+bool Clamp_VTX_LODS( const char *fileName, int rootLOD, studiohdr_t *pStudioHdr )
+{
+	int i, j, k, m, n;
+	int nLodID;
+	int size;
+
+	OptimizedModel::FileHeader_t *pVtxHdr;
+	int			len;
+
+	len  = LoadFile((char*)fileName, (void **)&pVtxHdr);
+
+	OptimizedModel::FileHeader_t *pNewVtxHdr = (OptimizedModel::FileHeader_t *)calloc( FILEBUFFER, 1 );
+
+	byte *pData = (byte *)pNewVtxHdr;
+	pData += sizeof( OptimizedModel::FileHeader_t );
+	ALIGN4( pData );
+
+	// header
+	pNewVtxHdr->version = pVtxHdr->version;
+	pNewVtxHdr->vertCacheSize = pVtxHdr->vertCacheSize;
+	pNewVtxHdr->maxBonesPerStrip = pVtxHdr->maxBonesPerStrip;
+	pNewVtxHdr->maxBonesPerTri = pVtxHdr->maxBonesPerTri;
+	pNewVtxHdr->maxBonesPerVert = pVtxHdr->maxBonesPerVert;
+	pNewVtxHdr->checkSum = pVtxHdr->checkSum;
+	pNewVtxHdr->numLODs = pVtxHdr->numLODs;
+
+	// material replacement list
+	pNewVtxHdr->materialReplacementListOffset = (pData - (byte *)pNewVtxHdr);
+	pData += pVtxHdr->numLODs * sizeof( OptimizedModel::MaterialReplacementListHeader_t );
+	// ALIGN4( pData );
+
+	BeginStringTable( );
+
+	// allocate replacement list arrays
+	for ( nLodID = rootLOD; nLodID < pVtxHdr->numLODs; nLodID++ )
+	{
+		OptimizedModel::MaterialReplacementListHeader_t *pReplacementList = pVtxHdr->pMaterialReplacementList( nLodID );
+		OptimizedModel::MaterialReplacementListHeader_t *pNewReplacementList = pNewVtxHdr->pMaterialReplacementList( nLodID );
+
+		pNewReplacementList->numReplacements = pReplacementList->numReplacements;
+		pNewReplacementList->replacementOffset = (pData - (byte *)pNewReplacementList);
+		pData += pNewReplacementList->numReplacements * sizeof( OptimizedModel::MaterialReplacementHeader_t );
+		// ALIGN4( pData );
+
+		for (i = 0; i < pReplacementList->numReplacements; i++)
+		{
+			OptimizedModel::MaterialReplacementHeader_t *pReplacement = pReplacementList->pMaterialReplacement( i );
+			OptimizedModel::MaterialReplacementHeader_t *pNewReplacement = pNewReplacementList->pMaterialReplacement( i );
+
+			pNewReplacement->materialID = pReplacement->materialID;
+			AddToStringTable( pNewReplacement, &pNewReplacement->replacementMaterialNameOffset, pReplacement->pMaterialReplacementName() );
+		}
+	}
+	pData = WriteStringTable( pData );
+
+	// link previous LODs to higher LODs
+	for ( nLodID = 0; nLodID < rootLOD; nLodID++ )
+	{
+		OptimizedModel::MaterialReplacementListHeader_t *pRootReplacementList = pNewVtxHdr->pMaterialReplacementList( rootLOD );
+		OptimizedModel::MaterialReplacementListHeader_t *pNewReplacementList = pNewVtxHdr->pMaterialReplacementList( nLodID );
+
+		int delta = (byte *)pRootReplacementList - (byte *)pNewReplacementList;
+
+		pNewReplacementList->numReplacements = pRootReplacementList->numReplacements;
+		pNewReplacementList->replacementOffset = pRootReplacementList->replacementOffset + delta;
+	}
+
+	// body parts
+	pNewVtxHdr->numBodyParts = pStudioHdr->numbodyparts;
+	pNewVtxHdr->bodyPartOffset = (pData - (byte *)pNewVtxHdr);
+	pData += pNewVtxHdr->numBodyParts * sizeof( OptimizedModel::BodyPartHeader_t );
+	// ALIGN4( pData );
+
+	// Iterate over every body part...
+	for ( i = 0; i < pStudioHdr->numbodyparts; i++ )
+	{
+		mstudiobodyparts_t* pBodyPart = pStudioHdr->pBodypart(i);
+		OptimizedModel::BodyPartHeader_t* pVtxBodyPart = pVtxHdr->pBodyPart(i);
+		OptimizedModel::BodyPartHeader_t* pNewVtxBodyPart = pNewVtxHdr->pBodyPart(i);
+
+		pNewVtxBodyPart->numModels = pBodyPart->nummodels;
+		pNewVtxBodyPart->modelOffset = (pData - (byte *)pNewVtxBodyPart);
+		pData += pNewVtxBodyPart->numModels * sizeof( OptimizedModel::ModelHeader_t );
+		// ALIGN4( pData );
+
+		// Iterate over every submodel...
+		for (j = 0; j < pBodyPart->nummodels; ++j)
+		{
+			mstudiomodel_t* pModel = pBodyPart->pModel(j);
+			OptimizedModel::ModelHeader_t* pVtxModel = pVtxBodyPart->pModel(j);
+			OptimizedModel::ModelHeader_t* pNewVtxModel = pNewVtxBodyPart->pModel(j);
+
+			pNewVtxModel->numLODs = pVtxModel->numLODs;
+			pNewVtxModel->lodOffset = (pData - (byte *)pNewVtxModel);
+			pData += pNewVtxModel->numLODs * sizeof( OptimizedModel::ModelLODHeader_t );
+			ALIGN4( pData );
+
+			for ( nLodID = rootLOD; nLodID < pVtxModel->numLODs; nLodID++ )
+			{
+				OptimizedModel::ModelLODHeader_t *pVtxLOD = pVtxModel->pLOD( nLodID );
+				OptimizedModel::ModelLODHeader_t *pNewVtxLOD = pNewVtxModel->pLOD( nLodID );
+
+				pNewVtxLOD->numMeshes = pVtxLOD->numMeshes;
+				pNewVtxLOD->switchPoint = pVtxLOD->switchPoint;
+				pNewVtxLOD->meshOffset = (pData - (byte *)pNewVtxLOD);
+				pData += pNewVtxLOD->numMeshes * sizeof( OptimizedModel::MeshHeader_t );
+				ALIGN4( pData );
+
+				// Iterate over all the meshes....
+				for (k = 0; k < pModel->nummeshes; ++k)
+				{
+					Assert( pModel->nummeshes == pVtxLOD->numMeshes );
+//					mstudiomesh_t* pMesh = pModel->pMesh(k);
+					OptimizedModel::MeshHeader_t* pVtxMesh = pVtxLOD->pMesh(k);
+					OptimizedModel::MeshHeader_t* pNewVtxMesh = pNewVtxLOD->pMesh(k);
+
+					pNewVtxMesh->numStripGroups = pVtxMesh->numStripGroups;
+					pNewVtxMesh->flags = pVtxMesh->flags;
+					pNewVtxMesh->stripGroupHeaderOffset = (pData - (byte *)pNewVtxMesh);
+					pData += pNewVtxMesh->numStripGroups * sizeof( OptimizedModel::StripGroupHeader_t );
+
+					// printf("part %d : model %d : lod %d : mesh %d : strips %d : offset %d\n", i, j, nLodID, k, pVtxMesh->numStripGroups, pVtxMesh->stripGroupHeaderOffset );
+
+					for (m = 0; m < pVtxMesh->numStripGroups; m++)
+					{
+						OptimizedModel::StripGroupHeader_t *pStripGroup = pVtxMesh->pStripGroup( m );
+						OptimizedModel::StripGroupHeader_t *pNewStripGroup = pNewVtxMesh->pStripGroup( m );
+
+						// int delta = ((byte *)pStripGroup - (byte *)pVtxHdr) - ((byte *)pNewStripGroup - (byte *)pNewVtxHdr);
+
+						pNewStripGroup->numVerts = pStripGroup->numVerts;
+						pNewStripGroup->vertOffset = (pData - (byte *)pNewStripGroup);
+						size = pNewStripGroup->numVerts * sizeof( OptimizedModel::Vertex_t );
+						memcpy( pData, pStripGroup->pVertex(0), size );
+						pData += size;
+
+						pNewStripGroup->numIndices = pStripGroup->numIndices;
+						pNewStripGroup->indexOffset = (pData - (byte *)pNewStripGroup);
+						size = pNewStripGroup->numIndices * sizeof( unsigned short );
+						memcpy( pData, pStripGroup->pIndex(0), size );
+						pData += size;
+
+						pNewStripGroup->numStrips = pStripGroup->numStrips;
+						pNewStripGroup->stripOffset = (pData - (byte *)pNewStripGroup);
+						size = pNewStripGroup->numStrips * sizeof( OptimizedModel::StripHeader_t );
+						pData += size;
+
+						pNewStripGroup->flags = pStripGroup->flags;
+
+						/*
+						printf("\tnumVerts %d %d :\n", pStripGroup->numVerts, pStripGroup->vertOffset );
+						printf("\tnumIndices %d %d :\n", pStripGroup->numIndices, pStripGroup->indexOffset );
+						printf("\tnumStrips %d %d :\n", pStripGroup->numStrips, pStripGroup->stripOffset );
+						*/
+
+						for (n = 0; n < pStripGroup->numStrips; n++)
+						{
+							OptimizedModel::StripHeader_t *pStrip = pStripGroup->pStrip( n );
+							OptimizedModel::StripHeader_t *pNewStrip = pNewStripGroup->pStrip( n );
+
+							pNewStrip->numIndices = pStrip->numIndices;
+							pNewStrip->indexOffset = pStrip->indexOffset;
+
+							pNewStrip->numVerts = pStrip->numVerts;
+							pNewStrip->vertOffset = pStrip->vertOffset;
+
+							pNewStrip->numBones = pStrip->numBones;
+							pNewStrip->flags = pStrip->flags;
+
+							pNewStrip->numBoneStateChanges = pStrip->numBoneStateChanges;
+							pNewStrip->boneStateChangeOffset = (pData - (byte *)pNewStrip);
+							size = pNewStrip->numBoneStateChanges * sizeof( OptimizedModel::BoneStateChangeHeader_t );
+							memcpy( pData, pStrip->pBoneStateChange(0), size );
+							pData += size;
+
+							/*
+							printf("\t\tnumIndices %d %d :\n", pNewStrip->numIndices, pNewStrip->indexOffset );
+							printf("\t\tnumVerts %d %d :\n", pNewStrip->numVerts, pNewStrip->vertOffset );
+							printf("\t\tnumBoneStateChanges %d %d :\n", pNewStrip->numBoneStateChanges, pNewStrip->boneStateChangeOffset );
+							*/
+							// printf("(%d)\n", delta );
+						}
+						// printf("(%d)\n", delta );
+					}
+				}
+			}
+		}
+	}
+
+	// Iterate over every body part...
+	for ( i = 0; i < pStudioHdr->numbodyparts; i++ )
+	{
+		mstudiobodyparts_t* pBodyPart = pStudioHdr->pBodypart(i);
+
+		// Iterate over every submodel...
+		for (j = 0; j < pBodyPart->nummodels; ++j)
+		{
+			// link previous LODs to higher LODs
+			for ( nLodID = 0; nLodID < rootLOD; nLodID++ )
+			{
+				OptimizedModel::ModelLODHeader_t *pVtxLOD = pVtxHdr->pBodyPart(i)->pModel(j)->pLOD(nLodID);
+				OptimizedModel::ModelLODHeader_t *pRootVtxLOD = pNewVtxHdr->pBodyPart(i)->pModel(j)->pLOD(rootLOD);
+				OptimizedModel::ModelLODHeader_t *pNewVtxLOD = pNewVtxHdr->pBodyPart(i)->pModel(j)->pLOD(nLodID);
+
+				pNewVtxLOD->numMeshes = pRootVtxLOD->numMeshes;
+				pNewVtxLOD->switchPoint = pVtxLOD->switchPoint;
+
+				int delta = (byte *)pRootVtxLOD - (byte *)pNewVtxLOD;
+				pNewVtxLOD->meshOffset = pRootVtxLOD->meshOffset + delta;
+			}
+		}
+	}
+
+	int newLen = pData - (byte *)pNewVtxHdr;
+	// printf("len %d : %d\n", len, newLen );
+
+	// pNewVtxHdr->length = newLen;
+
+	if (!g_quiet)
+	{
+		printf ("writing %s:\n", fileName);
+		printf( "everything (%d bytes)\n", newLen );
+	}
+	
+	{
+		CP4AutoEditAddFile autop4( fileName, "binary" );
+		SaveFile( (char *)fileName, pNewVtxHdr, newLen );
+	}
+
+	free( pNewVtxHdr );
+
+	return true;
+}
+
+
+
+
+bool Clamp_RootLOD( studiohdr_t *phdr )
+{
+	char	filename[MAX_PATH];
+	char	tmpFileName[MAX_PATH];
+	int		i;
+	const char						*vtxPrefixes[] = {".dx80.vtx", ".dx90.vtx", ".sw.vtx"};
+
+	int rootLOD = g_minLod;
+
+	if (rootLOD > g_ScriptLODs.Size() - 1)
+	{
+		rootLOD = g_ScriptLODs.Size() -1;
+	}
+
+	if (rootLOD == 0)
+	{
+		return true;
+	}
+
+	V_strcpy_safe( filename, gamedir );
+	V_strcat_safe( filename, "models/" );	
+	V_strcat_safe( filename, outname );
+	Q_StripExtension( filename, filename, sizeof( filename ) );
+
+	// shift the files so that g_minLod is the root LOD
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".mdl" );
+	Clamp_MDL_LODS( tmpFileName, rootLOD );
+
+	V_strcpy_safe( tmpFileName, filename );
+	V_strcat_safe( tmpFileName, ".vvd" );
+	Clamp_VVD_LODS( tmpFileName, rootLOD );
+
+	for (i=0; i<ARRAYSIZE(vtxPrefixes); i++)
+	{
+		// fixup ???.vtx
+		V_strcpy_safe( tmpFileName, filename );
+		V_strcat_safe( tmpFileName, vtxPrefixes[i] );
+		Clamp_VTX_LODS( tmpFileName, rootLOD, phdr );
+	}
+
+	return true;
+}
+
+
+//----------------------------------------------------------------------
+// For a particular .qc, converts all studiomdl generated files to big-endian format.
+//----------------------------------------------------------------------
+void WriteSwappedFile( char *srcname, char *outname, int(*pfnSwapFunc)(void*, const void*, int)  )
+{
+	if ( FileExists( srcname ) )
+	{
+		if( !g_quiet )
+		{
+			printf( "---------------------\n" );
+			printf( "Generating Xbox360 file format for \"%s\":\n", srcname );
+		}
+
+		void *pFileBase = NULL;
+		int fileSize = LoadFile( srcname, &pFileBase );
+		int paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING;
+
+		void *pOutBase = malloc( paddedSize );
+
+		int bytes = pfnSwapFunc( pOutBase, pFileBase, fileSize );
+
+		if ( bytes != 0 )
+		{
+			CP4AutoEditAddFile autop4( outname, "binary" );
+			SaveFile( outname, pOutBase, bytes );
+		}
+
+		free(pOutBase);
+		free(pFileBase);
+
+		if ( bytes == 0 )
+		{
+			MdlError( "Aborted byteswap on '%s':\n", srcname );
+		}
+	}
+}
+
+//----------------------------------------------------------------------
+// For a particular .qc, converts all studiomdl generated files to big-endian format.
+//----------------------------------------------------------------------
+void WriteAllSwappedFiles( const char *filename )
+{
+	char srcname[ MAX_PATH ];
+	char outname[ MAX_PATH ];
+
+	extern IPhysicsCollision *physcollision;
+	if ( physcollision )
+	{
+		StudioByteSwap::SetCollisionInterface( physcollision );
+	}
+
+	// Convert PHY
+	Q_StripExtension( filename, srcname, sizeof( srcname ) );
+	Q_strncpy( outname, srcname, sizeof( outname ) );
+
+	Q_strcat( srcname, ".phy", sizeof( srcname ) );
+	Q_strcat( outname, ".360.phy", sizeof( outname ) );
+
+	WriteSwappedFile( srcname, outname, StudioByteSwap::ByteswapPHY );
+
+	// Convert VVD
+	Q_StripExtension( filename, srcname, sizeof( srcname ) );
+	Q_strncpy( outname, srcname, sizeof( outname ) );
+
+	Q_strcat( srcname, ".vvd", sizeof( srcname ) );
+	Q_strcat( outname, ".360.vvd", sizeof( outname ) );
+
+	WriteSwappedFile( srcname, outname, StudioByteSwap::ByteswapVVD );
+
+	// Convert VTX
+	Q_StripExtension( filename, srcname, sizeof( srcname ) );
+	Q_StripExtension( srcname, srcname, sizeof( srcname ) );
+	Q_strncpy( outname, srcname, sizeof( outname ) );
+
+	Q_strcat( srcname, ".dx90.vtx", sizeof( srcname ) );
+	Q_strcat( outname, ".360.vtx", sizeof( outname ) );
+
+	WriteSwappedFile( srcname, outname, StudioByteSwap::ByteswapVTX );
+
+	// Convert MDL
+	Q_StripExtension( filename, srcname, sizeof( srcname ) );
+	Q_strncpy( outname, srcname, sizeof( outname ) );
+
+	Q_strcat( srcname, ".mdl", sizeof( srcname ) );
+	Q_strcat( outname, ".360.mdl", sizeof( outname ) );
+
+	WriteSwappedFile( srcname, outname, StudioByteSwap::ByteswapMDL );
+}
\ No newline at end of file