/*
====================
idMD5Mesh::ParseMesh
====================
*/
void idMD5Mesh::ParseMesh( idLexer& parser, int numJoints, const idJointMat* joints )
{
idToken token;
idToken name;
parser.ExpectTokenString( "{" );
//
// parse name
//
if( parser.CheckTokenString( "name" ) )
{
parser.ReadToken( &name );
}
//
// parse shader
//
parser.ExpectTokenString( "shader" );
parser.ReadToken( &token );
idStr shaderName = token;
shader = declManager->FindMaterial( shaderName );
//
// parse texture coordinates
//
parser.ExpectTokenString( "numverts" );
int count = parser.ParseInt();
if( count < 0 )
{
parser.Error( "Invalid size: %s", token.c_str() );
}
this->numVerts = count;
idList<idVec2> texCoords;
idList<int> firstWeightForVertex;
idList<int> numWeightsForVertex;
texCoords.SetNum( count );
firstWeightForVertex.SetNum( count );
numWeightsForVertex.SetNum( count );
int numWeights = 0;
int maxweight = 0;
for( int i = 0; i < texCoords.Num(); i++ )
{
parser.ExpectTokenString( "vert" );
parser.ParseInt();
parser.Parse1DMatrix( 2, texCoords[ i ].ToFloatPtr() );
firstWeightForVertex[ i ] = parser.ParseInt();
numWeightsForVertex[ i ] = parser.ParseInt();
if( !numWeightsForVertex[ i ] )
{
parser.Error( "Vertex without any joint weights." );
}
numWeights += numWeightsForVertex[ i ];
if( numWeightsForVertex[ i ] + firstWeightForVertex[ i ] > maxweight )
{
maxweight = numWeightsForVertex[ i ] + firstWeightForVertex[ i ];
}
}
//
// parse tris
//
parser.ExpectTokenString( "numtris" );
count = parser.ParseInt();
if( count < 0 )
{
parser.Error( "Invalid size: %d", count );
}
idList<int> tris;
tris.SetNum( count * 3 );
numTris = count;
for( int i = 0; i < count; i++ )
{
parser.ExpectTokenString( "tri" );
parser.ParseInt();
tris[ i * 3 + 0 ] = parser.ParseInt();
tris[ i * 3 + 1 ] = parser.ParseInt();
tris[ i * 3 + 2 ] = parser.ParseInt();
}
//
// parse weights
//
parser.ExpectTokenString( "numweights" );
count = parser.ParseInt();
if( count < 0 )
{
parser.Error( "Invalid size: %d", count );
}
if( maxweight > count )
{
parser.Warning( "Vertices reference out of range weights in model (%d of %d weights).", maxweight, count );
}
idList<vertexWeight_t> tempWeights;
tempWeights.SetNum( count );
assert( numJoints < 256 ); // so we can pack into bytes
for( int i = 0; i < count; i++ )
{
parser.ExpectTokenString( "weight" );
parser.ParseInt();
int jointnum = parser.ParseInt();
if( ( jointnum < 0 ) || ( jointnum >= numJoints ) )
{
parser.Error( "Joint Index out of range(%d): %d", numJoints, jointnum );
}
tempWeights[ i ].joint = jointnum;
tempWeights[ i ].jointWeight = parser.ParseFloat();
parser.Parse1DMatrix( 3, tempWeights[ i ].offset.ToFloatPtr() );
}
// create pre-scaled weights and an index for the vertex/joint lookup
idVec4* scaledWeights = ( idVec4* ) Mem_Alloc16( numWeights * sizeof( scaledWeights[0] ), TAG_MD5_WEIGHT );
int* weightIndex = ( int* ) Mem_Alloc16( numWeights * 2 * sizeof( weightIndex[0] ), TAG_MD5_INDEX );
memset( weightIndex, 0, numWeights * 2 * sizeof( weightIndex[0] ) );
count = 0;
for( int i = 0; i < texCoords.Num(); i++ )
{
int num = firstWeightForVertex[i];
for( int j = 0; j < numWeightsForVertex[i]; j++, num++, count++ )
{
scaledWeights[count].ToVec3() = tempWeights[num].offset * tempWeights[num].jointWeight;
scaledWeights[count].w = tempWeights[num].jointWeight;
weightIndex[count * 2 + 0] = tempWeights[num].joint * sizeof( idJointMat );
}
weightIndex[count * 2 - 1] = 1;
}
parser.ExpectTokenString( "}" );
// update counters
c_numVerts += texCoords.Num();
c_numWeights += numWeights;
c_numWeightJoints++;
for( int i = 0; i < numWeights; i++ )
{
c_numWeightJoints += weightIndex[i * 2 + 1];
}
//
// build a base pose that can be used for skinning
//
idDrawVert* basePose = ( idDrawVert* )Mem_ClearedAlloc( texCoords.Num() * sizeof( *basePose ), TAG_MD5_BASE );
for( int j = 0, i = 0; i < texCoords.Num(); i++ )
{
idVec3 v = ( *( idJointMat* )( ( byte* )joints + weightIndex[j * 2 + 0] ) ) * scaledWeights[j];
while( weightIndex[j * 2 + 1] == 0 )
{
j++;
v += ( *( idJointMat* )( ( byte* )joints + weightIndex[j * 2 + 0] ) ) * scaledWeights[j];
}
j++;
basePose[i].Clear();
basePose[i].xyz = v;
basePose[i].SetTexCoord( texCoords[i] );
}
// build the weights and bone indexes into the verts, so they will be duplicated
// as necessary at mirror seems
static int maxWeightsPerVert;
static float maxResidualWeight;
const int MAX_VERTEX_WEIGHTS = 4;
idList< bool > jointIsUsed;
jointIsUsed.SetNum( numJoints );
for( int i = 0; i < jointIsUsed.Num(); i++ )
{
jointIsUsed[i] = false;
}
numMeshJoints = 0;
maxJointVertDist = 0.0f;
//-----------------------------------------
// new-style setup for fixed four weights and normal / tangent deformation
//
// Several important models have >25% residual weight in joints after the
// first four, which is worrisome for using a fixed four joint deformation.
//-----------------------------------------
for( int i = 0; i < texCoords.Num(); i++ )
{
idDrawVert& dv = basePose[i];
// some models do have >4 joint weights, so it is necessary to sort and renormalize
// sort the weights and take the four largest
int weights[256];
const int numWeights = numWeightsForVertex[ i ];
for( int j = 0; j < numWeights; j++ )
{
weights[j] = firstWeightForVertex[i] + j;
}
// bubble sort
for( int j = 0; j < numWeights; j++ )
{
for( int k = 0; k < numWeights - 1 - j; k++ )
{
if( tempWeights[weights[k]].jointWeight < tempWeights[weights[k + 1]].jointWeight )
{
SwapValues( weights[k], weights[k + 1] );
}
}
}
if( numWeights > maxWeightsPerVert )
{
maxWeightsPerVert = numWeights;
}
const int usedWeights = Min( MAX_VERTEX_WEIGHTS, numWeights );
float totalWeight = 0;
for( int j = 0; j < numWeights; j++ )
{
totalWeight += tempWeights[weights[j]].jointWeight;
}
assert( totalWeight > 0.999f && totalWeight < 1.001f );
float usedWeight = 0;
for( int j = 0; j < usedWeights; j++ )
{
usedWeight += tempWeights[weights[j]].jointWeight;
}
const float residualWeight = totalWeight - usedWeight;
if( residualWeight > maxResidualWeight )
{
maxResidualWeight = residualWeight;
}
byte finalWeights[MAX_VERTEX_WEIGHTS] = { 0 };
byte finalJointIndecies[MAX_VERTEX_WEIGHTS] = { 0 };
for( int j = 0; j < usedWeights; j++ )
{
const vertexWeight_t& weight = tempWeights[weights[j]];
const int jointIndex = weight.joint;
const float fw = weight.jointWeight;
assert( fw >= 0.0f && fw <= 1.0f );
const float normalizedWeight = fw / usedWeight;
finalWeights[j] = idMath::Ftob( normalizedWeight * 255.0f );
finalJointIndecies[j] = jointIndex;
}
// Sort the weights and indices for hardware skinning
for( int k = 0; k < 3; ++k )
{
for( int l = k + 1; l < 4; ++l )
{
if( finalWeights[l] > finalWeights[k] )
{
SwapValues( finalWeights[k], finalWeights[l] );
SwapValues( finalJointIndecies[k], finalJointIndecies[l] );
}
}
}
// Give any left over to the biggest weight
finalWeights[0] += Max( 255 - finalWeights[0] - finalWeights[1] - finalWeights[2] - finalWeights[3], 0 );
dv.color[0] = finalJointIndecies[0];
dv.color[1] = finalJointIndecies[1];
dv.color[2] = finalJointIndecies[2];
dv.color[3] = finalJointIndecies[3];
dv.color2[0] = finalWeights[0];
dv.color2[1] = finalWeights[1];
dv.color2[2] = finalWeights[2];
dv.color2[3] = finalWeights[3];
for( int j = usedWeights; j < 4; j++ )
{
assert( dv.color2[j] == 0 );
}
for( int j = 0; j < usedWeights; j++ )
{
if( !jointIsUsed[finalJointIndecies[j]] )
{
jointIsUsed[finalJointIndecies[j]] = true;
numMeshJoints++;
}
const idJointMat& joint = joints[finalJointIndecies[j]];
float dist = ( dv.xyz - joint.GetTranslation() ).Length();
if( dist > maxJointVertDist )
{
maxJointVertDist = dist;
}
}
}
meshJoints = ( byte* ) Mem_Alloc( numMeshJoints * sizeof( meshJoints[0] ), TAG_MODEL );
numMeshJoints = 0;
for( int i = 0; i < numJoints; i++ )
{
if( jointIsUsed[i] )
{
meshJoints[numMeshJoints++] = i;
}
}
// build the deformInfo and collect a final base pose with the mirror
// seam verts properly including the bone weights
deformInfo = R_BuildDeformInfo( texCoords.Num(), basePose, tris.Num(), tris.Ptr(),
shader->UseUnsmoothedTangents() );
for( int i = 0; i < deformInfo->numOutputVerts; i++ )
{
for( int j = 0; j < 4; j++ )
{
if( deformInfo->verts[i].color[j] >= numJoints )
{
idLib::FatalError( "Bad joint index" );
}
}
}
Mem_Free( basePose );
}
/*
====================
idRenderModelLiquid::InitFromFile
====================
*/
void idRenderModelLiquid::InitFromFile( const char* fileName )
{
int i, x, y;
idToken token;
idParser parser( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS );
idList<int> tris;
float size_x, size_y;
float rate;
name = fileName;
if( !parser.LoadFile( fileName ) )
{
MakeDefaultModel();
return;
}
size_x = scale_x * verts_x;
size_y = scale_y * verts_y;
while( parser.ReadToken( &token ) )
{
if( !token.Icmp( "seed" ) )
{
seed = parser.ParseInt();
}
else if( !token.Icmp( "size_x" ) )
{
size_x = parser.ParseFloat();
}
else if( !token.Icmp( "size_y" ) )
{
size_y = parser.ParseFloat();
}
else if( !token.Icmp( "verts_x" ) )
{
verts_x = parser.ParseFloat();
if( verts_x < 2 )
{
parser.Warning( "Invalid # of verts. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "verts_y" ) )
{
verts_y = parser.ParseFloat();
if( verts_y < 2 )
{
parser.Warning( "Invalid # of verts. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "liquid_type" ) )
{
liquid_type = parser.ParseInt() - 1;
if( ( liquid_type < 0 ) || ( liquid_type >= LIQUID_MAX_TYPES ) )
{
parser.Warning( "Invalid liquid_type. Using default model." );
MakeDefaultModel();
return;
}
}
else if( !token.Icmp( "density" ) )
{
density = parser.ParseFloat();
}
else if( !token.Icmp( "drop_height" ) )
{
drop_height = parser.ParseFloat();
}
else if( !token.Icmp( "drop_radius" ) )
{
drop_radius = parser.ParseInt();
}
else if( !token.Icmp( "drop_delay" ) )
{
drop_delay = SEC2MS( parser.ParseFloat() );
}
else if( !token.Icmp( "shader" ) )
{
parser.ReadToken( &token );
shader = declManager->FindMaterial( token );
}
else if( !token.Icmp( "update_rate" ) )
{
rate = parser.ParseFloat();
if( ( rate <= 0.0f ) || ( rate > 60.0f ) )
{
parser.Warning( "Invalid update_rate. Must be between 0 and 60. Using default model." );
MakeDefaultModel();
return;
}
update_tics = 1000 / rate;
}
else
{
parser.Warning( "Unknown parameter '%s'. Using default model.", token.c_str() );
MakeDefaultModel();
return;
}
}
scale_x = size_x / ( verts_x - 1 );
scale_y = size_y / ( verts_y - 1 );
pages.SetNum( 2 * verts_x * verts_y );
page1 = pages.Ptr();
page2 = page1 + verts_x * verts_y;
verts.SetNum( verts_x * verts_y );
for( i = 0, y = 0; y < verts_y; y++ )
{
for( x = 0; x < verts_x; x++, i++ )
{
page1[ i ] = 0.0f;
page2[ i ] = 0.0f;
verts[ i ].Clear();
verts[ i ].xyz.Set( x * scale_x, y * scale_y, 0.0f );
verts[ i ].SetTexCoord( ( float ) x / ( float )( verts_x - 1 ), ( float ) - y / ( float )( verts_y - 1 ) );
}
}
tris.SetNum( ( verts_x - 1 ) * ( verts_y - 1 ) * 6 );
for( i = 0, y = 0; y < verts_y - 1; y++ )
{
for( x = 1; x < verts_x; x++, i += 6 )
{
tris[ i + 0 ] = y * verts_x + x;
tris[ i + 1 ] = y * verts_x + x - 1;
tris[ i + 2 ] = ( y + 1 ) * verts_x + x - 1;
tris[ i + 3 ] = ( y + 1 ) * verts_x + x - 1;
tris[ i + 4 ] = ( y + 1 ) * verts_x + x;
tris[ i + 5 ] = y * verts_x + x;
}
}
// build the information that will be common to all animations of this mesh:
// sil edge connectivity and normal / tangent generation information
deformInfo = R_BuildDeformInfo( verts.Num(), verts.Ptr(), tris.Num(), tris.Ptr(), true );
bounds.Clear();
bounds.AddPoint( idVec3( 0.0f, 0.0f, drop_height * -10.0f ) );
bounds.AddPoint( idVec3( ( verts_x - 1 ) * scale_x, ( verts_y - 1 ) * scale_y, drop_height * 10.0f ) );
// set the timestamp for reloadmodels
fileSystem->ReadFile( name, NULL, &timeStamp );
Reset();
}
/*
====================
idMD5Mesh::ParseMesh
====================
*/
void idMD5Mesh::ParseMesh( idLexer &parser, int numJoints, const idJointMat *joints ) {
idToken token;
idToken name;
int num;
int count;
int jointnum;
idStr shaderName;
int i, j;
idList<int> tris;
idList<int> firstWeightForVertex;
idList<int> numWeightsForVertex;
int maxweight;
idList<vertexWeight_t> tempWeights;
parser.ExpectTokenString( "{" );
//
// parse name
//
if ( parser.CheckTokenString( "name" ) ) {
parser.ReadToken( &name );
}
//
// parse shader
//
parser.ExpectTokenString( "shader" );
parser.ReadToken( &token );
shaderName = token;
shader = declManager->FindMaterial( shaderName );
//
// parse texture coordinates
//
parser.ExpectTokenString( "numverts" );
count = parser.ParseInt();
if ( count < 0 ) {
parser.Error( "Invalid size: %s", token.c_str() );
}
texCoords.SetNum( count );
firstWeightForVertex.SetNum( count );
numWeightsForVertex.SetNum( count );
numWeights = 0;
maxweight = 0;
for( i = 0; i < texCoords.Num(); i++ ) {
parser.ExpectTokenString( "vert" );
parser.ParseInt();
parser.Parse1DMatrix( 2, texCoords[ i ].ToFloatPtr() );
firstWeightForVertex[ i ] = parser.ParseInt();
numWeightsForVertex[ i ] = parser.ParseInt();
if ( !numWeightsForVertex[ i ] ) {
parser.Error( "Vertex without any joint weights." );
}
numWeights += numWeightsForVertex[ i ];
if ( numWeightsForVertex[ i ] + firstWeightForVertex[ i ] > maxweight ) {
maxweight = numWeightsForVertex[ i ] + firstWeightForVertex[ i ];
}
}
//
// parse tris
//
parser.ExpectTokenString( "numtris" );
count = parser.ParseInt();
if ( count < 0 ) {
parser.Error( "Invalid size: %d", count );
}
tris.SetNum( count * 3 );
numTris = count;
for( i = 0; i < count; i++ ) {
parser.ExpectTokenString( "tri" );
parser.ParseInt();
tris[ i * 3 + 0 ] = parser.ParseInt();
tris[ i * 3 + 1 ] = parser.ParseInt();
tris[ i * 3 + 2 ] = parser.ParseInt();
}
//
// parse weights
//
parser.ExpectTokenString( "numweights" );
count = parser.ParseInt();
if ( count < 0 ) {
parser.Error( "Invalid size: %d", count );
}
if ( maxweight > count ) {
parser.Warning( "Vertices reference out of range weights in model (%d of %d weights).", maxweight, count );
}
tempWeights.SetNum( count );
for( i = 0; i < count; i++ ) {
parser.ExpectTokenString( "weight" );
parser.ParseInt();
jointnum = parser.ParseInt();
if ( ( jointnum < 0 ) || ( jointnum >= numJoints ) ) {
parser.Error( "Joint Index out of range(%d): %d", numJoints, jointnum );
}
tempWeights[ i ].joint = jointnum;
tempWeights[ i ].jointWeight = parser.ParseFloat();
parser.Parse1DMatrix( 3, tempWeights[ i ].offset.ToFloatPtr() );
}
// create pre-scaled weights and an index for the vertex/joint lookup
scaledWeights = (idVec4 *) Mem_Alloc16( numWeights * sizeof( scaledWeights[0] ) );
weightIndex = (int *) Mem_Alloc16( numWeights * 2 * sizeof( weightIndex[0] ) );
memset( weightIndex, 0, numWeights * 2 * sizeof( weightIndex[0] ) );
count = 0;
for( i = 0; i < texCoords.Num(); i++ ) {
num = firstWeightForVertex[i];
for( j = 0; j < numWeightsForVertex[i]; j++, num++, count++ ) {
scaledWeights[count].ToVec3() = tempWeights[num].offset * tempWeights[num].jointWeight;
scaledWeights[count].w = tempWeights[num].jointWeight;
weightIndex[count * 2 + 0] = tempWeights[num].joint * sizeof( idJointMat );
}
weightIndex[count * 2 - 1] = 1;
}
tempWeights.Clear();
numWeightsForVertex.Clear();
firstWeightForVertex.Clear();
parser.ExpectTokenString( "}" );
// update counters
c_numVerts += texCoords.Num();
c_numWeights += numWeights;
c_numWeightJoints++;
for ( i = 0; i < numWeights; i++ ) {
c_numWeightJoints += weightIndex[i*2+1];
}
//
// build the information that will be common to all animations of this mesh:
// silhouette edge connectivity and normal / tangent generation information
//
idDrawVert *verts = (idDrawVert *) _alloca16( texCoords.Num() * sizeof( idDrawVert ) );
for ( i = 0; i < texCoords.Num(); i++ ) {
verts[i].Clear();
verts[i].st = texCoords[i];
}
TransformVerts( verts, joints );
deformInfo = R_BuildDeformInfo( texCoords.Num(), verts, tris.Num(), tris.Ptr(), shader->UseUnsmoothedTangents() );
}
