diff options
Diffstat (limited to 'utils/studiomdl/write.cpp')
| -rw-r--r-- | utils/studiomdl/write.cpp | 4586 |
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 |