Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/datacache/mdlcombine.cpp

2894 lines
106 KiB
C++
Raw Normal View History

uid issue
2021-07-25 12:11:47 +08:00
#include "datacache/imdlcache.h"
#include "optimize.h"
#include "mdlcombine.h"
#include "filesystem.h"
#include "studio.h"
#include "mathlib/mathlib.h"
#include <math.h>
#include "tier1/characterset.h"
#include "keyvalues.h"
#include "vtfcombine.h"
// beware: this does not do any type of byte swapping for handling of endian issues!
CCombinerMemoryWriter g_CombinerWriter;
CModelCombine g_ModelCombiner;
static CModelCombine *s_pCurrentCombine = &g_ModelCombiner;
static characterset_t s_BreakSet;
unsigned int CModelCombine::m_nNextAssetID = 0;
#ifdef DEBUG_COMBINE
#define DebugCombineMsg( ... ) Msg( __VA_ARGS__ )
//#define TEST_MDL_COMBINE 1
//#define TEST_VTX_COMBINE 1
#else
#define DebugCombineMsg( ... )
#endif
CCombinerMemoryWriter::CCombinerMemoryWriter( )
{
m_pWorkBuffer = NULL;
}
CCombinerMemoryWriter::~CCombinerMemoryWriter( )
{
free( m_pWorkBuffer );
}
void CCombinerMemoryWriter::Init( )
{
if ( m_pWorkBuffer == NULL )
{
CharacterSetBuild( &s_BreakSet, "{}()':" );
m_pWorkBuffer = ( char * )malloc( COMBINER_WORK_BUFFER_SIZE );
m_pEndBuffer = m_pWorkBuffer + COMBINER_WORK_BUFFER_SIZE - 1;
}
memset( m_pWorkBuffer, 0, COMBINER_WORK_BUFFER_SIZE );
m_pWriteArea = m_pWritePos = NULL;
#ifdef DEBUG_COMBINE
m_pErrorPos = NULL;
#endif // DEBUG_COMBINE
m_nWriteArea = -1;
InitWriteArea( WRITE_AREA_VVD, m_pWorkBuffer );
SetWriteArea( WRITE_AREA_VVD );
}
void CCombinerMemoryWriter::InitWriteArea( int nArea, char *pPosition )
{
pPosition = ( char * )( ( intp )( pPosition + 15 ) & ( ~15 ) );
m_pSaveWriteArea[ nArea ] = m_pSaveWritePos[ nArea ] = pPosition;
}
void CCombinerMemoryWriter::SetWriteArea( int nArea )
{
if ( m_nWriteArea != -1 )
{
m_pSaveWriteArea[ m_nWriteArea ] = m_pWriteArea;
m_pSaveWritePos[ m_nWriteArea ] = m_pWritePos;
}
m_nWriteArea = nArea;
if ( m_nWriteArea != -1 )
{
m_pWriteArea = m_pSaveWriteArea[ m_nWriteArea ];
m_pWritePos = m_pSaveWritePos[ m_nWriteArea ];
}
}
char *CCombinerMemoryWriter::AllocWrite( int nSize )
{
char *pOrigPos = m_pWritePos;
#ifdef DEBUG_COMBINE
if ( m_pErrorPos >= m_pWritePos && m_pErrorPos < m_pWritePos + nSize )
{
Msg( "AllocFailure: %d offset %d\n", m_pErrorPos - m_pWriteArea, m_pErrorPos - m_pWritePos );
Assert( 0 );
}
#endif // DEBUG_COMBINE
m_pWritePos += nSize;
if ( m_pWritePos > m_pEndBuffer )
{
AssertMsg( false, "Internal model combiner buffer not large enough" );
V_sprintf_safe( g_ModelCombiner.GetResults()->m_szErrorMessage, "Internal model combiner buffer not large enough" );
throw( COMBINE_RESULT_FLAG_OUT_OF_MEMORY );
}
return pOrigPos;
}
char *CCombinerMemoryWriter::WriteOffset( int &nOffsetIndex )
{
nOffsetIndex = ( m_pWritePos - m_pWriteArea );
return m_pWritePos;
}
char *CCombinerMemoryWriter::WriteOffset( int &nOffsetIndex, void *pBasePtr )
{
nOffsetIndex = ( ( byte * )m_pWritePos - ( byte * )pBasePtr );
return m_pWritePos;
}
char *CCombinerMemoryWriter::WriteOffset( short &nOffsetIndex, void *pBasePtr )
{
nOffsetIndex = ( ( byte * )m_pWritePos - ( byte * )pBasePtr );
return m_pWritePos;
}
char *CCombinerMemoryWriter::WriteBuffer( const void *pData, int nSize )
{
char *pOrigPos = AllocWrite( nSize );
memcpy( pOrigPos, pData, nSize );
return pOrigPos;
}
char *CCombinerMemoryWriter::WriteBufferWithOffset( const void *pData, int nSize, int &nOffsetIndex )
{
WriteOffset( nOffsetIndex );
return WriteBuffer( pData, nSize );
}
char *CCombinerMemoryWriter::WriteString( const char *pszString )
{
return WriteBuffer( pszString, strlen( pszString ) + 1 );
}
char *CCombinerMemoryWriter::WriteText( const char *pszString )
{
return WriteBuffer( pszString, strlen( pszString ) );
}
void CCombinerMemoryWriter::AlignWrite( int nAlignSize )
{
#ifdef DEBUG_COMBINE
char *pPriorPos = m_pWritePos;
#endif // DEBUG_COMBINE
nAlignSize--;
m_pWritePos = ( char * )( ( intp )( m_pWritePos + nAlignSize ) & ( ~nAlignSize ) );
#ifdef DEBUG_COMBINE
if ( m_pErrorPos >= pPriorPos && m_pErrorPos < m_pWritePos )
{
DebugCombineMsg( "AlignFailure: %d offset %d\n", m_pErrorPos - m_pWriteArea, m_pErrorPos - m_pWritePos );
Assert( 0 );
}
#endif // DEBUG_COMBINE
if ( m_pWritePos > m_pEndBuffer )
{
Assert( 0 );
V_sprintf_safe( g_ModelCombiner.GetResults()->m_szErrorMessage, "Internal model combiner buffer not large enough" );
throw( COMBINE_RESULT_FLAG_OUT_OF_MEMORY );
}
}
CModelCombine::CModelCombine( )
{
}
CModelCombine::~CModelCombine( )
{
}
void CModelCombine::Init( TCombinedStudioData *pCombinedStudioData )
{
m_pCombinedStudioData = pCombinedStudioData;
memset( &m_pCombinedStudioData->m_Results, 0, sizeof( m_pCombinedStudioData->m_Results ) );
for ( int nGroup = 0; nGroup < COMBINER_MAX_ATLAS_GROUPS; nGroup++ )
{
memset( &m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_pCombinedTextures, 0, sizeof( m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_pCombinedTextures ) );
memset( &m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_nCombinedTextureSizes, 0, sizeof( m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_nCombinedTextureSizes ) );
m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_pCombinedMaterial = NULL;
memset( &m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_szCombinedMaterialName, 0, sizeof( m_pCombinedStudioData->m_AtlasGroups[ nGroup ].m_szCombinedMaterialName ) );
}
// we need to make sure we don't have any periods, as other routines may strip off those as an extension
for( char *pszTestChar = m_pCombinedStudioData->m_szCombinedModelName; *pszTestChar; pszTestChar++ )
{
if ( *pszTestChar == '.' )
{
*pszTestChar = '_';
}
}
g_CombinerWriter.Init();
}
void CModelCombine::BeginStringTable( )
{
strings[ 0 ].base = NULL;
strings[ 0 ].ptr = NULL;
strings[ 0 ].string = "";
strings[ 0 ].dupindex = -1;
numStrings = 1;
}
//-----------------------------------------------------------------------------
// Purpose: add a string to the file-global string table.
// Keep track of fixup locations
//-----------------------------------------------------------------------------
void CModelCombine::AddToStringTable( void *base, int *ptr, const char *string )
{
if ( numStrings >= COMBINER_MAX_STRINGS )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Too many strings for string table of size %d", COMBINER_MAX_STRINGS );
throw( COMBINE_RESULT_FLAG_TOO_MANY_STRINGS );
}
for ( int i = 0; i < numStrings; i++ )
{
if ( !string || !strcmp( string, strings[ i ].string ) )
{
strings[ numStrings ].base = ( byte * )base;
strings[ numStrings ].ptr = ptr;
strings[ numStrings ].string = string;
strings[ numStrings ].dupindex = i;
numStrings++;
return;
}
}
strings[ numStrings ].base = ( byte * )base;
strings[ numStrings ].ptr = ptr;
strings[ numStrings ].string = string;
strings[ numStrings ].dupindex = -1;
numStrings++;
}
//-----------------------------------------------------------------------------
// Purpose: Write out stringtable
// fixup local pointers
//-----------------------------------------------------------------------------
void CModelCombine::WriteStringTable( )
{
// force null at first address
strings[ 0 ].addr = ( byte * )g_CombinerWriter.GetWritePos();
g_CombinerWriter.WriteBuffer( "", 1 ); // null string
// save all the rest
for ( int i = 1; i < numStrings; i++ )
{
if ( strings[ i ].dupindex == -2 )
{
// initial filler to match string tables up
strings[ i ].addr = ( byte * )g_CombinerWriter.GetWritePos();
g_CombinerWriter.WriteBuffer( strings[ i ].string, strlen( strings[ i ].string ) + 1 );
}
else if ( strings[ i ].dupindex == -1 )
{
// not in table yet
// calc offset relative to local base
*strings[ i ].ptr = ( byte * )g_CombinerWriter.GetWritePos() - strings[ i ].base;
// keep track of address in case of duplication
strings[ i ].addr = ( byte * )g_CombinerWriter.GetWritePos();
// copy string data, add a terminating \0
g_CombinerWriter.WriteBuffer( strings[ i ].string, strlen( strings[ i ].string ) + 1 );
}
else
{
// already in table, calc offset of existing string relative to local base
*strings[ i ].ptr = strings[ strings[ i ].dupindex ].addr - strings[ i ].base;
}
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::VerifyField( int nField, const char *pszDescription )
{
#ifdef DEBUG_COMBINE
int *pOriginal = ( int * )( ( ( byte * )m_pStudioHdr[ 0 ] ) + nField );
int *pCombined = ( int * )( ( ( byte * )m_pCombinedStudioHdr ) + nField );
DebugCombineMsg( "Verify Field %s: %d / %d\n", pszDescription, *pOriginal, *pCombined );
#endif // DEBUG_COMBINE
}
void CModelCombine::VerifyField2( int nField, const char *pszDescription )
{
#ifdef DEBUG_COMBINE
int *pOriginal = ( int * )( ( ( byte * )m_pStudioHdr2[ 0 ] ) + nField );
int *pCombined = ( int * )( ( ( byte * )m_pCombinedStudioHdr2 ) + nField );
DebugCombineMsg( "Verify Field2 %s: %d / %d\n", pszDescription, *pOriginal, *pCombined );
#endif // DEBUG_COMBINE
}
void CModelCombine::VerifyOffset( void *pPtr, const char *pszDescription, void *pWritePos )
{
#ifdef DEBUG_COMBINE
int pV1 = ( ( char * )pPtr ) - ( ( char * ) m_pStudioHdr[ 0 ] );
if ( pWritePos == 0 )
{
pWritePos = m_pWritePos;
}
int pV2 = ( char * )pWritePos - m_pWriteArea;
DebugCombineMsg( "Verify Offset %s: %d / %d ( %d )\n", pszDescription, pV1, pV2, pV2 - pV1 );
#endif // DEBUG_COMBINE
}
bool CModelCombine::Resolve( )
{
char szFileName[ MAX_PATH ];
m_pCombinedStudioData->m_Results.m_nCombinedResults = COMBINE_RESULT_FLAG_OK;
m_pCombinedStudioData->m_Results.m_szErrorMessage[ 0 ] = 0;
m_pCombinedStudioData->m_Results.m_szErrorDetails[ 0 ] = 0;
m_pCombinedStudioData->m_Results.m_nDetailedError = COMBINED_DETAIL_ERROR_NOT_SPECIFIED;
memset( MDL_Data, 0, sizeof( MDL_Data ) );
memset( VTX_Data, 0, sizeof( VTX_Data ) );
memset( VVD_Data, 0, sizeof( VVD_Data ) );
try
{
if ( STRING(m_pCombinedStudioData->m_ModelInputData[ 0 ].m_iszModelName)[ 0 ] == 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "No primary model specified" );
throw( COMBINE_RESULT_FLAG_MISSING_ASSET_FILE );
}
double flStartLoadTime = Plat_FloatTime();
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
bool bResult;
MDL_Data[ nModel ] = new CUtlBuffer();
V_strcpy_safe( szFileName, STRING(m_pCombinedStudioData->m_ModelInputData[ nModel ].m_iszModelName) );
Q_SetExtension( szFileName, ".mdl", sizeof( szFileName ) );
bResult = g_pFullFileSystem->ReadFile( szFileName, "GAME", *MDL_Data[ nModel ], 0 );
if ( !bResult )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Missing asset file: %s", szFileName );
throw( COMBINE_RESULT_FLAG_MISSING_ASSET_FILE );
}
m_pStudioHdr[ nModel ] = ( studiohdr_t * )MDL_Data[ nModel ]->PeekGet();
m_pStudioHdr2[ nModel ] = ( studiohdr2_t * )MDL_Data[ nModel ]->PeekGet( m_pStudioHdr[ nModel ]->studiohdr2index );
VTX_Data[ nModel ] = new CUtlBuffer();
V_strcpy_safe( szFileName, STRING(m_pCombinedStudioData->m_ModelInputData[ nModel ].m_iszModelName) );
Q_SetExtension( szFileName, ".dx90.vtx", sizeof( szFileName ) ); // GetVTXExtension() private :(
bResult = g_pFullFileSystem->ReadFile( szFileName, "GAME", *VTX_Data[ nModel ], 0 );
if ( !bResult )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Missing asset file: %s", szFileName );
throw( COMBINE_RESULT_FLAG_MISSING_ASSET_FILE );
}
VVD_Data[ nModel ] = new CUtlBuffer();
V_strcpy_safe( szFileName, STRING(m_pCombinedStudioData->m_ModelInputData[ nModel ].m_iszModelName) );
Q_SetExtension( szFileName, ".vvd", sizeof( szFileName ) );
bResult = g_pFullFileSystem->ReadFile( szFileName, "GAME", *VVD_Data[ nModel ], 0 );
if ( !bResult )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Missing asset file: %s", szFileName );
throw( COMBINE_RESULT_FLAG_MISSING_ASSET_FILE );
}
m_pVertexFileHeader[ nModel ] = ( vertexFileHeader_t * )VVD_Data[ nModel ]->PeekGet();
}
m_pCombinedStudioData->m_Results.m_flModelLoadDuration += ( float )( Plat_FloatTime() - flStartLoadTime );
CombineTextures();
double flStartCombineTime = Plat_FloatTime();
DetermineMasterBoneList();
CombineVVD();
CombineVTX();
#ifdef TEST_MDL_COMBINE
CombineMDL( true );
TestCombineMDL();
#else
CombineMDL( false );
#endif
g_CombinerWriter.SetWriteArea( -1 );
m_pCombinedStudioData->m_Results.m_flModelCombineDuration += ( float )( Plat_FloatTime() - flStartCombineTime );
m_pCombinedStudioData->m_Results.m_nCombinedResults = COMBINE_RESULT_FLAG_OK;
}
catch( ECombinedResult nFlags )
{
m_pCombinedStudioData->m_Results.m_nCombinedResults = nFlags;
}
GetTextureCombiner().Cleanup();
for( int i = 0; i < m_pCombinedStudioData->m_nNumModels; i++ )
{
delete MDL_Data[ i ];
delete VTX_Data[ i ];
delete VVD_Data[ i ];
}
return ( m_pCombinedStudioData->m_Results.m_nCombinedResults == COMBINE_RESULT_FLAG_OK );
}
void CModelCombine::DetermineMasterBoneList( )
{
studiohdr_t *pPrimaryStudioHdr = m_pStudioHdr[ 0 ];
if ( pPrimaryStudioHdr->numbones > COMBINER_MAX_BONES )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Too many bones in primary model: %d > %d", pPrimaryStudioHdr->numbones, COMBINER_MAX_BONES );
throw( COMBINE_RESULT_FLAG_TOO_MANY_BONES );
}
memset( m_nMasterToLocalBoneRemap, -1, sizeof( m_nMasterToLocalBoneRemap ) );
m_nNumMasterBones = 0;
for( int nBone = 0; nBone < pPrimaryStudioHdr->numbones; nBone++ )
{
const mstudiobone_t *pOrigBone = pPrimaryStudioHdr->pBone( nBone );
m_pMasterBoneList[ m_nNumMasterBones ] = pOrigBone;
m_nBoneModelOwner[ m_nNumMasterBones ] = 0;
m_nBoneRemap[ 0 ][ nBone ] = m_nNumMasterBones;
m_nMasterToLocalBoneRemap[ 0 ][ m_nNumMasterBones ] = nBone;
m_nNumMasterBones++;
}
for( int nModel = 1; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
studiohdr_t *pSecondaryStudioHdr = m_pStudioHdr[ nModel ];
for( int nBone = 0; nBone < pSecondaryStudioHdr->numbones; nBone++ )
{
const mstudiobone_t *pOrigBone = pSecondaryStudioHdr->pBone( nBone );
char *pszName = pOrigBone->pszName();
bool bFound = false;
for ( int nBoneSearch = 0 ; nBoneSearch < m_nNumMasterBones; nBoneSearch++ )
{
if ( strcmpi( m_pMasterBoneList[ nBoneSearch ]->pszName(), pszName ) == 0 )
{
m_nBoneRemap[ nModel ][ nBone ] = nBoneSearch;
m_nMasterToLocalBoneRemap[ nModel ][ nBoneSearch ] = nBone;
bFound = true;
break;
}
}
if ( bFound == false )
{
if ( m_nNumMasterBones >= COMBINER_MAX_BONES )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Too many bones from secondary model %s", pSecondaryStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_TOO_MANY_BONES );
}
m_pMasterBoneList[ m_nNumMasterBones ] = pOrigBone;
m_nBoneModelOwner[ m_nNumMasterBones ] = nModel;
m_nBoneRemap[ nModel ][ nBone ] = m_nNumMasterBones;
m_nMasterToLocalBoneRemap[ nModel ][ m_nNumMasterBones ] = nBone;
m_nNumMasterBones++;
}
}
}
}
void CModelCombine::CombineMDL_PreintStrings( )
{
char *pStringData = m_pStudioHdr2[ 0 ]->pszName(); // this is the first entry in the string table;
char *pEndData = ( ( char * ) m_pStudioHdr[ 0 ] ) + m_pStudioHdr[ 0 ]->length;
while( pStringData < pEndData )
{
if ( numStrings >= COMBINER_MAX_STRINGS )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "Too many initial strings %d > %d", numStrings, COMBINER_MAX_STRINGS );
throw( COMBINE_RESULT_FLAG_TOO_MANY_STRINGS );
}
strings[ numStrings ].base = NULL;
strings[ numStrings ].ptr = NULL;
strings[ numStrings ].string = pStringData;
strings[ numStrings ].dupindex = -2;
numStrings++;
pStringData += strlen( pStringData ) + 1;
}
}
void CModelCombine::WriteBoneProc( int nSize, int nType1, int nType2 )
{
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
const mstudiobone_t *pOrigBone = m_pMasterBoneList[ nBone ];
mstudiobone_t *pNewBone = (mstudiobone_t *)m_pCombinedStudioHdr->pBone( nBone );
if ( pNewBone->proctype == nType1 || pNewBone->proctype == nType2 )
{
char *pPos = g_CombinerWriter.WriteBuffer( pOrigBone->pProcedure(), nSize );
pNewBone->procindex = (byte *)pPos - (byte *)pNewBone;
}
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::WriteBoneQuatInterp( )
{
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
const mstudiobone_t *pOrigBone = m_pMasterBoneList[ nBone ];
mstudiobone_t *pNewBone = (mstudiobone_t *)m_pCombinedStudioHdr->pBone( nBone );
if ( pNewBone->proctype == STUDIO_PROC_QUATINTERP )
{
mstudioquatinterpbone_t *pOrigProc = ( mstudioquatinterpbone_t * )pOrigBone->pProcedure();
mstudioquatinterpbone_t *pNewProc = ( mstudioquatinterpbone_t * )pNewBone->pProcedure();
char *pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTrigger( 0 ), pOrigProc->numtriggers * sizeof( mstudioquatinterpinfo_t ) );
pNewProc->triggerindex = (byte *)pPos - (byte *)pNewProc;
}
}
// AlignWrite( 4 );
}
void CModelCombine::WriteBoneTwist( )
{
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
const mstudiobone_t *pOrigBone = m_pMasterBoneList[ nBone ];
mstudiobone_t *pNewBone = (mstudiobone_t *)m_pCombinedStudioHdr->pBone( nBone );
if ( pNewBone->proctype == STUDIO_PROC_TWIST_MASTER || pNewBone->proctype == STUDIO_PROC_TWIST_SLAVE )
{
mstudiotwistbone_t *pOrigProc = ( mstudiotwistbone_t * )pOrigBone->pProcedure();
mstudiotwistbone_t *pNewProc = ( mstudiotwistbone_t * )pNewBone->pProcedure();
char *pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTarget( 0 ), pOrigProc->m_nTargetCount * sizeof( mstudiotwistbonetarget_t ) );
pNewProc->m_nTargetIndex = (byte *)pPos - (byte *)pNewProc;
g_CombinerWriter.AlignWrite( 4 );
}
}
// AlignWrite( 4 );
}
void CModelCombine::WriteBoneConstraints( )
{
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
const mstudiobone_t *pOrigBone = m_pMasterBoneList[ nBone ];
mstudiobone_t *pNewBone = (mstudiobone_t *)m_pCombinedStudioHdr->pBone( nBone );
// make this not repeat the same code
switch( pNewBone->proctype )
{
case STUDIO_PROC_POINT_CONSTRAINT:
{
char *pPos = g_CombinerWriter.WriteBuffer( pOrigBone->pProcedure(), sizeof( mstudiopointconstraint_t ) );
pNewBone->procindex = (byte *)pPos - (byte *)pNewBone;
g_CombinerWriter.AlignWrite( 4 );
mstudiopointconstraint_t *pOrigProc = ( mstudiopointconstraint_t * )pOrigBone->pProcedure();
mstudiopointconstraint_t *pNewProc = ( mstudiopointconstraint_t * )pNewBone->pProcedure();
pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTarget( 0 ), pOrigProc->m_nTargetCount * sizeof( mstudioconstrainttarget_t ) );
pNewProc->m_nTargetIndex = (byte *)pPos - (byte *)pNewProc;
g_CombinerWriter.AlignWrite( 4 );
}
break;
case STUDIO_PROC_ORIENT_CONSTRAINT:
{
char *pPos = g_CombinerWriter.WriteBuffer( pOrigBone->pProcedure(), sizeof( mstudioorientconstraint_t ) );
pNewBone->procindex = (byte *)pPos - (byte *)pNewBone;
g_CombinerWriter.AlignWrite( 4 );
mstudioorientconstraint_t *pOrigProc = ( mstudioorientconstraint_t * )pOrigBone->pProcedure();
mstudioorientconstraint_t *pNewProc = ( mstudioorientconstraint_t * )pNewBone->pProcedure();
pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTarget( 0 ), pOrigProc->m_nTargetCount * sizeof( mstudioconstrainttarget_t ) );
pNewProc->m_nTargetIndex = (byte *)pPos - (byte *)pNewProc;
g_CombinerWriter.AlignWrite( 4 );
}
break;
case STUDIO_PROC_AIM_CONSTRAINT:
{
char *pPos = g_CombinerWriter.WriteBuffer( pOrigBone->pProcedure(), sizeof( mstudioaimconstraint_t ) );
pNewBone->procindex = (byte *)pPos - (byte *)pNewBone;
g_CombinerWriter.AlignWrite( 4 );
mstudioaimconstraint_t *pOrigProc = ( mstudioaimconstraint_t * )pOrigBone->pProcedure();
mstudioaimconstraint_t *pNewProc = ( mstudioaimconstraint_t * )pNewBone->pProcedure();
pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTarget( 0 ), pOrigProc->m_nTargetCount * sizeof( mstudioconstrainttarget_t ) );
pNewProc->m_nTargetIndex = (byte *)pPos - (byte *)pNewProc;
g_CombinerWriter.AlignWrite( 4 );
}
break;
case STUDIO_PROC_PARENT_CONSTRAINT:
{
char *pPos = g_CombinerWriter.WriteBuffer( pOrigBone->pProcedure(), sizeof( mstudioparentconstraint_t ) );
pNewBone->procindex = (byte *)pPos - (byte *)pNewBone;
g_CombinerWriter.AlignWrite( 4 );
mstudioparentconstraint_t *pOrigProc = ( mstudioparentconstraint_t * )pOrigBone->pProcedure();
mstudioparentconstraint_t *pNewProc = ( mstudioparentconstraint_t * )pNewBone->pProcedure();
pPos = g_CombinerWriter.WriteBuffer( pOrigProc->pTarget( 0 ), pOrigProc->m_nTargetCount * sizeof( mstudioconstrainttarget_t ) );
pNewProc->m_nTargetIndex = (byte *)pPos - (byte *)pNewProc;
g_CombinerWriter.AlignWrite( 4 );
}
break;
}
}
}
void CModelCombine::WriteBoneAttachments( )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->localattachmentindex );
m_pCombinedStudioHdr->numlocalattachments = 0;
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ nModel ];
int nNumAttachments = pStudioHdr->numlocalattachments;
for( int nAttachment = 0; nAttachment < nNumAttachments; nAttachment++ )
{
m_pCombinedStudioHdr->numlocalattachments++;
mstudioattachment_t *pOrigAttachment = pStudioHdr->pLocalAttachment( nAttachment );
mstudioattachment_t *pNewAttachment = m_pCombinedStudioHdr->pLocalAttachment( m_pCombinedStudioHdr->numlocalattachments - 1 );
g_CombinerWriter.WriteBuffer( pOrigAttachment, sizeof( *pOrigAttachment ) );
AddToStringTable( pNewAttachment, &pNewAttachment->sznameindex, pOrigAttachment->pszName() );
RemapBone( nModel, pNewAttachment->localbone );
}
}
g_CombinerWriter.AlignWrite( 4 );
VerifyField( offsetof( studiohdr_t, localattachmentindex ), "BoneAttachments" );
}
void CModelCombine::WriteHitBoxes( )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->hitboxsetindex );
m_pCombinedStudioHdr->numhitboxsets = 0;
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
if ( nModel > 0 )
{ // for now, we are only interested in the hitbox sets of the primary model
break;
}
studiohdr_t *pStudioHdr = m_pStudioHdr[ nModel ];
int nNumHitBoxSets = pStudioHdr->numhitboxsets;
for( int nHitBoxSet = 0; nHitBoxSet < nNumHitBoxSets; nHitBoxSet++ )
{
m_pCombinedStudioHdr->numhitboxsets++;
mstudiohitboxset_t *pOrigHitBoxSet = pStudioHdr->pHitboxSet( nHitBoxSet );
mstudiohitboxset_t *pNewHitBoxSet = m_pCombinedStudioHdr->pHitboxSet( m_pCombinedStudioHdr->numhitboxsets - 1 );
g_CombinerWriter.WriteBuffer( pOrigHitBoxSet, sizeof( *pOrigHitBoxSet ) );
AddToStringTable( pNewHitBoxSet, &pNewHitBoxSet->sznameindex, pOrigHitBoxSet->pszName() );
}
}
g_CombinerWriter.AlignWrite( 4 );
for( int nHitBoxSet = 0; nHitBoxSet < m_pCombinedStudioHdr->numhitboxsets; nHitBoxSet++ )
{
mstudiohitboxset_t *pNewHitBoxSet = m_pCombinedStudioHdr->pHitboxSet( nHitBoxSet );
pNewHitBoxSet->numhitboxes = 0;
g_CombinerWriter.WriteOffset( pNewHitBoxSet->hitboxindex, pNewHitBoxSet );
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ nModel ];
if ( nModel > 0 )
{
break;
}
if ( nHitBoxSet < pStudioHdr->numhitboxsets )
{
mstudiohitboxset_t *pOrigHitBoxSet = pStudioHdr->pHitboxSet( nHitBoxSet );
for( int nHitBox = 0; nHitBox < pOrigHitBoxSet->numhitboxes; nHitBox++ )
{
pNewHitBoxSet->numhitboxes++;
mstudiobbox_t *pOrigHitBox = pOrigHitBoxSet->pHitbox( nHitBox );
mstudiobbox_t *pNewHitBox = pNewHitBoxSet->pHitbox( pNewHitBoxSet->numhitboxes - 1 );
g_CombinerWriter.WriteBuffer( pOrigHitBox, sizeof( *pOrigHitBox ) );
AddToStringTable( pNewHitBox, &pNewHitBox->szhitboxnameindex, pOrigHitBox->pszHitboxName() );
RemapBone( nModel, pNewHitBox->bone );
}
}
}
g_CombinerWriter.AlignWrite( 4 );
}
VerifyField( offsetof( studiohdr_t, hitboxsetindex ), "HitBoxes" );
}
// compare function for qsort below
int CModelCombine::BoneNameCompare( const void *elem1, const void *elem2 )
{
int index1 = *(byte *)elem1;
int index2 = *(byte *)elem2;
// compare bones by name
return strcmpi( s_pCurrentCombine->m_pMasterBoneList[ index1 ]->pszName(), s_pCurrentCombine->m_pMasterBoneList[ index2 ]->pszName() );
}
void CModelCombine::WriteBoneTable( )
{
byte *pBoneTable = ( byte * )g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->bonetablebynameindex );
g_CombinerWriter.AllocWrite( sizeof( *pBoneTable ) * m_pCombinedStudioHdr->numbones );
for ( int i = 0; i < m_pCombinedStudioHdr->numbones; i++ )
{
pBoneTable[ i ] = i;
}
qsort( pBoneTable, m_pCombinedStudioHdr->numbones, sizeof( byte ), BoneNameCompare );
}
void CModelCombine::CombineMDL_Bones( )
{
studiohdr_t *pPrimaryStudioHdr = m_pStudioHdr[ 0 ];
AddToStringTable( m_pCombinedStudioHdr, &m_pCombinedStudioHdr->surfacepropindex, pPrimaryStudioHdr->pszSurfaceProp() );
int *nFlags = ( int * )stackalloc( sizeof( int ) * m_nNumMasterBones );
memset( nFlags, 0, sizeof( int ) * m_nNumMasterBones );
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
OptimizedModel::FileHeader_t *pOrigHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ nModel ]->PeekGet();
int nBoneTest = 0;
int nBoneProp = 0;
if ( nModel > 0 )
{
nBoneTest = BONE_USED_BY_VERTEX_AT_LOD( pOrigHeader->numLODs - 1 );
for( int nLOD = pOrigHeader->numLODs; nLOD < m_pCombinedHardwareHeader->numLODs; nLOD++ )
{
nBoneProp |= BONE_USED_BY_VERTEX_AT_LOD( nLOD );
}
}
for( int nBone = 0; nBone < m_pStudioHdr[ nModel ]->numbones; nBone++ )
{
nFlags[ m_nBoneRemap[ nModel ][ nBone ] ] |= m_pStudioHdr[ nModel ]->pBone( nBone )->flags;
if ( nModel > 0 && pOrigHeader->numLODs < m_pCombinedHardwareHeader->numLODs )
{
if ( ( m_pStudioHdr[ nModel ]->pBone( nBone )->flags & nBoneTest ) != 0 )
{
nFlags[ m_nBoneRemap[ nModel ][ nBone ] ] |= nBoneProp;
}
}
}
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->boneindex );
m_pCombinedStudioHdr->numbones = 0;
for( int nBone = 0; nBone < pPrimaryStudioHdr->numbones; nBone++ )
{
const mstudiobone_t *pOrigBone = pPrimaryStudioHdr->pBone( nBone );
mstudiobone_t *pNewBone = ( mstudiobone_t * )g_CombinerWriter.WriteBuffer( pOrigBone, sizeof( mstudiobone_t ) );
AddToStringTable( pNewBone, &pNewBone->sznameindex, pOrigBone->pszName() );
AddToStringTable( pNewBone, &pNewBone->surfacepropidx, pOrigBone->pszSurfaceProp() );
pNewBone->flags = nFlags[ nBone ];
m_pCombinedStudioHdr->numbones++;
}
for( int nBone = m_pCombinedStudioHdr->numbones; nBone < m_nNumMasterBones; nBone++ )
{
const mstudiobone_t *pOrigBone = m_pMasterBoneList[ nBone ];
mstudiobone_t *pNewBone = ( mstudiobone_t * )g_CombinerWriter.WriteBuffer( pOrigBone, sizeof( mstudiobone_t ) );
AddToStringTable( pNewBone, &pNewBone->sznameindex, pOrigBone->pszName() );
AddToStringTable( pNewBone, &pNewBone->surfacepropidx, pOrigBone->pszSurfaceProp() );
if ( pNewBone->parent >= 0 )
{
pNewBone->parent = m_nBoneRemap[ m_nBoneModelOwner[ nBone ] ][ pNewBone->parent ];
}
pNewBone->flags = nFlags[ nBone ];
m_pCombinedStudioHdr->numbones++;
}
g_CombinerWriter.AlignWrite( 4 );
WriteBoneProc( sizeof( mstudioaxisinterpbone_t ), STUDIO_PROC_AXISINTERP );
WriteBoneProc( sizeof( mstudioquatinterpbone_t ), STUDIO_PROC_QUATINTERP );
WriteBoneQuatInterp();
WriteBoneProc( sizeof( mstudiojigglebone_t ), STUDIO_PROC_JIGGLE );
WriteBoneProc( sizeof( mstudioaimatbone_t ), STUDIO_PROC_AIMATBONE, STUDIO_PROC_AIMATATTACH ); // aimAttach needs fixup
WriteBoneProc( sizeof( mstudiotwistbone_t ), STUDIO_PROC_TWIST_MASTER, STUDIO_PROC_TWIST_SLAVE );
WriteBoneTwist();
WriteBoneConstraints();
if ( pPrimaryStudioHdr->numbonecontrollers > 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model has bone controllers: %s", pPrimaryStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->bonecontrollerindex );
g_CombinerWriter.AlignWrite( 4 );
WriteBoneAttachments();
WriteHitBoxes();
WriteBoneTable();
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::WriteAnimation( mstudioanimdesc_t *pOrigAnim, void *pAnimData, int nFrameSize )
{
if ( ( pOrigAnim->flags & STUDIO_FRAMEANIM ) != 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model has anim frames" );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
else
{
mstudio_rle_anim_t *pOrigFrame = ( mstudio_rle_anim_t * )( pAnimData );
while( 1 )
{
int nSize = sizeof( mstudio_rle_anim_t );
if ( pOrigFrame->flags & STUDIO_ANIM_RAWROT2 )
{
nSize += sizeof( Quaternion64 );
}
if ( pOrigFrame->flags & STUDIO_ANIM_RAWPOS )
{
nSize += sizeof( Vector48 );
}
if ( pOrigFrame->flags & STUDIO_ANIM_ANIMROT )
{
nSize += sizeof( mstudioanim_valueptr_t );
}
if ( pOrigFrame->flags & STUDIO_ANIM_ANIMPOS )
{
nSize += sizeof( mstudioanim_valueptr_t );
}
if ( pOrigFrame->flags & STUDIO_ANIM_ANIMROT )
{
mstudioanim_valueptr_t *rotvptr = pOrigFrame->pRotV();
for (int k = 0; k < 3; k++)
{
mstudioanimvalue_t *pAnimValue = rotvptr->pAnimvalue( k );
if ( pAnimValue != NULL )
{
int nCount = nFrameSize;
while( nCount > 0 )
{
nSize += sizeof( *pAnimValue ) * ( pAnimValue->num.valid + 1 );
nCount -= pAnimValue->num.total;
pAnimValue += pAnimValue->num.valid + 1;
}
}
}
}
if ( pOrigFrame->flags & STUDIO_ANIM_ANIMPOS )
{
mstudioanim_valueptr_t *posvptr = pOrigFrame->pPosV();
for (int k = 0; k < 3; k++)
{
mstudioanimvalue_t *pAnimValue = posvptr->pAnimvalue( k );
if ( pAnimValue != NULL )
{
int nCount = nFrameSize;
while( nCount > 0 )
{
nSize += sizeof( *pAnimValue ) * ( pAnimValue->num.valid + 1 );
nCount -= pAnimValue->num.total;
pAnimValue += pAnimValue->num.valid + 1;
}
}
}
}
// all of the indexes are relative, so a direct copy should be safe
g_CombinerWriter.WriteBuffer( pOrigFrame, nSize );
// DebugCombineMsg( "%d: %d\n", pOrigFrame->bone, pOrigFrame->nextoffset - nSize );
if ( pOrigFrame->nextoffset == 0 )
{
break;
}
else
{
pOrigFrame = pOrigFrame->pNext();
VerifyOffset( pOrigFrame, "Start rle_anim" );
}
}
g_CombinerWriter.AllocWrite( sizeof( mstudio_rle_anim_t ) ); // bug in studiomdl which adds an extra one of these
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::CombineMDL_Anims( )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ 0 ];
VerifyOffset( pStudioHdr->pLocalAnimdesc( 0 ), "Start Animations" );
g_CombinerWriter.WriteBufferWithOffset( pStudioHdr->pLocalAnimdesc( 0 ), sizeof( mstudioanimdesc_t ) * pStudioHdr->numlocalanim, m_pCombinedStudioHdr->localanimindex );
g_CombinerWriter.AlignWrite( 4 );
m_pCombinedStudioHdr->numlocalanim = pStudioHdr->numlocalanim;
for( int nAnim = 0; nAnim < m_pCombinedStudioHdr->numlocalanim; nAnim++ )
{
mstudioanimdesc_t *pOrigAnim = pStudioHdr->pLocalAnimdesc( nAnim );
mstudioanimdesc_t *pNewAnim = m_pCombinedStudioHdr->pLocalAnimdesc( nAnim );
pNewAnim->baseptr = ( byte * )g_CombinerWriter.GetWriteArea() - ( byte * )pNewAnim;
AddToStringTable( pNewAnim, &pNewAnim->sznameindex, pOrigAnim->pszName() );
int nNumSections = 0;
if ( pOrigAnim->sectionframes > 1 )
{
nNumSections = ( pOrigAnim->numframes / pOrigAnim->sectionframes ) + 2; // studio.cpp line 113
pNewAnim->sectionindex = ( byte * )g_CombinerWriter.AllocWrite( nNumSections * sizeof( mstudioanimsections_t ) ) - (byte *)pNewAnim;
}
g_CombinerWriter.AlignWrite( 16 );
pNewAnim->sectionframes = pOrigAnim->sectionframes;
g_CombinerWriter.WriteOffset( pNewAnim->animindex, pNewAnim );
DebugCombineMsg( "Anim %d: %d / %d ( %d )\n", nAnim, pOrigAnim->animindex, pNewAnim->animindex, pNewAnim->animindex - pOrigAnim->animindex );
if ( nNumSections > 1 )
{
int nRemainingFrames = pOrigAnim->numframes;
for( int nSection = 0; nSection < nNumSections; nSection++ )
{
mstudioanimsections_t *pOrigSection = pOrigAnim->pSection( nSection );
mstudioanimsections_t *pNewSection = pNewAnim->pSection( nSection );
VerifyOffset( pOrigSection, "Start mstudioanimsections_t", pNewSection );
*pNewSection = *pOrigSection;
g_CombinerWriter.WriteOffset( pNewSection->animindex, pNewAnim );
int nFrames;
if ( nRemainingFrames > pOrigAnim->sectionframes )
{
nRemainingFrames -= pOrigAnim->sectionframes;
nFrames = pOrigAnim->sectionframes + 1;
}
else
{
nFrames = nRemainingFrames;
nRemainingFrames = 0;
}
WriteAnimation( pOrigAnim, ( ( byte * )pOrigAnim ) + pOrigSection->animindex, nFrames );
}
}
else
{
WriteAnimation( pOrigAnim, pOrigAnim->pAnimBlock( pOrigAnim->animblock, pOrigAnim->animindex ), pOrigAnim->numframes );
}
g_CombinerWriter.AlignWrite( 4 );
if ( pOrigAnim->numikrules > 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model has ik rules: %s", pStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
g_CombinerWriter.AlignWrite( 4 );
if ( pOrigAnim->numlocalhierarchy > 0 )
{
g_CombinerWriter.WriteOffset( pNewAnim->localhierarchyindex, pNewAnim );
g_CombinerWriter.WriteBuffer( pOrigAnim->pHierarchy( 0 ), pOrigAnim->numlocalhierarchy * sizeof( mstudiolocalhierarchy_t ) );
for( int nLocalHierarchy = 0; nLocalHierarchy < pOrigAnim->numlocalhierarchy; nLocalHierarchy++ )
{
mstudiolocalhierarchy_t *pOrigLocalHierarchy = pOrigAnim->pHierarchy( nLocalHierarchy );
mstudiolocalhierarchy_t *pNewLocalHierarchy = pNewAnim->pHierarchy( nLocalHierarchy );
g_CombinerWriter.WriteOffset( pNewLocalHierarchy->localanimindex, pNewLocalHierarchy );
mstudiocompressedikerror_t *pOrigCompressedIKError = pOrigLocalHierarchy->pLocalAnim();
mstudiocompressedikerror_t *pNewCompressedIKError = pNewLocalHierarchy->pLocalAnim();
g_CombinerWriter.WriteBuffer( pOrigCompressedIKError, sizeof( *pOrigCompressedIKError ) );
for( int nAnim = 0; nAnim < 6; nAnim++ )
{
g_CombinerWriter.WriteOffset( pNewCompressedIKError->offset[ nAnim ], pNewCompressedIKError );
int nSize = 0;
mstudioanimvalue_t *pAnimValue = pOrigCompressedIKError->pAnimvalue( nAnim );
if ( pAnimValue != NULL )
{
int nCount = pOrigAnim->numframes;
while( nCount > 0 )
{
nSize += sizeof( *pAnimValue ) * ( pAnimValue->num.valid + 1 );
nCount -= pAnimValue->num.total;
pAnimValue += pAnimValue->num.valid + 1;
}
}
g_CombinerWriter.WriteBuffer( pOrigCompressedIKError->pAnimvalue( nAnim ), nSize );
}
}
}
g_CombinerWriter.AlignWrite( 4 );
}
for( int nAnim = 0; nAnim < m_pCombinedStudioHdr->numlocalanim; nAnim++ )
{
mstudioanimdesc_t *pOrigAnim = pStudioHdr->pLocalAnimdesc( nAnim );
mstudioanimdesc_t *pNewAnim = m_pCombinedStudioHdr->pLocalAnimdesc( nAnim );
if ( pOrigAnim->nummovements > 0 )
{
g_CombinerWriter.WriteOffset( pNewAnim->movementindex, pNewAnim );
VerifyOffset( pOrigAnim->pMovement( 0 ), "Start Movement" );
g_CombinerWriter.WriteBuffer( pOrigAnim->pMovement( 0 ), sizeof( mstudiomovement_t ) * pOrigAnim->nummovements );
g_CombinerWriter.AlignWrite( 4 );
}
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::CombineMDL_SequenceInfo( )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ 0 ];
VerifyField( offsetof( studiohdr_t, localseqindex ), "Sequence Info" );
m_pCombinedStudioHdr->numlocalseq = pStudioHdr->numlocalseq;
g_CombinerWriter.WriteBufferWithOffset( pStudioHdr->pLocalSeqdesc( 0 ), sizeof( mstudioseqdesc_t ) * pStudioHdr->numlocalseq, m_pCombinedStudioHdr->localseqindex );
for( int nSequence = 0; nSequence < pStudioHdr->numlocalseq; nSequence++ )
{
mstudioseqdesc_t *pOrigSequence = pStudioHdr->pLocalSeqdesc( nSequence );
mstudioseqdesc_t *pNewSequence = m_pCombinedStudioHdr->pLocalSeqdesc( nSequence );
AddToStringTable( pNewSequence, &pNewSequence->szlabelindex, pOrigSequence->pszLabel() );
AddToStringTable( pNewSequence, &pNewSequence->szactivitynameindex, pOrigSequence->pszActivityName() );
pNewSequence->baseptr = ( byte * )g_CombinerWriter.GetWriteArea() - ( byte * )pNewSequence;
if ( pOrigSequence->groupsize[ 0 ] > 1 || pOrigSequence->groupsize[ 1 ] > 1 )
{
g_CombinerWriter.WriteOffset( pNewSequence->posekeyindex, pNewSequence );
int nSize = ( pOrigSequence->groupsize[ 0 ] + pOrigSequence->groupsize[ 1 ] ) * sizeof( float );
g_CombinerWriter.WriteBuffer( pOrigSequence->pPoseKey( 0, 0 ), nSize );
}
g_CombinerWriter.WriteOffset( pNewSequence->eventindex, pNewSequence );
if ( pOrigSequence->numevents > 0 )
{
VerifyOffset( pOrigSequence->pEvent( 0 ), "Sequence Event" );
g_CombinerWriter.WriteBuffer( pOrigSequence->pEvent( 0 ), pOrigSequence->numevents * sizeof( mstudioevent_t ) );
for ( int nEvent = 0; nEvent < pOrigSequence->numevents; nEvent++ )
{
mstudioevent_t *pOrigEvent = pOrigSequence->pEvent( nEvent );
mstudioevent_t *pNewEvent = pNewSequence->pEvent( nEvent );
if ( pOrigEvent->type == NEW_EVENT_STYLE )
{
AddToStringTable( pNewEvent, &pNewEvent->szeventindex, pOrigEvent->pszEventName() );
}
}
}
g_CombinerWriter.AlignWrite( 4 );
g_CombinerWriter.WriteOffset( pNewSequence->autolayerindex, pNewSequence );
if ( pOrigSequence->numautolayers > 0 )
{
VerifyOffset( pOrigSequence->pAutolayer( 0 ), "Auto Layer" );
g_CombinerWriter.WriteBuffer( pOrigSequence->pAutolayer( 0 ), pOrigSequence->numautolayers * sizeof( mstudioautolayer_t ) );
}
if ( pOrigSequence->weightlistindex < pOrigSequence->eventindex )
{ // we are using an existing weight
int nFound = -1;
for( int nPreviousSequence = 0; nPreviousSequence < nSequence; nPreviousSequence++ )
{
mstudioseqdesc_t *pOrigPreviousSequence = pStudioHdr->pLocalSeqdesc( nPreviousSequence );
if ( memcmp( pOrigPreviousSequence->pBoneweight( 0 ), pOrigSequence->pBoneweight( 0 ), pStudioHdr->numbones * sizeof( float ) ) == 0 )
{
nFound = nPreviousSequence;
break;
}
}
if ( nFound != -1 )
{
mstudioseqdesc_t *pNewPreviousSequence = m_pCombinedStudioHdr->pLocalSeqdesc( nFound );
pNewSequence->weightlistindex = ( ( byte * )pNewPreviousSequence->pBoneweight( 0 ) - ( byte * )pNewSequence);
}
else
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "was not able to find existing weight in model: %s", pStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_UNHANDLED_ISSUE );
}
}
else
{
g_CombinerWriter.WriteOffset( pNewSequence->weightlistindex, pNewSequence );
// Assert( m_nNumMasterBones == pStudioHdr->numbones ); // need to handle bone merge!
g_CombinerWriter.WriteBuffer( pOrigSequence->pBoneweight( 0 ), pStudioHdr->numbones * sizeof( float ) );
float flTempWeight = 1.0f;
for( int nNewBones = pStudioHdr->numbones; nNewBones < m_nNumMasterBones; nNewBones++ )
{ // more efficient ways to do this, but for now, not knowing if I can just give them all 1.0f, I'll leave it
g_CombinerWriter.WriteBuffer( &flTempWeight, sizeof( flTempWeight ) );
}
}
g_CombinerWriter.WriteOffset( pNewSequence->iklockindex, pNewSequence );
if ( pOrigSequence->numiklocks > 0 )
{
VerifyOffset( pOrigSequence->pIKLock( 0 ), "IK Lock" );
g_CombinerWriter.WriteBuffer( pOrigSequence->pIKLock( 0 ), pOrigSequence->numiklocks * sizeof( mstudioiklock_t ) );
}
g_CombinerWriter.AlignWrite( 4 );
g_CombinerWriter.WriteOffset( pNewSequence->animindexindex, pNewSequence );
int nSize = ( pOrigSequence->groupsize[ 0 ] * pOrigSequence->groupsize[ 1 ] ) * sizeof( short );
if ( nSize > 0 )
{
VerifyOffset( ( ( ( byte * )pOrigSequence ) + pOrigSequence->animindexindex ), "AnimIndexIndex" );
g_CombinerWriter.WriteBuffer( ( ( ( byte * )pOrigSequence ) + pOrigSequence->animindexindex ), nSize );
}
g_CombinerWriter.AlignWrite( 4 );
g_CombinerWriter.WriteOffset( pNewSequence->keyvalueindex, pNewSequence );
if( pOrigSequence->keyvaluesize > 0 )
{
VerifyOffset( ( void * )pOrigSequence->KeyValueText(), "Sequence KV" );
g_CombinerWriter.WriteBuffer( ( void * )pOrigSequence->KeyValueText(), pOrigSequence->keyvaluesize * sizeof( char ) );
}
g_CombinerWriter.AlignWrite( 4 );
g_CombinerWriter.WriteOffset( pNewSequence->activitymodifierindex, pNewSequence );
if ( pOrigSequence->numactivitymodifiers > 0 )
{
g_CombinerWriter.WriteBuffer( pOrigSequence->pActivityModifier( 0 ), pOrigSequence->numactivitymodifiers * sizeof( mstudioactivitymodifier_t ) );
}
g_CombinerWriter.AlignWrite( 4 );
for ( int nActivityModifier = 0; nActivityModifier < pOrigSequence->numactivitymodifiers; nActivityModifier++ )
{
mstudioactivitymodifier_t *pOrigActivityModifier = pOrigSequence->pActivityModifier( nActivityModifier );
mstudioactivitymodifier_t *pNewActivityModifier = pNewSequence->pActivityModifier( nActivityModifier );
AddToStringTable( pNewActivityModifier, &pNewActivityModifier->sznameindex, pOrigActivityModifier->pszName() );
}
nSize = pOrigSequence->numactivitymodifiers * sizeof( mstudioactivitymodifier_t );
byte *pTestPtr = ( ( ( byte * )pOrigSequence ) + pOrigSequence->activitymodifierindex ) + nSize;
VerifyOffset( pTestPtr, "Final Sequence Write" );
}
int *pNodeName = ( int * )g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->localnodenameindex );
g_CombinerWriter.AllocWrite( pStudioHdr->numlocalnodes * sizeof( *pNodeName ) );
g_CombinerWriter.AlignWrite( 4 );
for ( int nNodeIndex = 0; nNodeIndex < pStudioHdr->numlocalnodes; nNodeIndex++ )
{
AddToStringTable( m_pCombinedStudioHdr, pNodeName, pStudioHdr->pszLocalNodeName( nNodeIndex ) );
pNodeName++;
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->localnodeindex );
if ( pStudioHdr->numlocalnodes > 0 )
{
g_CombinerWriter.WriteBuffer( pStudioHdr->pLocalTransition( 0 ), pStudioHdr->numlocalnodes * pStudioHdr->numlocalnodes * sizeof( byte ) );
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::WriteModel( int nModel )
{
mstudiomodel_t *pOrigModel = m_pMasterModels[ 0 ][ nModel ];
mstudiomodel_t *pNewModel = &m_pCombinedModels[ nModel ];
g_CombinerWriter.WriteOffset( pNewModel->meshindex, pNewModel );
g_CombinerWriter.WriteBuffer( pOrigModel->pMesh( 0 ), pOrigModel->nummeshes * sizeof( mstudiomesh_t ) );
g_CombinerWriter.AlignWrite( 4 );
for ( int nMesh = 0; nMesh < pOrigModel->nummeshes; nMesh++ )
{
// mstudiomesh_t *pOrigMesh = pOrigModel->pMesh( nMesh );
mstudiomesh_t *pNewMesh = pNewModel->pMesh( nMesh );
pNewMesh->numvertices = m_pCombinedVertex->numLODVertexes[ 0 ];
for( int nLOD = 0; nLOD < m_pCombinedVertex->numLODs; nLOD++ )
{
pNewMesh->vertexdata.numLODVertexes[ nLOD ] = m_pCombinedVertex->numLODVertexes[ nLOD ];
}
pNewMesh->modelindex = ( byte * )pNewModel - ( byte * )pNewMesh;
}
// pNewModel->vertexindex = pOrigModel->vertexindex;
// externalVertexIndex += pmodel[i].numvertices * sizeof(mstudiovertex_t);
// ALIGN4( externalTangentsIndex );
// pmodel[i].tangentsindex = (int)externalTangentsIndex;
// externalTangentsIndex += pmodel[i].numvertices * sizeof( Vector4D );
g_CombinerWriter.WriteOffset( pNewModel->eyeballindex, pNewModel );
if ( pOrigModel->numeyeballs > 0 )
{
g_CombinerWriter.WriteBuffer( pOrigModel->pEyeball( 0 ), pOrigModel->numeyeballs * sizeof( mstudioeyeball_t ) );
}
for ( int nMesh = 0; nMesh < pOrigModel->nummeshes; nMesh++ )
{
// mstudiomesh_t *pOrigMesh = pOrigModel->pMesh( nMesh );
mstudiomesh_t *pNewMesh = pNewModel->pMesh( nMesh );
pNewMesh->numflexes = 0;
g_CombinerWriter.WriteOffset( pNewMesh->flexindex, pNewMesh );
for( int nSubModel = 0; nSubModel < m_pCombinedStudioData->m_nNumModels; nSubModel++ )
{
if ( !m_pMasterModels[ nSubModel ][ nModel ] )
{
continue;
}
mstudiomesh_t *pOrigFlexMesh = m_pMasterModels[ nSubModel ][ nModel ]->pMesh( nMesh );
if ( pOrigFlexMesh->numflexes )
{ // figure out the total number of flex entries for this mesh and reserve space
pNewMesh->numflexes += pOrigFlexMesh->numflexes;
g_CombinerWriter.WriteBuffer( pOrigFlexMesh->pFlex( 0 ), pOrigFlexMesh->numflexes * sizeof( mstudioflex_t ) );
}
}
int nTotalFlexes = 0;
if ( pNewMesh->numflexes > 0 )
{
g_CombinerWriter.AlignWrite( 4 );
for( int nSubModel = 0; nSubModel < m_pCombinedStudioData->m_nNumModels; nSubModel++ )
{
if ( !m_pMasterModels[ nSubModel ][ nModel ] )
{
continue;
}
mstudiomesh_t *pOrigFlexMesh = m_pMasterModels[ nSubModel ][ nModel ]->pMesh( nMesh );
if ( pOrigFlexMesh->numflexes )
{
for( int nFlex = 0; nFlex < pOrigFlexMesh->numflexes; nFlex++, nTotalFlexes++ )
{
mstudioflex_t *pOrigFlex = pOrigFlexMesh->pFlex( nFlex );
mstudioflex_t *pNewFlex = pNewMesh->pFlex( nTotalFlexes );
bool bWrinkleVAnim = ( pOrigFlex->vertanimtype == STUDIO_VERT_ANIM_WRINKLE );
int nVAnimDeltaSize = bWrinkleVAnim ? sizeof( mstudiovertanim_wrinkle_t ) : sizeof( mstudiovertanim_t );
g_CombinerWriter.WriteOffset( pNewFlex->vertindex, pNewFlex );
g_CombinerWriter.WriteBuffer( pOrigFlex->pBaseVertanim(), pOrigFlex->numverts * nVAnimDeltaSize );
if ( bWrinkleVAnim )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model has anim wrinkle" );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
#if 0
for( int nVert = 0; nVert < pOrigFlex->numverts; nVert++ )
{
mstudiovertanim_wrinkle_t *pNewVertAnimWrinkle = pNewFlex->pVertanimWrinkle( nVert );
}
#endif
}
else
{
float flDestAnimFixPointScale = m_pCombinedStudioHdr->VertAnimFixedPointScale();
float flSourceAnimFixPointScale = m_pStudioHdr[ nSubModel ]->VertAnimFixedPointScale();
Vector vUpdate;
for( int nVert = 0; nVert < pOrigFlex->numverts; nVert++ )
{
mstudiovertanim_t *pOrigVertAnim = pOrigFlex->pVertanim( nVert );
mstudiovertanim_t *pNewVertAnim = pNewFlex->pVertanim( nVert );
int nVertIndex = pOrigVertAnim->index;
nVertIndex += pOrigFlexMesh->vertexoffset;
vUpdate = pNewVertAnim->GetDeltaFloat();
vUpdate /= flSourceAnimFixPointScale;
vUpdate *= flDestAnimFixPointScale;
pNewVertAnim->SetDeltaFloat( vUpdate );
vUpdate = pNewVertAnim->GetNDeltaFloat();
vUpdate /= flSourceAnimFixPointScale;
vUpdate *= flDestAnimFixPointScale;
pNewVertAnim->SetNDeltaFloat( vUpdate );
pNewVertAnim->index = m_nVertexRemap[ nSubModel ][ nVertIndex ] - pNewMesh->vertexoffset;
}
}
}
}
}
}
}
}
void CModelCombine::CombineMDL_Model( )
{
studiohdr_t *pPrimaryStudioHdr = m_pStudioHdr[ 0 ];
studiohdr_t *pFlexStudioHdr = NULL;
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ nModel ];
if ( pStudioHdr->numflexdesc )
{
#if 0
if ( pFlexStudioHdr )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model %s and %s both have flex specifications", pFlexStudioHdr->pszName(), pStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
#endif
pFlexStudioHdr = pStudioHdr;
m_nFlexModelSource = nModel;
break;
}
}
if ( !pFlexStudioHdr )
{
pFlexStudioHdr = pPrimaryStudioHdr;
m_nFlexModelSource = 0;
}
VerifyField( offsetof( studiohdr_t, bodypartindex ), "Body Part Sequence" );
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->bodypartindex );
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pBodypart( 0 ), pPrimaryStudioHdr->numbodyparts * sizeof( mstudiobodyparts_t ) );
m_pCombinedModels = ( mstudiomodel_t * )g_CombinerWriter.GetWritePos();
int nTotalModels = 0;
for ( int nBodyPart = 0; nBodyPart < pPrimaryStudioHdr->numbodyparts; nBodyPart++ )
{
mstudiobodyparts_t *pOrigBodyPart = pPrimaryStudioHdr->pBodypart( nBodyPart );
mstudiobodyparts_t *pNewBodyPart = m_pCombinedStudioHdr->pBodypart( nBodyPart );
AddToStringTable( pNewBodyPart, &pNewBodyPart->sznameindex, pOrigBodyPart->pszName() );
g_CombinerWriter.WriteOffset( pNewBodyPart->modelindex, pNewBodyPart );
for( int nModel = 0; nModel < pOrigBodyPart->nummodels; nModel++ )
{ // build our list of master models
m_pMasterModels[ 0 ][ nTotalModels ] = m_pMasterFlexModels[ nTotalModels ] = pOrigBodyPart->pModel( nModel );
g_CombinerWriter.WriteBuffer( m_pMasterModels[ 0 ][ nTotalModels ], sizeof( mstudiomodel_t ) );
for( int nSubModels = 1; nSubModels < m_pCombinedStudioData->m_nNumModels; nSubModels++ )
{
m_pMasterModels[ nSubModels ][ nTotalModels ] = NULL;
studiohdr_t *pSubStudioHdr = m_pStudioHdr[ nSubModels ];
if ( nBodyPart < pSubStudioHdr->numbodyparts )
{
mstudiobodyparts_t *pSubBodyPart = pSubStudioHdr->pBodypart( nBodyPart );
if ( nModel < pSubBodyPart->nummodels )
{ // if a sub model matches up to the body part
m_pCombinedModels[ nTotalModels ].numvertices += pSubBodyPart->pModel( nModel )->numvertices;
if ( nSubModels == m_nFlexModelSource )
{ // if it is part of the primary flex specification
m_pMasterFlexModels[ nTotalModels ] = pSubBodyPart->pModel( nModel );
}
m_pMasterModels[ nSubModels ][ nTotalModels ] = pSubBodyPart->pModel( nModel );
}
}
}
nTotalModels++;
}
}
g_CombinerWriter.AlignWrite( 4 );
m_pCombinedStudioHdr->numflexdesc = pFlexStudioHdr->numflexdesc;
m_pCombinedStudioHdr->numflexcontrollers = pFlexStudioHdr->numflexcontrollers;
m_pCombinedStudioHdr->numflexrules = pFlexStudioHdr->numflexrules;
m_pCombinedStudioHdr->numflexcontrollerui = pFlexStudioHdr->numflexcontrollerui;
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->flexdescindex );
VerifyField( offsetof( studiohdr_t, flexdescindex ), "Flex Desc" );
if ( pFlexStudioHdr->numflexdesc > 0 )
{
g_CombinerWriter.WriteBuffer( pFlexStudioHdr->pFlexdesc( 0 ), pFlexStudioHdr->numflexdesc * sizeof( mstudioflexdesc_t ) );
}
g_CombinerWriter.AlignWrite( 4 );
for ( int nFlexDesc = 0; nFlexDesc < pFlexStudioHdr->numflexdesc; nFlexDesc++ )
{
mstudioflexdesc_t *pOrigFlexDesc = pFlexStudioHdr->pFlexdesc( nFlexDesc );
mstudioflexdesc_t *pNewFlexDesc = m_pCombinedStudioHdr->pFlexdesc( nFlexDesc );
AddToStringTable( pNewFlexDesc, &pNewFlexDesc->szFACSindex, pOrigFlexDesc->pszFACS() );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->flexcontrollerindex );
VerifyField( offsetof( studiohdr_t, flexdescindex ), "Flex Controller" );
if ( pFlexStudioHdr->numflexcontrollers > 0 )
{
g_CombinerWriter.WriteBuffer( pFlexStudioHdr->pFlexcontroller( ( LocalFlexController_t )0 ), pFlexStudioHdr->numflexcontrollers * sizeof( mstudioflexcontroller_t ) );
for( int nFlexController = 0; nFlexController < pFlexStudioHdr->numflexcontrollers; nFlexController++ )
{
mstudioflexcontroller_t *pOrigFlexController = pFlexStudioHdr->pFlexcontroller( ( LocalFlexController_t )nFlexController );
mstudioflexcontroller_t *pNewFlexController = m_pCombinedStudioHdr->pFlexcontroller( ( LocalFlexController_t )nFlexController );
AddToStringTable( pNewFlexController, &pNewFlexController->sznameindex, pOrigFlexController->pszName() );
AddToStringTable( pNewFlexController, &pNewFlexController->sztypeindex, pOrigFlexController->pszType() );
}
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->flexruleindex );
VerifyField( offsetof( studiohdr_t, flexruleindex ), "Flex Rules" );
if ( pFlexStudioHdr->numflexrules > 0 )
{
g_CombinerWriter.WriteBuffer( pFlexStudioHdr->pFlexRule( 0 ), pFlexStudioHdr->numflexrules * sizeof( mstudioflexrule_t ) );
g_CombinerWriter.AlignWrite( 4 );
for( int nFlexRule = 0; nFlexRule < pFlexStudioHdr->numflexrules; nFlexRule++ )
{
mstudioflexrule_t *pOrigFlexRule = pFlexStudioHdr->pFlexRule( nFlexRule );
mstudioflexrule_t *pNewFlexRule = m_pCombinedStudioHdr->pFlexRule( nFlexRule );
g_CombinerWriter.WriteOffset( pNewFlexRule->opindex, pNewFlexRule );
g_CombinerWriter.WriteBuffer( pOrigFlexRule->iFlexOp( 0 ), pOrigFlexRule->numops * sizeof( mstudioflexop_t ) );
g_CombinerWriter.AlignWrite( 4 );
}
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->flexcontrolleruiindex );
VerifyField( offsetof( studiohdr_t, flexcontrolleruiindex ), "Flex Controller UI" );
if ( pFlexStudioHdr->numflexcontrollerui > 0 )
{
g_CombinerWriter.WriteBuffer( pFlexStudioHdr->pFlexControllerUI( 0 ), pFlexStudioHdr->numflexcontrollerui * sizeof( mstudioflexcontrollerui_t ) );
for( int nFlexControllerUI = 0; nFlexControllerUI < pFlexStudioHdr->numflexcontrollerui; nFlexControllerUI++ )
{
mstudioflexcontrollerui_t *pOrigFlexControllerUI = pFlexStudioHdr->pFlexControllerUI( nFlexControllerUI );
mstudioflexcontrollerui_t *pNewFlexControllerUI = m_pCombinedStudioHdr->pFlexControllerUI( nFlexControllerUI );
AddToStringTable( pNewFlexControllerUI, &pNewFlexControllerUI->sznameindex, pOrigFlexControllerUI->pszName() );
// not worrying about remapping the controller indexes here yet
}
g_CombinerWriter.AlignWrite( 4 );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->ikchainindex );
VerifyField( offsetof( studiohdr_t, ikchainindex ), "IK Chain" );
if ( pPrimaryStudioHdr->numikchains > 0 )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pIKChain( 0 ), pPrimaryStudioHdr->numikchains * sizeof( mstudioikchain_t ) );
g_CombinerWriter.AlignWrite( 4 );
for( int nIKChain = 0; nIKChain < pPrimaryStudioHdr->numikchains; nIKChain++ )
{
mstudioikchain_t *pOrigIKChain = pPrimaryStudioHdr->pIKChain( nIKChain );
mstudioikchain_t *pNewIKChain = m_pCombinedStudioHdr->pIKChain( nIKChain );
AddToStringTable( pNewIKChain, &pNewIKChain->sznameindex, pNewIKChain->pszName() );
g_CombinerWriter.WriteOffset( pNewIKChain->linkindex, pNewIKChain );
g_CombinerWriter.WriteBuffer( pOrigIKChain->pLink( 0 ), pOrigIKChain->numlinks * sizeof( mstudioiklink_t ) );
}
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->localikautoplaylockindex );
VerifyField( offsetof( studiohdr_t, localikautoplaylockindex ), "IK Autoplay Lock" );
if ( pPrimaryStudioHdr->numlocalikautoplaylocks > 0 )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pLocalIKAutoplayLock( 0 ), pPrimaryStudioHdr->numlocalikautoplaylocks * sizeof( mstudioiklock_t ) );
g_CombinerWriter.AlignWrite( 4 );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->mouthindex );
VerifyField( offsetof( studiohdr_t, mouthindex ), "Mouth" );
if ( pPrimaryStudioHdr->nummouths )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pMouth( 0 ), pPrimaryStudioHdr->nummouths * sizeof( mstudiomouth_t ) );
g_CombinerWriter.AlignWrite( 4 );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->localposeparamindex );
VerifyField( offsetof( studiohdr_t, localposeparamindex ), "Pose Param" );
if ( pPrimaryStudioHdr->numlocalposeparameters > 0 )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pLocalPoseParameter( 0 ), pPrimaryStudioHdr->numlocalposeparameters * sizeof( mstudioposeparamdesc_t ) );
g_CombinerWriter.AlignWrite( 4 );
for( int nPoseParam = 0; nPoseParam < pPrimaryStudioHdr->numlocalposeparameters; nPoseParam++ )
{
mstudioposeparamdesc_t *pOrigPoseParam = pPrimaryStudioHdr->pLocalPoseParameter( nPoseParam );
mstudioposeparamdesc_t *pNewPoseParam = m_pCombinedStudioHdr->pLocalPoseParameter( nPoseParam );
AddToStringTable( pNewPoseParam, &pNewPoseParam->sznameindex, pOrigPoseParam->pszName() );
}
}
for( int nModel = 0; nModel < nTotalModels; nModel++ )
{
WriteModel( nModel );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->includemodelindex );
VerifyField( offsetof( studiohdr_t, includemodelindex ), "Model Groups" );
if ( pPrimaryStudioHdr->numincludemodels > 0 )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pModelGroup( 0 ), pPrimaryStudioHdr->numincludemodels * sizeof( mstudiomodelgroup_t ) );
for( int nModelGroup = 0; nModelGroup < pPrimaryStudioHdr->numincludemodels; nModelGroup++ )
{
mstudiomodelgroup_t *pOrigModelGroup = pPrimaryStudioHdr->pModelGroup( nModelGroup );
mstudiomodelgroup_t *pNewModelGroup = m_pCombinedStudioHdr->pModelGroup( nModelGroup );
AddToStringTable( pNewModelGroup, &pNewModelGroup->sznameindex, pOrigModelGroup->pszName() );
}
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->animblockindex );
VerifyField( offsetof( studiohdr_t, animblockindex ), "Anim Blocks" );
if ( pPrimaryStudioHdr->numanimblocks > 0 )
{
g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr->pAnimBlock( 0 ), pPrimaryStudioHdr->numanimblocks * sizeof( mstudioanimblock_t ) );
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model has anim blocks: %s", pPrimaryStudioHdr->pszName() );
throw( COMBINE_RESULT_FLAG_UNHANDLED_ISSUE );
}
g_CombinerWriter.AlignWrite( 4 );
AddToStringTable( m_pCombinedStudioHdr, &m_pCombinedStudioHdr->szanimblocknameindex, pPrimaryStudioHdr->pszAnimBlockName() );
}
void CModelCombine::CombineMDL_Textures( )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->textureindex );
m_pCombinedStudioHdr->numtextures = m_pCombinedStudioData->m_nNumAtlasGroups + m_pCombinedStudioData->m_nNumNonAtlasedMaterialBaseNames;
// first allocate/write out "blank" texture entries (materials)
mstudiotexture_t NewTexture;
memset( &NewTexture, 0, sizeof( NewTexture ) );
NewTexture.sznameindex = 0;
NewTexture.used = 1;
for ( int nAtlasGroup = 0; nAtlasGroup < m_pCombinedStudioHdr->numtextures; nAtlasGroup++ )
{
g_CombinerWriter.WriteBuffer( &NewTexture, sizeof( mstudiotexture_t ) );
}
g_CombinerWriter.AlignWrite( 4 );
// then fix up those written entries with proper name index values from the string table
for ( int nAtlasGroup = 0; nAtlasGroup < m_pCombinedStudioData->m_nNumAtlasGroups; nAtlasGroup++ )
{
mstudiotexture_t *pNewTexture = m_pCombinedStudioHdr->pTexture( nAtlasGroup );
// we use a specialized name here that other systems won't understand
V_sprintf_safe( m_pCombinedStudioData->m_AtlasGroups[ nAtlasGroup ].m_szCombinedMaterialName, "!%s|%d|%hu|%d!", m_pCombinedStudioData->m_szCombinedModelName, nAtlasGroup, m_pCombinedStudioData->m_FinalHandle, GetNextAssetID() );
AddToStringTable( pNewTexture, &pNewTexture->sznameindex, m_pCombinedStudioData->m_AtlasGroups[ nAtlasGroup ].m_szCombinedMaterialName );
}
for ( int nNonAtlasedMaterial = 0; nNonAtlasedMaterial < m_pCombinedStudioData->m_nNumNonAtlasedMaterialBaseNames; nNonAtlasedMaterial++ )
{
int nMaterial = m_pCombinedStudioData->m_nNumAtlasGroups + nNonAtlasedMaterial;
mstudiotexture_t *pNewTexture = m_pCombinedStudioHdr->pTexture( nMaterial );
AddToStringTable( pNewTexture, &pNewTexture->sznameindex, m_pCombinedStudioData->m_szNonAtlasedMaterialBaseName[ nNonAtlasedMaterial ] );
}
// write out material paths (used for non atlased materials)
int *pNewCDTexture = ( int * )g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->cdtextureindex );
m_pCombinedStudioHdr->numcdtextures = m_pCombinedStudioData->m_nNumNonAtlasedMaterialPaths;
g_CombinerWriter.AllocWrite( m_pCombinedStudioHdr->numcdtextures * sizeof( int ) );
g_CombinerWriter.AlignWrite( 4 );
for ( int nMaterialPaths = 0; nMaterialPaths < m_pCombinedStudioData->m_nNumNonAtlasedMaterialPaths; nMaterialPaths++ )
{
AddToStringTable( m_pCombinedStudioHdr, &pNewCDTexture[ nMaterialPaths ], m_pCombinedStudioData->m_szNonAtlasedMaterialPaths[ nMaterialPaths ] );
}
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->skinindex );
m_pCombinedStudioHdr->numskinref = m_pCombinedStudioHdr->numtextures;
m_pCombinedStudioHdr->numskinfamilies = 1;
for ( short nTexture = 0; nTexture < static_cast< short >( m_pCombinedStudioHdr->numtextures ); nTexture++ )
{
g_CombinerWriter.WriteBuffer( &nTexture, sizeof( short ) );
}
g_CombinerWriter.AlignWrite( 4 );
}
void CModelCombine::CombineMDL_KeyValues( )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ 0 ];
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr->keyvalueindex );
VerifyField( offsetof( studiohdr_t, keyvalueindex ), "KeyValues" );
if ( pStudioHdr->keyvaluesize > 0 )
{
g_CombinerWriter.WriteBuffer( pStudioHdr->KeyValueText(), pStudioHdr->keyvaluesize );
}
g_CombinerWriter.AlignWrite( 4 );
}
#define WRITE_BONE_BLOCK( type, srcfield, dest, destindex ) \
g_CombinerWriter.WriteOffset( pNewLinearBone->destindex, pNewLinearBone ); \
type *dest = (type *)g_CombinerWriter.AllocWrite( m_nNumMasterBones * sizeof( type ) ); \
g_CombinerWriter.AlignWrite( 4 ); \
for ( int i = 0; i < m_nNumMasterBones; i++) \
{ \
dest[ i ] = m_pMasterBoneList[ i ]->srcfield; \
}
void CModelCombine::CombineMDL_BoneTransforms( )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr2->srcbonetransformindex );
VerifyField2( offsetof( studiohdr2_t, srcbonetransformindex ), "Bone Transforms" );
// need to merge bone transforms from the sub models?
if ( m_pStudioHdr2[ 0 ]->numsrcbonetransform > 0 )
{
g_CombinerWriter.WriteBuffer( m_pStudioHdr[ 0 ]->SrcBoneTransform( 0 ), m_pStudioHdr2[ 0 ]->numsrcbonetransform * sizeof( mstudiosrcbonetransform_t ) );
for( int nBoneTransform = 0; nBoneTransform < m_pStudioHdr2[ 0 ]->numsrcbonetransform; nBoneTransform++ )
{
mstudiosrcbonetransform_t *pOrigBoneTransform = ( mstudiosrcbonetransform_t * )m_pStudioHdr[ 0 ]->SrcBoneTransform( nBoneTransform );
mstudiosrcbonetransform_t *pNewBoneTransform = ( mstudiosrcbonetransform_t * )m_pCombinedStudioHdr->SrcBoneTransform( nBoneTransform );
AddToStringTable( pNewBoneTransform, &pNewBoneTransform->sznameindex, pOrigBoneTransform->pszName() );
}
}
g_CombinerWriter.AlignWrite( 4 );
if ( m_pStudioHdr2[ 0 ]->pLinearBones() != NULL )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr2->linearboneindex, m_pCombinedStudioHdr2 );
VerifyField2( offsetof( studiohdr2_t, linearboneindex ), "Linear Bone Index" );
mstudiolinearbone_t *pNewLinearBone = ( mstudiolinearbone_t * )g_CombinerWriter.WriteBuffer( m_pStudioHdr2[ 0 ]->pLinearBones(), sizeof( mstudiolinearbone_t ) );
pNewLinearBone->numbones = m_nNumMasterBones;
WRITE_BONE_BLOCK( int, flags, pFlags, flagsindex );
WRITE_BONE_BLOCK( int, parent, pParent, parentindex );
WRITE_BONE_BLOCK( Vector, pos, pPos, posindex );
WRITE_BONE_BLOCK( Quaternion, quat, pQuat, quatindex );
WRITE_BONE_BLOCK( RadianEuler, rot, pRot, rotindex );
WRITE_BONE_BLOCK( matrix3x4_t, poseToBone, pPoseToBone, posetoboneindex );
WRITE_BONE_BLOCK( Vector, posscale, pPoseScale, posscaleindex );
WRITE_BONE_BLOCK( Vector, rotscale, pRotScale, rotscaleindex );
WRITE_BONE_BLOCK( Quaternion, qAlignment, pQAlignment, qalignmentindex );
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
mstudiobone_t *pNewBone = (mstudiobone_t *)m_pCombinedStudioHdr->pBone( nBone );
*pNewLinearBone->pflags( nBone ) = pNewBone->flags;
}
}
}
void CModelCombine::CombineMDL_BoneFlexDrivers( )
{
m_pCombinedStudioHdr2->m_nBoneFlexDriverCount = m_pStudioHdr2[ m_nFlexModelSource ]->m_nBoneFlexDriverCount;
if ( m_pStudioHdr2[ m_nFlexModelSource ]->m_nBoneFlexDriverCount > 0 )
{
g_CombinerWriter.WriteOffset( m_pCombinedStudioHdr2->m_nBoneFlexDriverIndex, m_pCombinedStudioHdr2 );
VerifyField2( offsetof( studiohdr2_t, m_nBoneFlexDriverIndex ), "Bone Flex Drivers" );
g_CombinerWriter.WriteBuffer( m_pStudioHdr2[ m_nFlexModelSource ]->pBoneFlexDriver( 0 ), m_pStudioHdr2[ m_nFlexModelSource ]->m_nBoneFlexDriverCount * sizeof( mstudioboneflexdriver_t ) );
g_CombinerWriter.AlignWrite( 4 );
for( int nBoneFlexDriver = 0; nBoneFlexDriver < m_pStudioHdr2[ m_nFlexModelSource ]->m_nBoneFlexDriverCount; nBoneFlexDriver++ )
{
mstudioboneflexdriver_t *pOrigBoneFlexDriver = m_pStudioHdr2[ m_nFlexModelSource ]->pBoneFlexDriver( nBoneFlexDriver );
mstudioboneflexdriver_t *pNewBoneFlexDriver = m_pCombinedStudioHdr2->pBoneFlexDriver( nBoneFlexDriver );
g_CombinerWriter.WriteOffset( pNewBoneFlexDriver->m_nControlIndex, pNewBoneFlexDriver );
g_CombinerWriter.WriteBuffer( pOrigBoneFlexDriver->pBoneFlexDriverControl( 0 ), pOrigBoneFlexDriver->m_nControlCount * sizeof( mstudioboneflexdrivercontrol_t ) );
/* for( int nBoneFlexDriverControl = 0; nBoneFlexDriverControl < pOrigBoneFlexDriver->m_nControlCount; nBoneFlexDriverControl++ )
{
mstudioboneflexdrivercontrol_t *pOrigBoneFlexDriverControl = pOrigBoneFlexDriver->pBoneFlexDriverControl( nBoneFlexDriverControl );
mstudioboneflexdrivercontrol_t *pNewBoneFlexDriverControl = pNewBoneFlexDriver->pBoneFlexDriverControl( nBoneFlexDriver );
}*/
g_CombinerWriter.AlignWrite( 4 );
}
}
}
void CModelCombine::CombineMDL_AssignMeshIDs( )
{
int i;
int j;
int m;
int numMeshes;
mstudiobodyparts_t *pStudioBodyPart;
mstudiomodel_t *pStudioModel;
mstudiomesh_t *pStudioMesh;
numMeshes = 0;
for (i=0; i<m_pCombinedStudioHdr->numbodyparts; i++)
{
pStudioBodyPart = m_pCombinedStudioHdr->pBodypart(i);
for (j=0; j<pStudioBodyPart->nummodels; j++)
{
pStudioModel = pStudioBodyPart->pModel(j);
for (m=0; m<pStudioModel->nummeshes; m++)
{
// get each mesh
pStudioMesh = pStudioModel->pMesh(m);
pStudioMesh->meshid = numMeshes + m;
}
numMeshes += pStudioModel->nummeshes;
}
}
}
void CModelCombine::CombineMDL( bool bNoStringTable )
{
g_CombinerWriter.AllocWrite( 256 );
g_CombinerWriter.AlignWrite( 16 );
g_CombinerWriter.InitWriteArea( WRITE_AREA_MDL, g_CombinerWriter.GetWritePos() );
g_CombinerWriter.SetWriteArea( WRITE_AREA_MDL );
m_nFlexModelSource = -1;
studiohdr_t *pPrimaryStudioHdr = m_pStudioHdr[ 0 ];
m_pCombinedStudioHdr = ( studiohdr_t * )g_CombinerWriter.WriteBuffer( pPrimaryStudioHdr, sizeof( *pPrimaryStudioHdr ) );
m_pCombinedStudioHdr2 = ( studiohdr2_t * )g_CombinerWriter.WriteBufferWithOffset( pPrimaryStudioHdr->pStudioHdr2(), sizeof( studiohdr2_t ), m_pCombinedStudioHdr->studiohdr2index );
m_pCombinedStudioHdr->flags |= STUDIOHDR_FLAGS_COMBINED;
BeginStringTable();
CombineMDL_PreintStrings();
AddToStringTable( m_pCombinedStudioHdr2, &m_pCombinedStudioHdr2->sznameindex, m_pStudioHdr2[ 0 ]->pszName() );
CombineMDL_Bones();
CombineMDL_Anims();
CombineMDL_SequenceInfo();
CombineMDL_Model();
CombineMDL_Textures();
CombineMDL_KeyValues();
CombineMDL_BoneTransforms();
CombineMDL_BoneFlexDrivers();
// int nStringOffset = m_pWritePos - m_pWriteArea;
// const char *pszOrigStrings = ( ( char * ) m_pStudioHdr[ 0 ] ) + nStringOffset;
// const char *pszNewStrings = ( char * )m_pWritePos;
if ( !bNoStringTable )
{
WriteStringTable();
}
int nTotal = g_CombinerWriter.GetWritePos() - g_CombinerWriter.GetWriteArea();
m_pCombinedStudioHdr->length = nTotal;
m_pCombinedStudioHdr->checksum = 0;
for ( int i = 0; i < nTotal; i += 4 )
{
// TODO: does this need something more than a simple shift left and add checksum?
m_pCombinedStudioHdr->checksum = ( m_pCombinedStudioHdr->checksum << 1 ) +
( ( m_pCombinedStudioHdr->checksum & 0x8000000 ) ? 1 : 0 ) + *( ( long * )( g_CombinerWriter.GetWriteArea() + i ) );
}
m_pCombinedHardwareHeader->checkSum = m_pCombinedStudioHdr->checksum;
m_pCombinedVertex->checksum = m_pCombinedStudioHdr->checksum;
CombineMDL_AssignMeshIDs();
}
#ifdef DEBUG_COMBINE
void CModelCombine::TestCombineMDL( )
{
int nLength = m_pCombinedStudioHdr->length;
char *pOrig = ( char * )m_pStudioHdr[ 0 ];
char *pNew = ( char * )m_pCombinedStudioHdr;
char *pStart = pNew;
if ( nLength != m_pStudioHdr[ 0 ]->length )
{
Msg( "Test Failure: Original Length: %d, New Length: %d\n", m_pStudioHdr[ 0 ]->length, nLength );
if ( nLength > m_pStudioHdr[ 0 ]->length )
{
nLength = m_pStudioHdr[ 0 ]->length;
}
}
int nOffset = sizeof( studiohdr_t ) + sizeof( studiohdr2_t );
nLength -= nOffset;
pOrig += nOffset;
pNew += nOffset;
char *pErrorPos = NULL;
for( ; nLength; pOrig++, pNew++, nLength-- )
{
if ( ( *pOrig ) != ( *pNew ) )
{
pErrorPos = pNew;
break;
}
}
if ( pErrorPos != NULL )
{
Msg( "Test Failure: Offset %d\n", pNew - pStart );
Init( m_pCombinedStudioData );
m_pErrorPos = pErrorPos;
// need to do VVD and VTX to recreate memory
CombineVVD();
CombineVTX();
CombineMDL( true );
}
}
#endif // DEBUG_COMBINE
void CModelCombine::CalcVTXInfo()
{
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
OptimizedModel::FileHeader_t *pOrigHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ nModel ]->PeekGet();
if ( pOrigHeader->numBodyParts > m_MaxHardwareData.m_nMaxBodyParts )
{
m_MaxHardwareData.m_nMaxBodyParts = pOrigHeader->numBodyParts;
}
for( int nBodyPart = 0; nBodyPart < pOrigHeader->numBodyParts; nBodyPart++ )
{
OptimizedModel::BodyPartHeader_t *pOrigBodyPart = pOrigHeader->pBodyPart( nBodyPart );
int nSubModelToUse = m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection;
for( int nBodyModel = 0; nBodyModel < pOrigBodyPart->numModels; nBodyModel++ )
{
// skip over sub models that are not the selected one (-1 no selection, so no skipping)
if ( nSubModelToUse != -1 && nBodyModel != nSubModelToUse )
{
continue;
}
OptimizedModel::ModelHeader_t *pOrigModel = pOrigBodyPart->pModel( nBodyModel );
for ( int nLOD = 0; nLOD < pOrigModel->numLODs; nLOD++ )
{
OptimizedModel::ModelLODHeader_t *pOrigLOD = pOrigModel->pLOD( nLOD );
unsigned char nStripGroupFlags = OptimizedModel::STRIPGROUP_IS_HWSKINNED;
for (int i = 0; i < 2; i++ )
{
if ( i > 0 )
{
nStripGroupFlags |= OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED;
}
for( int nMesh = 0; nMesh < pOrigLOD->numMeshes; nMesh++ )
{
OptimizedModel::MeshHeader_t *pOrigMesh = pOrigLOD->pMesh( nMesh );
bool bUsed = false;
for( int nStripGroup = 0; nStripGroup < pOrigMesh->numStripGroups; nStripGroup++ )
{
OptimizedModel::StripGroupHeader_t *pOrigStripGroup = pOrigMesh->pStripGroup( nStripGroup );
if ( pOrigStripGroup->flags == nStripGroupFlags )
{ // we are compatible
for( int nStrip = 0; nStrip < pOrigStripGroup->numStrips; nStrip++ )
{
OptimizedModel::StripHeader_t *pOrigStrip = pOrigStripGroup->pStrip( nStrip );
if ( pOrigStrip->numTopologyIndices > 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "strip has topology indices" );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
m_MaxHardwareData.m_nBoneStateChanges += pOrigStrip->numBoneStateChanges;
m_MaxHardwareData.m_nIndices += pOrigStrip->numIndices;
m_MaxHardwareData.m_nVerts += pOrigStrip->numVerts;
m_MaxHardwareData.m_nStrips++;
}
bUsed = true;
}
}
if ( bUsed )
{ // we put things into this strip group
m_MaxHardwareData.m_nStripGroups++;
}
}
}
m_MaxHardwareData.m_nModelLODs++;
}
}
m_MaxHardwareData.m_nBodyParts++;
}
}
}
void CModelCombine::WriteStrip( OptimizedModel::StripGroupHeader_t *pNewStripGroup,
int nModel, OptimizedModel::StripGroupHeader_t *pOrigStripGroup, OptimizedModel::StripHeader_t *pOrigStrip )
{
OptimizedModel::Vertex_t *pNewVert = pNewStripGroup->pVertex( pNewStripGroup->numVerts );
// OptimizedModel::Vertex_t *pOrigVert = pOrigStripGroup->pVertex( pOrigStrip->vertOffset );
unsigned short *pNewIndex = pNewStripGroup->pIndex( pNewStripGroup->numIndices );
unsigned short *pOrigIndex = pOrigStripGroup->pIndex( pOrigStrip->indexOffset );
OptimizedModel::StripHeader_t *pNewStrip = pNewStripGroup->pStrip( pNewStripGroup->numStrips );
if ( pOrigStrip->numTopologyIndices > 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "strip has topology indices" );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
Assert( m_CurrentHardwareData.m_nStrips < m_MaxHardwareData.m_nStrips );
pNewStrip->numIndices = pOrigStrip->numIndices;
pNewStrip->numTopologyIndices = pOrigStrip->numTopologyIndices;
pNewStrip->indexOffset = pNewStripGroup->numIndices;
pNewStrip->topologyOffset = pNewStripGroup->numTopologyIndices;
pNewStrip->numVerts = pOrigStrip->numVerts;
pNewStrip->vertOffset = pNewStripGroup->numVerts;
pNewStrip->numBoneStateChanges = pOrigStrip->numBoneStateChanges;
pNewStrip->numBones = pOrigStrip->numBones;
pNewStrip->flags = pOrigStrip->flags;
int boneFileOffset = m_HardwareOffsets.m_nBoneStateChanges + m_CurrentHardwareData.m_nBoneStateChanges * sizeof( OptimizedModel::BoneStateChangeHeader_t );
int stripFileOffset = m_HardwareOffsets.m_nStrips + m_CurrentHardwareData.m_nStrips * sizeof( OptimizedModel::StripHeader_t );
pNewStrip->boneStateChangeOffset = boneFileOffset - stripFileOffset;
int nOffset = pNewStripGroup->numVerts - pOrigStrip->vertOffset;
for( int nIndex = 0; nIndex < pOrigStrip->numIndices; nIndex++ )
{
*pNewIndex = ( *pOrigIndex ) + nOffset;
Assert( ( *pNewIndex ) >= pNewStrip->vertOffset );
Assert( ( *pNewIndex ) < pNewStrip->vertOffset + pNewStrip->numVerts );
pOrigIndex++;
pNewIndex++;
}
// OptimizedModel::Vertex_t *pTestVert = pOrigStripGroup->pVertex( 0 );
// OptimizedModel::FileHeader_t *pPrimaryHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ 0 ]->PeekGet();
// Msg( "%d / %d\n", ( char * )pNewVert - ( char * )m_pCombinedHardwareHeader, ( char * )pTestVert - ( char * )pPrimaryHeader );
for( int nVert = 0; nVert < pOrigStrip->numVerts; nVert++ )
{
OptimizedModel::Vertex_t *pOrigVert = pOrigStripGroup->pVertex( nVert + pOrigStrip->vertOffset );
*pNewVert = *pOrigVert;
pNewVert->origMeshVertID = m_nVertexRemap[ nModel ][ pOrigVert->origMeshVertID ];
pNewVert++;
}
// pTestVert = pOrigStripGroup->pVertex( pOrigStrip->numVerts );
// Msg( "%d / %d\n", ( char * )pNewVert - ( char * )m_pCombinedHardwareHeader, ( char * )pTestVert - ( char * )pPrimaryHeader );
for( int nBone = 0; nBone < pOrigStrip->numBoneStateChanges; nBone++ )
{
OptimizedModel::BoneStateChangeHeader_t *pNewBone = pNewStrip->pBoneStateChange( nBone );
OptimizedModel::BoneStateChangeHeader_t *pOrigBone = pOrigStrip->pBoneStateChange( nBone );
pNewBone->hardwareID = pOrigBone->hardwareID;
pNewBone->newBoneID = m_nBoneRemap[ nModel ][ pOrigBone->newBoneID ];
}
m_CurrentHardwareData.m_nBoneStateChanges += pNewStrip->numBoneStateChanges;
pNewStripGroup->numIndices += pOrigStrip->numIndices;
m_CurrentHardwareData.m_nIndices += pOrigStrip->numIndices;
pNewStripGroup->numVerts += pOrigStrip->numVerts;
m_CurrentHardwareData.m_nVerts += pOrigStrip->numVerts;
pNewStripGroup->numStrips++;
m_CurrentHardwareData.m_nStrips++;
}
void CModelCombine::MergeStripGroup( int nLOD, OptimizedModel::StripGroupHeader_t *pNewStripGroup, int nModel, OptimizedModel::StripGroupHeader_t *pOrigStripGroup )
{
// OptimizedModel::Vertex_t *pNewVert = pNewStripGroup->pVertex( pNewStripGroup->numVerts );
// unsigned short *pNewIndex = pNewStripGroup->pIndex( pNewStripGroup->numIndices );
// OptimizedModel::StripHeader_t *pNewStrip = pNewStripGroup->pStrip( pNewStripGroup->numStrips );
for( int nStrip = 0; nStrip < pOrigStripGroup->numStrips; nStrip++ )
{
OptimizedModel::StripHeader_t *pOrigStrip = pOrigStripGroup->pStrip( nStrip );
WriteStrip( pNewStripGroup, nModel, pOrigStripGroup, pOrigStrip );
m_pCombinedStudioData->m_Results.m_nNumIndexes[ nModel ][ nLOD ] += pOrigStrip->numIndices;
}
m_pCombinedStudioData->m_Results.m_nBatches[ nModel ][ nLOD ] += pOrigStripGroup->numStrips;
m_pCombinedStudioData->m_Results.m_nCombinedBatches[ nLOD ] += pOrigStripGroup->numStrips;
}
void CModelCombine::WriteStripGroup( int nLOD, int nMaterialIndex, unsigned char nStripGroupFlags, OptimizedModel::MeshHeader_t *pNewMesh )
{
OptimizedModel::StripGroupHeader_t *pNewStripGroup = pNewMesh->pStripGroup( pNewMesh->numStripGroups );
pNewStripGroup->numVerts = 0;
pNewStripGroup->numIndices = 0;
pNewStripGroup->numTopologyIndices = 0;
pNewStripGroup->numStrips = 0;
pNewStripGroup->flags = nStripGroupFlags;
int stripGroupFileOffset = m_HardwareOffsets.m_nStripGroups + m_CurrentHardwareData.m_nStripGroups * sizeof( OptimizedModel::StripGroupHeader_t );
int vertsFileOffset = m_HardwareOffsets.m_nVerts + m_CurrentHardwareData.m_nVerts * sizeof( OptimizedModel::Vertex_t );
int indicesFileOffset = m_HardwareOffsets.m_nIndices + m_CurrentHardwareData.m_nIndices * sizeof( unsigned short );
int topologyFileOffset = m_HardwareOffsets.m_nTopology + m_CurrentHardwareData.m_nTopology * sizeof( unsigned short );
int stripsFileOffset = m_HardwareOffsets.m_nStrips + m_CurrentHardwareData.m_nStrips * sizeof( OptimizedModel::StripHeader_t );
pNewStripGroup->vertOffset = vertsFileOffset - stripGroupFileOffset;
pNewStripGroup->indexOffset = indicesFileOffset - stripGroupFileOffset;
pNewStripGroup->topologyOffset = topologyFileOffset - stripGroupFileOffset;
pNewStripGroup->stripOffset = stripsFileOffset - stripGroupFileOffset;
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
OptimizedModel::FileHeader_t *pOrigHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ nModel ]->PeekGet();
for( int nBodyPart = 0; nBodyPart < pOrigHeader->numBodyParts; nBodyPart++ )
{
OptimizedModel::BodyPartHeader_t *pOrigBodyPart = pOrigHeader->pBodyPart( nBodyPart );
int nSubModelToUse = m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection;
for( int nBodyModel = 0; nBodyModel < pOrigBodyPart->numModels; nBodyModel++ )
{
// skip over sub models that are not the selected one (-1 no selection, so no skipping)
if ( nSubModelToUse != -1 && nBodyModel != nSubModelToUse )
{
continue;
}
OptimizedModel::ModelHeader_t *pOrigModel = pOrigBodyPart->pModel( nBodyModel );
int nPickLOD = nLOD;
if ( nLOD >= pOrigModel->numLODs )
{
nPickLOD = pOrigModel->numLODs - 1;
}
OptimizedModel::ModelLODHeader_t *pOrigLOD = pOrigModel->pLOD( nPickLOD );
for( int nMesh = 0; nMesh < pOrigLOD->numMeshes; nMesh++ )
{
OptimizedModel::MeshHeader_t *pOrigMesh = pOrigLOD->pMesh( nMesh );
// determine the new material index
int nOriginalMaterialIndex = m_pCombinedStudioData->m_MeshToMaterialMap[ nModel ][ nBodyPart ][ nMesh ];
int nNewMaterialIndex = GetTextureCombiner().GetAtlasGroupIndex( nOriginalMaterialIndex );
if ( nNewMaterialIndex == -1 )
{
nNewMaterialIndex = m_pCombinedStudioData->m_nNumAtlasGroups + GetTextureCombiner().GetAtlasGroupMaterialIndex( nOriginalMaterialIndex );
}
if ( nMaterialIndex == nNewMaterialIndex )
{
for( int nStripGroup = 0; nStripGroup < pOrigMesh->numStripGroups; nStripGroup++ )
{
OptimizedModel::StripGroupHeader_t *pOrigStripGroup = pOrigMesh->pStripGroup( nStripGroup );
if ( pOrigStripGroup->flags == pNewStripGroup->flags )
{ // we are compatible
MergeStripGroup( nLOD, pNewStripGroup, nModel, pOrigStripGroup );
}
}
}
}
}
}
}
m_pCombinedStudioData->m_Results.m_nCombinedNumIndexes[ nLOD ] += pNewStripGroup->numIndices;
if ( pNewStripGroup->numIndices )
{ // we put things into this strip group
pNewMesh->numStripGroups++;
m_CurrentHardwareData.m_nStripGroups++;
}
}
void CModelCombine::WriteMeshes( int nLOD, int nMaterialIndex, OptimizedModel::ModelLODHeader_t *pNewModelLOD, OptimizedModel::ModelLODHeader_t *pOrigModelLOD )
{
OptimizedModel::MeshHeader_t *pNewMesh = pNewModelLOD->pMesh( pNewModelLOD->numMeshes );
OptimizedModel::MeshHeader_t *pOrigMesh = pOrigModelLOD->pMesh( 0 );
int meshFileOffset = m_HardwareOffsets.m_nMeshes + m_CurrentHardwareData.m_nMeshes * sizeof( OptimizedModel::MeshHeader_t );
int stripGroupFileOffset = m_HardwareOffsets.m_nStripGroups + m_CurrentHardwareData.m_nStripGroups * sizeof( OptimizedModel::StripGroupHeader_t );
pNewMesh->stripGroupHeaderOffset = stripGroupFileOffset - meshFileOffset;
pNewMesh->flags = pOrigMesh->flags;
WriteStripGroup( nLOD, nMaterialIndex, OptimizedModel::STRIPGROUP_IS_HWSKINNED, pNewMesh );
WriteStripGroup( nLOD, nMaterialIndex, OptimizedModel::STRIPGROUP_IS_HWSKINNED | OptimizedModel::STRIPGROUP_IS_DELTA_FLEXED, pNewMesh );
pNewModelLOD->numMeshes++;
m_CurrentHardwareData.m_nMeshes++;
}
void CModelCombine::WriteModelLOD( int nLOD, OptimizedModel::ModelHeader_t *pNewModel, OptimizedModel::ModelHeader_t *pOrigModel )
{
OptimizedModel::ModelLODHeader_t *pNewModelLOD = pNewModel->pLOD( m_CurrentHardwareData.m_nModelLODs );
OptimizedModel::ModelLODHeader_t *pOrigModelLOD = pOrigModel->pLOD( nLOD );
int lodFileOffset = m_HardwareOffsets.m_nModelLODs + m_CurrentHardwareData.m_nModelLODs * sizeof( OptimizedModel::ModelLODHeader_t );
int meshFileOffset = m_HardwareOffsets.m_nMeshes + m_CurrentHardwareData.m_nMeshes * sizeof( OptimizedModel::MeshHeader_t );
pNewModelLOD->meshOffset = meshFileOffset - lodFileOffset;
int nTotalMaterials = m_pCombinedStudioData->m_nNumAtlasGroups + m_pCombinedStudioData->m_nNumNonAtlasedMaterialBaseNames;
for ( int nMaterialIndex = 0; nMaterialIndex < nTotalMaterials; nMaterialIndex++ )
{
WriteMeshes( nLOD, nMaterialIndex, pNewModelLOD, pOrigModelLOD );
}
m_CurrentHardwareData.m_nModelLODs++;
}
void CModelCombine::WriteModel( int nBodyModel, OptimizedModel::BodyPartHeader_t *pNewBodyPart, OptimizedModel::BodyPartHeader_t *pOrigBodyPart )
{
OptimizedModel::ModelHeader_t *pNewModel = pNewBodyPart->pModel( m_CurrentHardwareData.m_nModels );
OptimizedModel::ModelHeader_t *pOrigModel = pOrigBodyPart->pModel( nBodyModel );
pNewModel->numLODs = pOrigModel->numLODs;
int modelFileOffset = m_HardwareOffsets.m_nModels + m_CurrentHardwareData.m_nModels * sizeof( OptimizedModel::ModelHeader_t );
int lodFileOffset = m_HardwareOffsets.m_nModelLODs + m_CurrentHardwareData.m_nModelLODs * sizeof( OptimizedModel::ModelLODHeader_t );
pNewModel->lodOffset = lodFileOffset - modelFileOffset;
for( int nLOD = 0; nLOD < pOrigModel->numLODs; nLOD++ )
{
WriteModelLOD( nLOD, pNewModel, pOrigModel );
}
m_CurrentHardwareData.m_nModels++;
pNewBodyPart->numModels++;
}
void CModelCombine::WriteBodyPart( int nBodyPart )
{
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
OptimizedModel::FileHeader_t *pOrigHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ nModel ]->PeekGet();
if ( pOrigHeader->numBodyParts > nBodyPart )
{
OptimizedModel::BodyPartHeader_t *pOrigBodyPart = pOrigHeader->pBodyPart( nBodyPart );
OptimizedModel::BodyPartHeader_t *pNewBodyPart = m_pCombinedHardwareHeader->pBodyPart( nBodyPart );
pNewBodyPart->numModels = 0;
int bodyPartOffset = m_HardwareOffsets.m_nBodyParts + m_CurrentHardwareData.m_nBodyParts * sizeof( OptimizedModel::BodyPartHeader_t );
int modelFileOffset = m_HardwareOffsets.m_nModels + m_CurrentHardwareData.m_nModels * sizeof( OptimizedModel::ModelHeader_t );
pNewBodyPart->modelOffset = modelFileOffset - bodyPartOffset;
int nBodyModel = ( m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection != -1 ) ? m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection : 0;
WriteModel( nBodyModel, pNewBodyPart, pOrigBodyPart );
break;
}
}
m_CurrentHardwareData.m_nBodyParts++;
}
void CModelCombine::CombineVTX( )
{
int nMaxSize = 0;
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
nMaxSize += VTX_Data[ nModel ]->TellMaxPut();
}
g_CombinerWriter.AllocWrite( 256 );
g_CombinerWriter.AlignWrite( 16 );
g_CombinerWriter.InitWriteArea( WRITE_AREA_VTX, g_CombinerWriter.GetWritePos() );
g_CombinerWriter.SetWriteArea( WRITE_AREA_VTX );
OptimizedModel::FileHeader_t *pPrimaryHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ 0 ]->PeekGet();
// m_pCombinedHardwareHeader = ( OptimizedModel::FileHeader_t * )g_CombinerWriter.WriteBuffer( pPrimaryHeader, VTX_Data[ 0 ]->TellMaxPut() );
// return;
m_pCombinedHardwareHeader = ( OptimizedModel::FileHeader_t * )g_CombinerWriter.AllocWrite( sizeof( *m_pCombinedHardwareHeader ) );
m_pCombinedHardwareHeader->version = pPrimaryHeader->version;
m_pCombinedHardwareHeader->vertCacheSize = pPrimaryHeader->vertCacheSize;
m_pCombinedHardwareHeader->maxBonesPerStrip = pPrimaryHeader->maxBonesPerStrip;
m_pCombinedHardwareHeader->maxBonesPerFace = pPrimaryHeader->maxBonesPerFace;
m_pCombinedHardwareHeader->maxBonesPerVert = pPrimaryHeader->maxBonesPerVert;
m_pCombinedHardwareHeader->numLODs = pPrimaryHeader->numLODs;
// figure out the worst case scenario - we'll have some blank spots in the file, but should be minimal
memset( &m_MaxHardwareData, 0, sizeof( m_MaxHardwareData ) );
memset( &m_CurrentHardwareData, 0, sizeof( m_CurrentHardwareData ) );
memset( &m_HardwareOffsets, 0, sizeof( m_HardwareOffsets ) );
CalcVTXInfo();
m_pCombinedHardwareHeader->numBodyParts = m_MaxHardwareData.m_nMaxBodyParts;
m_MaxHardwareData.m_nStripGroups++; // we need to reserve space for temp writing
m_HardwareOffsets.m_nBodyParts = sizeof( OptimizedModel::FileHeader_t );
m_HardwareOffsets.m_nModels = m_HardwareOffsets.m_nBodyParts + sizeof( OptimizedModel::BodyPartHeader_t ) * m_MaxHardwareData.m_nBodyParts;
m_HardwareOffsets.m_nModelLODs = m_HardwareOffsets.m_nModels + sizeof( OptimizedModel::ModelHeader_t ) * m_MaxHardwareData.m_nModels;
m_HardwareOffsets.m_nMeshes = m_HardwareOffsets.m_nModelLODs + sizeof( OptimizedModel::ModelLODHeader_t ) * m_MaxHardwareData.m_nModelLODs;
m_HardwareOffsets.m_nStripGroups = m_HardwareOffsets.m_nMeshes + sizeof( OptimizedModel::MeshHeader_t ) * m_MaxHardwareData.m_nMeshes;
m_HardwareOffsets.m_nStrips = m_HardwareOffsets.m_nStripGroups + sizeof( OptimizedModel::StripGroupHeader_t ) * m_MaxHardwareData.m_nStripGroups;
m_HardwareOffsets.m_nVerts = m_HardwareOffsets.m_nStrips + sizeof( OptimizedModel::StripHeader_t ) * m_MaxHardwareData.m_nStrips;
m_HardwareOffsets.m_nIndices = m_HardwareOffsets.m_nVerts + sizeof( OptimizedModel::Vertex_t ) * m_MaxHardwareData.m_nVerts;
m_HardwareOffsets.m_nBoneStateChanges = m_HardwareOffsets.m_nIndices + sizeof( unsigned short ) * m_MaxHardwareData.m_nIndices;
m_HardwareOffsets.m_nStringTable = m_HardwareOffsets.m_nBoneStateChanges + sizeof( OptimizedModel::BoneStateChangeHeader_t ) * m_MaxHardwareData.m_nBoneStateChanges;
m_HardwareOffsets.m_nMaterialReplacements = m_HardwareOffsets.m_nStringTable + 0;
g_CombinerWriter.AllocWrite( m_HardwareOffsets.m_nMaterialReplacements - m_HardwareOffsets.m_nModels );
m_pCombinedHardwareHeader->bodyPartOffset = m_HardwareOffsets.m_nBodyParts;
for( int nBodyPart = 0; nBodyPart < m_MaxHardwareData.m_nMaxBodyParts; nBodyPart++ )
{
WriteBodyPart( nBodyPart );
}
for( int nLOD = 1; nLOD < m_pCombinedVertex->numLODs; nLOD++ )
{
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
if ( m_pCombinedStudioData->m_Results.m_nNumIndexes[ nModel ][ nLOD ] > m_pCombinedStudioData->m_Results.m_nNumIndexes[ nModel ][ nLOD - 1 ] )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "%s has lower LOD which has higher triangle count\n", m_pStudioHdr[ nModel ]->pszName() );
m_pCombinedStudioData->m_Results.m_nDetailedError = COMBINED_DETAIL_ERROR_MODEL_LOWER_LOD_HIGHER_TRI_COUNT;
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorDetails, "Model %s\nLOD %d Tris %d\nLOD %d Tris %d\n", m_pStudioHdr[ nModel ]->pszName(), nLOD - 1, m_pCombinedStudioData->m_Results.m_nNumIndexes[ nModel ][ nLOD - 1 ] / 3,
nLOD, m_pCombinedStudioData->m_Results.m_nNumIndexes[ nModel ][ nLOD ] / 3 );
throw( COMBINE_RESULT_FLAG_FAILED_GOOD_PRACTICE );
}
}
}
m_pCombinedHardwareHeader->materialReplacementListOffset = m_HardwareOffsets.m_nMaterialReplacements;
g_CombinerWriter.AllocWrite( pPrimaryHeader->numLODs * sizeof( OptimizedModel::MaterialReplacementListHeader_t ) );
for( int nLOD = 0; nLOD < pPrimaryHeader->numLODs; nLOD++ )
{
OptimizedModel::MaterialReplacementListHeader_t *pNewMaterialReplacementList = m_pCombinedHardwareHeader->pMaterialReplacementList( nLOD );
OptimizedModel::MaterialReplacementListHeader_t *pOrigMaterialReplacementList = pPrimaryHeader->pMaterialReplacementList( nLOD );
pNewMaterialReplacementList->numReplacements = pOrigMaterialReplacementList->numReplacements;
g_CombinerWriter.WriteOffset( pNewMaterialReplacementList->replacementOffset, pNewMaterialReplacementList );
if ( pOrigMaterialReplacementList->numReplacements > 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "material has replacements" );
throw( COMBINE_RESULT_FLAG_UNSUPPORTED_FEATURE );
}
}
#ifdef TEST_VTX_COMBINE
TestCombineVTX();
#endif // TEST_VTX_COMBINE
// int nSize = Min( 48916, VTX_Data[ 0 ]->TellMaxPut() );
// memcpy( m_pCombinedHardwareHeader, VTX_Data[ 0 ]->PeekGet(), nSize );
// memcpy( ( char * )m_pCombinedHardwareHeader + 48916, ( char * )VTX_Data[ 0 ]->PeekGet() + 48916, 688 );
// g_CombinerWriter.AlignWrite( 128 );
// m_pCombinedHardwareHeader = ( OptimizedModel::FileHeader_t * )g_CombinerWriter.WriteBuffer( VTX_Data[ 0 ]->PeekGet(), VTX_Data[ 0 ]->TellMaxPut() );
}
#ifdef DEBUG_COMBINE
void CModelCombine::TestCombineVTX( )
{
OptimizedModel::FileHeader_t *pPrimaryHeader = ( OptimizedModel::FileHeader_t * )VTX_Data[ 0 ]->PeekGet();
Assert( pPrimaryHeader->version == m_pCombinedHardwareHeader->version );
Assert( pPrimaryHeader->vertCacheSize == m_pCombinedHardwareHeader->vertCacheSize );
Assert( pPrimaryHeader->maxBonesPerStrip == m_pCombinedHardwareHeader->maxBonesPerStrip );
Assert( pPrimaryHeader->maxBonesPerFace == m_pCombinedHardwareHeader->maxBonesPerFace );
Assert( pPrimaryHeader->maxBonesPerVert == m_pCombinedHardwareHeader->maxBonesPerVert );
Assert( pPrimaryHeader->numLODs == m_pCombinedHardwareHeader->numLODs );
Assert( pPrimaryHeader->numBodyParts == m_pCombinedHardwareHeader->numBodyParts );
for( int nBodyPart = 0; nBodyPart < pPrimaryHeader->numBodyParts; nBodyPart++ )
{
OptimizedModel::BodyPartHeader_t *pOrigBodyPart = pPrimaryHeader->pBodyPart( nBodyPart );
OptimizedModel::BodyPartHeader_t *pNewBodyPart = m_pCombinedHardwareHeader->pBodyPart( nBodyPart );
Assert( pOrigBodyPart->numModels == pNewBodyPart->numModels );
for( int nModel = 0; nModel < pOrigBodyPart->numModels; nModel++ )
{
OptimizedModel::ModelHeader_t *pOrigModel = pOrigBodyPart->pModel( nModel );
OptimizedModel::ModelHeader_t *pNewModel = pNewBodyPart->pModel( nModel );
Assert( pOrigModel->numLODs == pNewModel->numLODs );
for( int nLOD = 0; nLOD < pOrigModel->numLODs; nLOD++ )
{
OptimizedModel::ModelLODHeader_t *pOrigLOD = pOrigModel->pLOD( nLOD );
OptimizedModel::ModelLODHeader_t *pNewLOD = pNewModel->pLOD( nLOD );
Assert( pOrigLOD->numMeshes == pNewLOD->numMeshes );
Assert( pOrigLOD->switchPoint == pNewLOD->switchPoint );
for( int nMesh = 0; nMesh < pOrigLOD->numMeshes; nMesh++ )
{
OptimizedModel::MeshHeader_t *pOrigMesh = pOrigLOD->pMesh( nMesh );
OptimizedModel::MeshHeader_t *pNewMesh = pNewLOD->pMesh( nMesh );
Assert( pOrigMesh->numStripGroups == pNewMesh->numStripGroups );
Assert( pOrigMesh->flags == pNewMesh->flags );
for( int nStripGroup = 0; nStripGroup < pOrigMesh->numStripGroups; nStripGroup++ )
{
OptimizedModel::StripGroupHeader_t *pOrigStripGroup = pOrigMesh->pStripGroup( nStripGroup );
OptimizedModel::StripGroupHeader_t *pNewStripGroup = pNewMesh->pStripGroup( nStripGroup );
Assert( pOrigStripGroup->numVerts == pNewStripGroup->numVerts );
Assert( pOrigStripGroup->numIndices == pNewStripGroup->numIndices );
Assert( pOrigStripGroup->numStrips == pNewStripGroup->numStrips );
Assert( pOrigStripGroup->flags == pNewStripGroup->flags );
Assert( pOrigStripGroup->numTopologyIndices == pNewStripGroup->numTopologyIndices );
for( int nNumVerts = 0; nNumVerts < pOrigStripGroup->numVerts; nNumVerts++ )
{
OptimizedModel::Vertex_t *pOrigVertex = pOrigStripGroup->pVertex( nNumVerts );
OptimizedModel::Vertex_t *pNewVertex = pNewStripGroup->pVertex( nNumVerts );
Assert( memcmp( pOrigVertex, pNewVertex, sizeof( *pOrigVertex ) ) == 0 );
}
for( int nStrip = 0; nStrip < pOrigStripGroup->numStrips; nStrip++ )
{
OptimizedModel::StripHeader_t *pOrigStrip = pOrigStripGroup->pStrip( nStrip );
OptimizedModel::StripHeader_t *pNewStrip = pNewStripGroup->pStrip( nStrip );
Assert( pOrigStrip->numIndices == pNewStrip->numIndices );
Assert( pOrigStrip->numVerts == pNewStrip->numVerts );
Assert( pOrigStrip->numBones == pNewStrip->numBones );
Assert( pOrigStrip->flags == pNewStrip->flags );
Assert( pOrigStrip->numBoneStateChanges == pNewStrip->numBoneStateChanges );
Assert( pOrigStrip->numTopologyIndices == pNewStrip->numTopologyIndices );
for( int nBoneStateChange = 0; nBoneStateChange < pOrigStrip->numBoneStateChanges; nBoneStateChange++ )
{
OptimizedModel::BoneStateChangeHeader_t *pOrigBoneStateChange = pOrigStrip->pBoneStateChange( nBoneStateChange );
OptimizedModel::BoneStateChangeHeader_t *pNewBoneStateChange = pNewStrip->pBoneStateChange( nBoneStateChange );
Assert( pOrigBoneStateChange->hardwareID == pNewBoneStateChange->hardwareID );
Assert( pOrigBoneStateChange->newBoneID == pNewBoneStateChange->newBoneID );
}
}
}
}
}
}
}
}
#endif // DEBUG_COMBINE
// this will move a vert belonging to a secondary model from pose space of that secondary model
// into that secondary model's bone space, then transform the vert into pose space of the primary model.
void CModelCombine::CombineVVD_OffsetVerts( )
{
matrix3x4_t VertToPrimaryPose[ COMBINER_MAX_BONES ];
for( int nBone = 0; nBone < m_nNumMasterBones; nBone++ )
{
matrix3x4_t VertToPrimaryBone;
VertToPrimaryBone = m_pMasterBoneList[ nBone ]->poseToBone;
MatrixInvert( VertToPrimaryBone, VertToPrimaryPose[ nBone ] );
}
for( int nModel = 1; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
int nNumVerts = m_pVertexFileHeader[ nModel ]->numLODVertexes[ 0 ];
for( int nVert = 0; nVert < nNumVerts; nVert++ )
{
int nRealVert = m_nVertexRemap[ nModel ][ nVert ];
mstudiovertex_t *pVert = ( mstudiovertex_t * )m_pCombinedVertex->GetVertexData() + nRealVert;
Vector vPosition, vPos, vFinalVert, vFinalNormal, vFinalTangent;
bool bHasTangent = m_pVertexFileHeader[ nModel ]->tangentDataStart != NULL;
vFinalVert.Init();
vFinalNormal.Init();
vFinalTangent.Init();
for( int nBone = 0; nBone < pVert->m_BoneWeights.numbones; nBone++ )
{
int nBoneIndex = pVert->m_BoneWeights.bone[ nBone ];
VectorTransform( pVert->m_vecPosition, m_pStudioHdr[ nModel ]->pBone( m_nMasterToLocalBoneRemap[ nModel ][ nBoneIndex ] )->poseToBone, vPosition );
VectorTransform( vPosition, VertToPrimaryPose[ nBoneIndex ], vPos );
vFinalVert += vPos * pVert->m_BoneWeights.weight[ nBone ];
VectorRotate( pVert->m_vecNormal, m_pStudioHdr[ nModel ]->pBone( m_nMasterToLocalBoneRemap[ nModel ][ nBoneIndex ] )->poseToBone, vPosition );
VectorRotate( vPosition, VertToPrimaryPose[ nBoneIndex ], vPos );
vFinalNormal += vPos * pVert->m_BoneWeights.weight[ nBone ];
if ( bHasTangent )
{
Vector4D vTangent = *( m_pCombinedVertex->GetTangentData() + nRealVert );
VectorRotate( vTangent.AsVector3D(), m_pStudioHdr[ nModel ]->pBone( m_nMasterToLocalBoneRemap[ nModel ][ nBoneIndex ] )->poseToBone, vPosition );
VectorRotate( vPosition, VertToPrimaryPose[ nBoneIndex ], vPos );
vFinalTangent += vPos * pVert->m_BoneWeights.weight[ nBone ];
}
}
pVert->m_vecPosition = vFinalVert;
pVert->m_vecNormal = vFinalNormal;
if ( bHasTangent )
{
Vector *pTangent = ( Vector * )( m_pCombinedVertex->GetTangentData() + nRealVert );
*pTangent = vFinalTangent;
}
}
}
}
void CModelCombine::CombineVVD( )
{
int nVertsWritten[ COMBINER_MAX_MODELS ];
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
int nNumVerts = m_pVertexFileHeader[ nModel ]->numLODVertexes[ 0 ];
m_nVertexRemap[ nModel ] = ( int * )g_CombinerWriter.AllocWrite( sizeof( int ) * nNumVerts );
nVertsWritten[ nModel ] = 0;
}
g_CombinerWriter.AlignWrite( 16 );
g_CombinerWriter.InitWriteArea( WRITE_AREA_VVD, g_CombinerWriter.GetWritePos() );
g_CombinerWriter.SetWriteArea( WRITE_AREA_VVD );
m_pCombinedVertex = ( vertexFileHeader_t * )g_CombinerWriter.AllocWrite( sizeof( *m_pCombinedVertex ) );
m_pCombinedVertex->id = MODEL_VERTEX_FILE_ID;
m_pCombinedVertex->version = MODEL_VERTEX_FILE_VERSION;
m_pCombinedVertex->numLODs = m_pVertexFileHeader[ 0 ]->numLODs;
g_CombinerWriter.WriteOffset( m_pCombinedVertex->vertexDataStart, m_pCombinedVertex );
int nVertOffset = 0;
for( int nLOD = m_pCombinedVertex->numLODs - 1; nLOD >= 0; nLOD-- )
{
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
int nNumVerts = m_pVertexFileHeader[ nModel ]->numLODVertexes[ nLOD ];
m_pCombinedVertex->numLODVertexes[ nLOD ] += m_pVertexFileHeader[ nModel ]->numLODVertexes[ nLOD ];
nNumVerts -= nVertsWritten[ nModel ];
mstudiovertex_t *pNewVertex = ( mstudiovertex_t * )g_CombinerWriter.GetWritePos();
if ( m_pVertexFileHeader[ nModel ]->numFixups > 0 )
{
int nCount = nNumVerts;
int nOffset = nVertsWritten[ nModel ];
int nNumWritten = 0;
const mstudiovertex_t *pOrigVertex = m_pVertexFileHeader[ nModel ]->GetVertexData();
for( int nFixup = 0; nFixup < m_pVertexFileHeader[ nModel ]->numFixups; nFixup++ )
{
vertexFileFixup_t *pOrigFixup = ( vertexFileFixup_t * )( ( byte * )m_pVertexFileHeader[ nModel ] + m_pVertexFileHeader[ nModel ]->fixupTableStart) + nFixup;
if ( pOrigFixup->numVertexes < nOffset )
{
nOffset -= pOrigFixup->numVertexes;
}
else
{
int nSize = pOrigFixup->numVertexes - nOffset;
if ( nSize > nCount )
{
nSize = nCount;
}
g_CombinerWriter.WriteBuffer( pOrigVertex + nOffset, nSize * sizeof( mstudiovertex_t ) );
nOffset = 0;
nCount -= nSize;
nNumWritten += nSize;
if ( nCount == 0 )
{
break;
}
}
}
Assert( nNumWritten == nNumVerts );
}
else
{
g_CombinerWriter.WriteBuffer( m_pVertexFileHeader[ nModel ]->GetVertexData() + nVertsWritten[ nModel ], nNumVerts * sizeof( mstudiovertex_t ) );
}
if ( nModel > 0 )
{ // primary one doesn't need bone remap
mstudiovertex_t *pBoneVertex = pNewVertex;
for( int nVert = 0, nVertIndex = nVertsWritten[ nModel ]; nVert < nNumVerts; nVert++, pBoneVertex++, nVertIndex++ )
{
for( int nBone = 0; nBone < pBoneVertex->m_BoneWeights.numbones; nBone++ )
{
pBoneVertex->m_BoneWeights.bone[ nBone ] = m_nBoneRemap[ nModel ][ pBoneVertex->m_BoneWeights.bone[ nBone ] ];
}
}
}
for( int nBodyBart = 0; nBodyBart < m_pStudioHdr[ nModel ]->numbodyparts; nBodyBart++ )
{
mstudiobodyparts_t *pOrigBodyPart = m_pStudioHdr[ nModel ]->pBodypart( nBodyBart );
int nSubModelToUse = m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection;
for( int nBodyPartModel = 0; nBodyPartModel < pOrigBodyPart->nummodels; nBodyPartModel++ )
{
// skip over sub models that are not the selected one (-1 no selection, so no skipping)
if ( nSubModelToUse != -1 && nBodyPartModel != nSubModelToUse )
{
continue;
}
mstudiomodel_t *pOrigModel = pOrigBodyPart->pModel( nBodyPartModel );
for( int nMesh = 0; nMesh < pOrigModel->nummeshes; nMesh++ )
{
mstudiomesh_t *pOrigMesh = pOrigModel->pMesh( nMesh );
Vector2D vStartST, vSizeST, vPixelSize;
int nTextureIndex = m_pCombinedStudioData->m_nModelMaterialIndices[ nModel ][ nMesh ];
GetTextureCombiner().GetTextureInfo( nTextureIndex, vStartST, vSizeST, vPixelSize );
for( int nVert = 0, nVertIndex = nVertsWritten[ nModel ] + pOrigMesh->vertexoffset; nVert < pOrigMesh->numvertices; nVert++, pNewVertex++, nVertIndex++ )
{
double flInteger;
pNewVertex->m_vecTexCoord.x = ( float )modf( ( double )pNewVertex->m_vecTexCoord.x, &flInteger );
if ( pNewVertex->m_vecTexCoord.x < 0.0f )
{
pNewVertex->m_vecTexCoord.x += 1.0f;
}
pNewVertex->m_vecTexCoord.y = ( float )modf( ( double )pNewVertex->m_vecTexCoord.y, &flInteger );
if ( pNewVertex->m_vecTexCoord.y < 0.0f )
{
pNewVertex->m_vecTexCoord.y += 1.0f;
}
pNewVertex->m_vecTexCoord = ( pNewVertex->m_vecTexCoord * vSizeST );
pNewVertex->m_vecTexCoord += vStartST;
m_nVertexRemap[ nModel ][ nVertIndex ] = nVertOffset + nVert;
}
}
}
}
nVertsWritten[ nModel ] += nNumVerts;
nVertOffset += nNumVerts;
m_pCombinedStudioData->m_Results.m_nNumLODs[ nModel ] = m_pVertexFileHeader[ nModel ]->numLODs;
if ( nLOD < m_pCombinedVertex->numLODs - 1 )
{
m_pCombinedStudioData->m_Results.m_nNumVerts[ nModel ][ nLOD ] = m_pCombinedStudioData->m_Results.m_nNumVerts[ nModel ][ nLOD + 1 ] + nNumVerts;
}
else
{
m_pCombinedStudioData->m_Results.m_nNumVerts[ nModel ][ nLOD ] = nNumVerts;
}
m_pCombinedStudioData->m_Results.m_nCombinedNumVerts[ nLOD ] += nNumVerts;
}
}
m_pCombinedStudioData->m_Results.m_nCombinedNumLODs = m_pCombinedVertex->numLODs;
int nLastLODSize = m_pCombinedVertex->numLODVertexes[ m_pCombinedVertex->numLODs - 1 ];
for( int nLOD = m_pCombinedVertex->numLODs; nLOD < MAX_NUM_LODS; nLOD++ )
{
m_pCombinedVertex->numLODVertexes[ nLOD ] = nLastLODSize;
}
Vector4D *pData = ( Vector4D * )g_CombinerWriter.WriteOffset( m_pCombinedVertex->tangentDataStart, m_pCombinedVertex );
g_CombinerWriter.AllocWrite( m_pCombinedVertex->numLODVertexes[ 0 ] * sizeof( Vector4D ) );
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
if ( m_pVertexFileHeader[ nModel ]->tangentDataStart == 0 )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "vertex file has tangent data" );
throw( COMBINE_RESULT_FLAG_UNHANDLED_ISSUE );
}
const Vector4D *vData = m_pVertexFileHeader[ nModel ]->GetTangentData();
for( int nIndex = 0; nIndex < m_pVertexFileHeader[ nModel ]->numLODVertexes[ 0 ]; nIndex++ )
{
pData[ m_nVertexRemap[ nModel ][ nIndex ] ] = *vData;
vData++;
}
}
CombineVVD_OffsetVerts();
}
#if 0
void CModelCombine::Test( )
{
studiohdr_t *pStudioHdr = m_pStudioHdr[ 0 ];
vertexFileHeader_t *pVertexHeader = ( vertexFileHeader_t * )VVD_Data[ 0 ]->PeekGet();
const mstudiovertex_t *pVertex = pVertexHeader->GetVertexData();
int nTotalModels = 0;
for ( int nBodyPart = 0; nBodyPart < pStudioHdr->numbodyparts; nBodyPart++ )
{
mstudiobodyparts_t *pOrigBodyPart = pStudioHdr->pBodypart( nBodyPart );
for( int nModel = 0; nModel < pOrigBodyPart->nummodels; nModel++ )
{
mstudiomodel_t *pOrigModel = pOrigBodyPart->pModel( nModel );
for( int nMesh = 0; nMesh < pOrigModel->nummeshes; nMesh++ )
{
mstudiomesh_t *pOrigMesh = pOrigModel->pMesh( nMesh );
for( int nVert = 0; nVert < pOrigMesh->numvertices; nVert++ )
{
const mstudiovertex_t *pOrigVert = &pVertex[ nVert + pOrigMesh->vertexoffset ];
Msg("");
}
}
}
}
}
#endif
void CModelCombine::CombineTextures( )
{
GetTextureCombiner().Init( m_pCombinedStudioData );
for( int nModel = 0; nModel < m_pCombinedStudioData->m_nNumModels; nModel++ )
{
#if 0
for( int nSkin = 0; nSkin < m_pStudioHdr[ nModel ]->numskinfamilies; nSkin++ )
{
short *pSkinRef = m_pStudioHdr[ nModel ]->pSkinref( 0 );
pSkinRef += ( nSkin * m_pStudioHdr[ nModel ]->numskinref );
for( int nReference = 0; nReference < m_pStudioHdr[ nModel ]->numskinref; nReference++, pSkinRef++ )
{
int nTextureIndex = *pSkinRef;
const char *pszTextureName = m_pStudioHdr[ nModel ]->pTexture( nTextureIndex )->pszName();
Msg( "SKin %d, Reference %d: %s\n", nSkin, nReference, pszTextureName );
}
}
#endif
int nSkin = m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nSkinFamily;
short *pSkinRef = m_pStudioHdr[ nModel ]->pSkinref( 0 );
if ( nSkin > 0 && nSkin < m_pStudioHdr[ nModel ]->numskinfamilies )
{
pSkinRef += ( nSkin * m_pStudioHdr[ nModel ]->numskinref );
}
for( int nBodyPart = 0; nBodyPart < m_pStudioHdr[ nModel ]->numbodyparts; nBodyPart++ )
{
mstudiobodyparts_t *pOrigBodyPart = m_pStudioHdr[ nModel ]->pBodypart( nBodyPart );
int nSubModelToUse = m_pCombinedStudioData->m_ModelInputData[ nModel ].m_nBodyGroupSubModelSelection;
for( int nBodyPartModel = 0; nBodyPartModel < pOrigBodyPart->nummodels; nBodyPartModel++ )
{
// skip over sub models that are not the selected one (-1 no selection, so no skipping)
if ( nSubModelToUse != -1 && nBodyPartModel != nSubModelToUse )
{
continue;
}
mstudiomodel_t *pOrigModel = pOrigBodyPart->pModel( nBodyPartModel );
m_pCombinedStudioData->m_nModelMaterialCounts[ nModel ] = pOrigModel->nummeshes;
for( int nMesh = 0; nMesh < pOrigModel->nummeshes; nMesh++ )
{
mstudiomesh_t *pOrigMesh = pOrigModel->pMesh( nMesh );
int nTextureIndex = pSkinRef[ pOrigMesh->material ];
m_pCombinedStudioData->m_MeshToMaterialMap[ nModel ][ nBodyPart ][ nMesh ] = nTextureIndex;
m_pCombinedStudioData->m_nModelMaterialIndices[ nModel ][ nMesh ] = AddMaterialToTextureCombiner( nTextureIndex, nModel, pOrigMesh->material );
}
}
}
}
GetTextureCombiner().Resolve();
}
int CModelCombine::AddMaterialToTextureCombiner( int nTextureIndex, int nModel, int nModelMaterialIndex )
{
char szPath[ MAX_PATH ];
char szFinalPath[ MAX_PATH ];
bool bFound = false;
// If we don't do this, we get filenames like "materials\\blah.vmt".
const char *pszTextureName = m_pStudioHdr[ nModel ]->pTexture( nTextureIndex )->pszName();
if ( pszTextureName[ 0 ] == CORRECT_PATH_SEPARATOR || pszTextureName[ 0 ] == INCORRECT_PATH_SEPARATOR )
{
pszTextureName++;
}
// search through all specified directories until a valid material is found
for ( int nSearch = 0; nSearch < m_pStudioHdr[ nModel ]->numcdtextures; nSearch++ )
{
// This prevents filenames like /models/blah.vmt.
const char *pszCDTexture = m_pStudioHdr[ nModel ]->pCdtexture( nSearch );
if ( pszCDTexture[ 0 ] == CORRECT_PATH_SEPARATOR || pszCDTexture[ 0 ] == INCORRECT_PATH_SEPARATOR )
{
pszCDTexture++;
}
V_ComposeFileName( pszCDTexture, pszTextureName, szPath, sizeof( szPath ) );
V_ComposeFileName( "materials/", szPath, szFinalPath, sizeof( szFinalPath ) );
char szCheckPath[ MAX_PATH ];
V_strcpy_safe( szCheckPath, szFinalPath );
V_strcat_safe( szCheckPath, ".vmt" );
if ( g_pFullFileSystem->FileExists( szCheckPath ) )
{
bFound = true;
break;
}
}
if ( bFound == false )
{
Assert( 0 );
V_sprintf_safe( m_pCombinedStudioData->m_Results.m_szErrorMessage, "model %s has missing material %s", m_pStudioHdr[ nModel ]->pszName(), pszTextureName );
throw( COMBINE_RESULT_FLAG_MISSING_ASSET_FILE );
}
return GetTextureCombiner().AddMaterial( szFinalPath );
}
Reference in New Issue Copy Permalink