1632 lines
48 KiB
C++
1632 lines
48 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <math.h>
|
|
#include <float.h>
|
|
|
|
#include "cmdlib.h"
|
|
#include "scriplib.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "studio.h"
|
|
#include "studiomdl.h"
|
|
#include "bone_setup.h"
|
|
#include "tier1/strtools.h"
|
|
#include "mathlib/vmatrix.h"
|
|
#include "optimize.h"
|
|
|
|
// debugging only - enabling turns off remapping to create all lod vertexes as unique
|
|
// to ensure remapping logic does not introduce collapse anomalies
|
|
//#define UNIQUE_VERTEXES_FOR_LOD
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations local to this file
|
|
//-----------------------------------------------------------------------------
|
|
class CVertexDictionary;
|
|
struct VertexInfo_t;
|
|
static void BuildBoneLODMapping( CUtlVector<int> &boneMap, int lodID );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Globals
|
|
//-----------------------------------------------------------------------------
|
|
static int g_NumBonesInLOD[MAX_NUM_LODS];
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Makes sure all boneweights in a s_boneweight_t are valid
|
|
//-----------------------------------------------------------------------------
|
|
static void ValidateBoneWeight( const s_boneweight_t &boneWeight )
|
|
{
|
|
#ifdef _DEBUG
|
|
int i;
|
|
if( boneWeight.weight[0] == 1.0f )
|
|
{
|
|
Assert( boneWeight.numbones == 1 );
|
|
}
|
|
for( i = 0; i < boneWeight.numbones; i++ )
|
|
{
|
|
Assert( boneWeight.bone[i] >= 0 && boneWeight.bone[i] < g_numbones );
|
|
}
|
|
|
|
float weight = 0.0f;
|
|
for( i = 0; i < boneWeight.numbones; i++ )
|
|
{
|
|
weight += boneWeight.weight[i] ;
|
|
}
|
|
Assert( fabs( weight - 1.0f ) < 1e-3 );
|
|
#endif
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Swap bones
|
|
//-----------------------------------------------------------------------------
|
|
static inline void SwapBones( s_boneweight_t &boneWeight, int nBone1, int nBone2 )
|
|
{
|
|
// swap
|
|
int nTmpBone = boneWeight.bone[nBone1];
|
|
float flTmpWeight = boneWeight.weight[nBone1];
|
|
boneWeight.bone[nBone1] = boneWeight.bone[nBone2];
|
|
boneWeight.weight[nBone1] = boneWeight.weight[nBone2];
|
|
boneWeight.bone[nBone2] = nTmpBone;
|
|
boneWeight.weight[nBone2] = flTmpWeight;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort the bone weight structure to be sorted by bone weight
|
|
//-----------------------------------------------------------------------------
|
|
static void SortBoneWeightByWeight( s_boneweight_t &boneWeight )
|
|
{
|
|
// bubble sort the bones by weight. . .put the largest weight first.
|
|
for( int j = boneWeight.numbones; j > 1; j-- )
|
|
{
|
|
for( int k = 0; k < j - 1; k++ )
|
|
{
|
|
if( boneWeight.weight[k] >= boneWeight.weight[k+1] )
|
|
continue;
|
|
|
|
SwapBones( boneWeight, k, k+1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort the bone weight structure to be sorted by bone index
|
|
//-----------------------------------------------------------------------------
|
|
static void SortBoneWeightByIndex( s_boneweight_t &boneWeight )
|
|
{
|
|
// bubble sort the bones by index. . .put the smallest index first.
|
|
for ( int j = boneWeight.numbones; j > 1; j-- )
|
|
{
|
|
for( int k = 0; k < j - 1; k++ )
|
|
{
|
|
if( boneWeight.bone[k] <= boneWeight.bone[k+1] )
|
|
continue;
|
|
|
|
SwapBones( boneWeight, k, k+1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A vertex format
|
|
//-----------------------------------------------------------------------------
|
|
struct VertexInfo_t
|
|
{
|
|
Vector m_Position;
|
|
Vector m_Normal;
|
|
Vector2D m_TexCoord;
|
|
Vector4D m_TangentS;
|
|
s_boneweight_t m_BoneWeight;
|
|
int m_nLodFlag;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Stores all vertices in the vertex dictionary
|
|
//-----------------------------------------------------------------------------
|
|
class CVertexDictionary
|
|
{
|
|
public:
|
|
CVertexDictionary();
|
|
|
|
// Adds a vertex to the dictionary
|
|
int AddVertex( const VertexInfo_t &srcVertex );
|
|
int AddVertexFromSource( const s_source_t *pSrc, int nVertexIndex, int nLod );
|
|
|
|
// Iteration
|
|
int VertexCount() const;
|
|
VertexInfo_t &Vertex( int i );
|
|
const VertexInfo_t &Vertex( int i ) const;
|
|
|
|
int RootLODVertexStart() const;
|
|
int RootLODVertexEnd() const;
|
|
|
|
// Gets the vertex count for the previous LOD
|
|
int PrevLODVertexCount() const;
|
|
|
|
// Marks the dictionary as starting defining vertices for a new LOD
|
|
void StartNewLOD();
|
|
|
|
void SetRootVertexRange( int start, int end );
|
|
|
|
private:
|
|
CUtlVector<VertexInfo_t> m_Verts;
|
|
int m_nPrevLODCount;
|
|
int m_nRootLODStart;
|
|
int m_nRootLODEnd;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies in a particular vertex from the s_source_t
|
|
//-----------------------------------------------------------------------------
|
|
CVertexDictionary::CVertexDictionary()
|
|
{
|
|
m_nPrevLODCount = 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Accessor
|
|
//-----------------------------------------------------------------------------
|
|
inline VertexInfo_t &CVertexDictionary::Vertex( int i )
|
|
{
|
|
return m_Verts[i];
|
|
}
|
|
|
|
inline const VertexInfo_t &CVertexDictionary::Vertex( int i ) const
|
|
{
|
|
return m_Verts[i];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the vertex count for the previous LOD
|
|
//-----------------------------------------------------------------------------
|
|
inline int CVertexDictionary::PrevLODVertexCount() const
|
|
{
|
|
return m_nPrevLODCount;
|
|
}
|
|
|
|
|
|
inline int CVertexDictionary::RootLODVertexStart() const
|
|
{
|
|
return m_nRootLODStart;
|
|
}
|
|
|
|
|
|
inline int CVertexDictionary::RootLODVertexEnd() const
|
|
{
|
|
return m_nRootLODEnd;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Marks the dictionary as starting defining vertices for a new LOD
|
|
//-----------------------------------------------------------------------------
|
|
void CVertexDictionary::StartNewLOD()
|
|
{
|
|
m_nPrevLODCount = VertexCount();
|
|
}
|
|
|
|
|
|
void CVertexDictionary::SetRootVertexRange( int start, int end )
|
|
{
|
|
m_nRootLODStart = start;
|
|
m_nRootLODEnd = end;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Adds a vertex to the dictionary
|
|
//-----------------------------------------------------------------------------
|
|
int CVertexDictionary::AddVertex( const VertexInfo_t &srcVertex )
|
|
{
|
|
int nDstVertID = m_Verts.AddToTail( srcVertex );
|
|
VertexInfo_t &vertex = m_Verts[ nDstVertID ];
|
|
ValidateBoneWeight( vertex.m_BoneWeight );
|
|
SortBoneWeightByIndex( vertex.m_BoneWeight );
|
|
ValidateBoneWeight( vertex.m_BoneWeight );
|
|
|
|
return nDstVertID;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copies in a particular vertex from the s_source_t
|
|
//-----------------------------------------------------------------------------
|
|
int CVertexDictionary::AddVertexFromSource( const s_source_t *pSrc, int nVertexIndex, int nLod )
|
|
{
|
|
int nDstVertID = m_Verts.AddToTail( );
|
|
VertexInfo_t &vertex = m_Verts[ nDstVertID ];
|
|
|
|
const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[nVertexIndex];
|
|
vertex.m_Position = srcVertex.position;
|
|
vertex.m_Normal = srcVertex.normal;
|
|
vertex.m_TexCoord = srcVertex.texcoord;
|
|
vertex.m_TangentS = srcVertex.tangentS;
|
|
vertex.m_BoneWeight = srcVertex.boneweight;
|
|
vertex.m_nLodFlag = 1 << nLod;
|
|
|
|
ValidateBoneWeight( vertex.m_BoneWeight );
|
|
SortBoneWeightByIndex( vertex.m_BoneWeight );
|
|
ValidateBoneWeight( vertex.m_BoneWeight );
|
|
|
|
return nDstVertID;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// How many vertices in the dictionary?
|
|
//-----------------------------------------------------------------------------
|
|
int CVertexDictionary::VertexCount() const
|
|
{
|
|
return m_Verts.Count();
|
|
}
|
|
|
|
|
|
s_source_t* GetModelLODSource( const char *pModelName,
|
|
const LodScriptData_t& scriptLOD, bool* pFound )
|
|
{
|
|
// When doing LOD replacement, ignore all path + extension information
|
|
char* pTempBuf = (char*)_alloca( Q_strlen(pModelName) + 1 );
|
|
|
|
// Strip off extensions for the source...
|
|
strcpy( pTempBuf, pModelName );
|
|
char* pDot = strrchr( pTempBuf, '.' );
|
|
if (pDot)
|
|
{
|
|
*pDot = 0;
|
|
}
|
|
|
|
for( int i = 0; i < scriptLOD.modelReplacements.Count(); i++ )
|
|
{
|
|
// FIXME: Should we strip off path information?
|
|
// char* pSlash = strrchr( pTempBuf1, '\\' );
|
|
// char* pSlash2 = strrchr( pTempBuf1, '/' );
|
|
// if (pSlash2 > pSlash)
|
|
// pSlash = pSlash2;
|
|
// if (!pSlash)
|
|
// pSlash = pTempBuf1;
|
|
|
|
if( !Q_stricmp( pTempBuf, scriptLOD.modelReplacements[i].GetSrcName() ) )
|
|
{
|
|
*pFound = true;
|
|
return scriptLOD.modelReplacements[i].m_pSource;
|
|
}
|
|
}
|
|
|
|
*pFound = false;
|
|
return 0;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Tolerances for all fields of the vertex
|
|
//-----------------------------------------------------------------------------
|
|
#define POSITION_EPSILON 0.01f // Was 0.05f
|
|
#define TEXCOORD_EPSILON 0.01f
|
|
#define NORMAL_EPSILON 10.0f // in degrees
|
|
#define TANGENT_EPSILON 10.0f // in degrees
|
|
#define BONEWEIGHT_EPSILON 0.05f
|
|
|
|
#define UNMATCHED_BONE_WEIGHT 1.0f
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes error between two positions; returns false if the error is too great
|
|
//-----------------------------------------------------------------------------
|
|
bool ComparePositionFuzzy( const Vector &p1, const Vector &p2, float &flError )
|
|
{
|
|
Vector vecDelta;
|
|
VectorSubtract( p1, p2, vecDelta );
|
|
flError = DotProduct( vecDelta, vecDelta );
|
|
return ( flError <= (POSITION_EPSILON * POSITION_EPSILON) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes error between two normals; returns false if the error is too great
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareNormalFuzzy( const Vector &n1, const Vector &n2, float &flError )
|
|
{
|
|
static float flEpsilon = cos( DEG2RAD( NORMAL_EPSILON ) );
|
|
|
|
Vector v1, v2;
|
|
v1 = n1;
|
|
v2 = n2;
|
|
VectorNormalize( v1 );
|
|
VectorNormalize( v2 );
|
|
float flDot = DotProduct( v1, v2 );
|
|
flError = 1.0F - flDot;
|
|
return ( flDot >= flEpsilon );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes error between two tangentS vectors; returns false if the error is too great
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareTangentSFuzzy( const Vector4D &n1, const Vector4D &n2, float &flError )
|
|
{
|
|
static float flEpsilon = cos( DEG2RAD( TANGENT_EPSILON ) );
|
|
|
|
Vector4D v1, v2;
|
|
v1 = n1;
|
|
v2 = n2;
|
|
|
|
if (v1.w != v2.w)
|
|
{
|
|
// must match as -1 or 1
|
|
flError = 2;
|
|
return false;
|
|
}
|
|
|
|
VectorNormalize( v1.AsVector3D() );
|
|
VectorNormalize( v2.AsVector3D() );
|
|
float flDot = DotProduct( v1.AsVector3D(), v2.AsVector3D() );
|
|
|
|
// error ranges from [0..2]
|
|
flError = 1.0F - flDot;
|
|
|
|
return ( flDot >= flEpsilon );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes error between two texcoords; returns false if the error is too great
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareTexCoordsFuzzy( const Vector2D &t1, const Vector2D &t2, float &flError )
|
|
{
|
|
Vector2D vecError;
|
|
vecError[0] = fabs( t2[0] - t1[0] );
|
|
vecError[1] = fabs( t2[1] - t1[1] );
|
|
flError = vecError.LengthSqr();
|
|
return ( flError <= (TEXCOORD_EPSILON * TEXCOORD_EPSILON) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes the error between two bone weights, returns false if they are too far
|
|
//-----------------------------------------------------------------------------
|
|
bool CompareBoneWeightsFuzzy( const s_boneweight_t &b1, const s_boneweight_t &b2, float &flError )
|
|
{
|
|
// This is a list of which bones that exist in b1 also exist in b2.
|
|
// Use the index to figure out where in the array for b2 that the corresponding bone in b1 is.
|
|
int nMatchingBones = 0;
|
|
int pBoneIndexMap1[MAX_NUM_BONES_PER_VERT];
|
|
int pBoneIndexMap2[MAX_NUM_BONES_PER_VERT];
|
|
|
|
int i;
|
|
for ( i = 0; i < b2.numbones; ++i )
|
|
{
|
|
pBoneIndexMap2[i] = -1;
|
|
}
|
|
|
|
for ( i = 0; i < b1.numbones; ++i )
|
|
{
|
|
pBoneIndexMap1[i] = -1;
|
|
for ( int j = 0; j < b2.numbones; ++j )
|
|
{
|
|
if ( b2.bone[j] == b1.bone[i] )
|
|
{
|
|
pBoneIndexMap1[i] = j;
|
|
pBoneIndexMap2[j] = i;
|
|
++nMatchingBones;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If no bones match, we're done
|
|
if ( !nMatchingBones )
|
|
{
|
|
flError = FLT_MAX;
|
|
return false;
|
|
}
|
|
|
|
// At least one bone matches, so we're going to consider this vertex as a potential match
|
|
// This loop will take care of figuring out the error for all bones that exist in
|
|
// b1 alone, and all bones that exist in b1 and b2
|
|
flError = 0;
|
|
for ( i = 0; i < b1.numbones; ++i )
|
|
{
|
|
// If we didn't find a match for this bone, compute a more expensive weight
|
|
if ( pBoneIndexMap1[i] == -1 )
|
|
{
|
|
flError += b1.weight[i] * b1.weight[i] * UNMATCHED_BONE_WEIGHT;
|
|
continue;
|
|
}
|
|
|
|
float flDeltaWeight = fabs( b1.weight[i] - b2.weight[ pBoneIndexMap1[i] ] );
|
|
flError += flDeltaWeight * flDeltaWeight;
|
|
}
|
|
|
|
// This loop will take care of figuring out the error for all bones that exist in b2 alone
|
|
for ( i = 0; i < b2.numbones; ++i )
|
|
{
|
|
// If we didn't find a match for this bone, compute a more expensive weight
|
|
if ( pBoneIndexMap2[i] == -1 )
|
|
{
|
|
flError += b2.weight[i] * b2.weight[i] * UNMATCHED_BONE_WEIGHT;
|
|
}
|
|
}
|
|
|
|
// This renormalizes the error. The error will become greater with the total
|
|
// number of bones in the two vertices.
|
|
flError /= sqrt( (float) (b1.numbones + b2.numbones));
|
|
return ( flError <= BONEWEIGHT_EPSILON );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Searches for a material in the texture list
|
|
//-----------------------------------------------------------------------------
|
|
int FindMaterialByName( const char *pMaterialName )
|
|
{
|
|
int i;
|
|
int allocLen = strlen( pMaterialName ) + 1;
|
|
char *pBaseName = ( char * )_alloca( allocLen );
|
|
Q_FileBase( ( char * )pMaterialName, pBaseName, allocLen );
|
|
|
|
for( i = 0; i < g_numtextures; i++ )
|
|
{
|
|
if( stricmp( pBaseName, g_texture[i].name ) == 0 )
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static s_mesh_t *FindMeshByMaterial( s_source_t *pSrc, int nMaterialID )
|
|
{
|
|
for ( int m = 0; m < pSrc->nummeshes; m++ )
|
|
{
|
|
if ( pSrc->meshindex[m] == nMaterialID )
|
|
return &pSrc->mesh[ pSrc->meshindex[m] ];
|
|
}
|
|
|
|
// this mesh/material doesn't exist at this lod.
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static s_mesh_t *FindOrCullMesh( int nLodID, s_source_t *pSrc, int nMaterialID )
|
|
{
|
|
char baseMeshName[MAX_PATH];
|
|
char baseRemovalName[MAX_PATH];
|
|
|
|
// possibly marked for removal via $removemesh
|
|
// determine mesh name
|
|
int nTextureID = MaterialToTexture( nMaterialID );
|
|
if (nTextureID == -1)
|
|
{
|
|
MdlError( "Unknown Texture for Material %d\n", nMaterialID );
|
|
}
|
|
|
|
Q_FileBase(g_texture[nTextureID].name, baseMeshName, sizeof(baseMeshName)-1);
|
|
for ( int i = 0; i < g_ScriptLODs[nLodID].meshRemovals.Count(); i++ )
|
|
{
|
|
const char *pMeshRemovalName = g_ScriptLODs[nLodID].meshRemovals[i].GetSrcName();
|
|
Q_FileBase( pMeshRemovalName, baseRemovalName, sizeof(baseRemovalName)-1);
|
|
|
|
if (!stricmp( baseRemovalName, baseMeshName ))
|
|
{
|
|
// mesh has been marked for removal
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
s_mesh_t *pMesh = FindMeshByMaterial( pSrc, nMaterialID );
|
|
return pMesh;
|
|
}
|
|
|
|
|
|
static void CopyVerts( int nLodID, const s_source_t *pSrc, const s_mesh_t *pSrcMesh, CVertexDictionary &vertexDict, s_mesh_t *pDstMesh, int *pMeshVertIndexMap )
|
|
{
|
|
// populate the dictionary with the verts
|
|
for( int srcVertID = 0; srcVertID < pSrcMesh->numvertices; srcVertID++ )
|
|
{
|
|
int nVertexIndex = pSrcMesh->vertexoffset + srcVertID;
|
|
pMeshVertIndexMap[ nVertexIndex ] = vertexDict.AddVertexFromSource( pSrc, nVertexIndex, nLodID ) - pDstMesh->vertexoffset;
|
|
}
|
|
|
|
pDstMesh->numvertices = pSrcMesh->numvertices;
|
|
}
|
|
|
|
static void CopyFaces( const s_source_t *pSrc, const s_mesh_t *pSrcMesh, CUtlVector<s_face_t> &faces, s_mesh_t *pDstMesh )
|
|
{
|
|
int srcFaceID;
|
|
for( srcFaceID = 0; srcFaceID < pSrcMesh->numfaces; srcFaceID++ )
|
|
{
|
|
int srcID = srcFaceID + pSrcMesh->faceoffset;
|
|
s_face_t *pSrcFace = &pSrc->face[srcID];
|
|
s_face_t *pDstFace = &faces[faces.AddToTail()];
|
|
pDstFace->a = pSrcFace->a;
|
|
pDstFace->b = pSrcFace->b;
|
|
pDstFace->c = pSrcFace->c;
|
|
pDstMesh->numfaces++;
|
|
}
|
|
}
|
|
|
|
#define IGNORE_POSITION 0x01
|
|
#define IGNORE_TEXCOORD 0x02
|
|
#define IGNORE_BONEWEIGHT 0x04
|
|
#define IGNORE_NORMAL 0x08
|
|
#define IGNORE_TANGENTS 0x10
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// return -1 if there is no match. The index returned is used to index into vertexDict.
|
|
//-----------------------------------------------------------------------------
|
|
static int FindVertexWithinVertexDictionary( const VertexInfo_t &find,
|
|
const CVertexDictionary &vertexDict, int nStartVert, int nEndVert, int fIgnore )
|
|
{
|
|
int nBestIndex = -1;
|
|
float flPositionError = 0.0f;
|
|
float flNormalError = 0.0f;
|
|
float flTangentSError = 0.0f;
|
|
float flTexcoordError = 0.0f;
|
|
float flBoneWeightError = 0.0f;
|
|
float flMinPositionError = FLT_MAX;
|
|
float flMinNormalError = FLT_MAX;
|
|
float flMinTangentSError = FLT_MAX;
|
|
float flMinTexcoordError = FLT_MAX;
|
|
float flMinBoneWeightError = FLT_MAX;
|
|
bool bFound;
|
|
|
|
if (fIgnore & IGNORE_POSITION)
|
|
{
|
|
flMinPositionError = 0;
|
|
flPositionError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_TEXCOORD)
|
|
{
|
|
flMinTexcoordError = 0;
|
|
flTexcoordError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_BONEWEIGHT)
|
|
{
|
|
flMinBoneWeightError = 0;
|
|
flBoneWeightError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_NORMAL)
|
|
{
|
|
flMinNormalError = 0;
|
|
flNormalError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_TANGENTS)
|
|
{
|
|
flMinTangentSError = 0;
|
|
flTangentSError = 0;
|
|
}
|
|
|
|
for ( int nVertexIndex = nStartVert; nVertexIndex < nEndVert; ++nVertexIndex )
|
|
{
|
|
// see if the position is reasonable
|
|
if ( !(fIgnore & IGNORE_POSITION) && !ComparePositionFuzzy( find.m_Position, vertexDict.Vertex(nVertexIndex).m_Position, flPositionError ) )
|
|
continue;
|
|
|
|
if ( !(fIgnore & IGNORE_TEXCOORD) && !CompareTexCoordsFuzzy( find.m_TexCoord, vertexDict.Vertex(nVertexIndex).m_TexCoord, flTexcoordError ) )
|
|
continue;
|
|
|
|
if ( !(fIgnore & IGNORE_BONEWEIGHT) && !CompareBoneWeightsFuzzy( find.m_BoneWeight, vertexDict.Vertex(nVertexIndex).m_BoneWeight, flBoneWeightError ) )
|
|
continue;
|
|
|
|
if ( !(fIgnore & IGNORE_NORMAL) && !CompareNormalFuzzy( find.m_Normal, vertexDict.Vertex(nVertexIndex).m_Normal, flNormalError ) )
|
|
continue;
|
|
|
|
if ( !(fIgnore & IGNORE_TANGENTS) && !CompareTangentSFuzzy( find.m_TangentS, vertexDict.Vertex(nVertexIndex).m_TangentS, flTangentSError ) )
|
|
continue;
|
|
|
|
// the vert with minimum error is the best or exact candidate
|
|
bFound = false;
|
|
if (flMinPositionError > flPositionError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinPositionError == flPositionError)
|
|
{
|
|
if (flMinTexcoordError > flTexcoordError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinTexcoordError == flTexcoordError)
|
|
{
|
|
if (flMinBoneWeightError > flBoneWeightError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinBoneWeightError == flBoneWeightError)
|
|
{
|
|
if (flMinNormalError > flNormalError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinNormalError == flNormalError)
|
|
{
|
|
if (flMinTangentSError >= flTangentSError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bFound)
|
|
continue;
|
|
|
|
flMinPositionError = flPositionError;
|
|
flMinTexcoordError = flTexcoordError;
|
|
flMinBoneWeightError = flBoneWeightError;
|
|
flMinNormalError = flNormalError;
|
|
flMinTangentSError = flTangentSError;
|
|
nBestIndex = nVertexIndex;
|
|
}
|
|
|
|
return nBestIndex;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Use position, normal, and texcoord checks across the entire model to find a boneweight
|
|
//-----------------------------------------------------------------------------
|
|
static void FindBoneWeightWithinModel( const VertexInfo_t &searchVertex, const s_source_t *pSrc, s_boneweight_t &boneWeight, int fIgnore )
|
|
{
|
|
int nBestIndex = -1;
|
|
float flPositionError = 0.0f;
|
|
float flNormalError = 0.0f;
|
|
float flTangentSError = 0.0f;
|
|
float flTexcoordError = 0.0f;
|
|
float flMinPositionError = FLT_MAX;
|
|
float flMinNormalError = FLT_MAX;
|
|
float flMinTangentSError = FLT_MAX;
|
|
float flMinTexcoordError = FLT_MAX;
|
|
bool bFound;
|
|
|
|
if (fIgnore & IGNORE_NORMAL)
|
|
{
|
|
flMinNormalError = 0;
|
|
flNormalError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_TEXCOORD)
|
|
{
|
|
flMinTexcoordError = 0;
|
|
flTexcoordError = 0;
|
|
}
|
|
|
|
if (fIgnore & IGNORE_TANGENTS)
|
|
{
|
|
flMinTangentSError = 0;
|
|
flTangentSError = 0;
|
|
}
|
|
|
|
int nVertexCount = pSrc->m_GlobalVertices.Count();
|
|
for ( int i = 0; i < nVertexCount; i++ )
|
|
{
|
|
const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[i];
|
|
|
|
// Compute error metrics
|
|
ComparePositionFuzzy( searchVertex.m_Position, srcVertex.position, flPositionError );
|
|
|
|
if (!(fIgnore & IGNORE_NORMAL))
|
|
{
|
|
CompareNormalFuzzy( searchVertex.m_Normal, srcVertex.normal, flNormalError );
|
|
}
|
|
|
|
if (!(fIgnore & IGNORE_TEXCOORD))
|
|
{
|
|
CompareTexCoordsFuzzy( searchVertex.m_TexCoord, srcVertex.texcoord, flTexcoordError );
|
|
}
|
|
|
|
if (!(fIgnore & IGNORE_TANGENTS))
|
|
{
|
|
CompareTangentSFuzzy( searchVertex.m_TangentS, srcVertex.tangentS, flTangentSError );
|
|
}
|
|
|
|
// the vert with minimum error is the best or exact candidate
|
|
bFound = false;
|
|
if (flMinPositionError > flPositionError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinPositionError == flPositionError)
|
|
{
|
|
if (flMinTexcoordError > flTexcoordError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinTexcoordError == flTexcoordError)
|
|
{
|
|
if (flMinNormalError > flNormalError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
else if (flMinNormalError == flNormalError)
|
|
{
|
|
if (flMinTangentSError >= flTangentSError)
|
|
{
|
|
bFound = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bFound)
|
|
{
|
|
flMinPositionError = flPositionError;
|
|
flMinTexcoordError = flTexcoordError;
|
|
flMinNormalError = flNormalError;
|
|
flMinTangentSError = flTangentSError;
|
|
nBestIndex = i;
|
|
}
|
|
}
|
|
|
|
if ( nBestIndex == -1 )
|
|
{
|
|
MdlError( "Encountered a mesh with no vertices!\n" );
|
|
}
|
|
|
|
memcpy( &boneWeight, &pSrc->m_GlobalVertices[ nBestIndex ].boneweight, sizeof(s_boneweight_t) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Modify the bone weights in all of the vertices....
|
|
//-----------------------------------------------------------------------------
|
|
static void RemapBoneWeights( const CUtlVector<int> &boneMap, s_boneweight_t &boneWeight )
|
|
{
|
|
for( int i = 0; i < boneWeight.numbones; i++ )
|
|
{
|
|
Assert( boneWeight.bone[i] >= 0 && boneWeight.bone[i] < boneMap.Count() );
|
|
boneWeight.bone[i] = boneMap[ boneWeight.bone[i] ];
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// After the remapping, we may get multiple instances of the same bone
|
|
// which we want to collapse into a single bone
|
|
//-----------------------------------------------------------------------------
|
|
static void CollapseBoneWeights( s_boneweight_t &boneWeight )
|
|
{
|
|
// We need the bones to be sorted by bone index for the loop right below
|
|
SortBoneWeightByIndex( boneWeight );
|
|
|
|
for( int i = 0; i < boneWeight.numbones-1; i++ )
|
|
{
|
|
if( boneWeight.bone[i] != boneWeight.bone[i+1] )
|
|
continue;
|
|
|
|
// add i+1's weight to i since they have the same bone index
|
|
boneWeight.weight[i] += boneWeight.weight[i+1];
|
|
|
|
// remove i+1
|
|
for( int j = i+1; j < boneWeight.numbones-1; j++ )
|
|
{
|
|
boneWeight.bone[j] = boneWeight.bone[j+1];
|
|
boneWeight.weight[j] = boneWeight.weight[j+1];
|
|
}
|
|
--boneWeight.numbones;
|
|
|
|
// Gotta step back one, may have many bones collapsing into one
|
|
--i;
|
|
}
|
|
|
|
ValidateBoneWeight( boneWeight );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Find a matching vertex within the root lod
|
|
//-----------------------------------------------------------------------------
|
|
static void CalculateBoneWeightFromRootLod( const VertexInfo_t &searchVertex, CVertexDictionary &vertexDict,
|
|
const s_source_t *pRootLODSrc, VertexInfo_t &idealVertex )
|
|
{
|
|
idealVertex = searchVertex;
|
|
|
|
// Look through the part of the vertex dictionary associated with the root LODs for a match
|
|
// bone weights are not defined properly in SMDs for lower LODs, so don't consider
|
|
// we can only accept the boneweight from the root LOD
|
|
int nVertexDictID = FindVertexWithinVertexDictionary( searchVertex, vertexDict,
|
|
vertexDict.RootLODVertexStart(), vertexDict.RootLODVertexEnd(), IGNORE_BONEWEIGHT|IGNORE_TANGENTS );
|
|
if ( nVertexDictID != -1 )
|
|
{
|
|
Assert( nVertexDictID >= vertexDict.RootLODVertexStart() && nVertexDictID < vertexDict.RootLODVertexEnd() );
|
|
Assert( nVertexDictID >= 0 && nVertexDictID < vertexDict.VertexCount() );
|
|
|
|
// found vertex in dictionary
|
|
#ifdef UNIQUE_VERTEXES_FOR_LOD
|
|
// keep entry vertex and fill in the missing bone weight attribute
|
|
idealVertex.m_BoneWeight = vertexDict.Vertex( nVertexDictID ).m_BoneWeight;
|
|
#else
|
|
// discard entry vertex in favor of best match
|
|
// this ensures all the attributes, including bone weight are correct for that vertex
|
|
// the worst case is that the vertex is not an *exact* match for entry attributes just a "close" match
|
|
idealVertex = vertexDict.Vertex( nVertexDictID );
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// In this case, we didn't find anything within the tolerance, so we need to
|
|
// do a *positional check only* to give us a bone weight to assign to this vertex.
|
|
FindBoneWeightWithinModel( searchVertex, pRootLODSrc, idealVertex.m_BoneWeight, IGNORE_BONEWEIGHT|IGNORE_TANGENTS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Find a matching vertex
|
|
//-----------------------------------------------------------------------------
|
|
static void CalculateIdealVert( const VertexInfo_t &searchVertex, CVertexDictionary &vertexDict,
|
|
const s_mesh_t *pVertexDictMesh, const s_source_t *pRootLODSrc, VertexInfo_t &idealVertex )
|
|
{
|
|
#ifndef UNIQUE_VERTEXES_FOR_LOD
|
|
// Only look through the part of the vertex dictionary associated with all *higher* LODs for a match
|
|
int nVertexDictID = FindVertexWithinVertexDictionary( searchVertex, vertexDict,
|
|
pVertexDictMesh->vertexoffset, vertexDict.PrevLODVertexCount(), 0 );
|
|
if ( nVertexDictID != -1 )
|
|
{
|
|
Assert( nVertexDictID >= pVertexDictMesh->vertexoffset && nVertexDictID < vertexDict.PrevLODVertexCount() );
|
|
Assert( nVertexDictID >= 0 && nVertexDictID < vertexDict.VertexCount() );
|
|
|
|
// found vertex in dictionary
|
|
idealVertex = vertexDict.Vertex( nVertexDictID );
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
// could not find a tolerant match
|
|
// the search vertex is unique
|
|
idealVertex = searchVertex;
|
|
}
|
|
|
|
|
|
static bool FuzzyFloatCompare( float f1, float f2, float epsilon )
|
|
{
|
|
if( fabs( f1 - f2 ) < epsilon )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is this bone weight structure sorted by bone?
|
|
//-----------------------------------------------------------------------------
|
|
static bool IsBoneWeightSortedByBone( const s_boneweight_t &src )
|
|
{
|
|
for ( int i = 1; i < src.numbones; ++i )
|
|
{
|
|
Assert( src.bone[i] != -1 );
|
|
if ( src.bone[ i-1 ] > src.bone[ i ] )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Are two bone-weight structures equal?
|
|
//-----------------------------------------------------------------------------
|
|
static bool AreBoneWeightsEqual( const s_boneweight_t &b1, const s_boneweight_t &b2 )
|
|
{
|
|
// Have to have the same number of bones
|
|
if ( b1.numbones != b2.numbones )
|
|
return false;
|
|
|
|
// This is a list of which bones that exist in b1 also exist in b2.
|
|
// Use the index to figure out where in the array for b2 that the corresponding bone in b1 is.
|
|
int nMatchingBones = 0;
|
|
int pBoneIndexMap[MAX_NUM_BONES_PER_VERT];
|
|
|
|
int i;
|
|
for ( i = 0; i < b1.numbones; ++i )
|
|
{
|
|
pBoneIndexMap[i] = -1;
|
|
for ( int j = 0; j < b2.numbones; ++j )
|
|
{
|
|
if ( b2.bone[j] == b1.bone[i] )
|
|
{
|
|
pBoneIndexMap[i] = j;
|
|
++nMatchingBones;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we aren't using the same bone indices, we're done
|
|
if ( nMatchingBones != b1.numbones )
|
|
return false;
|
|
|
|
// Check to see if the weights are the same
|
|
for ( i = 0; i < b1.numbones; ++i )
|
|
{
|
|
Assert( pBoneIndexMap[i] != -1 );
|
|
if ( b1.weight[i] != b2.weight[ pBoneIndexMap[i] ] )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds an *exact* requested vertex in the dictionary
|
|
//-----------------------------------------------------------------------------
|
|
static int FindVertexInDictionaryExact( CVertexDictionary &vertexDict, int nStartVert, int nEndVert, const VertexInfo_t &vertex )
|
|
{
|
|
for ( int nVertID = nStartVert; nVertID < nEndVert; ++nVertID )
|
|
{
|
|
if ( vertexDict.Vertex( nVertID ).m_Position != vertex.m_Position )
|
|
continue;
|
|
|
|
if ( !AreBoneWeightsEqual( vertexDict.Vertex( nVertID ).m_BoneWeight, vertex.m_BoneWeight ) )
|
|
continue;
|
|
|
|
if ( vertexDict.Vertex( nVertID ).m_TexCoord != vertex.m_TexCoord )
|
|
continue;
|
|
|
|
if ( vertexDict.Vertex( nVertID ).m_Normal != vertex.m_Normal )
|
|
continue;
|
|
|
|
if ( vertexDict.Vertex( nVertID ).m_TangentS != vertex.m_TangentS )
|
|
continue;
|
|
|
|
return nVertID;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds the *exact* requested vertex in the dictionary or creates it
|
|
//-----------------------------------------------------------------------------
|
|
static int FindOrCreateExactVertexInDictionary( CVertexDictionary &vertexDict,
|
|
const VertexInfo_t &vertex, s_mesh_t *pDstMesh )
|
|
{
|
|
int nMeshVertID = FindVertexInDictionaryExact( vertexDict, pDstMesh->vertexoffset, pDstMesh->vertexoffset+pDstMesh->numvertices, vertex );
|
|
if ( nMeshVertID != -1 )
|
|
{
|
|
// flag vertex for what LoD's are using it
|
|
vertexDict.Vertex( nMeshVertID ).m_nLodFlag |= vertex.m_nLodFlag;
|
|
return nMeshVertID - pDstMesh->vertexoffset;
|
|
}
|
|
|
|
nMeshVertID = vertexDict.AddVertex( vertex );
|
|
++pDstMesh->numvertices;
|
|
return nMeshVertID - pDstMesh->vertexoffset;
|
|
}
|
|
|
|
static void PrintBonesUsedInLOD( s_source_t *pSrc )
|
|
{
|
|
printf( "PrintBonesUsedInLOD\n" );
|
|
|
|
int nVertexCount = pSrc->m_GlobalVertices.Count();
|
|
for( int i = 0; i <nVertexCount; i++ )
|
|
{
|
|
Vector &pos = pSrc->m_GlobalVertices[i].position;
|
|
Vector &norm = pSrc->m_GlobalVertices[i].normal;
|
|
Vector2D &texcoord = pSrc->m_GlobalVertices[i].texcoord;
|
|
printf( "pos: %f %f %f norm: %f %f %f texcoord: %f %f\n",
|
|
pos[0], pos[1], pos[2], norm[0], norm[1], norm[2], texcoord[0], texcoord[1] );
|
|
s_boneweight_t *pBoneWeight = &pSrc->m_GlobalVertices[i].boneweight;
|
|
int j;
|
|
for( j = 0; j < pBoneWeight->numbones; j++ )
|
|
{
|
|
int globalBoneID = pBoneWeight->bone[j];
|
|
const char *pBoneName = g_bonetable[globalBoneID].name;
|
|
printf( "vert: %d bone: %d boneid: %d weight: %f name: \"%s\"\n", i, ( int )j, ( int )pBoneWeight->bone[j],
|
|
( float )pBoneWeight->weight[j], pBoneName );
|
|
}
|
|
printf( "\n" );
|
|
fflush( stdout );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Indicates a particular set of bones is used by a particular LOD
|
|
//-----------------------------------------------------------------------------
|
|
static void MarkBonesUsedByLod( const s_boneweight_t &boneWeight, int nLodID )
|
|
{
|
|
for( int j = 0; j < boneWeight.numbones; ++j )
|
|
{
|
|
int nGlobalBoneID = boneWeight.bone[j];
|
|
s_bonetable_t *pBone = &g_bonetable[nGlobalBoneID];
|
|
pBone->flags |= ( BONE_USED_BY_VERTEX_LOD0 << nLodID );
|
|
}
|
|
}
|
|
|
|
|
|
static void PrintSBoneWeight( s_boneweight_t *pBoneWeight, const s_source_t *pSrc )
|
|
{
|
|
int j;
|
|
for( j = 0; j < pBoneWeight->numbones; j++ )
|
|
{
|
|
int globalBoneID;
|
|
globalBoneID = pBoneWeight->bone[j];
|
|
const char *pBoneName = g_bonetable[globalBoneID].name;
|
|
printf( "bone: %d boneid: %d weight: %f name: \"%s\"\n", ( int )j, ( int )pBoneWeight->bone[j],
|
|
( float )pBoneWeight->weight[j], pBoneName );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// In the non-top LOD, look for vertices that would be appropriate from the
|
|
// vertex dictionary, and use them if you find them, or add new vertices to the
|
|
// vertex dictionary if not and use those new vertices.
|
|
//-----------------------------------------------------------------------------
|
|
static void CreateLODVertsInDictionary( int nLodID, const s_source_t *pRootLODSrc, s_source_t *pCurrentLODSrc,
|
|
const s_mesh_t *pCurrLODMesh, s_mesh_t *pVertexDictMesh, CVertexDictionary &vertexDict, int *pMeshVertIndexMap )
|
|
{
|
|
// this function is specific to lods and not the root
|
|
Assert( nLodID );
|
|
|
|
int nNumCurrentVerts = vertexDict.VertexCount();
|
|
|
|
// Used to control where we look for vertices + merging rules
|
|
vertexDict.StartNewLOD();
|
|
|
|
CUtlVector<int> boneMap;
|
|
BuildBoneLODMapping( boneMap, nLodID );
|
|
|
|
for( int nSrcVertID = 0; nSrcVertID < pCurrLODMesh->numvertices; ++nSrcVertID )
|
|
{
|
|
int nSrcID = nSrcVertID + pCurrLODMesh->vertexoffset;
|
|
|
|
// candidate vertex
|
|
// vertices at lower LODs have bogus boneweights assigned
|
|
// must get the boneweight from the nearest or exact vertex at root lod
|
|
const s_vertexinfo_t& srcVertex = pCurrentLODSrc->m_GlobalVertices[nSrcID];
|
|
VertexInfo_t vertex;
|
|
vertex.m_Position = srcVertex.position;
|
|
vertex.m_Normal = srcVertex.normal;
|
|
vertex.m_TexCoord = srcVertex.texcoord;
|
|
vertex.m_TangentS = srcVertex.tangentS;
|
|
|
|
#ifdef _DEBUG
|
|
memset( &vertex.m_BoneWeight, 0xDD, sizeof( s_boneweight_t ) );
|
|
#endif
|
|
// determine the best bone weight for the desired vertex within the root lod only
|
|
// the root lod contains no bone remappings
|
|
// this ensures we get a vertex with its matched proper boneweight assignment
|
|
VertexInfo_t idealVertex;
|
|
CalculateBoneWeightFromRootLod( vertex, vertexDict, pRootLODSrc, idealVertex );
|
|
|
|
// try again to match the candidate vertex
|
|
// determine the ideal vertex with desired remapped boneweight
|
|
vertex = idealVertex;
|
|
CalculateIdealVert( vertex, vertexDict, pVertexDictMesh, pRootLODSrc, idealVertex);
|
|
|
|
// remap bone
|
|
RemapBoneWeights( boneMap, idealVertex.m_BoneWeight );
|
|
CollapseBoneWeights( idealVertex.m_BoneWeight );
|
|
SortBoneWeightByWeight( idealVertex.m_BoneWeight );
|
|
|
|
// FIXME: this is marking bones based on the slammed vertex data
|
|
MarkBonesUsedByLod( idealVertex.m_BoneWeight, nLodID );
|
|
|
|
// tag ideal vertex as being part of the current lod
|
|
idealVertex.m_nLodFlag = 1 << nLodID;
|
|
|
|
// Find the exact vertex or create it in the dictionary
|
|
int nMeshVertID = FindOrCreateExactVertexInDictionary( vertexDict, idealVertex, pVertexDictMesh );
|
|
|
|
// Indicate where in the higher LODs the vertex we selected resides
|
|
pMeshVertIndexMap[nSrcID] = nMeshVertID;
|
|
}
|
|
|
|
int nNewVertsCreated = vertexDict.VertexCount() - nNumCurrentVerts;
|
|
if (!g_quiet && nNewVertsCreated)
|
|
{
|
|
printf( "Lod %d: vertexes: %d (%d new)\n", nLodID, vertexDict.VertexCount(), nNewVertsCreated);
|
|
}
|
|
}
|
|
|
|
static void PrintSourceVerts( s_source_t *pSrc )
|
|
{
|
|
int nVertexCount = pSrc->m_GlobalVertices.Count();
|
|
for( int i = 0; i < nVertexCount; i++ )
|
|
{
|
|
const s_vertexinfo_t &srcVertex = pSrc->m_GlobalVertices[i];
|
|
printf( "v %d ", i );
|
|
printf( "pos: %f %f %f ", srcVertex.position[0], srcVertex.position[1], srcVertex.position[2] );
|
|
printf( "norm: %f %f %f ", srcVertex.normal[0], srcVertex.normal[1], srcVertex.normal[2] );
|
|
printf( "texcoord: %f %f\n", srcVertex.texcoord[0], srcVertex.texcoord[1] );
|
|
int j;
|
|
for( j = 0; j < srcVertex.boneweight.numbones; j++ )
|
|
{
|
|
printf( "\t%d: %d %f\n", j, ( int )srcVertex.boneweight.bone[j],
|
|
srcVertex.boneweight.weight[j] );
|
|
}
|
|
fflush( stdout );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copy the vertex dictionary to the finalized processed data
|
|
// Leaves the source data intact, necessary for later processes.
|
|
// Routines can then choose which data they operate on
|
|
//-----------------------------------------------------------------------------
|
|
static void SetProcessedWithDictionary( s_model_t* pSrcModel, CVertexDictionary &vertexDict,
|
|
CUtlVector<s_face_t> &faces, CUtlVector<s_mesh_t> &meshes, int *pMeshVertIndexMaps[MAX_NUM_LODS] )
|
|
{
|
|
int i;
|
|
|
|
s_loddata_t *pLodData = new s_loddata_t;
|
|
memset( pLodData, 0, sizeof(s_loddata_t) );
|
|
|
|
pSrcModel->m_pLodData = pLodData;
|
|
|
|
int nVertexCount = vertexDict.VertexCount();
|
|
|
|
pLodData->vertex = (s_lodvertexinfo_t *)kalloc( nVertexCount, sizeof( s_lodvertexinfo_t ) );
|
|
pLodData->numvertices = nVertexCount;
|
|
pLodData->face = (s_face_t *)kalloc( faces.Count(), sizeof( s_face_t ));
|
|
pLodData->numfaces = faces.Count();
|
|
|
|
for ( i = 0; i < nVertexCount; ++i )
|
|
{
|
|
const VertexInfo_t &srcVertex = vertexDict.Vertex( i );
|
|
s_lodvertexinfo_t &dstVertex = pLodData->vertex[i];
|
|
|
|
dstVertex.boneweight = srcVertex.m_BoneWeight;
|
|
Assert( dstVertex.boneweight.numbones <= 4 );
|
|
dstVertex.position = srcVertex.m_Position;
|
|
dstVertex.normal = srcVertex.m_Normal;
|
|
dstVertex.texcoord = srcVertex.m_TexCoord;
|
|
dstVertex.tangentS = srcVertex.m_TangentS;
|
|
dstVertex.lodFlag = srcVertex.m_nLodFlag;
|
|
}
|
|
|
|
memcpy( pLodData->face, faces.Base(), faces.Count() * sizeof( s_face_t ) );
|
|
memcpy( pLodData->mesh, meshes.Base(), meshes.Count() * sizeof( s_mesh_t ) );
|
|
|
|
for (i=0; i<MAX_NUM_LODS; i++)
|
|
{
|
|
pLodData->pMeshVertIndexMaps[i] = pMeshVertIndexMaps[i];
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// This fills out boneMap, which is a mapping from src bone to src bone replacement (or to itself
|
|
// if there is no bone replacement.
|
|
//-----------------------------------------------------------------------------
|
|
static void BuildBoneLODMapping( CUtlVector<int> &boneMap, int lodID )
|
|
{
|
|
boneMap.AddMultipleToTail( g_numbones );
|
|
|
|
Assert( lodID < g_ScriptLODs.Size() );
|
|
LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
|
|
|
|
// First, create a direct mapping where no bones are collapsed
|
|
int i;
|
|
for( i = 0; i < g_numbones; i++ )
|
|
{
|
|
boneMap[i] = i;
|
|
}
|
|
|
|
for( i = 0; i < scriptLOD.boneReplacements.Size(); i++ )
|
|
{
|
|
const char *src, *dst;
|
|
src = scriptLOD.boneReplacements[i].GetSrcName();
|
|
dst = scriptLOD.boneReplacements[i].GetDstName();
|
|
int j = findGlobalBone( src );
|
|
int k = findGlobalBone( dst );
|
|
|
|
if ( j != -1 && k != -1)
|
|
{
|
|
boneMap[j] = k;
|
|
}
|
|
else if ( j == -1)
|
|
{
|
|
// FIXME: is this really an error? It could just be replacement command for bone that doesnt' exist anymore.
|
|
if (g_verbose)
|
|
{
|
|
MdlWarning( "Couldn't replace unknown bone \"%s\" with \"%s\"\n", src, dst );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// FIXME: is this really an error? It could just be replacement command for bone that doesnt' exist anymore.
|
|
if (g_verbose)
|
|
{
|
|
MdlWarning( "Couldn't replace bone \"%s\" with unknown \"%s\"\n", src, dst );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MarkRootLODBones( CVertexDictionary &vertexDictionary )
|
|
{
|
|
// should result in an identity mapping
|
|
// because their are no bone remaps at the root lod
|
|
CUtlVector<int> boneMap;
|
|
BuildBoneLODMapping( boneMap, 0 );
|
|
|
|
// iterate and mark bones
|
|
for (int nVertDictID=vertexDictionary.RootLODVertexStart(); nVertDictID<vertexDictionary.RootLODVertexEnd(); nVertDictID++)
|
|
{
|
|
s_boneweight_t &boneWeight = vertexDictionary.Vertex( nVertDictID ).m_BoneWeight;
|
|
|
|
RemapBoneWeights( boneMap, boneWeight );
|
|
CollapseBoneWeights( boneWeight );
|
|
SortBoneWeightByWeight( boneWeight );
|
|
|
|
MarkBonesUsedByLod( boneWeight, 0 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Computes LOD vertices for a model piece.
|
|
//-----------------------------------------------------------------------------
|
|
static void UnifyModelLODs( s_model_t *pSrcModel )
|
|
{
|
|
if ( !Q_stricmp( pSrcModel->name, "blank" ) )
|
|
return;
|
|
|
|
// each lod has a unique vertex mapping table
|
|
int nNumLODs = pSrcModel->m_LodSources.Count();
|
|
int nLodID;
|
|
int *pMeshVertIndexMaps[MAX_NUM_LODS];
|
|
for ( nLodID = 0; nLodID < MAX_NUM_LODS; nLodID++ )
|
|
{
|
|
if ( nLodID < nNumLODs && pSrcModel->m_LodSources[nLodID] )
|
|
{
|
|
int nVertexCount = pSrcModel->m_LodSources[nLodID]->m_GlobalVertices.Count();
|
|
pMeshVertIndexMaps[nLodID] = new int[ nVertexCount ];
|
|
#ifdef _DEBUG
|
|
memset( pMeshVertIndexMaps[nLodID], 0xDD, nVertexCount * sizeof(int) );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
pMeshVertIndexMaps[nLodID] = NULL;
|
|
}
|
|
}
|
|
|
|
// These hold the aggregate data for the model that grows as lods are processed
|
|
CVertexDictionary vertexDictionary;
|
|
CUtlVector<s_face_t> faces;
|
|
CUtlVector<s_mesh_t> meshes;
|
|
|
|
meshes.AddMultipleToTail( MAXSTUDIOSKINS );
|
|
Assert( meshes.Count() == MAXSTUDIOSKINS );
|
|
memset( meshes.Base(), 0, meshes.Count() * sizeof( s_mesh_t ) );
|
|
|
|
int nMeshID;
|
|
for( nMeshID = 0; nMeshID < pSrcModel->source->nummeshes; nMeshID++ )
|
|
{
|
|
s_mesh_t *pVertexDictMesh = &meshes[pSrcModel->source->meshindex[nMeshID]];
|
|
|
|
pVertexDictMesh->numvertices = 0;
|
|
pVertexDictMesh->vertexoffset = vertexDictionary.VertexCount();
|
|
pVertexDictMesh->numfaces = 0;
|
|
pVertexDictMesh->faceoffset = faces.Count();
|
|
|
|
// First build up information for LOD 0
|
|
if ( !pSrcModel->m_LodSources[0] )
|
|
continue;
|
|
|
|
s_source_t *pLOD0Source = pSrcModel->m_LodSources[0];
|
|
|
|
// lookup the material used by this mesh
|
|
int nMaterialID = pLOD0Source->meshindex[nMeshID];
|
|
s_mesh_t *pLOD0Mesh = FindMeshByMaterial( pLOD0Source, nMaterialID );
|
|
if ( !pLOD0Mesh )
|
|
continue;
|
|
|
|
// populate with all vertices from LOD 0
|
|
int nStart = vertexDictionary.VertexCount();
|
|
CopyVerts( 0, pLOD0Source, pLOD0Mesh, vertexDictionary, pVertexDictMesh, pMeshVertIndexMaps[0] );
|
|
vertexDictionary.SetRootVertexRange( nStart, vertexDictionary.VertexCount() );
|
|
|
|
MarkRootLODBones( vertexDictionary );
|
|
|
|
// only fix up the faces for the highest lod since the lowest ones are going
|
|
// to be reprocessed later.
|
|
CopyFaces( pLOD0Source, pLOD0Mesh, faces, pVertexDictMesh );
|
|
|
|
// Now, for each LOD, try to build meshes using the vertices in LOD 0.
|
|
// Ideally, vertices used in an LOD would be in LOD 0 for the benefit of shared vertices.
|
|
// If we don't find vertices in LOD 0, this code will add vertices into LOD 0's list
|
|
// of vertices for the next LOD to find
|
|
for ( nLodID = 1; nLodID < nNumLODs; ++nLodID )
|
|
{
|
|
s_source_t *pCurrLOD = pSrcModel->m_LodSources[nLodID];
|
|
if ( !pCurrLOD )
|
|
continue;
|
|
|
|
// Find the mesh that matches the material
|
|
// mesh may not be present or could be culled due to $removemesh commands
|
|
s_mesh_t *pCurrLODMesh = FindOrCullMesh( nLodID, pCurrLOD, nMaterialID );
|
|
if ( !pCurrLODMesh )
|
|
continue;
|
|
|
|
CreateLODVertsInDictionary( nLodID, pLOD0Source, pCurrLOD, pCurrLODMesh, pVertexDictMesh, vertexDictionary, pMeshVertIndexMaps[nLodID]);
|
|
}
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
Msg( "Total vertex count: %d\n", vertexDictionary.VertexCount() );
|
|
#endif
|
|
|
|
// save the data we just built into the processed data section
|
|
// The processed data has all of the verts that are needed for all LODs.
|
|
SetProcessedWithDictionary( pSrcModel, vertexDictionary, faces, meshes, pMeshVertIndexMaps );
|
|
// PrintSourceVerts( pSrcModel->m_LodModels[0] );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Force the vertex array for a model to have all of the vertices that are needed
|
|
// for all of the LODs of the model.
|
|
//-----------------------------------------------------------------------------
|
|
void UnifyLODs( void )
|
|
{
|
|
// todo: need to fixup the firstref/lastref stuff . . do we really need it anymore?
|
|
for( int modelID = 0; modelID < g_nummodelsbeforeLOD; modelID++ )
|
|
{
|
|
UnifyModelLODs( g_model[modelID] );
|
|
}
|
|
}
|
|
|
|
|
|
static void PrintSpaces( int numSpaces )
|
|
{
|
|
int i;
|
|
for( i = 0; i < numSpaces; i++ )
|
|
{
|
|
printf( " " );
|
|
}
|
|
}
|
|
|
|
static void SpewBoneInfo( int globalBoneID, int depth )
|
|
{
|
|
s_bonetable_t *pBone = &g_bonetable[globalBoneID];
|
|
if( g_bPrintBones )
|
|
{
|
|
PrintSpaces( depth * 2 );
|
|
printf( "%d \"%s\" ", depth, pBone->name );
|
|
}
|
|
int i;
|
|
for( i = 0; i < 8; i++ )
|
|
{
|
|
if( pBone->flags & ( BONE_USED_BY_VERTEX_LOD0 << i ) )
|
|
{
|
|
if( g_bPrintBones )
|
|
{
|
|
printf( "lod%d ", i );
|
|
}
|
|
g_NumBonesInLOD[i]++;
|
|
}
|
|
}
|
|
if( g_bPrintBones )
|
|
{
|
|
printf( "\n" );
|
|
}
|
|
|
|
int j;
|
|
for( j = 0; j < g_numbones; j++ )
|
|
{
|
|
s_bonetable_t *pBone = &g_bonetable[j];
|
|
if( pBone->parent == globalBoneID )
|
|
{
|
|
SpewBoneInfo( j, depth + 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
void SpewBoneUsageStats( void )
|
|
{
|
|
memset( g_NumBonesInLOD, 0, sizeof( int ) * MAX_NUM_LODS );
|
|
if( g_numbones == 0 )
|
|
{
|
|
return;
|
|
}
|
|
SpewBoneInfo( 0, 0 );
|
|
if( g_bPrintBones )
|
|
{
|
|
int i;
|
|
for( i = 0; i < g_ScriptLODs.Count(); i++ )
|
|
{
|
|
printf( "\t%d bones used in lod %d\n", g_NumBonesInLOD[i], i );
|
|
}
|
|
}
|
|
}
|
|
|
|
void MarkParentBoneLODs( void )
|
|
{
|
|
int i;
|
|
for( i = 0; i < g_numbones; i++ )
|
|
{
|
|
int flags = g_bonetable[i].flags;
|
|
flags &= BONE_USED_BY_VERTEX_MASK;
|
|
int globalBoneID = g_bonetable[i].parent;
|
|
while( globalBoneID != -1 )
|
|
{
|
|
g_bonetable[globalBoneID].flags |= flags;
|
|
globalBoneID = g_bonetable[globalBoneID].parent;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the sources associated with the various LODs based on the script commands
|
|
//-----------------------------------------------------------------------------
|
|
static void GetLODSources( CUtlVector< s_source_t * > &lods, const s_model_t *pSrcModel )
|
|
{
|
|
int nNumLODs = g_ScriptLODs.Count();
|
|
lods.EnsureCount( nNumLODs );
|
|
for( int lodID = 0; lodID < nNumLODs; lodID++ )
|
|
{
|
|
LodScriptData_t& scriptLOD = g_ScriptLODs[lodID];
|
|
|
|
bool bFound;
|
|
s_source_t* pSource = GetModelLODSource( pSrcModel->filename, scriptLOD, &bFound );
|
|
if ( !pSource && !bFound )
|
|
{
|
|
pSource = pSrcModel->source;
|
|
}
|
|
|
|
lods[lodID] = pSource;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates models to store converted data for the various LODs
|
|
//-----------------------------------------------------------------------------
|
|
void LoadLODSources( void )
|
|
{
|
|
g_nummodelsbeforeLOD = g_nummodels;
|
|
for( int modelID = 0; modelID < g_nummodelsbeforeLOD; modelID++ )
|
|
{
|
|
if ( !Q_stricmp( g_model[modelID]->name, "blank" ) )
|
|
{
|
|
int nNumLODs = g_ScriptLODs.Count();
|
|
g_model[modelID]->m_LodSources.SetCount( nNumLODs );
|
|
for ( int i = 0; i < nNumLODs; ++i )
|
|
{
|
|
g_model[modelID]->m_LodSources[i] = NULL;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
GetLODSources( g_model[modelID]->m_LodSources, g_model[modelID] );
|
|
}
|
|
}
|
|
|
|
static void ReplaceBonesRecursive( int globalBoneID, bool replaceThis,
|
|
CUtlVector<CLodScriptReplacement_t> &boneReplacements,
|
|
const char *replacementName )
|
|
{
|
|
if( replaceThis )
|
|
{
|
|
CLodScriptReplacement_t &boneReplacement = boneReplacements[boneReplacements.AddToTail()];
|
|
boneReplacement.SetSrcName( g_bonetable[globalBoneID].name );
|
|
boneReplacement.SetDstName( replacementName );
|
|
}
|
|
|
|
// find children and recurse.
|
|
int i;
|
|
for( i = 0; i < g_numbones; i++ )
|
|
{
|
|
if( g_bonetable[i].parent == globalBoneID )
|
|
{
|
|
ReplaceBonesRecursive( i, true, boneReplacements, replacementName );
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ConvertSingleBoneTreeCollapseToReplaceBones( CLodScriptReplacement_t &boneTreeCollapse,
|
|
CUtlVector<CLodScriptReplacement_t> &boneReplacements )
|
|
{
|
|
// find the bone that we are starting with.
|
|
int i = findGlobalBone( boneTreeCollapse.GetSrcName() );
|
|
if (i != -1)
|
|
{
|
|
ReplaceBonesRecursive( i, false, boneReplacements, g_bonetable[i].name );
|
|
return;
|
|
}
|
|
MdlWarning( "Couldn't find bone %s for bonetreecollapse, skipping\n", boneTreeCollapse.GetSrcName() );
|
|
}
|
|
|
|
void ConvertBoneTreeCollapsesToReplaceBones( void )
|
|
{
|
|
int i;
|
|
for( i = 0; i < g_ScriptLODs.Size(); i++ )
|
|
{
|
|
LodScriptData_t& lod = g_ScriptLODs[i];
|
|
int j;
|
|
for( j = 0; j < lod.boneTreeCollapses.Size(); j++ )
|
|
{
|
|
ConvertSingleBoneTreeCollapseToReplaceBones( lod.boneTreeCollapses[j],
|
|
lod.boneReplacements );
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
static void PrintReplacedBones( LodScriptData_t &lod )
|
|
{
|
|
int i;
|
|
for( i = 0; i < lod.boneReplacements.Count(); i++ )
|
|
{
|
|
printf( "%s -> %s\n",
|
|
lod.boneReplacements[i].GetSrcName(),
|
|
lod.boneReplacements[i].GetDstName() );
|
|
}
|
|
}
|
|
*/
|
|
|
|
void FixupReplacedBonesForLOD( LodScriptData_t &lod )
|
|
{
|
|
/*
|
|
printf( "before:\n" );
|
|
PrintReplacedBones( lod );
|
|
*/
|
|
bool changed;
|
|
int i;
|
|
int j;
|
|
do
|
|
{
|
|
changed = false;
|
|
for( i = 0; i < lod.boneReplacements.Count(); i++ )
|
|
{
|
|
for( j = 0; j < lod.boneReplacements.Count(); j++ )
|
|
{
|
|
if( i == j )
|
|
{
|
|
continue;
|
|
}
|
|
if( Q_stricmp( lod.boneReplacements[i].GetSrcName(), lod.boneReplacements[j].GetDstName() ) == 0 )
|
|
{
|
|
lod.boneReplacements[j].SetDstName( lod.boneReplacements[i].GetDstName() );
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
} while( changed );
|
|
/*
|
|
printf( "after:\n" );
|
|
PrintReplacedBones( lod );
|
|
*/
|
|
}
|
|
|
|
void FixupReplacedBones( void )
|
|
{
|
|
int i;
|
|
for( i = 0; i < g_ScriptLODs.Size(); i++ )
|
|
{
|
|
FixupReplacedBonesForLOD( g_ScriptLODs[i] );
|
|
}
|
|
}
|