1HEADmaster

1 files changed, 4586 insertions, 0 deletions

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