The Quake III Arena sources as originally released under the GPL license on August 20, 2005.
This commit is contained in:
commit
dbe4ddb103
1409 changed files with 806066 additions and 0 deletions
700
code/renderer/tr_model.c
Normal file
700
code/renderer/tr_model.c
Normal file
|
@ -0,0 +1,700 @@
|
|||
/*
|
||||
===========================================================================
|
||||
Copyright (C) 1999-2005 Id Software, Inc.
|
||||
|
||||
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 Foobar; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
===========================================================================
|
||||
*/
|
||||
// tr_models.c -- model loading and caching
|
||||
|
||||
#include "tr_local.h"
|
||||
|
||||
#define LL(x) x=LittleLong(x)
|
||||
|
||||
static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *name );
|
||||
static qboolean R_LoadMD4 (model_t *mod, void *buffer, const char *name );
|
||||
|
||||
model_t *loadmodel;
|
||||
|
||||
/*
|
||||
** R_GetModelByHandle
|
||||
*/
|
||||
model_t *R_GetModelByHandle( qhandle_t index ) {
|
||||
model_t *mod;
|
||||
|
||||
// out of range gets the defualt model
|
||||
if ( index < 1 || index >= tr.numModels ) {
|
||||
return tr.models[0];
|
||||
}
|
||||
|
||||
mod = tr.models[index];
|
||||
|
||||
return mod;
|
||||
}
|
||||
|
||||
//===============================================================================
|
||||
|
||||
/*
|
||||
** R_AllocModel
|
||||
*/
|
||||
model_t *R_AllocModel( void ) {
|
||||
model_t *mod;
|
||||
|
||||
if ( tr.numModels == MAX_MOD_KNOWN ) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
mod = ri.Hunk_Alloc( sizeof( *tr.models[tr.numModels] ), h_low );
|
||||
mod->index = tr.numModels;
|
||||
tr.models[tr.numModels] = mod;
|
||||
tr.numModels++;
|
||||
|
||||
return mod;
|
||||
}
|
||||
|
||||
/*
|
||||
====================
|
||||
RE_RegisterModel
|
||||
|
||||
Loads in a model for the given name
|
||||
|
||||
Zero will be returned if the model fails to load.
|
||||
An entry will be retained for failed models as an
|
||||
optimization to prevent disk rescanning if they are
|
||||
asked for again.
|
||||
====================
|
||||
*/
|
||||
qhandle_t RE_RegisterModel( const char *name ) {
|
||||
model_t *mod;
|
||||
unsigned *buf;
|
||||
int lod;
|
||||
int ident;
|
||||
qboolean loaded;
|
||||
qhandle_t hModel;
|
||||
int numLoaded;
|
||||
|
||||
if ( !name || !name[0] ) {
|
||||
ri.Printf( PRINT_ALL, "RE_RegisterModel: NULL name\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ( strlen( name ) >= MAX_QPATH ) {
|
||||
Com_Printf( "Model name exceeds MAX_QPATH\n" );
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// search the currently loaded models
|
||||
//
|
||||
for ( hModel = 1 ; hModel < tr.numModels; hModel++ ) {
|
||||
mod = tr.models[hModel];
|
||||
if ( !strcmp( mod->name, name ) ) {
|
||||
if( mod->type == MOD_BAD ) {
|
||||
return 0;
|
||||
}
|
||||
return hModel;
|
||||
}
|
||||
}
|
||||
|
||||
// allocate a new model_t
|
||||
|
||||
if ( ( mod = R_AllocModel() ) == NULL ) {
|
||||
ri.Printf( PRINT_WARNING, "RE_RegisterModel: R_AllocModel() failed for '%s'\n", name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// only set the name after the model has been successfully loaded
|
||||
Q_strncpyz( mod->name, name, sizeof( mod->name ) );
|
||||
|
||||
|
||||
// make sure the render thread is stopped
|
||||
R_SyncRenderThread();
|
||||
|
||||
mod->numLods = 0;
|
||||
|
||||
//
|
||||
// load the files
|
||||
//
|
||||
numLoaded = 0;
|
||||
|
||||
for ( lod = MD3_MAX_LODS - 1 ; lod >= 0 ; lod-- ) {
|
||||
char filename[1024];
|
||||
|
||||
strcpy( filename, name );
|
||||
|
||||
if ( lod != 0 ) {
|
||||
char namebuf[80];
|
||||
|
||||
if ( strrchr( filename, '.' ) ) {
|
||||
*strrchr( filename, '.' ) = 0;
|
||||
}
|
||||
sprintf( namebuf, "_%d.md3", lod );
|
||||
strcat( filename, namebuf );
|
||||
}
|
||||
|
||||
ri.FS_ReadFile( filename, (void **)&buf );
|
||||
if ( !buf ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
loadmodel = mod;
|
||||
|
||||
ident = LittleLong(*(unsigned *)buf);
|
||||
if ( ident == MD4_IDENT ) {
|
||||
loaded = R_LoadMD4( mod, buf, name );
|
||||
} else {
|
||||
if ( ident != MD3_IDENT ) {
|
||||
ri.Printf (PRINT_WARNING,"RE_RegisterModel: unknown fileid for %s\n", name);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
loaded = R_LoadMD3( mod, lod, buf, name );
|
||||
}
|
||||
|
||||
ri.FS_FreeFile (buf);
|
||||
|
||||
if ( !loaded ) {
|
||||
if ( lod == 0 ) {
|
||||
goto fail;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
mod->numLods++;
|
||||
numLoaded++;
|
||||
// if we have a valid model and are biased
|
||||
// so that we won't see any higher detail ones,
|
||||
// stop loading them
|
||||
// if ( lod <= r_lodbias->integer ) {
|
||||
// break;
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
if ( numLoaded ) {
|
||||
// duplicate into higher lod spots that weren't
|
||||
// loaded, in case the user changes r_lodbias on the fly
|
||||
for ( lod-- ; lod >= 0 ; lod-- ) {
|
||||
mod->numLods++;
|
||||
mod->md3[lod] = mod->md3[lod+1];
|
||||
}
|
||||
|
||||
return mod->index;
|
||||
}
|
||||
#ifdef _DEBUG
|
||||
else {
|
||||
ri.Printf (PRINT_WARNING,"RE_RegisterModel: couldn't load %s\n", name);
|
||||
}
|
||||
#endif
|
||||
|
||||
fail:
|
||||
// we still keep the model_t around, so if the model name is asked for
|
||||
// again, we won't bother scanning the filesystem
|
||||
mod->type = MOD_BAD;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
=================
|
||||
R_LoadMD3
|
||||
=================
|
||||
*/
|
||||
static qboolean R_LoadMD3 (model_t *mod, int lod, void *buffer, const char *mod_name ) {
|
||||
int i, j;
|
||||
md3Header_t *pinmodel;
|
||||
md3Frame_t *frame;
|
||||
md3Surface_t *surf;
|
||||
md3Shader_t *shader;
|
||||
md3Triangle_t *tri;
|
||||
md3St_t *st;
|
||||
md3XyzNormal_t *xyz;
|
||||
md3Tag_t *tag;
|
||||
int version;
|
||||
int size;
|
||||
|
||||
pinmodel = (md3Header_t *)buffer;
|
||||
|
||||
version = LittleLong (pinmodel->version);
|
||||
if (version != MD3_VERSION) {
|
||||
ri.Printf( PRINT_WARNING, "R_LoadMD3: %s has wrong version (%i should be %i)\n",
|
||||
mod_name, version, MD3_VERSION);
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
mod->type = MOD_MESH;
|
||||
size = LittleLong(pinmodel->ofsEnd);
|
||||
mod->dataSize += size;
|
||||
mod->md3[lod] = ri.Hunk_Alloc( size, h_low );
|
||||
|
||||
Com_Memcpy (mod->md3[lod], buffer, LittleLong(pinmodel->ofsEnd) );
|
||||
|
||||
LL(mod->md3[lod]->ident);
|
||||
LL(mod->md3[lod]->version);
|
||||
LL(mod->md3[lod]->numFrames);
|
||||
LL(mod->md3[lod]->numTags);
|
||||
LL(mod->md3[lod]->numSurfaces);
|
||||
LL(mod->md3[lod]->ofsFrames);
|
||||
LL(mod->md3[lod]->ofsTags);
|
||||
LL(mod->md3[lod]->ofsSurfaces);
|
||||
LL(mod->md3[lod]->ofsEnd);
|
||||
|
||||
if ( mod->md3[lod]->numFrames < 1 ) {
|
||||
ri.Printf( PRINT_WARNING, "R_LoadMD3: %s has no frames\n", mod_name );
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
// swap all the frames
|
||||
frame = (md3Frame_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsFrames );
|
||||
for ( i = 0 ; i < mod->md3[lod]->numFrames ; i++, frame++) {
|
||||
frame->radius = LittleFloat( frame->radius );
|
||||
for ( j = 0 ; j < 3 ; j++ ) {
|
||||
frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
|
||||
frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
|
||||
frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
|
||||
}
|
||||
}
|
||||
|
||||
// swap all the tags
|
||||
tag = (md3Tag_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsTags );
|
||||
for ( i = 0 ; i < mod->md3[lod]->numTags * mod->md3[lod]->numFrames ; i++, tag++) {
|
||||
for ( j = 0 ; j < 3 ; j++ ) {
|
||||
tag->origin[j] = LittleFloat( tag->origin[j] );
|
||||
tag->axis[0][j] = LittleFloat( tag->axis[0][j] );
|
||||
tag->axis[1][j] = LittleFloat( tag->axis[1][j] );
|
||||
tag->axis[2][j] = LittleFloat( tag->axis[2][j] );
|
||||
}
|
||||
}
|
||||
|
||||
// swap all the surfaces
|
||||
surf = (md3Surface_t *) ( (byte *)mod->md3[lod] + mod->md3[lod]->ofsSurfaces );
|
||||
for ( i = 0 ; i < mod->md3[lod]->numSurfaces ; i++) {
|
||||
|
||||
LL(surf->ident);
|
||||
LL(surf->flags);
|
||||
LL(surf->numFrames);
|
||||
LL(surf->numShaders);
|
||||
LL(surf->numTriangles);
|
||||
LL(surf->ofsTriangles);
|
||||
LL(surf->numVerts);
|
||||
LL(surf->ofsShaders);
|
||||
LL(surf->ofsSt);
|
||||
LL(surf->ofsXyzNormals);
|
||||
LL(surf->ofsEnd);
|
||||
|
||||
if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
|
||||
ri.Error (ERR_DROP, "R_LoadMD3: %s has more than %i verts on a surface (%i)",
|
||||
mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
|
||||
}
|
||||
if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
|
||||
ri.Error (ERR_DROP, "R_LoadMD3: %s has more than %i triangles on a surface (%i)",
|
||||
mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
|
||||
}
|
||||
|
||||
// change to surface identifier
|
||||
surf->ident = SF_MD3;
|
||||
|
||||
// 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
|
||||
shader = (md3Shader_t *) ( (byte *)surf + surf->ofsShaders );
|
||||
for ( j = 0 ; j < surf->numShaders ; j++, shader++ ) {
|
||||
shader_t *sh;
|
||||
|
||||
sh = R_FindShader( shader->name, LIGHTMAP_NONE, qtrue );
|
||||
if ( sh->defaultShader ) {
|
||||
shader->shaderIndex = 0;
|
||||
} else {
|
||||
shader->shaderIndex = sh->index;
|
||||
}
|
||||
}
|
||||
|
||||
// swap all the triangles
|
||||
tri = (md3Triangle_t *) ( (byte *)surf + surf->ofsTriangles );
|
||||
for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) {
|
||||
LL(tri->indexes[0]);
|
||||
LL(tri->indexes[1]);
|
||||
LL(tri->indexes[2]);
|
||||
}
|
||||
|
||||
// swap all the ST
|
||||
st = (md3St_t *) ( (byte *)surf + surf->ofsSt );
|
||||
for ( j = 0 ; j < surf->numVerts ; j++, st++ ) {
|
||||
st->st[0] = LittleFloat( st->st[0] );
|
||||
st->st[1] = LittleFloat( st->st[1] );
|
||||
}
|
||||
|
||||
// swap all the XyzNormals
|
||||
xyz = (md3XyzNormal_t *) ( (byte *)surf + surf->ofsXyzNormals );
|
||||
for ( j = 0 ; j < surf->numVerts * surf->numFrames ; j++, xyz++ )
|
||||
{
|
||||
xyz->xyz[0] = LittleShort( xyz->xyz[0] );
|
||||
xyz->xyz[1] = LittleShort( xyz->xyz[1] );
|
||||
xyz->xyz[2] = LittleShort( xyz->xyz[2] );
|
||||
|
||||
xyz->normal = LittleShort( xyz->normal );
|
||||
}
|
||||
|
||||
|
||||
// find the next surface
|
||||
surf = (md3Surface_t *)( (byte *)surf + surf->ofsEnd );
|
||||
}
|
||||
|
||||
return qtrue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
=================
|
||||
R_LoadMD4
|
||||
=================
|
||||
*/
|
||||
static qboolean R_LoadMD4( model_t *mod, void *buffer, const char *mod_name ) {
|
||||
int i, j, k, lodindex;
|
||||
md4Header_t *pinmodel, *md4;
|
||||
md4Frame_t *frame;
|
||||
md4LOD_t *lod;
|
||||
md4Surface_t *surf;
|
||||
md4Triangle_t *tri;
|
||||
md4Vertex_t *v;
|
||||
int version;
|
||||
int size;
|
||||
shader_t *sh;
|
||||
int frameSize;
|
||||
|
||||
pinmodel = (md4Header_t *)buffer;
|
||||
|
||||
version = LittleLong (pinmodel->version);
|
||||
if (version != MD4_VERSION) {
|
||||
ri.Printf( PRINT_WARNING, "R_LoadMD4: %s has wrong version (%i should be %i)\n",
|
||||
mod_name, version, MD4_VERSION);
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
mod->type = MOD_MD4;
|
||||
size = LittleLong(pinmodel->ofsEnd);
|
||||
mod->dataSize += size;
|
||||
md4 = mod->md4 = ri.Hunk_Alloc( size, h_low );
|
||||
|
||||
Com_Memcpy( md4, buffer, LittleLong(pinmodel->ofsEnd) );
|
||||
|
||||
LL(md4->ident);
|
||||
LL(md4->version);
|
||||
LL(md4->numFrames);
|
||||
LL(md4->numBones);
|
||||
LL(md4->numLODs);
|
||||
LL(md4->ofsFrames);
|
||||
LL(md4->ofsLODs);
|
||||
LL(md4->ofsEnd);
|
||||
|
||||
if ( md4->numFrames < 1 ) {
|
||||
ri.Printf( PRINT_WARNING, "R_LoadMD4: %s has no frames\n", mod_name );
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
// we don't need to swap tags in the renderer, they aren't used
|
||||
|
||||
// swap all the frames
|
||||
frameSize = (int)( &((md4Frame_t *)0)->bones[ md4->numBones ] );
|
||||
for ( i = 0 ; i < md4->numFrames ; i++, frame++) {
|
||||
frame = (md4Frame_t *) ( (byte *)md4 + md4->ofsFrames + i * frameSize );
|
||||
frame->radius = LittleFloat( frame->radius );
|
||||
for ( j = 0 ; j < 3 ; j++ ) {
|
||||
frame->bounds[0][j] = LittleFloat( frame->bounds[0][j] );
|
||||
frame->bounds[1][j] = LittleFloat( frame->bounds[1][j] );
|
||||
frame->localOrigin[j] = LittleFloat( frame->localOrigin[j] );
|
||||
}
|
||||
for ( j = 0 ; j < md4->numBones * sizeof( md4Bone_t ) / 4 ; j++ ) {
|
||||
((float *)frame->bones)[j] = LittleFloat( ((float *)frame->bones)[j] );
|
||||
}
|
||||
}
|
||||
|
||||
// swap all the LOD's
|
||||
lod = (md4LOD_t *) ( (byte *)md4 + md4->ofsLODs );
|
||||
for ( lodindex = 0 ; lodindex < md4->numLODs ; lodindex++ ) {
|
||||
|
||||
// swap all the surfaces
|
||||
surf = (md4Surface_t *) ( (byte *)lod + lod->ofsSurfaces );
|
||||
for ( i = 0 ; i < lod->numSurfaces ; i++) {
|
||||
LL(surf->ident);
|
||||
LL(surf->numTriangles);
|
||||
LL(surf->ofsTriangles);
|
||||
LL(surf->numVerts);
|
||||
LL(surf->ofsVerts);
|
||||
LL(surf->ofsEnd);
|
||||
|
||||
if ( surf->numVerts > SHADER_MAX_VERTEXES ) {
|
||||
ri.Error (ERR_DROP, "R_LoadMD3: %s has more than %i verts on a surface (%i)",
|
||||
mod_name, SHADER_MAX_VERTEXES, surf->numVerts );
|
||||
}
|
||||
if ( surf->numTriangles*3 > SHADER_MAX_INDEXES ) {
|
||||
ri.Error (ERR_DROP, "R_LoadMD3: %s has more than %i triangles on a surface (%i)",
|
||||
mod_name, SHADER_MAX_INDEXES / 3, surf->numTriangles );
|
||||
}
|
||||
|
||||
// change to surface identifier
|
||||
surf->ident = SF_MD4;
|
||||
|
||||
// lowercase the surface name so skin compares are faster
|
||||
Q_strlwr( surf->name );
|
||||
|
||||
// register the shaders
|
||||
sh = R_FindShader( surf->shader, LIGHTMAP_NONE, qtrue );
|
||||
if ( sh->defaultShader ) {
|
||||
surf->shaderIndex = 0;
|
||||
} else {
|
||||
surf->shaderIndex = sh->index;
|
||||
}
|
||||
|
||||
// swap all the triangles
|
||||
tri = (md4Triangle_t *) ( (byte *)surf + surf->ofsTriangles );
|
||||
for ( j = 0 ; j < surf->numTriangles ; j++, tri++ ) {
|
||||
LL(tri->indexes[0]);
|
||||
LL(tri->indexes[1]);
|
||||
LL(tri->indexes[2]);
|
||||
}
|
||||
|
||||
// swap all the vertexes
|
||||
// FIXME
|
||||
// This makes TFC's skeletons work. Shouldn't be necessary anymore, but left
|
||||
// in for reference.
|
||||
//v = (md4Vertex_t *) ( (byte *)surf + surf->ofsVerts + 12);
|
||||
v = (md4Vertex_t *) ( (byte *)surf + surf->ofsVerts);
|
||||
for ( j = 0 ; j < surf->numVerts ; j++ ) {
|
||||
v->normal[0] = LittleFloat( v->normal[0] );
|
||||
v->normal[1] = LittleFloat( v->normal[1] );
|
||||
v->normal[2] = LittleFloat( v->normal[2] );
|
||||
|
||||
v->texCoords[0] = LittleFloat( v->texCoords[0] );
|
||||
v->texCoords[1] = LittleFloat( v->texCoords[1] );
|
||||
|
||||
v->numWeights = LittleLong( v->numWeights );
|
||||
|
||||
for ( k = 0 ; k < v->numWeights ; k++ ) {
|
||||
v->weights[k].boneIndex = LittleLong( v->weights[k].boneIndex );
|
||||
v->weights[k].boneWeight = LittleFloat( v->weights[k].boneWeight );
|
||||
v->weights[k].offset[0] = LittleFloat( v->weights[k].offset[0] );
|
||||
v->weights[k].offset[1] = LittleFloat( v->weights[k].offset[1] );
|
||||
v->weights[k].offset[2] = LittleFloat( v->weights[k].offset[2] );
|
||||
}
|
||||
// FIXME
|
||||
// This makes TFC's skeletons work. Shouldn't be necessary anymore, but left
|
||||
// in for reference.
|
||||
//v = (md4Vertex_t *)( ( byte * )&v->weights[v->numWeights] + 12 );
|
||||
v = (md4Vertex_t *)( ( byte * )&v->weights[v->numWeights]);
|
||||
}
|
||||
|
||||
// find the next surface
|
||||
surf = (md4Surface_t *)( (byte *)surf + surf->ofsEnd );
|
||||
}
|
||||
|
||||
// find the next LOD
|
||||
lod = (md4LOD_t *)( (byte *)lod + lod->ofsEnd );
|
||||
}
|
||||
|
||||
return qtrue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
/*
|
||||
** RE_BeginRegistration
|
||||
*/
|
||||
void RE_BeginRegistration( glconfig_t *glconfigOut ) {
|
||||
|
||||
R_Init();
|
||||
|
||||
*glconfigOut = glConfig;
|
||||
|
||||
R_SyncRenderThread();
|
||||
|
||||
tr.viewCluster = -1; // force markleafs to regenerate
|
||||
R_ClearFlares();
|
||||
RE_ClearScene();
|
||||
|
||||
tr.registered = qtrue;
|
||||
|
||||
// NOTE: this sucks, for some reason the first stretch pic is never drawn
|
||||
// without this we'd see a white flash on a level load because the very
|
||||
// first time the level shot would not be drawn
|
||||
RE_StretchPic(0, 0, 0, 0, 0, 0, 1, 1, 0);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
/*
|
||||
===============
|
||||
R_ModelInit
|
||||
===============
|
||||
*/
|
||||
void R_ModelInit( void ) {
|
||||
model_t *mod;
|
||||
|
||||
// leave a space for NULL model
|
||||
tr.numModels = 0;
|
||||
|
||||
mod = R_AllocModel();
|
||||
mod->type = MOD_BAD;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
R_Modellist_f
|
||||
================
|
||||
*/
|
||||
void R_Modellist_f( void ) {
|
||||
int i, j;
|
||||
model_t *mod;
|
||||
int total;
|
||||
int lods;
|
||||
|
||||
total = 0;
|
||||
for ( i = 1 ; i < tr.numModels; i++ ) {
|
||||
mod = tr.models[i];
|
||||
lods = 1;
|
||||
for ( j = 1 ; j < MD3_MAX_LODS ; j++ ) {
|
||||
if ( mod->md3[j] && mod->md3[j] != mod->md3[j-1] ) {
|
||||
lods++;
|
||||
}
|
||||
}
|
||||
ri.Printf( PRINT_ALL, "%8i : (%i) %s\n",mod->dataSize, lods, mod->name );
|
||||
total += mod->dataSize;
|
||||
}
|
||||
ri.Printf( PRINT_ALL, "%8i : Total models\n", total );
|
||||
|
||||
#if 0 // not working right with new hunk
|
||||
if ( tr.world ) {
|
||||
ri.Printf( PRINT_ALL, "\n%8i : %s\n", tr.world->dataSize, tr.world->name );
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
R_GetTag
|
||||
================
|
||||
*/
|
||||
static md3Tag_t *R_GetTag( md3Header_t *mod, int frame, const char *tagName ) {
|
||||
md3Tag_t *tag;
|
||||
int i;
|
||||
|
||||
if ( frame >= mod->numFrames ) {
|
||||
// it is possible to have a bad frame while changing models, so don't error
|
||||
frame = mod->numFrames - 1;
|
||||
}
|
||||
|
||||
tag = (md3Tag_t *)((byte *)mod + mod->ofsTags) + frame * mod->numTags;
|
||||
for ( i = 0 ; i < mod->numTags ; i++, tag++ ) {
|
||||
if ( !strcmp( tag->name, tagName ) ) {
|
||||
return tag; // found it
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
R_LerpTag
|
||||
================
|
||||
*/
|
||||
int R_LerpTag( orientation_t *tag, qhandle_t handle, int startFrame, int endFrame,
|
||||
float frac, const char *tagName ) {
|
||||
md3Tag_t *start, *end;
|
||||
int i;
|
||||
float frontLerp, backLerp;
|
||||
model_t *model;
|
||||
|
||||
model = R_GetModelByHandle( handle );
|
||||
if ( !model->md3[0] ) {
|
||||
AxisClear( tag->axis );
|
||||
VectorClear( tag->origin );
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
start = R_GetTag( model->md3[0], startFrame, tagName );
|
||||
end = R_GetTag( model->md3[0], endFrame, tagName );
|
||||
if ( !start || !end ) {
|
||||
AxisClear( tag->axis );
|
||||
VectorClear( tag->origin );
|
||||
return qfalse;
|
||||
}
|
||||
|
||||
frontLerp = frac;
|
||||
backLerp = 1.0f - frac;
|
||||
|
||||
for ( i = 0 ; i < 3 ; i++ ) {
|
||||
tag->origin[i] = start->origin[i] * backLerp + end->origin[i] * frontLerp;
|
||||
tag->axis[0][i] = start->axis[0][i] * backLerp + end->axis[0][i] * frontLerp;
|
||||
tag->axis[1][i] = start->axis[1][i] * backLerp + end->axis[1][i] * frontLerp;
|
||||
tag->axis[2][i] = start->axis[2][i] * backLerp + end->axis[2][i] * frontLerp;
|
||||
}
|
||||
VectorNormalize( tag->axis[0] );
|
||||
VectorNormalize( tag->axis[1] );
|
||||
VectorNormalize( tag->axis[2] );
|
||||
return qtrue;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
====================
|
||||
R_ModelBounds
|
||||
====================
|
||||
*/
|
||||
void R_ModelBounds( qhandle_t handle, vec3_t mins, vec3_t maxs ) {
|
||||
model_t *model;
|
||||
md3Header_t *header;
|
||||
md3Frame_t *frame;
|
||||
|
||||
model = R_GetModelByHandle( handle );
|
||||
|
||||
if ( model->bmodel ) {
|
||||
VectorCopy( model->bmodel->bounds[0], mins );
|
||||
VectorCopy( model->bmodel->bounds[1], maxs );
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !model->md3[0] ) {
|
||||
VectorClear( mins );
|
||||
VectorClear( maxs );
|
||||
return;
|
||||
}
|
||||
|
||||
header = model->md3[0];
|
||||
|
||||
frame = (md3Frame_t *)( (byte *)header + header->ofsFrames );
|
||||
|
||||
VectorCopy( frame->bounds[0], mins );
|
||||
VectorCopy( frame->bounds[1], maxs );
|
||||
}
|
Loading…
Add table
Add a link
Reference in a new issue