archive
/
tf2
mirror of https://github.com/sr2echa/TF2-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8 Commits
1 Branch
0 Tags
1.4 GiB
 
 
 
 
 
 
Tree: df62d5da09
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'df62d5da09'
${ noResults }
tf2/tf2_src/common/studiobyteswap.cpp

3179 lines
109 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Swaps the bytes in all file types generated by studiomdl
// (.vvd, .vtx, .mdl, .phy, .ani) so the files can be loaded
// on a big-endian machine, specifically the Xbox360. A new file is generated
// with an extra extension in the form of <filename>.360.<ext>
//
//=============================================================================//
#include "studio.h"
#include "optimize.h"
#include "phyfile.h"
#include "studiobyteswap.h"
#include "vphysics_interface.h"
#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)
// Fixup macros create variables that may not be referenced
#pragma warning( push )
#pragma warning( disable:4189 ) // local variable is initialized but not referenced
#pragma warning( disable:4366 ) // The result of the unary '&' operator may be unaligned
namespace StudioByteSwap
{
static bool g_bVerbose = true;
static bool g_bNativeSrc;
static CByteswap g_Swap;
static IPhysicsCollision *pCollision;
static CompressFunc_t g_pCompressFunc;
void ActivateByteSwapping( bool activate )
{
g_Swap.ActivateByteSwapping( activate );
SourceIsNative( IsPC() );
}
void SourceIsNative( bool bNative )
{
g_bNativeSrc = bNative;
}
void SetCollisionInterface( IPhysicsCollision *pPhysicsCollision )
{
pCollision = pPhysicsCollision;
}
void SetVerbose( bool bVerbose )
{
g_bVerbose = bVerbose;
}
//----------------------------------------------------------------------
// Helper to write a chunk of objects of the same type, and increment the buffer pointers.
//----------------------------------------------------------------------
template<class T> inline void WriteObjects( byte **pOutputBuffer, byte **pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, *pBaseData, sizeof(T) );
g_Swap.SwapFieldsToTargetEndian( &tempObject, &tempObject );
Q_memcpy( *pOutputBuffer, &tempObject, sizeof(T) );
*pOutputBuffer += sizeof(T);
*pBaseData += sizeof(T);
}
}
//----------------------------------------------------------------------
// Helper to write a chunk of objects of the same type, and increment the buffer pointers.
//----------------------------------------------------------------------
template<class T> inline void WriteObjects( T **pOutputBuffer, T **pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, *pBaseData, sizeof(T) );
g_Swap.SwapFieldsToTargetEndian( &tempObject, &tempObject );
Q_memcpy( *pOutputBuffer, &tempObject, sizeof(T) );
++*pOutputBuffer;
++*pBaseData;
}
}
//----------------------------------------------------------------------
// Helper to write a chunk of objects of the same type.
//----------------------------------------------------------------------
template<class T> inline void WriteObjects( byte *pOutputBuffer, byte *pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, pBaseData, sizeof(T) );
g_Swap.SwapFieldsToTargetEndian( &tempObject, &tempObject );
Q_memcpy( pOutputBuffer, &tempObject, sizeof(T) );
pOutputBuffer += sizeof(T);
pBaseData += sizeof(T);
}
}
//----------------------------------------------------------------------
// Helper to write a chunk of objects of the same type.
//----------------------------------------------------------------------
template<class T> inline void WriteObjects( T *pOutputBuffer, T *pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, pBaseData, sizeof(T) );
g_Swap.SwapFieldsToTargetEndian( &tempObject, &tempObject );
Q_memcpy( pOutputBuffer, &tempObject, sizeof(T) );
++pOutputBuffer;
++pBaseData;
}
}
//----------------------------------------------------------------------
// Helper to write a buffer of some integral type, and increment the buffer pointers.
//----------------------------------------------------------------------
template<class T> inline void WriteBuffer( byte **pOutputBuffer, byte **pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, *pBaseData, sizeof(T) );
g_Swap.SwapBufferToTargetEndian( &tempObject, &tempObject );
Q_memcpy( *pOutputBuffer, &tempObject, sizeof(T) );
*pOutputBuffer += sizeof(T);
*pBaseData += sizeof(T);
}
}
//----------------------------------------------------------------------
// Helper to write a buffer of some integral type
//----------------------------------------------------------------------
template<class T> inline void WriteBuffer( byte *pOutputBuffer, byte *pBaseData, int objectCount = 1 )
{
T tempObject;
for ( int i = 0; i < objectCount; ++i )
{
Q_memcpy( &tempObject, pBaseData, sizeof(T) );
g_Swap.SwapBufferToTargetEndian( &tempObject, &tempObject );
Q_memcpy( pOutputBuffer, &tempObject, sizeof(T) );
pOutputBuffer += sizeof(T);
pBaseData += sizeof(T);
}
}
//----------------------------------------------------------------------
// For getting values in the correct source/dest endian format
//----------------------------------------------------------------------
template< class T >
T SrcNative( T *idx )
{
T ret = *idx;
if ( !g_bNativeSrc )
{
g_Swap.SwapBuffer( &ret, idx );
}
return ret;
}
template< class T >
T DestNative( T *idx )
{
T ret = *idx;
if ( g_bNativeSrc )
{
g_Swap.SwapBuffer( &ret, idx );
}
return ret;
}
//----------------------------------------------------------------------
// Declares objects pointers for src/dest buffer
//----------------------------------------------------------------------
#define DECLARE_OBJECT_POINTERS( objPtr, base, type ) \
type* objPtr##Src = (type*)base##Src; \
type* objPtr##Dest = (type*)base##Dest; \
type* objPtr = objPtr##Src;
//----------------------------------------------------------------------
// Declares src/dest byte pointers and sets them to some index offset in the buffers.
//----------------------------------------------------------------------
#define DECLARE_INDEX_POINTERS( ptr, base, index ) \
byte *ptr##Src = (byte*)base##Src + SrcNative( &base##Src->index ); \
byte *ptr##Dest = (byte*)base##Dest + SrcNative( &base##Src->index );
//----------------------------------------------------------------------
// Declares src/dest byte pointers and sets them to some index offset in the buffers.
// If src pointer is misaligned, the fixup method is called.
//----------------------------------------------------------------------
#define DECLARE_INDEX_POINTERS_FIXUP( ptr, base, index ) \
byte *ptr##Src = (byte*)base##Src + SrcNative( &base##Src->index ); \
byte *ptr##Dest = (byte*)base##Dest + SrcNative( &base##Src->index ); \
FIXUP_OFFSETS( ptr, base, index )
//----------------------------------------------------------------------
// Same as DECLARE_OBJECT_POINTERS, but reuses existing type pointers.
//----------------------------------------------------------------------
#define SET_OBJECT_POINTERS( objPtr, base, type ) \
objPtr##Src = (type*)base##Src; \
objPtr##Dest = (type*)base##Dest; \
objPtr = objPtr##Src;
//----------------------------------------------------------------------
// Same as DECLARE_INDEX_POINTERS, but reuses existing byte pointers.
//----------------------------------------------------------------------
#define SET_INDEX_POINTERS( ptr, base, index ) \
ptr##Src = (byte*)base##Src + SrcNative( &base##Src->index ); \
ptr##Dest = (byte*)base##Dest + SrcNative( &base##Src->index );
//----------------------------------------------------------------------
// Same as DECLARE_INDEX_POINTERS, but reuses existing byte pointers.
// If src pointer is misaligned, the fixup method is called.
//----------------------------------------------------------------------
#define SET_INDEX_POINTERS_FIXUP( ptr, base, index ) \
ptr##Src = (byte*)base##Src + SrcNative( &base##Src->index ); \
ptr##Dest = (byte*)base##Dest + SrcNative( &base##Src->index ); \
FIXUP_OFFSETS( ptr, base, index )
//----------------------------------------------------------------------
// for() loop header, updates all three object pointers (src,dest,native)
//----------------------------------------------------------------------
#define ITERATE_BLOCK( objPtr, count ) \
for ( int objPtr##_idx = 0; objPtr##_idx < SrcNative( &count ); ++objPtr##_idx, ++objPtr, ++objPtr##Src, ++objPtr##Dest )
//----------------------------------------------------------------------
// Checks for misaligned source pointer, then calculates the necessary fixup,
// calls the fixup function, and sets the src pointer to the new position.
//----------------------------------------------------------------------
#define FIXUP_OFFSETS( ptr, base, index ) \
{ \
byte *ptr##Fixup = ptr##Src; \
ALIGN4( ptr##Fixup ); \
if ( ptr##Fixup != ptr##Src ) \
{ \
int nShiftBytes = ptr##Fixup - ptr##Src; \
if ( g_bVerbose ) \
Warning( "Shifting misaligned data block by %d bytes at " #base "->" #index "\n", nShiftBytes ); \
int prevBytes = (byte*)ptr##Src - (byte*)g_pDataSrcBase; \
Q_memmove( (byte*)ptr##Src + nShiftBytes, ptr##Src, fixedFileSize - prevBytes ); \
g_pFixPoint = ptr##Src; \
g_nFixupBytes = nShiftBytes; \
fixedFileSize += nShiftBytes; \
if ( fixedFileSize > fileSize + BYTESWAP_ALIGNMENT_PADDING ) \
{ \
Error( "Byteswap buffer overrun - increase BYTESWAP_ALIGNMENT_PADDING!\n" ); \
return 0; \
} \
g_pfnFileProcessFunc( pHdrSrc, UpdateSrcIndexFields ); \
g_pFixPoint = NULL; \
g_nFixupBytes = 0; \
ptr##Src = ptr##Fixup; \
} \
}
typedef void ( *datadescProcessFunc_t)( void *pBase, void *pData, typedescription_t *pFields );
typedef void ( *pfnFixupFunc_t )( void *pDestBase, datadescProcessFunc_t );
static pfnFixupFunc_t g_pfnFileProcessFunc;
static studiohdr_t *g_pHdr;
static const void *g_pDataSrcBase;
static void *g_pFixPoint;
static int g_nFixupBytes;
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool UpdateIndex( void *pBase, int *indexMember )
{
bool bUpdateIndex = false;
int idx = *indexMember;
// Update the index fields
if ( pBase < g_pFixPoint )
{
if ( (byte*)pBase + idx >= g_pFixPoint )
{
bUpdateIndex = true;
}
}
else
{
if ( (byte*)pBase + idx < g_pFixPoint )
{
bUpdateIndex = true;
}
}
// Update the member offset by the global fixup
if ( bUpdateIndex && *indexMember )
{
*indexMember = idx + g_nFixupBytes * Sign(idx);
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int GetIntegerFromField( void *pData, int fieldType )
{
if ( fieldType == FIELD_INTEGER )
{
return SrcNative( (int*)pData );
}
else if ( fieldType == FIELD_SHORT )
{
return SrcNative( (short*)pData );
}
Error( "Byteswap macro DEFINE_INDEX using unsupported fieldType %d\n", fieldType );
return 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void PutIntegerInField( void *pData, int index, int fieldType )
{
if ( fieldType == FIELD_INTEGER )
{
*(int*)pData = SrcNative( &index );
}
else if ( fieldType == FIELD_SHORT )
{
*(short*)pData = SrcNative( &index );
}
else
{
Error( "Byteswap macro DEFINE_INDEX using unsupported fieldType %d\n", fieldType );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void UpdateSrcIndexFields( void *pBase, void *pData, typedescription_t *pField )
{
if ( pField->flags & FTYPEDESC_INDEX )
{
int index = GetIntegerFromField( pData, pField->fieldType );
if ( UpdateIndex( pBase, &index ) )
{
PutIntegerInField( pData, index, pField->fieldType );
}
}
}
//-----------------------------------------------------------------------------
// Pass a datadesc field to a processing function
//-----------------------------------------------------------------------------
void ProcessField( void *pBase, void *pData, typedescription_t *pField, datadescProcessFunc_t pfn )
{
if ( pfn )
{
pfn( pBase, pData, pField );
}
}
//-----------------------------------------------------------------------------
// Process the fields of a datadesc.
//-----------------------------------------------------------------------------
void ProcessFields( void *pBaseAddress, void *pData, datamap_t *pDataMap, datadescProcessFunc_t pfnProcessFunc )
{
// deal with base class first
if ( pDataMap->baseMap )
{
ProcessFields( pBaseAddress, pData, pDataMap->baseMap, pfnProcessFunc );
}
typedescription_t *pFields = pDataMap->dataDesc;
int fieldCount = pDataMap->dataNumFields;
for ( int i = 0; i < fieldCount; ++i )
{
typedescription_t *pField = &pFields[i];
ProcessField( pBaseAddress, (BYTE*)pData + pField->fieldOffset[ TD_OFFSET_NORMAL ], pField, pfnProcessFunc );
}
}
//-----------------------------------------------------------------------------
// Process the fields of a datadesc.
//-----------------------------------------------------------------------------
void ProcessFields( void *pData, datamap_t *pDataMap, datadescProcessFunc_t pfnProcessFunc )
{
ProcessFields( pData, pData, pDataMap, pfnProcessFunc );
}
//-----------------------------------------------------------------------------
// Process a datadesc field by name
//-----------------------------------------------------------------------------
void ProcessFieldByName( void *pBaseAddress, void *pData, datamap_t *pDataMap, const char *pName, datadescProcessFunc_t pfnProcessFunc )
{
// deal with base class first
if ( pDataMap->baseMap )
{
ProcessFieldByName( pBaseAddress, pData, pDataMap->baseMap, pName, pfnProcessFunc );
}
typedescription_t *pFields = pDataMap->dataDesc;
int fieldCount = pDataMap->dataNumFields;
for ( int i = 0; i < fieldCount; ++i )
{
typedescription_t *pField = &pFields[i];
if ( !Q_stricmp( pField->fieldName, pName ) )
{
ProcessField( pBaseAddress, (BYTE*)pData + pField->fieldOffset[ TD_OFFSET_NORMAL ], pField, pfnProcessFunc );
break;
}
}
}
//-----------------------------------------------------------------------------
// Process a datadesc field by name.
//-----------------------------------------------------------------------------
void ProcessFieldByName( void *pData, datamap_t *pDataMap, const char *pName, datadescProcessFunc_t pfnProcessFunc )
{
ProcessFieldByName( pData, pData, pDataMap, pName, pfnProcessFunc );
}
void ProcessANIFields( void *pDataBase, datadescProcessFunc_t pfnProcessFunc );
void ProcessMDLFields( void *pDataBase, datadescProcessFunc_t pfnProcessFunc );
// Fake header declaration for easier phy swapping
struct swapcompactsurfaceheader_t
{
DECLARE_BYTESWAP_DATADESC();
int size;
int vphysicsID;
short version;
short modelType;
int surfaceSize;
Vector dragAxisAreas;
int axisMapSize;
};
BEGIN_BYTESWAP_DATADESC( swapcompactsurfaceheader_t )
DEFINE_FIELD( size, FIELD_INTEGER ),
DEFINE_FIELD( vphysicsID, FIELD_INTEGER ),
DEFINE_FIELD( version, FIELD_SHORT ),
DEFINE_FIELD( modelType, FIELD_SHORT ),
DEFINE_FIELD( surfaceSize, FIELD_INTEGER ),
DEFINE_FIELD( dragAxisAreas, FIELD_VECTOR ),
DEFINE_FIELD( axisMapSize, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
// Fake header declaration for old style phy format
#if defined( _X360 )
#pragma bitfield_order( push, lsb_to_msb )
#endif
struct legacysurfaceheader_t
{
DECLARE_BYTESWAP_DATADESC();
int size;
float mass_center[3];
float rotation_inertia[3];
float upper_limit_radius;
BEGIN_BITFIELD( bf )
int max_deviation : 8;
int byte_size : 24;
END_BITFIELD()
int offset_ledgetree_root;
int dummy[3];
};
#if defined( _X360 )
#pragma bitfield_order( pop )
#endif
BEGIN_BYTESWAP_DATADESC( legacysurfaceheader_t )
DEFINE_FIELD( size, FIELD_INTEGER ),
DEFINE_ARRAY( mass_center, FIELD_FLOAT, 3 ),
DEFINE_ARRAY( rotation_inertia, FIELD_FLOAT, 3 ),
DEFINE_FIELD( upper_limit_radius, FIELD_FLOAT ),
DEFINE_BITFIELD( bf, FIELD_INTEGER, 32 ),
DEFINE_FIELD( offset_ledgetree_root, FIELD_INTEGER ),
DEFINE_ARRAY( dummy, FIELD_INTEGER, 3 ),
END_BYTESWAP_DATADESC()
//----------------------------------------------------------------------
// Swap a .phy file
// Fixes alignment errors
//----------------------------------------------------------------------
int ByteswapPHY( void *pDestBase, const void *pSrcBase, const int fileSize )
{
Assert( pCollision );
if ( !pCollision )
return 0;
Q_memset( pDestBase, 0, fileSize );
byte *pSrc = (byte*)pSrcBase;
byte *pDest = (byte*)pDestBase;
vcollide_t collide = {0};
// file header
phyheader_t *pHdr = (phyheader_t*)( g_bNativeSrc ? pSrc : pDest );
WriteObjects<phyheader_t>( &pDest, &pSrc );
if ( g_bNativeSrc )
{
// Reset the pointers and let ivp swap the binary physics data
pSrc = (byte*)pSrcBase + pHdr->size;
pDest = (byte*)pDestBase + pHdr->size;
int bufSize = fileSize - pHdr->size;
pCollision->VCollideLoad( &collide, pHdr->solidCount, (const char *)pSrc, bufSize, false );
}
// Swap the collision data headers
for ( int i = 0; i < pHdr->solidCount; ++i )
{
swapcompactsurfaceheader_t *baseHdr = (swapcompactsurfaceheader_t*)( g_bNativeSrc ? pSrc : pDest );
WriteObjects<swapcompactsurfaceheader_t>( pDest, pSrc );
int srcIncrement = baseHdr->surfaceSize + sizeof(swapcompactsurfaceheader_t);
int destIncrement = srcIncrement;
bool bCopyToSrc = !g_bNativeSrc;
if ( baseHdr->vphysicsID != MAKEID('V','P','H','Y') )
{
// May be old phy format
legacysurfaceheader_t *legacyHdr = (legacysurfaceheader_t*)( g_bNativeSrc ? pSrc : pDest );
WriteObjects<legacysurfaceheader_t>( pDest, pSrc );
if ( legacyHdr->dummy[2] == MAKEID('I','V','P','S') || legacyHdr->dummy[2] == 0 )
{
srcIncrement = legacyHdr->byte_size + sizeof(int);
destIncrement = legacyHdr->byte_size + sizeof(swapcompactsurfaceheader_t);
bCopyToSrc = false;
if ( !g_bNativeSrc )
{
// src needs the size member to be native to load vcollides
Q_memcpy( pSrc, pDest, sizeof(int) );
}
}
else
{
// Not recognized
Assert(0);
return 0;
}
}
if ( bCopyToSrc )
{
// src needs the native header data to load the vcollides
Q_memcpy( pSrc, pDest, sizeof(swapcompactsurfaceheader_t) );
}
pSrc += srcIncrement;
pDest += destIncrement;
}
// the rest of the file is text
int currPos = pSrc - (byte*)pSrcBase;
int remainingBytes = fileSize - currPos;
WriteBuffer<char>( &pDest, &pSrc, remainingBytes );
if ( !g_bNativeSrc )
{
// let ivp swap the ledge tree
pSrc = (byte*)pSrcBase + pHdr->size;
int bufSize = fileSize - pHdr->size;
pCollision->VCollideLoad( &collide, pHdr->solidCount, (const char *)pSrc, bufSize, true );
}
// Write out the ledge tree data
pDest = (byte*)pDestBase + pHdr->size;
for ( int i = 0; i < collide.solidCount; ++i )
{
// skip over the size
pDest += sizeof(int);
int offset = pCollision->CollideWrite( (char*)pDest, collide.solids[i], g_bNativeSrc );
int destSize = g_bNativeSrc ? SwapLong( offset ) : offset;
Q_memcpy( pDest - sizeof(int), &destSize, sizeof(int) );
pDest += offset;
}
// Free the memory
pCollision->VCollideUnload( &collide );
int newFileSize = pDest - (byte*)pDestBase + remainingBytes;
if ( g_pCompressFunc )
{
// compress entire swapped PHY
void *pInput = pDestBase;
int inputSize = newFileSize;
void *pOutput;
int outputSize;
if ( g_pCompressFunc( pInput, inputSize, &pOutput, &outputSize ) )
{
// put the compressed version in its place
V_memcpy( pDestBase, pOutput, outputSize );
free( pOutput );
newFileSize = outputSize;
}
}
return newFileSize;
}
//----------------------------------------------------------------------
// Swap a .vvd file
// Doesn't do any alignment fixups
//----------------------------------------------------------------------
int ByteswapVVD( void *pDestBase, const void *pSrcBase, const int fileSize )
{
Q_memset( pDestBase, 0, fileSize );
byte *pDataSrc = (byte*)pSrcBase;
byte *pDataDest = (byte*)pDestBase;
/** FILE HEADER **/
DECLARE_OBJECT_POINTERS( pHdr, pData, vertexFileHeader_t )
WriteObjects<vertexFileHeader_t>( &pDataDest, &pDataSrc );
/** FIXUP TABLE **/
SET_INDEX_POINTERS( pData, pHdr, fixupTableStart )
WriteObjects<vertexFileFixup_t>( &pDataDest, &pDataSrc, SrcNative( &pHdr->numFixups ) );
/** VERTEX DATA **/
SET_INDEX_POINTERS( pData, pHdr, vertexDataStart )
WriteObjects<mstudiovertex_t>( &pDataDest, &pDataSrc, SrcNative( &pHdr->numLODVertexes[0] ) );
/** TANGENT DATA **/
if ( pHdr->tangentDataStart != 0 )
{
SET_INDEX_POINTERS( pData, pHdr, tangentDataStart )
WriteBuffer<float>( &pDataDest, &pDataSrc, 4 * SrcNative( &pHdr->numLODVertexes[0] ) );
}
int newFileSize = pDataDest - (byte*)pDestBase;
if ( g_pCompressFunc )
{
void *pInput = (byte*)pDestBase + sizeof( vertexFileHeader_t );
int inputSize = newFileSize - sizeof( vertexFileHeader_t );
void *pOutput;
int outputSize;
if ( g_pCompressFunc( pInput, inputSize, &pOutput, &outputSize ) )
{
// place the compressed data after the header
V_memcpy( pInput, pOutput, outputSize );
free( pOutput );
newFileSize = sizeof( vertexFileHeader_t ) + outputSize;
}
}
return newFileSize;
}
//----------------------------------------------------------------------
// Swap a .vtx file
// Doesn't do any alignment fixups
//----------------------------------------------------------------------
int ByteswapVTX( void *pDestBase, const void *pSrcBase, const int fileSize )
{
Q_memset( pDestBase, 0, fileSize );
// Do a straight copy first so the string table is transferred
memcpy( pDestBase, pSrcBase, fileSize );
// Start writing the file
byte *pDataSrc = (byte*)pSrcBase;
byte *pDataDest = (byte*)pDestBase;
DECLARE_OBJECT_POINTERS( pVtxHeader, pData, OptimizedModel::FileHeader_t )
WriteObjects( pVtxHeaderDest, pVtxHeaderSrc );
/** BODY PARTS **/
SET_INDEX_POINTERS( pData, pVtxHeader, bodyPartOffset )
DECLARE_OBJECT_POINTERS( pBodyPartHeader, pData, OptimizedModel::BodyPartHeader_t )
ITERATE_BLOCK( pBodyPartHeader, pVtxHeader->numBodyParts )
{
WriteObjects( pBodyPartHeaderDest, pBodyPartHeaderSrc );
/** MODELS **/
SET_INDEX_POINTERS( pData, pBodyPartHeader, modelOffset )
DECLARE_OBJECT_POINTERS( pModelHeader, pData, OptimizedModel::ModelHeader_t )
ITERATE_BLOCK( pModelHeader, pBodyPartHeader->numModels )
{
WriteObjects( pModelHeaderDest, pModelHeaderSrc );
/** MODEL LODS **/
unsigned int meshOffset = 0;
SET_INDEX_POINTERS( pData, pModelHeader, lodOffset )
DECLARE_OBJECT_POINTERS( pModelLODHeader, pData, OptimizedModel::ModelLODHeader_t )
ITERATE_BLOCK( pModelLODHeader, pModelHeader->numLODs )
{
WriteObjects( pModelLODHeaderDest, pModelLODHeaderSrc );
/** MESHES **/
unsigned int prevOffset = meshOffset;
meshOffset = SrcNative( &pModelLODHeader->meshOffset );
if ( prevOffset - sizeof(OptimizedModel::ModelLODHeader_t) == meshOffset )
{
// This LOD shares data with the previous LOD - don't reswap.
continue;
}
SET_INDEX_POINTERS( pData, pModelLODHeader, meshOffset )
DECLARE_OBJECT_POINTERS( pMeshHeader, pData, OptimizedModel::MeshHeader_t )
ITERATE_BLOCK( pMeshHeader, pModelLODHeader->numMeshes )
{
WriteObjects( pMeshHeaderDest, pMeshHeaderSrc );
/** STRIP GROUPS **/
SET_INDEX_POINTERS( pData, pMeshHeader, stripGroupHeaderOffset )
DECLARE_OBJECT_POINTERS( pStripGroupHeader, pData, OptimizedModel::StripGroupHeader_t )
ITERATE_BLOCK( pStripGroupHeader, pMeshHeader->numStripGroups )
{
WriteObjects( pStripGroupHeaderDest, pStripGroupHeaderSrc );
/** STRIP VERTS **/
SET_INDEX_POINTERS( pData, pStripGroupHeader, vertOffset )
WriteObjects<OptimizedModel::Vertex_t>( pDataDest, pDataSrc, SrcNative( &pStripGroupHeader->numVerts ) );
/** VERT INDICES **/
SET_INDEX_POINTERS( pData, pStripGroupHeader, indexOffset )
WriteBuffer<short>( pDataDest, pDataSrc, SrcNative( &pStripGroupHeader->numIndices ) );
/** STRIPS **/
SET_INDEX_POINTERS( pData, pStripGroupHeader, stripOffset )
DECLARE_OBJECT_POINTERS( pStripHeader, pData, OptimizedModel::StripHeader_t )
ITERATE_BLOCK( pStripHeader, pStripGroupHeader->numStrips )
{
WriteObjects( pStripHeaderDest, pStripHeaderSrc );
/** BONE STATE CHANGES **/
SET_INDEX_POINTERS( pData, pStripHeader, boneStateChangeOffset )
WriteObjects<OptimizedModel::BoneStateChangeHeader_t>( pDataDest, pDataSrc, SrcNative( &pStripHeader->numBoneStateChanges ) );
}
}
}
}
}
}
/** MATERIAL REPLACEMENT HEADERS **/
SET_INDEX_POINTERS( pData, pVtxHeader, materialReplacementListOffset )
DECLARE_OBJECT_POINTERS( pMatRepListHeader, pData, OptimizedModel::MaterialReplacementListHeader_t )
ITERATE_BLOCK( pMatRepListHeader, pVtxHeader->numLODs )
{
WriteObjects( pMatRepListHeaderDest, pMatRepListHeaderSrc );
/** MATERIAL REPLACEMENTS **/
SET_INDEX_POINTERS( pData, pMatRepListHeader, replacementOffset )
WriteObjects<OptimizedModel::MaterialReplacementHeader_t>( &pDataDest, &pDataSrc, SrcNative( &pMatRepListHeader->numReplacements ) );
}
int newFileSize = fileSize;
if ( g_pCompressFunc )
{
void *pInput = (byte*)pDestBase + sizeof( OptimizedModel::FileHeader_t );
int inputSize = fileSize - sizeof( OptimizedModel::FileHeader_t );
void *pOutput;
int outputSize;
if ( g_pCompressFunc( pInput, inputSize, &pOutput, &outputSize ) )
{
// place the compressed data after the header
V_memcpy( pInput, pOutput, outputSize );
free( pOutput );
newFileSize = sizeof( OptimizedModel::FileHeader_t ) + outputSize;
}
}
return newFileSize;
}
//----------------------------------------------------------------------
// Swap animation data
// Fixes alignment errors
//----------------------------------------------------------------------
void ByteswapAnimData( mstudioanimdesc_t *pAnimDesc, int section, byte *&pDataSrc, byte *&pDataDest )
{
/** ANIMATIONS **/
DECLARE_OBJECT_POINTERS( pAnimation, pData, mstudioanim_t )
WriteObjects( pAnimationDest, pAnimationSrc );
if ( pAnimation->bone == 255 )
{
// No animation data
pAnimation = 0;
}
while( pAnimation )
{
if ( pAnimation->flags & ( STUDIO_ANIM_RAWROT | STUDIO_ANIM_RAWPOS | STUDIO_ANIM_RAWROT2 ) )
{
if ( pAnimation->flags & STUDIO_ANIM_RAWROT )
{
int offset = (byte*)pAnimation->pQuat48() - (byte*)pAnimation;
pDataSrc = (byte*)pAnimationSrc + offset;
pDataDest = (byte*)pAnimationDest + offset;
// Write the quaternion (bit fields contained in 3 unsigned shorts)
WriteBuffer<short>( &pDataDest, &pDataSrc, 3 );
}
if ( pAnimation->flags & STUDIO_ANIM_RAWROT2 )
{
int offset = (byte*)pAnimation->pQuat64() - (byte*)pAnimation;
pDataSrc = (byte*)pAnimationSrc + offset;
pDataDest = (byte*)pAnimationDest + offset;
// Write the quaternion (bit fields contained in 1 64 bit int
WriteBuffer<int64>( &pDataDest, &pDataSrc, 1 );
}
if ( pAnimation->flags & STUDIO_ANIM_RAWPOS )
{
int offset = (byte*)pAnimation->pPos() - (byte*)pAnimation;
pDataSrc = (byte*)pAnimationSrc + offset;
pDataDest = (byte*)pAnimationDest + offset;
// Write the vector (3 float16)
WriteBuffer<short>( &pDataDest, &pDataSrc, 3 );
}
}
else
{
int offset = (byte*)pAnimation->pRotV() - (byte*)pAnimation;
pDataSrc = (byte*)pAnimationSrc + offset;
pDataDest = (byte*)pAnimationDest + offset;
mstudioanim_valueptr_t *rotvptr = (mstudioanim_valueptr_t*)pDataSrc;
WriteObjects<mstudioanim_valueptr_t>( &pDataDest, &pDataSrc );
int animValueCt = 0;
for ( int idx = 0; idx < 3; ++idx )
{
animValueCt += rotvptr->offset[idx] ? 1 : 0;
}
if ( pAnimation->flags & STUDIO_ANIM_ANIMPOS )
{
int offsetAnim = (byte*)pAnimation->pPosV() - (byte*)pAnimation;
pDataSrc = (byte*)pAnimationSrc + offsetAnim;
pDataDest = (byte*)pAnimationDest + offsetAnim;
mstudioanim_valueptr_t *posvptr = (mstudioanim_valueptr_t*)pDataSrc;
WriteObjects<mstudioanim_valueptr_t>( &pDataDest, &pDataSrc );
for ( int idx = 0; idx < 3; ++idx )
{
animValueCt += posvptr->offset[idx] ? 1 : 0;
}
}
// Write position and rotation animations
// Note: destanimvalue_t is a union that can be either two bytes or a short.
// This structure is used to compress animation data using RLE.
// The first object of a chunk acts as the header, and uses the two bytes to
// store how many objects follow, and how many frames are encoded by them.
// The objects that follow use the short to store a value.
// The total number of chunks has been determined by counting the number of valid (non-zero) offsets.
for ( int animValue = 0; animValue < animValueCt; ++animValue )
{
int encodedFrames = 0;
int totalFrames = SrcNative( &pAnimDesc->numframes );
int sectionFrames = SrcNative( &pAnimDesc->sectionframes );
if ( sectionFrames )
{
int iStartFrame = section * sectionFrames;
int iEndFrame = (section + 1) * sectionFrames;
iStartFrame = min( iStartFrame, totalFrames - 1 );
iEndFrame = min( iEndFrame, totalFrames - 1 );
totalFrames = iEndFrame - iStartFrame + 1;
}
while ( encodedFrames < totalFrames )
{
// Write the first animation value (struct of 2 bytes)
mstudioanimvalue_t *pDestAnimvalue = (mstudioanimvalue_t*)( g_bNativeSrc ? pDataSrc : pDataDest );
WriteBuffer<char>( &pDataDest, &pDataSrc, 2 );
// Write the remaining animation values from this group (shorts)
WriteBuffer<short>( &pDataDest, &pDataSrc, pDestAnimvalue->num.valid );
encodedFrames += pDestAnimvalue->num.total;
}
}
}
// TODOKD: Could add a fixup here with some more work, hasn't been necessary yet
if ( pAnimation->nextoffset )
{
// Set pointers to the next animation
pAnimationSrc = (mstudioanim_t*)( (byte*)pAnimationSrc + SrcNative( &pAnimation->nextoffset ) );
pAnimationDest = (mstudioanim_t*)( (byte*)pAnimationDest + SrcNative( &pAnimation->nextoffset ) );
pAnimation = pAnimationSrc;
// Swap the next animation
WriteObjects( pAnimationDest, pAnimationSrc );
}
else
{
pAnimation = 0;
pDataSrc += sizeof( mstudioanim_t );
pDataDest += sizeof( mstudioanim_t );
}
}
ALIGN4( pDataSrc );
ALIGN4( pDataDest );
}
int ByteswapIKRules( studiohdr_t *&pHdrSrc, int numikrules, int numFrames, byte *&pDataSrc, byte *&pDataDest, int &fixedFileSize, const int fileSize )
{
DECLARE_OBJECT_POINTERS( pIKRule, pData, mstudioikrule_t )
ITERATE_BLOCK( pIKRule, numikrules )
{
WriteObjects<mstudioikrule_t>( pIKRuleDest, pIKRuleSrc );
/** IK ERROR KEYS **/
// Calculate the number of ikerrors by converting the ikerror start and end float values to
// frame numbers. (See the generation of these values in simplify.cpp: ProcessIKRules()).
float start = floorf( SrcNative( &pIKRule->start ) * (numFrames - 1) + 0.5f );
float end = floorf( SrcNative( &pIKRule->end ) * (numFrames - 1) + 0.5f );
int totalerror = (int)( end - start + 1 );
if ( end >= numFrames )
totalerror += 2;
// Uncompressed - only found in some older models (shipped hl2)
if ( pIKRule->ikerrorindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pIKRule, ikerrorindex )
WriteObjects<mstudioikerror_t>( pDataDest, pDataSrc, totalerror );
}
// Compressed - all models since hl2
if ( pIKRule->compressedikerrorindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pIKRule, compressedikerrorindex )
WriteObjects<mstudiocompressedikerror_t>( pDataDest, pDataSrc );
mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pDataSrc;
// Write the animvalues.
for ( int idx = 0; idx < 6; ++idx )
{
if ( pCompressed->offset[idx] )
{
byte *pAnimvalueSrc = pDataSrc + SrcNative( &pCompressed->offset[idx] );
byte *pAnimvalueDest = pDataDest + SrcNative( &pCompressed->offset[idx] );
int numerror = 0;
while ( numerror < totalerror )
{
// Write the first animation value (struct of 2 bytes)
mstudioanimvalue_t *pDestAnimvalue = (mstudioanimvalue_t*)( g_bNativeSrc ? pAnimvalueSrc : pAnimvalueDest );
WriteBuffer<char>( &pAnimvalueDest, &pAnimvalueSrc, 2 );
// Write the remaining animation values from this group (shorts)
WriteBuffer<short>( &pAnimvalueDest, &pAnimvalueSrc, pDestAnimvalue->num.valid );
numerror += pDestAnimvalue->num.total;
}
}
}
if ( pIKRule->szattachmentindex )
{
SET_INDEX_POINTERS( pData, pIKRule, szattachmentindex )
int size = strlen( (char*)pDataSrc ) + 1;
WriteBuffer<char>( pDataDest, pDataSrc, size );
}
}
}
return fixedFileSize;
}
//----------------------------------------------------------------------
// Swap an .ani file
// Fixes alignment errors
//----------------------------------------------------------------------
int ByteswapANIFile( studiohdr_t* pHdr, void *pDestBase, const void *pSrcBase, const int fileSize )
{
// Note, pHdr came from a native .mdl -
// so the header, animdescs and animblocks are already in native format.
Assert( pHdr );
if ( !pHdr )
return false;
Q_memset( pDestBase, 0, fileSize );
// swap file header
{
byte *pHeaderSrc = (byte *)pSrcBase;
byte *pHeaderDest = (byte *)pDestBase;
DECLARE_OBJECT_POINTERS( pAniHeader, pHeader, studiohdr_t )
WriteObjects( pAniHeaderDest, pAniHeaderSrc );
}
// for fixup functions
int fixedFileSize = fileSize;
g_pfnFileProcessFunc = ProcessANIFields;
g_pDataSrcBase = pSrcBase;
g_pHdr = pHdr;
studiohdr_t *pHdrSrc = pHdr;
// The animdesc_t header is always contained in the mdl file, but its data may be in
// the mdl or the ani. When the data is contained in the mdl, the animdesc index fields
// represent offsets from the location of the animdesc header. When the data is in the ani,
// the index fields contain offsets from the start of the animblock in which the animdesc data is contained.
mstudioanimdesc_t *pAnimDesc = pHdr->pLocalAnimdesc( 0 );
for ( int i = 0; i < pHdr->numlocalanim; ++i, ++pAnimDesc )
{
// printf("anim %d : %d : %d\n", i, pAnimDesc->animblock, pAnimDesc->sectionframes );
if ( pAnimDesc->animblock == -1)
{
// out of date model format
continue;
}
if ( pAnimDesc->animblock == 0 && pAnimDesc->sectionframes == 0)
{
// already saved out
continue;
}
if ( pAnimDesc->sectionframes == 0 )
{
mstudioanimblock_t *pAnimBlock = pHdr->pAnimBlock( pAnimDesc->animblock );
// printf("block %d : start %d + %d\n", pAnimDesc->animblock, pAnimBlock->datastart, pAnimDesc->animindex );
// Base address of the animblock
byte *pBlockBaseSrc = (byte*)pSrcBase + pAnimBlock->datastart;
byte *pBlockBaseDest = (byte*)pDestBase + pAnimBlock->datastart;
// Base address of the animation in the animblock
byte *pDataSrc = pBlockBaseSrc + pAnimDesc->animindex;
byte *pDataDest = pBlockBaseDest + pAnimDesc->animindex;
ByteswapAnimData( pAnimDesc, 0, pDataSrc, pDataDest );
}
else
{
int numsections = pAnimDesc->numframes / pAnimDesc->sectionframes + 2;
for ( int iSec = 0; iSec < numsections; ++iSec )
{
int block = pAnimDesc->pSection( iSec )->animblock;
int index = pAnimDesc->pSection( iSec )->animindex;
if ( block != 0 )
{
// printf("%s %d %d\n", pAnimDesc->pszName(), block, index );
mstudioanimblock_t *pAnimBlock = pHdr->pAnimBlock( block );
// Base address of the animblock
byte *pBlockBaseSrc = (byte*)pSrcBase + pAnimBlock->datastart;
byte *pBlockBaseDest = (byte*)pDestBase + pAnimBlock->datastart;
FIXUP_OFFSETS( pBlockBase, pAnimBlock, datastart )
// Base address of the animation in the animblock
byte *pDataSrc = pBlockBaseSrc + index;
byte *pDataDest = pBlockBaseDest + index;
ByteswapAnimData( pAnimDesc, iSec, pDataSrc, pDataDest );
}
}
}
if ( pAnimDesc->animblock == 0)
{
// already saved out
continue;
}
mstudioanimblock_t *pAnimBlock = pHdr->pAnimBlock( pAnimDesc->animblock );
// Base address of the animblock
byte *pBlockBaseSrc = (byte*)pSrcBase + pAnimBlock->datastart;
byte *pBlockBaseDest = (byte*)pDestBase + pAnimBlock->datastart;
FIXUP_OFFSETS( pBlockBase, pAnimBlock, datastart )
// Base address of the animation in the animblock
byte *pDataSrc = pBlockBaseSrc + pAnimDesc->animindex;
byte *pDataDest = pBlockBaseDest + pAnimDesc->animindex;
FIXUP_OFFSETS( pData, pAnimDesc, animindex )
/** IK RULES **/
if ( pAnimDesc->animblockikruleindex )
{
pDataSrc = (byte*)pBlockBaseSrc + pAnimDesc->animblockikruleindex;
pDataDest = (byte*)pBlockBaseDest + pAnimDesc->animblockikruleindex;
FIXUP_OFFSETS( pData, pAnimDesc, animblockikruleindex )
int numikrules = SrcNative( &pAnimDesc->numikrules );
ByteswapIKRules( pHdrSrc, pAnimDesc->numikrules, pAnimDesc->numframes, pDataSrc, pDataDest, fixedFileSize, fileSize );
}
/** LOCAL HIERARCHY **/
if ( pAnimDesc->localhierarchyindex )
{
pDataSrc = (byte*)pBlockBaseSrc + pAnimDesc->localhierarchyindex;
pDataDest = (byte*)pBlockBaseDest + pAnimDesc->localhierarchyindex;
DECLARE_OBJECT_POINTERS( pLocalHierarchy, pData, mstudiolocalhierarchy_t )
// HACK: Since animdescs are already native, pre-swap pAnimDesc->numlocalhierarchy
// here so the automatic swap inside ITERATE_BLOCK will restore it
int numlocalhierarchy = SrcNative( &pAnimDesc->numlocalhierarchy );
ITERATE_BLOCK( pLocalHierarchy, numlocalhierarchy )
{
WriteObjects<mstudiolocalhierarchy_t>( pLocalHierarchyDest, pLocalHierarchySrc, pAnimDesc->numlocalhierarchy );
/** COMPRESSED IK ERRORS **/
if ( pLocalHierarchy->localanimindex != 0 )
{
// Calculate the number of ikerrors by converting the ikerror start and end float values to
// frame numbers. (See the generation of these values in simplify.cpp: ProcessIKRules()).
int numFrames = pAnimDesc->numframes;
float start = floorf( SrcNative( &pLocalHierarchy->start ) * (numFrames - 1) + 0.5f );
float end = floorf( SrcNative( &pLocalHierarchy->end ) * (numFrames - 1) + 0.5f );
int totalerror = (int)( end - start + 1 );
if ( end >= numFrames )
totalerror += 2;
SET_INDEX_POINTERS( pData, pLocalHierarchy, localanimindex )
WriteObjects<mstudiocompressedikerror_t>( pDataDest, pDataSrc );
mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pDataSrc;
// Write the animvalues.
for ( int idx = 0; idx < 6; ++idx )
{
if ( pCompressed->offset[idx] )
{
byte *pAnimvalueSrc = pDataSrc + SrcNative( &pCompressed->offset[idx] );
byte *pAnimvalueDest = pDataDest + SrcNative( &pCompressed->offset[idx] );
int numerror = 0;
while ( numerror < totalerror )
{
// Write the first animation value (struct of 2 bytes)
mstudioanimvalue_t *pDestAnimvalue = (mstudioanimvalue_t*)( g_bNativeSrc ? pAnimvalueSrc : pAnimvalueDest );
WriteBuffer<char>( &pAnimvalueDest, &pAnimvalueSrc, 2 );
// Write the remaining animation values from this group (shorts)
WriteBuffer<short>( &pAnimvalueDest, &pAnimvalueSrc, pDestAnimvalue->num.valid );
numerror += pDestAnimvalue->num.total;
}
}
}
}
} // Local Hierarchy block
}
}
// printf("returning %d\n", fixedFileSize );
return fixedFileSize;
}
int ByteswapANI( studiohdr_t* pHdr, void *pDestBase, const void *pSrcBase, const int fileSize )
{
// Make a working copy of the source to allow for alignment fixups
void *pNewSrcBase = malloc( fileSize + BYTESWAP_ALIGNMENT_PADDING );
Q_memcpy( pNewSrcBase, pSrcBase, fileSize );
int fixedFileSize = ByteswapANIFile( pHdr, pDestBase, pNewSrcBase, fileSize );
if ( fixedFileSize != fileSize )
{
int finalSize = ByteswapANIFile( pHdr, pDestBase, pNewSrcBase, fixedFileSize );
if ( finalSize != fixedFileSize )
{
if ( g_bVerbose )
Warning( "Alignment fixups failed on ANI swap!\n" );
fixedFileSize = 0;
}
}
free( pNewSrcBase );
// the compression needs to happen on the final or "fixed" pass
if ( g_pCompressFunc && pHdr->numanimblocks >= 2 && fixedFileSize )
{
// assemble a new anim of compressed anim blocks
// start with original size, with room for alignment padding
fixedFileSize += (pHdr->numanimblocks + 1) * 2048;
byte *pNewDestBase = (byte *)malloc( fixedFileSize );
Q_memset( pNewDestBase, 0, fixedFileSize );
byte *pNewDest = pNewDestBase;
// get the header payload as is
// assuming the header is up to the first anim block
mstudioanimblock_t *pAnimBlock = pHdr->pAnimBlock( 1 );
V_memcpy( pNewDest, pDestBase, pAnimBlock->datastart );
pNewDest += pAnimBlock->datastart;
int padding = AlignValue( (unsigned int)pNewDest - (unsigned int)pNewDestBase, 2048 );
padding -= (unsigned int)pNewDest - (unsigned int)pNewDestBase;
pNewDest += padding;
// iterate and compress anim blocks
for ( int i = 1; i < pHdr->numanimblocks; ++i )
{
pAnimBlock = pHdr->pAnimBlock( i );
void *pInput = (byte *)pDestBase + pAnimBlock->datastart;
int inputSize = pAnimBlock->dataend - pAnimBlock->datastart;
pAnimBlock->datastart = (unsigned int)pNewDest - (unsigned int)pNewDestBase;
void *pOutput;
int outputSize;
if ( g_pCompressFunc( pInput, inputSize, &pOutput, &outputSize ) )
{
V_memcpy( pNewDest, pOutput, outputSize );
pNewDest += outputSize;
free( pOutput );
}
else
{
// as is
V_memcpy( pNewDest, pInput, inputSize );
pNewDest += inputSize;
}
padding = AlignValue( (unsigned int)pNewDest - (unsigned int)pNewDestBase, 2048 );
padding -= (unsigned int)pNewDest - (unsigned int)pNewDestBase;
pNewDest += padding;
pAnimBlock->dataend = (unsigned int)pNewDest - (unsigned int)pNewDestBase;
}
fixedFileSize = pNewDest - pNewDestBase;
V_memcpy( pDestBase, pNewDestBase, fixedFileSize );
free( pNewDestBase );
}
return fixedFileSize;
}
//----------------------------------------------------------------------
// Write a .mdl file in big-endian format
//----------------------------------------------------------------------
int ByteswapMDLFile( void *pDestBase, void *pSrcBase, const int fileSize )
{
// Needed by fixup functions
g_pDataSrcBase = pSrcBase;
g_pfnFileProcessFunc = ProcessMDLFields;
int fixedFileSize = fileSize;
Q_memset( pDestBase, 0, fileSize );
byte *pDataSrc = (byte*)pSrcBase;
byte *pDataDest = (byte*)pDestBase;
/** FILE HEADER **/
DECLARE_OBJECT_POINTERS( pHdr, pData, studiohdr_t )
WriteObjects( pHdrDest, pHdrSrc );
/** BONES **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, boneindex )
DECLARE_OBJECT_POINTERS( pStudioBone, pData, mstudiobone_t )
ITERATE_BLOCK( pStudioBone, pHdr->numbones )
{
WriteObjects( pStudioBoneDest, pStudioBoneSrc );
if ( pStudioBone->procindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pStudioBone, procindex )
unsigned int index = SrcNative( &pStudioBone->proctype );
switch( index )
{
case STUDIO_PROC_AXISINTERP:
{
/** AXIS-INTERP BONES **/
DECLARE_OBJECT_POINTERS( pAxisInterpBone, pData, mstudioaxisinterpbone_t )
WriteObjects( pAxisInterpBoneDest, pAxisInterpBoneSrc );
break;
}
case STUDIO_PROC_QUATINTERP:
{
/** QUAT-INTERP BONES **/
DECLARE_OBJECT_POINTERS( pQuatInterpBone, pData, mstudioquatinterpbone_t )
WriteObjects( pQuatInterpBoneDest, pQuatInterpBoneSrc );
/** QUAT-INTERP TRIGGERS **/
SET_INDEX_POINTERS_FIXUP( pData, pQuatInterpBone, triggerindex )
WriteObjects<mstudioquatinterpinfo_t>( pDataDest, pDataSrc, SrcNative( &pQuatInterpBone->numtriggers ) );
break;
}
case STUDIO_PROC_JIGGLE:
{
/** JIGGLE BONES **/
DECLARE_OBJECT_POINTERS( pJiggleBone, pData, mstudiojigglebone_t )
WriteObjects( pJiggleBoneDest, pJiggleBoneSrc );
break;
}
case STUDIO_PROC_AIMATBONE:
case STUDIO_PROC_AIMATATTACH:
{
/** AIM AT BONES **/
DECLARE_OBJECT_POINTERS( pAimAtBone, pData, mstudioaimatbone_t )
WriteObjects( pAimAtBoneDest, pAimAtBoneSrc );
break;
}
default:
Assert( 0 );
Warning( "Unknown bone type %d found!\n", index );
}
}
}
/** BONE CONTROLLERS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, bonecontrollerindex )
WriteObjects<mstudiobonecontroller_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numbonecontrollers ) );
/** ATTACHMENTS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localattachmentindex )
WriteObjects<mstudioattachment_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numlocalattachments ) );
/** HITBOX SETS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, hitboxsetindex )
DECLARE_OBJECT_POINTERS( pHitboxSet, pData, mstudiohitboxset_t )
ITERATE_BLOCK( pHitboxSet, pHdr->numhitboxsets )
{
WriteObjects( pHitboxSetDest, pHitboxSetSrc );
/** HITBOXES **/
SET_INDEX_POINTERS_FIXUP( pData, pHitboxSet, hitboxindex )
WriteObjects<mstudiobbox_t>( pDataDest, pDataSrc, SrcNative( &pHitboxSet->numhitboxes ) );
}
/** BONE TABLE **/
SET_INDEX_POINTERS( pData, pHdr, bonetablebynameindex )
WriteBuffer<char>( pDataDest, pDataSrc, SrcNative( &pHdr->numbones ) );
/** ANIMATION DESCRIPTIONS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localanimindex )
DECLARE_OBJECT_POINTERS( pAnimDesc, pData, mstudioanimdesc_t )
ITERATE_BLOCK( pAnimDesc, pHdr->numlocalanim )
{
WriteObjects( pAnimDescDest, pAnimDescSrc );
if ( pAnimDesc->animblock == -1 )
{
// out of date model format
continue;
}
// section data can point to both internal and external blocks
int numsections = 0;
if ( pAnimDesc->sectionframes != 0 )
{
numsections = pAnimDesc->numframes / pAnimDesc->sectionframes + 2;
SET_INDEX_POINTERS( pData, pAnimDesc, sectionindex )
DECLARE_OBJECT_POINTERS( pSection, pData, mstudioanimsections_t )
WriteObjects( pSectionDest, pSectionSrc, numsections );
}
if ( pAnimDesc->animblock == 0 )
{
if ( numsections == 0 )
{
SET_INDEX_POINTERS( pData, pAnimDesc, animindex )
ByteswapAnimData( pAnimDesc, 0, pDataSrc, pDataDest );
}
else
{
for ( int i = 0; i < numsections; ++i )
{
if ( pAnimDesc->pSection( i )->animblock == 0 )
{
int index = pAnimDesc->pSection( i )->animindex;
// Base address of the animation in the animblock
byte *pDataSrcAnim = (byte *)pAnimDescSrc + index;
byte *pDataDestAnim = (byte *)pAnimDescDest + index;
ByteswapAnimData( pAnimDesc, i, pDataSrcAnim, pDataDestAnim );
}
}
}
/** IK RULES **/
if ( pAnimDesc->ikruleindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pAnimDesc, ikruleindex )
DECLARE_OBJECT_POINTERS( pIKRule, pData, mstudioikrule_t )
int numframes = SrcNative( &pAnimDesc->numframes );
ByteswapIKRules( pHdrSrc, pAnimDesc->numikrules, numframes, pDataSrc, pDataDest, fixedFileSize, fileSize );
}
/** LOCAL HIERARCHY **/
if ( pAnimDesc->localhierarchyindex )
{
SET_INDEX_POINTERS( pData, pAnimDesc, localhierarchyindex )
DECLARE_OBJECT_POINTERS( pLocalHierarchy, pData, mstudiolocalhierarchy_t )
ITERATE_BLOCK( pLocalHierarchy, pAnimDesc->numlocalhierarchy )
{
WriteObjects<mstudiolocalhierarchy_t>( pLocalHierarchyDest, pLocalHierarchySrc, SrcNative( &pAnimDesc->numlocalhierarchy ) );
/** COMPRESSED IK ERRORS **/
if ( pLocalHierarchy->localanimindex != 0 )
{
// Calculate the number of ikerrors by converting the ikerror start and end float values to
// frame numbers. (See the generation of these values in simplify.cpp: ProcessIKRules()).
int numFrames = SrcNative( &pAnimDesc->numframes );
float start = floorf( SrcNative( &pLocalHierarchy->start ) * (numFrames - 1) + 0.5f );
float end = floorf( SrcNative( &pLocalHierarchy->end ) * (numFrames - 1) + 0.5f );
int totalerror = (int)( end - start + 1 );
if ( end >= numFrames )
totalerror += 2;
SET_INDEX_POINTERS( pData, pLocalHierarchy, localanimindex )
WriteObjects<mstudiocompressedikerror_t>( pDataDest, pDataSrc );
mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pDataSrc;
// Write the animvalues.
for ( int idx = 0; idx < 6; ++idx )
{
if ( pCompressed->offset[idx] )
{
byte *pAnimvalueSrc = pDataSrc + SrcNative( &pCompressed->offset[idx] );
byte *pAnimvalueDest = pDataDest + SrcNative( &pCompressed->offset[idx] );
int numerror = 0;
while ( numerror < totalerror )
{
// Write the first animation value (struct of 2 bytes)
mstudioanimvalue_t *pDestAnimvalue = (mstudioanimvalue_t*)( g_bNativeSrc ? pAnimvalueSrc : pAnimvalueDest );
WriteBuffer<char>( &pAnimvalueDest, &pAnimvalueSrc, 2 );
// Write the remaining animation values from this group (shorts)
WriteBuffer<short>( &pAnimvalueDest, &pAnimvalueSrc, pDestAnimvalue->num.valid );
numerror += pDestAnimvalue->num.total;
}
}
}
}
}
} // Local Hierarchy block
}
} // Animdesc block
/** MOVEMENTS **/
// Separate loop required by format of mstudioanimdesc_t data
SET_INDEX_POINTERS( pData, pHdr, localanimindex )
SET_OBJECT_POINTERS( pAnimDesc, pData, mstudioanimdesc_t )
ITERATE_BLOCK( pAnimDesc, pHdr->numlocalanim )
{
if ( pAnimDesc->nummovements )
{
SET_INDEX_POINTERS_FIXUP( pData, pAnimDesc, movementindex )
WriteObjects<mstudiomovement_t>( pDataDest, pDataSrc, SrcNative( &pAnimDesc->nummovements ) );
}
}
/** IK RULES (2nd pass) **/
// This is required to support older models that had these lumps in a different
// order - the model version didn't change, so there's no reliable way to detect it.
SET_INDEX_POINTERS( pData, pHdr, localanimindex )
SET_OBJECT_POINTERS( pAnimDesc, pData, mstudioanimdesc_t )
ITERATE_BLOCK( pAnimDesc, pHdr->numlocalanim )
{
if ( pAnimDesc->ikruleindex )
{
// Only need to write the data again if a fixup happens
byte *pTest = (byte*)pAnimDesc + SrcNative( &pAnimDesc->ikruleindex );
SET_INDEX_POINTERS_FIXUP( pData, pAnimDesc, ikruleindex )
if ( pTest == pDataSrc )
continue;
DECLARE_OBJECT_POINTERS( pIKRule, pData, mstudioikrule_t )
ITERATE_BLOCK( pIKRule, pAnimDesc->numikrules )
{
WriteObjects<mstudioikrule_t>( pIKRuleDest, pIKRuleSrc );
/** IK ERROR KEYS **/
// Calculate the number of ikerrors by converting the ikerror start and end float values to
// frame numbers. (See the generation of these values in simplify.cpp: ProcessIKRules()).
int numFrames = SrcNative( &pAnimDesc->numframes );
float start = floorf( SrcNative( &pIKRule->start ) * (numFrames - 1) + 0.5f );
float end = floorf( SrcNative( &pIKRule->end ) * (numFrames - 1) + 0.5f );
int totalerror = (int)( end - start + 1 );
if ( end >= numFrames )
totalerror += 2;
// Uncompressed - only found in some older models (shipped hl2)
if ( pIKRule->ikerrorindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pIKRule, ikerrorindex )
WriteObjects<mstudioikerror_t>( pDataDest, pDataSrc, totalerror );
}
// Compressed - all models since hl2
if ( pIKRule->compressedikerrorindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pIKRule, compressedikerrorindex )
WriteObjects<mstudiocompressedikerror_t>( pDataDest, pDataSrc );
mstudiocompressedikerror_t *pCompressed = (mstudiocompressedikerror_t *)pDataSrc;
// Write the animvalues.
for ( int idx = 0; idx < 6; ++idx )
{
if ( pCompressed->offset[idx] )
{
byte *pAnimvalueSrc = pDataSrc + SrcNative( &pCompressed->offset[idx] );
byte *pAnimvalueDest = pDataDest + SrcNative( &pCompressed->offset[idx] );
int numerror = 0;
while ( numerror < totalerror )
{
// Write the first animation value (struct of 2 bytes)
mstudioanimvalue_t *pDestAnimvalue = (mstudioanimvalue_t*)( g_bNativeSrc ? pAnimvalueSrc : pAnimvalueDest );
WriteBuffer<char>( &pAnimvalueDest, &pAnimvalueSrc, 2 );
// Write the remaining animation values from this group (shorts)
WriteBuffer<short>( &pAnimvalueDest, &pAnimvalueSrc, pDestAnimvalue->num.valid );
numerror += pDestAnimvalue->num.total;
}
}
}
if ( pIKRule->szattachmentindex )
{
SET_INDEX_POINTERS( pData, pIKRule, szattachmentindex )
int size = strlen( (char*)pDataSrc ) + 1;
WriteBuffer<char>( pDataDest, pDataSrc, size );
}
}
}
}
// Local hierarchy keys don't exist in older models
}
/** ZERO FRAMES **/
SET_INDEX_POINTERS( pData, pHdr, localanimindex )
SET_OBJECT_POINTERS( pAnimDesc, pData, mstudioanimdesc_t )
ITERATE_BLOCK( pAnimDesc, pHdr->numlocalanim )
{
if ( pAnimDesc->pZeroFrameData( ) != NULL )
{
int offset = pAnimDesc->pZeroFrameData( ) - (byte *)pAnimDesc;
// Base address of the animation in the animblock
byte *pZeroFrameSrc = (byte *)pAnimDescSrc + offset;
byte *pZeroFrameDest = (byte *)pAnimDescDest + offset;
SET_INDEX_POINTERS( pData, pHdr, boneindex )
SET_OBJECT_POINTERS( pStudioBone, pData, mstudiobone_t )
ITERATE_BLOCK( pStudioBone, pHdr->numbones )
{
if ( pStudioBone->flags & BONE_HAS_SAVEFRAME_POS )
{
for ( int j = 0; j < pAnimDesc->zeroframecount; j++)
{
WriteBuffer<short>( &pZeroFrameDest, &pZeroFrameSrc, 3 );
}
}
if ( pStudioBone->flags & BONE_HAS_SAVEFRAME_ROT )
{
for ( int j = 0; j < pAnimDesc->zeroframecount; j++)
{
WriteBuffer<int64>( &pZeroFrameDest, &pZeroFrameSrc, 1 );
}
}
}
}
}
/** SEQUENCE INFO **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localseqindex )
DECLARE_OBJECT_POINTERS( pSequence, pData, mstudioseqdesc_t )
ITERATE_BLOCK( pSequence, pHdr->numlocalseq )
{
WriteObjects( pSequenceDest, pSequenceSrc );
/** POSE KEYS **/
if ( pSequence->posekeyindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pSequence, posekeyindex )
WriteBuffer<float>( pDataDest, pDataSrc, SrcNative( &pSequence->groupsize[0] ) + SrcNative( &pSequence->groupsize[1] ) );
}
/** STUDIO EVENTS **/
SET_INDEX_POINTERS_FIXUP( pData, pSequence, eventindex )
WriteObjects<mstudioevent_t>( pDataDest, pDataSrc, SrcNative( &pSequence->numevents ) );
/** AUTOLAYERS **/
SET_INDEX_POINTERS_FIXUP( pData, pSequence, autolayerindex )
WriteObjects<mstudioautolayer_t>( pDataDest, pDataSrc, SrcNative( &pSequence->numautolayers ) );
/** BONE WEIGHTS **/
// Data may be shared across sequences
DECLARE_INDEX_POINTERS_FIXUP( pWeight, pSequence, weightlistindex )
if ( pWeightSrc >= pDataSrc )
{
int numBoneWeights = ( SrcNative( &pSequence->iklockindex ) - SrcNative( &pSequence->weightlistindex ) ) / sizeof(float);
WriteBuffer<float>( pWeightDest, pWeightSrc, numBoneWeights );
}
/** IK LOCKS **/
SET_INDEX_POINTERS_FIXUP( pData, pSequence, iklockindex )
WriteObjects<mstudioiklock_t>( pDataDest, pDataSrc, SrcNative( &pSequence->numiklocks ) );
/** ANIMATION INDICES **/
if ( pSequence->animindexindex )
{
SET_INDEX_POINTERS( pData, pSequence, animindexindex )
WriteBuffer<short>( pDataDest, pDataSrc, SrcNative( &pSequence->groupsize[0] ) * SrcNative( &pSequence->groupsize[1] ) );
}
/** KEYVALUES **/
SET_INDEX_POINTERS( pData, pSequence, keyvalueindex )
WriteBuffer<char>( pDataDest, pDataSrc, SrcNative( &pSequence->keyvaluesize ) );
/** ACTIVITY MODIFIERS **/
SET_INDEX_POINTERS( pData, pSequence, activitymodifierindex )
WriteObjects<mstudioactivitymodifier_t>( pDataDest, pDataSrc, SrcNative( &pSequence->numactivitymodifiers ) );
}
/** TRANSITION GRAPH **/
int numLocalNodes = SrcNative( &pHdr->numlocalnodes );
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localnodenameindex )
WriteBuffer<int>( pDataDest, pDataSrc, numLocalNodes );
/** LOCAL NODES **/
SET_INDEX_POINTERS( pData, pHdr, localnodeindex )
WriteBuffer<char>( pDataDest, pDataSrc, numLocalNodes * numLocalNodes );
/** BODYPART INFO **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, bodypartindex )
DECLARE_OBJECT_POINTERS( pBodypart, pData, mstudiobodyparts_t )
ITERATE_BLOCK( pBodypart, pHdr->numbodyparts )
{
WriteObjects( pBodypartDest, pBodypartSrc );
/** MODEL INFO **/
SET_INDEX_POINTERS_FIXUP( pData, pBodypart, modelindex )
DECLARE_OBJECT_POINTERS( pModel, pData, mstudiomodel_t )
ITERATE_BLOCK( pModel, pBodypart->nummodels )
{
WriteObjects( pModelDest, pModelSrc );
/** MESHES **/
SET_INDEX_POINTERS_FIXUP( pData, pModel, meshindex )
DECLARE_OBJECT_POINTERS( pMesh, pData, mstudiomesh_t )
ITERATE_BLOCK( pMesh, pModel->nummeshes )
{
WriteObjects( pMeshDest, pMeshSrc );
if ( !pMesh->numflexes )
continue;
/** FLEXES **/
SET_INDEX_POINTERS_FIXUP( pData, pMesh, flexindex )
DECLARE_OBJECT_POINTERS( pFlex, pData, mstudioflex_t )
ITERATE_BLOCK( pFlex, pMesh->numflexes )
{
WriteObjects( pFlexDest, pFlexSrc );
/** VERT ANIMS **/
SET_INDEX_POINTERS_FIXUP( pData, pFlex, vertindex )
WriteObjects<mstudiovertanim_t>( pDataDest, pDataSrc, SrcNative( &pFlex->numverts ) );
}
}
/** EYEBALLS **/
SET_INDEX_POINTERS_FIXUP( pData, pModel, eyeballindex )
WriteObjects<mstudioeyeball_t>( pDataDest, pDataSrc, SrcNative( &pModel->numeyeballs ) );
}
}
/** GLOBAL FLEX NAMES **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, flexdescindex )
WriteObjects<mstudioflexdesc_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numflexdesc ) );
/** GLOBAL FLEX CONTROLLERS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, flexcontrollerindex )
WriteObjects<mstudioflexcontroller_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numflexcontrollers ) );
/** GLOBAL FLEX CONTROLLER REMAPS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, flexcontrolleruiindex )
WriteObjects<mstudioflexcontrollerui_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numflexcontrollerui ) );
// TODOKD: The remap indices after the flex controller remap headers need to be swapped as well?
/** FLEX RULES **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, flexruleindex )
DECLARE_OBJECT_POINTERS( pFlexRule, pData, mstudioflexrule_t )
ITERATE_BLOCK( pFlexRule, pHdr->numflexrules )
{
WriteObjects( pFlexRuleDest, pFlexRuleSrc );
/** FLEX OPS **/
SET_INDEX_POINTERS_FIXUP( pData, pFlexRule, opindex )
WriteObjects<mstudioflexop_t>( pDataDest, pDataSrc, SrcNative( &pFlexRule->numops ) );
}
/** IK CHAINS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, ikchainindex )
DECLARE_OBJECT_POINTERS( pIKChain, pData, mstudioikchain_t )
ITERATE_BLOCK( pIKChain, pHdr->numikchains )
{
WriteObjects( pIKChainDest, pIKChainSrc );
/** IK LINKS **/
SET_INDEX_POINTERS( pData, pIKChain, linkindex )
WriteObjects<mstudioiklink_t>( pDataDest, pDataSrc, SrcNative( &pIKChain->numlinks ) );
}
/** IK AUTOPLAY LOCKS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localikautoplaylockindex )
WriteObjects<mstudioiklock_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numlocalikautoplaylocks ) );
/** MOUTH INFO **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, mouthindex )
WriteObjects<mstudiomouth_t>( pDataDest, pDataSrc, SrcNative( &pHdr->nummouths ) );
/** POSE PARAMATERS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, localposeparamindex )
WriteObjects<mstudioposeparamdesc_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numlocalposeparameters ) );
/** MODEL GROUPS **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, includemodelindex )
WriteObjects<mstudiomodelgroup_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numincludemodels ) );
/** ANIMBLOCK GROUP INFO **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, animblockindex )
WriteObjects<mstudioanimblock_t>( pDataDest, pDataSrc, SrcNative( &pHdr->numanimblocks ) );
/** TEXTURE INFO **/
// While swapping, kill off unwanted textures by name
SET_INDEX_POINTERS_FIXUP( pData, pHdr, textureindex )
DECLARE_OBJECT_POINTERS( pTexture, pData, mstudiotexture_t )
int textureCt = SrcNative( &pHdr->numtextures );
int nameOffset = 0;
for ( int i = 0; i < SrcNative( &pHdr->numtextures ); ++i, ++pTexture, ++pTextureSrc )
{
WriteObjects<mstudiotexture_t>( pTextureDest, pTextureSrc );
int destnameindex = SrcNative( &pTexture->sznameindex ) + nameOffset;
pTextureDest->sznameindex = DestNative( &destnameindex );
char *pName = (char*)pTexture + SrcNative( &pTexture->sznameindex );
#if 0 // Undone: Killing textures here can cause crashes at runtime.
// Don't need pupil textures
if ( Q_stristr( pName, "pupil_" ) || !Q_stricmp( pName, "pupil" ) )
{
--textureCt;
nameOffset += sizeof(mstudiotexture_t);
}
else
#endif
{
++pTextureDest;
}
}
pHdrDest->numtextures = DestNative( &textureCt );
/** TEXTURE INDICES **/
SET_INDEX_POINTERS_FIXUP( pData, pHdr, cdtextureindex )
WriteBuffer<int>( &pDataDest, &pDataSrc, SrcNative( &pHdr->numcdtextures ) );
/** TEXTURE DICTIONARY **/
SET_INDEX_POINTERS( pData, pHdr, skinindex )
WriteBuffer<short>( &pDataDest, &pDataSrc, SrcNative( &pHdr->numskinfamilies ) * SrcNative( &pHdr->numskinref ) );
/** KEYVALUES **/
SET_INDEX_POINTERS( pData, pHdr, keyvalueindex )
WriteBuffer<char>( &pDataDest, &pDataSrc, SrcNative( &pHdr->keyvaluesize ) );
/** STUDIOHDR2 **/
if ( pHdr->studiohdr2index )
{
DECLARE_INDEX_POINTERS_FIXUP( pLocalData, pHdr, studiohdr2index )
DECLARE_OBJECT_POINTERS( pStudioHdr2, pLocalData, studiohdr2_t )
// HACK: Pre-swap the constant "1" here so the automatic swap inside ITERATE_BLOCK will restore it
int studiohdr2ct = 1;
studiohdr2ct = SrcNative( &studiohdr2ct );
ITERATE_BLOCK( pStudioHdr2, studiohdr2ct )
{
WriteObjects( pStudioHdr2Dest, pStudioHdr2Src );
/** SRC BONE TRANSFORMS **/
if ( pStudioHdr2->numsrcbonetransform )
{
// Note, srcbonetransformindex is an offset from the start of the file, not the start of the studiohdr2
// as is the convention. That's why the macros can't be used here.
pDataSrc = (byte*)pHdrSrc + SrcNative( &pStudioHdr2->srcbonetransformindex );
pDataDest = (byte*)pHdrDest + SrcNative( &pStudioHdr2->srcbonetransformindex );
WriteObjects<mstudiosrcbonetransform_t>( &pDataDest, &pDataSrc, SrcNative( &pStudioHdr2->numsrcbonetransform ) );
}
if ( pStudioHdr2->linearboneindex )
{
SET_INDEX_POINTERS_FIXUP( pData, pStudioHdr2, linearboneindex )
DECLARE_OBJECT_POINTERS( pLinearBone, pData, mstudiolinearbone_t )
WriteObjects( pLinearBoneDest, pLinearBoneSrc );
int numBones = SrcNative( &pLinearBone->numbones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, flagsindex )
WriteBuffer<int>( &pDataDest, &pDataSrc, numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, parentindex )
WriteBuffer<int>( &pDataDest, &pDataSrc, numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, posindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 3*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, quatindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 4*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, rotindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 3*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, posetoboneindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 12*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, posscaleindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 3*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, rotscaleindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 3*numBones );
SET_INDEX_POINTERS_FIXUP( pData, pLinearBone, qalignmentindex )
WriteBuffer<float>( &pDataDest, &pDataSrc, 4*numBones );
}
/** BONE FLEX DRIVERS **/
if ( pStudioHdr2->m_nBoneFlexDriverIndex )
{
SET_INDEX_POINTERS_FIXUP( pData, pStudioHdr2, m_nBoneFlexDriverIndex )
DECLARE_OBJECT_POINTERS( pBoneFlexDriver, pData, mstudioboneflexdriver_t )
ITERATE_BLOCK( pBoneFlexDriver, pStudioHdr2->m_nBoneFlexDriverCount )
{
WriteObjects( pBoneFlexDriverDest, pBoneFlexDriverSrc );
/** BONE FLEX DRIVER CONTROLS **/
SET_INDEX_POINTERS_FIXUP( pData, pBoneFlexDriver, m_nControlIndex );
WriteObjects< mstudioboneflexdrivercontrol_t >( &pDataDest, &pDataSrc, SrcNative( &pBoneFlexDriver->m_nControlCount ) );
}
}
}
}
/** STRING TABLE **/
// NOTE: The block of data (above) swapped immediately before the string table MUST update the
// pDataSrc pointer position, in order for this string table offset calculation to work correctly.
// To update the pointer position, pass the pointer address to WriteObjects().
int offset = pDataSrc - (byte*)pSrcBase;
int stringTableBytes = fixedFileSize - offset;
WriteBuffer<char>( pDataDest, pDataSrc, stringTableBytes );
pHdrDest->length = DestNative( &fixedFileSize );
// Cleanup texture paths
// Some older MDL's have double terminal slashes
SET_INDEX_POINTERS( pData, pHdr, cdtextureindex )
int numCdTextures = SrcNative( &pHdr->numcdtextures );
for ( int i = 0; i < numCdTextures; ++i )
{
char *pPath = (char*)pHdrDest + SrcNative( &((int *)pDataSrc)[i] );
int len = strlen( pPath );
if ( len >= 2 && ( pPath[len-1] == '\\' || pPath[len-1] == '/' ) && ( pPath[len-2] == '\\' || pPath[len-2] == '/' ) )
{
pPath[len-1] = '\0';
}
}
return fixedFileSize;
}
//----------------------------------------------------------------------
// Swap a .mdl in two passes - first pass fixes alignment errors by shifting
// the data and updating offsets, then the second pass does the final swap.
//----------------------------------------------------------------------
int ByteswapMDL( void *pDestBase, const void *pSrcBase, const int fileSize )
{
// Make a working copy of the source to allow for alignment fixups
void *pNewSrcBase = malloc( fileSize + BYTESWAP_ALIGNMENT_PADDING );
Q_memcpy( pNewSrcBase, pSrcBase, fileSize );
int fixedFileSize = ByteswapMDLFile( pDestBase, pNewSrcBase, fileSize );
if ( fixedFileSize != fileSize )
{
int finalSize = ByteswapMDLFile( pDestBase, pNewSrcBase, fixedFileSize );
if ( finalSize != fixedFileSize )
{
Warning( "Alignment fixups failed on MDL swap!\n" );
fixedFileSize = 0;
}
}
free( pNewSrcBase );
// the compression needs to happen on the final or "fixed" pass
if ( g_pCompressFunc && fixedFileSize )
{
void *pInput = pDestBase;
int inputSize = fixedFileSize;
void *pOutput;
int outputSize;
if ( g_pCompressFunc( pInput, inputSize, &pOutput, &outputSize ) )
{
V_memcpy( pDestBase, pOutput, outputSize );
free( pOutput );
fixedFileSize = outputSize;
}
}
return fixedFileSize;
}
//----------------------------------------------------------------------
// Determines what kind of file this is and calls the correct swap function
//----------------------------------------------------------------------
int ByteswapStudioFile( const char *pFilename, void *pOutBase, const void *pFileBase, int fileSize, studiohdr_t *pHdr, CompressFunc_t pCompressFunc )
{
assert( pFilename );
assert( pOutBase != pFileBase );
g_pCompressFunc = pCompressFunc;
int retVal = 0;
if ( Q_stristr( pFilename, ".mdl" ) )
{
retVal = ByteswapMDL( pOutBase, pFileBase, fileSize );
}
else if ( Q_stristr( pFilename, ".vvd" ) )
{
retVal = ByteswapVVD( pOutBase, pFileBase, fileSize );
}
else if ( Q_stristr( pFilename, ".vtx" ) )
{
retVal = ByteswapVTX( pOutBase, pFileBase, fileSize );
}
else if ( Q_stristr( pFilename, ".phy" ) )
{
retVal = ByteswapPHY( pOutBase, pFileBase, fileSize );
}
else if ( Q_stristr( pFilename, ".ani" ) )
{
// some dead .ani files exist in the tree
// only process valid .ani files properly hooked to their .mdl
if ( pHdr && pHdr->numanimblocks != 0 )
{
retVal = ByteswapANI( pHdr, pOutBase, pFileBase, fileSize );
}
}
g_pCompressFunc = NULL;
return retVal;
}
//----------------------------------------------------------------------
// LEGACY ANI FIXUPS - No need to update this function
//
// If model data needs to be shifted to fix a misalignment, this function is
// called with the process func "UpdateSrcIndexFields" to update every datadesc field
// that was marked as FIELD_INDEX. Any index that "points" across
// the shifted data location will have its value incremented or decremented
// by the appropriate number of bytes. This misalignment issue only
// applies to some pre-EP2 models, as all newly compiled models are guaranteed
// to be aligned correctly. Therefore, this function should not need to change
// when model formats are updated, as any model compiled with a new format will
// naturally not require this fixup function to be called.
//----------------------------------------------------------------------
void ProcessANIFields( void *pDataBase, datadescProcessFunc_t pfnProcessFunc )
{
studiohdr_t *pHdr = g_pHdr;
//byte *pData = (byte*)pDataBase;
byte *pSrcBase = (byte*)g_pDataSrcBase;
// Since the animblocks and animdescs are native data, trick the system
// into not swapping their index values during processing.
bool bNativeSrc = g_bNativeSrc;
g_bNativeSrc = true;
// Update the .mdl's animblock offsets into the .ani file
mstudioanimblock_t *pAnimBlock = pHdr->pAnimBlock( 1 );
for ( int i = 1; i < pHdr->numanimblocks; ++i, ++pAnimBlock )
{
ProcessFields( pSrcBase, pAnimBlock, &mstudioanimblock_t::m_DataMap, pfnProcessFunc );
}
// Update the .mdl's animindex offsets into the .ani file
// Don't bother with local hierarchy keys - they only exist in newer, properly aligned models
mstudioanimdesc_t *pAnimDesc = pHdr->pLocalAnimdesc( 0 );
for ( int i = 0; i < pHdr->numlocalanim; ++i, ++pAnimDesc )
{
pAnimBlock = pHdr->pAnimBlock( pAnimDesc->animblock );
byte *pBlockBase = (byte*)pSrcBase + pAnimBlock->datastart;
ProcessFieldByName( pBlockBase, pAnimDesc, &mstudioanimdesc_t::m_DataMap, "animindex", pfnProcessFunc );
ProcessFieldByName( pBlockBase, pAnimDesc, &mstudioanimdesc_t::m_DataMap, "animblockikruleindex", pfnProcessFunc );
}
// Restore the correct native setting
g_bNativeSrc = bNativeSrc;
// Update the .ani file's internal offsets
pAnimDesc = pHdr->pLocalAnimdesc( 0 );
for ( int i = 0; i < pHdr->numlocalanim; ++i, ++pAnimDesc )
{
pAnimBlock = pHdr->pAnimBlock( pAnimDesc->animblock );
byte *pBlockBase = (byte*)pSrcBase + pAnimBlock->datastart;
byte *pData = pBlockBase + pAnimDesc->animindex;
mstudioanim_t* pAnimation = (mstudioanim_t*)pData;
if ( pAnimation->bone == 255 )
{
// No animation data
pAnimation = 0;
}
while( pAnimation )
{
ProcessFields( pAnimation, &mstudioanim_t::m_DataMap, pfnProcessFunc );
if ( pAnimation->nextoffset )
{
pData = (byte*)pAnimation + SrcNative( &pAnimation->nextoffset );
pAnimation = (mstudioanim_t*)pData;
}
else
{
pAnimation = NULL;
}
}
if ( pAnimDesc->animblockikruleindex )
{
pData = (byte*)pBlockBase + pAnimDesc->animblockikruleindex;
mstudioikrule_t *pIKRule = (mstudioikrule_t *)pData;
for ( int iIK = 0; iIK < pAnimDesc->numikrules; ++iIK, ++pIKRule )
{
ProcessFields( pIKRule, &mstudioikrule_t::m_DataMap, pfnProcessFunc );
}
}
}
}
//----------------------------------------------------------------------
// LEGACY MDL FIXUPS - No need to update this function
//
// If model data needs to be shifted to fix a misalignment, this function is
// called with the process func "UpdateSrcIndexFields" to update every datadesc field
// that was marked as FIELD_INDEX. Any index that "points" across
// the shifted data location will have its value incremented or decremented
// by the appropriate number of bytes. This misalignment issue only
// applies to some pre-EP2 models, as all newly compiled models are guaranteed
// to be aligned correctly. Therefore, this function should not need to change
// when model formats are updated, as any model compiled with a new format will
// naturally not require this fixup function to be called.
//----------------------------------------------------------------------
void ProcessMDLFields( void *pDataBase, datadescProcessFunc_t pfnProcessFunc )
{
byte *pData = (byte*)pDataBase;
/** FILE HEADER **/
studiohdr_t *pHdr = (studiohdr_t*)pData;
ProcessFields( pHdr, &studiohdr_t::m_DataMap, pfnProcessFunc );
/** BONES **/
pData = (byte*)pHdr + SrcNative( &pHdr->boneindex );
mstudiobone_t *pBone = (mstudiobone_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numbones ); ++i, ++pBone )
{
ProcessFields( pBone, &mstudiobone_t::m_DataMap, pfnProcessFunc );
if ( pBone->procindex )
{
pData = (byte*)pBone + SrcNative( &pBone->procindex );
unsigned int proctype = SrcNative( &pBone->proctype );
switch( proctype )
{
case STUDIO_PROC_AXISINTERP:
/** AXIS-INTERP BONES **/
ProcessFields( pData, &mstudioaxisinterpbone_t::m_DataMap, pfnProcessFunc );
break;
case STUDIO_PROC_QUATINTERP:
/** QUAT-INTERP BONES **/
ProcessFields( pData, &mstudioquatinterpbone_t::m_DataMap, pfnProcessFunc );
break;
case STUDIO_PROC_JIGGLE:
/** JIGGLE BONES **/
ProcessFields( pData, &mstudiojigglebone_t::m_DataMap, pfnProcessFunc );
break;
case STUDIO_PROC_AIMATBONE:
case STUDIO_PROC_AIMATATTACH:
/** AIM AT BONES **/
ProcessFields( pData, &mstudioaimatbone_t::m_DataMap, pfnProcessFunc );
break;
}
}
}
/** ATTACHMENTS **/
pData = (byte*)pHdr + SrcNative( &pHdr->localattachmentindex );
mstudioattachment_t *pAttachment = (mstudioattachment_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numlocalattachments ); ++i, ++pAttachment )
{
ProcessFields( pAttachment, &mstudioattachment_t::m_DataMap, pfnProcessFunc );
}
/** HITBOX SETS **/
pData = (byte*)pHdr + SrcNative( &pHdr->hitboxsetindex );
mstudiohitboxset_t* pHitboxSet = (mstudiohitboxset_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numhitboxsets ); ++i, ++pHitboxSet )
{
ProcessFields( pHitboxSet, &mstudiohitboxset_t::m_DataMap, pfnProcessFunc );
/** HITBOXES **/
pData = (byte*)pHitboxSet + SrcNative( &pHitboxSet->hitboxindex );
mstudiobbox_t *pBBox = (mstudiobbox_t*)pData;
for ( int iHit = 0; iHit < SrcNative( &pHitboxSet->numhitboxes ); ++iHit, ++pBBox )
{
ProcessFields( pBBox, &mstudiobbox_t::m_DataMap, pfnProcessFunc );
}
}
/** ANIMATION DESCRIPTIONS **/
pData = (byte*)pHdr + SrcNative( &pHdr->localanimindex );
mstudioanimdesc_t* pAnimDesc = (mstudioanimdesc_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numlocalanim ); ++i, ++pAnimDesc )
{
// Can't update animindex or animblockindex for animations that are in a separate .ani file
ProcessFieldByName( pAnimDesc, &mstudioanimdesc_t::m_DataMap, "baseptr", pfnProcessFunc );
ProcessFieldByName( pAnimDesc, &mstudioanimdesc_t::m_DataMap, "sznameindex", pfnProcessFunc );
ProcessFieldByName( pAnimDesc, &mstudioanimdesc_t::m_DataMap, "movementindex", pfnProcessFunc );
ProcessFieldByName( pAnimDesc, &mstudioanimdesc_t::m_DataMap, "ikruleindex", pfnProcessFunc );
/** ANIMATIONS **/
if ( pAnimDesc->animblock == 0 )
{
// Now it's safe to update the animindex
ProcessFieldByName( pAnimDesc, &mstudioanimdesc_t::m_DataMap, "animindex", pfnProcessFunc );
pData = (byte*)pAnimDesc + SrcNative( &pAnimDesc->animindex );
mstudioanim_t* pAnimation = (mstudioanim_t*)pData;
while( pAnimation )
{
ProcessFields( pAnimation, &mstudioanim_t::m_DataMap, pfnProcessFunc );
if ( pAnimation->nextoffset )
{
pData = (byte*)pAnimation + SrcNative( &pAnimation->nextoffset );
pAnimation = (mstudioanim_t*)pData;
}
else
{
pAnimation = NULL;
}
}
}
if ( pAnimDesc->ikruleindex )
{
pData = (byte*)pAnimDesc + SrcNative( &pAnimDesc->ikruleindex );
mstudioikrule_t *pIKRule = (mstudioikrule_t *)pData;
for ( int iIK = 0; iIK < SrcNative( &pAnimDesc->numikrules ); ++iIK, ++pIKRule )
{
ProcessFields( pIKRule, &mstudioikrule_t::m_DataMap, pfnProcessFunc );
}
}
}
/** SEQUENCE INFO **/
pData = (byte*)pHdr + SrcNative( &pHdr->localseqindex );
mstudioseqdesc_t *pSequenceHdr = (mstudioseqdesc_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numlocalseq ); ++i, ++pSequenceHdr )
{
ProcessFields( pSequenceHdr, &mstudioseqdesc_t::m_DataMap, pfnProcessFunc );
/** STUDIO EVENTS **/
pData = (byte*)pHdr + SrcNative( &pSequenceHdr->eventindex );
mstudioevent_t *pEvent = (mstudioevent_t*)pData;
for ( int iEvent = 0; iEvent < SrcNative( &pSequenceHdr->numevents ); ++iEvent, ++pEvent )
{
ProcessFields( pSequenceHdr, &mstudioevent_t::m_DataMap, pfnProcessFunc );
}
}
/** BODYPART INFO **/
pData = (byte*)pHdr + SrcNative( &pHdr->bodypartindex );
mstudiobodyparts_t *pBodypart = (mstudiobodyparts_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numbodyparts ); ++i, ++pBodypart )
{
ProcessFields( pBodypart, &mstudiobodyparts_t::m_DataMap, pfnProcessFunc );
/** MODEL INFO **/
byte *pDataModel = (byte*)pBodypart + SrcNative( &pBodypart->modelindex );
mstudiomodel_t *pModel = (mstudiomodel_t*)pDataModel;
for ( int iModel = 0; iModel < SrcNative( &pBodypart->nummodels ); ++iModel, ++pModel )
{
ProcessFields( pModel, &mstudiomodel_t::m_DataMap, pfnProcessFunc );
/** MESHES **/
pData = (byte*)pModel + SrcNative( &pModel->meshindex );
mstudiomesh_t *pMesh = (mstudiomesh_t*)pData;
for ( int iMesh = 0; iMesh < SrcNative( &pModel->nummeshes ); ++iMesh, ++pMesh )
{
ProcessFields( pMesh, &mstudiomesh_t::m_DataMap, pfnProcessFunc );
if ( !pMesh->numflexes )
continue;
/** FLEXES **/
pData = (byte*)pMesh + SrcNative( &pMesh->flexindex );
mstudioflex_t *pFlex = (mstudioflex_t*)pData;
for ( int iFlesh = 0; iFlesh < SrcNative( &pMesh->numflexes ); ++iFlesh, ++pFlex )
{
ProcessFields( pFlex, &mstudioflex_t::m_DataMap, pfnProcessFunc );
}
}
/** EYEBALLS **/
pData= (byte*)pModel + SrcNative( &pModel->eyeballindex );
mstudioeyeball_t *pEyeball = (mstudioeyeball_t*)pData;
for ( int iEye = 0; iEye < SrcNative( &pModel->numeyeballs ); ++iEye, ++pEyeball )
{
ProcessFields( pEyeball, &mstudioeyeball_t::m_DataMap, pfnProcessFunc );
}
}
}
/** GLOBAL FLEX NAMES **/
pData = (byte*)pHdr + SrcNative( &pHdr->flexdescindex );
mstudioflexdesc_t *pFlexDesc = (mstudioflexdesc_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numflexdesc ); ++i, ++pFlexDesc )
{
ProcessFields( pFlexDesc, &mstudioflexdesc_t::m_DataMap, pfnProcessFunc );
}
/** GLOBAL FLEX CONTROLLERS **/
pData = (byte*)pHdr + SrcNative( &pHdr->flexcontrollerindex );
mstudioflexcontroller_t *pFlexController = (mstudioflexcontroller_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numflexcontrollers ); ++i, ++pFlexController )
{
ProcessFields( pFlexController, &mstudioflexcontroller_t::m_DataMap, pfnProcessFunc );
}
/** GLOBAL FLEX CONTROLLER REMAPS **/
pData = (byte*)pHdr + SrcNative( &pHdr->flexcontrolleruiindex );
mstudioflexcontrollerui_t *pFlexControllerRemap = (mstudioflexcontrollerui_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numflexcontrollerui ); ++i, ++pFlexControllerRemap )
{
ProcessFields( pFlexControllerRemap, &mstudioflexcontrollerui_t::m_DataMap, pfnProcessFunc );
}
/** FLEX RULES **/
pData = (byte*)pHdr + SrcNative( &pHdr->flexruleindex );
mstudioflexrule_t *pFlexRule = (mstudioflexrule_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numflexrules ); ++i, ++pFlexRule )
{
ProcessFields( pFlexRule, &mstudioflexrule_t::m_DataMap, pfnProcessFunc );
}
/** IK CHAINS **/
pData = (byte*)pHdr + SrcNative( &pHdr->ikchainindex );
mstudioikchain_t *pIKChain = (mstudioikchain_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numikchains ); ++i, ++pIKChain )
{
ProcessFields( pIKChain, &mstudioikchain_t::m_DataMap, pfnProcessFunc );
}
/** POSE PARAMATERS **/
pData = (byte*)pHdr + SrcNative( &pHdr->localposeparamindex );
mstudioposeparamdesc_t *pPoseParam = (mstudioposeparamdesc_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numlocalposeparameters ); ++i, ++pPoseParam )
{
ProcessFields( pPoseParam, &mstudioposeparamdesc_t::m_DataMap, pfnProcessFunc );
}
/** MODEL GROUPS **/
pData = (byte*)pHdr + SrcNative( &pHdr->includemodelindex );
mstudiomodelgroup_t *pMdl = (mstudiomodelgroup_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numincludemodels ); ++i, ++pMdl )
{
ProcessFields( pMdl, &mstudiomodelgroup_t::m_DataMap, pfnProcessFunc );
}
/** TEXTURE INFO **/
pData = (byte*)pHdr + SrcNative( &pHdr->textureindex );
mstudiotexture_t *pTexture = (mstudiotexture_t*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numtextures ); ++i, ++pTexture )
{
ProcessFields( pTexture, &mstudiotexture_t::m_DataMap, pfnProcessFunc );
}
/** CDTEXTURE OFFSETS **/
pData = (byte*)pHdr + SrcNative( &pHdr->cdtextureindex );
int *pIdx = (int*)pData;
for ( int i = 0; i < SrcNative( &pHdr->numcdtextures ); ++i, ++pIdx )
{
int idx = SrcNative( pIdx );
UpdateIndex( pHdr, &idx );
*pIdx = SrcNative( &idx );
}
/** STUDIOHDR2 **/
if ( pHdr->studiohdr2index )
{
pData = (byte*)pHdr + SrcNative( &pHdr->studiohdr2index );
studiohdr2_t *pStudioHdr2 = (studiohdr2_t*)pData;
for ( int i = 0; i < 1; ++i, ++pStudioHdr2 )
{
ProcessFields( pStudioHdr2, &studiohdr2_t::m_DataMap, pfnProcessFunc );
/** SRC BONE TRANSFORMS **/
pData = (byte*)pHdr + SrcNative( &pStudioHdr2->srcbonetransformindex );
mstudiosrcbonetransform_t *pSrcBoneTransform = (mstudiosrcbonetransform_t*)pData;
for ( int iBone = 0; iBone < SrcNative( &pStudioHdr2->numsrcbonetransform ); ++iBone, ++pSrcBoneTransform )
{
ProcessFields( pSrcBoneTransform, &mstudiosrcbonetransform_t::m_DataMap, pfnProcessFunc );
}
}
}
}
#pragma warning( pop ) // local variable is initialized but not referenced
} // namespace StudioByteSwap
// Data descriptions for byte swapping - only needed
// for structures that are written to file for use by the game.
// For any fields that reference other data in the file, use the
// DEFINE_INDEX macro to identify them as such.
BEGIN_BYTESWAP_DATADESC( studiohdr_t )
DEFINE_FIELD( id, FIELD_INTEGER ),
DEFINE_FIELD( version, FIELD_INTEGER ),
DEFINE_FIELD( checksum, FIELD_INTEGER ),
DEFINE_ARRAY( name, FIELD_CHARACTER, 64 ),
DEFINE_FIELD( length, FIELD_INTEGER ),
DEFINE_FIELD( eyeposition, FIELD_VECTOR ),
DEFINE_FIELD( illumposition, FIELD_VECTOR ),
DEFINE_FIELD( hull_min, FIELD_VECTOR ),
DEFINE_FIELD( hull_max, FIELD_VECTOR ),
DEFINE_FIELD( view_bbmin, FIELD_VECTOR ),
DEFINE_FIELD( view_bbmax, FIELD_VECTOR ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( numbones, FIELD_INTEGER ), // bones
DEFINE_INDEX( boneindex, FIELD_INTEGER ),
DEFINE_FIELD( numbonecontrollers, FIELD_INTEGER ), // bone controllers
DEFINE_INDEX( bonecontrollerindex, FIELD_INTEGER ),
DEFINE_FIELD( numhitboxsets, FIELD_INTEGER ),
DEFINE_INDEX( hitboxsetindex, FIELD_INTEGER ),
DEFINE_FIELD( numlocalanim, FIELD_INTEGER ), // animations/poses
DEFINE_INDEX( localanimindex, FIELD_INTEGER ), // animation descriptions
DEFINE_FIELD( numlocalseq, FIELD_INTEGER ), // sequences
DEFINE_INDEX( localseqindex, FIELD_INTEGER ),
DEFINE_FIELD( activitylistversion, FIELD_INTEGER ), // initialization flag - have the sequences been indexed?
DEFINE_FIELD( eventsindexed, FIELD_INTEGER ),
DEFINE_FIELD( numtextures, FIELD_INTEGER ),
DEFINE_INDEX( textureindex, FIELD_INTEGER ),
DEFINE_FIELD( numcdtextures, FIELD_INTEGER ),
DEFINE_INDEX( cdtextureindex, FIELD_INTEGER ),
DEFINE_FIELD( numskinref, FIELD_INTEGER ),
DEFINE_FIELD( numskinfamilies, FIELD_INTEGER ),
DEFINE_INDEX( skinindex, FIELD_INTEGER ),
DEFINE_FIELD( numbodyparts, FIELD_INTEGER ),
DEFINE_INDEX( bodypartindex, FIELD_INTEGER ),
DEFINE_FIELD( numlocalattachments, FIELD_INTEGER ),
DEFINE_INDEX( localattachmentindex, FIELD_INTEGER ),
DEFINE_FIELD( numlocalnodes, FIELD_INTEGER ),
DEFINE_INDEX( localnodeindex, FIELD_INTEGER ),
DEFINE_INDEX( localnodenameindex, FIELD_INTEGER ),
DEFINE_FIELD( numflexdesc, FIELD_INTEGER ),
DEFINE_INDEX( flexdescindex, FIELD_INTEGER ),
DEFINE_FIELD( numflexcontrollers, FIELD_INTEGER ),
DEFINE_INDEX( flexcontrollerindex, FIELD_INTEGER ),
DEFINE_FIELD( numflexrules, FIELD_INTEGER ),
DEFINE_INDEX( flexruleindex, FIELD_INTEGER ),
DEFINE_FIELD( numikchains, FIELD_INTEGER ),
DEFINE_INDEX( ikchainindex, FIELD_INTEGER ),
DEFINE_FIELD( nummouths, FIELD_INTEGER ),
DEFINE_INDEX( mouthindex, FIELD_INTEGER ),
DEFINE_FIELD( numlocalposeparameters, FIELD_INTEGER ),
DEFINE_INDEX( localposeparamindex, FIELD_INTEGER ),
DEFINE_INDEX( surfacepropindex, FIELD_INTEGER ),
DEFINE_INDEX( keyvalueindex, FIELD_INTEGER ),
DEFINE_FIELD( keyvaluesize, FIELD_INTEGER ),
DEFINE_FIELD( numlocalikautoplaylocks, FIELD_INTEGER ),
DEFINE_INDEX( localikautoplaylockindex, FIELD_INTEGER ),
DEFINE_FIELD( mass, FIELD_FLOAT ),
DEFINE_FIELD( contents, FIELD_INTEGER ),
DEFINE_FIELD( numincludemodels, FIELD_INTEGER ),
DEFINE_INDEX( includemodelindex, FIELD_INTEGER ),
DEFINE_FIELD( virtualModel, FIELD_INTEGER ), // void*
DEFINE_INDEX( szanimblocknameindex, FIELD_INTEGER ),
DEFINE_FIELD( numanimblocks, FIELD_INTEGER ),
DEFINE_INDEX( animblockindex, FIELD_INTEGER ),
DEFINE_FIELD( animblockModel, FIELD_INTEGER ), // void*
DEFINE_INDEX( bonetablebynameindex, FIELD_INTEGER ),
DEFINE_FIELD( pVertexBase, FIELD_INTEGER ), // void*
DEFINE_FIELD( pIndexBase, FIELD_INTEGER ), // void*
DEFINE_FIELD( constdirectionallightdot, FIELD_CHARACTER ), // byte
DEFINE_FIELD( rootLOD, FIELD_CHARACTER ), // byte
DEFINE_FIELD( numAllowedRootLODs, FIELD_CHARACTER ), // byte
DEFINE_ARRAY( unused, FIELD_CHARACTER, 1 ), // byte
DEFINE_INDEX( unused4, FIELD_INTEGER ),
DEFINE_FIELD( numflexcontrollerui, FIELD_INTEGER ),
DEFINE_INDEX( flexcontrolleruiindex, FIELD_INTEGER ),
DEFINE_FIELD( flVertAnimFixedPointScale, FIELD_FLOAT ),
DEFINE_ARRAY( unused3, FIELD_INTEGER, 1 ),
DEFINE_INDEX( studiohdr2index, FIELD_INTEGER ),
DEFINE_ARRAY( unused2, FIELD_INTEGER, 1 ),
END_BYTESWAP_DATADESC()
// NOTE! Next time we up the .mdl file format, remove studiohdr2_t
// and insert all fields in this structure into studiohdr_t.
BEGIN_BYTESWAP_DATADESC( studiohdr2_t )
DEFINE_FIELD( numsrcbonetransform, FIELD_INTEGER ),
DEFINE_INDEX( srcbonetransformindex, FIELD_INTEGER ),
DEFINE_FIELD( illumpositionattachmentindex, FIELD_INTEGER ),
DEFINE_FIELD( flMaxEyeDeflection, FIELD_FLOAT ),
DEFINE_INDEX( linearboneindex, FIELD_INTEGER ),
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_INDEX( m_nBoneFlexDriverCount, FIELD_INTEGER ),
DEFINE_INDEX( m_nBoneFlexDriverIndex, FIELD_INTEGER ),
DEFINE_ARRAY( reserved, FIELD_INTEGER, 56 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiobone_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( parent, FIELD_INTEGER ),
DEFINE_ARRAY( bonecontroller, FIELD_INTEGER, 6 ),
DEFINE_FIELD( pos, FIELD_VECTOR ),
DEFINE_FIELD( quat, FIELD_QUATERNION ),
DEFINE_ARRAY( rot, FIELD_FLOAT, 3 ), // RadianEuler
DEFINE_FIELD( posscale, FIELD_VECTOR ),
DEFINE_FIELD( rotscale, FIELD_VECTOR ),
DEFINE_ARRAY( poseToBone, FIELD_FLOAT, 12 ), // matrix3x4_t
DEFINE_FIELD( qAlignment, FIELD_QUATERNION ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( proctype, FIELD_INTEGER ),
DEFINE_INDEX( procindex, FIELD_INTEGER ),
DEFINE_INDEX( physicsbone, FIELD_INTEGER ),
DEFINE_INDEX( surfacepropidx, FIELD_INTEGER ),
DEFINE_FIELD( contents, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiolinearbone_t )
DEFINE_FIELD( numbones, FIELD_INTEGER ),
DEFINE_INDEX( flagsindex, FIELD_INTEGER ),
DEFINE_INDEX( parentindex, FIELD_INTEGER ),
DEFINE_INDEX( posindex, FIELD_INTEGER ),
DEFINE_INDEX( quatindex, FIELD_INTEGER ),
DEFINE_INDEX( rotindex, FIELD_INTEGER ),
DEFINE_INDEX( posetoboneindex, FIELD_INTEGER ),
DEFINE_INDEX( posscaleindex, FIELD_INTEGER ),
DEFINE_INDEX( rotscaleindex, FIELD_INTEGER ),
DEFINE_INDEX( qalignmentindex, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 6 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioboneflexdrivercontrol_t )
DEFINE_INDEX( m_nBoneComponent, FIELD_INTEGER ),
DEFINE_FIELD( m_nFlexControllerIndex, FIELD_INTEGER ),
DEFINE_INDEX( m_flMin, FIELD_FLOAT ),
DEFINE_INDEX( m_flMax, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioboneflexdriver_t )
DEFINE_INDEX( m_nBoneIndex, FIELD_INTEGER ),
DEFINE_FIELD( m_nControlCount, FIELD_INTEGER ),
DEFINE_INDEX( m_nControlIndex, FIELD_FLOAT ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 3 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioaxisinterpbone_t )
DEFINE_FIELD( control, FIELD_INTEGER ),
DEFINE_FIELD( axis, FIELD_INTEGER ),
DEFINE_ARRAY( pos, FIELD_VECTOR, 6 ),
DEFINE_ARRAY( quat, FIELD_QUATERNION, 6 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioquatinterpbone_t )
DEFINE_FIELD( control, FIELD_INTEGER ),
DEFINE_FIELD( numtriggers, FIELD_INTEGER ),
DEFINE_INDEX( triggerindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiojigglebone_t )
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( length, FIELD_FLOAT ),
DEFINE_FIELD( tipMass, FIELD_FLOAT ),
DEFINE_FIELD( yawStiffness, FIELD_FLOAT ),
DEFINE_FIELD( yawDamping, FIELD_FLOAT ),
DEFINE_FIELD( pitchStiffness, FIELD_FLOAT ),
DEFINE_FIELD( pitchDamping, FIELD_FLOAT ),
DEFINE_FIELD( alongStiffness, FIELD_FLOAT ),
DEFINE_FIELD( alongDamping, FIELD_FLOAT ),
DEFINE_FIELD( angleLimit, FIELD_FLOAT ),
DEFINE_FIELD( minYaw, FIELD_FLOAT ),
DEFINE_FIELD( maxYaw, FIELD_FLOAT ),
DEFINE_FIELD( yawFriction, FIELD_FLOAT ),
DEFINE_FIELD( yawBounce, FIELD_FLOAT ),
DEFINE_FIELD( minPitch, FIELD_FLOAT ),
DEFINE_FIELD( maxPitch, FIELD_FLOAT ),
DEFINE_FIELD( pitchFriction, FIELD_FLOAT ),
DEFINE_FIELD( pitchBounce, FIELD_FLOAT ),
DEFINE_FIELD( baseMass, FIELD_FLOAT ),
DEFINE_FIELD( baseStiffness, FIELD_FLOAT ),
DEFINE_FIELD( baseDamping, FIELD_FLOAT ),
DEFINE_FIELD( baseMinLeft, FIELD_FLOAT ),
DEFINE_FIELD( baseMaxLeft, FIELD_FLOAT ),
DEFINE_FIELD( baseLeftFriction, FIELD_FLOAT ),
DEFINE_FIELD( baseMinUp, FIELD_FLOAT ),
DEFINE_FIELD( baseMaxUp, FIELD_FLOAT ),
DEFINE_FIELD( baseUpFriction, FIELD_FLOAT ),
DEFINE_FIELD( baseMinForward, FIELD_FLOAT ),
DEFINE_FIELD( baseMaxForward, FIELD_FLOAT ),
DEFINE_FIELD( baseForwardFriction, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioaimatbone_t )
DEFINE_FIELD( parent, FIELD_INTEGER ),
DEFINE_FIELD( aim, FIELD_INTEGER ),
DEFINE_ARRAY( aimvector, FIELD_FLOAT, 3 ),
DEFINE_ARRAY( upvector, FIELD_FLOAT, 3 ),
DEFINE_ARRAY( basepos, FIELD_FLOAT, 3 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioquatinterpinfo_t )
DEFINE_FIELD( inv_tolerance, FIELD_FLOAT ),
DEFINE_FIELD( trigger, FIELD_QUATERNION ),
DEFINE_FIELD( pos, FIELD_VECTOR ),
DEFINE_FIELD( quat, FIELD_QUATERNION ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiobonecontroller_t )
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( type, FIELD_INTEGER ),
DEFINE_FIELD( start, FIELD_FLOAT ),
DEFINE_FIELD( end, FIELD_FLOAT ),
DEFINE_FIELD( rest, FIELD_INTEGER ),
DEFINE_FIELD( inputfield, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioattachment_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( localbone, FIELD_INTEGER ),
DEFINE_ARRAY( local, FIELD_FLOAT, 12 ), // matrix3x4_t
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiohitboxset_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( numhitboxes, FIELD_INTEGER ),
DEFINE_INDEX( hitboxindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiosrcbonetransform_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_ARRAY( pretransform, FIELD_FLOAT, 12 ), // matrix3x4_t
DEFINE_ARRAY( posttransform, FIELD_FLOAT, 12 ), // matrix3x4_t
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiobbox_t )
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( group, FIELD_INTEGER ),
DEFINE_FIELD( bbmin, FIELD_VECTOR ),
DEFINE_FIELD( bbmax, FIELD_VECTOR ),
DEFINE_INDEX( szhitboxnameindex, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioanim_valueptr_t )
DEFINE_ARRAY( offset, FIELD_SHORT, 3 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiolocalhierarchy_t )
DEFINE_FIELD( iBone, FIELD_INTEGER ),
DEFINE_FIELD( iNewParent, FIELD_INTEGER ),
DEFINE_FIELD( start, FIELD_FLOAT ),
DEFINE_FIELD( peak, FIELD_FLOAT ),
DEFINE_FIELD( tail, FIELD_FLOAT ),
DEFINE_FIELD( end, FIELD_FLOAT ),
DEFINE_FIELD( iStart, FIELD_INTEGER ),
DEFINE_INDEX( localanimindex, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 4 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioanimsections_t )
DEFINE_FIELD( animblock, FIELD_INTEGER ),
DEFINE_INDEX( animindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioanimdesc_t )
DEFINE_INDEX( baseptr, FIELD_INTEGER ),
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( fps, FIELD_FLOAT ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( numframes, FIELD_INTEGER ),
DEFINE_FIELD( nummovements, FIELD_INTEGER ),
DEFINE_INDEX( movementindex, FIELD_INTEGER ),
DEFINE_ARRAY( unused1, FIELD_INTEGER, 6 ),
DEFINE_FIELD( animblock, FIELD_INTEGER ),
DEFINE_INDEX( animindex, FIELD_INTEGER ),
DEFINE_FIELD( numikrules, FIELD_INTEGER ),
DEFINE_INDEX( ikruleindex, FIELD_INTEGER ),
DEFINE_INDEX( animblockikruleindex, FIELD_INTEGER ),
DEFINE_FIELD( numlocalhierarchy, FIELD_INTEGER ),
DEFINE_INDEX( localhierarchyindex, FIELD_INTEGER ),
DEFINE_INDEX( sectionindex, FIELD_INTEGER ),
DEFINE_FIELD( sectionframes, FIELD_INTEGER ),
DEFINE_FIELD( zeroframespan, FIELD_SHORT ),
DEFINE_FIELD( zeroframecount, FIELD_SHORT ),
DEFINE_INDEX( zeroframeindex, FIELD_INTEGER ),
DEFINE_FIELD( zeroframestalltime, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioanim_t )
DEFINE_FIELD( bone, FIELD_CHARACTER ),
DEFINE_FIELD( flags, FIELD_CHARACTER ),
DEFINE_INDEX( nextoffset, FIELD_SHORT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioikerror_t )
DEFINE_FIELD( pos, FIELD_VECTOR ),
DEFINE_FIELD( q, FIELD_QUATERNION ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiocompressedikerror_t )
DEFINE_ARRAY( scale, FIELD_FLOAT, 6 ),
DEFINE_ARRAY( offset, FIELD_SHORT, 6 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioikrule_t )
DEFINE_FIELD( index, FIELD_INTEGER ),
DEFINE_FIELD( type, FIELD_INTEGER ),
DEFINE_FIELD( chain, FIELD_INTEGER ),
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( slot, FIELD_INTEGER ),
DEFINE_FIELD( height, FIELD_FLOAT ),
DEFINE_FIELD( radius, FIELD_FLOAT ),
DEFINE_FIELD( floor, FIELD_FLOAT ),
DEFINE_FIELD( pos, FIELD_VECTOR ),
DEFINE_FIELD( q, FIELD_QUATERNION ),
DEFINE_INDEX( compressedikerrorindex, FIELD_INTEGER ),
DEFINE_FIELD( unused2, FIELD_INTEGER ),
DEFINE_FIELD( iStart, FIELD_INTEGER ),
DEFINE_INDEX( ikerrorindex, FIELD_INTEGER ),
DEFINE_FIELD( start, FIELD_FLOAT ),
DEFINE_FIELD( peak, FIELD_FLOAT ),
DEFINE_FIELD( tail, FIELD_FLOAT ),
DEFINE_FIELD( end, FIELD_FLOAT ),
DEFINE_FIELD( unused3, FIELD_FLOAT ),
DEFINE_FIELD( contact, FIELD_FLOAT ),
DEFINE_FIELD( drop, FIELD_FLOAT ),
DEFINE_FIELD( top, FIELD_FLOAT ),
DEFINE_FIELD( unused6, FIELD_INTEGER ),
DEFINE_FIELD( unused7, FIELD_INTEGER ),
DEFINE_FIELD( unused8, FIELD_INTEGER ),
DEFINE_INDEX( szattachmentindex, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 7 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiomovement_t )
DEFINE_FIELD( endframe, FIELD_INTEGER ),
DEFINE_FIELD( motionflags, FIELD_INTEGER ),
DEFINE_FIELD( v0, FIELD_FLOAT ),
DEFINE_FIELD( v1, FIELD_FLOAT ),
DEFINE_FIELD( angle, FIELD_FLOAT ),
DEFINE_FIELD( vector, FIELD_VECTOR ),
DEFINE_FIELD( position, FIELD_VECTOR ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioactivitymodifier_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioseqdesc_t )
DEFINE_INDEX( baseptr, FIELD_INTEGER ),
DEFINE_INDEX( szlabelindex, FIELD_INTEGER ),
DEFINE_INDEX( szactivitynameindex, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_INTEGER ), // looping/non-looping flags
DEFINE_FIELD( activity, FIELD_INTEGER ), // initialized at loadtime to game DLL values
DEFINE_FIELD( actweight, FIELD_INTEGER ),
DEFINE_FIELD( numevents, FIELD_INTEGER ),
DEFINE_INDEX( eventindex, FIELD_INTEGER ),
DEFINE_FIELD( bbmin, FIELD_VECTOR ),
DEFINE_FIELD( bbmax, FIELD_VECTOR ),
DEFINE_FIELD( numblends, FIELD_INTEGER ),
DEFINE_INDEX( animindexindex, FIELD_INTEGER ),
DEFINE_INDEX( movementindex, FIELD_INTEGER ), // [blend] float array for blended movement
DEFINE_ARRAY( groupsize, FIELD_INTEGER, 2 ),
DEFINE_ARRAY( paramindex, FIELD_INTEGER, 2 ), // X, Y, Z, XR, YR, ZR
DEFINE_ARRAY( paramstart, FIELD_FLOAT, 2 ), // local (0..1) starting value
DEFINE_ARRAY( paramend, FIELD_FLOAT, 2 ), // local (0..1) ending value
DEFINE_FIELD( paramparent, FIELD_INTEGER ),
DEFINE_FIELD( fadeintime, FIELD_FLOAT ), // ideal cross fate in time (0.2 default)
DEFINE_FIELD( fadeouttime, FIELD_FLOAT ), // ideal cross fade out time (0.2 default)
DEFINE_FIELD( localentrynode, FIELD_INTEGER ), // transition node at entry
DEFINE_FIELD( localexitnode, FIELD_INTEGER ), // transition node at exit
DEFINE_FIELD( nodeflags, FIELD_INTEGER ), // transition rules
DEFINE_FIELD( entryphase, FIELD_FLOAT ), // used to match entry gait
DEFINE_FIELD( exitphase, FIELD_FLOAT ), // used to match exit gait
DEFINE_FIELD( lastframe, FIELD_FLOAT ), // frame that should generation EndOfSequence
DEFINE_FIELD( nextseq, FIELD_INTEGER ), // auto advancing sequences
DEFINE_FIELD( pose, FIELD_INTEGER ), // index of delta animation between end and nextseq
DEFINE_FIELD( numikrules, FIELD_INTEGER ),
DEFINE_FIELD( numautolayers, FIELD_INTEGER ),
DEFINE_INDEX( autolayerindex, FIELD_INTEGER ),
DEFINE_INDEX( weightlistindex, FIELD_INTEGER ),
DEFINE_INDEX( posekeyindex, FIELD_INTEGER ),
DEFINE_FIELD( numiklocks, FIELD_INTEGER ),
DEFINE_INDEX( iklockindex, FIELD_INTEGER ),
DEFINE_INDEX( keyvalueindex, FIELD_INTEGER ),
DEFINE_FIELD( keyvaluesize, FIELD_INTEGER ),
DEFINE_INDEX( cycleposeindex, FIELD_INTEGER ),
DEFINE_INDEX( activitymodifierindex, FIELD_INTEGER ),
DEFINE_FIELD( numactivitymodifiers, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 5 ), // remove/add as appropriate (grow back to 8 ints on version change!)
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioevent_t )
DEFINE_FIELD( cycle, FIELD_FLOAT ),
DEFINE_FIELD( event, FIELD_INTEGER ),
DEFINE_FIELD( type, FIELD_INTEGER ),
DEFINE_ARRAY( options, FIELD_CHARACTER, 64 ),
DEFINE_INDEX( szeventindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioautolayer_t )
DEFINE_FIELD( iSequence, FIELD_SHORT ),
DEFINE_FIELD( iPose, FIELD_SHORT ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( start, FIELD_FLOAT ),
DEFINE_FIELD( peak, FIELD_FLOAT ),
DEFINE_FIELD( tail, FIELD_FLOAT ),
DEFINE_FIELD( end, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioiklock_t )
DEFINE_FIELD( chain, FIELD_INTEGER ),
DEFINE_FIELD( flPosWeight, FIELD_FLOAT ),
DEFINE_FIELD( flLocalQWeight, FIELD_FLOAT ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 4 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiobodyparts_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( nummodels, FIELD_INTEGER ),
DEFINE_FIELD( base, FIELD_INTEGER ),
DEFINE_INDEX( modelindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiomodel_t )
DEFINE_ARRAY( name, FIELD_CHARACTER, 64 ),
DEFINE_FIELD( type, FIELD_INTEGER ),
DEFINE_FIELD( boundingradius, FIELD_FLOAT ),
DEFINE_FIELD( nummeshes, FIELD_INTEGER ),
DEFINE_INDEX( meshindex, FIELD_INTEGER ),
DEFINE_FIELD( numvertices, FIELD_INTEGER ),
DEFINE_INDEX( vertexindex, FIELD_INTEGER ),
DEFINE_INDEX( tangentsindex, FIELD_INTEGER ),
DEFINE_FIELD( numattachments, FIELD_INTEGER ),
DEFINE_INDEX( attachmentindex, FIELD_INTEGER ),
DEFINE_FIELD( numeyeballs, FIELD_INTEGER ),
DEFINE_INDEX( eyeballindex, FIELD_INTEGER ),
DEFINE_EMBEDDED( vertexdata ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudio_modelvertexdata_t )
DEFINE_FIELD( pVertexData, FIELD_INTEGER ), // void*
DEFINE_FIELD( pTangentData, FIELD_INTEGER ), // void*
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflexdesc_t )
DEFINE_INDEX( szFACSindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflexcontroller_t )
DEFINE_INDEX( sztypeindex, FIELD_INTEGER ),
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( localToGlobal, FIELD_INTEGER ),
DEFINE_FIELD( min, FIELD_FLOAT ),
DEFINE_FIELD( max, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflexcontrollerui_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_INDEX( szindex0, FIELD_INTEGER ),
DEFINE_INDEX( szindex1, FIELD_INTEGER ),
DEFINE_INDEX( szindex2, FIELD_INTEGER ),
DEFINE_FIELD( remaptype, FIELD_CHARACTER ),
DEFINE_FIELD( stereo, FIELD_BOOLEAN ),
DEFINE_ARRAY( unused, FIELD_CHARACTER, 2 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflexrule_t )
DEFINE_FIELD( flex, FIELD_INTEGER ),
DEFINE_FIELD( numops, FIELD_INTEGER ),
DEFINE_INDEX( opindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflexop_t )
DEFINE_FIELD( op, FIELD_INTEGER ),
DEFINE_FIELD( d, FIELD_INTEGER ), // int/float union
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioikchain_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( linktype, FIELD_INTEGER ),
DEFINE_FIELD( numlinks, FIELD_INTEGER ),
DEFINE_INDEX( linkindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioiklink_t )
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( kneeDir, FIELD_VECTOR ),
DEFINE_FIELD( unused0, FIELD_VECTOR ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiomouth_t )
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( forward, FIELD_VECTOR ),
DEFINE_FIELD( flexdesc, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioposeparamdesc_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( start, FIELD_FLOAT ),
DEFINE_FIELD( end, FIELD_FLOAT ),
DEFINE_FIELD( loop, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiomesh_t )
DEFINE_FIELD( material, FIELD_INTEGER ),
DEFINE_INDEX( modelindex, FIELD_INTEGER ),
DEFINE_FIELD( numvertices, FIELD_INTEGER ),
DEFINE_FIELD( vertexoffset, FIELD_INTEGER ),
DEFINE_FIELD( numflexes, FIELD_INTEGER ),
DEFINE_INDEX( flexindex, FIELD_INTEGER ),
DEFINE_FIELD( materialtype, FIELD_INTEGER ),
DEFINE_FIELD( materialparam, FIELD_INTEGER ),
DEFINE_FIELD( meshid, FIELD_INTEGER ),
DEFINE_FIELD( center, FIELD_VECTOR ),
DEFINE_EMBEDDED( vertexdata ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 8 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudio_meshvertexdata_t )
DEFINE_FIELD( modelvertexdata, FIELD_INTEGER ), // mstudio_modelvertexdata_t*
DEFINE_ARRAY( numLODVertexes, FIELD_INTEGER, MAX_NUM_LODS ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioeyeball_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( bone, FIELD_INTEGER ),
DEFINE_FIELD( org, FIELD_VECTOR ),
DEFINE_FIELD( zoffset, FIELD_FLOAT ),
DEFINE_FIELD( radius, FIELD_FLOAT ),
DEFINE_FIELD( up, FIELD_VECTOR ),
DEFINE_FIELD( forward, FIELD_VECTOR ),
DEFINE_FIELD( texture, FIELD_INTEGER ),
DEFINE_FIELD( unused1, FIELD_INTEGER ),
DEFINE_FIELD( iris_scale, FIELD_FLOAT ),
DEFINE_FIELD( unused2, FIELD_INTEGER ),
DEFINE_ARRAY( upperflexdesc, FIELD_INTEGER, 3 ),
DEFINE_ARRAY( lowerflexdesc, FIELD_INTEGER, 3 ),
DEFINE_ARRAY( uppertarget, FIELD_FLOAT, 3 ),
DEFINE_ARRAY( lowertarget, FIELD_FLOAT, 3 ),
DEFINE_FIELD( upperlidflexdesc, FIELD_INTEGER ),
DEFINE_FIELD( lowerlidflexdesc, FIELD_INTEGER ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 4 ),
DEFINE_FIELD( m_bNonFACS, FIELD_BOOLEAN ),
DEFINE_ARRAY( unused3, FIELD_CHARACTER, 3 ),
DEFINE_ARRAY( unused4, FIELD_INTEGER, 7 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioflex_t )
DEFINE_FIELD( flexdesc, FIELD_INTEGER ),
DEFINE_FIELD( target0, FIELD_FLOAT ),
DEFINE_FIELD( target1, FIELD_FLOAT ),
DEFINE_FIELD( target2, FIELD_FLOAT ),
DEFINE_FIELD( target3, FIELD_FLOAT ),
DEFINE_FIELD( numverts, FIELD_INTEGER ),
DEFINE_INDEX( vertindex, FIELD_INTEGER ),
DEFINE_FIELD( flexpair, FIELD_INTEGER ),
DEFINE_FIELD( vertanimtype, FIELD_CHARACTER ),
DEFINE_ARRAY( unusedchar, FIELD_CHARACTER, 3 ),
DEFINE_ARRAY( unused, FIELD_INTEGER, 6 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiovertanim_t )
DEFINE_FIELD( index, FIELD_SHORT ),
DEFINE_FIELD( speed, FIELD_CHARACTER ),
DEFINE_FIELD( side, FIELD_CHARACTER ),
DEFINE_ARRAY( delta, FIELD_SHORT, 3 ), // short[3]/float16[3]union
DEFINE_ARRAY( ndelta, FIELD_SHORT, 3 ), // short[3]/float16[3] union
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiomodelgroup_t )
DEFINE_INDEX( szlabelindex, FIELD_INTEGER ),
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioanimblock_t )
DEFINE_INDEX( datastart, FIELD_INTEGER ),
DEFINE_INDEX( dataend, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiotexture_t )
DEFINE_INDEX( sznameindex, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_INTEGER ),
DEFINE_FIELD( used, FIELD_INTEGER ),
DEFINE_FIELD( unused1, FIELD_INTEGER ),
DEFINE_FIELD( material, FIELD_INTEGER ), // IMaterial*
DEFINE_FIELD( clientmaterial, FIELD_INTEGER ), // void*
DEFINE_ARRAY( unused, FIELD_INTEGER, 10 ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( vertexFileHeader_t )
DEFINE_FIELD( id, FIELD_INTEGER ),
DEFINE_FIELD( version, FIELD_INTEGER ),
DEFINE_FIELD( checksum, FIELD_INTEGER ),
DEFINE_FIELD( numLODs, FIELD_INTEGER ),
DEFINE_ARRAY( numLODVertexes, FIELD_INTEGER, MAX_NUM_LODS ),
DEFINE_FIELD( numFixups, FIELD_INTEGER ),
DEFINE_FIELD( fixupTableStart, FIELD_INTEGER ),
DEFINE_FIELD( vertexDataStart, FIELD_INTEGER ),
DEFINE_FIELD( tangentDataStart, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( vertexFileFixup_t )
DEFINE_FIELD( lod, FIELD_INTEGER ),
DEFINE_FIELD( sourceVertexID, FIELD_INTEGER ),
DEFINE_FIELD( numVertexes, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudioboneweight_t )
DEFINE_ARRAY( weight, FIELD_FLOAT, MAX_NUM_BONES_PER_VERT ),
DEFINE_ARRAY( bone, FIELD_CHARACTER, MAX_NUM_BONES_PER_VERT ),
DEFINE_FIELD( numbones, FIELD_CHARACTER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( mstudiovertex_t )
DEFINE_EMBEDDED( m_BoneWeights ),
DEFINE_FIELD( m_vecPosition, FIELD_VECTOR ),
DEFINE_FIELD( m_vecNormal, FIELD_VECTOR ),
DEFINE_ARRAY( m_vecTexCoord, FIELD_FLOAT, 2 ),
END_BYTESWAP_DATADESC()
// Data descriptions from OptimizedModel.h
namespace OptimizedModel
{
BEGIN_BYTESWAP_DATADESC( BoneStateChangeHeader_t )
DEFINE_FIELD( hardwareID, FIELD_INTEGER ),
DEFINE_FIELD( newBoneID, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( Vertex_t )
DEFINE_ARRAY( boneWeightIndex, FIELD_CHARACTER, MAX_NUM_BONES_PER_VERT ),
DEFINE_FIELD( numBones, FIELD_CHARACTER ),
DEFINE_FIELD( origMeshVertID, FIELD_SHORT ),
DEFINE_ARRAY( boneID, FIELD_CHARACTER, MAX_NUM_BONES_PER_VERT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( StripHeader_t )
DEFINE_FIELD( numIndices, FIELD_INTEGER ),
DEFINE_FIELD( indexOffset, FIELD_INTEGER ),
DEFINE_FIELD( numVerts, FIELD_INTEGER ),
DEFINE_FIELD( vertOffset, FIELD_INTEGER ),
DEFINE_FIELD( numBones, FIELD_SHORT ),
DEFINE_FIELD( flags, FIELD_CHARACTER ),
DEFINE_FIELD( numBoneStateChanges, FIELD_INTEGER ),
DEFINE_FIELD( boneStateChangeOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( StripGroupHeader_t )
DEFINE_FIELD( numVerts, FIELD_INTEGER ),
DEFINE_FIELD( vertOffset, FIELD_INTEGER ),
DEFINE_FIELD( numIndices, FIELD_INTEGER ),
DEFINE_FIELD( indexOffset, FIELD_INTEGER ),
DEFINE_FIELD( numStrips, FIELD_INTEGER ),
DEFINE_FIELD( stripOffset, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_CHARACTER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( MeshHeader_t )
DEFINE_FIELD( numStripGroups, FIELD_INTEGER ),
DEFINE_FIELD( stripGroupHeaderOffset, FIELD_INTEGER ),
DEFINE_FIELD( flags, FIELD_CHARACTER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( ModelLODHeader_t )
DEFINE_FIELD( numMeshes, FIELD_INTEGER ),
DEFINE_FIELD( meshOffset, FIELD_INTEGER ),
DEFINE_FIELD( switchPoint, FIELD_FLOAT ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( ModelHeader_t )
DEFINE_FIELD( numLODs, FIELD_INTEGER ),
DEFINE_FIELD( lodOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( BodyPartHeader_t )
DEFINE_FIELD( numModels, FIELD_INTEGER ),
DEFINE_FIELD( modelOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( MaterialReplacementHeader_t )
DEFINE_FIELD( materialID, FIELD_SHORT ),
DEFINE_FIELD( replacementMaterialNameOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( MaterialReplacementListHeader_t )
DEFINE_FIELD( numReplacements, FIELD_INTEGER ),
DEFINE_FIELD( replacementOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
BEGIN_BYTESWAP_DATADESC( FileHeader_t )
DEFINE_FIELD( version, FIELD_INTEGER ),
DEFINE_FIELD( vertCacheSize, FIELD_INTEGER ),
DEFINE_FIELD( maxBonesPerStrip, FIELD_SHORT ),
DEFINE_FIELD( maxBonesPerTri, FIELD_SHORT ),
DEFINE_FIELD( maxBonesPerVert, FIELD_INTEGER ),
DEFINE_FIELD( checkSum, FIELD_INTEGER ),
DEFINE_FIELD( numLODs, FIELD_INTEGER ),
DEFINE_FIELD( materialReplacementListOffset, FIELD_INTEGER ),
DEFINE_FIELD( numBodyParts, FIELD_INTEGER ),
DEFINE_FIELD( bodyPartOffset, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()
} // namespace OptimizedModel
// Data descriptions from phyfile.h
BEGIN_BYTESWAP_DATADESC( phyheader_t )
DEFINE_FIELD( size, FIELD_INTEGER ),
DEFINE_FIELD( id, FIELD_INTEGER ),
DEFINE_FIELD( solidCount, FIELD_INTEGER ),
DEFINE_FIELD( checkSum, FIELD_INTEGER ),
END_BYTESWAP_DATADESC()