mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
4018 lines
130 KiB
C++
4018 lines
130 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#pragma warning( disable : 4786 )
|
|
|
|
#pragma warning( disable : 4748 ) // buffer overrun with optimizations off
|
|
// This file has tons of problems with global optimizations. . turn 'em off.
|
|
// NOTE: Would be nice to have a test case for this! - not verified in vs2005
|
|
#pragma optimize( "g", off )
|
|
|
|
// use this much memory to build an output file in memory.
|
|
#define FILEBUFFER_SIZE ( 4 * 1024 * 1024 )
|
|
|
|
//#define IGNORE_BONES
|
|
|
|
#define NVTRISTRIP
|
|
|
|
#define EMIT_TRILISTS
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <float.h>
|
|
#include "mathlib/mathlib.h"
|
|
#include "cmdlib.h"
|
|
#include "studio.h"
|
|
#include "studiomdl.h"
|
|
#include "HardwareMatrixState.h"
|
|
#include "HardwareVertexCache.h"
|
|
#include "optimize.h"
|
|
#include <malloc.h>
|
|
#include <nvtristrip.h>
|
|
#include "FileBuffer.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "tier1/utllinkedlist.h"
|
|
|
|
#include "tier1/smartptr.h"
|
|
#include "tier2/p4helpers.h"
|
|
|
|
bool g_bDumpGLViewFiles;
|
|
extern bool g_IHVTest;
|
|
|
|
// flush bones between strips rather than deallocating the LRU.
|
|
#define USE_FLUSH
|
|
|
|
extern int FindMaterialByName( const char *pMaterialName );
|
|
|
|
namespace OptimizedModel
|
|
{
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Defines which debugging output file we will see
|
|
//-----------------------------------------------------------------------------
|
|
|
|
enum
|
|
{
|
|
WRITEGLVIEW_SHOWMESH = 0x00000001,
|
|
WRITEGLVIEW_SHOWSTRIPGROUP = 0x00000002,
|
|
WRITEGLVIEW_SHOWSTRIP = 0x00000004,
|
|
WRITEGLVIEW_SHOWSUBSTRIP = 0x00000008,
|
|
WRITEGLVIEW_SHOWFLEXED = 0x00000010,
|
|
WRITEGLVIEW_SHOWSW = 0x00000020,
|
|
WRITEGLVIEW_SHOWMESHPROPS = 0x00000040,
|
|
WRITEGLVIEW_SHOWVERTNUMBONES = 0x00000080,
|
|
WRITEGLVIEW_SHOWSTRIPNUMBONES = 0x00000100,
|
|
WRITEGLVIEW_FORCEUINT = 0xffffffff
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is used to help us figure out where in the file data should go
|
|
// and also to display stats
|
|
//-----------------------------------------------------------------------------
|
|
struct TotalMeshStats_t
|
|
{
|
|
int m_TotalBodyParts;
|
|
int m_TotalModels;
|
|
int m_TotalModelLODs;
|
|
int m_TotalMeshes;
|
|
int m_TotalStrips;
|
|
int m_TotalStripGroups;
|
|
int m_TotalVerts;
|
|
int m_TotalIndices;
|
|
int m_TotalBoneStateChanges;
|
|
int m_TotalMaterialReplacements;
|
|
};
|
|
|
|
struct Triangle_t
|
|
{
|
|
Triangle_t()
|
|
{
|
|
touched = false;
|
|
neighborTriID[0] = neighborTriID[1] = neighborTriID[2] = -1;
|
|
}
|
|
int vertID[3];
|
|
int neighborTriID[3];
|
|
int boneID[MAX_NUM_BONES_PER_TRI];
|
|
int numBones;
|
|
bool touched;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Associates software bone indices with hardware bone indices
|
|
//-----------------------------------------------------------------------------
|
|
struct BoneStateChange_t
|
|
{
|
|
int hardwareID;
|
|
int newBoneID;
|
|
};
|
|
|
|
struct Strip_t
|
|
{
|
|
// these are the verts and indices that are used while building.
|
|
// (there may be verts in here that aren't use in the stripGroup.)
|
|
CUtlVector<Vertex_t> verts;
|
|
int numIndices;
|
|
unsigned short *pIndices;
|
|
|
|
unsigned int flags;
|
|
|
|
int numBones;
|
|
|
|
// These are the final, sorted verts as they appear in the strip group.
|
|
int stripGroupIndexOffset; // offset into stripGroup's indices
|
|
int numStripGroupIndices;
|
|
int stripGroupVertexOffset; // offset into stripGroup's verts
|
|
int numStripGroupVerts;
|
|
|
|
int numBoneStateChanges;
|
|
BoneStateChange_t boneStateChanges[MAX_NUM_BONES_PER_STRIP];
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// a list of vertices + triangles for a strip group
|
|
//-----------------------------------------------------------------------------
|
|
|
|
typedef CUtlVector<Vertex_t> VertexList_t;
|
|
typedef CUtlVector<Triangle_t> TriangleList_t;
|
|
typedef CUtlVector<unsigned short> VertexIndexList_t;
|
|
typedef CUtlVector<Strip_t> StripList_t;
|
|
typedef CUtlVector<bool> TriangleProcessedList_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// String table
|
|
//-----------------------------------------------------------------------------
|
|
class CStringTable
|
|
{
|
|
public:
|
|
int StringTableOffset( const char *string )
|
|
{
|
|
int i;
|
|
int size = 0;
|
|
for( i = 0; i < m_Strings.Size(); i++ )
|
|
{
|
|
if( stricmp( m_Strings[i].Base(), string ) == 0 )
|
|
{
|
|
return size;
|
|
}
|
|
size += m_Strings[i].Size();
|
|
}
|
|
return -1;
|
|
}
|
|
bool StringPresent( const char *string )
|
|
{
|
|
int i;
|
|
for( i = 0; i < m_Strings.Size(); i++ )
|
|
{
|
|
if( stricmp( m_Strings[i].Base(), string ) == 0 )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
void AddString( const char *newString )
|
|
{
|
|
if( StringPresent( newString ) )
|
|
{
|
|
return;
|
|
}
|
|
CUtlVector<char> &s = m_Strings[m_Strings.AddToTail()];
|
|
int size = strlen( newString ) + 1;
|
|
s.AddMultipleToTail( size );
|
|
strcpy( s.Base(), newString );
|
|
}
|
|
void Purge()
|
|
{
|
|
m_Strings.Purge();
|
|
}
|
|
int CalcSize( void )
|
|
{
|
|
int size = 0;
|
|
int i;
|
|
for( i = 0; i < m_Strings.Size(); i++ )
|
|
{
|
|
size += m_Strings[i].Size();
|
|
}
|
|
return size;
|
|
}
|
|
void WriteToMem( char *pDst )
|
|
{
|
|
int size = 0;
|
|
int i;
|
|
for( i = 0; i < m_Strings.Size(); i++ )
|
|
{
|
|
#ifdef _DEBUG
|
|
int j = Q_strlen( m_Strings[i].Base() ) + 1;
|
|
int k = m_Strings[i].Size();
|
|
Assert( j == k );
|
|
#endif
|
|
memcpy( pDst + size, m_Strings[i].Base(), m_Strings[i].Size() );
|
|
size += m_Strings[i].Size();
|
|
}
|
|
}
|
|
private:
|
|
typedef CUtlVector<char> CharVector_t;
|
|
CUtlVector<CharVector_t> m_Strings;
|
|
};
|
|
|
|
// global string table for the whole vtx file.
|
|
static CStringTable s_StringTable;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This is all the indices, vertices, and strips that make up this group
|
|
// a group can be rendered all in one call to the material system
|
|
//-----------------------------------------------------------------------------
|
|
|
|
struct StripGroup_t
|
|
{
|
|
VertexIndexList_t indices;
|
|
VertexList_t verts;
|
|
StripList_t strips;
|
|
unsigned int flags;
|
|
};
|
|
|
|
struct Mesh_t
|
|
{
|
|
CUtlVector<StripGroup_t> stripGroups;
|
|
unsigned int flags;
|
|
};
|
|
|
|
struct ModelLOD_t
|
|
{
|
|
CUtlVector<Mesh_t> meshes;
|
|
float switchPoint;
|
|
};
|
|
|
|
struct Model_t
|
|
{
|
|
CUtlVector<ModelLOD_t> modelLODs;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Main class that does all the dirty work to stripy + groupify
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class COptimizedModel
|
|
{
|
|
public:
|
|
bool OptimizeFromStudioHdr( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts, int vertCacheSize,
|
|
bool usesFixedFunction, bool bForceSoftwareSkin, bool bHWFlex, int maxBonesPerVert, int maxBonesPerTri,
|
|
int maxBonesPerStrip, const char *fileName, const char *glViewFileName );
|
|
|
|
private:
|
|
void CleanupEverything();
|
|
|
|
// Setup to get the ball rolling
|
|
void SetupMeshProcessing( studiohdr_t *phdr, int vertCacheSize,
|
|
bool usesFixedFunction, int maxBonesPerVert, int maxBonesPerTri,
|
|
int maxBonesPerStrip, const char *fileName );
|
|
|
|
//
|
|
// Methods associated with pre-processing the mesh
|
|
//
|
|
|
|
//
|
|
// Methods associated with mesh processing
|
|
//
|
|
|
|
void SourceMeshToTriangleList( s_model_t *pSrcModel, s_mesh_t *pSrcMesh, CUtlVector<mstudioiface_t> &meshTriangleList );
|
|
void CreateLODTriangleList( s_model_t *pSrcModel, int nLodID, s_source_t* pLODSource,
|
|
mstudiomodel_t *pStudioModel,
|
|
mstudiomesh_t *pStudioMesh,
|
|
CUtlVector<mstudioiface_t> &meshTriangleList, bool writeDebug );
|
|
|
|
// This processes the model + breaks it into strips
|
|
void ProcessModel( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts, TotalMeshStats_t& stats,
|
|
bool bForceSoftwareSkin, bool bHWFlex );
|
|
|
|
// processes a single mesh within the model
|
|
void ProcessMesh( Mesh_t *pMesh, studiohdr_t *pStudioHeader, CUtlVector<mstudioiface_t> &srcFaces,
|
|
mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, bool ForceNoFlex,
|
|
bool bForceSoftwareSkin, bool bHWFlex );
|
|
|
|
// Processes a single strip group
|
|
void ProcessStripGroup( StripGroup_t *pStripGroup, bool isHWSkinned, bool isFlexed,
|
|
mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh,
|
|
CUtlVector<mstudioiface_t> &srcFaces,
|
|
TriangleProcessedList_t& trianglesProcessed,
|
|
int maxBonesPerVert, int maxBonesPerTri, int maxBonesPerStrip,
|
|
bool forceNoFlex, bool bHWFlex );
|
|
|
|
// Constructs vertices appropriate for a strip group based on source face data
|
|
bool GenerateStripGroupVerticesFromFace( mstudioiface_t* pFace,
|
|
mstudiomesh_t *pStudioMesh, int maxPreferredBones, Vertex_t* pStripGroupVert );
|
|
|
|
// Count the number of unique bones in a set of vertices
|
|
int CountUniqueBones( int count, Vertex_t *pVertex ) const;
|
|
int CountMaxVertBones( int count, Vertex_t *pVertex ) const;
|
|
|
|
// Counts the unique # of bones in a strip
|
|
int CountUniqueBonesInStrip( StripGroup_t *pStripGroup, Strip_t *pStrip );
|
|
|
|
// Builds SW + HW skinned strips
|
|
void BuildSWSkinnedStrips( TriangleList_t& tris,
|
|
VertexList_t const& verts, StripGroup_t *pStripGroup );
|
|
void BuildHWSkinnedStrips( TriangleList_t& tris, VertexList_t& verts,
|
|
StripGroup_t *pStripGroup, int maxBonesPerStrip );
|
|
|
|
// These methods deal with finding another triangle to batch together
|
|
// in a similar matrix state group
|
|
int ComputeNewBonesNeeded( Triangle_t const& triangle ) const;
|
|
bool AllocateHardwareBonesForTriangle( Triangle_t *tri );
|
|
Triangle_t* GetNextTriangle( TriangleList_t& triangles, bool allowNewStrip );
|
|
Triangle_t* GetNextUntouchedWithoutBoneStateChange( TriangleList_t& triangles );
|
|
Triangle_t* GetNextUntouchedWithLeastBoneStateChanges( TriangleList_t& triangles );
|
|
|
|
// Actually does the stripification
|
|
void Stripify( VertexIndexList_t const& sourceIndices, bool isHWSkinned,
|
|
int* pNumIndices, unsigned short** ppIndices );
|
|
|
|
// Makes sure our vertices are using the correct bones
|
|
void SanityCheckVertBones( VertexIndexList_t const& list, VertexList_t const& vertices );
|
|
|
|
// Sets the flags associated with a particular strip group + mesh
|
|
void ComputeStripGroupFlags( StripGroup_t *pStripGroup, bool isHWSkinned, bool isFlexed );
|
|
void ComputeMeshFlags( Mesh_t *pMesh, studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh );
|
|
|
|
bool MeshIsTeeth( studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh );
|
|
|
|
// Tries to add neighboring vertices that'll fit into the matrix transform state
|
|
void BuildStripsRecursive( VertexIndexList_t& indices, TriangleList_t& list, Triangle_t *triangle );
|
|
|
|
// Figures out all bones affecting a particular triangle
|
|
void BuildTriangleBoneData( VertexList_t& list, Triangle_t& tri );
|
|
|
|
// Memory optimize the strip data
|
|
void PostProcessStripGroup( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, StripGroup_t *pStripGroup );
|
|
|
|
void COptimizedModel::ZeroNumBones( void );
|
|
|
|
//
|
|
// Methods associated with writing VTX files
|
|
//
|
|
|
|
// This writes the strip data out to a VTX file
|
|
void WriteVTXFile( studiohdr_t *pHdr, char const* pFileName,
|
|
TotalMeshStats_t const& stats );
|
|
|
|
|
|
//
|
|
// Methods associated with writing GL View files
|
|
//
|
|
|
|
|
|
// This writes the GL debugging files
|
|
void WriteGLViewFiles( studiohdr_t *pHdr, const char *glViewFileName );
|
|
|
|
void OutputMemoryUsage( void );
|
|
bool IsVertexFlexed( mstudiomesh_t *pStudioMesh, int vertID ) const;
|
|
void BuildNeighborInfo( TriangleList_t& list, int nMaxVertexId );
|
|
void ClearTouched( void );
|
|
void PrintVert( Vertex_t *v, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh );
|
|
void SanityCheckAgainstStudioHDR( studiohdr_t *phdr );
|
|
void WriteStringTable( int stringTableOffset );
|
|
void WriteMaterialReplacements( int materialReplacementsOffset );
|
|
void WriteMaterialReplacementLists( int materialReplacementsOffset, int materialReplacementListOffset );
|
|
void WriteHeader( int vertCacheSize, int maxBonesPerVert,
|
|
int maxBonesPerTri, int maxBonesPerStrip, int numBodyParts, long checkSum );
|
|
void WriteBodyPart( int bodyPartID, mstudiobodyparts_t *pBodyPart, int modelID );
|
|
void WriteModel( int modelID, mstudiomodel_t *pModel, int lodID );
|
|
void WriteModelLOD( int lodID, ModelLOD_t *pLOD, int meshID );
|
|
void WriteMesh( int meshID, Mesh_t *pMesh, int stripGroupID );
|
|
void WriteStripGroup( int stripGroupID, StripGroup_t *pStripGroup,
|
|
int vertID, int indexID, int stripID );
|
|
int WriteVerts( int vertID, StripGroup_t *pStripGroup );
|
|
int WriteIndices( int indexID, StripGroup_t *pStripGroup );
|
|
void WriteStrip( int stripID, Strip_t *pStrip, int indexID, int vertID, int boneID );
|
|
void WriteBoneStateChange( int boneID, BoneStateChange_t *boneStateChange );
|
|
|
|
void DrawGLViewTriangle( FILE *fp, Vector& pos1, Vector& pos2, Vector& pos3,
|
|
Vector& color1, Vector& color2, Vector& color3 );
|
|
void WriteGLViewFile( studiohdr_t *phdr, const char *pFileName, unsigned int flags, float shrinkFactor );
|
|
void ShrinkVerts( float shrinkFactor );
|
|
void GLViewDrawBegin( int mode );
|
|
void CheckVertBoneWeights( Vertex_t *pVert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh );
|
|
void GLViewVert( FILE *fp, Vertex_t vert, int index, Vector& color, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, bool showSubStrips, float shrinkFraction );
|
|
void GLViewDrawEnd( void );
|
|
void SetMeshPropsColor( unsigned int meshFlags, Vector& color );
|
|
void SetFlexedAndSkinColor( unsigned int glViewFlags, unsigned int stripGroupFlags, Vector& color );
|
|
void SetColorFromNumVertexBones( int numBones, Vector& color );
|
|
Vector& GetOrigVertPosition( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert );
|
|
float GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
|
|
mstudioboneweight_t &GetOrigVertBoneWeight( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert );
|
|
int GetOrigVertBoneIndex( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
|
|
void ShowStats( void );
|
|
void MapGlobalBonesToHardwareBoneIDsAndSortBones( studiohdr_t *phdr );
|
|
void RemoveRedundantBoneStateChanges( void );
|
|
void CheckVert( Vertex_t *pVert, int maxBonesPerTri, int maxBonesPerVert );
|
|
void CheckAllVerts( int maxBonesPerTri, int maxBonesPerVert );
|
|
void SortBonesWithinVertex( bool flexed, Vertex_t *vert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, int *globalToHardwareBoneIndex, int *hardwareToGlobalBoneIndex, int maxBonesPerTri, int maxBonesPerVert );
|
|
int GetTotalVertsForMesh( Mesh_t *pMesh );
|
|
int GetTotalIndicesForMesh( Mesh_t *pMesh );
|
|
int GetTotalStripsForMesh( Mesh_t *pMesh );
|
|
int GetTotalStripGroupsForMesh( Mesh_t *pMesh );
|
|
int GetTotalBoneStateChangesForMesh( Mesh_t *pMesh );
|
|
bool MeshNeedsRemoval( studiohdr_t *pHdr, mstudiomesh_t *pStudioMesh,
|
|
LodScriptData_t& scriptLOD );
|
|
|
|
void PrintBoneStateChanges( studiohdr_t *pHdr, int lod );
|
|
void PrintVerts( studiohdr_t *phdr, int lod );
|
|
void SanityCheckVertexBoneLODFlags( studiohdr_t *pStudioHdr, FileHeader_t *pVtxHeader );
|
|
|
|
//
|
|
// SOURCE DATA
|
|
//
|
|
|
|
// These are all the built models
|
|
CUtlVector<Model_t> m_Models;
|
|
|
|
// total number of bones in the studio model
|
|
int m_NumBones;
|
|
|
|
// information about the hardware
|
|
int m_VertexCacheSize;
|
|
int m_MaxBonesPerTri;
|
|
int m_MaxBonesPerVert;
|
|
int m_MaxBonesPerStrip;
|
|
bool m_UsesFixedFunction;
|
|
|
|
// stats
|
|
int m_NumSkinnedAndFlexedVerts;
|
|
|
|
CHardwareMatrixState m_HardwareMatrixState;
|
|
|
|
// a place to stick file output.
|
|
CFileBuffer *m_FileBuffer;
|
|
|
|
// offset for different items in the output file.
|
|
int m_BodyPartsOffset;
|
|
int m_ModelsOffset;
|
|
int m_ModelLODsOffset;
|
|
int m_MeshesOffset;
|
|
int m_StripGroupsOffset;
|
|
int m_StripsOffset;
|
|
int m_VertsOffset;
|
|
int m_IndicesOffset;
|
|
int m_BoneStageChangesOffset;
|
|
int m_StringTableOffset;
|
|
int m_MaterialReplacementsOffset;
|
|
int m_MaterialReplacementsListOffset;
|
|
int m_EndOfFileOffset;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton instance
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static COptimizedModel s_OptimizedModel;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Cleanup method
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::CleanupEverything()
|
|
{
|
|
}
|
|
|
|
|
|
|
|
void COptimizedModel::OutputMemoryUsage( void )
|
|
{
|
|
printf( "body parts: %7d bytes\n", ( int )( m_ModelsOffset - m_BodyPartsOffset ) );
|
|
printf( "models: %7d bytes\n", ( int )( m_MeshesOffset - m_ModelsOffset ) );
|
|
printf( "model LODs: %7d bytes\n", ( int )( m_MeshesOffset - m_ModelLODsOffset ) );
|
|
printf( "meshes: %7d bytes\n", ( int )( m_StripGroupsOffset - m_MeshesOffset ) );
|
|
printf( "strip groups: %7d bytes\n", ( int )( m_StripsOffset - m_StripGroupsOffset ) );
|
|
printf( "strips: %7d bytes\n", ( int )( m_VertsOffset - m_StripsOffset ) );
|
|
printf( "verts: %7d bytes\n", ( int )( m_IndicesOffset - m_VertsOffset ) );
|
|
printf( "indices: %7d bytes\n", ( int )( m_BoneStageChangesOffset - m_IndicesOffset ) );
|
|
printf( "bone changes: %7d bytes\n", ( int )( m_EndOfFileOffset - m_BoneStageChangesOffset ) );
|
|
printf( "everything: %7d bytes\n", ( int )( m_EndOfFileOffset ) );
|
|
}
|
|
|
|
void COptimizedModel::SanityCheckAgainstStudioHDR( studiohdr_t *phdr )
|
|
{
|
|
#if 0 // garymcthack
|
|
printf( "SanityCheckAgainstStudioHDR\n" );
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
Assert( header->numBodyParts == phdr->numbodyparts );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
Assert( bodyPart->numModels == pStudioBodyPart->nummodels );
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
Assert( model->numMeshes == pStudioModel->nummeshes );
|
|
for( int meshID = 0; meshID < model->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = model->pMesh( meshID );
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *stripGroup = mesh->pStripGroup( stripGroupID );
|
|
for( int stripID = 0; stripID < stripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *strip = stripGroup->pStrip( stripID );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// The following methods are all related to creating groups of meshes to strip
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// pick any triangle that hasn't been used yet to start with.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static Triangle_t *GetNextUntouched( TriangleList_t& triangles )
|
|
{
|
|
int i;
|
|
for( i = 0; i < triangles.Size(); i++ )
|
|
{
|
|
if( !triangles[i].touched )
|
|
return &triangles[i];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the number of bones that are not represented in the current hardware state
|
|
//-----------------------------------------------------------------------------
|
|
|
|
inline int COptimizedModel::ComputeNewBonesNeeded( Triangle_t const& triangle ) const
|
|
{
|
|
int numNewBones = 0;
|
|
for( int i = 0; i < triangle.numBones; ++i )
|
|
{
|
|
if( !m_HardwareMatrixState.IsMatrixAllocated( triangle.boneID[i] ) )
|
|
++numNewBones;
|
|
}
|
|
return numNewBones;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// returns triangle index
|
|
// Find the next triangle without a bone state change
|
|
// May add new hardware bones if there is space and is necessary.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Triangle_t* COptimizedModel::GetNextUntouchedWithoutBoneStateChange( TriangleList_t& triangles )
|
|
{
|
|
Triangle_t *bestTriangle = 0;
|
|
int bestNumNewBones = MAX_NUM_BONES_PER_TRI + 1;
|
|
|
|
int i;
|
|
for( i = 0; i < triangles.Size(); i++ )
|
|
{
|
|
// We haven't processed this one, so let's try it
|
|
if( !triangles[i].touched )
|
|
{
|
|
// How many bones are not represented in the current state?
|
|
int numNewBones = ComputeNewBonesNeeded( triangles[i] );
|
|
|
|
// if this triangle fit and if it's the best so far, save it.
|
|
if ( (numNewBones <= m_HardwareMatrixState.FreeMatrixCount()) &&
|
|
(numNewBones < bestNumNewBones ) )
|
|
{
|
|
bestNumNewBones = numNewBones;
|
|
bestTriangle = &triangles[i];
|
|
|
|
// Can't get any better than this!
|
|
if (bestNumNewBones == 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return bestTriangle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This will returns the triangle that requires the last number of bone
|
|
// state changes
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Triangle_t *COptimizedModel::GetNextUntouchedWithLeastBoneStateChanges( TriangleList_t& triangles )
|
|
{
|
|
Triangle_t *bestTriangle = 0;
|
|
int bestNumNewBones = MAX_NUM_BONES_PER_TRI + 1;
|
|
int i;
|
|
|
|
// For this one, just find the triangle that needs the least number
|
|
// of new bones. That way, we'll not have to change too many states
|
|
for( i = 0; i < triangles.Size(); i++ )
|
|
{
|
|
if( !triangles[i].touched )
|
|
{
|
|
int numNewBones = ComputeNewBonesNeeded( triangles[i] );
|
|
|
|
if( numNewBones < bestNumNewBones )
|
|
{
|
|
bestNumNewBones = numNewBones;
|
|
bestTriangle = &triangles[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// This only happens if there are no triangles untouched
|
|
if( !bestTriangle )
|
|
return 0;
|
|
|
|
#ifdef USE_FLUSH
|
|
m_HardwareMatrixState.DeallocateAll();
|
|
#else
|
|
// Remove bones until we have enough space...
|
|
int numToRemove = bestNumNewBones - m_HardwareMatrixState.FreeMatrixCount();
|
|
Assert( numToRemove > 0 );
|
|
m_HardwareMatrixState.DeallocateLRU(numToRemove);
|
|
#endif
|
|
|
|
return bestTriangle;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Allocate bones for a triangle from the hardware matrix state
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool COptimizedModel::AllocateHardwareBonesForTriangle( Triangle_t *tri )
|
|
{
|
|
for( int i = 0; i < tri->numBones; ++i )
|
|
{
|
|
int bone = tri->boneID[i];
|
|
if( !m_HardwareMatrixState.IsMatrixAllocated( bone ) )
|
|
{
|
|
if( !m_HardwareMatrixState.AllocateMatrix( bone ) )
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Get the next triangle.
|
|
// Try to find one that doesn't cause a bone state change by jumping to
|
|
// a new location in the model that works with the bones that we have allocated.
|
|
// If we can't find one, and allowNewStrip is true, then flush and pick the next
|
|
// best triangle that is close to the current hardware bone state.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
Triangle_t *COptimizedModel::GetNextTriangle( TriangleList_t& tris, bool allowNewStrip )
|
|
{
|
|
// First try to get a triangle that doesn't involve changing matrix state
|
|
Triangle_t *tri;
|
|
tri = GetNextUntouchedWithoutBoneStateChange( tris );
|
|
|
|
// If that didn't work, pick the triangle that changes the state the least
|
|
if( !tri && allowNewStrip )
|
|
{
|
|
tri = GetNextUntouchedWithLeastBoneStateChanges( tris );
|
|
}
|
|
|
|
// Return the triangle we found
|
|
return tri;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Make sure all vertices we've added up to now use bones in the matrix list
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::SanityCheckVertBones( VertexIndexList_t const& list, VertexList_t const& vertices )
|
|
{
|
|
#ifdef _DEBUG
|
|
Vertex_t const *pVert;
|
|
int i;
|
|
for( i = 0; i < list.Size(); i++ )
|
|
{
|
|
pVert = &vertices[list[i]];
|
|
if( !g_staticprop )
|
|
{
|
|
Assert( pVert->numBones != 0 );
|
|
}
|
|
int j;
|
|
for( j = 0; j < pVert->numBones; j++ )
|
|
{
|
|
if( pVert->boneID[j] == -1 )
|
|
{
|
|
continue;
|
|
}
|
|
if( !m_HardwareMatrixState.IsMatrixAllocated( pVert->boneID[j] ) )
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Make sure all vertices we've added up to now use bones in the matrix list
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::Stripify( VertexIndexList_t const& sourceIndices, bool isHWSkinned,
|
|
int* pNumIndices, unsigned short** ppIndices )
|
|
{
|
|
if( sourceIndices.Size() == 0 )
|
|
{
|
|
*ppIndices = 0;
|
|
*pNumIndices = 0;
|
|
return;
|
|
}
|
|
|
|
// Skip the tristripping phase if we're building in preview mode
|
|
if ( g_bBuildPreview || isHWSkinned == false )
|
|
{
|
|
*pNumIndices = sourceIndices.Count();
|
|
*ppIndices = new unsigned short[*pNumIndices];
|
|
memcpy( *ppIndices, sourceIndices.Base(), (*pNumIndices) * sizeof(unsigned short) );
|
|
return;
|
|
}
|
|
|
|
/*
|
|
printf( "Stripify\n" );
|
|
int i;
|
|
for( i = 0; i < sourceIndices.Size(); i++ )
|
|
{
|
|
printf( "stripindex: %d\n", sourceIndices[i] );
|
|
}
|
|
*/
|
|
|
|
#ifdef NVTRISTRIP
|
|
PrimitiveGroup *primGroups;
|
|
unsigned short numPrimGroups;
|
|
|
|
// Be sure to call delete[] on the returned primGroups to avoid leaking mem
|
|
GenerateStrips( &sourceIndices[0], sourceIndices.Size(),
|
|
&primGroups, &numPrimGroups );
|
|
Assert( numPrimGroups == 1 );
|
|
*pNumIndices = primGroups->numIndices;
|
|
*ppIndices = new unsigned short[*pNumIndices];
|
|
memcpy( *ppIndices, primGroups->indices, sizeof( unsigned short ) * *pNumIndices );
|
|
delete [] primGroups;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eat up triangle recursively by flood-filling around the model until
|
|
// we run out of bones on the hardware.
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::BuildStripsRecursive( VertexIndexList_t& indices,
|
|
TriangleList_t& tris, Triangle_t *triangle )
|
|
{
|
|
Assert( triangle );
|
|
|
|
// Don't process the triangle if it's already been processed
|
|
if( triangle->touched )
|
|
return;
|
|
|
|
// Only suck in triangles that need no state change
|
|
if ( ComputeNewBonesNeeded( *triangle ) )
|
|
return;
|
|
|
|
// We've got enough hardware bones. Lets add this triangle's vertices, and
|
|
// then add the vertices of all the neighboring triangles.
|
|
triangle->touched = true;
|
|
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[0] );
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[1] );
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[2] );
|
|
|
|
// Try to add our neighbors
|
|
if( triangle->neighborTriID[0] != -1 )
|
|
{
|
|
BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[0]] );
|
|
}
|
|
if( triangle->neighborTriID[1] != -1 )
|
|
{
|
|
BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[1]] );
|
|
}
|
|
if( triangle->neighborTriID[2] != -1 )
|
|
{
|
|
BuildStripsRecursive( indices, tris, &tris[triangle->neighborTriID[2]] );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Processes a HW-skinned strip group
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::BuildHWSkinnedStrips( TriangleList_t& triangles,
|
|
VertexList_t& vertices, StripGroup_t *pStripGroup, int maxBonesPerStrip )
|
|
{
|
|
// Set up the hardware matrix state
|
|
m_HardwareMatrixState.Init( maxBonesPerStrip );
|
|
|
|
// Empty out the list of triangles to be stripified.
|
|
VertexIndexList_t trianglesToStrip;
|
|
trianglesToStrip.EnsureCapacity( triangles.Size() * 3 );
|
|
|
|
// pick any old unused triangle to start with.
|
|
Triangle_t *pSeedTri = GetNextUntouched( triangles );
|
|
while( pSeedTri )
|
|
{
|
|
// Make sure we've got out transforms allocated
|
|
#ifdef DBGFLAG_ASSERT
|
|
bool ok =
|
|
#endif
|
|
AllocateHardwareBonesForTriangle( pSeedTri );
|
|
Assert( ok );
|
|
|
|
// eat up triangle recursively by flood-filling around the model until
|
|
// we run out of bones on the hardware.
|
|
BuildStripsRecursive( trianglesToStrip, triangles, pSeedTri );
|
|
|
|
// Try to jump to a new location in the mesh without
|
|
// causing a hardware bone state overflow or flush.
|
|
pSeedTri = GetNextTriangle( triangles, false );
|
|
if( pSeedTri )
|
|
continue;
|
|
|
|
// Save the results of the generated strip.
|
|
int stripIdx = pStripGroup->strips.AddToTail( );
|
|
Strip_t& newStrip = pStripGroup->strips[stripIdx];
|
|
|
|
// Compute the strip flags
|
|
newStrip.flags = 0;
|
|
#ifdef EMIT_TRILISTS
|
|
newStrip.flags |= STRIP_IS_TRILIST;
|
|
#else
|
|
newStrip.flags |= STRIP_IS_TRISTRIP;
|
|
#endif
|
|
|
|
// Sanity check the indices of the bones.
|
|
SanityCheckVertBones( trianglesToStrip, vertices );
|
|
|
|
// There are no more triangles to eat up without causing a flush, so
|
|
// go ahead and stripify what we have and flush.
|
|
// NOTE: This allocates space for stripIndices.pIndices.
|
|
Stripify( trianglesToStrip, true, &newStrip.numIndices, &newStrip.pIndices );
|
|
|
|
// hack - should just build directly into newStrip.verts instead of using a global.
|
|
int i;
|
|
for( i = 0; i < vertices.Size(); i++ )
|
|
{
|
|
newStrip.verts.AddToTail( vertices[i] );
|
|
}
|
|
|
|
// Compute the number of bones in this strip
|
|
newStrip.numBoneStateChanges = m_HardwareMatrixState.AllocatedMatrixCount();
|
|
Assert( newStrip.numBoneStateChanges <= maxBonesPerStrip );
|
|
|
|
// Save off the bones used for this strip.
|
|
for( i = 0; i < m_HardwareMatrixState.AllocatedMatrixCount(); i++ )
|
|
{
|
|
newStrip.boneStateChanges[i].hardwareID = i;
|
|
newStrip.boneStateChanges[i].newBoneID = m_HardwareMatrixState.GetNthBoneGlobalID( i );
|
|
}
|
|
|
|
// Empty out the triangles to strip so that we can start again with a new strip.
|
|
trianglesToStrip.RemoveAll();
|
|
|
|
// Get the next best triangle, allowing for a bone state flushes.
|
|
pSeedTri = GetNextTriangle( triangles, true );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Processes a SW-skinned strip group
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::BuildSWSkinnedStrips( TriangleList_t& triangles,
|
|
VertexList_t const& vertices, StripGroup_t *pStripGroup )
|
|
{
|
|
// Save the results of the generated strip.
|
|
int stripIdx = pStripGroup->strips.AddToTail( );
|
|
Strip_t& newStrip = pStripGroup->strips[stripIdx];
|
|
|
|
// Set the strip flags
|
|
newStrip.flags = 0;
|
|
#ifdef EMIT_TRILISTS
|
|
newStrip.flags |= STRIP_IS_TRILIST;
|
|
#else
|
|
newStrip.flags |= STRIP_IS_TRISTRIP;
|
|
#endif
|
|
|
|
int nTriangleCount = triangles.Count();
|
|
|
|
VertexIndexList_t indices;
|
|
indices.EnsureCapacity( nTriangleCount * 3 );
|
|
|
|
for( int i = 0; i < nTriangleCount; i++ )
|
|
{
|
|
Triangle_t* triangle = &triangles[i];
|
|
triangle->touched = true;
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[0] );
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[1] );
|
|
indices.AddToTail( ( unsigned short )triangle->vertID[2] );
|
|
}
|
|
|
|
Stripify( indices, false, &newStrip.numIndices, &newStrip.pIndices );
|
|
|
|
// hack - should just build directly into newStrip.verts instead of using a global.
|
|
for( int i = 0; i < vertices.Size(); i++ )
|
|
{
|
|
newStrip.verts.AddToTail( vertices[i] );
|
|
}
|
|
|
|
newStrip.numBoneStateChanges = 0;
|
|
for( int i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
|
|
{
|
|
newStrip.boneStateChanges[i].hardwareID = -1;
|
|
newStrip.boneStateChanges[i].newBoneID = -1;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns true if a particular vertex is part of a flex
|
|
//-----------------------------------------------------------------------------
|
|
bool COptimizedModel::IsVertexFlexed( mstudiomesh_t *pStudioMesh, int vertID ) const
|
|
{
|
|
mstudioflex_t *pflex = pStudioMesh->pFlex( 0 );
|
|
|
|
int i, j, n;
|
|
|
|
// Iterate through all the flexes
|
|
// figure out if the vertex is part of the flex
|
|
for (i = 0; i < pStudioMesh->numflexes; i++)
|
|
{
|
|
byte *pvanim = pflex[i].pBaseVertanim();
|
|
int nVAnimSizeBytes = pflex[i].VertAnimSizeBytes();
|
|
|
|
for (j = 0; j < pflex[i].numverts; j++, pvanim += nVAnimSizeBytes )
|
|
{
|
|
mstudiovertanim_t *pAnim = (mstudiovertanim_t*)( pvanim );
|
|
|
|
n = pAnim->index;
|
|
if ( n == vertID )
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes flags for the strip group
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::ComputeStripGroupFlags( StripGroup_t *pStripGroup,
|
|
bool isHWSkinned, bool isFlexed )
|
|
{
|
|
pStripGroup->flags = 0;
|
|
if( isFlexed )
|
|
{
|
|
pStripGroup->flags |= STRIPGROUP_IS_FLEXED;
|
|
pStripGroup->flags |= STRIPGROUP_IS_DELTA_FLEXED; // Going forward, DX9 models are delta flexed
|
|
}
|
|
if( isHWSkinned )
|
|
{
|
|
pStripGroup->flags |= STRIPGROUP_IS_HWSKINNED;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Try to reduce the number of bones affecting this vert so hardware can deal
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define MIN_BONE_INFLUENCE 1.0f
|
|
|
|
static void TryToReduceBoneInfluence( Vertex_t& stripGroupVert,
|
|
mstudioboneweight_t const& boneWeights, int maxBones )
|
|
{
|
|
int i;
|
|
while ( stripGroupVert.numBones > maxBones)
|
|
{
|
|
// Find the minimum bone weight...
|
|
float minWeight = 2.0;
|
|
int minIndex = -1;
|
|
for( i = 0; i < MAX_NUM_BONES_PER_VERT; ++i )
|
|
{
|
|
if (stripGroupVert.boneID[i] != -1)
|
|
{
|
|
float weight = boneWeights.weight[ stripGroupVert.boneWeightIndex[i] ];
|
|
if (weight < minWeight)
|
|
{
|
|
minWeight = weight;
|
|
minIndex = i;
|
|
}
|
|
}
|
|
}
|
|
Assert( minIndex >= 0 );
|
|
|
|
// Now that we got it, remove that bone influence if it's small enough
|
|
if (minWeight >= MIN_BONE_INFLUENCE)
|
|
return;
|
|
|
|
// Blat out that bone!
|
|
for( i = minIndex; i < MAX_NUM_BONES_PER_VERT - 1; ++i )
|
|
{
|
|
stripGroupVert.boneID[i] = stripGroupVert.boneID[i+1];
|
|
stripGroupVert.boneWeightIndex[i] = stripGroupVert.boneWeightIndex[i+1];
|
|
}
|
|
stripGroupVert.boneID[ MAX_NUM_BONES_PER_VERT - 1] = -1;
|
|
stripGroupVert.boneWeightIndex[ MAX_NUM_BONES_PER_VERT - 1] = 0;
|
|
|
|
--stripGroupVert.numBones;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Generate three strip-group ready vertices from source mesh data
|
|
// returns true if the face contants a flexed vertex
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool COptimizedModel::GenerateStripGroupVerticesFromFace( mstudioiface_t* pFace,
|
|
mstudiomesh_t *pStudioMesh,
|
|
int maxPreferredBones,
|
|
Vertex_t* pStripGroupVert )
|
|
{
|
|
int vertIDs[3];
|
|
vertIDs[0] = pFace->a;
|
|
vertIDs[1] = pFace->b;
|
|
vertIDs[2] = pFace->c;
|
|
|
|
const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
|
|
bool triangleIsFlexed = false;
|
|
for( int faceIndex = 0; faceIndex < 3; ++faceIndex )
|
|
{
|
|
// Get the original source vertex id
|
|
int vertex = vertIDs[faceIndex];
|
|
|
|
// Check the verts of the triangle to see if they are flexed
|
|
triangleIsFlexed = triangleIsFlexed || IsVertexFlexed( pStudioMesh, vertex );
|
|
|
|
// How many bones affect this vertex
|
|
mstudioboneweight_t *pBoneWeight = vertData->BoneWeights(vertex);
|
|
|
|
int bonesAffectingVertex = pBoneWeight->numbones;
|
|
if( !g_staticprop && bonesAffectingVertex <= 0 )
|
|
{
|
|
MdlWarning( "too few bones/vert (%d) : it has no bones!\n", bonesAffectingVertex );
|
|
}
|
|
else if( bonesAffectingVertex > MAX_NUM_BONES_PER_VERT )
|
|
{
|
|
MdlError( "too many bones/vert (%d) : MAX_NUM_BONES_PER_VERT needs to be upped\n", bonesAffectingVertex );
|
|
}
|
|
|
|
// Set the fields of the strip group's vert
|
|
pStripGroupVert[faceIndex].origMeshVertID = vertex;
|
|
|
|
pStripGroupVert[faceIndex].numBones = bonesAffectingVertex;
|
|
|
|
int boneID;
|
|
|
|
#ifndef IGNORE_BONES
|
|
for( boneID = 0; boneID < bonesAffectingVertex; boneID++ )
|
|
{
|
|
pStripGroupVert[faceIndex].boneID[boneID] = pBoneWeight->bone[boneID];
|
|
pStripGroupVert[faceIndex].boneWeightIndex[boneID] = boneID;
|
|
}
|
|
for( ; boneID < MAX_NUM_BONES_PER_VERT; boneID++ )
|
|
{
|
|
pStripGroupVert[faceIndex].boneID[boneID] = -1;
|
|
pStripGroupVert[faceIndex].boneWeightIndex[boneID] = boneID;
|
|
}
|
|
#else
|
|
// don't let bones have any influence.
|
|
for( boneID = 0; boneID < MAX_NUM_BONES_PER_VERT; boneID++ )
|
|
{
|
|
pStripGroupVert[faceIndex].boneID[boneID] = -1;
|
|
pStripGroupVert[faceIndex].boneWeights[boneID] = 0;
|
|
}
|
|
#endif
|
|
|
|
// For hardware skinning, we want to try to reduce the number of
|
|
// bone influences, which we'll do here if we can.
|
|
// At the moment, we can't do this for fixed function because
|
|
// we get seam problems at transitions between SW and HW rendered
|
|
if (!m_UsesFixedFunction)
|
|
{
|
|
if ((maxPreferredBones > 0) && (bonesAffectingVertex > maxPreferredBones))
|
|
{
|
|
TryToReduceBoneInfluence( pStripGroupVert[faceIndex], *pBoneWeight,
|
|
maxPreferredBones );
|
|
}
|
|
}
|
|
}
|
|
|
|
return triangleIsFlexed;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the unique number of bones in a specified set of vertices
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int COptimizedModel::CountUniqueBones( int count, Vertex_t *pVertex ) const
|
|
{
|
|
int uniqueBoneCount = 0;
|
|
int uniqueBoneList[MAX_NUM_BONES_PER_STRIP];
|
|
while ( --count >= 0 )
|
|
{
|
|
for (int i = 0; i < pVertex[count].numBones; ++i)
|
|
{
|
|
int boneID = pVertex[count].boneID[i];
|
|
int j = uniqueBoneCount;
|
|
while ( --j >= 0 )
|
|
{
|
|
if (uniqueBoneList[j] == boneID)
|
|
break;
|
|
}
|
|
|
|
// Didn't find a match!
|
|
if (j < 0)
|
|
{
|
|
Assert( uniqueBoneCount < MAX_NUM_BONES_PER_STRIP );
|
|
uniqueBoneList[uniqueBoneCount++] = boneID;
|
|
}
|
|
}
|
|
}
|
|
|
|
return uniqueBoneCount;
|
|
}
|
|
|
|
int COptimizedModel::CountMaxVertBones( int count, Vertex_t *pVertex ) const
|
|
{
|
|
int maxBones = 0;
|
|
while ( --count >= 0 )
|
|
{
|
|
if (maxBones < pVertex[count].numBones)
|
|
maxBones = pVertex[count].numBones;
|
|
}
|
|
|
|
return maxBones;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a vertex to the list of vertices to be added to the strip group
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static int FindOrCreateVertex( VertexList_t& list, Vertex_t const& vert )
|
|
{
|
|
int i;
|
|
for( i = 0; i < list.Size(); i++ )
|
|
{
|
|
if (list[i].origMeshVertID == vert.origMeshVertID)
|
|
{
|
|
// If this is the case, then everything else should be too!
|
|
Assert( !memcmp( &list[i], &vert, sizeof( vert )) );
|
|
return i;
|
|
}
|
|
}
|
|
|
|
list.AddToTail( vert );
|
|
return i;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the bones used by the triangle
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::BuildTriangleBoneData( VertexList_t& list, Triangle_t& tri )
|
|
{
|
|
int j, k, l;
|
|
|
|
// Blat out the bone ID state
|
|
tri.numBones = 0;
|
|
for( j = 0; j < MAX_NUM_BONES_PER_TRI; j++ )
|
|
{
|
|
tri.boneID[j] = -1;
|
|
}
|
|
|
|
// Iterate through the vertices in the triangle
|
|
for( j = 0; j < 3; j++ )
|
|
{
|
|
// Iterate over the bones influencing the vertex
|
|
Vertex_t& vert = list[tri.vertID[j]];
|
|
for( k = 0; k < vert.numBones; ++k )
|
|
{
|
|
int bone = vert.boneID[k];
|
|
Assert( (bone >= 0) && (bone < m_NumBones) );
|
|
|
|
// Look for matches with previously found bones
|
|
for ( l = tri.numBones; --l >= 0; )
|
|
{
|
|
if ( bone == tri.boneID[l] )
|
|
break;
|
|
}
|
|
|
|
// No match, add it to our list
|
|
if ( l < 0 )
|
|
tri.boneID[tri.numBones++] = bone;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes neighboring triangles along each face of a triangle
|
|
//-----------------------------------------------------------------------------
|
|
struct EdgeInfo_t
|
|
{
|
|
int m_nConnectedVertId;
|
|
int m_nEdgeIndex;
|
|
int m_nTriangleId;
|
|
};
|
|
|
|
static void FindMatchingEdge( TriangleList_t& list, int nTriangleId, int nEdgeIndex,
|
|
const int *pVertIds, CUtlVector< int >& vertexToEdges, CUtlFixedLinkedList< EdgeInfo_t >& edges )
|
|
{
|
|
// Have we already attached this edge to something?
|
|
Triangle_t &tri = list[nTriangleId];
|
|
if ( tri.neighborTriID[nEdgeIndex] != -1 )
|
|
return;
|
|
|
|
int nVertIndex = ( pVertIds[0] < pVertIds[1] ) ? 0 : 1;
|
|
int nConnectedVertId = pVertIds[ 1-nVertIndex ];
|
|
int hFirstEdge = vertexToEdges[nVertIndex];
|
|
for ( int hEdge = hFirstEdge; hEdge != edges.InvalidIndex(); hEdge = edges.Next(hEdge) )
|
|
{
|
|
EdgeInfo_t &edge = edges[hEdge];
|
|
if ( edge.m_nConnectedVertId != nConnectedVertId )
|
|
continue;
|
|
|
|
// Can't attach triangles to themselves
|
|
if ( edge.m_nTriangleId == nTriangleId )
|
|
continue;
|
|
|
|
// Found a match! Mark the two triangles as sharing an edge
|
|
tri.neighborTriID[nEdgeIndex] = edge.m_nTriangleId;
|
|
list[ edge.m_nTriangleId ].neighborTriID[ edge.m_nEdgeIndex ] = nTriangleId;
|
|
if ( hEdge == hFirstEdge )
|
|
{
|
|
vertexToEdges[nVertIndex] = edges.Next( hFirstEdge );
|
|
}
|
|
edges.Free( hEdge );
|
|
return;
|
|
}
|
|
|
|
// No match! Insert the disconnected edge into the edge list
|
|
int hNewEdge = edges.Alloc( true );
|
|
EdgeInfo_t &newEdge = edges[hNewEdge];
|
|
newEdge.m_nConnectedVertId = nConnectedVertId;
|
|
newEdge.m_nEdgeIndex = nEdgeIndex;
|
|
newEdge.m_nTriangleId = nTriangleId;
|
|
edges.LinkBefore( hFirstEdge, hNewEdge );
|
|
vertexToEdges[nVertIndex] = hNewEdge;
|
|
}
|
|
|
|
void COptimizedModel::BuildNeighborInfo( TriangleList_t& list, int nMaxVertexId )
|
|
{
|
|
// NOTE: vertexToEdges[vertId] contains the index of the head of a linked list stored in edges
|
|
CUtlFixedLinkedList< EdgeInfo_t > edges;
|
|
CUtlVector< int > vertexToEdges;
|
|
vertexToEdges.SetCount( nMaxVertexId );
|
|
memset( vertexToEdges.Base(), 0, nMaxVertexId * sizeof(int) );
|
|
|
|
int pEdgeVertIds[2];
|
|
int nTriCount = list.Count();
|
|
for ( int i = 0; i < nTriCount; ++i )
|
|
{
|
|
Triangle_t &tri = list[i];
|
|
|
|
// Add the three edges for this tri into a lookup table indexed by the lower vertID
|
|
pEdgeVertIds[0] = tri.vertID[0]; pEdgeVertIds[1] = tri.vertID[1];
|
|
FindMatchingEdge( list, i, 0, pEdgeVertIds, vertexToEdges, edges );
|
|
|
|
pEdgeVertIds[0] = tri.vertID[1]; pEdgeVertIds[1] = tri.vertID[2];
|
|
FindMatchingEdge( list, i, 1, pEdgeVertIds, vertexToEdges, edges );
|
|
|
|
pEdgeVertIds[0] = tri.vertID[2]; pEdgeVertIds[1] = tri.vertID[0];
|
|
FindMatchingEdge( list, i, 2, pEdgeVertIds, vertexToEdges, edges );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Processes a single strip group
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::ProcessStripGroup( StripGroup_t *pStripGroup, bool isHWSkinned,
|
|
bool isFlexed, mstudiomodel_t *pStudioModel,
|
|
mstudiomesh_t *pStudioMesh,
|
|
CUtlVector<mstudioiface_t> &srcFaces,
|
|
TriangleProcessedList_t& trianglesProcessed,
|
|
int maxBonesPerVert, int maxBonesPerTri,
|
|
int maxBonesPerStrip, bool forceNoFlex, bool bHWFlex )
|
|
{
|
|
ComputeStripGroupFlags( pStripGroup, isHWSkinned, isFlexed );
|
|
|
|
// all of the triangles before stripping for the current stripgroup.
|
|
TriangleList_t stripGroupSourceTriangles;
|
|
VertexList_t stripGroupVertices;
|
|
|
|
// FIXME: Flexed/HWSkinned state of faces don't change with each pass.
|
|
// We could precompute those flags just once (instead of doing it 4 times)
|
|
|
|
// Add each face to the stripgroup, if it's appropriate
|
|
for( int n=0; n < srcFaces.Size(); ++n )
|
|
{
|
|
// Don't bother processing a triangle that's already been done
|
|
if (trianglesProcessed[n])
|
|
continue;
|
|
|
|
mstudioiface_t *pFace = &srcFaces[n];
|
|
|
|
int preferredBones = isHWSkinned && (bHWFlex || !isFlexed) ? maxBonesPerVert : 0;
|
|
// start a new strip group header.
|
|
Vertex_t stripGroupVert[3];
|
|
bool triangleIsFlexed = GenerateStripGroupVerticesFromFace(
|
|
pFace, pStudioMesh,
|
|
preferredBones,
|
|
stripGroupVert );
|
|
|
|
if( forceNoFlex )
|
|
{
|
|
triangleIsFlexed = false;
|
|
}
|
|
|
|
// Don't bother to add the vertices to our strip-group vertex list
|
|
// if we don't need to.
|
|
if ( triangleIsFlexed != isFlexed )
|
|
continue;
|
|
|
|
// If we're doing software skinning, then always accept, even if
|
|
// this triangle should have been a HW skinned triangle.
|
|
if (isHWSkinned)
|
|
{
|
|
// Check how many unique bones were in that face, and how many vertices
|
|
// maximally in a vertex
|
|
int numVertexBones = CountMaxVertBones( 3, stripGroupVert );
|
|
int numTriangleBones = CountUniqueBones( 3, stripGroupVert );
|
|
|
|
// If we have too many, we'll be skinning in software
|
|
bool triangleIsHWSkinned = ( numTriangleBones <= maxBonesPerTri ) &&
|
|
( numVertexBones <= maxBonesPerVert );
|
|
|
|
// Don't bother to add vertices which aren't gonna be used in this pass
|
|
if (!triangleIsHWSkinned)
|
|
continue;
|
|
}
|
|
|
|
// Add a new triangle to our list of triangles
|
|
int triIndex = stripGroupSourceTriangles.AddToTail( );
|
|
|
|
Triangle_t& newTri = stripGroupSourceTriangles[triIndex];
|
|
newTri.vertID[0] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[0] );
|
|
newTri.vertID[1] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[1] );
|
|
newTri.vertID[2] = FindOrCreateVertex( stripGroupVertices, stripGroupVert[2] );
|
|
BuildTriangleBoneData( stripGroupVertices, newTri );
|
|
|
|
// By default, this processes a triangle
|
|
// Later on below, we may decide to un-process triangles
|
|
// if tristrips that are too small are generated
|
|
trianglesProcessed[n] = true;
|
|
}
|
|
|
|
// No mesh? bye bye
|
|
if (stripGroupSourceTriangles.Size() == 0)
|
|
return;
|
|
|
|
// Figure out neighboring triangles
|
|
BuildNeighborInfo( stripGroupSourceTriangles, stripGroupVertices.Count() );
|
|
|
|
// Build the actual strips
|
|
if( isHWSkinned )
|
|
{
|
|
BuildHWSkinnedStrips( stripGroupSourceTriangles, stripGroupVertices, pStripGroup, maxBonesPerStrip );
|
|
|
|
// Check to see if any strips were produced that are too small
|
|
// If so, remove them, and let the software pass take care of them.
|
|
//if (stripGroupSourceTriangles.Size() < m_MinimumGroupSize
|
|
// trianglesProcessed[n] = false;
|
|
}
|
|
else
|
|
{
|
|
BuildSWSkinnedStrips( stripGroupSourceTriangles, stripGroupVertices, pStripGroup );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// How many unique bones are in a strip?
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int COptimizedModel::CountUniqueBonesInStrip( StripGroup_t *pStripGroup, Strip_t *pStrip )
|
|
{
|
|
int *boneUsageCounts = ( int * )_alloca( m_NumBones * sizeof( int ) );
|
|
memset( boneUsageCounts, 0, sizeof( int ) * m_NumBones );
|
|
int i;
|
|
for( i = 0; i < pStrip->numStripGroupVerts; i++ )
|
|
{
|
|
Vertex_t *pVert = &pStripGroup->verts[i+pStrip->stripGroupVertexOffset];
|
|
if( !g_staticprop )
|
|
{
|
|
Assert( pVert->numBones != 0 );
|
|
}
|
|
int j;
|
|
for( j = 0; j < pVert->numBones; j++ )
|
|
{
|
|
int boneID;
|
|
boneID = pVert->boneID[j];
|
|
Assert( boneID != -1 );
|
|
boneUsageCounts[boneID]++;
|
|
}
|
|
}
|
|
int numBones = 0;
|
|
for( i = 0; i < m_NumBones; i++ )
|
|
{
|
|
if( boneUsageCounts[i] )
|
|
{
|
|
numBones++;
|
|
}
|
|
}
|
|
return numBones;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A little work to be done after we construct the strip groups
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::PostProcessStripGroup( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, StripGroup_t *pStripGroup )
|
|
{
|
|
int i;
|
|
|
|
// We're gonna compile all of the vertices in the current strip into
|
|
// the current strip group's vertex list
|
|
for( i = 0; i < pStripGroup->strips.Size(); i++ )
|
|
{
|
|
// create sorted strip verts and indices in the stripgroup
|
|
Strip_t *pStrip = &pStripGroup->strips[i];
|
|
int vertOffset = pStripGroup->verts.Size();
|
|
pStrip->stripGroupVertexOffset = vertOffset;
|
|
pStrip->stripGroupIndexOffset = pStripGroup->indices.Size();
|
|
|
|
// make sure we have enough memory allocated
|
|
pStripGroup->indices.EnsureCapacity( pStripGroup->indices.Size() + pStrip->numIndices );
|
|
|
|
// Try to find each of the strip's vertices in the strip group
|
|
int maxNumBones = 0;
|
|
int j;
|
|
for( j = 0; j < pStrip->numIndices; j++ )
|
|
{
|
|
int newIndex = -1;
|
|
int index = pStrip->pIndices[j];
|
|
Vertex_t *pVert = &pStrip->verts[index];
|
|
|
|
// Does this vertex exist in the strip group?
|
|
int k;
|
|
for( k = vertOffset; k < pStripGroup->verts.Size(); k++ )
|
|
{
|
|
if( pVert->origMeshVertID == pStripGroup->verts[k].origMeshVertID )
|
|
{
|
|
newIndex = k;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Didn't find it? Add the vertex to the list
|
|
if( newIndex == -1 )
|
|
{
|
|
newIndex = pStripGroup->verts.AddToTail( *pVert );
|
|
}
|
|
pStripGroup->indices.AddToTail( newIndex );
|
|
|
|
#ifdef _DEBUG
|
|
// float GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID );
|
|
int i;
|
|
float *pWeight = ( float * )_alloca( sizeof( float ) * pVert->numBones );
|
|
for( i = 0; i < pVert->numBones; i++ )
|
|
{
|
|
pWeight[i] = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, pVert, i );
|
|
}
|
|
#endif
|
|
|
|
// Keep track of the max # of bones in a vert
|
|
if (pVert->numBones > maxNumBones)
|
|
maxNumBones = pVert->numBones;
|
|
}
|
|
pStrip->numStripGroupIndices = pStripGroup->indices.Size() - pStrip->stripGroupIndexOffset;
|
|
pStrip->numStripGroupVerts = pStripGroup->verts.Size() - pStrip->stripGroupVertexOffset;
|
|
|
|
// The number of bones in a strip is the max number of
|
|
// bones in a vertex in this strip for vertex shaders, and it's the
|
|
// number of unique bones in the strip for fixed-function
|
|
if (!m_UsesFixedFunction)
|
|
pStrip->numBones = maxNumBones;
|
|
else
|
|
pStrip->numBones = CountUniqueBonesInStrip(pStripGroup, pStrip);
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns true if a particular mesh is teeth
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool COptimizedModel::MeshIsTeeth( studiohdr_t *pStudioHeader, mstudiomesh_t *pStudioMesh )
|
|
{
|
|
// The mesh is teeth if it's got a skin whose material has a non-zero flags
|
|
int i;
|
|
for( i = 0; i < pStudioHeader->numskinfamilies; i++ )
|
|
{
|
|
short *pskinref = pStudioHeader->pSkinref( 0 );
|
|
pskinref += ( i * pStudioHeader->numskinref );
|
|
mstudiotexture_t *ptexture;
|
|
ptexture = pStudioHeader->pTexture( pskinref[ pStudioMesh->material ] );
|
|
if( ptexture->flags )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the flags for a mesh
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::ComputeMeshFlags( Mesh_t *pMesh, studiohdr_t *pStudioHeader,
|
|
mstudiomesh_t *pStudioMesh )
|
|
{
|
|
// eyeball?
|
|
pMesh->flags = 0;
|
|
if( pStudioMesh->materialtype != 0 )
|
|
{
|
|
pMesh->flags |= MESH_IS_EYES;
|
|
}
|
|
|
|
// teeth?
|
|
if( MeshIsTeeth( pStudioHeader, pStudioMesh ) )
|
|
{
|
|
pMesh->flags |= MESH_IS_TEETH;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates 4 strip groups for a mesh, combinations of flexed + hwskinned
|
|
// A mesh has a single material
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::ProcessMesh( Mesh_t *pMesh, studiohdr_t *pStudioHeader,
|
|
CUtlVector<mstudioiface_t> &srcFaces,
|
|
mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh,
|
|
bool forceNoFlex, bool bForceSoftwareSkin, bool bHWFlex )
|
|
{
|
|
// Compute the mesh flags
|
|
ComputeMeshFlags( pMesh, pStudioHeader, pStudioMesh );
|
|
|
|
// We're gonna keep track of which ones we haven't processed
|
|
// because we're gonna add all unprocessed faces to the software
|
|
// lists if for some reason they don't get added to the hardware lists
|
|
TriangleProcessedList_t trianglesProcessed;
|
|
trianglesProcessed.AddMultipleToTail( srcFaces.Size() );
|
|
memset( trianglesProcessed.Base(), 0, trianglesProcessed.Size() );
|
|
|
|
// there are up to 4 stripgroups per mesh
|
|
// Note that we're gonna do the HW skinned versions first
|
|
// because they have the option of deciding not to be hardware after all
|
|
int isHWSkinned, isFlexed;
|
|
for( isHWSkinned = bForceSoftwareSkin ? 0 : 1; isHWSkinned >= 0; --isHWSkinned )
|
|
{
|
|
for( isFlexed = 1; isFlexed >= 0; --isFlexed )
|
|
{
|
|
int realMaxBonesPerTri, realMaxBonesPerVert, realMaxBonesPerStrip;
|
|
|
|
if( isFlexed && !bHWFlex )
|
|
{
|
|
realMaxBonesPerTri = 1;
|
|
realMaxBonesPerVert = 1;
|
|
realMaxBonesPerStrip = 1;
|
|
}
|
|
else
|
|
{
|
|
realMaxBonesPerTri = m_MaxBonesPerTri;
|
|
realMaxBonesPerVert = m_MaxBonesPerVert;
|
|
realMaxBonesPerStrip = m_MaxBonesPerStrip;
|
|
}
|
|
|
|
int newStripGroupIndex = pMesh->stripGroups.AddToTail( );
|
|
StripGroup_t& newStripGroup = pMesh->stripGroups[newStripGroupIndex];
|
|
ProcessStripGroup( &newStripGroup,
|
|
isHWSkinned ? true : false,
|
|
isFlexed ? true : false,
|
|
pStudioModel, pStudioMesh, srcFaces, trianglesProcessed,
|
|
realMaxBonesPerVert, realMaxBonesPerTri, realMaxBonesPerStrip, forceNoFlex, bHWFlex );
|
|
|
|
PostProcessStripGroup( pStudioModel, pStudioMesh, &newStripGroup );
|
|
|
|
// Clear out the strip group if there wasn't anything in it
|
|
if( !newStripGroup.indices.Size() )
|
|
pMesh->stripGroups.FastRemove( newStripGroupIndex );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// some setup required before we really get into it
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::SetupMeshProcessing( studiohdr_t *pHdr, int vertexCacheSize,
|
|
bool usesFixedFunction, int maxBonesPerVert, int maxBonesPerTri,
|
|
int maxBonesPerStrip, const char *fileName )
|
|
{
|
|
#ifdef NVTRISTRIP
|
|
// tell nvtristrip all of it's params
|
|
SetCacheSize( vertexCacheSize );
|
|
SetStitchStrips( true );
|
|
SetMinStripSize( 0 );
|
|
# ifdef EMIT_TRILISTS
|
|
SetListsOnly( true );
|
|
# else
|
|
SetListsOnly( false );
|
|
# endif
|
|
#endif // NVTRISTRIP
|
|
|
|
if( !g_quiet )
|
|
{
|
|
printf( "---------------------\n" );
|
|
printf( "Generating optimized mesh \"%s\":\n", fileName );
|
|
#ifdef _DEBUG
|
|
printf( "\tvertex cache size: %d\n", vertexCacheSize );
|
|
printf( "\tmax bones/tri: %d\n", maxBonesPerTri );
|
|
printf( "\tmax bones/vert: %d\n", maxBonesPerVert );
|
|
printf( "\tmax bones/strip: %d\n", maxBonesPerStrip );
|
|
#endif
|
|
}
|
|
|
|
CleanupEverything();
|
|
|
|
// Total number of bones in the original model
|
|
m_NumBones = pHdr->numbones;
|
|
|
|
// Hardware limitations
|
|
m_MaxBonesPerVert = maxBonesPerVert;
|
|
m_MaxBonesPerTri = maxBonesPerTri;
|
|
m_MaxBonesPerStrip = maxBonesPerStrip;
|
|
m_UsesFixedFunction = usesFixedFunction;
|
|
m_VertexCacheSize = vertexCacheSize;
|
|
|
|
// stats
|
|
m_NumSkinnedAndFlexedVerts = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Process the entire model, return stats...
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int COptimizedModel::GetTotalVertsForMesh( Mesh_t *pMesh )
|
|
{
|
|
int numVerts = 0;
|
|
int i;
|
|
for( i = 0; i < pMesh->stripGroups.Size(); i++ )
|
|
{
|
|
StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
|
|
numVerts += pStripGroup->verts.Size();
|
|
}
|
|
return numVerts;
|
|
}
|
|
|
|
int COptimizedModel::GetTotalIndicesForMesh( Mesh_t *pMesh )
|
|
{
|
|
int numIndices = 0;
|
|
int i;
|
|
for( i = 0; i < pMesh->stripGroups.Size(); i++ )
|
|
{
|
|
StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
|
|
numIndices += pStripGroup->indices.Size();
|
|
}
|
|
return numIndices;
|
|
}
|
|
|
|
int COptimizedModel::GetTotalStripsForMesh( Mesh_t *pMesh )
|
|
{
|
|
int numStrips = 0;
|
|
int i;
|
|
for( i = 0; i < pMesh->stripGroups.Size(); i++ )
|
|
{
|
|
StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
|
|
numStrips += pStripGroup->strips.Size();
|
|
}
|
|
return numStrips;
|
|
}
|
|
|
|
int COptimizedModel::GetTotalStripGroupsForMesh( Mesh_t *pMesh )
|
|
{
|
|
return pMesh->stripGroups.Size();
|
|
}
|
|
|
|
int COptimizedModel::GetTotalBoneStateChangesForMesh( Mesh_t *pMesh )
|
|
{
|
|
int numBoneStateChanges = 0;
|
|
int i;
|
|
for( i = 0; i < pMesh->stripGroups.Size(); i++ )
|
|
{
|
|
StripGroup_t *pStripGroup = &pMesh->stripGroups[i];
|
|
int j;
|
|
for( j = 0; j < pStripGroup->strips.Size(); j++ )
|
|
{
|
|
Strip_t *pStrip = &pStripGroup->strips[j];
|
|
numBoneStateChanges += pStrip->numBoneStateChanges;
|
|
}
|
|
}
|
|
return numBoneStateChanges;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
static void WriteDebugFile( const char *fileName, const char *outFileName, float red, float grn, float blu )
|
|
{
|
|
char *tmpName = ( char * )_alloca( strlen( fileName ) + 1 );
|
|
strcpy( tmpName, fileName );
|
|
|
|
s_source_t *pSrc = Load_Source( tmpName, "SMD" );
|
|
Assert( pSrc );
|
|
|
|
int i, j;
|
|
|
|
FILE *fp;
|
|
fp = fopen( outFileName, "w" );
|
|
Assert( fp );
|
|
|
|
for( i = 0; i < pSrc->nummeshes; i++ )
|
|
{
|
|
s_mesh_t *pMesh = &pSrc->mesh[i];
|
|
for( j = 0; j < pMesh->numfaces; j++ )
|
|
{
|
|
s_face_t *pFace = &pSrc->face[pMesh->faceoffset + j];
|
|
Vector &a = pSrc->vertex[pMesh->vertexoffset + pFace->a];
|
|
Vector &b = pSrc->vertex[pMesh->vertexoffset + pFace->b];
|
|
Vector &c = pSrc->vertex[pMesh->vertexoffset + pFace->c];
|
|
fprintf( fp, "3\n" );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", ( float )( a[0] ), ( float )( a[1] ), ( float )( a[2] ),
|
|
( float )red, ( float )grn, ( float )blu );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", ( float )( b[0] ), ( float )( b[1] ), ( float )( b[2] ),
|
|
( float )red, ( float )grn, ( float )blu );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", ( float )( c[0] ), ( float )( c[1] ), ( float )( c[2] ),
|
|
( float )red, ( float )grn, ( float )blu );
|
|
}
|
|
|
|
}
|
|
fclose( fp );
|
|
}
|
|
*/
|
|
|
|
void COptimizedModel::SourceMeshToTriangleList( s_model_t *pSrcModel, s_mesh_t *pSrcMesh,
|
|
CUtlVector<mstudioiface_t> &meshTriangleList )
|
|
{
|
|
s_face_t *pFaces = pSrcModel->source->face + pSrcMesh->faceoffset;
|
|
int i;
|
|
for ( i = 0; i < pSrcMesh->numfaces; i++ )
|
|
{
|
|
const s_face_t &pFace = pFaces[i];
|
|
int j = meshTriangleList.AddToTail();
|
|
mstudioiface_t &newTriangle = meshTriangleList[j];
|
|
newTriangle.a = pFace.a;
|
|
newTriangle.b = pFace.b;
|
|
newTriangle.c = pFace.c;
|
|
}
|
|
}
|
|
|
|
/*
|
|
static void WriteSourceMesh( s_model_t *pSrcModel, s_mesh_t *pSrcMesh, int red_, int grn_, int blu_ )
|
|
{
|
|
FILE *fp;
|
|
fp = fopen( "blah.glv", "a+" );
|
|
float red, grn, blu;
|
|
|
|
red = ( float )rand() / ( float )VALVE_RAND_MAX;
|
|
grn = ( float )rand() / ( float )VALVE_RAND_MAX;
|
|
blu = ( float )rand() / ( float )VALVE_RAND_MAX;
|
|
float len = red * red + grn * grn + blu * blu;
|
|
len = sqrt( len );
|
|
red *= 255.0f / len;
|
|
grn *= 255.0f / len;
|
|
blu *= 255.0f / len;
|
|
|
|
s_face_t *pFaces = pSrcModel->source->face + pSrcMesh->faceoffset;
|
|
int i;
|
|
for( i = 0; i < pSrcMesh->numfaces; i++ )
|
|
{
|
|
const s_face_t &face = pFaces[i];
|
|
Vector a, b, c;
|
|
a = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.a];
|
|
b = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.b];
|
|
c = pSrcModel->source->vertex[pSrcMesh->vertexoffset + face.c];
|
|
fprintf( fp, "3\n" );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", a[0], a[1], a[2], red, grn, blu );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", c[0], c[1], c[2], red, grn, blu );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", b[0], b[1], b[2], red, grn, blu );
|
|
}
|
|
fclose( fp );
|
|
}
|
|
*/
|
|
|
|
static void RandomColor( Vector& color )
|
|
{
|
|
color[0] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
|
|
color[1] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
|
|
color[2] = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
|
|
VectorNormalize( color );
|
|
}
|
|
|
|
/*
|
|
static void GLViewCube( Vector pos, float size, FILE *fp )
|
|
{
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
|
|
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
|
|
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
|
|
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
|
|
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] + size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] - size, pos[1] - size, pos[2] + size );
|
|
|
|
fprintf( fp, "4\n" );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] - size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] + size, pos[2] + size );
|
|
fprintf( fp, "%f %f %f 255 0 0\n", pos[0] + size, pos[1] - size, pos[2] + size );
|
|
}
|
|
*/
|
|
|
|
#if 0
|
|
static void MStudioBoneWeightToSBoneWeight( s_boneweight_t &sbone, const mstudioboneweight_t &mbone,
|
|
const s_source_t *pSrc )
|
|
{
|
|
int i;
|
|
for( i = 0; i < mbone.numbones; i++ )
|
|
{
|
|
sbone.bone[i] = pSrc->boneimap[mbone.bone[i]];
|
|
// sbone.bone[i] = mbone.bone[i];
|
|
sbone.weight[i] = mbone.weight[i];
|
|
}
|
|
sbone.numbones = mbone.numbones;
|
|
}
|
|
#endif
|
|
|
|
void COptimizedModel::CreateLODTriangleList( s_model_t *pSrcModel, int nLodID, s_source_t* pSrc,
|
|
mstudiomodel_t *pStudioModel,
|
|
mstudiomesh_t *pStudioMesh,
|
|
CUtlVector<mstudioiface_t> &meshTriangleList,
|
|
bool writeDebug )
|
|
{
|
|
if ( !pSrc || !pSrcModel )
|
|
return;
|
|
|
|
#ifdef _DEBUG
|
|
// const mstudio_modelvertexdata_t *vertData = pStudioModel->GetVertexData();
|
|
// Assert( vertData ); // This can only return NULL on X360 for now
|
|
// mstudiovertex_t *modelFirstVert = vertData->Vertex( 0 );
|
|
// mstudiovertex_t *modelLastVert = vertData->Vertex( pStudioModel->numvertices - 1 );
|
|
// mstudiovertex_t *meshFirstVert = vertData->Vertex( 0 );
|
|
// mstudiovertex_t *meshLastVert = vertData->Vertex( pStudioMesh->numvertices - 1 );
|
|
#endif
|
|
|
|
/*
|
|
if( writeDebug )
|
|
{
|
|
printf( "MODEL VERTS:\n" );
|
|
int i;
|
|
for( i = 0; i < pStudioModel->numvertices; i++ )
|
|
{
|
|
Vector &v = *pStudioModel->pVertex( i );
|
|
Vector &n = *pStudioModel->pNormal( i );
|
|
Vector2D &t = *pStudioModel->pTexcoord( i );
|
|
printf( "model %d: p %f %f %f n: %f %f %f t: %f %f\n",
|
|
i, v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1] );
|
|
}
|
|
printf( "MESH VERTS:\n" );
|
|
for( i = 0; i < pStudioMesh->numvertices; i++ )
|
|
{
|
|
Vector &v = *pStudioMesh->pVertex( i );
|
|
Vector &n = *pStudioMesh->pNormal( i );
|
|
Vector2D &t = *pStudioMesh->pTexcoord( i );
|
|
printf( "mesh %d: p %f %f %f n: %f %f %f t: %f %f\n",
|
|
i, v[0], v[1], v[2], n[0], n[1], n[2], t[0], t[1] );
|
|
}
|
|
}
|
|
*/
|
|
// need to find the mesh in the lod model that matches the original model.
|
|
int i;
|
|
int textureSearchID = MaterialToTexture( pStudioMesh->material );
|
|
|
|
// this is icky.. . pSrc->nummeshes really refers to the total number of non-empty meshes
|
|
// in the model. In pSrc->meshes, there are some empty meshes in the middle if they
|
|
// don't exist for the material, so you have to go through all of the meshes to find
|
|
// the non-empty ones.
|
|
s_mesh_t *pSrcMesh = NULL;
|
|
for ( i = 0; i < pStudioModel->nummeshes; i++ )
|
|
{
|
|
if ( pSrc->texmap[pSrc->meshindex[i]] == textureSearchID )
|
|
{
|
|
// woo hoo! found it.
|
|
pSrcMesh = &pSrc->mesh[pSrc->meshindex[i]];
|
|
break;
|
|
}
|
|
}
|
|
if ( !pSrcMesh )
|
|
{
|
|
//printf( "%s doesn't have material %d\n", lodSMDName, textureSearchID );
|
|
// There aren't any triangles in this lower lod with this material on it.
|
|
return;
|
|
}
|
|
|
|
CUtlVector<int> indexMapping;
|
|
indexMapping.AddMultipleToTail( pSrcMesh->numvertices );
|
|
|
|
for ( i = 0; i < pSrcMesh->numvertices; i++ )
|
|
{
|
|
// get the mapping between indices in the lod and their real pool location.
|
|
indexMapping[i] = pSrcModel->m_pLodData->pMeshVertIndexMaps[nLodID][pSrcMesh->vertexoffset + i];
|
|
}
|
|
|
|
// build the lod's faces so indexes map to remapped vertexes
|
|
for ( i = 0; i < pSrcMesh->numfaces; i++ )
|
|
{
|
|
int index = meshTriangleList.AddToTail();
|
|
mstudioiface_t& newFace = meshTriangleList[index];
|
|
const s_face_t &srcFace = pSrc->face[pSrcMesh->faceoffset + i];
|
|
newFace.a = indexMapping[srcFace.a];
|
|
newFace.b = indexMapping[srcFace.b];
|
|
newFace.c = indexMapping[srcFace.c];
|
|
}
|
|
}
|
|
|
|
|
|
bool ComparePath( const char *a, const char *b )
|
|
{
|
|
if ( strlen( a ) != strlen( b ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// case and seperator invariant
|
|
for ( ; *a; a++, b++ )
|
|
{
|
|
if ( *a == *b )
|
|
{
|
|
continue;
|
|
}
|
|
if ( tolower( *a ) == tolower( *b ) )
|
|
{
|
|
continue;
|
|
}
|
|
if ( ( *a == '/' || *a == '\\' ) &&
|
|
( *b == '/' || *b == '\\' ) )
|
|
{
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool COptimizedModel::MeshNeedsRemoval( studiohdr_t *pHdr, mstudiomesh_t *pStudioMesh,
|
|
LodScriptData_t& scriptLOD )
|
|
{
|
|
mstudiotexture_t *ptexture;
|
|
short *pskinref = pHdr->pSkinref( 0 );
|
|
ptexture = pHdr->pTexture( pskinref[ pStudioMesh->material ] );
|
|
const char *meshName = ptexture->material->GetName();
|
|
int i;
|
|
for( i = 0; i < scriptLOD.meshRemovals.Size(); i++ )
|
|
{
|
|
const char *meshRemovalName = scriptLOD.meshRemovals[i].GetSrcName();
|
|
if ( ComparePath( meshName, meshRemovalName ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Process the entire model, return stats...
|
|
//-----------------------------------------------------------------------------
|
|
void COptimizedModel::ProcessModel( studiohdr_t *pHdr, s_bodypart_t *pSrcBodyParts,
|
|
TotalMeshStats_t& stats, bool bForceSoftwareSkin, bool bHWFlex )
|
|
{
|
|
memset( &stats, 0, sizeof(stats) );
|
|
m_Models.RemoveAll();
|
|
|
|
int bodyPartID, modelID, meshID, lodID;
|
|
for ( bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++, stats.m_TotalBodyParts++ )
|
|
{
|
|
mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
|
|
s_bodypart_t *pSrcBodyPart = &pSrcBodyParts[bodyPartID];
|
|
for ( modelID = 0; modelID < pBodyPart->nummodels; modelID++, stats.m_TotalModels++ )
|
|
{
|
|
int i = m_Models.AddToTail();
|
|
Model_t& newModel = m_Models[i];
|
|
mstudiomodel_t *pStudioModel = pBodyPart->pModel( modelID );
|
|
s_model_t *pSrcModel = pSrcBodyPart->pmodel[modelID];
|
|
for ( lodID = 0; lodID < g_ScriptLODs.Count(); lodID++, stats.m_TotalModelLODs++ )
|
|
{
|
|
LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
|
|
s_source_t *pLODSource = pSrcModel->m_LodSources[lodID];
|
|
|
|
int i = newModel.modelLODs.AddToTail();
|
|
Assert( i == lodID );
|
|
ModelLOD_t& newLOD = newModel.modelLODs[i];
|
|
newLOD.switchPoint = scriptLOD.switchValue;
|
|
|
|
// In this case, we've been told to remove the model
|
|
if ( !pLODSource )
|
|
{
|
|
if ( pSrcModel && stricmp( pSrcModel->name, "blank" ) != 0)
|
|
{
|
|
// This is nonsensical
|
|
Assert( lodID != 0 );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
for ( meshID = 0; meshID < pStudioModel->nummeshes; meshID++, stats.m_TotalMeshes++ )
|
|
{
|
|
#ifdef _DEBUG
|
|
// printf( "bodyPart: %d model: %d modellod: %d mesh: %d\n", bodyPartID, modelID, lodID, meshID );
|
|
#endif
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
s_mesh_t *pSrcMesh = &pSrcModel->source->mesh[pSrcModel->source->meshindex[meshID]];
|
|
|
|
int i = newLOD.meshes.AddToTail();
|
|
Assert( i == meshID );
|
|
Mesh_t& newMesh = newLOD.meshes[i];
|
|
|
|
if ( MeshNeedsRemoval( pHdr, pStudioMesh, scriptLOD ) )
|
|
continue;
|
|
#ifdef _DEBUG
|
|
// int textureSearchID = material_to_texture( pStudioMesh->material );
|
|
// const char *pDebugName = pHdr->pTexture( textureSearchID )->pszName( );
|
|
#endif
|
|
CUtlVector<mstudioiface_t> meshTriangleList;
|
|
if ( pLODSource )
|
|
{
|
|
// map the lod data to triangles
|
|
// uses the original mesh redirected through a mapping table
|
|
// this expects built per lod-to-root mapping tables to generate faces
|
|
CreateLODTriangleList( pSrcModel, lodID, pLODSource, pStudioModel, pStudioMesh, meshTriangleList, false );
|
|
}
|
|
else
|
|
{
|
|
// build the triangle list from the unmapped source
|
|
SourceMeshToTriangleList( pSrcModel, pSrcMesh, meshTriangleList );
|
|
}
|
|
|
|
ProcessMesh( &newMesh, pHdr, meshTriangleList, pStudioModel, pStudioMesh,
|
|
!scriptLOD.GetFacialAnimationEnabled(), bForceSoftwareSkin, bHWFlex );
|
|
|
|
stats.m_TotalVerts += GetTotalVertsForMesh( &newMesh );
|
|
stats.m_TotalIndices += GetTotalIndicesForMesh( &newMesh );
|
|
stats.m_TotalStrips += GetTotalStripsForMesh( &newMesh );
|
|
stats.m_TotalStripGroups += GetTotalStripGroupsForMesh( &newMesh );
|
|
stats.m_TotalBoneStateChanges += GetTotalBoneStateChangesForMesh( &newMesh );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Some processing that happens at the end
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::MapGlobalBonesToHardwareBoneIDsAndSortBones( studiohdr_t *phdr )
|
|
{
|
|
// garymcthack: holy jesus is this function long!
|
|
#ifdef IGNORE_BONES
|
|
return;
|
|
#endif
|
|
|
|
int *globalToHardwareBoneIndex;
|
|
int hardwareToGlobalBoneIndex[MAX_NUM_BONES_PER_STRIP];
|
|
|
|
globalToHardwareBoneIndex = ( int * )_alloca( m_NumBones * sizeof( int ) );
|
|
Assert( globalToHardwareBoneIndex );
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
for( int lodID = 0; lodID < header->numLODs; lodID++ )
|
|
{
|
|
// Dear LORD! This needs to be in another function! (garymcthack)
|
|
int i;
|
|
for( i = 0; i < m_NumBones; i++ )
|
|
{
|
|
globalToHardwareBoneIndex[i] = -1;
|
|
}
|
|
for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
|
|
{
|
|
hardwareToGlobalBoneIndex[i] = -1;
|
|
}
|
|
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
// Only do this to HW-skinned meshes
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
if( !( pStripGroup->flags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
continue;
|
|
}
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
// printf( "UPDATING BONE STATE\n" );
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
|
|
// Generate mapping back and forth between hardware IDs and original bone IDs
|
|
int boneStateChangeID;
|
|
for( boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
|
|
{
|
|
BoneStateChangeHeader_t *pBoneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
|
|
globalToHardwareBoneIndex[pBoneStateChange->newBoneID] = pBoneStateChange->hardwareID;
|
|
if( pBoneStateChange->hardwareID != -1 )
|
|
{
|
|
hardwareToGlobalBoneIndex[pBoneStateChange->hardwareID] = pBoneStateChange->newBoneID;
|
|
}
|
|
}
|
|
int vertID;
|
|
for( vertID = 0; vertID < pStrip->numVerts; vertID++ )
|
|
{
|
|
Vertex_t *vert = pStripGroup->pVertex( vertID + pStrip->vertOffset );
|
|
int boneID;
|
|
for( boneID = 0; boneID < header->maxBonesPerVert; boneID++ )
|
|
{
|
|
int globalBoneID = vert->boneID[boneID];
|
|
if( globalBoneID == -1 )
|
|
{
|
|
// this index isn't used.
|
|
vert->boneID[boneID] = 0;
|
|
// make sure it's associated weight is zero.
|
|
// Assert( vert->boneWeights[boneID] == 0 );
|
|
continue;
|
|
}
|
|
Assert( globalBoneID >= 0 && globalBoneID < m_NumBones );
|
|
vert->boneID[boneID] = globalToHardwareBoneIndex[globalBoneID];
|
|
Assert( vert->boneID[boneID] >= 0 && vert->boneID[boneID] < header->maxBonesPerStrip );
|
|
}
|
|
|
|
// We only do index palette skinning when we're not doing fixed function
|
|
if (m_UsesFixedFunction)
|
|
{
|
|
// bool flexed = pStripGroup->flags & STRIPGROUP_IS_FLEXED;
|
|
SortBonesWithinVertex( false /* flexed */, vert, pStudioModel,
|
|
pStudioMesh, globalToHardwareBoneIndex, hardwareToGlobalBoneIndex,
|
|
m_MaxBonesPerTri, m_MaxBonesPerVert );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// The following methods are associated with writing a .vtx file
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::WriteHeader( int vertCacheSize, int maxBonesPerVert,
|
|
int maxBonesPerTri, int maxBonesPerStrip, int numBodyParts, long checkSum )
|
|
{
|
|
FileHeader_t fileHeader;
|
|
|
|
fileHeader.version = OPTIMIZED_MODEL_FILE_VERSION;
|
|
fileHeader.vertCacheSize = vertCacheSize;
|
|
fileHeader.maxBonesPerTri = IsUShort( maxBonesPerTri );
|
|
fileHeader.maxBonesPerVert = maxBonesPerVert;
|
|
fileHeader.maxBonesPerStrip = IsUShort( maxBonesPerStrip );
|
|
fileHeader.numBodyParts = numBodyParts;
|
|
fileHeader.bodyPartOffset = sizeof( FileHeader_t );
|
|
fileHeader.checkSum = checkSum;
|
|
fileHeader.numLODs = g_ScriptLODs.Size();
|
|
fileHeader.materialReplacementListOffset = m_MaterialReplacementsListOffset;
|
|
m_FileBuffer->WriteAt( 0, &fileHeader, sizeof( FileHeader_t ), "header" );
|
|
#ifdef _DEBUG
|
|
// FileHeader_t *debug = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
// BodyPartHeader_t *pBodyPart = debug->pBodyPart( 0 );
|
|
#endif
|
|
}
|
|
|
|
|
|
void COptimizedModel::WriteBodyPart( int bodyPartID, mstudiobodyparts_t *pBodyPart, int modelID )
|
|
{
|
|
BodyPartHeader_t bodyPart;
|
|
bodyPart.numModels = pBodyPart->nummodels;
|
|
int bodyPartOffset = m_BodyPartsOffset + bodyPartID * sizeof( BodyPartHeader_t );
|
|
int modelFileOffset = m_ModelsOffset + modelID * sizeof( ModelHeader_t );
|
|
bodyPart.modelOffset = modelFileOffset - bodyPartOffset;
|
|
m_FileBuffer->WriteAt( bodyPartOffset, &bodyPart, sizeof( BodyPartHeader_t ), "bodypart" );
|
|
#ifdef _DEBUG
|
|
// BodyPartHeader_t *debug = ( BodyPartHeader_t * )m_FileBuffer->GetPointer( bodyPartOffset );
|
|
// ModelHeader_t *pModel = debug->pModel( 0 );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::WriteModel( int modelID, mstudiomodel_t *pModel, int lodID )
|
|
{
|
|
ModelHeader_t model;
|
|
model.numLODs = IsChar( g_ScriptLODs.Size() );
|
|
int modelFileOffset = m_ModelsOffset + modelID * sizeof( ModelHeader_t );
|
|
int lodFileOffset = m_ModelLODsOffset + lodID * sizeof( ModelLODHeader_t );
|
|
model.lodOffset = lodFileOffset - modelFileOffset;
|
|
m_FileBuffer->WriteAt( modelFileOffset, &model, sizeof( ModelHeader_t ), "model" );
|
|
#ifdef _DEBUG
|
|
// ModelHeader_t *debug = ( ModelHeader_t * )m_FileBuffer->GetPointer( modelFileOffset );
|
|
// ModelLODHeader_t *pLOD = debug->pLOD( 0 );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::WriteModelLOD( int lodID, ModelLOD_t *pLOD, int meshID )
|
|
{
|
|
ModelLODHeader_t lod;
|
|
int lodFileOffset = m_ModelLODsOffset + lodID * sizeof( ModelLODHeader_t );
|
|
int meshFileOffset = m_MeshesOffset + meshID * sizeof( MeshHeader_t );
|
|
lod.meshOffset = meshFileOffset - lodFileOffset;
|
|
lod.numMeshes = pLOD->meshes.Size();
|
|
lod.switchPoint = pLOD->switchPoint;
|
|
m_FileBuffer->WriteAt( lodFileOffset, &lod, sizeof( ModelLODHeader_t ), "modellod" );
|
|
#ifdef _DEBUG
|
|
// ModelLODHeader_t *debug = ( ModelLODHeader_t * )m_FileBuffer->GetPointer( lodFileOffset );
|
|
// MeshHeader_t *pMesh = debug->pMesh( 0 );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::WriteMesh( int meshID, Mesh_t *pMesh, int stripGroupID )
|
|
{
|
|
MeshHeader_t mesh;
|
|
mesh.numStripGroups = IsChar( pMesh->stripGroups.Size() );
|
|
int meshFileOffset = m_MeshesOffset + meshID * sizeof( MeshHeader_t );
|
|
int stripGroupFileOffset = m_StripGroupsOffset + stripGroupID * sizeof( StripGroupHeader_t );
|
|
mesh.stripGroupHeaderOffset = stripGroupFileOffset - meshFileOffset;
|
|
mesh.flags = pMesh->flags;
|
|
m_FileBuffer->WriteAt( meshFileOffset, &mesh, sizeof( MeshHeader_t ), "mesh" );
|
|
#ifdef _DEBUG
|
|
// MeshHeader_t *debug = ( MeshHeader_t * )m_FileBuffer->GetPointer( meshFileOffset );
|
|
// StripGroupHeader_t *pStripGroup = debug->pStripGroup( 0 );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::WriteStripGroup( int stripGroupID, StripGroup_t *pStripGroup,
|
|
int vertID, int indexID, int stripID )
|
|
{
|
|
StripGroupHeader_t stripGroup;
|
|
stripGroup.numVerts = pStripGroup->verts.Size();
|
|
stripGroup.numIndices = pStripGroup->indices.Size();
|
|
stripGroup.numStrips = pStripGroup->strips.Size();
|
|
stripGroup.flags = IsByte( pStripGroup->flags );
|
|
int stripGroupFileOffset = m_StripGroupsOffset + stripGroupID * sizeof( StripGroupHeader_t );
|
|
int vertsFileOffset = m_VertsOffset + vertID * sizeof( Vertex_t );
|
|
int indicesFileOffset = m_IndicesOffset + indexID * sizeof( unsigned short );
|
|
int stripsFileOffset = m_StripsOffset + stripID * sizeof( StripHeader_t );
|
|
stripGroup.vertOffset = vertsFileOffset - stripGroupFileOffset;
|
|
stripGroup.indexOffset = indicesFileOffset - stripGroupFileOffset;
|
|
stripGroup.stripOffset = stripsFileOffset - stripGroupFileOffset;
|
|
m_FileBuffer->WriteAt( stripGroupFileOffset, &stripGroup, sizeof( StripGroupHeader_t), "strip group" );
|
|
#ifdef _DEBUG
|
|
// StripGroupHeader_t *debug = ( StripGroupHeader_t * )m_FileBuffer->GetPointer( stripGroupFileOffset );
|
|
// unsigned short *pIndex = debug->pIndex( 0 );
|
|
// Vertex_t *pVert = debug->pVertex( 0 );
|
|
// StripHeader_t *pStripHeader = debug->pStrip( 0 );
|
|
#endif
|
|
}
|
|
|
|
int COptimizedModel::WriteVerts( int vertID, StripGroup_t *pStripGroup )
|
|
{
|
|
int vertFileOffset = m_VertsOffset + vertID * sizeof( Vertex_t );
|
|
int numVerts = pStripGroup->verts.Size();
|
|
m_FileBuffer->WriteAt( vertFileOffset, &pStripGroup->verts[0], sizeof( Vertex_t ) * numVerts, "verts" );
|
|
#ifdef _DEBUG
|
|
// Vertex_t *debug = ( Vertex_t * )m_FileBuffer->GetPointer( vertFileOffset );
|
|
#endif
|
|
return numVerts;
|
|
}
|
|
|
|
int COptimizedModel::WriteIndices( int indexID, StripGroup_t *pStripGroup )
|
|
{
|
|
int indexFileOffset = m_IndicesOffset + indexID * sizeof( unsigned short );
|
|
int numIndices = pStripGroup->indices.Size();
|
|
m_FileBuffer->WriteAt( indexFileOffset, &pStripGroup->indices[0], sizeof( unsigned short ) * numIndices, "indices" );
|
|
#ifdef _DEBUG
|
|
// unsigned short *debug = ( unsigned short * )m_FileBuffer->GetPointer( indexFileOffset );
|
|
#endif
|
|
return numIndices;
|
|
}
|
|
|
|
void COptimizedModel::WriteStrip( int stripID, Strip_t *pStrip, int indexID, int vertID, int boneID )
|
|
{
|
|
StripHeader_t stripHeader;
|
|
|
|
stripHeader.numIndices = pStrip->numStripGroupIndices;
|
|
stripHeader.indexOffset = pStrip->stripGroupIndexOffset;
|
|
stripHeader.numVerts = pStrip->numStripGroupVerts;
|
|
stripHeader.vertOffset = pStrip->stripGroupVertexOffset;
|
|
stripHeader.numBoneStateChanges = pStrip->numBoneStateChanges;
|
|
stripHeader.numBones = IsShort( pStrip->numBones );
|
|
stripHeader.flags = IsByte( pStrip->flags );
|
|
int boneFileOffset = m_BoneStageChangesOffset + boneID * sizeof( BoneStateChangeHeader_t );
|
|
int stripFileOffset = m_StripsOffset + stripID * sizeof( StripHeader_t );
|
|
stripHeader.boneStateChangeOffset = IsInt24( boneFileOffset - stripFileOffset );
|
|
m_FileBuffer->WriteAt( stripFileOffset, &stripHeader, sizeof( StripHeader_t ), "strip" );
|
|
#ifdef _DEBUG
|
|
// StripHeader_t *debug = ( StripHeader_t* )m_FileBuffer->GetPointer( stripFileOffset );
|
|
// BoneStateChangeHeader_t *pBoneStateChange = debug->pBoneStateChange( 0 );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::WriteBoneStateChange( int boneID, BoneStateChange_t *boneStateChange )
|
|
{
|
|
BoneStateChangeHeader_t boneHeader;
|
|
boneHeader.hardwareID = boneStateChange->hardwareID;
|
|
boneHeader.newBoneID = boneStateChange->newBoneID;
|
|
int boneFileOffset = m_BoneStageChangesOffset + boneID * sizeof( BoneStateChangeHeader_t );
|
|
#if 0
|
|
printf( "\tboneStateChange: hwid: %d boneID %d\n", ( int )boneHeader.hardwareID,
|
|
( int )boneHeader.newBoneID );
|
|
#endif
|
|
m_FileBuffer->WriteAt( boneFileOffset, &boneHeader, sizeof( BoneStateChangeHeader_t ), "bone" );
|
|
#ifdef _DEBUG
|
|
// BoneStateChangeHeader_t *debug = ( BoneStateChangeHeader_t * )m_FileBuffer->GetPointer( boneFileOffset );
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::ZeroNumBones( void )
|
|
{
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
int bodyPartID, modelID, lodID, meshID, stripGroupID, vertID, stripID;
|
|
for( bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *pBodyPart = header->pBodyPart( bodyPartID );
|
|
for( modelID = 0; modelID < pBodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *pModel = pBodyPart->pModel( modelID );
|
|
for( lodID = 0; lodID < pModel->numLODs; lodID++ )
|
|
{
|
|
ModelLODHeader_t *pLOD = pModel->pLOD( lodID );
|
|
for( meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *pMesh = pLOD->pMesh( meshID );
|
|
for( stripGroupID = 0; stripGroupID < pMesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = pMesh->pStripGroup( stripGroupID );
|
|
for( vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
|
|
{
|
|
Vertex_t *pVert = pStripGroup->pVertex( vertID );
|
|
pVert->numBones = 0;
|
|
}
|
|
for( stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
pStrip->numBones = 0;
|
|
pStrip->numBoneStateChanges = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::WriteStringTable( int stringTableOffset )
|
|
{
|
|
int stringTableSize = s_StringTable.CalcSize();
|
|
if( stringTableSize == 0 )
|
|
{
|
|
return;
|
|
}
|
|
char *pTmp = new char[stringTableSize];
|
|
s_StringTable.WriteToMem( pTmp );
|
|
m_FileBuffer->WriteAt( stringTableOffset, pTmp, stringTableSize, "string table" );
|
|
// char *pDebug = ( char * )m_FileBuffer->GetPointer( stringTableOffset );
|
|
delete [] pTmp;
|
|
}
|
|
|
|
void COptimizedModel::WriteMaterialReplacements( int materialReplacementsOffset )
|
|
{
|
|
int offset = materialReplacementsOffset;
|
|
int i, j;
|
|
int numLODs = g_ScriptLODs.Size();
|
|
for( i = 0; i < numLODs; i++ )
|
|
{
|
|
LodScriptData_t &scriptLOD = g_ScriptLODs[i];
|
|
for( j = 0; j < scriptLOD.materialReplacements.Size(); j++ )
|
|
{
|
|
CLodScriptReplacement_t &materialReplacement = scriptLOD.materialReplacements[j];
|
|
MaterialReplacementHeader_t tmpHeader;
|
|
tmpHeader.materialID = FindMaterialByName( materialReplacement.GetSrcName() );
|
|
tmpHeader.replacementMaterialNameOffset = m_StringTableOffset +
|
|
s_StringTable.StringTableOffset( materialReplacement.GetDstName() ) - offset;
|
|
m_FileBuffer->WriteAt( offset, &tmpHeader, sizeof( tmpHeader ), "material replacements" );
|
|
offset += sizeof( MaterialReplacementHeader_t );
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::WriteMaterialReplacementLists( int materialReplacementsOffset, int materialReplacementListOffset )
|
|
{
|
|
int replacementOffset = materialReplacementsOffset;
|
|
int offset = materialReplacementListOffset;
|
|
int i;
|
|
int numLODs = g_ScriptLODs.Size();
|
|
for( i = 0; i < numLODs; i++ )
|
|
{
|
|
LodScriptData_t &scriptLOD = g_ScriptLODs[i];
|
|
MaterialReplacementListHeader_t tmpHeader;
|
|
tmpHeader.numReplacements = IsChar( scriptLOD.materialReplacements.Size() );
|
|
tmpHeader.replacementOffset = IsInt24( replacementOffset - offset );
|
|
m_FileBuffer->WriteAt( offset, &tmpHeader, sizeof( tmpHeader ), "material replacement headers" );
|
|
MaterialReplacementListHeader_t *pDebugList =
|
|
( MaterialReplacementListHeader_t * )m_FileBuffer->GetPointer( offset );
|
|
if( pDebugList->numReplacements )
|
|
{
|
|
// MaterialReplacementHeader_t *pDebug = pDebugList->pMaterialReplacement( 0 );
|
|
// const char *string = pDebug->pMaterialReplacementName();
|
|
}
|
|
replacementOffset += tmpHeader.numReplacements * sizeof( MaterialReplacementHeader_t );
|
|
offset += sizeof( MaterialReplacementListHeader_t );
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::SanityCheckVertexBoneLODFlags( studiohdr_t *pStudioHdr, FileHeader_t *pVtxHeader )
|
|
{
|
|
int bodyPartID;
|
|
for( bodyPartID = 0; bodyPartID < pStudioHdr->numbodyparts; bodyPartID++ )
|
|
{
|
|
mstudiobodyparts_t *pBodyPart = pStudioHdr->pBodypart( bodyPartID );
|
|
BodyPartHeader_t *pVtxBodyPart = pVtxHeader->pBodyPart( bodyPartID );
|
|
int modelID;
|
|
for( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
|
|
{
|
|
mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
|
|
ModelHeader_t *pVtxModel = pVtxBodyPart->pModel( modelID );
|
|
int lodID;
|
|
for( lodID = 0; lodID < pVtxModel->numLODs; lodID++ )
|
|
{
|
|
ModelLODHeader_t *pVtxLOD = pVtxModel->pLOD( lodID );
|
|
int meshID;
|
|
Assert( pVtxLOD->numMeshes == pModel->nummeshes );
|
|
for( meshID = 0; meshID < pVtxLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *pVtxMesh = pVtxLOD->pMesh( meshID );
|
|
mstudiomesh_t *pMesh = pModel->pMesh( meshID );
|
|
int stripGroupID;
|
|
for( stripGroupID = 0; stripGroupID < pVtxMesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = pVtxMesh->pStripGroup( stripGroupID );
|
|
int vertID;
|
|
for( vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
|
|
{
|
|
Vertex_t *pVertex = pStripGroup->pVertex( vertID );
|
|
Vector pos = GetOrigVertPosition( pModel, pMesh, pVertex );
|
|
const mstudioboneweight_t &boneWeight = GetOrigVertBoneWeight( pModel, pMesh, pVertex );
|
|
int i;
|
|
|
|
for( i = 0; i < boneWeight.numbones; i++ )
|
|
{
|
|
mstudiobone_t *pBone = pStudioHdr->pBone( boneWeight.bone[i] );
|
|
// const char *pBoneName = pBone->pszName();
|
|
if (!( pBone->flags & ( BONE_USED_BY_VERTEX_LOD0 << lodID ) ))
|
|
{
|
|
MdlError("Mismarked Bone flag");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::WriteVTXFile( studiohdr_t *pHdr, const char *pFileName,
|
|
TotalMeshStats_t const& stats )
|
|
{
|
|
|
|
// calculate file offsets
|
|
m_FileBuffer = new CFileBuffer( FILEBUFFER_SIZE );
|
|
m_BodyPartsOffset = sizeof( FileHeader_t );
|
|
m_ModelsOffset = m_BodyPartsOffset + sizeof( BodyPartHeader_t ) * stats.m_TotalBodyParts;
|
|
m_ModelLODsOffset = m_ModelsOffset + sizeof( ModelHeader_t ) * stats.m_TotalModels;
|
|
m_MeshesOffset = m_ModelLODsOffset + sizeof( ModelLODHeader_t ) * stats.m_TotalModelLODs;
|
|
m_StripGroupsOffset = m_MeshesOffset + sizeof( MeshHeader_t ) * stats.m_TotalMeshes;
|
|
m_StripsOffset = m_StripGroupsOffset + sizeof( StripGroupHeader_t ) * stats.m_TotalStripGroups;
|
|
m_VertsOffset = m_StripsOffset + sizeof( StripHeader_t ) * stats.m_TotalStrips;
|
|
m_IndicesOffset = m_VertsOffset + sizeof( Vertex_t ) * stats.m_TotalVerts;
|
|
m_BoneStageChangesOffset = m_IndicesOffset + sizeof( unsigned short ) * stats.m_TotalIndices;
|
|
m_StringTableOffset = m_BoneStageChangesOffset + sizeof( BoneStateChangeHeader_t ) * stats.m_TotalBoneStateChanges;
|
|
m_MaterialReplacementsOffset = m_StringTableOffset + s_StringTable.CalcSize();
|
|
m_MaterialReplacementsListOffset = m_MaterialReplacementsOffset + stats.m_TotalMaterialReplacements * sizeof( MaterialReplacementHeader_t );
|
|
m_EndOfFileOffset = m_MaterialReplacementsListOffset + g_ScriptLODs.Count() * sizeof( MaterialReplacementListHeader_t );
|
|
|
|
int curModel = 0;
|
|
int curLOD = 0;
|
|
int curMesh = 0;
|
|
int curStrip = 0;
|
|
int curStripGroup = 0;
|
|
int curVert = 0;
|
|
int curIndex = 0;
|
|
int curBoneStateChange = 0;
|
|
int deltaModel = 0;
|
|
int deltaLOD = 0;
|
|
int deltaMesh = 0;
|
|
int deltaStrip = 0;
|
|
int deltaStripGroup = 0;
|
|
int deltaVert = 0;
|
|
int deltaIndex = 0;
|
|
int deltaBoneStateChange = 0;
|
|
|
|
WriteStringTable( m_StringTableOffset );
|
|
WriteMaterialReplacements( m_MaterialReplacementsOffset );
|
|
WriteMaterialReplacementLists( m_MaterialReplacementsOffset, m_MaterialReplacementsListOffset );
|
|
|
|
for( int bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++ )
|
|
{
|
|
mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
|
|
for( int modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
|
|
{
|
|
mstudiomodel_t *pStudioModel = pBodyPart->pModel( modelID );
|
|
Model_t *pModel = &m_Models[curModel + deltaModel];
|
|
for( int lodID = 0; lodID < g_ScriptLODs.Count(); lodID++ )
|
|
{
|
|
// printf( "lod: %d\n", lodID );
|
|
ModelLOD_t *pLOD = &pModel->modelLODs[lodID];
|
|
for( int meshID = 0; meshID < pStudioModel->nummeshes; meshID++ )
|
|
{
|
|
Mesh_t *pMesh = &pLOD->meshes[meshID];
|
|
for( int stripGroupID = 0; stripGroupID < pMesh->stripGroups.Count(); stripGroupID++ )
|
|
{
|
|
StripGroup_t *pStripGroup = &pMesh->stripGroups[stripGroupID];
|
|
deltaVert += WriteVerts( curVert + deltaVert, pStripGroup );
|
|
deltaIndex += WriteIndices( curIndex + deltaIndex, pStripGroup );
|
|
|
|
int nStripCount = pStripGroup->strips.Count();
|
|
for( int stripID = 0; stripID < nStripCount; stripID++ )
|
|
{
|
|
Strip_t *pStrip = &pStripGroup->strips[stripID];
|
|
for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
|
|
{
|
|
WriteBoneStateChange( curBoneStateChange + deltaBoneStateChange, &pStrip->boneStateChanges[boneStateChangeID] );
|
|
deltaBoneStateChange++;
|
|
}
|
|
WriteStrip( curStrip + deltaStrip, pStrip, curIndex, curVert, curBoneStateChange );
|
|
deltaStrip++;
|
|
curBoneStateChange += deltaBoneStateChange;
|
|
deltaBoneStateChange = 0;
|
|
}
|
|
WriteStripGroup( curStripGroup + deltaStripGroup, pStripGroup, curVert, curIndex, curStrip );
|
|
deltaStripGroup++;
|
|
curStrip += deltaStrip;
|
|
deltaStrip = 0;
|
|
curVert += deltaVert;
|
|
deltaVert = 0;
|
|
curIndex += deltaIndex;
|
|
deltaIndex = 0;
|
|
}
|
|
WriteMesh( curMesh + deltaMesh, pMesh, curStripGroup );
|
|
deltaMesh++;
|
|
curStripGroup += deltaStripGroup;
|
|
deltaStripGroup = 0;
|
|
}
|
|
WriteModelLOD( curLOD + deltaLOD, pLOD, curMesh );
|
|
deltaLOD++;
|
|
curMesh += deltaMesh;
|
|
deltaMesh = 0;
|
|
}
|
|
WriteModel( curModel + deltaModel, pStudioModel, curLOD );
|
|
deltaModel++;
|
|
curLOD += deltaLOD;
|
|
deltaLOD = 0;
|
|
}
|
|
WriteBodyPart( bodyPartID, pBodyPart, curModel );
|
|
curModel += deltaModel;
|
|
deltaModel = 0;
|
|
}
|
|
|
|
WriteHeader( m_VertexCacheSize, m_MaxBonesPerVert, m_MaxBonesPerTri,
|
|
m_MaxBonesPerStrip, pHdr->numbodyparts, pHdr->checksum );
|
|
|
|
#ifdef _DEBUG
|
|
m_FileBuffer->TestWritten( m_EndOfFileOffset );
|
|
#endif
|
|
|
|
MapGlobalBonesToHardwareBoneIDsAndSortBones( pHdr );
|
|
|
|
// DebugCompareVerts( phdr );
|
|
SanityCheckAgainstStudioHDR( pHdr );
|
|
|
|
if ( !g_quiet )
|
|
{
|
|
OutputMemoryUsage();
|
|
}
|
|
|
|
RemoveRedundantBoneStateChanges();
|
|
if( g_staticprop )
|
|
{
|
|
ZeroNumBones();
|
|
}
|
|
|
|
// Show statistics
|
|
#ifdef _DEBUG
|
|
// ShowStats();
|
|
#endif
|
|
|
|
m_FileBuffer->WriteToFile( pFileName, m_EndOfFileOffset );
|
|
|
|
FileHeader_t *pVtxHeader = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
SanityCheckVertexBoneLODFlags( pHdr, pVtxHeader );
|
|
}
|
|
|
|
|
|
|
|
static void MergeLikeBoneIndicesWithinVert( mstudioboneweight_t *pBoneWeight )
|
|
{
|
|
if( pBoneWeight->numbones == 1 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int i, j;
|
|
int realNumBones = pBoneWeight->numbones;
|
|
for( i = 0; i < pBoneWeight->numbones; i++ )
|
|
{
|
|
for( j = i+1; j < pBoneWeight->numbones; j++ )
|
|
{
|
|
if( ( pBoneWeight->bone[i] == pBoneWeight->bone[j] ) && ( pBoneWeight->weight[i] != 0.0f ) )
|
|
{
|
|
pBoneWeight->weight[i] += pBoneWeight->weight[j];
|
|
pBoneWeight->weight[j] = 0.0f;
|
|
realNumBones--;
|
|
}
|
|
}
|
|
}
|
|
|
|
// force all of the -1's at the end with a bubble sort
|
|
|
|
float tmpWeight;
|
|
int tmpIndex;
|
|
// bubble sort the bones.
|
|
for( j = pBoneWeight->numbones; j > 1; j-- )
|
|
{
|
|
int k;
|
|
for( k = 0; k < j - 1; k++ )
|
|
{
|
|
if( ( pBoneWeight->weight[k] == 0.0f ) && ( pBoneWeight->weight[k+1] != 0.0f ) )
|
|
{
|
|
// swap
|
|
tmpIndex = pBoneWeight->bone[k];
|
|
tmpWeight = pBoneWeight->weight[k];
|
|
pBoneWeight->bone[k] = pBoneWeight->bone[k+1];
|
|
pBoneWeight->weight[k] = pBoneWeight->weight[k+1];
|
|
pBoneWeight->bone[k+1] = tmpIndex;
|
|
pBoneWeight->weight[k+1] = tmpWeight;
|
|
}
|
|
}
|
|
}
|
|
pBoneWeight->numbones = realNumBones;
|
|
}
|
|
|
|
static void MergeLikeBoneIndicesWithinVerts( studiohdr_t *pHdr )
|
|
{
|
|
int bodyPartID, modelID, vertID;
|
|
for( bodyPartID = 0; bodyPartID < pHdr->numbodyparts; bodyPartID++ )
|
|
{
|
|
mstudiobodyparts_t *pBodyPart = pHdr->pBodypart( bodyPartID );
|
|
for( modelID = 0; modelID < pBodyPart->nummodels; modelID++ )
|
|
{
|
|
mstudiomodel_t *pModel = pBodyPart->pModel( modelID );
|
|
for( vertID = 0; vertID < pModel->numvertices; vertID++ )
|
|
{
|
|
const mstudio_modelvertexdata_t *vertData = pModel->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
mstudioboneweight_t *pBoneWeight = vertData->BoneWeights( vertID );
|
|
MergeLikeBoneIndicesWithinVert( pBoneWeight );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::PrintBoneStateChanges( studiohdr_t *phdr, int lod )
|
|
{
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
// mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
// for( int lodID = 0; lodID < header->numLODs; lodID++ )
|
|
int lodID = lod;
|
|
{
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
// mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
// mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
|
|
{
|
|
BoneStateChangeHeader_t *pBoneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
|
|
printf( "bone change: hwid: %d boneid: %d (%s)\n",
|
|
( int )pBoneStateChange->hardwareID,
|
|
( int )pBoneStateChange->newBoneID,
|
|
g_bonetable[pBoneStateChange->newBoneID].name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::PrintVerts( studiohdr_t *phdr, int lod )
|
|
{
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
// for( int lodID = 0; lodID < header->numLODs; lodID++ )
|
|
int lodID = lod;
|
|
{
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
for( int vertID = 0; vertID < pStripGroup->numVerts; vertID++ )
|
|
{
|
|
PrintVert( pStripGroup->pVertex( vertID ), pStudioModel, pStudioMesh );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int CalcNumMaterialReplacements()
|
|
{
|
|
int i;
|
|
int numReplacements = 0;
|
|
int numLODs = g_ScriptLODs.Size();
|
|
for( i = 0; i < numLODs; i++ )
|
|
{
|
|
LodScriptData_t &scriptLOD = g_ScriptLODs[i];
|
|
numReplacements += scriptLOD.materialReplacements.Size();
|
|
}
|
|
return numReplacements;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Main entry point
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool COptimizedModel::OptimizeFromStudioHdr( studiohdr_t *pHdr, s_bodypart_t *pSrcBodyParts,
|
|
int vertCacheSize,
|
|
bool usesFixedFunction, bool bForceSoftwareSkin, bool bHWFlex, int maxBonesPerVert, int maxBonesPerTri,
|
|
int maxBonesPerStrip, const char *pFileName, const char *glViewFileName )
|
|
{
|
|
Assert( maxBonesPerVert <= MAX_NUM_BONES_PER_VERT );
|
|
Assert( maxBonesPerTri <= MAX_NUM_BONES_PER_TRI );
|
|
Assert( maxBonesPerStrip <= MAX_NUM_BONES_PER_STRIP );
|
|
|
|
MergeLikeBoneIndicesWithinVerts( pHdr );
|
|
|
|
// Some initialization shite
|
|
SetupMeshProcessing( pHdr, vertCacheSize, usesFixedFunction, maxBonesPerVert,
|
|
maxBonesPerTri, maxBonesPerStrip, pFileName );
|
|
|
|
// The dude that does it all
|
|
TotalMeshStats_t stats;
|
|
ProcessModel( pHdr, pSrcBodyParts, stats, bForceSoftwareSkin, bHWFlex );
|
|
stats.m_TotalMaterialReplacements = CalcNumMaterialReplacements();
|
|
|
|
// Write it out to disk
|
|
WriteVTXFile( pHdr, pFileName, stats );
|
|
|
|
// Write out debugging files....
|
|
WriteGLViewFiles( pHdr, glViewFileName );
|
|
|
|
// DebugCrap( pHdr );
|
|
|
|
// PrintBoneStateChanges( pHdr, 1 );
|
|
// PrintVerts( pHdr, 1 );
|
|
|
|
delete m_FileBuffer;
|
|
m_FileBuffer = NULL;
|
|
|
|
if( m_NumSkinnedAndFlexedVerts != 0 )
|
|
{
|
|
MdlWarning( "!!!!WARNING!!!!: %d flexed verts had more than one bone influence. . will use SLOW path in engine\n", m_NumSkinnedAndFlexedVerts );
|
|
}
|
|
|
|
CleanupEverything();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static int numGLViewTrangles = 0;
|
|
static int numGLViewSWDegenerates = 0;
|
|
static int numGLViewHWDegenerates = 0;
|
|
|
|
|
|
enum
|
|
{
|
|
GLVIEWDRAW_TRILIST,
|
|
GLVIEWDRAW_TRISTRIP,
|
|
GLVIEWDRAW_NONE
|
|
};
|
|
|
|
static int s_DrawMode;
|
|
static int s_LastThreeIndices[3];
|
|
static Vertex_t s_LastThreeVerts[3];
|
|
static Vector s_LastThreePositions[3];
|
|
static int s_ListID = 0;
|
|
static bool s_Shrunk[3];
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// The following methods are used in writing out GL View files
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::PrintVert( Vertex_t *v, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh )
|
|
{
|
|
printf( "vert:\n" );
|
|
#if 0
|
|
printf( "\tposition: %f %f %f\n",
|
|
v->position[0], v->position[1], v->position[2] );
|
|
printf( "\tnormal: %f %f %f\n",
|
|
v->normal[0], v->normal[1], v->normal[2] );
|
|
printf( "\ttexcoord: %f %f\n",
|
|
v->texCoord[0], v->texCoord[1] );
|
|
#endif
|
|
printf( "\torigMeshVertID: %d\n", v->origMeshVertID );
|
|
printf( "\tnumBones: %d\n", v->numBones );
|
|
int i;
|
|
// for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
|
|
for( i = 0; i < v->numBones; i++ )
|
|
{
|
|
float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, v, i );
|
|
printf( "\tboneID[%d]: %d weight: %f (%s)\n", i, ( int )v->boneID[i], boneWeight,
|
|
g_bonetable[v->boneID[i]].name );
|
|
}
|
|
}
|
|
|
|
|
|
static float RandomFloat( float min, float max )
|
|
{
|
|
float ret;
|
|
|
|
ret = ( ( float )rand() ) / ( float )VALVE_RAND_MAX;
|
|
ret *= max - min;
|
|
ret += min;
|
|
return ret;
|
|
}
|
|
|
|
Vector& COptimizedModel::GetOrigVertPosition( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert )
|
|
{
|
|
Assert( pStudioMesh->pModel() == pStudioModel );
|
|
|
|
const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
return *vertData->Position( pVert->origMeshVertID );
|
|
}
|
|
|
|
float COptimizedModel::GetOrigVertBoneWeightValue( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID )
|
|
{
|
|
Assert( pStudioMesh->pModel() == pStudioModel );
|
|
|
|
const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
return vertData->BoneWeights( pVert->origMeshVertID )->weight[pVert->boneWeightIndex[boneID]];
|
|
}
|
|
|
|
mstudioboneweight_t &COptimizedModel::GetOrigVertBoneWeight( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert )
|
|
{
|
|
Assert( pStudioMesh->pModel() == pStudioModel );
|
|
|
|
const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
return *vertData->BoneWeights( pVert->origMeshVertID );
|
|
}
|
|
|
|
int COptimizedModel::GetOrigVertBoneIndex( mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, Vertex_t *pVert, int boneID )
|
|
{
|
|
Assert( pStudioMesh->pModel() == pStudioModel );
|
|
|
|
const mstudio_meshvertexdata_t *vertData = pStudioMesh->GetVertexData();
|
|
Assert( vertData ); // This can only return NULL on X360 for now
|
|
return vertData->BoneWeights( pVert->origMeshVertID )->bone[pVert->boneWeightIndex[boneID]];
|
|
}
|
|
|
|
void COptimizedModel::SetMeshPropsColor( unsigned int meshFlags, Vector& color )
|
|
{
|
|
if( meshFlags & MESH_IS_TEETH )
|
|
{
|
|
color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
|
|
}
|
|
else if( meshFlags & MESH_IS_EYES )
|
|
{
|
|
color[0] = 1.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::SetFlexedAndSkinColor( unsigned int glViewFlags, unsigned int stripGroupFlags, Vector& color )
|
|
{
|
|
if( ( glViewFlags & WRITEGLVIEW_SHOWFLEXED ) && ( glViewFlags & WRITEGLVIEW_SHOWSW ) )
|
|
{
|
|
if( ( stripGroupFlags & STRIPGROUP_IS_FLEXED ) &&
|
|
( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
// flexed and hw skinned = yellow
|
|
color[0] = 1.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
else if( !( stripGroupFlags & STRIPGROUP_IS_FLEXED ) &&
|
|
( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
// not flexed and hw skinned = green
|
|
color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
else if( !( stripGroupFlags & STRIPGROUP_IS_FLEXED ) &&
|
|
!( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
// not flexed and sw skinned = blue
|
|
color[0] = 0.0f; color[1] = 0.0f; color[2] = 1.0f;
|
|
}
|
|
else if( ( stripGroupFlags & STRIPGROUP_IS_FLEXED ) &&
|
|
!( stripGroupFlags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
// flexed and sw skinned = red
|
|
color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
|
|
}
|
|
else if( glViewFlags & WRITEGLVIEW_SHOWFLEXED )
|
|
{
|
|
if( stripGroupFlags & STRIPGROUP_IS_FLEXED )
|
|
{
|
|
color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
}
|
|
else if( glViewFlags & WRITEGLVIEW_SHOWSW )
|
|
{
|
|
if( stripGroupFlags & STRIPGROUP_IS_HWSKINNED )
|
|
{
|
|
color[0] = 0.0f; color[1] = 1.0f; color[2] = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
color[0] = 1.0f; color[1] = 0.0f; color[2] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::SetColorFromNumVertexBones( int numBones, Vector& color )
|
|
{
|
|
Vector numBonesColor[5] = {
|
|
Vector( 0.0f, 0.0f, 0.0f ), // 0 bones = black
|
|
Vector( 0.0f, 1.0f, 0.0f ), // 1 bone = green
|
|
Vector( 1.0f, 1.0f, 0.0f ), // 2 bones = yellow
|
|
Vector( 0.0f, 0.0f, 1.0f ), // 3 bones = blue
|
|
Vector( 1.0f, 0.0f, 0.0f ) // 4 bones = red
|
|
};
|
|
Assert( numBones >= 0 && numBones <= 4 );
|
|
VectorCopy( numBonesColor[numBones], color );
|
|
}
|
|
|
|
|
|
void COptimizedModel::DrawGLViewTriangle( FILE *fp, Vector& pos1, Vector& pos2, Vector& pos3,
|
|
Vector& color1, Vector& color2, Vector& color3 )
|
|
{
|
|
numGLViewTrangles++;
|
|
fprintf( fp, "3\n" );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", pos1[0], pos1[1], pos1[2], color1[0], color1[1], color1[2] );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", pos2[0], pos2[1], pos2[2], color2[0], color2[1], color2[2] );
|
|
fprintf( fp, "%f %f %f %f %f %f\n", pos3[0], pos3[1], pos3[2], color3[0], color3[1], color3[2] );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// use index to test for degenerates. . isn't used for anything else.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::GLViewVert( FILE *fp, Vertex_t vert, int index,
|
|
Vector& color, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh,
|
|
bool showSubStrips, float shrinkFactor )
|
|
{
|
|
// CheckVertBoneWeights( &vert, pStudioModel, pStudioMesh );
|
|
Assert( s_DrawMode != GLVIEWDRAW_NONE );
|
|
int id = s_ListID % 3;
|
|
s_LastThreeIndices[id] = index;
|
|
s_LastThreeVerts[id] = vert;
|
|
s_Shrunk[id] = false;
|
|
VectorCopy( GetOrigVertPosition( pStudioModel, pStudioMesh, &s_LastThreeVerts[id] ), s_LastThreePositions[id] );
|
|
if( s_DrawMode == GLVIEWDRAW_TRILIST )
|
|
{
|
|
// trilist
|
|
if( id == 2 )
|
|
{
|
|
ShrinkVerts( shrinkFactor );
|
|
DrawGLViewTriangle( fp,
|
|
s_LastThreePositions[0],
|
|
s_LastThreePositions[1],
|
|
s_LastThreePositions[2],
|
|
color, color, color );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// tristrip
|
|
if( s_ListID >= 2 )
|
|
{
|
|
// spit out the triangle with both facings. . doesn't matter if we
|
|
// get the facing right for glview
|
|
if( s_LastThreeIndices[0] == s_LastThreeIndices[1] ||
|
|
s_LastThreeIndices[1] == s_LastThreeIndices[2] ||
|
|
s_LastThreeIndices[0] == s_LastThreeIndices[2] )
|
|
{
|
|
// skip degenerate triangles
|
|
numGLViewHWDegenerates++;
|
|
if( showSubStrips )
|
|
{
|
|
RandomColor( color );
|
|
}
|
|
}
|
|
else if( !( s_ListID & 1 ) )
|
|
{
|
|
ShrinkVerts( shrinkFactor );
|
|
DrawGLViewTriangle( fp,
|
|
s_LastThreePositions[(id+0-2+3)%3],
|
|
s_LastThreePositions[(id+1-2+3)%3],
|
|
s_LastThreePositions[(id+2-2+3)%3],
|
|
color, color, color );
|
|
}
|
|
else
|
|
{
|
|
ShrinkVerts( shrinkFactor );
|
|
DrawGLViewTriangle( fp,
|
|
s_LastThreePositions[(id+2-2+3)%3],
|
|
s_LastThreePositions[(id+1-2+3)%3],
|
|
s_LastThreePositions[(id+0-2+3)%3],
|
|
color, color, color );
|
|
}
|
|
}
|
|
}
|
|
|
|
s_ListID++;
|
|
}
|
|
|
|
void COptimizedModel::GLViewDrawEnd( void )
|
|
{
|
|
s_DrawMode = GLVIEWDRAW_NONE;
|
|
}
|
|
|
|
/*
|
|
void COptimizedModel::DebugCrap( studiohdr_t *phdr )
|
|
{
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
for( int lodID = 0; lodID < model->numLODs; lodID++ )
|
|
{
|
|
char tmp[256];
|
|
sprintf( tmp, "crap.lod%d", lodID );
|
|
printf( "writing %s\n", tmp );
|
|
FILE *fp = fopen( tmp, "w" );
|
|
if( !fp )
|
|
{
|
|
printf( "can't write crap file %s\n", tmp );
|
|
return;
|
|
}
|
|
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
|
|
{
|
|
int id = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
|
|
Vertex_t& vert = *pStripGroup->pVertex( id );
|
|
Vector& vertPos = GetOrigVertPosition( pStudioModel, pStudioMesh, &vert );
|
|
fprintf( fp, "mesh: %04d origvertid: %04d pos: %0.2f %0.2f %0.2f ", meshID, vert.origMeshVertID, vertPos[0], vertPos[1], vertPos[2] );
|
|
int i;
|
|
for( i = 0; i < vert.numBones; i++ )
|
|
{
|
|
float boneWeight;
|
|
boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, &vert, i );
|
|
int boneID;
|
|
boneID = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, &vert, i );
|
|
fprintf( fp, "bone: %d %0.1f ", boneID, boneWeight );
|
|
}
|
|
fprintf( fp, "\n" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fclose( fp );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
|
|
void COptimizedModel::WriteGLViewFile( studiohdr_t *phdr, const char *pFileName, unsigned int flags, float shrinkFactor )
|
|
{
|
|
Vector color;
|
|
RandomColor( color );
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
mstudiobodyparts_t *pStudioBodyPart = phdr->pBodypart( bodyPartID );
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
mstudiomodel_t *pStudioModel = pStudioBodyPart->pModel( modelID );
|
|
for( int lodID = 0; lodID < model->numLODs; lodID++ )
|
|
{
|
|
char tmp[256];
|
|
sprintf( tmp, "%s.lod%d", pFileName, lodID );
|
|
printf( "writing %s\n", tmp );
|
|
CPlainAutoPtr< CP4File > spFile( g_p4factory->AccessFile( tmp ) );
|
|
spFile->Edit();
|
|
FILE *fp = fopen( tmp, "w" );
|
|
if( !fp )
|
|
{
|
|
printf( "can't write glview file %s\n", tmp );
|
|
return;
|
|
}
|
|
|
|
/*
|
|
// write out tangent space vectors
|
|
int vertID;
|
|
for( vertID = 0; vertID < pStudioModel->numvertices; vertID++ )
|
|
{
|
|
const Vector &pos = *pStudioModel->pVertex( vertID );
|
|
const Vector &norm = *pStudioModel->pNormal( vertID );
|
|
const Vector4D &sVect = *pStudioModel->pTangentS( vertID );
|
|
Vector tmpVect;
|
|
tmpVect = pos + norm * .15f;
|
|
fprintf( fp, "2\n" );
|
|
fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", pos[0], pos[1], pos[2] );
|
|
fprintf( fp, "%f %f %f 0.0 0.0 1.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
|
|
|
|
Vector tmpSVect( sVect[0], sVect[1], sVect[2] );
|
|
tmpVect = pos + tmpSVect * .15f;
|
|
fprintf( fp, "2\n" );
|
|
fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", pos[0], pos[1], pos[2] );
|
|
fprintf( fp, "%f %f %f 1.0 0.0 0.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
|
|
|
|
Vector tmpTVect;
|
|
CrossProduct( norm, tmpSVect, tmpTVect );
|
|
tmpTVect *= sVect[3];
|
|
tmpVect = pos + tmpTVect * .15f;
|
|
|
|
fprintf( fp, "2\n" );
|
|
fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", pos[0], pos[1], pos[2] );
|
|
fprintf( fp, "%f %f %f 0.0 1.0 0.0\n", tmpVect[0], tmpVect[1], tmpVect[2] );
|
|
|
|
}
|
|
continue;
|
|
*/
|
|
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
mstudiomesh_t *pStudioMesh = pStudioModel->pMesh( meshID );
|
|
if( flags & WRITEGLVIEW_SHOWMESH )
|
|
{
|
|
RandomColor( color );
|
|
}
|
|
if( flags & WRITEGLVIEW_SHOWMESHPROPS )
|
|
{
|
|
SetMeshPropsColor( mesh->flags, color );
|
|
}
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
if( flags & WRITEGLVIEW_SHOWSTRIPGROUP )
|
|
{
|
|
RandomColor( color );
|
|
}
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
|
|
SetFlexedAndSkinColor( flags, pStripGroup->flags, color );
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
if( flags & WRITEGLVIEW_SHOWSTRIP )
|
|
{
|
|
RandomColor( color );
|
|
}
|
|
|
|
if( flags & WRITEGLVIEW_SHOWSTRIPNUMBONES )
|
|
{
|
|
switch (pStrip->numBones)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
color.Init( 0, 0, 255 );
|
|
break;
|
|
|
|
case 2:
|
|
color.Init( 0, 255, 0 );
|
|
break;
|
|
|
|
case 3:
|
|
color.Init( 255, 255, 0 );
|
|
break;
|
|
|
|
case 4:
|
|
color.Init( 255, 0, 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
GLViewDrawBegin( ( pStrip->flags & STRIP_IS_TRILIST ) ? GLVIEWDRAW_TRILIST : GLVIEWDRAW_TRISTRIP );
|
|
for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
|
|
{
|
|
int id = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
|
|
Vertex_t& vert = *pStripGroup->pVertex( id );
|
|
|
|
if( flags & WRITEGLVIEW_SHOWVERTNUMBONES )
|
|
{
|
|
switch (vert.numBones)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
color.Init( 0, 0, 255 );
|
|
break;
|
|
|
|
case 2:
|
|
color.Init( 0, 255, 0 );
|
|
break;
|
|
|
|
case 3:
|
|
color.Init( 255, 255, 0 );
|
|
break;
|
|
|
|
case 4:
|
|
color.Init( 255, 0, 0 );
|
|
break;
|
|
}
|
|
}
|
|
|
|
GLViewVert( fp, vert, id, color, pStudioModel, pStudioMesh,
|
|
( flags & WRITEGLVIEW_SHOWSUBSTRIP ) ? true : false, shrinkFactor );
|
|
}
|
|
GLViewDrawEnd();
|
|
}
|
|
}
|
|
}
|
|
fclose( fp );
|
|
spFile->Add();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Write out all GL View files
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void COptimizedModel::WriteGLViewFiles( studiohdr_t *pHdr, char const* glViewFileName )
|
|
{
|
|
if( !g_bDumpGLViewFiles )
|
|
return;
|
|
|
|
char tmpFileName[128];
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".mesh" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWMESH, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".stripgroup" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIPGROUP, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".strip" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIP, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".substrip" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSUBSTRIP, .97f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".flexed" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWFLEXED, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".sw" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSW, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".flexedandsw" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSW | WRITEGLVIEW_SHOWFLEXED, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".meshprops" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWMESHPROPS, .8f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".vertnumbones" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWVERTNUMBONES, 1.0f );
|
|
strcpy( tmpFileName, glViewFileName );
|
|
strcat( tmpFileName, ".stripnumbones" );
|
|
WriteGLViewFile( pHdr, tmpFileName, WRITEGLVIEW_SHOWSTRIPNUMBONES, 1.0f );
|
|
}
|
|
|
|
|
|
void COptimizedModel::GLViewDrawBegin( int mode )
|
|
{
|
|
s_DrawMode = mode;
|
|
s_ListID = 0;
|
|
}
|
|
|
|
void COptimizedModel::ShrinkVerts( float shrinkFactor )
|
|
{
|
|
Vector center;
|
|
Vector delta;
|
|
|
|
VectorCopy( s_LastThreePositions[0], center );
|
|
VectorAdd( center, s_LastThreePositions[1], center );
|
|
VectorAdd( center, s_LastThreePositions[2], center );
|
|
VectorScale( center, 1.0f / 3.0f, center );
|
|
|
|
int i;
|
|
for( i = 0; i < 3; i++ )
|
|
{
|
|
if( s_Shrunk[i] )
|
|
{
|
|
continue;
|
|
}
|
|
VectorSubtract( s_LastThreePositions[i], center, delta );
|
|
VectorScale( delta, shrinkFactor, delta );
|
|
VectorAdd( center, delta, s_LastThreePositions[i] );
|
|
s_Shrunk[i] = true;
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::CheckVertBoneWeights( Vertex_t *pVert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh )
|
|
{
|
|
int i;
|
|
float sum = 0;
|
|
for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
|
|
{
|
|
float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, pVert, i );
|
|
sum += boneWeight;
|
|
}
|
|
Assert( sum > 0.95f && sum < 1.1f );
|
|
}
|
|
|
|
|
|
#define CACHE_INEFFICIENCY 6
|
|
void COptimizedModel::ShowStats( void )
|
|
{
|
|
int totalHWTriangles = 0;
|
|
int totalHWDegenerates = 0;
|
|
int totalHWIndices = 0;
|
|
int totalHWVertexCacheHits = 0;
|
|
int totalHWVertexCacheMisses = 0;
|
|
int totalSWTriangles = 0;
|
|
int totalSWDegenerates = 0;
|
|
int totalSWIndices = 0;
|
|
int totalSWVertexCacheHits = 0;
|
|
int totalSWVertexCacheMisses = 0;
|
|
|
|
CHardwareVertexCache hardwareVertexCache;
|
|
hardwareVertexCache.Init( m_VertexCacheSize - CACHE_INEFFICIENCY );
|
|
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
printf( "header: %d body parts\n", header->numBodyParts );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
printf( " bodyPart %d: %d models\n", bodyPartID, bodyPart->numModels );
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
printf( " model: %d lods\n", model->numLODs );
|
|
for( int lodID = 0; lodID < 1; lodID++ )
|
|
{
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
printf( " lod: %d meshes\n", pLOD->numMeshes );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
printf( " mesh %d: %d stripsgroups\n", meshID, mesh->numStripGroups );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
int lastThreeIndices[3];
|
|
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
printf( " strip: %d numIndices: %d indexOffset: %d\n", stripID, pStrip->numIndices, pStrip->indexOffset );
|
|
|
|
hardwareVertexCache.Flush();
|
|
if( pStrip->flags & STRIP_IS_TRISTRIP )
|
|
{
|
|
for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
|
|
{
|
|
totalHWIndices++;
|
|
int newVertOffset = indexID % 3;
|
|
lastThreeIndices[newVertOffset] = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
|
|
if( !hardwareVertexCache.IsPresent( lastThreeIndices[newVertOffset] ) )
|
|
{
|
|
totalHWVertexCacheMisses++;
|
|
hardwareVertexCache.Insert( lastThreeIndices[newVertOffset] );
|
|
}
|
|
else
|
|
{
|
|
totalHWVertexCacheHits++;
|
|
}
|
|
if( indexID >= 2 )
|
|
{
|
|
totalHWTriangles++;
|
|
if( lastThreeIndices[0] != lastThreeIndices[1] &&
|
|
lastThreeIndices[1] != lastThreeIndices[2] )
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
totalHWDegenerates++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( pStrip->numIndices % 3 == 0 );
|
|
totalHWTriangles += pStrip->numIndices / 3;
|
|
for( int indexID = 0; indexID < pStrip->numIndices; indexID++ )
|
|
{
|
|
int newVertOffset = indexID % 3;
|
|
int index = *pStripGroup->pIndex( indexID + pStrip->indexOffset );
|
|
// printf( "%d\n", index );
|
|
lastThreeIndices[newVertOffset] = index;
|
|
if( newVertOffset == 2 )
|
|
{
|
|
if( lastThreeIndices[0] == lastThreeIndices[1] ||
|
|
lastThreeIndices[1] == lastThreeIndices[2] ||
|
|
lastThreeIndices[0] == lastThreeIndices[2] )
|
|
{
|
|
// printf( "degenerate triangle!!!! %d %d %d\n", lastThreeIndices[0], lastThreeIndices[1], lastThreeIndices[2] );
|
|
totalHWDegenerates++;
|
|
}
|
|
}
|
|
totalHWIndices++;
|
|
if( !hardwareVertexCache.IsPresent( index ) )
|
|
{
|
|
totalHWVertexCacheMisses++;
|
|
hardwareVertexCache.Insert( index );
|
|
}
|
|
else
|
|
{
|
|
totalHWVertexCacheHits++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
int totalRealHWTriangles = totalHWTriangles - totalHWDegenerates;
|
|
int totalRealSWTriangles = totalSWTriangles - totalSWDegenerates;
|
|
printf( "TotalHWTriangles: %d\n", totalHWTriangles );
|
|
printf( "TotalHWDegenerates: %d\n", totalHWDegenerates );
|
|
printf( "TotalRealHWTriangles: %d\n", totalRealHWTriangles );
|
|
printf( "TotalHWIndices: %d\n", totalHWIndices );
|
|
printf( "HW real tris/index: %f\n", ( float )totalRealHWTriangles / ( float )totalHWIndices );
|
|
printf( "totalHWVertexCacheHits: %d\n", totalHWVertexCacheHits );
|
|
printf( "totalHWVertexCacheMisses: %d\n", totalHWVertexCacheMisses );
|
|
printf( "HW vertex cache hit/miss ratio: %f\n", ( float )totalHWVertexCacheHits / ( float )totalHWVertexCacheMisses );
|
|
|
|
printf( "TotalSWTriangles: %d\n", totalSWTriangles );
|
|
printf( "TotalSWDegenerates: %d\n", totalSWDegenerates );
|
|
printf( "TotalRealSWTriangles: %d\n", totalRealSWTriangles );
|
|
printf( "TotalSWIndices: %d\n", totalSWIndices );
|
|
printf( "SW real tris/index: %f\n", ( float )totalRealSWTriangles / ( float )totalSWIndices );
|
|
printf( "totalSWVertexCacheHits: %d\n", totalSWVertexCacheHits );
|
|
printf( "totalSWVertexCacheMisses: %d\n", totalSWVertexCacheMisses );
|
|
printf( "SW vertex cache hit/miss ratio: %f\n", ( float )totalSWVertexCacheHits / ( float )totalSWVertexCacheMisses );
|
|
}
|
|
|
|
void COptimizedModel::CheckVert( Vertex_t *pVert, int maxBonesPerTri, int maxBonesPerVert )
|
|
{
|
|
#ifndef IGNORE_BONES
|
|
|
|
#ifdef _DEBUG
|
|
int offset = ( int )( ( unsigned char * )pVert - ( unsigned char * )m_FileBuffer->GetPointer( 0 ) );
|
|
Assert( offset >= m_VertsOffset && offset < m_IndicesOffset );
|
|
Assert( ( ( offset - m_VertsOffset ) % sizeof( Vertex_t ) ) == 0 );
|
|
#endif
|
|
|
|
int j;
|
|
for( j = 0; j < maxBonesPerVert; j++ )
|
|
{
|
|
if( pVert->boneID[j] != -1 )
|
|
{
|
|
Assert( pVert->boneID[j] >= 0 && pVert->boneID[j] < maxBonesPerTri );
|
|
}
|
|
#if 0
|
|
if( pVert->boneWeights[j] != 0 )
|
|
{
|
|
Assert( pVert->boneID[j] != -1 );
|
|
}
|
|
#endif
|
|
}
|
|
// Test to make sure we are sorted.
|
|
for( j = 0; j < maxBonesPerVert-1; j++ )
|
|
{
|
|
#if 1
|
|
// if( pVert->boneWeights[j] != 0 && pVert->boneWeights[j+1] != 0 )
|
|
{
|
|
Assert( pVert->boneID[j] < pVert->boneID[j+1] );
|
|
}
|
|
#endif
|
|
}
|
|
#if 0
|
|
// Make sure that all the non-zero weights are first.
|
|
bool foundZero = false;
|
|
for( j = 0; j < maxBonesPerVert; j++ )
|
|
{
|
|
if( !foundZero )
|
|
{
|
|
if( pVert->boneWeights[j] == 0.0f )
|
|
{
|
|
foundZero = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( pVert->boneWeights[j] == 0.0f );
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::CheckAllVerts( int maxBonesPerTri, int maxBonesPerVert )
|
|
{
|
|
int i;
|
|
for( i = m_VertsOffset; i < m_IndicesOffset; i += sizeof( Vertex_t ) )
|
|
{
|
|
Vertex_t *vert = ( Vertex_t * )m_FileBuffer->GetPointer( i );
|
|
CheckVert( vert, maxBonesPerTri, maxBonesPerVert );
|
|
}
|
|
}
|
|
|
|
void COptimizedModel::SortBonesWithinVertex( bool flexed, Vertex_t *vert, mstudiomodel_t *pStudioModel, mstudiomesh_t *pStudioMesh, int *globalToHardwareBoneIndex, int *hardwareToGlobalBoneIndex, int maxBonesPerTri, int maxBonesPerVert )
|
|
{
|
|
int i;
|
|
/*
|
|
for( i = 0; i < m_NumBones; i++ )
|
|
{
|
|
if( globalToHardwareBoneIndex[i] != -1 )
|
|
{
|
|
if( flexed )
|
|
{
|
|
printf( "global bone id: %d hardware bone id: %d\n",
|
|
i, globalToHardwareBoneIndex[i] );
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
#if 0
|
|
unsigned char tmpWeightIndex;
|
|
int tmpIndex;
|
|
int j;
|
|
// bubble sort the bones.
|
|
for( j = m_MaxBonesPerVert; j > 1; j-- )
|
|
{
|
|
int k;
|
|
for( k = 0; k < j - 1; k++ )
|
|
{
|
|
if( vert->boneID[k] > vert->boneID[k+1] )
|
|
{
|
|
// swap
|
|
tmpIndex = vert->boneID[k];
|
|
tmpWeightIndex = vert->boneWeightIndex[k];
|
|
vert->boneID[k] = vert->boneID[k+1];
|
|
vert->boneWeightIndex[k] = vert->boneWeightIndex[k+1];
|
|
vert->boneID[k+1] = tmpIndex;
|
|
vert->boneWeightIndex[k+1] = tmpWeightIndex;
|
|
}
|
|
}
|
|
}
|
|
#else
|
|
|
|
int origBoneWeightIndex[MAX_NUM_BONES_PER_VERT];
|
|
int zeroWeightIndex = -1;
|
|
// find a orig vert bone index that has a zero weight
|
|
for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
|
|
{
|
|
float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
|
|
if( boneWeight == 0.0f )
|
|
{
|
|
zeroWeightIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for( i = 0; i < MAX_NUM_BONES_PER_VERT; i++ )
|
|
{
|
|
origBoneWeightIndex[i] = zeroWeightIndex;
|
|
}
|
|
for( i = 0; i < vert->numBones; i++ )
|
|
{
|
|
float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
|
|
int globalBoneIndex = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, vert, i );
|
|
// if( vert->numBones > 1 )
|
|
{
|
|
if( flexed )
|
|
{
|
|
printf( "boneWeight: %f\n", boneWeight );
|
|
printf( "globalBoneIndex: %d\n", globalBoneIndex );
|
|
}
|
|
}
|
|
if( boneWeight > 0.0f )
|
|
{
|
|
int hardwareBoneIndex = globalToHardwareBoneIndex[globalBoneIndex];
|
|
Assert( globalBoneIndex != -1 );
|
|
origBoneWeightIndex[hardwareBoneIndex] = vert->boneWeightIndex[i];
|
|
}
|
|
else
|
|
{
|
|
int hardwareBoneIndex = globalToHardwareBoneIndex[globalBoneIndex];
|
|
origBoneWeightIndex[hardwareBoneIndex] = zeroWeightIndex;
|
|
Assert( zeroWeightIndex != -1 );
|
|
Assert( globalBoneIndex == -1 );
|
|
}
|
|
}
|
|
// if( vert->numBones > 1 )
|
|
for( i = 0; i < maxBonesPerTri; i++ )
|
|
{
|
|
vert->boneID[i] = i;
|
|
vert->boneWeightIndex[i] = origBoneWeightIndex[i];
|
|
float boneWeight = GetOrigVertBoneWeightValue( pStudioModel, pStudioMesh, vert, i );
|
|
int globalBoneIndex = GetOrigVertBoneIndex( pStudioModel, pStudioMesh, vert, i );
|
|
if( flexed )
|
|
{
|
|
Assert( boneWeight >= 0.0f && boneWeight <= 1.0f );
|
|
printf( "boneWeight: %f ", boneWeight );
|
|
printf( "globalBoneIndex: %d ", globalBoneIndex );
|
|
printf( "hardwareBoneID: %d\n", i );
|
|
}
|
|
}
|
|
vert->numBones = maxBonesPerTri; // this may be different for software t&l stuff
|
|
#endif
|
|
}
|
|
|
|
void COptimizedModel::RemoveRedundantBoneStateChanges( void )
|
|
{
|
|
FileHeader_t *header = ( FileHeader_t * )m_FileBuffer->GetPointer( 0 );
|
|
for( int bodyPartID = 0; bodyPartID < header->numBodyParts; bodyPartID++ )
|
|
{
|
|
BodyPartHeader_t *bodyPart = header->pBodyPart( bodyPartID );
|
|
|
|
bool allocated[MAX_NUM_BONES_PER_STRIP];
|
|
int hardwareBoneState[MAX_NUM_BONES_PER_STRIP];
|
|
bool changed[MAX_NUM_BONES_PER_STRIP];
|
|
|
|
// start anew with each body part
|
|
// printf( "START BODY PARTY - RESETTING BONE MATRIX STATE\n" );
|
|
int i;
|
|
for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
|
|
{
|
|
hardwareBoneState[i] = -1;
|
|
allocated[i] = false;
|
|
}
|
|
|
|
for( int modelID = 0; modelID < bodyPart->numModels; modelID++ )
|
|
{
|
|
ModelHeader_t *model = bodyPart->pModel( modelID );
|
|
for( int lodID = 0; lodID < model->numLODs; lodID++ )
|
|
{
|
|
ModelLODHeader_t *pLOD = model->pLOD( lodID );
|
|
for( int meshID = 0; meshID < pLOD->numMeshes; meshID++ )
|
|
{
|
|
MeshHeader_t *mesh = pLOD->pMesh( meshID );
|
|
for( int stripGroupID = 0; stripGroupID < mesh->numStripGroups; stripGroupID++ )
|
|
{
|
|
StripGroupHeader_t *pStripGroup = mesh->pStripGroup( stripGroupID );
|
|
if( !( pStripGroup->flags & STRIPGROUP_IS_HWSKINNED ) )
|
|
{
|
|
// printf( "skipping! software skinned stripgroup\n" );
|
|
continue;
|
|
}
|
|
for( int stripID = 0; stripID < pStripGroup->numStrips; stripID++ )
|
|
{
|
|
StripHeader_t *pStrip = pStripGroup->pStrip( stripID );
|
|
// int startNumBoneChanges = pStrip->numBoneStateChanges;
|
|
/*
|
|
printf( "HARDWARE BONE STATE\n" );
|
|
for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
|
|
{
|
|
if( allocated[i] )
|
|
{
|
|
printf( "\thw: %d global: %d\n", i, hardwareBoneState[i] );
|
|
}
|
|
}
|
|
|
|
printf( "before optimization\n" );
|
|
for( i = 0; i < pStrip->numBoneStateChanges; i++ )
|
|
{
|
|
printf( "\thw: %d global: %d\n",
|
|
( int )pStrip->pBoneStateChange( i )->hardwareID,
|
|
( int )pStrip->pBoneStateChange( i )->newBoneID );
|
|
}
|
|
*/
|
|
|
|
for( i = 0; i < MAX_NUM_BONES_PER_STRIP; i++ )
|
|
{
|
|
changed[i] = false;
|
|
}
|
|
for( int boneStateChangeID = 0; boneStateChangeID < pStrip->numBoneStateChanges; boneStateChangeID++ )
|
|
{
|
|
BoneStateChangeHeader_t *boneStateChange = pStrip->pBoneStateChange( boneStateChangeID );
|
|
Assert( boneStateChange->hardwareID >= 0 && boneStateChange->hardwareID < MAX_NUM_BONES_PER_STRIP );
|
|
if( allocated[boneStateChange->hardwareID] &&
|
|
hardwareBoneState[boneStateChange->hardwareID] == boneStateChange->newBoneID )
|
|
{
|
|
// already got this one!
|
|
}
|
|
else
|
|
{
|
|
changed[boneStateChange->hardwareID] = true;
|
|
allocated[boneStateChange->hardwareID] = true;
|
|
hardwareBoneState[boneStateChange->hardwareID] = boneStateChange->newBoneID;
|
|
}
|
|
}
|
|
/*
|
|
// now "changed" should tell us which ones we care about.
|
|
int curOutBoneID = 0;
|
|
for( i = 0; i < pStrip->numBoneStateChanges; i++ )
|
|
{
|
|
// hack . . going to stomp over what is already there with new data.
|
|
if( changed[i] )
|
|
{
|
|
BoneStateChangeHeader_t *boneStateChange = pStrip->pBoneStateChange( curOutBoneID );
|
|
boneStateChange->hardwareID = i;
|
|
boneStateChange->newBoneID = hardwareBoneState[i];
|
|
curOutBoneID++;
|
|
}
|
|
}
|
|
pStrip->numBoneStateChanges = curOutBoneID;
|
|
printf( "start bone changes: %d end bone changes: %d\n", startNumBoneChanges, pStrip->numBoneStateChanges );
|
|
printf( "after optimization\n" );
|
|
for( i = 0; i < pStrip->numBoneStateChanges; i++ )
|
|
{
|
|
printf( "\thw: %d global: %d\n",
|
|
( int )pStrip->pBoneStateChange( i )->hardwareID,
|
|
( int )pStrip->pBoneStateChange( i )->newBoneID );
|
|
}
|
|
|
|
*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void AddMaterialReplacementsToStringTable( void )
|
|
{
|
|
int i, j;
|
|
int numLODs = g_ScriptLODs.Size();
|
|
for( i = 0; i < numLODs; i++ )
|
|
{
|
|
LodScriptData_t &scriptLOD = g_ScriptLODs[i];
|
|
for( j = 0; j < scriptLOD.materialReplacements.Size(); j++ )
|
|
{
|
|
CLodScriptReplacement_t &materialReplacement = scriptLOD.materialReplacements[j];
|
|
s_StringTable.AddString( materialReplacement.GetDstName() );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Check that all replacematerial/removemesh commands map to valid source materials
|
|
void ValidateLODReplacements( studiohdr_t *pHdr )
|
|
{
|
|
bool failed = false;
|
|
int lodID;
|
|
for( lodID = 0; lodID < g_ScriptLODs.Size(); lodID++ )
|
|
{
|
|
LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
|
|
int j;
|
|
for( j = 0; j < scriptLOD.meshRemovals.Count(); j++ )
|
|
{
|
|
const char *pName1 = scriptLOD.meshRemovals[j].GetSrcName();
|
|
int i;
|
|
for( i = 0; i < pHdr->numtextures; i++ )
|
|
{
|
|
const char *pName2 = pHdr->pTexture( i )->material->GetName();
|
|
if( ComparePath( pName1, pName2 ) )
|
|
{
|
|
goto got_one;
|
|
}
|
|
}
|
|
|
|
// no match
|
|
MdlWarning( "\"%s\" doesn't match any of the materals in the model\n", pName1 );
|
|
failed = true;
|
|
got_one:
|
|
;
|
|
}
|
|
}
|
|
if( failed )
|
|
{
|
|
MdlWarning( "possible materials in model:\n" );
|
|
int i;
|
|
for( i = 0; i < pHdr->numtextures; i++ )
|
|
{
|
|
MdlWarning( "\t\"%s\"\n", pHdr->pTexture( i )->material->GetName() );
|
|
}
|
|
MdlError( "Exiting due to errors\n" );
|
|
}
|
|
}
|
|
|
|
void WriteOptimizedFiles( studiohdr_t *phdr, s_bodypart_t *pSrcBodyParts )
|
|
{
|
|
char filename[MAX_PATH];
|
|
char tmpFileName[MAX_PATH];
|
|
char glViewFilename[MAX_PATH];
|
|
|
|
ValidateLODReplacements( phdr );
|
|
|
|
s_StringTable.Purge();
|
|
|
|
// hack! This should really go in the mdl file since it's common to all LODs.
|
|
AddMaterialReplacementsToStringTable();
|
|
|
|
V_strcpy_safe( filename, gamedir );
|
|
// if( *g_pPlatformName )
|
|
// {
|
|
// strcat( filename, "platform_" );
|
|
// strcat( filename, g_pPlatformName );
|
|
// strcat( filename, "/" );
|
|
// }
|
|
V_strcat_safe( filename, "models/" );
|
|
V_strcat_safe( filename, outname );
|
|
Q_StripExtension( filename, filename, sizeof( filename ) );
|
|
|
|
V_strcpy_safe( tmpFileName, filename );
|
|
V_strcat_safe( tmpFileName, ".sw.vtx" );
|
|
V_strcpy_safe( glViewFilename, filename );
|
|
V_strcat_safe( glViewFilename, ".sw.glview" );
|
|
bool bForceSoftwareSkinning = phdr->numbones > 0 && !g_staticprop;
|
|
s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
|
|
512, //vert cache size FIXME: figure out the correct size for L1
|
|
false, /* doesn't use fixed function */
|
|
bForceSoftwareSkinning, // force software skinning if not static prop
|
|
false, // No hardware flex
|
|
3, // bones/vert
|
|
3*3, // bones/tri
|
|
512, // bones/strip
|
|
tmpFileName, glViewFilename );
|
|
|
|
V_strcpy_safe( tmpFileName, filename );
|
|
V_strcat_safe( tmpFileName, ".dx80.vtx" );
|
|
V_strcpy_safe( glViewFilename, filename );
|
|
V_strcat_safe( glViewFilename, ".dx80.glview" );
|
|
s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
|
|
24 /* vert cache size (real size, not effective!)*/,
|
|
false, /* doesn't use fixed function */
|
|
false, // don't force software skinning
|
|
false, // No hardware flex
|
|
3 /* bones/vert */,
|
|
9 /* bones/tri */,
|
|
16 /* bones/strip */,
|
|
tmpFileName, glViewFilename );
|
|
|
|
V_strcpy_safe( tmpFileName, filename );
|
|
V_strcat_safe( tmpFileName, ".dx90.vtx" );
|
|
V_strcpy_safe( glViewFilename, filename );
|
|
V_strcat_safe( glViewFilename, ".dx90.glview" );
|
|
s_OptimizedModel.OptimizeFromStudioHdr( phdr, pSrcBodyParts,
|
|
24 /* vert cache size (real size, not effective!)*/,
|
|
false, /* doesn't use fixed function */
|
|
false, // don't force software skinning
|
|
true, // Hardware flex on DX9 parts
|
|
3 /* bones/vert */,
|
|
9 /* bones/tri */,
|
|
53 /* bones/strip */,
|
|
tmpFileName, glViewFilename );
|
|
|
|
s_StringTable.Purge();
|
|
}
|
|
|
|
}; // namespace OptimizedModel
|
|
#pragma optimize( "", on )
|