d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
159 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 2690e6c85a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2690e6c85a'
${ noResults }
source-engine/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()