4586 lines
132 KiB
C++
4586 lines
132 KiB
C++
//========= 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 );
|
|
} |