static void R_InitUnitCubeVBO()
{
vec3_t mins = { -1, -1, -1 };
vec3_t maxs = { 1, 1, 1 };
vboData_t data;
R_SyncRenderThread();
tess.multiDrawPrimitives = 0;
tess.numIndexes = 0;
tess.numVertexes = 0;
Tess_MapVBOs( true );
Tess_AddCube( vec3_origin, mins, maxs, colorWhite );
memset( &data, 0, sizeof( data ) );
data.xyz = ( vec3_t * ) ri.Hunk_AllocateTempMemory( tess.numVertexes * sizeof( *data.xyz ) );
data.numVerts = tess.numVertexes;
for (unsigned i = 0; i < tess.numVertexes; i++ )
{
VectorCopy( tess.verts[ i ].xyz, data.xyz[ i ] );
}
tr.unitCubeVBO = R_CreateStaticVBO( "unitCube_VBO", data, VBO_LAYOUT_POSITION );
tr.unitCubeIBO = R_CreateStaticIBO( "unitCube_IBO", tess.indexes, tess.numIndexes );
ri.Hunk_FreeTempMemory( data.xyz );
tess.multiDrawPrimitives = 0;
tess.numIndexes = 0;
tess.numVertexes = 0;
tess.verts = nullptr;
tess.indexes = nullptr;
}
/*
=================
R_LoadIQModel
Load an IQM model and compute the joint matrices for every frame.
=================
*/
bool R_LoadIQModel( 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;
iqmAnim_t *anim;
unsigned short *framedata;
char *str, *name;
int len;
transform_t *trans, *poses;
float *bounds;
size_t size, len_names;
IQModel_t *IQModel;
IQAnim_t *IQAnim;
srfIQModel_t *surface;
vboData_t vboData;
float *weightbuf;
int *indexbuf;
i16vec4_t *qtangentbuf;
VBO_t *vbo;
IBO_t *ibo;
void *ptr;
u8vec4_t *weights;
if( !LoadIQMFile( buffer, filesize, mod_name, &len_names ) ) {
return false;
}
header = (iqmHeader_t *)buffer;
// compute required space
size = sizeof(IQModel_t);
size += header->num_meshes * sizeof( srfIQModel_t );
size += header->num_anims * sizeof( IQAnim_t );
size += header->num_joints * sizeof( transform_t );
size = PAD( size, 16 );
size += header->num_joints * header->num_frames * sizeof( transform_t );
if(header->ofs_bounds)
size += header->num_frames * 6 * sizeof(float); // model bounds
size += header->num_vertexes * 3 * sizeof(float); // positions
size += header->num_vertexes * 3 * sizeof(float); // normals
size += header->num_vertexes * 3 * sizeof(float); // tangents
size += header->num_vertexes * 3 * sizeof(float); // bitangents
size += header->num_vertexes * 2 * sizeof(int16_t); // texcoords
size += header->num_vertexes * 4 * sizeof(byte); // blendIndexes
size += header->num_vertexes * 4 * sizeof(byte); // blendWeights
size += header->num_vertexes * 4 * sizeof(byte); // colors
size += header->num_triangles * 3 * sizeof(int); // triangles
size += header->num_joints * sizeof(int); // parents
size += len_names; // joint and anim names
IQModel = (IQModel_t *)ri.Hunk_Alloc( size, ha_pref::h_low );
mod->type = modtype_t::MOD_IQM;
mod->iqm = IQModel;
ptr = IQModel + 1;
// fill header and setup pointers
IQModel->num_vertexes = header->num_vertexes;
IQModel->num_triangles = header->num_triangles;
IQModel->num_frames = header->num_frames;
IQModel->num_surfaces = header->num_meshes;
IQModel->num_joints = header->num_joints;
IQModel->num_anims = header->num_anims;
IQModel->surfaces = (srfIQModel_t *)ptr;
ptr = IQModel->surfaces + header->num_meshes;
if( header->ofs_anims ) {
IQModel->anims = (IQAnim_t *)ptr;
ptr = IQModel->anims + header->num_anims;
} else {
IQModel->anims = nullptr;
}
IQModel->joints = (transform_t *)PADP(ptr, 16);
ptr = IQModel->joints + header->num_joints;
if( header->ofs_poses ) {
poses = (transform_t *)ptr;
ptr = poses + header->num_poses * header->num_frames;
} else {
poses = nullptr;
}
if( header->ofs_bounds ) {
bounds = (float *)ptr;
ptr = bounds + 6 * header->num_frames;
} else {
bounds = nullptr;
}
IQModel->positions = (float *)ptr;
ptr = IQModel->positions + 3 * header->num_vertexes;
IQModel->normals = (float *)ptr;
ptr = IQModel->normals + 3 * header->num_vertexes;
IQModel->tangents = (float *)ptr;
ptr = IQModel->tangents + 3 * header->num_vertexes;
IQModel->bitangents = (float *)ptr;
ptr = IQModel->bitangents + 3 * header->num_vertexes;
IQModel->texcoords = (int16_t *)ptr;
ptr = IQModel->texcoords + 2 * header->num_vertexes;
IQModel->blendIndexes = (byte *)ptr;
ptr = IQModel->blendIndexes + 4 * header->num_vertexes;
IQModel->blendWeights = (byte *)ptr;
ptr = IQModel->blendWeights + 4 * header->num_vertexes;
IQModel->colors = (byte *)ptr;
ptr = IQModel->colors + 4 * header->num_vertexes;
IQModel->jointParents = (int *)ptr;
ptr = IQModel->jointParents + header->num_joints;
IQModel->triangles = (int *)ptr;
ptr = IQModel->triangles + 3 * header->num_triangles;
str = (char *)ptr;
IQModel->jointNames = str;
// copy joint names
joint = ( iqmJoint_t* )IQMPtr( header, header->ofs_joints );
for(unsigned i = 0; i < header->num_joints; i++, joint++ ) {
name = ( char* )IQMPtr( header, header->ofs_text + joint->name );
len = strlen( name ) + 1;
Com_Memcpy( str, name, len );
str += len;
}
// setup animations
IQAnim = IQModel->anims;
anim = ( iqmAnim_t* )IQMPtr( header, header->ofs_anims );
for(int i = 0; i < IQModel->num_anims; i++, IQAnim++, anim++ ) {
IQAnim->num_frames = anim->num_frames;
IQAnim->framerate = anim->framerate;
IQAnim->num_joints = header->num_joints;
IQAnim->flags = anim->flags;
IQAnim->jointParents = IQModel->jointParents;
if( poses ) {
IQAnim->poses = poses + anim->first_frame * header->num_poses;
} else {
IQAnim->poses = nullptr;
}
if( bounds ) {
IQAnim->bounds = bounds + anim->first_frame * 6;
} else {
IQAnim->bounds = nullptr;
}
IQAnim->name = str;
IQAnim->jointNames = IQModel->jointNames;
name = ( char* )IQMPtr( header, header->ofs_text + anim->name );
len = strlen( name ) + 1;
Com_Memcpy( str, name, len );
str += len;
}
// calculate joint transforms
trans = IQModel->joints;
joint = ( iqmJoint_t* )IQMPtr( header, header->ofs_joints );
for(unsigned i = 0; i < header->num_joints; i++, joint++, trans++ ) {
if( joint->parent >= (int) i ) {
Log::Warn("R_LoadIQModel: file %s contains an invalid parent joint number.",
mod_name );
return false;
}
TransInitRotationQuat( joint->rotate, trans );
TransAddScale( joint->scale[0], trans );
TransAddTranslation( joint->translate, trans );
if( joint->parent >= 0 ) {
TransCombine( trans, &IQModel->joints[ joint->parent ],
trans );
}
IQModel->jointParents[i] = joint->parent;
}
// calculate pose transforms
framedata = ( short unsigned int* )IQMPtr( header, header->ofs_frames );
trans = poses;
for(unsigned i = 0; i < header->num_frames; i++ ) {
pose = ( iqmPose_t* )IQMPtr( header, header->ofs_poses );
for(unsigned j = 0; j < header->num_poses; j++, pose++, trans++ ) {
vec3_t translate;
quat_t rotate;
vec3_t scale;
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];
if( scale[0] < 0.0f ||
(int)( scale[0] - scale[1] ) ||
(int)( scale[1] - scale[2] ) ) {
Log::Warn("R_LoadIQM: file %s contains an invalid scale.", mod_name );
return false;
}
// construct transformation
TransInitRotationQuat( rotate, trans );
TransAddScale( scale[0], trans );
TransAddTranslation( translate, trans );
}
}
// copy vertexarrays and indexes
vertexarray = ( iqmVertexArray_t* )IQMPtr( header, header->ofs_vertexarrays );
for(unsigned i = 0; i < header->num_vertexarrays; i++, vertexarray++ ) {
int n;
// total number of values
n = header->num_vertexes * vertexarray->size;
switch( vertexarray->type ) {
case IQM_POSITION:
ClearBounds( IQModel->bounds[ 0 ], IQModel->bounds[ 1 ] );
Com_Memcpy( IQModel->positions,
IQMPtr( header, vertexarray->offset ),
n * sizeof(float) );
for( int j = 0; j < n; j += vertexarray->size ) {
AddPointToBounds( &IQModel->positions[ j ],
IQModel->bounds[ 0 ],
IQModel->bounds[ 1 ] );
}
IQModel->internalScale = BoundsMaxExtent( IQModel->bounds[ 0 ], IQModel->bounds[ 1 ] );
if( IQModel->internalScale > 0.0f ) {
float inverseScale = 1.0f / IQModel->internalScale;
for( int j = 0; j < n; j += vertexarray->size ) {
VectorScale( &IQModel->positions[ j ],
inverseScale,
&IQModel->positions[ j ] );
}
}
break;
case IQM_NORMAL:
Com_Memcpy( IQModel->normals,
IQMPtr( header, vertexarray->offset ),
n * sizeof(float) );
break;
case IQM_TANGENT:
BuildTangents( header->num_vertexes,
( float* )IQMPtr( header, vertexarray->offset ),
IQModel->normals, IQModel->tangents,
IQModel->bitangents );
break;
case IQM_TEXCOORD:
for( int j = 0; j < n; j++ ) {
IQModel->texcoords[ j ] = floatToHalf( ((float *)IQMPtr( header, vertexarray->offset ))[ j ] );
}
break;
case IQM_BLENDINDEXES:
Com_Memcpy( IQModel->blendIndexes,
IQMPtr( header, vertexarray->offset ),
n * sizeof(byte) );
break;
case IQM_BLENDWEIGHTS:
weights = (u8vec4_t *)IQMPtr( header, vertexarray->offset );
for(unsigned j = 0; j < header->num_vertexes; j++ ) {
IQModel->blendWeights[ 4 * j + 0 ] = 255 - weights[ j ][ 1 ] - weights[ j ][ 2 ] - weights[ j ][ 3 ];
IQModel->blendWeights[ 4 * j + 1 ] = weights[ j ][ 1 ];
IQModel->blendWeights[ 4 * j + 2 ] = weights[ j ][ 2 ];
IQModel->blendWeights[ 4 * j + 3 ] = weights[ j ][ 3 ];
}
break;
case IQM_COLOR:
Com_Memcpy( IQModel->colors,
IQMPtr( header, vertexarray->offset ),
n * sizeof(byte) );
break;
}
}
// copy triangles
triangle = ( iqmTriangle_t* )IQMPtr( header, header->ofs_triangles );
for(unsigned i = 0; i < header->num_triangles; i++, triangle++ ) {
IQModel->triangles[3*i+0] = triangle->vertex[0];
IQModel->triangles[3*i+1] = triangle->vertex[1];
IQModel->triangles[3*i+2] = triangle->vertex[2];
}
// convert data where necessary and create VBO
if( r_vboModels->integer && glConfig2.vboVertexSkinningAvailable
&& IQModel->num_joints <= glConfig2.maxVertexSkinningBones ) {
if( IQModel->blendIndexes ) {
indexbuf = (int *)ri.Hunk_AllocateTempMemory( sizeof(int[4]) * IQModel->num_vertexes );
for(int i = 0; i < IQModel->num_vertexes; i++ ) {
indexbuf[ 4 * i + 0 ] = IQModel->blendIndexes[ 4 * i + 0 ];
indexbuf[ 4 * i + 1 ] = IQModel->blendIndexes[ 4 * i + 1 ];
indexbuf[ 4 * i + 2 ] = IQModel->blendIndexes[ 4 * i + 2 ];
indexbuf[ 4 * i + 3 ] = IQModel->blendIndexes[ 4 * i + 3 ];
}
} else {
indexbuf = nullptr;
}
if( IQModel->blendWeights ) {
const float weightscale = 1.0f / 255.0f;
weightbuf = (float *)ri.Hunk_AllocateTempMemory( sizeof(vec4_t) * IQModel->num_vertexes );
for(int i = 0; i < IQModel->num_vertexes; i++ ) {
if( IQModel->blendWeights[ 4 * i + 0 ] == 0 &&
IQModel->blendWeights[ 4 * i + 1 ] == 0 &&
IQModel->blendWeights[ 4 * i + 2 ] == 0 &&
IQModel->blendWeights[ 4 * i + 3 ] == 0 )
IQModel->blendWeights[ 4 * i + 0 ] = 255;
weightbuf[ 4 * i + 0 ] = weightscale * IQModel->blendWeights[ 4 * i + 0 ];
weightbuf[ 4 * i + 1 ] = weightscale * IQModel->blendWeights[ 4 * i + 1 ];
weightbuf[ 4 * i + 2 ] = weightscale * IQModel->blendWeights[ 4 * i + 2 ];
weightbuf[ 4 * i + 3 ] = weightscale * IQModel->blendWeights[ 4 * i + 3 ];
}
} else {
weightbuf = nullptr;
}
qtangentbuf = (i16vec4_t *)ri.Hunk_AllocateTempMemory( sizeof( i16vec4_t ) * IQModel->num_vertexes );
for(int i = 0; i < IQModel->num_vertexes; i++ ) {
R_TBNtoQtangents( &IQModel->tangents[ 3 * i ],
&IQModel->bitangents[ 3 * i ],
&IQModel->normals[ 3 * i ],
qtangentbuf[ i ] );
}
vboData.xyz = (vec3_t *)IQModel->positions;
vboData.qtangent = qtangentbuf;
vboData.numFrames = 0;
vboData.color = (u8vec4_t *)IQModel->colors;
vboData.st = (i16vec2_t *)IQModel->texcoords;
vboData.noLightCoords = true;
vboData.boneIndexes = (int (*)[4])indexbuf;
vboData.boneWeights = (vec4_t *)weightbuf;
vboData.numVerts = IQModel->num_vertexes;
vbo = R_CreateStaticVBO( "IQM surface VBO", vboData,
vboLayout_t::VBO_LAYOUT_SKELETAL );
if( qtangentbuf ) {
ri.Hunk_FreeTempMemory( qtangentbuf );
}
if( weightbuf ) {
ri.Hunk_FreeTempMemory( weightbuf );
}
if( indexbuf ) {
ri.Hunk_FreeTempMemory( indexbuf );
}
// create IBO
ibo = R_CreateStaticIBO( "IQM surface IBO", ( glIndex_t* )IQModel->triangles, IQModel->num_triangles * 3 );
} else {
vbo = nullptr;
ibo = nullptr;
}
// register shaders
// overwrite the material offset with the shader index
mesh = ( iqmMesh_t* )IQMPtr( header, header->ofs_meshes );
surface = IQModel->surfaces;
for(unsigned i = 0; i < header->num_meshes; i++, mesh++, surface++ ) {
surface->surfaceType = surfaceType_t::SF_IQM;
if( mesh->name ) {
surface->name = str;
name = ( char* )IQMPtr( header, header->ofs_text + mesh->name );
len = strlen( name ) + 1;
Com_Memcpy( str, name, len );
str += len;
} else {
surface->name = nullptr;
}
surface->shader = R_FindShader( ( char* )IQMPtr(header, header->ofs_text + mesh->material),
shaderType_t::SHADER_3D_DYNAMIC, RSF_DEFAULT );
if( surface->shader->defaultShader )
surface->shader = tr.defaultShader;
surface->data = IQModel;
surface->first_vertex = mesh->first_vertex;
surface->num_vertexes = mesh->num_vertexes;
surface->first_triangle = mesh->first_triangle;
surface->num_triangles = mesh->num_triangles;
surface->vbo = vbo;
surface->ibo = ibo;
}
// copy model bounds
if(header->ofs_bounds)
{
iqmBounds_t *ptr = ( iqmBounds_t* )IQMPtr( header, header->ofs_bounds );
for(unsigned i = 0; i < header->num_frames; i++)
{
VectorCopy( ptr->bbmin, bounds );
bounds += 3;
VectorCopy( ptr->bbmax, bounds );
bounds += 3;
ptr++;
}
}
// register animations
IQAnim = IQModel->anims;
if( header->num_anims == 1 ) {
RE_RegisterAnimationIQM( mod_name, IQAnim );
}
for(unsigned i = 0; i < header->num_anims; i++, IQAnim++ ) {
char name[ MAX_QPATH ];
Com_sprintf( name, MAX_QPATH, "%s:%s", mod_name, IQAnim->name );
RE_RegisterAnimationIQM( name, IQAnim );
}
// build VBO
return true;
}
/*
=================
R_LoadMDC
=================
*/
qboolean R_LoadMDC( model_t *mod, int lod, void *buffer, int bufferSize, const char *modName )
{
int i, j, k;
mdcHeader_t *mdcModel;
md3Frame_t *mdcFrame;
mdcSurface_t *mdcSurf;
md3Shader_t *mdcShader;
md3Triangle_t *mdcTri;
md3St_t *mdcst;
md3XyzNormal_t *mdcxyz;
mdcXyzCompressed_t *mdcxyzComp;
mdcTag_t *mdcTag;
mdcTagName_t *mdcTagName;
mdvModel_t *mdvModel;
mdvFrame_t *frame;
mdvSurface_t *surf; //, *surface; //unused
srfTriangle_t *tri;
mdvXyz_t *v;
mdvSt_t *st;
mdvTag_t *tag;
mdvTagName_t *tagName;
short *ps;
int version;
int size;
mdcModel = ( mdcHeader_t * ) buffer;
version = LittleLong( mdcModel->version );
if ( version != MDC_VERSION )
{
ri.Printf( PRINT_WARNING, "R_LoadMD3: %s has wrong version (%i should be %i)\n", modName, version, MDC_VERSION );
return qfalse;
}
mod->type = MOD_MESH;
size = LittleLong( mdcModel->ofsEnd );
mod->dataSize += size;
mdvModel = mod->mdv[ lod ] = (mdvModel_t*) ri.Hunk_Alloc( sizeof( mdvModel_t ), h_low );
LL( mdcModel->ident );
LL( mdcModel->version );
LL( mdcModel->numFrames );
LL( mdcModel->numTags );
LL( mdcModel->numSurfaces );
LL( mdcModel->ofsFrames );
LL( mdcModel->ofsTags );
LL( mdcModel->ofsSurfaces );
LL( mdcModel->ofsEnd );
LL( mdcModel->ofsEnd );
LL( mdcModel->flags );
LL( mdcModel->numSkins );
if ( mdcModel->numFrames < 1 )
{
ri.Printf( PRINT_WARNING, "R_LoadMDC: '%s' has no frames\n", modName );
return qfalse;
}
// swap all the frames
mdvModel->numFrames = mdcModel->numFrames;
mdvModel->frames = frame = (mdvFrame_t*) ri.Hunk_Alloc( sizeof( *frame ) * mdcModel->numFrames, h_low );
mdcFrame = ( md3Frame_t * )( ( byte * ) mdcModel + mdcModel->ofsFrames );
for ( i = 0; i < mdcModel->numFrames; i++, frame++, mdcFrame++ )
{
#if 1
// RB: ET HACK
if ( strstr( mod->name, "sherman" ) || strstr( mod->name, "mg42" ) )
{
frame->radius = 256;
for ( j = 0; j < 3; j++ )
{
frame->bounds[ 0 ][ j ] = 128;
frame->bounds[ 1 ][ j ] = -128;
frame->localOrigin[ j ] = LittleFloat( mdcFrame->localOrigin[ j ] );
}
}
else
#endif
{
frame->radius = LittleFloat( mdcFrame->radius );
for ( j = 0; j < 3; j++ )
{
frame->bounds[ 0 ][ j ] = LittleFloat( mdcFrame->bounds[ 0 ][ j ] );
frame->bounds[ 1 ][ j ] = LittleFloat( mdcFrame->bounds[ 1 ][ j ] );
frame->localOrigin[ j ] = LittleFloat( mdcFrame->localOrigin[ j ] );
}
}
}
// swap all the tags
mdvModel->numTags = mdcModel->numTags;
mdvModel->tags = tag = (mdvTag_t*) ri.Hunk_Alloc( sizeof( *tag ) * ( mdcModel->numTags * mdcModel->numFrames ), h_low );
mdcTag = ( mdcTag_t * )( ( byte * ) mdcModel + mdcModel->ofsTags );
for ( i = 0; i < mdcModel->numTags * mdcModel->numFrames; i++, tag++, mdcTag++ )
{
vec3_t angles;
for ( j = 0; j < 3; j++ )
{
tag->origin[ j ] = ( float ) LittleShort( mdcTag->xyz[ j ] ) * MD3_XYZ_SCALE;
angles[ j ] = ( float ) LittleShort( mdcTag->angles[ j ] ) * MDC_TAG_ANGLE_SCALE;
}
AnglesToAxis( angles, tag->axis );
}
mdvModel->tagNames = tagName = (mdvTagName_t*) ri.Hunk_Alloc( sizeof( *tagName ) * ( mdcModel->numTags ), h_low );
mdcTagName = ( mdcTagName_t * )( ( byte * ) mdcModel + mdcModel->ofsTagNames );
for ( i = 0; i < mdcModel->numTags; i++, tagName++, mdcTagName++ )
{
Q_strncpyz( tagName->name, mdcTagName->name, sizeof( tagName->name ) );
}
// swap all the surfaces
mdvModel->numSurfaces = mdcModel->numSurfaces;
mdvModel->surfaces = surf = (mdvSurface_t*) ri.Hunk_Alloc( sizeof( *surf ) * mdcModel->numSurfaces, h_low );
mdcSurf = ( mdcSurface_t * )( ( byte * ) mdcModel + mdcModel->ofsSurfaces );
for ( i = 0; i < mdcModel->numSurfaces; i++ )
{
LL( mdcSurf->ident );
LL( mdcSurf->flags );
LL( mdcSurf->numBaseFrames );
LL( mdcSurf->numCompFrames );
LL( mdcSurf->numShaders );
LL( mdcSurf->numTriangles );
LL( mdcSurf->ofsTriangles );
LL( mdcSurf->numVerts );
LL( mdcSurf->ofsShaders );
LL( mdcSurf->ofsSt );
LL( mdcSurf->ofsXyzNormals );
LL( mdcSurf->ofsXyzNormals );
LL( mdcSurf->ofsXyzCompressed );
LL( mdcSurf->ofsFrameBaseFrames );
LL( mdcSurf->ofsFrameCompFrames );
LL( mdcSurf->ofsEnd );
if ( mdcSurf->numVerts > SHADER_MAX_VERTEXES )
{
ri.Error( ERR_DROP, "R_LoadMDC: %s has more than %i verts on a surface (%i)",
modName, SHADER_MAX_VERTEXES, mdcSurf->numVerts );
}
if ( mdcSurf->numTriangles > SHADER_MAX_TRIANGLES )
{
ri.Error( ERR_DROP, "R_LoadMDC: %s has more than %i triangles on a surface (%i)",
modName, SHADER_MAX_TRIANGLES, mdcSurf->numTriangles );
}
// change to surface identifier
surf->surfaceType = SF_MDV;
// give pointer to model for Tess_SurfaceMDV
surf->model = mdvModel;
// copy surface name
Q_strncpyz( surf->name, mdcSurf->name, sizeof( surf->name ) );
// lowercase the surface name so skin compares are faster
Q_strlwr( surf->name );
// strip off a trailing _1 or _2
// this is a crutch for q3data being a mess
j = strlen( surf->name );
if ( j > 2 && surf->name[ j - 2 ] == '_' )
{
surf->name[ j - 2 ] = 0;
}
// register the shaders
/*
surf->numShaders = md3Surf->numShaders;
surf->shaders = shader = ri.Hunk_Alloc(sizeof(*shader) * md3Surf->numShaders, h_low);
md3Shader = (md3Shader_t *) ((byte *) md3Surf + md3Surf->ofsShaders);
for(j = 0; j < md3Surf->numShaders; j++, shader++, md3Shader++)
{
shader_t *sh;
sh = R_FindShader(md3Shader->name, SHADER_3D_DYNAMIC, RSF_DEFAULT);
if(sh->defaultShader)
{
shader->shaderIndex = 0;
}
else
{
shader->shaderIndex = sh->index;
}
}
*/
// only consider the first shader
mdcShader = ( md3Shader_t * )( ( byte * ) mdcSurf + mdcSurf->ofsShaders );
surf->shader = R_FindShader( mdcShader->name, SHADER_3D_DYNAMIC, RSF_DEFAULT );
// swap all the triangles
surf->numTriangles = mdcSurf->numTriangles;
surf->triangles = tri = (srfTriangle_t*) ri.Hunk_Alloc( sizeof( *tri ) * mdcSurf->numTriangles, h_low );
mdcTri = ( md3Triangle_t * )( ( byte * ) mdcSurf + mdcSurf->ofsTriangles );
for ( j = 0; j < mdcSurf->numTriangles; j++, tri++, mdcTri++ )
{
tri->indexes[ 0 ] = LittleLong( mdcTri->indexes[ 0 ] );
tri->indexes[ 1 ] = LittleLong( mdcTri->indexes[ 1 ] );
tri->indexes[ 2 ] = LittleLong( mdcTri->indexes[ 2 ] );
}
// swap all the XyzNormals
mdcxyz = ( md3XyzNormal_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzNormals );
for ( j = 0; j < mdcSurf->numVerts * mdcSurf->numBaseFrames; j++, mdcxyz++ )
{
mdcxyz->xyz[ 0 ] = LittleShort( mdcxyz->xyz[ 0 ] );
mdcxyz->xyz[ 1 ] = LittleShort( mdcxyz->xyz[ 1 ] );
mdcxyz->xyz[ 2 ] = LittleShort( mdcxyz->xyz[ 2 ] );
mdcxyz->normal = LittleShort( mdcxyz->normal );
}
// swap all the XyzCompressed
mdcxyzComp = ( mdcXyzCompressed_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzCompressed );
for ( j = 0; j < mdcSurf->numVerts * mdcSurf->numCompFrames; j++, mdcxyzComp++ )
{
LL( mdcxyzComp->ofsVec );
}
// swap the frameBaseFrames
ps = ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameBaseFrames );
for ( j = 0; j < mdcModel->numFrames; j++, ps++ )
{
*ps = LittleShort( *ps );
}
// swap the frameCompFrames
ps = ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameCompFrames );
for ( j = 0; j < mdcModel->numFrames; j++, ps++ )
{
*ps = LittleShort( *ps );
}
surf->numVerts = mdcSurf->numVerts;
surf->verts = v = (mdvXyz_t*) ri.Hunk_Alloc( sizeof( *v ) * ( mdcSurf->numVerts * mdcModel->numFrames ), h_low );
for ( j = 0; j < mdcModel->numFrames; j++ )
{
int baseFrame;
int compFrame = 0;
baseFrame = ( int ) * ( ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameBaseFrames ) + j );
mdcxyz = ( md3XyzNormal_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzNormals + baseFrame * mdcSurf->numVerts * sizeof( md3XyzNormal_t ) );
if ( mdcSurf->numCompFrames > 0 )
{
compFrame = ( int ) * ( ( short * )( ( byte * ) mdcSurf + mdcSurf->ofsFrameCompFrames ) + j );
if ( compFrame >= 0 )
{
mdcxyzComp = ( mdcXyzCompressed_t * )( ( byte * ) mdcSurf + mdcSurf->ofsXyzCompressed + compFrame * mdcSurf->numVerts * sizeof( mdcXyzCompressed_t ) );
}
}
for ( k = 0; k < mdcSurf->numVerts; k++, v++, mdcxyz++ )
{
v->xyz[ 0 ] = LittleShort( mdcxyz->xyz[ 0 ] ) * MD3_XYZ_SCALE;
v->xyz[ 1 ] = LittleShort( mdcxyz->xyz[ 1 ] ) * MD3_XYZ_SCALE;
v->xyz[ 2 ] = LittleShort( mdcxyz->xyz[ 2 ] ) * MD3_XYZ_SCALE;
if ( mdcSurf->numCompFrames > 0 && compFrame >= 0 )
{
vec3_t ofsVec;
//vec3_t normal;
R_MDC_DecodeXyzCompressed2( LittleShort( mdcxyzComp->ofsVec ), ofsVec /*, normal*/ );
VectorAdd( v->xyz, ofsVec, v->xyz );
mdcxyzComp++;
}
}
}
// swap all the ST
surf->st = st = (mdvSt_t*) ri.Hunk_Alloc( sizeof( *st ) * mdcSurf->numVerts, h_low );
mdcst = ( md3St_t * )( ( byte * ) mdcSurf + mdcSurf->ofsSt );
for ( j = 0; j < mdcSurf->numVerts; j++, mdcst++, st++ )
{
st->st[ 0 ] = LittleFloat( mdcst->st[ 0 ] );
st->st[ 1 ] = LittleFloat( mdcst->st[ 1 ] );
}
// find the next surface
mdcSurf = ( mdcSurface_t * )( ( byte * ) mdcSurf + mdcSurf->ofsEnd );
surf++;
}
#if 1
// create VBO surfaces from md3 surfaces
{
growList_t vboSurfaces;
srfVBOMDVMesh_t *vboSurf;
vboData_t data;
int f;
Com_InitGrowList( &vboSurfaces, 10 );
for ( i = 0, surf = mdvModel->surfaces; i < mdvModel->numSurfaces; i++, surf++ )
{
//allocate temp memory for vertex data
memset( &data, 0, sizeof( data ) );
data.xyz = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.xyz ) * mdvModel->numFrames * surf->numVerts );
data.normal = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.normal ) * mdvModel->numFrames * surf->numVerts );
data.tangent = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.tangent ) * mdvModel->numFrames * surf->numVerts );
data.binormal = ( vec3_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.binormal ) * mdvModel->numFrames * surf->numVerts );
data.numFrames = mdvModel->numFrames;
data.st = ( vec2_t * ) ri.Hunk_AllocateTempMemory( sizeof( *data.st ) * surf->numVerts );
data.numVerts = surf->numVerts;
// feed vertex XYZ
for ( f = 0; f < mdvModel->numFrames; f++ )
{
for ( j = 0; j < surf->numVerts; j++ )
{
VectorCopy( surf->verts[ f * surf->numVerts + j ].xyz, data.xyz[ f * surf->numVerts + j ] );
}
}
// feed vertex texcoords
for ( j = 0; j < surf->numVerts; j++ )
{
data.st[ j ][ 0 ] = surf->st[ j ].st[ 0 ];
data.st[ j ][ 1 ] = surf->st[ j ].st[ 1 ];
}
// calc and feed tangent spaces
{
const float *v0, *v1, *v2;
const float *t0, *t1, *t2;
vec3_t tangent;
vec3_t binormal;
vec3_t normal;
for ( j = 0; j < ( surf->numVerts * mdvModel->numFrames ); j++ )
{
VectorClear( data.tangent[ j ] );
VectorClear( data.binormal[ j ] );
VectorClear( data.normal[ j ] );
}
for ( f = 0; f < mdvModel->numFrames; f++ )
{
for ( j = 0, tri = surf->triangles; j < surf->numTriangles; j++, tri++ )
{
v0 = surf->verts[ surf->numVerts * f + tri->indexes[ 0 ] ].xyz;
v1 = surf->verts[ surf->numVerts * f + tri->indexes[ 1 ] ].xyz;
v2 = surf->verts[ surf->numVerts * f + tri->indexes[ 2 ] ].xyz;
t0 = surf->st[ tri->indexes[ 0 ] ].st;
t1 = surf->st[ tri->indexes[ 1 ] ].st;
t2 = surf->st[ tri->indexes[ 2 ] ].st;
#if 1
R_CalcTangentSpace( tangent, binormal, normal, v0, v1, v2, t0, t1, t2 );
#else
R_CalcNormalForTriangle( normal, v0, v1, v2 );
R_CalcTangentsForTriangle( tangent, binormal, v0, v1, v2, t0, t1, t2 );
#endif
for ( k = 0; k < 3; k++ )
{
float *v;
v = data.tangent[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, tangent, v );
v = data.binormal[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, binormal, v );
v = data.normal[ surf->numVerts * f + tri->indexes[ k ] ];
VectorAdd( v, normal, v );
}
}
}
for ( j = 0; j < ( surf->numVerts * mdvModel->numFrames ); j++ )
{
VectorNormalize( data.tangent[ j ] );
VectorNormalize( data.binormal[ j ] );
VectorNormalize( data.normal[ j ] );
}
}
//ri.Printf(PRINT_ALL, "...calculating MD3 mesh VBOs ( '%s', %i verts %i tris )\n", surf->name, surf->numVerts, surf->numTriangles);
// create surface
vboSurf = (srfVBOMDVMesh_t*) ri.Hunk_Alloc( sizeof( *vboSurf ), h_low );
Com_AddToGrowList( &vboSurfaces, vboSurf );
vboSurf->surfaceType = SF_VBO_MDVMESH;
vboSurf->mdvModel = mdvModel;
vboSurf->mdvSurface = surf;
vboSurf->numIndexes = surf->numTriangles * 3;
vboSurf->numVerts = surf->numVerts;
vboSurf->ibo = R_CreateStaticIBO2( va( "staticMD3Mesh_IBO %s", surf->name ), surf->numTriangles, surf->triangles );
vboSurf->vbo = R_CreateStaticVBO( va( "staticMD3Mesh_VBO '%s'", surf->name ), data, VBO_LAYOUT_VERTEX_ANIMATION );
ri.Hunk_FreeTempMemory( data.st );
ri.Hunk_FreeTempMemory( data.binormal );
ri.Hunk_FreeTempMemory( data.tangent );
ri.Hunk_FreeTempMemory( data.normal );
ri.Hunk_FreeTempMemory( data.xyz );
}
// move VBO surfaces list to hunk
mdvModel->numVBOSurfaces = vboSurfaces.currentElements;
mdvModel->vboSurfaces = (srfVBOMDVMesh_t**) ri.Hunk_Alloc( mdvModel->numVBOSurfaces * sizeof( *mdvModel->vboSurfaces ), h_low );
for ( i = 0; i < mdvModel->numVBOSurfaces; i++ )
{
mdvModel->vboSurfaces[ i ] = ( srfVBOMDVMesh_t * ) Com_GrowListElement( &vboSurfaces, i );
}
Com_DestroyGrowList( &vboSurfaces );
}
#endif
return qtrue;
}
