Initial import of the new Q2PRO tree.

1 files changed, 981 insertions, 0 deletions

diff --git a/source/gl_models.c b/source/gl_models.c
new file mode 100644
index 0000000..9626ebe
--- /dev/null
+++ b/source/gl_models.c
@@ -0,0 +1,981 @@
+/*
+Copyright (C) 2003-2006 Andrey Nazarov
+
+This program 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.
+
+This program 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 this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+
+#include "gl_local.h"
+
+#define Model_Malloc( size )	sys.HunkAlloc( &model->pool, size )
+
+static model_t		r_models[MAX_MODELS];
+static int			r_numModels;
+
+static byte         ll2byte[256][256];
+
+static cvar_t       *gl_override_models;
+
+static model_t *Model_Alloc( const char *name ) {
+	model_t *model;
+	int i;
+
+	for( i = 0, model = r_models; i < r_numModels; i++, model++ ) {
+		if( !model->name[0] ) {
+			break;
+		}
+	}
+
+	if( i == r_numModels ) {
+		if( r_numModels == MAX_MODELS ) {
+			Com_Error( ERR_DROP, "Model_Alloc: MAX_MODELS" );
+		}
+		r_numModels++;
+	}
+
+	strcpy( model->name, name );
+	model->registration_sequence = registration_sequence;
+	model->type = MODEL_NULL;
+
+	return model;
+}
+
+static model_t *Model_Find( const char *name ) {
+	model_t *model;
+	aliasMesh_t *mesh;
+	int i, j;
+
+	for( i = 0, model = r_models; i < r_numModels; i++, model++ ) {
+		if( !model->name[0] ) {
+			continue;
+		}
+		if( !Q_stricmp( model->name, name ) ) {
+			break;
+		}
+	}
+
+	if( i == r_numModels ) {
+		return NULL;
+	}
+
+	switch( model->type ) {
+	case MODEL_ALIAS:
+		for( i = 0; i < model->numMeshes; i++ ) {
+			mesh = &model->meshes[i];
+			for( j = 0; j < mesh->numSkins; j++ ) {
+				mesh->skins[j]->registration_sequence = registration_sequence;
+			}
+		}
+		break;
+	case MODEL_SPRITE:
+		for( i = 0; i < model->numFrames; i++ ) {
+			model->sframes[i].image->registration_sequence = registration_sequence;
+		}
+		break;
+	default:
+		Com_Error( ERR_DROP, "Model_Find: bad model type: %d", model->type );
+		break;
+	}
+
+	model->registration_sequence = registration_sequence;
+	return model;
+}
+
+static void Model_List_f( void ) {
+	int		i;
+	model_t	*model;
+	int		bytes;
+
+	Com_Printf( "------------------\n");
+	bytes = 0;
+
+	for( i = 0, model = r_models; i < r_numModels; i++, model++ ) {
+		if( !model->name[0] ) {
+			continue;
+		}
+
+		Com_Printf( "%8i : %s\n", model->pool.cursize, model->name );
+		bytes += model->pool.cursize;
+	}
+	Com_Printf( "Total resident: %i\n", bytes );
+}
+
+void Model_FreeUnused( void ) {
+	model_t *model;
+	int i;
+
+	for( i = 0, model = r_models; i < r_numModels; i++, model++ ) {
+		if( !model->name[0] ) {
+			continue;
+		}
+		if( model->registration_sequence != registration_sequence ) {
+			sys.HunkFree( &model->pool );
+			model->name[0] = 0;
+		}
+	}
+}
+
+void Model_FreeAll( void ) {
+	model_t *model;
+	int i;
+
+	for( i = 0, model = r_models; i < r_numModels; i++, model++ ) {
+		if( !model->name[0] ) {
+			continue;
+		}
+
+		sys.HunkFree( &model->pool );
+		model->name[0] = 0;
+	}
+
+	r_numModels = 0;
+}
+
+static qboolean Model_LoadMd2( model_t *model, const byte *rawdata, int length ) {
+	dmdl_t header;
+	daliasframe_t *src_frame;
+	dtrivertx_t *src_vert;
+	dtriangle_t *src_tri;
+	dstvert_t *src_tc;
+	aliasFrame_t *dst_frame;
+	aliasVert_t *dst_vert;
+	aliasMesh_t *dst_mesh;
+	uint32 *finalIndices;
+	tcoord_t *dst_tc;
+	int i, j, k;
+	uint16 remap[MAX_TRIANGLES*3];
+	uint16 vertIndices[MAX_TRIANGLES*3];
+	uint16 tcIndices[MAX_TRIANGLES*3];
+	int numVerts, numIndices;
+	char skinname[MAX_QPATH];
+	char *src_skin;
+	image_t *skin;
+	vec_t scaleS, scaleT;
+	int offset, val;
+	vec3_t mins, maxs;
+	const byte *rawend;
+
+	if( length < sizeof( header ) ) {
+		Com_EPrintf( "%s has length < header length\n", model->name );
+		return qfalse;
+	}
+
+	/* byte swap the header */
+	header = *( dmdl_t * )rawdata;
+	for( i = 0; i < sizeof( header )/4; i++ ) {
+		(( uint32 * )&header)[i] = LittleLong( (( uint32 * )&header)[i] );
+	}
+
+	if( header.ident != IDALIASHEADER ) {
+		Com_EPrintf( "%s is not an MD2 file\n", model->name );
+		return qfalse;
+	}
+
+	if( header.version != ALIAS_VERSION ) {
+		Com_EPrintf( "%s has bad version: %d != %d\n",
+			model->name, header.version, ALIAS_VERSION );
+		return qfalse;
+	}
+
+	if( header.num_frames < 1 ) {
+		Com_EPrintf( "%s has bad number of frames: %d\n",
+			model->name, header.num_frames );
+		return qfalse;
+	}
+	if( header.num_frames > MAX_FRAMES ) {
+		Com_EPrintf( "%s has too many frames: %d > %d\n",
+			model->name, header.num_frames, MAX_FRAMES );
+		return qfalse;
+	}
+	if( header.num_tris < 1 ) {
+		Com_EPrintf( "%s has bad number of triangles: %d\n",
+			model->name, header.num_tris );
+		return qfalse;
+	}
+	if( header.num_tris > MAX_TRIANGLES ) {
+		Com_EPrintf( "%s has too many triangles: %d > %d\n",
+			model->name, header.num_tris, MAX_TRIANGLES );
+		return qfalse;
+	}
+	if( ( uint32 )header.num_skins > MAX_MD2SKINS ) {
+		Com_EPrintf( "%s has too many skins: %d > %d\n",
+			model->name, header.num_skins, MAX_MD2SKINS );
+		return qfalse;
+	}
+
+	if( header.skinwidth <= 0 || header.skinheight <= 0 ) {
+		Com_EPrintf( "%s has bad skin dimensions: %d x %d\n",
+			model->name, header.skinwidth, header.skinheight );
+		return qfalse;
+	}
+
+	rawend = rawdata + length;
+
+	model->type = MODEL_ALIAS;
+	sys.HunkBegin( &model->pool, 0x400000 );
+
+	/* load all triangle indices */
+	src_tri = ( dtriangle_t * )( ( byte * )rawdata + header.ofs_tris );
+	if( ( byte * )( src_tri + header.num_tris ) > rawend ) {
+		Com_EPrintf( "%s has bad triangles offset\n", model->name );
+		goto fail;
+	}
+	for( i = 0; i < header.num_tris; i++ ) {
+		vertIndices[i*3+0] = LittleShort( src_tri->index_xyz[0] );
+		vertIndices[i*3+1] = LittleShort( src_tri->index_xyz[1] );
+		vertIndices[i*3+2] = LittleShort( src_tri->index_xyz[2] );
+		
+		tcIndices[i*3+0] = LittleShort( src_tri->index_st[0] );
+		tcIndices[i*3+1] = LittleShort( src_tri->index_st[1] );
+		tcIndices[i*3+2] = LittleShort( src_tri->index_st[2] );
+
+		src_tri++;
+	}
+
+	numIndices = header.num_tris * 3;
+
+	model->meshes = Model_Malloc( sizeof( aliasMesh_t ) );
+	model->numMeshes = 1;
+
+	dst_mesh = model->meshes;
+	dst_mesh->indices = Model_Malloc( numIndices * sizeof( uint32 ) );
+	dst_mesh->numTris = header.num_tris;
+	dst_mesh->numIndices = numIndices;
+
+	for( i = 0; i < numIndices; i++ ) {
+		remap[i] = 0xFFFF;
+	}
+
+	numVerts = 0;
+	src_tc = ( dstvert_t * )( ( byte * )rawdata + header.ofs_st );
+	finalIndices = dst_mesh->indices;
+	for( i = 0; i < numIndices; i++ ) {
+		if( remap[i] != 0xFFFF ) {
+			continue; /* already remapped */
+		}
+
+		for( j = i + 1; j < numIndices; j++ ) {
+			if( vertIndices[i] == vertIndices[j] &&
+				( src_tc[tcIndices[i]].s == src_tc[tcIndices[j]].s &&
+					src_tc[tcIndices[i]].t == src_tc[tcIndices[j]].t ) )
+			{
+				/* duplicate vertex */
+				remap[j] = i;
+				finalIndices[j] = numVerts;
+			} 
+		}
+
+		/* new vertex */
+		remap[i] = i;
+		finalIndices[i] = numVerts++;
+	}
+
+	dst_mesh->verts = Model_Malloc( numVerts * header.num_frames * sizeof( aliasVert_t ) );
+	dst_mesh->tcoords = Model_Malloc( numVerts * sizeof( tcoord_t ) );
+	dst_mesh->numVerts = numVerts;
+
+	/* load all skins */
+	src_skin = ( char * )rawdata + header.ofs_skins;
+	if( ( byte * )( src_skin + MAX_SKINNAME * header.num_skins ) > rawend ) {
+		Com_EPrintf( "%s has bad skins offset\n", model->name );
+		goto fail;
+	}
+	for( i = 0; i < header.num_skins; i++ ) {
+		Q_strncpyz( skinname, src_skin, sizeof( skinname ) );
+		skin = R_FindImage( skinname, it_skin );
+		if( !skin ) {
+			skin = r_notexture;
+		}
+		dst_mesh->skins[i] = skin;
+		src_skin += MAX_SKINNAME;
+	}
+	dst_mesh->numSkins = header.num_skins;
+
+	/* load all tcoords */
+	src_tc = ( dstvert_t * )( ( byte * )rawdata + header.ofs_st );
+	dst_tc = dst_mesh->tcoords;
+	skin = dst_mesh->skins[0];
+	scaleS = 1.0f / header.skinwidth;
+	scaleT = 1.0f / header.skinheight;
+	for( i = 0; i < numIndices; i++ ) {
+		if( remap[i] == i ) {
+			dst_tc[ finalIndices[i] ].st[0] = LittleShort( src_tc[ tcIndices[i] ].s ) * scaleS;
+			dst_tc[ finalIndices[i] ].st[1] = LittleShort( src_tc[ tcIndices[i] ].t ) * scaleT;
+		}
+	}
+
+	/* load all frames */
+	model->frames = Model_Malloc( header.num_frames * sizeof( aliasFrame_t ) );
+	model->numFrames = header.num_frames;
+
+	offset = header.ofs_frames;
+	dst_frame = model->frames;
+	for( j = 0; j < header.num_frames; j++ ) {
+		src_frame = ( daliasframe_t * )( ( byte * )rawdata + offset );
+		if( ( byte * )( src_frame + 1 ) > rawend ) {
+			Com_EPrintf( "%s has bad offset for frame %d\n", model->name, j );
+			goto fail;
+		}
+
+		LittleVector( src_frame->scale, dst_frame->scale );
+		LittleVector( src_frame->translate, dst_frame->translate );
+
+		/* load frame vertices */
+		ClearBounds( mins, maxs );
+		for( i = 0; i < numIndices; i++ ) {
+			if( remap[i] == i ) {
+				src_vert = &src_frame->verts[ vertIndices[i] ];
+				dst_vert = &dst_mesh->verts[ j * numVerts + finalIndices[i] ];
+
+				dst_vert->pos[0] = src_vert->v[0];
+				dst_vert->pos[1] = src_vert->v[1];
+				dst_vert->pos[2] = src_vert->v[2];
+				k = src_vert->lightnormalindex;
+				if( k >= NUMVERTEXNORMALS ) {
+					Com_EPrintf( "%s has bad normal index\n", model->name );
+					goto fail;
+				}
+				dst_vert->normalIndex = k;
+
+				for ( k = 0; k < 3; k++ ) {
+					val = dst_vert->pos[k];
+					if( val < mins[k] )
+						mins[k] = val;
+					if( val > maxs[k] )
+						maxs[k] = val;
+				}
+			}
+		}
+
+		VectorVectorScale( mins, dst_frame->scale, mins );
+		VectorVectorScale( maxs, dst_frame->scale, maxs );
+
+		dst_frame->radius = RadiusFromBounds( mins, maxs );
+
+		VectorAdd( mins, dst_frame->translate, dst_frame->bounds[0] );
+		VectorAdd( maxs, dst_frame->translate, dst_frame->bounds[1] );
+
+		offset += header.framesize;
+		dst_frame++;
+	}
+
+    sys.HunkEnd( &model->pool );
+
+	return qtrue;
+
+fail:
+	sys.HunkFree( &model->pool );
+	return qfalse;
+}
+
+static qboolean Model_LoadMd3( model_t *model, const byte *rawdata, int length ) {
+	dmd3header_t header;
+	uint32 offset;
+	dmd3frame_t *src_frame;
+	dmd3mesh_t *src_mesh;
+	dmd3vertex_t *src_vert;
+	dmd3coord_t *src_tc;
+	dmd3skin_t *src_skin;
+	uint32 *src_idx;
+	aliasFrame_t *dst_frame;
+	aliasMesh_t *dst_mesh;
+	aliasVert_t *dst_vert;
+	tcoord_t *dst_tc;
+	uint32 *dst_idx;
+	uint32 numVerts, numTris, numSkins;
+	uint32 totalVerts;
+	char skinname[MAX_QPATH];
+	image_t *skin;
+	const byte *rawend;
+	int i, j;
+
+	if( length < sizeof( header ) ) {
+		Com_EPrintf( "%s has length < header length\n", model->name );
+		return qfalse;
+	}
+
+	/* byte swap the header */
+	header = *( dmd3header_t * )rawdata;
+	for( i = 0; i < sizeof( header )/4; i++ ) {
+		(( uint32 * )&header)[i] = LittleLong( (( uint32 * )&header)[i] );
+	}
+
+	if( header.ident != MD3_IDENT ) {
+		Com_EPrintf( "%s is not an MD3 file\n", model->name );
+		return qfalse;
+	}
+
+	if( header.version != MD3_VERSION ) {
+		Com_EPrintf( "%s has bad version: %d != %d\n",
+			model->name, header.version, MD3_VERSION );
+		return qfalse;
+	}
+
+	if( header.num_frames < 1 ) {
+		Com_EPrintf( "%s has bad number of frames: %d\n",
+			model->name, header.num_frames );
+		return qfalse;
+	}
+	if( header.num_frames > MD3_MAX_FRAMES ) {
+		Com_EPrintf( "%s has too many frames: %d > %d\n",
+			model->name, header.num_frames, MD3_MAX_FRAMES );
+		return qfalse;
+	}
+
+	if( header.num_meshes < 1 || header.num_meshes > MD3_MAX_SURFACES ) {
+		Com_EPrintf( "%s has bad number of meshes\n", model->name );
+		return qfalse;
+	}
+	
+	model->type = MODEL_ALIAS;
+	sys.HunkBegin( &model->pool, 0x400000 );
+	model->numFrames = header.num_frames;
+	model->numMeshes = header.num_meshes;
+	model->meshes = Model_Malloc( sizeof( aliasMesh_t ) * header.num_meshes );
+	model->frames = Model_Malloc( sizeof( aliasFrame_t ) * header.num_frames );
+
+	rawend = rawdata + length;
+	
+	/* load all frames */
+	src_frame = ( dmd3frame_t * )( rawdata + header.ofs_frames );
+	if( ( byte * )( src_frame + header.num_frames ) > rawend ) {
+		Com_EPrintf( "%s has bad frames offset\n", model->name );
+		goto fail;
+	}
+	dst_frame = model->frames;
+	for( i = 0; i < header.num_frames; i++ ) {
+		LittleVector( src_frame->translate, dst_frame->translate );
+		VectorSet( dst_frame->scale, MD3_XYZ_SCALE, MD3_XYZ_SCALE, MD3_XYZ_SCALE );
+
+		LittleVector( src_frame->mins, dst_frame->bounds[0] );
+		LittleVector( src_frame->maxs, dst_frame->bounds[1] );
+		dst_frame->radius = LittleFloat( src_frame->radius );
+
+		src_frame++; dst_frame++;
+	}
+	
+	/* load all meshes */
+	src_mesh = ( dmd3mesh_t * )( rawdata + header.ofs_meshes );
+	dst_mesh = model->meshes;
+	for( i = 0; i < header.num_meshes; i++ ) {
+		if( ( byte * )( src_mesh + 1 ) > rawend ) {
+			Com_EPrintf( "%s has bad offset for mesh %d\n", model->name, i );
+			goto fail;
+		}
+
+		numVerts = LittleLong( src_mesh->num_verts );
+		numTris = LittleLong( src_mesh->num_tris );
+
+		if( numVerts < 3 || numVerts > TESS_MAX_VERTICES ) {
+			Com_EPrintf( "%s has bad number of vertices for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		if( numTris < 1 || numTris > TESS_MAX_INDICES / 3 ) {
+			Com_EPrintf( "%s has bad number of faces for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		
+		dst_mesh->numTris = numTris;
+		dst_mesh->numIndices = numTris * 3;
+		dst_mesh->numVerts = numVerts;
+		dst_mesh->verts = Model_Malloc( sizeof( aliasVert_t ) * numVerts * header.num_frames );
+		dst_mesh->tcoords = Model_Malloc( sizeof( tcoord_t ) * numVerts );
+		dst_mesh->indices = Model_Malloc( sizeof( uint32 ) * numTris * 3 );
+
+		/* load all skins */
+		numSkins = LittleLong( src_mesh->num_skins );
+		if( numSkins > MAX_MD2SKINS ) {
+			Com_EPrintf( "%s has bad number of skins for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		offset = LittleLong( src_mesh->ofs_skins );
+		src_skin = ( dmd3skin_t * )( ( byte * )src_mesh + offset );
+		if( ( byte * )( src_skin + numSkins ) > rawend ) {
+			Com_EPrintf( "%s has bad skins offset for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		for( j = 0; j < numSkins; j++ ) {
+			Q_strncpyz( skinname, src_skin->name, sizeof( skinname ) );
+			skin = R_FindImage( skinname, it_skin );
+			if( !skin ) {
+				skin = r_notexture;
+			}
+			dst_mesh->skins[j] = skin;
+		}
+		dst_mesh->numSkins = numSkins;
+		
+		/* load all vertices */
+		totalVerts = numVerts * header.num_frames;
+		offset = LittleLong( src_mesh->ofs_verts );
+		src_vert = ( dmd3vertex_t * )( ( byte * )src_mesh + offset );
+		if( ( byte * )( src_vert + totalVerts ) > rawend ) {
+			Com_EPrintf( "%s has bad vertices offset for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		dst_vert = dst_mesh->verts;
+		for( j = 0; j < totalVerts; j++ ) {
+			dst_vert->pos[0] = LittleShort( src_vert->point[0] );
+			dst_vert->pos[1] = LittleShort( src_vert->point[1] );
+			dst_vert->pos[2] = LittleShort( src_vert->point[2] );
+
+			dst_vert->normalIndex = ll2byte[src_vert->norm[0]]
+                [src_vert->norm[1]];
+
+			src_vert++; dst_vert++;
+		}
+		
+		/* load all texture coords */
+		offset = LittleLong( src_mesh->ofs_tcs );
+		src_tc = ( dmd3coord_t * )( ( byte * )src_mesh + offset );
+		if( ( byte * )( src_tc + numVerts ) > rawend ) {
+			Com_EPrintf( "%s has bad tcoords offset for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		dst_tc = dst_mesh->tcoords;
+		for( j = 0; j < numVerts; j++ ) {
+			dst_tc->st[0] = LittleFloat( src_tc->st[0] );
+			dst_tc->st[1] = LittleFloat( src_tc->st[1] );
+			src_tc++; dst_tc++;
+		}
+
+		/* load all triangle indices */
+		offset = LittleLong( src_mesh->ofs_indexes );
+		src_idx = ( uint32 * )( ( byte * )src_mesh + offset );
+		if( ( byte * )( src_idx + numTris * 3 ) > rawend ) {
+			Com_EPrintf( "%s has bad indices offset for mesh %d\n", model->name, i );
+			goto fail;
+		}
+		dst_idx = dst_mesh->indices;
+		for( j = 0; j < numTris; j++ ) {
+			dst_idx[0] = LittleLong( src_idx[0] );
+			dst_idx[1] = LittleLong( src_idx[1] );
+			dst_idx[2] = LittleLong( src_idx[2] );
+            if( dst_idx[0] >= numVerts || dst_idx[1] >= numVerts || dst_idx[2] >= numVerts ) {
+			    Com_EPrintf( "%s has bad indices for triangle %d in mesh %d\n", model->name, j, i );
+			    goto fail;
+            }
+			src_idx += 3; dst_idx += 3;
+		}
+		
+		offset = LittleLong( src_mesh->meshsize );
+		src_mesh = ( dmd3mesh_t * )( ( byte * )src_mesh + offset );
+		dst_mesh++;
+	}
+
+    sys.HunkEnd( &model->pool );
+
+	return qtrue;
+
+fail:
+	sys.HunkFree( &model->pool );
+	return qfalse;
+}
+
+#define Model_TempAlloc( ptr, size ) \
+    do { ptr = ( void * )data; data += size; offset += size; } while( 0 )
+
+static qboolean Model_WriteMd3( model_t *model, fileHandle_t f ) {
+	dmd3header_t *header;
+	uint32 offset, length;
+    byte *data;
+	dmd3frame_t *dst_frame;
+	dmd3mesh_t *dst_mesh;
+	dmd3vertex_t *dst_vert;
+	dmd3coord_t *dst_tc;
+	dmd3skin_t *dst_skin;
+	uint32 *dst_idx;
+	aliasFrame_t *src_frame;
+	aliasMesh_t *src_mesh;
+	aliasVert_t *src_vert;
+	tcoord_t *src_tc;
+	uint32 *src_idx;
+	uint32 totalVerts;
+	int i, j;
+    qboolean ret;
+    short pos[3];
+
+    // precalculate total length
+    length = sizeof( dmd3header_t ) +
+        model->numFrames * sizeof( dmd3frame_t );
+	src_mesh = model->meshes;
+	for( i = 0; i < model->numMeshes; i++ ) {
+        length += sizeof( dmd3mesh_t ) +
+            src_mesh->numSkins * sizeof( dmd3skin_t ) +
+            src_mesh->numVerts * model->numFrames * sizeof( dmd3vertex_t ) +
+            src_mesh->numVerts * sizeof( dmd3coord_t ) +
+            src_mesh->numIndices * sizeof( uint32 );
+        src_mesh++;
+    }
+
+    data = fs.AllocTempMem( length );
+    offset = 0;
+
+    // write header
+    Model_TempAlloc( header, sizeof( dmd3header_t ) );
+    header->ident = LittleLong( MD3_IDENT );
+	header->version = LittleLong( MD3_VERSION );
+    memset( header->filename, 0, sizeof( header->filename ) );
+    header->flags = 0;
+	header->num_frames = LittleLong( model->numFrames );
+    header->num_tags = 0;
+    header->num_meshes = LittleLong( model->numMeshes );
+    header->num_skins = 0;
+
+	// write all frames
+    header->ofs_frames = LittleLong( offset );
+	src_frame = model->frames;
+    Model_TempAlloc( dst_frame, model->numFrames * sizeof( dmd3frame_t ) );
+	for( i = 0; i < model->numFrames; i++ ) {
+		LittleVector( src_frame->translate, dst_frame->translate );
+
+		LittleVector( src_frame->bounds[0], dst_frame->mins );
+		LittleVector( src_frame->bounds[1], dst_frame->maxs );
+		dst_frame->radius = LittleFloat( src_frame->radius );
+
+        memset( dst_frame->creator, 0, sizeof( dst_frame->creator ) );
+
+		src_frame++; dst_frame++;
+	}
+	
+	// write all meshes
+	header->ofs_meshes = LittleLong( offset );
+	src_mesh = model->meshes;
+	for( i = 0; i < model->numMeshes; i++ ) {
+        offset = 0;
+        Model_TempAlloc( dst_mesh, sizeof( dmd3mesh_t ) );
+        dst_mesh->ident = LittleLong( MD3_IDENT );
+        memset( dst_mesh->name, 0, sizeof( dst_mesh->name ) );
+        dst_mesh->flags = 0;
+        dst_mesh->num_frames = LittleLong( model->numFrames );
+        dst_mesh->num_skins = LittleLong( src_mesh->numSkins );
+		dst_mesh->num_tris = LittleLong( src_mesh->numTris );
+		dst_mesh->num_verts = LittleLong( src_mesh->numVerts );
+
+		// write all skins
+        dst_mesh->ofs_skins = LittleLong( offset );
+        Model_TempAlloc( dst_skin, sizeof( dmd3skin_t ) * src_mesh->numSkins );
+		for( j = 0; j < src_mesh->numSkins; j++ ) {
+            memcpy( dst_skin->name, src_mesh->skins[j]->name, MAX_QPATH );
+            dst_skin->unused = 0;
+            dst_skin++;
+		}
+		
+		// write all vertices
+        dst_mesh->ofs_verts = LittleLong( offset );
+		totalVerts = src_mesh->numVerts * model->numFrames;
+        src_vert = src_mesh->verts;
+        src_frame = model->frames;
+        Model_TempAlloc( dst_vert, sizeof( dmd3vertex_t ) * totalVerts );
+		for( j = 0; j < totalVerts; j++ ) {
+            pos[0] = src_vert->pos[0] * src_frame->scale[0] / MD3_XYZ_SCALE;
+            pos[1] = src_vert->pos[1] * src_frame->scale[1] / MD3_XYZ_SCALE;
+            pos[2] = src_vert->pos[2] * src_frame->scale[2] / MD3_XYZ_SCALE;
+
+			dst_vert->point[0] = LittleShort( pos[0] );
+			dst_vert->point[1] = LittleShort( pos[1] );
+			dst_vert->point[2] = LittleShort( pos[2] );
+
+            // TODO: calc normal
+
+            src_vert++; dst_vert++;
+		}
+		
+		// write all texture coords
+		dst_mesh->ofs_tcs = LittleLong( offset );
+        src_tc = src_mesh->tcoords;
+        Model_TempAlloc( dst_tc, sizeof( dmd3coord_t ) * src_mesh->numVerts );
+		for( j = 0; j < src_mesh->numVerts; j++ ) {
+			dst_tc->st[0] = LittleFloat( src_tc->st[0] );
+			dst_tc->st[1] = LittleFloat( src_tc->st[1] );
+            src_tc++; dst_tc++;
+		}
+
+		// write all triangle indices
+		dst_mesh->ofs_indexes = LittleLong( offset );
+		src_idx = src_mesh->indices;
+		Model_TempAlloc( dst_idx, sizeof( uint32 ) * src_mesh->numIndices );
+		for( j = 0; j < src_mesh->numTris; j++ ) {
+			dst_idx[0] = LittleLong( src_idx[0] );
+			dst_idx[1] = LittleLong( src_idx[1] );
+			dst_idx[2] = LittleLong( src_idx[2] );
+			src_idx += 3; dst_idx += 3;
+		}
+		
+	    dst_mesh->meshsize = LittleLong( offset );
+	}
+
+    header->ofs_tags = 0;
+    header->ofs_end = length;
+
+	// write model to disk
+    ret = qtrue;
+    if( fs.Write( header, length, f ) != length ) {
+        ret = qfalse;
+    }
+
+    fs.FreeFile( header );
+
+	return ret;
+}
+
+static qboolean Model_LoadSp2( model_t *model, const byte *rawdata, int length ) {
+	dsprite_t *header;
+	dsprframe_t *src_frame;
+	spriteFrame_t *dst_frame;
+	int ident, version, numframes;
+	int i, width, height;
+	char buffer[MAX_SKINNAME];
+	image_t *image;
+
+	if( length < sizeof( *header ) ) {
+		Com_EPrintf( "%s has length < header length\n", model->name );
+		return qfalse;
+	}
+
+	/* byte swap the header */
+	header = ( dsprite_t * )rawdata;
+	for( i = 0; i < sizeof( header )/4; i++ ) {
+		(( uint32 * )&header)[i] = LittleLong( (( uint32 * )&header)[i] );
+	}
+
+	ident = LittleLong( header->ident );
+	version = LittleLong( header->version );
+	numframes = LittleLong( header->numframes );
+
+	if( ident != IDSPRITEHEADER ) {
+		Com_EPrintf( "%s is not an sp2 file\n", model->name );
+		return qfalse;
+	}
+
+	if( version != SPRITE_VERSION ) {
+		Com_EPrintf( "%s has bad version: %d != %d\n",
+			model->name, version, ALIAS_VERSION );
+		return qfalse;
+	}
+
+	if( numframes < 1 ) {
+		Com_EPrintf( "%s has bad number of frames: %d\n",
+			model->name, numframes );
+		return qfalse;
+	}
+
+	if( numframes > MAX_MD2SKINS ) {
+		Com_EPrintf( "%s has too many frames: %d > %d\n",
+			model->name, numframes, MAX_MD2SKINS );
+		return qfalse;
+	}
+
+	model->type = MODEL_SPRITE;
+	sys.HunkBegin( &model->pool, 0x10000 );
+
+	model->sframes = Model_Malloc( sizeof( spriteFrame_t ) * numframes );
+	model->numFrames = numframes;
+
+	src_frame = header->frames;
+	dst_frame = model->sframes;
+	for( i = 0; i < numframes; i++ ) {
+		width = LittleLong( src_frame->width );
+		height = LittleLong( src_frame->height );
+		if( width <= 0 || height <= 0 ) {
+			Com_WPrintf( "%s has bad image dimensions for frame #%d: %d x %d\n",
+				model->name, width, height, i );
+			width = 1;
+			height = 1;
+		}
+		dst_frame->width = width;
+		dst_frame->height = height;
+		dst_frame->x = LittleLong( src_frame->origin_x );
+		dst_frame->y = LittleLong( src_frame->origin_y );
+
+		Q_strncpyz( buffer, src_frame->name, sizeof( buffer ) );
+		image = R_FindImage( buffer, it_sprite );
+		if( !image ) {
+			Com_DPrintf( "Couldn't find image '%s' for frame #%d for sprite '%s'\n",
+				buffer, i, model->name );
+			image = r_notexture;
+		}
+		dst_frame->image = image;
+
+		dst_frame++; src_frame++;
+	}
+
+    sys.HunkEnd( &model->pool );
+
+	return qtrue;
+}
+
+void GL_GetModelSize( qhandle_t hModel, vec3_t mins, vec3_t maxs ) {
+    VectorClear( mins );
+    VectorClear( maxs );
+}
+
+qhandle_t GL_RegisterModel( const char *name ) {
+	int index, length, nameLength;
+	model_t *model;
+	byte *rawdata;
+	uint32 ident;
+	qboolean success;
+	char buffer[MAX_QPATH];
+
+	if( name[0] == '*' ) {
+		/* inline bsp model */
+		index = atoi( name + 1 );
+		if( index < 1 || index >= r_world.numSubmodels ) {
+			Com_Error( ERR_DROP, "GL_RegisterModel: bad inline model index: %d", index );
+		}
+		return ~index;
+	}
+
+	if( !strcmp( r_world.name, name ) ) {
+		/* TODO: change client code and remove this hack */
+		return 0;
+	}
+
+	nameLength = strlen( name );
+	if( nameLength > MAX_QPATH - 1 ) {
+		Com_Error( ERR_DROP, "GL_RegisterModel: oversize name: %d chars", nameLength );
+	}
+
+	model = Model_Find( name );
+	if( model ) {
+		goto finish;
+	}
+
+	length = -1;
+    buffer[0] = 0;
+	if( gl_override_models->integer ) {
+		if( nameLength > 4 && !strcmp( name + nameLength - 4, ".md2" ) ) {
+			strcpy( buffer, name );
+			buffer[nameLength - 1] = '3';
+		}
+		length = fs.LoadFile( buffer, ( void ** )&rawdata );
+	}
+	if( length == -1 ) {
+		length = fs.LoadFile( name, ( void ** )&rawdata );
+		if( length == -1 ) {
+			Com_DPrintf( "Couldn't load %s\n", name );
+			return 0;
+		}
+	}
+
+	if( length < 4 ) {
+		Com_WPrintf( "%s has invalid length\n", name );
+		return 0;
+	}
+
+	model = Model_Alloc( name );
+
+	ident = LittleLong( *( uint32 * )rawdata );
+	switch( ident ) {
+	case IDALIASHEADER:
+		success = Model_LoadMd2( model, rawdata, length );
+        if( success && gl_override_models->integer > 1 ) {
+            fileHandle_t f;
+
+            fs.FOpenFile( buffer, &f, FS_MODE_WRITE );
+            if( f ) {
+                Model_WriteMd3( model, f );
+                fs.FCloseFile( f );
+            }
+        }
+		break;
+	case MD3_IDENT:
+		success = Model_LoadMd3( model, rawdata, length );
+		break;
+	case IDSPRITEHEADER:
+		success = Model_LoadSp2( model, rawdata, length );
+		break;
+	case IDBSPHEADER:
+		Com_WPrintf( "Loaded bsp model '%s' after the world\n", name );
+		success = qfalse;
+		break;
+	default:
+		Com_WPrintf( "%s has unknown ident: %x\n", name, ident );
+		success = qfalse;
+		break;
+	}
+
+	fs.FreeFile( rawdata );
+
+	if( !success ) {
+		model->name[0] = 0;
+		return 0;
+	}
+
+finish:
+	index = ( model - r_models ) + 1;
+	return index;
+}
+
+modelType_t *GL_ModelForHandle( qhandle_t hModel ) {
+	model_t *model;
+	bspSubmodel_t *submodel;
+
+	if( !hModel ) {
+		return NULL;
+	}
+
+	if( hModel & 0x80000000 ) {
+		hModel = ~hModel;
+
+		if( hModel < 1 || hModel >= r_world.numSubmodels ) {
+			Com_Error( ERR_DROP, "GL_ModelForHandle: submodel %d out of range", hModel );
+		}
+
+		submodel = &r_world.submodels[hModel];
+		return &submodel->type;
+	}
+
+	if( hModel > r_numModels ) {
+		Com_Error( ERR_DROP, "GL_ModelForHandle: %d out of range", hModel );
+	}
+	model = &r_models[ hModel - 1 ];
+	if( !model->name[0] ) {
+		return NULL;
+	}
+	return &model->type;
+	
+}
+
+void GL_InitModels( void ) {
+    float s[2], c[2];
+    vec3_t normal;
+    int i, j;
+
+    for( i = 0; i < 256; i++ ) {
+        for( j = 0; j < 256; j++ ) {
+            s[0] = sin( i / 255.0f );
+            c[0] = cos( i / 255.0f );
+            
+            s[1] = sin( j / 255.0f );
+            c[1] = cos( j / 255.0f );
+
+            VectorSet( normal, s[0] * c[1], s[0] * s[1], c[0] );
+            ll2byte[i][j] = DirToByte( normal );
+        }
+    }
+
+	gl_override_models = cvar.Get( "r_override_models", "0",
+        CVAR_ARCHIVE|CVAR_LATCHED );
+
+
+	cmd.AddCommand( "modellist", Model_List_f );
+}
+
+void GL_ShutdownModels( void ) {
+    Model_FreeAll();
+	cmd.RemoveCommand( "modellist" );
+}