/*
==============
R_CalcBones
The list of bones[] should only be built and modified from within here
==============
*/
void R_CalcBones(mdsHeader_t *header, const refEntity_t *refent, int *boneList, int numBones)
{
int i;
int *boneRefs;
float torsoWeight;
// if the entity has changed since the last time the bones were built, reset them
if (memcmp(&lastBoneEntity, refent, sizeof(refEntity_t)))
{
// different, cached bones are not valid
memset(validBones, 0, header->numBones);
lastBoneEntity = *refent;
// (SA) also reset these counter statics
//----(SA) print stats for the complete model (not per-surface)
if (r_bonesDebug->integer == 4 && totalrt)
{
Ren_Print("Lod %.2f verts %4d/%4d tris %4d/%4d (%.2f%%)\n",
lodScale,
totalrv,
totalv,
totalrt,
totalt,
( float )(100.0 * totalrt) / (float) totalt);
}
totalrv = totalrt = totalv = totalt = 0;
}
memset(newBones, 0, header->numBones);
if (refent->oldframe == refent->frame)
{
backlerp = 0;
frontlerp = 1;
}
else
{
backlerp = refent->backlerp;
frontlerp = 1.0f - backlerp;
}
if (refent->oldTorsoFrame == refent->torsoFrame)
{
torsoBacklerp = 0;
torsoFrontlerp = 1;
}
else
{
torsoBacklerp = refent->torsoBacklerp;
torsoFrontlerp = 1.0f - torsoBacklerp;
}
frameSize = (int) (sizeof(mdsFrame_t) + (header->numBones - 1) * sizeof(mdsBoneFrameCompressed_t));
frame = ( mdsFrame_t * )((byte *)header + header->ofsFrames +
refent->frame * frameSize);
torsoFrame = ( mdsFrame_t * )((byte *)header + header->ofsFrames +
refent->torsoFrame * frameSize);
oldFrame = ( mdsFrame_t * )((byte *)header + header->ofsFrames +
refent->oldframe * frameSize);
oldTorsoFrame = ( mdsFrame_t * )((byte *)header + header->ofsFrames +
refent->oldTorsoFrame * frameSize);
// lerp all the needed bones (torsoParent is always the first bone in the list)
cBoneList = frame->bones;
cBoneListTorso = torsoFrame->bones;
boneInfo = ( mdsBoneInfo_t * )((byte *)header + header->ofsBones);
boneRefs = boneList;
//
Matrix3Transpose(refent->torsoAxis, torsoAxis);
#ifdef HIGH_PRECISION_BONES
if (qtrue)
{
#else
if (!backlerp && !torsoBacklerp)
{
#endif
for (i = 0; i < numBones; i++, boneRefs++)
{
if (validBones[*boneRefs])
{
// this bone is still in the cache
bones[*boneRefs] = rawBones[*boneRefs];
continue;
}
// find our parent, and make sure it has been calculated
if ((boneInfo[*boneRefs].parent >= 0) && (!validBones[boneInfo[*boneRefs].parent] && !newBones[boneInfo[*boneRefs].parent]))
{
R_CalcBone(header, refent, boneInfo[*boneRefs].parent);
}
R_CalcBone(header, refent, *boneRefs);
}
}
else // interpolated
{
cOldBoneList = oldFrame->bones;
cOldBoneListTorso = oldTorsoFrame->bones;
for (i = 0; i < numBones; i++, boneRefs++)
{
if (validBones[*boneRefs])
{
// this bone is still in the cache
bones[*boneRefs] = rawBones[*boneRefs];
continue;
}
// find our parent, and make sure it has been calculated
if ((boneInfo[*boneRefs].parent >= 0) && (!validBones[boneInfo[*boneRefs].parent] && !newBones[boneInfo[*boneRefs].parent]))
{
R_CalcBoneLerp(header, refent, boneInfo[*boneRefs].parent);
}
R_CalcBoneLerp(header, refent, *boneRefs);
}
}
// adjust for torso rotations
torsoWeight = 0;
boneRefs = boneList;
for (i = 0; i < numBones; i++, boneRefs++)
{
thisBoneInfo = &boneInfo[*boneRefs];
bonePtr = &bones[*boneRefs];
// add torso rotation
if (thisBoneInfo->torsoWeight > 0)
{
if (!newBones[*boneRefs])
{
// just copy it back from the previous calc
bones[*boneRefs] = oldBones[*boneRefs];
continue;
}
if (!(thisBoneInfo->flags & BONEFLAG_TAG))
{
// 1st multiply with the bone->matrix
// 2nd translation for rotation relative to bone around torso parent offset
VectorSubtract(bonePtr->translation, torsoParentOffset, t);
Matrix4FromAxisPlusTranslation(bonePtr->matrix, t, m1);
// 3rd scaled rotation
// 4th translate back to torso parent offset
// use previously created matrix if available for the same weight
if (torsoWeight != thisBoneInfo->torsoWeight)
{
Matrix4FromScaledAxisPlusTranslation(torsoAxis, thisBoneInfo->torsoWeight, torsoParentOffset, m2);
torsoWeight = thisBoneInfo->torsoWeight;
}
// multiply matrices to create one matrix to do all calculations
Matrix4MultiplyInto3x3AndTranslation(m2, m1, bonePtr->matrix, bonePtr->translation);
}
else // tag's require special handling
{ // rotate each of the axis by the torsoAngles
LocalScaledMatrixTransformVector(bonePtr->matrix[0], thisBoneInfo->torsoWeight, torsoAxis, tmpAxis[0]);
LocalScaledMatrixTransformVector(bonePtr->matrix[1], thisBoneInfo->torsoWeight, torsoAxis, tmpAxis[1]);
LocalScaledMatrixTransformVector(bonePtr->matrix[2], thisBoneInfo->torsoWeight, torsoAxis, tmpAxis[2]);
memcpy(bonePtr->matrix, tmpAxis, sizeof(tmpAxis));
// rotate the translation around the torsoParent
VectorSubtract(bonePtr->translation, torsoParentOffset, t);
LocalScaledMatrixTransformVector(t, thisBoneInfo->torsoWeight, torsoAxis, bonePtr->translation);
VectorAdd(bonePtr->translation, torsoParentOffset, bonePtr->translation);
}
}
}
// backup the final bones
memcpy(oldBones, bones, sizeof(bones[0]) * header->numBones);
}
#ifdef DBG_PROFILE_BONES
#define DBG_SHOWTIME Ren_Print("%i: %i, ", di++, (dt = ri.Milliseconds()) - ldt); ldt = dt;
#else
#define DBG_SHOWTIME ;
#endif
/*
==============
RB_SurfaceAnim
==============
*/
void RB_SurfaceAnim(mdsSurface_t *surface)
{
int j, k;
refEntity_t *refent;
int *boneList;
mdsHeader_t *header;
#ifdef DBG_PROFILE_BONES
int di = 0, dt, ldt;
dt = ri.Milliseconds();
ldt = dt;
#endif
refent = &backEnd.currentEntity->e;
boneList = ( int * )((byte *)surface + surface->ofsBoneReferences);
header = ( mdsHeader_t * )((byte *)surface + surface->ofsHeader);
R_CalcBones(header, (const refEntity_t *)refent, boneList, surface->numBoneReferences);
DBG_SHOWTIME
// calculate LOD
// TODO: lerp the radius and origin
VectorAdd(refent->origin, frame->localOrigin, vec);
lodRadius = frame->radius;
lodScale = RB_CalcMDSLod(refent, vec, lodRadius, header->lodBias, header->lodScale);
//DBG_SHOWTIME
// modification to allow dead skeletal bodies to go below minlod (experiment)
if (refent->reFlags & REFLAG_DEAD_LOD)
{
if (lodScale < 0.35) // allow dead to lod down to 35% (even if below surf->minLod) (%35 is arbitrary and probably not good generally. worked for the blackguard/infantry as a test though)
{
lodScale = 0.35;
}
render_count = ROUND_INT(surface->numVerts * lodScale);
}
else
{
render_count = ROUND_INT(surface->numVerts * lodScale);
if (render_count < surface->minLod)
{
if (!(refent->reFlags & REFLAG_DEAD_LOD))
{
render_count = surface->minLod;
}
}
}
if (render_count > surface->numVerts)
{
render_count = surface->numVerts;
}
RB_CheckOverflow(render_count, surface->numTriangles);
//DBG_SHOWTIME
// setup triangle list
RB_CheckOverflow(surface->numVerts, surface->numTriangles * 3);
//DBG_SHOWTIME
collapse_map = ( int * )(( byte * )surface + surface->ofsCollapseMap);
triangles = ( int * )((byte *)surface + surface->ofsTriangles);
indexes = surface->numTriangles * 3;
baseIndex = tess.numIndexes;
baseVertex = tess.numVertexes;
oldIndexes = baseIndex;
tess.numVertexes += render_count;
pIndexes = &tess.indexes[baseIndex];
//DBG_SHOWTIME
if (render_count == surface->numVerts)
{
memcpy(pIndexes, triangles, sizeof(triangles[0]) * indexes);
if (baseVertex)
{
glIndex_t *indexesEnd;
for (indexesEnd = pIndexes + indexes ; pIndexes < indexesEnd ; pIndexes++)
{
*pIndexes += baseVertex;
}
}
tess.numIndexes += indexes;
}
else
{
int *collapseEnd;
pCollapse = collapse;
for (j = 0; j < render_count; pCollapse++, j++)
{
*pCollapse = j;
}
pCollapseMap = &collapse_map[render_count];
for (collapseEnd = collapse + surface->numVerts ; pCollapse < collapseEnd; pCollapse++, pCollapseMap++)
{
*pCollapse = collapse[*pCollapseMap];
}
for (j = 0 ; j < indexes ; j += 3)
{
p0 = collapse[*(triangles++)];
p1 = collapse[*(triangles++)];
p2 = collapse[*(triangles++)];
// FIXME
// note: serious optimization opportunity here,
// by sorting the triangles the following "continue"
// could have been made into a "break" statement.
if (p0 == p1 || p1 == p2 || p2 == p0)
{
continue;
}
*(pIndexes++) = baseVertex + p0;
*(pIndexes++) = baseVertex + p1;
*(pIndexes++) = baseVertex + p2;
tess.numIndexes += 3;
}
baseIndex = tess.numIndexes;
}
//DBG_SHOWTIME
// deform the vertexes by the lerped bones
numVerts = surface->numVerts;
v = ( mdsVertex_t * )((byte *)surface + surface->ofsVerts);
tempVert = ( float * )(tess.xyz + baseVertex);
tempNormal = ( float * )(tess.normal + baseVertex);
for (j = 0; j < render_count; j++, tempVert += 4, tempNormal += 4)
{
mdsWeight_t *w;
VectorClear(tempVert);
w = v->weights;
for (k = 0 ; k < v->numWeights ; k++, w++)
{
bone = &bones[w->boneIndex];
LocalAddScaledMatrixTransformVectorTranslate(w->offset, w->boneWeight, bone->matrix, bone->translation, tempVert);
}
LocalMatrixTransformVector(v->normal, bones[v->weights[0].boneIndex].matrix, tempNormal);
tess.texCoords0[baseVertex + j].v[0] = v->texCoords[0];
tess.texCoords0[baseVertex + j].v[1] = v->texCoords[1];
v = (mdsVertex_t *)&v->weights[v->numWeights];
}
DBG_SHOWTIME
if (r_bonesDebug->integer)
{
if (r_bonesDebug->integer < 3)
{
int i;
// DEBUG: show the bones as a stick figure with axis at each bone
boneRefs = ( int * )((byte *)surface + surface->ofsBoneReferences);
for (i = 0; i < surface->numBoneReferences; i++, boneRefs++)
{
bonePtr = &bones[*boneRefs];
GL_Bind(tr.whiteImage);
qglLineWidth(1);
qglBegin(GL_LINES);
for (j = 0; j < 3; j++)
{
VectorClear(vec);
vec[j] = 1;
qglColor3fv(vec);
qglVertex3fv(bonePtr->translation);
VectorMA(bonePtr->translation, 5, bonePtr->matrix[j], vec);
qglVertex3fv(vec);
}
qglEnd();
// connect to our parent if it's valid
if (validBones[boneInfo[*boneRefs].parent])
{
qglLineWidth(2);
qglBegin(GL_LINES);
qglColor3f(.6, .6, .6);
qglVertex3fv(bonePtr->translation);
qglVertex3fv(bones[boneInfo[*boneRefs].parent].translation);
qglEnd();
}
qglLineWidth(1);
}
}
if (r_bonesDebug->integer == 3 || r_bonesDebug->integer == 4)
{
int render_indexes = (tess.numIndexes - oldIndexes);
// show mesh edges
tempVert = ( float * )(tess.xyz + baseVertex);
tempNormal = ( float * )(tess.normal + baseVertex);
GL_Bind(tr.whiteImage);
qglLineWidth(1);
qglBegin(GL_LINES);
qglColor3f(.0, .0, .8);
pIndexes = &tess.indexes[oldIndexes];
for (j = 0; j < render_indexes / 3; j++, pIndexes += 3)
{
qglVertex3fv(tempVert + 4 * pIndexes[0]);
qglVertex3fv(tempVert + 4 * pIndexes[1]);
qglVertex3fv(tempVert + 4 * pIndexes[1]);
qglVertex3fv(tempVert + 4 * pIndexes[2]);
qglVertex3fv(tempVert + 4 * pIndexes[2]);
qglVertex3fv(tempVert + 4 * pIndexes[0]);
}
qglEnd();
// track debug stats
if (r_bonesDebug->integer == 4)
{
totalrv += render_count;
totalrt += render_indexes / 3;
totalv += surface->numVerts;
totalt += surface->numTriangles;
}
if (r_bonesDebug->integer == 3)
{
Ren_Print("Lod %.2f verts %4d/%4d tris %4d/%4d (%.2f%%)\n", lodScale, render_count, surface->numVerts, render_indexes / 3, surface->numTriangles,
( float )(100.0 * render_indexes / 3) / (float) surface->numTriangles);
}
}
}
if (r_bonesDebug->integer > 1)
{
// dont draw the actual surface
tess.numIndexes = oldIndexes;
tess.numVertexes = baseVertex;
return;
}
#ifdef DBG_PROFILE_BONES
Ren_Print("\n");
#endif
}
/*
==============
RB_SurfaceAnim
==============
*/
void RB_SurfaceAnim( mdsSurface_t *surface ) {
int i, j, k;
int render_count;
int p0, p1, p2, indexes;
refEntity_t *refent;
int *boneList, *triangles;
glIndex_t *indexesEnd, *pIndexes;
mdsHeader_t *header;
mdsFrame_t *backframe;
mdsBoneFrame_t *bone;
mdsVertex_t *v;
float *tempVert, *tempNormal;
int baseIndex, baseVertex, oldIndexes, numVerts;
int frameSize;
refent = &backEnd.currentEntity->e;
boneList = ( int * )( (byte *)surface + surface->ofsBoneReferences );
header = ( mdsHeader_t * )( (byte *)surface + surface->ofsHeader );
frameSize = (int) ( sizeof( mdsFrame_t ) + ( header->numBones - 1 ) * sizeof( mdsBoneFrameCompressed_t ) );
backframe = ( mdsFrame_t * )( (byte *)header + header->ofsFrames + refent->frame * frameSize );
render_count = surface->numVerts;
RB_CheckOverflow( render_count, surface->numTriangles );
//
// setup triangle list
//
RB_CheckOverflow( surface->numVerts, surface->numTriangles * 3 );
triangles = ( int * )( (byte *)surface + surface->ofsTriangles );
indexes = surface->numTriangles * 3;
baseIndex = tess.numIndexes;
baseVertex = tess.numVertexes;
oldIndexes = baseIndex;
tess.numVertexes += render_count;
pIndexes = &tess.indexes[baseIndex];
//memcpy( pIndexes, triangles, sizeof( triangles[0] ) * indexes );
for ( i = 0 ; i < indexes ; i++ ) {
*pIndexes++ = baseVertex + *triangles++;
}
tess.numIndexes += indexes;
//
// deform the vertexes by the lerped bones
//
numVerts = surface->numVerts;
v = ( mdsVertex_t * )( (byte *)surface + surface->ofsVerts );
tempVert = ( float * )( tess.xyz + baseVertex );
tempNormal = ( float * )( tess.normal + baseVertex );
//LockBones
R_CalcBones( header, (const refEntity_t *)refent, boneList, surface->numBoneReferences, 1 );
for ( j = 0; j < render_count; j++, tempVert += 4, tempNormal += 4 ) {
mdsWeight_t *w;
VectorClear( tempVert );
w = v->weights;
for ( k = 0 ; k < v->numWeights ; k++, w++ ) {
bone = &smpbones[1][w->boneIndex];
LocalAddScaledMatrixTransformVectorTranslate( w->offset, w->boneWeight, bone->matrix, bone->translation, tempVert );
}
LocalMatrixTransformVector( v->normal, smpbones[1][v->weights[0].boneIndex].matrix, tempNormal );
tess.texCoords[baseVertex + j][0][0] = v->texCoords[0];
tess.texCoords[baseVertex + j][0][1] = v->texCoords[1];
v = (mdsVertex_t *)&v->weights[v->numWeights];
}
//UnlockBones
}
