ubergames/lilium-voyager
0
0
Fork 0
mirror of https://github.com/UberGames/lilium-voyager.git synced 2024-12-14 22:20:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
lilium-voyager/code/renderergl2/tr_model_iqm.c

1697 lines
53 KiB
C
Raw Normal View History

Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
/*
===========================================================================
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)
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
// 3x4 identity matrix
static float identityMatrix[12] = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0
};
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
static qboolean IQM_CheckRange( iqmHeader_t *header, int offset,
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
int count, int size ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
// return true if the range specified by offset, count and size
// doesn't fit into the file
return ( count <= 0 ||
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
offset <= 0 ||
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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;
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
int i, j, k;
Fix renderergl2 warnings
2014-09-01 10:35:49 +00:00
float jointInvMats[IQM_MAX_JOINTS * 12] = {0.0f};
Fix origin returned by IQM's LerpTag It use to return pose joint's offset from base at the lerped frame, now it returns the joint's origin at the lerped frame. Patch by Axel Isouard and Zack Middleton.
2013-03-08 19:47:16 +00:00
float *mat, *matInv;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
size_t size, joint_names;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
byte *dataPtr;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
iqmData_t *iqmData;
srfIQModel_t *surface;
Show surface names in excessive vertexes and triangles warnings Add newlines to renderergl2's R_LoadMD3 vertex and triangle warnings.
2013-05-03 19:28:18 +00:00
char meshName[MAX_QPATH];
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
int vertexArrayFormat[IQM_COLOR+1];
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
int allocateInfluences;
byte *blendIndexes;
union {
byte *b;
float *f;
} blendWeights;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
for ( i = 0; i < ARRAY_LEN( vertexArrayFormat ); i++ ) {
vertexArrayFormat[i] = -1;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
blendIndexes = NULL;
blendWeights.b = NULL;
allocateInfluences = 0;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
if ( header->num_meshes )
{
// check and swap vertex arrays
if( IQM_CheckRange( header, header->ofs_vertexarrays,
header->num_vertexarrays,
sizeof(iqmVertexArray_t) ) ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
vertexarray = (iqmVertexArray_t *)((byte *)header + header->ofs_vertexarrays);
for( i = 0; i < header->num_vertexarrays; i++, vertexarray++ ) {
int n, *intPtr;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
if( vertexarray->size <= 0 || vertexarray->size > 4 ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// 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
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
return qfalse;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
break;
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
if( vertexarray->type < ARRAY_LEN( vertexArrayFormat ) ) {
vertexArrayFormat[vertexarray->type] = vertexarray->format;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
blendIndexes = (byte*)header + vertexarray->offset;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
break;
case IQM_BLENDWEIGHTS:
if( (vertexarray->format != IQM_FLOAT &&
vertexarray->format != IQM_UBYTE) ||
vertexarray->size != 4 ) {
return qfalse;
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
if( vertexarray->format == IQM_FLOAT ) {
blendWeights.f = (float*)( (byte*)header + vertexarray->offset );
} else {
blendWeights.b = (byte*)header + vertexarray->offset;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
break;
case IQM_COLOR:
if( vertexarray->format != IQM_UBYTE ||
vertexarray->size != 4 ) {
return qfalse;
}
break;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// 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 );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
Show surface names in excessive vertexes and triangles warnings Add newlines to renderergl2's R_LoadMD3 vertex and triangle warnings.
2013-05-03 19:28:18 +00:00
} else {
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// ignore blend arrays if present
vertexArrayFormat[IQM_BLENDINDEXES] = -1;
vertexArrayFormat[IQM_BLENDWEIGHTS] = -1;
Show surface names in excessive vertexes and triangles warnings Add newlines to renderergl2's R_LoadMD3 vertex and triangle warnings.
2013-05-03 19:28:18 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// opengl2 renderer requires tangents
if( vertexArrayFormat[IQM_TANGENT] == -1 ) {
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s is missing IQM_TANGENT array.\n", mod_name );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// check and swap triangles
if( IQM_CheckRange( header, header->ofs_triangles,
header->num_triangles, sizeof(iqmTriangle_t) ) ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// check and swap meshes
if( IQM_CheckRange( header, header->ofs_meshes,
header->num_meshes, sizeof(iqmMesh_t) ) ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// 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++;
}
}
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
if( header->num_poses != header->num_joints && header->num_poses != 0 ) {
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
ri.Printf( PRINT_WARNING, "R_LoadIQM: %s has %d poses and %d joints, must have the same number or 0 poses\n",
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
mod_name, header->num_poses, header->num_joints );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
Always initialize joint_names in R_LoadIQM Reported by MAN-AT-ARMS
2013-03-18 20:55:25 +00:00
joint_names = 0;
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
if ( header->num_joints )
{
// check and swap joints
if( IQM_CheckRange( header, header->ofs_joints,
header->num_joints, sizeof(iqmJoint_t) ) ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
return qfalse;
}
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
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;
}
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
if ( header->num_poses )
{
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
// 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] );
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
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);
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
if ( vertexArrayFormat[IQM_COLOR] != -1 ) {
size += header->num_vertexes * 4 * sizeof(byte); // colors
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
if ( allocateInfluences ) {
size += header->num_vertexes * sizeof(int); // influences
size += allocateInfluences * 4 * sizeof(byte); // influenceBlendIndexes
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
}
}
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
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 22:13:50 +00:00
} else if( header->num_meshes && header->num_frames == 0 ) {
size += 6 * sizeof(float); // model bounds
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
mod->type = MOD_IQM;
iqmData = (iqmData_t *)ri.Hunk_Alloc( size, h_low );
mod->modelData = iqmData;
// fill header
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
iqmData->num_vertexes = ( header->num_meshes > 0 ) ? header->num_vertexes : 0;
iqmData->num_triangles = ( header->num_meshes > 0 ) ? header->num_triangles : 0;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
iqmData->num_frames = header->num_frames;
iqmData->num_surfaces = header->num_meshes;
iqmData->num_joints = header->num_joints;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
iqmData->num_poses = header->num_poses;
iqmData->blendWeightsType = vertexArrayFormat[IQM_BLENDWEIGHTS];
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
dataPtr = (byte*)iqmData + sizeof(iqmData_t);
if( header->num_meshes ) {
iqmData->surfaces = (struct srfIQModel_s*)dataPtr;
dataPtr += header->num_meshes * sizeof( srfIQModel_t );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
if( header->num_joints ) {
iqmData->jointNames = (char*)dataPtr;
dataPtr += joint_names; // joint names
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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
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 22:13:50 +00:00
} else if( header->num_meshes && header->num_frames == 0 ) {
iqmData->bounds = (float*)dataPtr;
dataPtr += 6 * sizeof(float); // model bounds
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// 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];
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// 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;
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// 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++;
}
}
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
// 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;
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
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;
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
// 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++;
}
}
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 22:13:50 +00:00
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] );
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
// 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);
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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;
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
void *drawSurf;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
int i, j;
qboolean personalModel;
int cull;
int fogNum;
#5979: Cubemap support for opengl2.
2013-09-16 07:54:26 +00:00
int cubemapIndex;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
shader_t *shader;
skin_t *skin;
data = tr.currentModel->modelData;
surface = data->surfaces;
// don't add third_person objects if not in a portal
OpenGL2: Draw sun shadows for first person IQM player models This makes IQM have the same behavior as MD3 and MDR.
2017-06-30 18:59:07 +00:00
personalModel = (ent->e.renderfx & RF_THIRD_PERSON) && !(tr.viewParms.isPortal
|| (tr.viewParms.flags & (VPF_SHADOWMAP | VPF_DEPTHSHADOW)));
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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 );
#5979: Cubemap support for opengl2.
2013-09-16 07:54:26 +00:00
cubemapIndex = R_CubemapForPoint(ent->e.origin);
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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++)
{
Allow more than 32 surfaces in skin files Models don't have a surface limit; skins shouldn't either. Some player models require more than 32 surfaces since vanilla Quake 3 did not enforce the limit. Skins are now limited to 256 surfaces because having no limit would require parsing the skin file twice. The skin surfaces are dynamically allocated so it doesn't increase memory usage when less surfaces are used.
2017-07-04 18:48:52 +00:00
if (!strcmp(skin->surfaces[j].name, surface->name))
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
{
Allow more than 32 surfaces in skin files Models don't have a surface limit; skins shouldn't either. Some player models require more than 32 surfaces since vanilla Quake 3 did not enforce the limit. Skins are now limited to 256 surfaces because having no limit would require parsing the skin file twice. The skin surfaces are dynamically allocated so it doesn't increase memory usage when less surfaces are used.
2017-07-04 18:48:52 +00:00
shader = skin->surfaces[j].shader;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
break;
}
}
} else {
shader = surface->shader;
}
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
if ( data->numVaoSurfaces ) {
drawSurf = &data->vaoSurfaces[i];
} else {
drawSurf = surface;
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
// 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 ) {
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
R_AddDrawSurf( drawSurf, tr.shadowShader, 0, 0, 0, 0 );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
// projection shadows work fine with personal models
if ( r_shadows->integer == 3
&& fogNum == 0
&& (ent->e.renderfx & RF_SHADOW_PLANE )
&& shader->sort == SS_OPAQUE ) {
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
R_AddDrawSurf( drawSurf, tr.projectionShadowShader, 0, 0, 0, 0 );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
if( !personalModel ) {
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
R_AddDrawSurf( drawSurf, shader, fogNum, 0, 0, cubemapIndex );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
surface++;
}
}
Fix origin returned by IQM's LerpTag It use to return pose joint's offset from base at the lerped frame, now it returns the joint's origin at the lerped frame. Patch by Axel Isouard and Zack Middleton.
2013-03-08 19:47:16 +00:00
static void ComputePoseMats( iqmData_t *data, int frame, int oldframe,
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
float backlerp, float *mat ) {
float *mat1, *mat2;
int *joint = data->jointParents;
int i;
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
if ( oldframe == frame ) {
mat1 = data->poseMats + 12 * data->num_poses * frame;
for( i = 0; i < data->num_poses; i++, joint++ ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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 {
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
mat1 = data->poseMats + 12 * data->num_poses * frame;
mat2 = data->poseMats + 12 * data->num_poses * oldframe;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
for( i = 0; i < data->num_poses; i++, joint++ ) {
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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,
Fix IQM root joint backlerp when joint number is more than 0 Backlerp for root joint (joint with no parent) was always applied to joint 0. This is an issue when a model has multiple root joints.
2018-07-27 22:40:09 +00:00
backlerp, mat + 12*i );
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
}
}
}
Fix origin returned by IQM's LerpTag It use to return pose joint's offset from base at the lerped frame, now it returns the joint's origin at the lerped frame. Patch by Axel Isouard and Zack Middleton.
2013-03-08 19:47:16 +00:00
static void ComputeJointMats( iqmData_t *data, int frame, int oldframe,
float backlerp, float *mat ) {
float *mat1;
int i;
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
if ( data->num_poses == 0 ) {
Com_Memcpy( mat, data->jointMats, data->num_joints * 12 * sizeof(float) );
return;
}
Fix origin returned by IQM's LerpTag It use to return pose joint's offset from base at the lerped frame, now it returns the joint's origin at the lerped frame. Patch by Axel Isouard and Zack Middleton.
2013-03-08 19:47:16 +00:00
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));
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
Matrix34Multiply( outmat, data->jointMats + 12*i, mat1 );
Fix origin returned by IQM's LerpTag It use to return pose joint's offset from base at the lerped frame, now it returns the joint's origin at the lerped frame. Patch by Axel Isouard and Zack Middleton.
2013-03-08 19:47:16 +00:00
}
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
/*
=================
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;
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
float poseMats[IQM_MAX_JOINTS * 12];
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
float influenceVtxMat[SHADER_MAX_VERTEXES * 12];
float influenceNrmMat[SHADER_MAX_VERTEXES * 9];
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
int i;
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
float *xyz;
float *normal;
float *tangent;
float *texCoords;
byte *color;
Fix IQM tess buffer overflow Set the variables that use tess.numVertexes after calling RB_CHECKOVERFLOW() as it may set tess.numVertexes to 0! Could cause visual issues and error "RB_EndSurface() - SHADER_MAX_VERTEXES hit".
2013-06-18 23:00:45 +00:00
vec4_t *outXYZ;
OpenGL2: Store normals/tangents as int16_t[4].
2016-09-06 07:57:15 +00:00
int16_t *outNormal;
int16_t *outTangent;
OpenGL2: Don't interleave texCoords and lightCoords in tess.
2016-11-25 09:17:46 +00:00
vec2_t *outTexCoord;
OpenGL2: Store vertex colors and hdr lightmaps/lightgrid as RGBA16.
2016-10-11 10:28:20 +00:00
uint16_t *outColor;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
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;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
float backlerp = backEnd.currentEntity->e.backlerp;
int *tri;
glIndex_t *ptr;
glIndex_t base;
RB_CHECKOVERFLOW( surf->num_vertexes, surf->num_triangles * 3 );
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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;
}
Fix IQM tess buffer overflow Set the variables that use tess.numVertexes after calling RB_CHECKOVERFLOW() as it may set tess.numVertexes to 0! Could cause visual issues and error "RB_EndSurface() - SHADER_MAX_VERTEXES hit".
2013-06-18 23:00:45 +00:00
outXYZ = &tess.xyz[tess.numVertexes];
OpenGL2: Store normals/tangents as int16_t[4].
2016-09-06 07:57:15 +00:00
outNormal = tess.normal[tess.numVertexes];
outTangent = tess.tangent[tess.numVertexes];
Fix IQM tess buffer overflow Set the variables that use tess.numVertexes after calling RB_CHECKOVERFLOW() as it may set tess.numVertexes to 0! Could cause visual issues and error "RB_EndSurface() - SHADER_MAX_VERTEXES hit".
2013-06-18 23:00:45 +00:00
outTexCoord = &tess.texCoords[tess.numVertexes];
OpenGL2: Store vertex colors and hdr lightmaps/lightgrid as RGBA16.
2016-10-11 10:28:20 +00:00
outColor = tess.color[tess.numVertexes];
Fix IQM tess buffer overflow Set the variables that use tess.numVertexes after calling RB_CHECKOVERFLOW() as it may set tess.numVertexes to 0! Could cause visual issues and error "RB_EndSurface() - SHADER_MAX_VERTEXES hit".
2013-06-18 23:00:45 +00:00
Support IQMs with joints and no poses
2013-10-30 01:46:12 +00:00
if ( data->num_poses > 0 ) {
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// compute interpolated joint matrices
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
ComputePoseMats( data, frame, oldframe, backlerp, poseMats );
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// 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;
}
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
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];
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
for( j = 1; j < numWeights; j++ ) {
Fix axis returned by IQM's LerpTag The axis returned for IQM tag was the animation's joint rotation without the base frame joint rotation. It only worked correct for models that did not rotate the base frame joints.
2018-07-31 18:50:20 +00:00
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];
Add support for IQM int blend indices and float blend weights Integer blend indices are converted to bytes at load, ioq3 doesn't allow more than 128 joints. Heavily based on code by @zippers.
2013-10-30 03:09:06 +00:00
}
Fix loading and rendering IQMs with no joints
2013-03-18 19:13:09 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// 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];
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
// 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];
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
{
vec3_t unpackedNormal;
vec4_t unpackedTangent;
OpenGL2: Support GL_ARB_vertex_type_2_10_10_10_rev for normals/tangents/lightdirs
2013-12-10 01:33:54 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
unpackedNormal[0] = DotProduct(&nrmMat[0], normal);
unpackedNormal[1] = DotProduct(&nrmMat[3], normal);
unpackedNormal[2] = DotProduct(&nrmMat[6], normal);
OpenGL2: Support GL_ARB_vertex_type_2_10_10_10_rev for normals/tangents/lightdirs
2013-12-10 01:33:54 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
R_VaoPackNormal(outNormal, unpackedNormal);
OpenGL2: Support GL_ARB_vertex_type_2_10_10_10_rev for normals/tangents/lightdirs
2013-12-10 01:33:54 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
unpackedTangent[0] = DotProduct(&nrmMat[0], tangent);
unpackedTangent[1] = DotProduct(&nrmMat[3], tangent);
unpackedTangent[2] = DotProduct(&nrmMat[6], tangent);
unpackedTangent[3] = tangent[3];
OpenGL2: Support GL_ARB_vertex_type_2_10_10_10_rev for normals/tangents/lightdirs
2013-12-10 01:33:54 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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);
OpenGL2: Store normals/tangents as int16_t[4].
2016-09-06 07:57:15 +00:00
R_VaoPackTangent(outTangent, tangent);
OpenGL2: Support GL_ARB_vertex_type_2_10_10_10_rev for normals/tangents/lightdirs
2013-12-10 01:33:54 +00:00
}
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
Improve IQM CPU vertex skinning performance Only calculate vertex blend matrix for each unique bone indexes/weights combination once per-surface instead of recalculating for each vertex. For best performance the model surfaces needs to use few vertex bone indexes and weights combinations. Unroll loops so GCC better optimizes them. In my tests drawing animated IQM may take 50% as long in opengl1 and 70% as long in opengl2. It will vary by model though and might not help much at all. Made unanimated IQM models skip matrix math altogether.
2018-07-27 22:40:21 +00:00
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;
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
}
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;
}
OpenGL2: Add GPU vertex skinning for IQM models Using GPU vertex skinning is significantly faster than CPU vertex skinning. Especially since OpenGL2 has to run R_VaoPackNormal() and R_VaoPackTangent() each vertex each frame which causes CPU vertex skinning to be significantly slower than OpenGL1 renderer.
2018-07-27 22:40:25 +00:00
/*
=================
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;
}
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
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;
Improve IQM loading - Only allocate memory for vertex arrays that are present in the IQM file and are actually used (may not have colors or blend index/weights, don't load tangents in opengl1). (Colors is fixed to next commit.) - Explicitly handle loading IQM files without meshes (bones only). - Better IQM validation. Header data offset 0 mean data is not present in file. Check if required vertex arrays are present. This involved a lot of white space changes and moving code around.
2018-07-27 22:40:16 +00:00
char *names = data->jointNames;
Added Rend2, an alternate renderer. (Bug #4358)
2012-10-26 01:23:06 +00:00
// 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 Copy permalink