1HEADmaster

1 files changed, 2724 insertions, 0 deletions

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 );
+		}
+	}
+}
+
+