teambeef/ioq3quest
0
0
Fork 0
mirror of https://github.com/DrBeef/ioq3quest.git synced 2024-11-30 07:41:16 +00:00
Code Issues Projects Releases Packages Wiki Activity
ioq3quest/code/renderergl2/tr_model_iqm.c
Zack Middleton c7ebe82131 Calculate bounds for unanimated IQM models 
Bounds are optional for animated IQM models but are not possible to
include with unanimated models (seems intended for use with separate
model containing animations and bounds). Calculating bounds for
unanimated IQM models fixes culling and head model on HUD which
calculates position from model bounds.
2018-08-02 18:20:18 -05:00

1696 lines
53 KiB
C
Raw Blame History

/*
===========================================================================
Copyright (C) 2011 Thilo Schulz <thilo@tjps.eu>
Copyright (C) 2011 Matthias Bentrup <matthias.bentrup@googlemail.com>
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include "tr_local.h"
#define LL(x) x=LittleLong(x)
// 3x4 identity matrix
static float identityMatrix[12] = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0
};
static qboolean IQM_CheckRange( iqmHeader_t *header, int offset,
int count, int size ) {
// return true if the range specified by offset, count and size
// doesn't fit into the file
return ( count <= 0 ||
offset <= 0 ||
offset > header->filesize ||
offset + count * size < 0 ||
offset + count * size > header->filesize );
}
// "multiply" 3x4 matrices, these are assumed to be the top 3 rows
// of a 4x4 matrix with the last row = (0 0 0 1)
static void Matrix34Multiply( float *a, float *b, float *out ) {
out[ 0] = a[0] * b[0] + a[1] * b[4] + a[ 2] * b[ 8];
out[ 1] = a[0] * b[1] + a[1] * b[5] + a[ 2] * b[ 9];
out[ 2] = a[0] * b[2] + a[1] * b[6] + a[ 2] * b[10];
out[ 3] = a[0] * b[3] + a[1] * b[7] + a[ 2] * b[11] + a[ 3];
out[ 4] = a[4] * b[0] + a[5] * b[4] + a[ 6] * b[ 8];
out[ 5] = a[4] * b[1] + a[5] * b[5] + a[ 6] * b[ 9];
out[ 6] = a[4] * b[2] + a[5] * b[6] + a[ 6] * b[10];
out[ 7] = a[4] * b[3] + a[5] * b[7] + a[ 6] * b[11] + a[ 7];
out[ 8] = a[8] * b[0] + a[9] * b[4] + a[10] * b[ 8];
out[ 9] = a[8] * b[1] + a[9] * b[5] + a[10] * b[ 9];
out[10] = a[8] * b[2] + a[9] * b[6] + a[10] * b[10];
out[11] = a[8] * b[3] + a[9] * b[7] + a[10] * b[11] + a[11];
}
static void InterpolateMatrix( float *a, float *b, float lerp, float *mat ) {
float unLerp = 1.0f - lerp;
mat[ 0] = a[ 0] * unLerp + b[ 0] * lerp;
mat[ 1] = a[ 1] * unLerp + b[ 1] * lerp;
mat[ 2] = a[ 2] * unLerp + b[ 2] * lerp;
mat[ 3] = a[ 3] * unLerp + b[ 3] * lerp;
mat[ 4] = a[ 4] * unLerp + b[ 4] * lerp;
mat[ 5] = a[ 5] * unLerp + b[ 5] * lerp;
mat[ 6] = a[ 6] * unLerp + b[ 6] * lerp;
mat[ 7] = a[ 7] * unLerp + b[ 7] * lerp;
mat[ 8] = a[ 8] * unLerp + b[ 8] * lerp;
mat[ 9] = a[ 9] * unLerp + b[ 9] * lerp;
mat[10] = a[10] * unLerp + b[10] * lerp;
mat[11] = a[11] * unLerp + b[11] * lerp;
}
static void JointToMatrix( vec4_t rot, vec3_t scale, vec3_t trans,
float *mat ) {
float xx = 2.0f * rot[0] * rot[0];
float yy = 2.0f * rot[1] * rot[1];
float zz = 2.0f * rot[2] * rot[2];
float xy = 2.0f * rot[0] * rot[1];
float xz = 2.0f * rot[0] * rot[2];
float yz = 2.0f * rot[1] * rot[2];
float wx = 2.0f * rot[3] * rot[0];
float wy = 2.0f * rot[3] * rot[1];
float wz = 2.0f * rot[3] * rot[2];
mat[ 0] = scale[0] * (1.0f - (yy + zz));
mat[ 1] = scale[0] * (xy - wz);
mat[ 2] = scale[0] * (xz + wy);
mat[ 3] = trans[0];
mat[ 4] = scale[1] * (xy + wz);
mat[ 5] = scale[1] * (1.0f - (xx + zz));
mat[ 6] = scale[1] * (yz - wx);
mat[ 7] = trans[1];
mat[ 8] = scale[2] * (xz - wy);
mat[ 9] = scale[2] * (yz + wx);
mat[10] = scale[2] * (1.0f - (xx + yy));
mat[11] = trans[2];
}
static void Matrix34Invert( float *inMat, float *outMat )
{
vec3_t trans;
float invSqrLen, *v;
outMat[ 0] = inMat[ 0]; outMat[ 1] = inMat[ 4]; outMat[ 2] = inMat[ 8];
outMat[ 4] = inMat[ 1]; outMat[ 5] = inMat[ 5]; outMat[ 6] = inMat[ 9];
outMat[ 8] = inMat[ 2]; outMat[ 9] = inMat[ 6]; outMat[10] = inMat[10];
v = outMat + 0; invSqrLen = 1.0f / DotProduct(v, v); VectorScale(v, invSqrLen, v);
v = outMat + 4; invSqrLen = 1.0f / DotProduct(v, v); VectorScale(v, invSqrLen, v);
v = outMat + 8; invSqrLen = 1.0f / DotProduct(v, v); VectorScale(v, invSqrLen, v);
trans[0] = inMat[ 3];
trans[1] = inMat[ 7];
trans[2] = inMat[11];
outMat[ 3] = -DotProduct(outMat + 0, trans);
outMat[ 7] = -DotProduct(outMat + 4, trans);
outMat[11] = -DotProduct(outMat + 8, trans);
}
/*
=================
R_LoadIQM
Load an IQM model and compute the joint matrices for every frame.
=================
*/
qboolean R_LoadIQM( model_t *mod, void *buffer, int filesize, const char *mod_name ) {
iqmHeader_t *header;
iqmVertexArray_t *vertexarray;
iqmTriangle_t *triangle;
iqmMesh_t *mesh;
iqmJoint_t *joint;
iqmPose_t *pose;
iqmBounds_t *bounds;
unsigned short *framedata;
char *str;
int i, j, k;
float jointInvMats[IQM_MAX_JOINTS * 12] = {0.0f};
float *mat, *matInv;
size_t size, joint_names;
byte *dataPtr;
iqmData_t *iqmData;
srfIQModel_t *surface;
char meshName[MAX_QPATH];
int vertexArrayFormat[IQM_COLOR+1];
int allocateInfluences;
byte *blendIndexes;
union {
byte *b;
float *f;
} blendWeights;
if( filesize < sizeof(iqmHeader_t) ) {
return qfalse;
}
header = (iqmHeader_t *)buffer;
if( Q_strncmp( header->magic, IQM_MAGIC, sizeof(header->magic) ) ) {
return qfalse;
}
LL( header->version );
if( header->version != IQM_VERSION ) {
ri.Printf(PRINT_WARNING, "R_LoadIQM: %s is a unsupported IQM version (%d), only version %d is supported.\n",
mod_name, header->version, IQM_VERSION);
return qfalse;
}
LL( header->filesize );
if( header->filesize > filesize || header->filesize > 16<<20 ) {
return qfalse;
}
LL( header->flags );
LL( header->num_text );
LL( header->ofs_text );
LL( header->num_meshes );
LL( header->ofs_meshes );
LL( header->num_vertexarrays );
LL( header->num_vertexes );
LL( header->ofs_vertexarrays );
LL( header->num_triangles );
LL( header->ofs_triangles );
LL( header->ofs_adjacency );
LL( header->num_joints );
LL( header->ofs_joints );
LL( header->num_poses );
LL( header->ofs_poses );
LL( header->num_anims );
LL( header->ofs_anims );
LL( header->num_frames );
LL( header->num_framechannels );
LL( header->ofs_frames );
LL( header->ofs_bounds );
LL( header->num_comment );
LL( header->ofs_comment );
LL( header->num_extensions );
LL( header->ofs_extensions );
// check ioq3 joint limit
if ( header->num_joints > IQM_MAX_JOINTS ) {
ri.Printf(PRINT_WARNING, "R_LoadIQM: %s has more than %d joints (%d).\n",
mod_name, IQM_MAX_JOINTS, header->num_joints);
return qfalse;
}
for ( i = 0; i < ARRAY_LEN( vertexArrayFormat ); i++ ) {
vertexArrayFormat[i] = -1;
}
blendIndexes = NULL;
blendWeights.b = NULL;
allocateInfluences = 0;
if ( header->num_meshes )
{
// check and swap vertex arrays
if( IQM_CheckRange( header, header->ofs_vertexarrays,
header->num_vertexarrays,
sizeof(iqmVertexArray_t) ) ) {
return qfalse;
}
vertexarray = (iqmVertexArray_t *)((byte *)header + header->ofs_vertexarrays);
for( i = 0; i < header->num_vertexarrays; i++, vertexarray++ ) {
int n, *intPtr;
if( vertexarray->size <= 0 || vertexarray->size > 4 ) {
return qfalse;
}
// total number of values
n = header->num_vertexes * vertexarray->size;
switch( vertexarray->format ) {
case IQM_BYTE:
case IQM_UBYTE:
// 1 byte, no swapping necessary
if( IQM_CheckRange( header, vertexarray->offset,
n, sizeof(byte) ) ) {
return qfalse;
}
break;
case IQM_INT:
case IQM_UINT:
case IQM_FLOAT:
// 4-byte swap
if( IQM_CheckRange( header, vertexarray->offset,
n, sizeof(float) ) ) {
return qfalse;
}
intPtr = (int *)((byte *)header + vertexarray->offset);
for( j = 0; j < n; j++, intPtr++ ) {
LL( *intPtr );
}
break;
default:
// not supported
return qfalse;
break;
}
if( vertexarray->type < ARRAY_LEN( vertexArrayFormat ) ) {
vertexArrayFormat[vertexarray->type] = vertexarray->format;
}
switch( vertexarray->type ) {
case IQM_POSITION:
case IQM_NORMAL:
if( vertexarray->format != IQM_FLOAT ||
vertexarray->size != 3 ) {
return qfalse;
}
break;
case IQM_TANGENT:
if( vertexarray->format != IQM_FLOAT ||
vertexarray->size != 4 ) {
return qfalse;
}
break;
case IQM_TEXCOORD:
if( vertexarray->format != IQM_FLOAT ||
vertexarray->size != 2 ) {
return qfalse;
}
break;
case IQM_BLENDINDEXES:
if( (vertexarray->format != IQM_INT &&
vertexarray->format != IQM_UBYTE) ||
vertexarray->size != 4 ) {
return qfalse;
}
blendIndexes = (byte*)header + vertexarray->offset;
break;
case IQM_BLENDWEIGHTS:
if( (vertexarray->format != IQM_FLOAT &&
vertexarray->format != IQM_UBYTE) ||
vertexarray->size != 4 ) {
return qfalse;
}
if( vertexarray->format == IQM_FLOAT ) {
blendWeights.f = (float*)( (byte*)header + vertexarray->offset );
} else {
blendWeights.b = (byte*)header + vertexarray->offset;
}
break;
case IQM_COLOR:
if( vertexarray->format != IQM_UBYTE ||
vertexarray->size != 4 ) {
return qfalse;
}
break;
}
}
// check for required vertex arrays
if( vertexArrayFormat[IQM_POSITION] == -1 || vertexArrayFormat[IQM_NORMAL] == -1 || vertexArrayFormat[IQM_TEXCOORD] == -1 ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s is missing IQM_POSITION, IQM_NORMAL, and/or IQM_TEXCOORD array.\n", mod_name );
return qfalse;
}
if( header->num_joints ) {
if( vertexArrayFormat[IQM_BLENDINDEXES] == -1 || vertexArrayFormat[IQM_BLENDWEIGHTS] == -1 ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s is missing IQM_BLENDINDEXES and/or IQM_BLENDWEIGHTS array.\n", mod_name );
return qfalse;
}
} else {
// ignore blend arrays if present
vertexArrayFormat[IQM_BLENDINDEXES] = -1;
vertexArrayFormat[IQM_BLENDWEIGHTS] = -1;
}
// opengl2 renderer requires tangents
if( vertexArrayFormat[IQM_TANGENT] == -1 ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s is missing IQM_TANGENT array.\n", mod_name );
return qfalse;
}
// check and swap triangles
if( IQM_CheckRange( header, header->ofs_triangles,
header->num_triangles, sizeof(iqmTriangle_t) ) ) {
return qfalse;
}
triangle = (iqmTriangle_t *)((byte *)header + header->ofs_triangles);
for( i = 0; i < header->num_triangles; i++, triangle++ ) {
LL( triangle->vertex[0] );
LL( triangle->vertex[1] );
LL( triangle->vertex[2] );
if( triangle->vertex[0] > header->num_vertexes ||
triangle->vertex[1] > header->num_vertexes ||
triangle->vertex[2] > header->num_vertexes ) {
return qfalse;
}
}
// check and swap meshes
if( IQM_CheckRange( header, header->ofs_meshes,
header->num_meshes, sizeof(iqmMesh_t) ) ) {
return qfalse;
}
mesh = (iqmMesh_t *)((byte *)header + header->ofs_meshes);
for( i = 0; i < header->num_meshes; i++, mesh++) {
LL( mesh->name );
LL( mesh->material );
LL( mesh->first_vertex );
LL( mesh->num_vertexes );
LL( mesh->first_triangle );
LL( mesh->num_triangles );
if ( mesh->name < header->num_text ) {
Q_strncpyz( meshName, (char*)header + header->ofs_text + mesh->name, sizeof (meshName) );
} else {
meshName[0] = '\0';
}
// check ioq3 limits
if ( mesh->num_vertexes >= SHADER_MAX_VERTEXES ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s has more than %i verts on %s (%i).\n",
mod_name, SHADER_MAX_VERTEXES - 1, meshName[0] ? meshName : "a surface",
mesh->num_vertexes );
return qfalse;
}
if ( mesh->num_triangles*3 >= SHADER_MAX_INDEXES ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s has more than %i triangles on %s (%i).\n",
mod_name, ( SHADER_MAX_INDEXES / 3 ) - 1, meshName[0] ? meshName : "a surface",
mesh->num_triangles );
return qfalse;
}
if( mesh->first_vertex >= header->num_vertexes ||
mesh->first_vertex + mesh->num_vertexes > header->num_vertexes ||
mesh->first_triangle >= header->num_triangles ||
mesh->first_triangle + mesh->num_triangles > header->num_triangles ||
mesh->name >= header->num_text ||
mesh->material >= header->num_text ) {
return qfalse;
}
// find number of unique blend influences per mesh
if( header->num_joints ) {
for( j = 0; j < mesh->num_vertexes; j++ ) {
int vtx = mesh->first_vertex + j;
for( k = 0; k < j; k++ ) {
int influence = mesh->first_vertex + k;
if( *(int*)&blendIndexes[4*influence] != *(int*)&blendIndexes[4*vtx] ) {
continue;
}
if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
if ( blendWeights.f[4*influence+0] == blendWeights.f[4*vtx+0] &&
blendWeights.f[4*influence+1] == blendWeights.f[4*vtx+1] &&
blendWeights.f[4*influence+2] == blendWeights.f[4*vtx+2] &&
blendWeights.f[4*influence+3] == blendWeights.f[4*vtx+3] ) {
break;
}
} else {
if ( *(int*)&blendWeights.b[4*influence] == *(int*)&blendWeights.b[4*vtx] ) {
break;
}
}
}
if ( k == j ) {
allocateInfluences++;
}
}
}
}
}
if( header->num_poses != header->num_joints && header->num_poses != 0 ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s has %d poses and %d joints, must have the same number or 0 poses\n",
mod_name, header->num_poses, header->num_joints );
return qfalse;
}
joint_names = 0;
if ( header->num_joints )
{
// check and swap joints
if( IQM_CheckRange( header, header->ofs_joints,
header->num_joints, sizeof(iqmJoint_t) ) ) {
return qfalse;
}
joint = (iqmJoint_t *)((byte *)header + header->ofs_joints);
for( i = 0; i < header->num_joints; i++, joint++ ) {
LL( joint->name );
LL( joint->parent );
LL( joint->translate[0] );
LL( joint->translate[1] );
LL( joint->translate[2] );
LL( joint->rotate[0] );
LL( joint->rotate[1] );
LL( joint->rotate[2] );
LL( joint->rotate[3] );
LL( joint->scale[0] );
LL( joint->scale[1] );
LL( joint->scale[2] );
if( joint->parent < -1 ||
joint->parent >= (int)header->num_joints ||
joint->name >= (int)header->num_text ) {
return qfalse;
}
joint_names += strlen( (char *)header + header->ofs_text +
joint->name ) + 1;
}
}
if ( header->num_poses )
{
// check and swap poses
if( IQM_CheckRange( header, header->ofs_poses,
header->num_poses, sizeof(iqmPose_t) ) ) {
return qfalse;
}
pose = (iqmPose_t *)((byte *)header + header->ofs_poses);
for( i = 0; i < header->num_poses; i++, pose++ ) {
LL( pose->parent );
LL( pose->mask );
LL( pose->channeloffset[0] );
LL( pose->channeloffset[1] );
LL( pose->channeloffset[2] );
LL( pose->channeloffset[3] );
LL( pose->channeloffset[4] );
LL( pose->channeloffset[5] );
LL( pose->channeloffset[6] );
LL( pose->channeloffset[7] );
LL( pose->channeloffset[8] );
LL( pose->channeloffset[9] );
LL( pose->channelscale[0] );
LL( pose->channelscale[1] );
LL( pose->channelscale[2] );
LL( pose->channelscale[3] );
LL( pose->channelscale[4] );
LL( pose->channelscale[5] );
LL( pose->channelscale[6] );
LL( pose->channelscale[7] );
LL( pose->channelscale[8] );
LL( pose->channelscale[9] );
}
}
if (header->ofs_bounds)
{
// check and swap model bounds
if(IQM_CheckRange(header, header->ofs_bounds,
header->num_frames, sizeof(*bounds)))
{
return qfalse;
}
bounds = (iqmBounds_t *) ((byte *) header + header->ofs_bounds);
for(i = 0; i < header->num_frames; i++)
{
LL(bounds->bbmin[0]);
LL(bounds->bbmin[1]);
LL(bounds->bbmin[2]);
LL(bounds->bbmax[0]);
LL(bounds->bbmax[1]);
LL(bounds->bbmax[2]);
bounds++;
}
}
// allocate the model and copy the data
size = sizeof(iqmData_t);
if( header->num_meshes ) {
size += header->num_meshes * sizeof( srfIQModel_t ); // surfaces
size += header->num_triangles * 3 * sizeof(int); // triangles
size += header->num_vertexes * 3 * sizeof(float); // positions
size += header->num_vertexes * 2 * sizeof(float); // texcoords
size += header->num_vertexes * 3 * sizeof(float); // normals
if ( vertexArrayFormat[IQM_TANGENT] != -1 ) {
size += header->num_vertexes * 4 * sizeof(float); // tangents
}
if ( vertexArrayFormat[IQM_COLOR] != -1 ) {
size += header->num_vertexes * 4 * sizeof(byte); // colors
}
if ( allocateInfluences ) {
size += header->num_vertexes * sizeof(int); // influences
size += allocateInfluences * 4 * sizeof(byte); // influenceBlendIndexes
if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_UBYTE ) {
size += allocateInfluences * 4 * sizeof(byte); // influenceBlendWeights
} else if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
size += allocateInfluences * 4 * sizeof(float); // influenceBlendWeights
}
}
}
if( header->num_joints ) {
size += joint_names; // joint names
size += header->num_joints * sizeof(int); // joint parents
size += header->num_joints * 12 * sizeof( float ); // joint mats
}
if( header->num_poses ) {
size += header->num_poses * header->num_frames * 12 * sizeof( float ); // pose mats
}
if( header->ofs_bounds ) {
size += header->num_frames * 6 * sizeof(float); // model bounds
} else if( header->num_meshes && header->num_frames == 0 ) {
size += 6 * sizeof(float); // model bounds
}
mod->type = MOD_IQM;
iqmData = (iqmData_t *)ri.Hunk_Alloc( size, h_low );
mod->modelData = iqmData;
// fill header
iqmData->num_vertexes = ( header->num_meshes > 0 ) ? header->num_vertexes : 0;
iqmData->num_triangles = ( header->num_meshes > 0 ) ? header->num_triangles : 0;
iqmData->num_frames = header->num_frames;
iqmData->num_surfaces = header->num_meshes;
iqmData->num_joints = header->num_joints;
iqmData->num_poses = header->num_poses;
iqmData->blendWeightsType = vertexArrayFormat[IQM_BLENDWEIGHTS];
dataPtr = (byte*)iqmData + sizeof(iqmData_t);
if( header->num_meshes ) {
iqmData->surfaces = (struct srfIQModel_s*)dataPtr;
dataPtr += header->num_meshes * sizeof( srfIQModel_t );
iqmData->triangles = (int*)dataPtr;
dataPtr += header->num_triangles * 3 * sizeof(int); // triangles
iqmData->positions = (float*)dataPtr;
dataPtr += header->num_vertexes * 3 * sizeof(float); // positions
iqmData->texcoords = (float*)dataPtr;
dataPtr += header->num_vertexes * 2 * sizeof(float); // texcoords
iqmData->normals = (float*)dataPtr;
dataPtr += header->num_vertexes * 3 * sizeof(float); // normals
if ( vertexArrayFormat[IQM_TANGENT] != -1 ) {
iqmData->tangents = (float*)dataPtr;
dataPtr += header->num_vertexes * 4 * sizeof(float); // tangents
}
if ( vertexArrayFormat[IQM_COLOR] != -1 ) {
iqmData->colors = (byte*)dataPtr;
dataPtr += header->num_vertexes * 4 * sizeof(byte); // colors
}
if ( allocateInfluences ) {
iqmData->influences = (int*)dataPtr;
dataPtr += header->num_vertexes * sizeof(int); // influences
iqmData->influenceBlendIndexes = (byte*)dataPtr;
dataPtr += allocateInfluences * 4 * sizeof(byte); // influenceBlendIndexes
if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_UBYTE ) {
iqmData->influenceBlendWeights.b = (byte*)dataPtr;
dataPtr += allocateInfluences * 4 * sizeof(byte); // influenceBlendWeights
} else if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
iqmData->influenceBlendWeights.f = (float*)dataPtr;
dataPtr += allocateInfluences * 4 * sizeof(float); // influenceBlendWeights
}
}
}
if( header->num_joints ) {
iqmData->jointNames = (char*)dataPtr;
dataPtr += joint_names; // joint names
iqmData->jointParents = (int*)dataPtr;
dataPtr += header->num_joints * sizeof(int); // joint parents
iqmData->jointMats = (float*)dataPtr;
dataPtr += header->num_joints * 12 * sizeof( float ); // joint mats
}
if( header->num_poses ) {
iqmData->poseMats = (float*)dataPtr;
dataPtr += header->num_poses * header->num_frames * 12 * sizeof( float ); // pose mats
}
if( header->ofs_bounds ) {
iqmData->bounds = (float*)dataPtr;
dataPtr += header->num_frames * 6 * sizeof(float); // model bounds
} else if( header->num_meshes && header->num_frames == 0 ) {
iqmData->bounds = (float*)dataPtr;
dataPtr += 6 * sizeof(float); // model bounds
}
if( header->num_meshes )
{
// register shaders
// overwrite the material offset with the shader index
mesh = (iqmMesh_t *)((byte *)header + header->ofs_meshes);
surface = iqmData->surfaces;
str = (char *)header + header->ofs_text;
for( i = 0; i < header->num_meshes; i++, mesh++, surface++ ) {
surface->surfaceType = SF_IQM;
Q_strncpyz(surface->name, str + mesh->name, sizeof (surface->name));
Q_strlwr(surface->name); // lowercase the surface name so skin compares are faster
surface->shader = R_FindShader( str + mesh->material, LIGHTMAP_NONE, qtrue );
if( surface->shader->defaultShader )
surface->shader = tr.defaultShader;
surface->data = iqmData;
surface->first_vertex = mesh->first_vertex;
surface->num_vertexes = mesh->num_vertexes;
surface->first_triangle = mesh->first_triangle;
surface->num_triangles = mesh->num_triangles;
}
// copy triangles
triangle = (iqmTriangle_t *)((byte *)header + header->ofs_triangles);
for( i = 0; i < header->num_triangles; i++, triangle++ ) {
iqmData->triangles[3*i+0] = triangle->vertex[0];
iqmData->triangles[3*i+1] = triangle->vertex[1];
iqmData->triangles[3*i+2] = triangle->vertex[2];
}
// copy vertexarrays and indexes
vertexarray = (iqmVertexArray_t *)((byte *)header + header->ofs_vertexarrays);
for( i = 0; i < header->num_vertexarrays; i++, vertexarray++ ) {
int n;
// skip disabled arrays
if( vertexarray->type < ARRAY_LEN( vertexArrayFormat )
&& vertexArrayFormat[vertexarray->type] == -1 )
continue;
// total number of values
n = header->num_vertexes * vertexarray->size;
switch( vertexarray->type ) {
case IQM_POSITION:
Com_Memcpy( iqmData->positions,
(byte *)header + vertexarray->offset,
n * sizeof(float) );
break;
case IQM_NORMAL:
Com_Memcpy( iqmData->normals,
(byte *)header + vertexarray->offset,
n * sizeof(float) );
break;
case IQM_TANGENT:
Com_Memcpy( iqmData->tangents,
(byte *)header + vertexarray->offset,
n * sizeof(float) );
break;
case IQM_TEXCOORD:
Com_Memcpy( iqmData->texcoords,
(byte *)header + vertexarray->offset,
n * sizeof(float) );
break;
case IQM_BLENDINDEXES:
case IQM_BLENDWEIGHTS:
break;
case IQM_COLOR:
Com_Memcpy( iqmData->colors,
(byte *)header + vertexarray->offset,
n * sizeof(byte) );
break;
}
}
// find unique blend influences per mesh
if( allocateInfluences ) {
int vtx, influence, totalInfluences = 0;
surface = iqmData->surfaces;
for( i = 0; i < header->num_meshes; i++, surface++ ) {
surface->first_influence = totalInfluences;
surface->num_influences = 0;
for( j = 0; j < surface->num_vertexes; j++ ) {
vtx = surface->first_vertex + j;
for( k = 0; k < surface->num_influences; k++ ) {
influence = surface->first_influence + k;
if( *(int*)&iqmData->influenceBlendIndexes[4*influence] != *(int*)&blendIndexes[4*vtx] ) {
continue;
}
if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
if ( iqmData->influenceBlendWeights.f[4*influence+0] == blendWeights.f[4*vtx+0] &&
iqmData->influenceBlendWeights.f[4*influence+1] == blendWeights.f[4*vtx+1] &&
iqmData->influenceBlendWeights.f[4*influence+2] == blendWeights.f[4*vtx+2] &&
iqmData->influenceBlendWeights.f[4*influence+3] == blendWeights.f[4*vtx+3] ) {
break;
}
} else {
if ( *(int*)&iqmData->influenceBlendWeights.b[4*influence] == *(int*)&blendWeights.b[4*vtx] ) {
break;
}
}
}
iqmData->influences[vtx] = surface->first_influence + k;
if( k == surface->num_influences ) {
influence = surface->first_influence + k;
iqmData->influenceBlendIndexes[4*influence+0] = blendIndexes[4*vtx+0];
iqmData->influenceBlendIndexes[4*influence+1] = blendIndexes[4*vtx+1];
iqmData->influenceBlendIndexes[4*influence+2] = blendIndexes[4*vtx+2];
iqmData->influenceBlendIndexes[4*influence+3] = blendIndexes[4*vtx+3];
if( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
iqmData->influenceBlendWeights.f[4*influence+0] = blendWeights.f[4*vtx+0];
iqmData->influenceBlendWeights.f[4*influence+1] = blendWeights.f[4*vtx+1];
iqmData->influenceBlendWeights.f[4*influence+2] = blendWeights.f[4*vtx+2];
iqmData->influenceBlendWeights.f[4*influence+3] = blendWeights.f[4*vtx+3];
} else {
iqmData->influenceBlendWeights.b[4*influence+0] = blendWeights.b[4*vtx+0];
iqmData->influenceBlendWeights.b[4*influence+1] = blendWeights.b[4*vtx+1];
iqmData->influenceBlendWeights.b[4*influence+2] = blendWeights.b[4*vtx+2];
iqmData->influenceBlendWeights.b[4*influence+3] = blendWeights.b[4*vtx+3];
}
totalInfluences++;
surface->num_influences++;
}
}
}
}
}
if( header->num_joints )
{
// copy joint names
str = iqmData->jointNames;
joint = (iqmJoint_t *)((byte *)header + header->ofs_joints);
for( i = 0; i < header->num_joints; i++, joint++ ) {
char *name = (char *)header + header->ofs_text +
joint->name;
int len = strlen( name ) + 1;
Com_Memcpy( str, name, len );
str += len;
}
// copy joint parents
joint = (iqmJoint_t *)((byte *)header + header->ofs_joints);
for( i = 0; i < header->num_joints; i++, joint++ ) {
iqmData->jointParents[i] = joint->parent;
}
// calculate joint matrices and their inverses
// joint inverses are needed only until the pose matrices are calculated
mat = iqmData->jointMats;
matInv = jointInvMats;
joint = (iqmJoint_t *)((byte *)header + header->ofs_joints);
for( i = 0; i < header->num_joints; i++, joint++ ) {
float baseFrame[12], invBaseFrame[12];
JointToMatrix( joint->rotate, joint->scale, joint->translate, baseFrame );
Matrix34Invert( baseFrame, invBaseFrame );
if ( joint->parent >= 0 )
{
Matrix34Multiply( iqmData->jointMats + 12 * joint->parent, baseFrame, mat );
mat += 12;
Matrix34Multiply( invBaseFrame, jointInvMats + 12 * joint->parent, matInv );
matInv += 12;
}
else
{
Com_Memcpy( mat, baseFrame, sizeof(baseFrame) );
mat += 12;
Com_Memcpy( matInv, invBaseFrame, sizeof(invBaseFrame) );
matInv += 12;
}
}
}
if( header->num_poses )
{
// calculate pose matrices
framedata = (unsigned short *)((byte *)header + header->ofs_frames);
mat = iqmData->poseMats;
for( i = 0; i < header->num_frames; i++ ) {
pose = (iqmPose_t *)((byte *)header + header->ofs_poses);
for( j = 0; j < header->num_poses; j++, pose++ ) {
vec3_t translate;
vec4_t rotate;
vec3_t scale;
float mat1[12], mat2[12];
translate[0] = pose->channeloffset[0];
if( pose->mask & 0x001)
translate[0] += *framedata++ * pose->channelscale[0];
translate[1] = pose->channeloffset[1];
if( pose->mask & 0x002)
translate[1] += *framedata++ * pose->channelscale[1];
translate[2] = pose->channeloffset[2];
if( pose->mask & 0x004)
translate[2] += *framedata++ * pose->channelscale[2];
rotate[0] = pose->channeloffset[3];
if( pose->mask & 0x008)
rotate[0] += *framedata++ * pose->channelscale[3];
rotate[1] = pose->channeloffset[4];
if( pose->mask & 0x010)
rotate[1] += *framedata++ * pose->channelscale[4];
rotate[2] = pose->channeloffset[5];
if( pose->mask & 0x020)
rotate[2] += *framedata++ * pose->channelscale[5];
rotate[3] = pose->channeloffset[6];
if( pose->mask & 0x040)
rotate[3] += *framedata++ * pose->channelscale[6];
scale[0] = pose->channeloffset[7];
if( pose->mask & 0x080)
scale[0] += *framedata++ * pose->channelscale[7];
scale[1] = pose->channeloffset[8];
if( pose->mask & 0x100)
scale[1] += *framedata++ * pose->channelscale[8];
scale[2] = pose->channeloffset[9];
if( pose->mask & 0x200)
scale[2] += *framedata++ * pose->channelscale[9];
// construct transformation matrix
JointToMatrix( rotate, scale, translate, mat1 );
if( pose->parent >= 0 ) {
Matrix34Multiply( iqmData->jointMats + 12 * pose->parent,
mat1, mat2 );
} else {
Com_Memcpy( mat2, mat1, sizeof(mat1) );
}
Matrix34Multiply( mat2, jointInvMats + 12 * j, mat );
mat += 12;
}
}
}
// copy model bounds
if(header->ofs_bounds)
{
mat = iqmData->bounds;
bounds = (iqmBounds_t *) ((byte *) header + header->ofs_bounds);
for(i = 0; i < header->num_frames; i++)
{
mat[0] = bounds->bbmin[0];
mat[1] = bounds->bbmin[1];
mat[2] = bounds->bbmin[2];
mat[3] = bounds->bbmax[0];
mat[4] = bounds->bbmax[1];
mat[5] = bounds->bbmax[2];
mat += 6;
bounds++;
}
}
else if( header->num_meshes && header->num_frames == 0 )
{
mat = iqmData->bounds;
ClearBounds( &iqmData->bounds[0], &iqmData->bounds[3] );
for ( i = 0 ; i < header->num_vertexes ; i++ ) {
AddPointToBounds( &iqmData->positions[i*3], &iqmData->bounds[0], &iqmData->bounds[3] );
}
}
// Create VAO surfaces
if ( iqmData->num_surfaces && iqmData->num_joints <= glRefConfig.glslMaxAnimatedBones )
{
srfVaoIQModel_t *vaoSurf;
srfIQModel_t *surf;
iqmData->numVaoSurfaces = iqmData->num_surfaces;
iqmData->vaoSurfaces = ri.Hunk_Alloc(sizeof(*iqmData->vaoSurfaces) * iqmData->numVaoSurfaces, h_low);
vaoSurf = iqmData->vaoSurfaces;
surf = iqmData->surfaces;
for (i = 0; i < iqmData->num_surfaces; i++, vaoSurf++, surf++)
{
uint32_t offset_xyz, offset_st, offset_normal, offset_tangent;
uint32_t offset_blendindexes, offset_blendweights, stride;
uint32_t dataSize, dataOfs;
uint8_t *data;
glIndex_t indexes[SHADER_MAX_INDEXES];
glIndex_t *ptr;
int *tri;
offset_xyz = 0;
offset_st = offset_xyz + sizeof(float) * 3;
offset_normal = offset_st + sizeof(float) * 2;
offset_tangent = offset_normal + sizeof(int16_t) * 4;
if ( iqmData->num_joints )
{
offset_blendindexes = offset_tangent + sizeof(int16_t) * 4;
offset_blendweights = offset_blendindexes + sizeof(byte) * 4;
if ( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
stride = offset_blendweights + sizeof(float) * 4;
} else {
stride = offset_blendweights + sizeof(byte) * 4;
}
}
else
{
stride = offset_tangent + sizeof(int16_t) * 4;
}
dataSize = surf->num_vertexes * stride;
data = ri.Malloc(dataSize);
dataOfs = 0;
for ( j = 0; j < surf->num_vertexes; j++ )
{
int vtx = surf->first_vertex + j;
// xyz
memcpy(data + dataOfs, &iqmData->positions[vtx*3], sizeof(float) * 3);
dataOfs += sizeof(float) * 3;
// st
memcpy(data + dataOfs, &iqmData->texcoords[vtx*2], sizeof(float) * 2);
dataOfs += sizeof(float) * 2;
// normal
R_VaoPackNormal((int16_t*)(data + dataOfs), &iqmData->normals[vtx*3]);
dataOfs += sizeof(int16_t) * 4;
// tangent
R_VaoPackTangent((int16_t*)(data + dataOfs), &iqmData->tangents[vtx*4]);
dataOfs += sizeof(int16_t) * 4;
if ( iqmData->num_joints )
{
// blendindexes
memcpy(data + dataOfs, &blendIndexes[vtx*4], sizeof(byte) * 4);
dataOfs += sizeof(byte) * 4;
// blendweights
if ( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
memcpy(data + dataOfs, &blendWeights.f[vtx*4], sizeof(float) * 4);
dataOfs += sizeof(float) * 4;
} else {
memcpy(data + dataOfs, &blendWeights.b[vtx*4], sizeof(byte) * 4);
dataOfs += sizeof(byte) * 4;
}
}
}
tri = iqmData->triangles + 3 * surf->first_triangle;
ptr = indexes;
for( j = 0; j < surf->num_triangles; j++ ) {
*ptr++ = (*tri++ - surf->first_vertex);
*ptr++ = (*tri++ - surf->first_vertex);
*ptr++ = (*tri++ - surf->first_vertex);
}
vaoSurf->surfaceType = SF_VAO_IQM;
vaoSurf->iqmData = iqmData;
vaoSurf->iqmSurface = surf;
vaoSurf->numIndexes = surf->num_triangles * 3;
vaoSurf->numVerts = surf->num_vertexes;
vaoSurf->vao = R_CreateVao(va("staticIQMMesh_VAO '%s'", surf->name), data, dataSize, (byte *)indexes, surf->num_triangles * 3 * sizeof(indexes[0]), VAO_USAGE_STATIC);
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].count = 3;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].count = 2;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].count = 4;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].count = 4;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].type = GL_FLOAT;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].type = GL_FLOAT;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].type = GL_SHORT;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].type = GL_SHORT;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].normalized = GL_FALSE;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].normalized = GL_FALSE;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].normalized = GL_TRUE;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].normalized = GL_TRUE;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].offset = offset_xyz;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].offset = offset_st;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].offset = offset_normal;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].offset = offset_tangent;
vaoSurf->vao->attribs[ATTR_INDEX_POSITION].stride = stride;
vaoSurf->vao->attribs[ATTR_INDEX_TEXCOORD].stride = stride;
vaoSurf->vao->attribs[ATTR_INDEX_NORMAL ].stride = stride;
vaoSurf->vao->attribs[ATTR_INDEX_TANGENT ].stride = stride;
if ( iqmData->num_joints )
{
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].enabled = 1;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].count = 4;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].count = 4;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].type = GL_UNSIGNED_BYTE;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].normalized = GL_FALSE;
if ( vertexArrayFormat[IQM_BLENDWEIGHTS] == IQM_FLOAT ) {
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].type = GL_FLOAT;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].normalized = GL_FALSE;
} else {
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].type = GL_UNSIGNED_BYTE;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].normalized = GL_TRUE;
}
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].offset = offset_blendindexes;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].offset = offset_blendweights;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_INDEXES].stride = stride;
vaoSurf->vao->attribs[ATTR_INDEX_BONE_WEIGHTS].stride = stride;
}
Vao_SetVertexPointers(vaoSurf->vao);
ri.Free(data);
}
}
return qtrue;
}
/*
=============
R_CullIQM
=============
*/
static int R_CullIQM( iqmData_t *data, trRefEntity_t *ent ) {
vec3_t bounds[2];
vec_t *oldBounds, *newBounds;
int i;
if (!data->bounds) {
tr.pc.c_box_cull_md3_clip++;
return CULL_CLIP;
}
// compute bounds pointers
oldBounds = data->bounds + 6*ent->e.oldframe;
newBounds = data->bounds + 6*ent->e.frame;
// calculate a bounding box in the current coordinate system
for (i = 0 ; i < 3 ; i++) {
bounds[0][i] = oldBounds[i] < newBounds[i] ? oldBounds[i] : newBounds[i];
bounds[1][i] = oldBounds[i+3] > newBounds[i+3] ? oldBounds[i+3] : newBounds[i+3];
}
switch ( R_CullLocalBox( bounds ) )
{
case CULL_IN:
tr.pc.c_box_cull_md3_in++;
return CULL_IN;
case CULL_CLIP:
tr.pc.c_box_cull_md3_clip++;
return CULL_CLIP;
case CULL_OUT:
default:
tr.pc.c_box_cull_md3_out++;
return CULL_OUT;
}
}
/*
=================
R_ComputeIQMFogNum
=================
*/
int R_ComputeIQMFogNum( iqmData_t *data, trRefEntity_t *ent ) {
int i, j;
fog_t *fog;
const vec_t *bounds;
const vec_t defaultBounds[6] = { -8, -8, -8, 8, 8, 8 };
vec3_t diag, center;
vec3_t localOrigin;
vec_t radius;
if ( tr.refdef.rdflags & RDF_NOWORLDMODEL ) {
return 0;
}
// FIXME: non-normalized axis issues
if (data->bounds) {
bounds = data->bounds + 6*ent->e.frame;
} else {
bounds = defaultBounds;
}
VectorSubtract( bounds+3, bounds, diag );
VectorMA( bounds, 0.5f, diag, center );
VectorAdd( ent->e.origin, center, localOrigin );
radius = 0.5f * VectorLength( diag );
for ( i = 1 ; i < tr.world->numfogs ; i++ ) {
fog = &tr.world->fogs[i];
for ( j = 0 ; j < 3 ; j++ ) {
if ( localOrigin[j] - radius >= fog->bounds[1][j] ) {
break;
}
if ( localOrigin[j] + radius <= fog->bounds[0][j] ) {
break;
}
}
if ( j == 3 ) {
return i;
}
}
return 0;
}
/*
=================
R_AddIQMSurfaces
Add all surfaces of this model
=================
*/
void R_AddIQMSurfaces( trRefEntity_t *ent ) {
iqmData_t *data;
srfIQModel_t *surface;
void *drawSurf;
int i, j;
qboolean personalModel;
int cull;
int fogNum;
int cubemapIndex;
shader_t *shader;
skin_t *skin;
data = tr.currentModel->modelData;
surface = data->surfaces;
// don't add third_person objects if not in a portal
personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !(tr.viewParms.isPortal
|| (tr.viewParms.flags & (VPF_SHADOWMAP | VPF_DEPTHSHADOW)));
if ( ent->e.renderfx & RF_WRAP_FRAMES ) {
ent->e.frame %= data->num_frames;
ent->e.oldframe %= data->num_frames;
}
//
// Validate the frames so there is no chance of a crash.
// This will write directly into the entity structure, so
// when the surfaces are rendered, they don't need to be
// range checked again.
//
if ( (ent->e.frame >= data->num_frames)
|| (ent->e.frame < 0)
|| (ent->e.oldframe >= data->num_frames)
|| (ent->e.oldframe < 0) ) {
ri.Printf( PRINT_DEVELOPER, "R_AddIQMSurfaces: no such frame %d to %d for '%s'\n",
ent->e.oldframe, ent->e.frame,
tr.currentModel->name );
ent->e.frame = 0;
ent->e.oldframe = 0;
}
//
// cull the entire model if merged bounding box of both frames
// is outside the view frustum.
//
cull = R_CullIQM ( data, ent );
if ( cull == CULL_OUT ) {
return;
}
//
// set up lighting now that we know we aren't culled
//
if ( !personalModel || r_shadows->integer > 1 ) {
R_SetupEntityLighting( &tr.refdef, ent );
}
//
// see if we are in a fog volume
//
fogNum = R_ComputeIQMFogNum( data, ent );
cubemapIndex = R_CubemapForPoint(ent->e.origin);
for ( i = 0 ; i < data->num_surfaces ; i++ ) {
if(ent->e.customShader)
shader = R_GetShaderByHandle( ent->e.customShader );
else if(ent->e.customSkin > 0 && ent->e.customSkin < tr.numSkins)
{
skin = R_GetSkinByHandle(ent->e.customSkin);
shader = tr.defaultShader;
for(j = 0; j < skin->numSurfaces; j++)
{
if (!strcmp(skin->surfaces[j].name, surface->name))
{
shader = skin->surfaces[j].shader;
break;
}
}
} else {
shader = surface->shader;
}
if ( data->numVaoSurfaces ) {
drawSurf = &data->vaoSurfaces[i];
} else {
drawSurf = surface;
}
// we will add shadows even if the main object isn't visible in the view
// stencil shadows can't do personal models unless I polyhedron clip
if ( !personalModel
&& r_shadows->integer == 2
&& fogNum == 0
&& !(ent->e.renderfx & ( RF_NOSHADOW | RF_DEPTHHACK ) )
&& shader->sort == SS_OPAQUE ) {
R_AddDrawSurf( drawSurf, tr.shadowShader, 0, 0, 0, 0 );
}
// projection shadows work fine with personal models
if ( r_shadows->integer == 3
&& fogNum == 0
&& (ent->e.renderfx & RF_SHADOW_PLANE )
&& shader->sort == SS_OPAQUE ) {
R_AddDrawSurf( drawSurf, tr.projectionShadowShader, 0, 0, 0, 0 );
}
if( !personalModel ) {
R_AddDrawSurf( drawSurf, shader, fogNum, 0, 0, cubemapIndex );
}
surface++;
}
}
static void ComputePoseMats( iqmData_t *data, int frame, int oldframe,
float backlerp, float *mat ) {
float *mat1, *mat2;
int *joint = data->jointParents;
int i;
if ( oldframe == frame ) {
mat1 = data->poseMats + 12 * data->num_poses * frame;
for( i = 0; i < data->num_poses; i++, joint++ ) {
if( *joint >= 0 ) {
Matrix34Multiply( mat + 12 * *joint,
mat1 + 12*i, mat + 12*i );
} else {
Com_Memcpy( mat + 12*i, mat1 + 12*i, 12 * sizeof(float) );
}
}
} else {
mat1 = data->poseMats + 12 * data->num_poses * frame;
mat2 = data->poseMats + 12 * data->num_poses * oldframe;
for( i = 0; i < data->num_poses; i++, joint++ ) {
if( *joint >= 0 ) {
float tmpMat[12];
InterpolateMatrix( mat1 + 12*i, mat2 + 12*i,
backlerp, tmpMat );
Matrix34Multiply( mat + 12 * *joint,
tmpMat, mat + 12*i );
} else {
InterpolateMatrix( mat1 + 12*i, mat2 + 12*i,
backlerp, mat + 12*i );
}
}
}
}
static void ComputeJointMats( iqmData_t *data, int frame, int oldframe,
float backlerp, float *mat ) {
float *mat1;
int i;
if ( data->num_poses == 0 ) {
Com_Memcpy( mat, data->jointMats, data->num_joints * 12 * sizeof(float) );
return;
}
ComputePoseMats( data, frame, oldframe, backlerp, mat );
for( i = 0; i < data->num_joints; i++ ) {
float outmat[12];
mat1 = mat + 12 * i;
Com_Memcpy(outmat, mat1, sizeof(outmat));
Matrix34Multiply( outmat, data->jointMats + 12*i, mat1 );
}
}
/*
=================
RB_AddIQMSurfaces
Compute vertices for this model surface
=================
*/
void RB_IQMSurfaceAnim( surfaceType_t *surface ) {
srfIQModel_t *surf = (srfIQModel_t *)surface;
iqmData_t *data = surf->data;
float poseMats[IQM_MAX_JOINTS * 12];
float influenceVtxMat[SHADER_MAX_VERTEXES * 12];
float influenceNrmMat[SHADER_MAX_VERTEXES * 9];
int i;
float *xyz;
float *normal;
float *tangent;
float *texCoords;
byte *color;
vec4_t *outXYZ;
int16_t *outNormal;
int16_t *outTangent;
vec2_t *outTexCoord;
uint16_t *outColor;
int frame = data->num_frames ? backEnd.currentEntity->e.frame % data->num_frames : 0;
int oldframe = data->num_frames ? backEnd.currentEntity->e.oldframe % data->num_frames : 0;
float backlerp = backEnd.currentEntity->e.backlerp;
int *tri;
glIndex_t *ptr;
glIndex_t base;
RB_CHECKOVERFLOW( surf->num_vertexes, surf->num_triangles * 3 );
xyz = &data->positions[surf->first_vertex * 3];
normal = &data->normals[surf->first_vertex * 3];
tangent = &data->tangents[surf->first_vertex * 4];
texCoords = &data->texcoords[surf->first_vertex * 2];
if ( data->colors ) {
color = &data->colors[surf->first_vertex * 4];
} else {
color = NULL;
}
outXYZ = &tess.xyz[tess.numVertexes];
outNormal = tess.normal[tess.numVertexes];
outTangent = tess.tangent[tess.numVertexes];
outTexCoord = &tess.texCoords[tess.numVertexes];
outColor = tess.color[tess.numVertexes];
if ( data->num_poses > 0 ) {
// compute interpolated joint matrices
ComputePoseMats( data, frame, oldframe, backlerp, poseMats );
// compute vertex blend influence matricies
for( i = 0; i < surf->num_influences; i++ ) {
int influence = surf->first_influence + i;
float *vtxMat = &influenceVtxMat[12*i];
float *nrmMat = &influenceNrmMat[9*i];
int j;
float blendWeights[4];
int numWeights;
for ( numWeights = 0; numWeights < 4; numWeights++ ) {
if ( data->blendWeightsType == IQM_FLOAT )
blendWeights[numWeights] = data->influenceBlendWeights.f[4*influence + numWeights];
else
blendWeights[numWeights] = (float)data->influenceBlendWeights.b[4*influence + numWeights] / 255.0f;
if ( blendWeights[numWeights] <= 0.0f )
break;
}
if ( numWeights == 0 ) {
// no blend joint, use identity matrix.
vtxMat[0] = identityMatrix[0];
vtxMat[1] = identityMatrix[1];
vtxMat[2] = identityMatrix[2];
vtxMat[3] = identityMatrix[3];
vtxMat[4] = identityMatrix[4];
vtxMat[5] = identityMatrix[5];
vtxMat[6] = identityMatrix[6];
vtxMat[7] = identityMatrix[7];
vtxMat[8] = identityMatrix[8];
vtxMat[9] = identityMatrix[9];
vtxMat[10] = identityMatrix[10];
vtxMat[11] = identityMatrix[11];
} else {
// compute the vertex matrix by blending the up to
// four blend weights
vtxMat[0] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 0];
vtxMat[1] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 1];
vtxMat[2] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 2];
vtxMat[3] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 3];
vtxMat[4] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 4];
vtxMat[5] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 5];
vtxMat[6] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 6];
vtxMat[7] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 7];
vtxMat[8] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 8];
vtxMat[9] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 9];
vtxMat[10] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 10];
vtxMat[11] = blendWeights[0] * poseMats[12 * data->influenceBlendIndexes[4*influence + 0] + 11];
for( j = 1; j < numWeights; j++ ) {
vtxMat[0] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 0];
vtxMat[1] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 1];
vtxMat[2] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 2];
vtxMat[3] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 3];
vtxMat[4] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 4];
vtxMat[5] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 5];
vtxMat[6] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 6];
vtxMat[7] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 7];
vtxMat[8] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 8];
vtxMat[9] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 9];
vtxMat[10] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 10];
vtxMat[11] += blendWeights[j] * poseMats[12 * data->influenceBlendIndexes[4*influence + j] + 11];
}
}
// compute the normal matrix as transpose of the adjoint
// of the vertex matrix
nrmMat[ 0] = vtxMat[ 5]*vtxMat[10] - vtxMat[ 6]*vtxMat[ 9];
nrmMat[ 1] = vtxMat[ 6]*vtxMat[ 8] - vtxMat[ 4]*vtxMat[10];
nrmMat[ 2] = vtxMat[ 4]*vtxMat[ 9] - vtxMat[ 5]*vtxMat[ 8];
nrmMat[ 3] = vtxMat[ 2]*vtxMat[ 9] - vtxMat[ 1]*vtxMat[10];
nrmMat[ 4] = vtxMat[ 0]*vtxMat[10] - vtxMat[ 2]*vtxMat[ 8];
nrmMat[ 5] = vtxMat[ 1]*vtxMat[ 8] - vtxMat[ 0]*vtxMat[ 9];
nrmMat[ 6] = vtxMat[ 1]*vtxMat[ 6] - vtxMat[ 2]*vtxMat[ 5];
nrmMat[ 7] = vtxMat[ 2]*vtxMat[ 4] - vtxMat[ 0]*vtxMat[ 6];
nrmMat[ 8] = vtxMat[ 0]*vtxMat[ 5] - vtxMat[ 1]*vtxMat[ 4];
}
// transform vertexes and fill other data
for( i = 0; i < surf->num_vertexes;
i++, xyz+=3, normal+=3, tangent+=4, texCoords+=2,
outXYZ++, outNormal+=4, outTangent+=4, outTexCoord++ ) {
int influence = data->influences[surf->first_vertex + i] - surf->first_influence;
float *vtxMat = &influenceVtxMat[12*influence];
float *nrmMat = &influenceNrmMat[9*influence];
(*outTexCoord)[0] = texCoords[0];
(*outTexCoord)[1] = texCoords[1];
(*outXYZ)[0] =
vtxMat[ 0] * xyz[0] +
vtxMat[ 1] * xyz[1] +
vtxMat[ 2] * xyz[2] +
vtxMat[ 3];
(*outXYZ)[1] =
vtxMat[ 4] * xyz[0] +
vtxMat[ 5] * xyz[1] +
vtxMat[ 6] * xyz[2] +
vtxMat[ 7];
(*outXYZ)[2] =
vtxMat[ 8] * xyz[0] +
vtxMat[ 9] * xyz[1] +
vtxMat[10] * xyz[2] +
vtxMat[11];
{
vec3_t unpackedNormal;
vec4_t unpackedTangent;
unpackedNormal[0] = DotProduct(&nrmMat[0], normal);
unpackedNormal[1] = DotProduct(&nrmMat[3], normal);
unpackedNormal[2] = DotProduct(&nrmMat[6], normal);
R_VaoPackNormal(outNormal, unpackedNormal);
unpackedTangent[0] = DotProduct(&nrmMat[0], tangent);
unpackedTangent[1] = DotProduct(&nrmMat[3], tangent);
unpackedTangent[2] = DotProduct(&nrmMat[6], tangent);
unpackedTangent[3] = tangent[3];
R_VaoPackTangent(outTangent, unpackedTangent);
}
}
} else {
// copy vertexes and fill other data
for( i = 0; i < surf->num_vertexes;
i++, xyz+=3, normal+=3, tangent+=4, texCoords+=2,
outXYZ++, outNormal+=4, outTangent+=4, outTexCoord++ ) {
(*outTexCoord)[0] = texCoords[0];
(*outTexCoord)[1] = texCoords[1];
(*outXYZ)[0] = xyz[0];
(*outXYZ)[1] = xyz[1];
(*outXYZ)[2] = xyz[2];
R_VaoPackNormal(outNormal, normal);
R_VaoPackTangent(outTangent, tangent);
}
}
if ( color ) {
for( i = 0; i < surf->num_vertexes; i++, color+=4, outColor+=4 ) {
outColor[0] = color[0] * 257;
outColor[1] = color[1] * 257;
outColor[2] = color[2] * 257;
outColor[3] = color[3] * 257;
}
} else {
for( i = 0; i < surf->num_vertexes; i++, outColor+=4 ) {
outColor[0] = 0;
outColor[1] = 0;
outColor[2] = 0;
outColor[3] = 0;
}
}
tri = data->triangles + 3 * surf->first_triangle;
ptr = &tess.indexes[tess.numIndexes];
base = tess.numVertexes;
for( i = 0; i < surf->num_triangles; i++ ) {
*ptr++ = base + (*tri++ - surf->first_vertex);
*ptr++ = base + (*tri++ - surf->first_vertex);
*ptr++ = base + (*tri++ - surf->first_vertex);
}
tess.numIndexes += 3 * surf->num_triangles;
tess.numVertexes += surf->num_vertexes;
}
/*
=================
RB_IQMSurfaceAnimVao
=================
*/
void RB_IQMSurfaceAnimVao(srfVaoIQModel_t * surface)
{
iqmData_t *data = surface->iqmData;
if (ShaderRequiresCPUDeforms(tess.shader))
{
RB_IQMSurfaceAnim((surfaceType_t*)surface->iqmSurface);
return;
}
if(!surface->vao)
return;
//RB_CheckVao(surface->vao);
RB_EndSurface();
RB_BeginSurface(tess.shader, tess.fogNum, tess.cubemapIndex);
R_BindVao(surface->vao);
tess.useInternalVao = qfalse;
tess.numIndexes = surface->numIndexes;
tess.numVertexes = surface->numVerts;
glState.boneAnimation = data->num_poses;
if ( glState.boneAnimation ) {
float jointMats[IQM_MAX_JOINTS * 12];
int frame = data->num_frames ? backEnd.currentEntity->e.frame % data->num_frames : 0;
int oldframe = data->num_frames ? backEnd.currentEntity->e.oldframe % data->num_frames : 0;
float backlerp = backEnd.currentEntity->e.backlerp;
int i;
// compute interpolated joint matrices
ComputePoseMats( surface->iqmData, frame, oldframe, backlerp, jointMats );
// convert row-major order 3x4 matrix to column-major order 4x4 matrix
for ( i = 0; i < data->num_poses; i++ ) {
glState.boneMatrix[i][0] = jointMats[i*12+0];
glState.boneMatrix[i][1] = jointMats[i*12+4];
glState.boneMatrix[i][2] = jointMats[i*12+8];
glState.boneMatrix[i][3] = 0.0f;
glState.boneMatrix[i][4] = jointMats[i*12+1];
glState.boneMatrix[i][5] = jointMats[i*12+5];
glState.boneMatrix[i][6] = jointMats[i*12+9];
glState.boneMatrix[i][7] = 0.0f;
glState.boneMatrix[i][8] = jointMats[i*12+2];
glState.boneMatrix[i][9] = jointMats[i*12+6];
glState.boneMatrix[i][10] = jointMats[i*12+10];
glState.boneMatrix[i][11] = 0.0f;
glState.boneMatrix[i][12] = jointMats[i*12+3];
glState.boneMatrix[i][13] = jointMats[i*12+7];
glState.boneMatrix[i][14] = jointMats[i*12+11];
glState.boneMatrix[i][15] = 1.0f;
}
}
RB_EndSurface();
glState.boneAnimation = 0;
}
int R_IQMLerpTag( orientation_t *tag, iqmData_t *data,
int startFrame, int endFrame,
float frac, const char *tagName ) {
float jointMats[IQM_MAX_JOINTS * 12];
int joint;
char *names = data->jointNames;
// get joint number by reading the joint names
for( joint = 0; joint < data->num_joints; joint++ ) {
if( !strcmp( tagName, names ) )
break;
names += strlen( names ) + 1;
}
if( joint >= data->num_joints ) {
AxisClear( tag->axis );
VectorClear( tag->origin );
return qfalse;
}
ComputeJointMats( data, startFrame, endFrame, frac, jointMats );
tag->axis[0][0] = jointMats[12 * joint + 0];
tag->axis[1][0] = jointMats[12 * joint + 1];
tag->axis[2][0] = jointMats[12 * joint + 2];
tag->origin[0] = jointMats[12 * joint + 3];
tag->axis[0][1] = jointMats[12 * joint + 4];
tag->axis[1][1] = jointMats[12 * joint + 5];
tag->axis[2][1] = jointMats[12 * joint + 6];
tag->origin[1] = jointMats[12 * joint + 7];
tag->axis[0][2] = jointMats[12 * joint + 8];
tag->axis[1][2] = jointMats[12 * joint + 9];
tag->axis[2][2] = jointMats[12 * joint + 10];
tag->origin[2] = jointMats[12 * joint + 11];
return qtrue;
}
Reference in a new issue View git blame Copy permalink