BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/utils/studiomdl/optimize.cpp

4018 lines
130 KiB
C++
Raw Permalink Blame History

//========= 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 )
Reference in New Issue View Git Blame Copy Permalink