gtkradiant/tools/quake2/qdata_heretic2/models.c

/*
   Copyright (C) 1999-2007 id Software, Inc. and contributors.
   For a list of contributors, see the accompanying CONTRIBUTORS file.

   This file is part of GtkRadiant.

   GtkRadiant 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.

   GtkRadiant 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 GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */


#include "qdata.h"
#include <assert.h>
#include "jointed.h"
#include "fmodel.h"

//=================================================================

typedef struct
{
	int numnormals;
	vec3_t normalsum;
} vertexnormals_t;

typedef struct
{
	vec3_t v;
	int lightnormalindex;
} trivert_t;

typedef struct
{
	vec3_t mins, maxs;
	char name[16];
	trivert_t v[MAX_VERTS];
	QDataJoint_t joints[NUM_CLUSTERS];    // ,this
} frame_t;

// ,and all of this should get out of here, need to use new stuff in fmodels instead

typedef struct IntListNode_s
{
	int data;
	struct IntListNode_s *next;
} IntListNode_t;  // gaak

typedef struct
{
	float scale[3];         // multiply byte verts by this
	float translate[3];         // then add this
} PartialAliasFrame_t;

int jointed;
int clustered;

int *clusters[NUM_CLUSTERS];
IntListNode_t *vertLists[NUM_CLUSTERS];
int num_verts[NUM_CLUSTERS + 1];
int new_num_verts[NUM_CLUSTERS + 1];

// end that

//================================================================

frame_t g_frames[MAX_FRAMES];
//frame_t		*g_frames;

static dmdl_t model;


float scale_up;                 // set by $scale
vec3_t adjust;                  // set by $origin
int g_fixedwidth, g_fixedheight;            // set by $skinsize


//
// base frame info
//
dstvert_t base_st[MAX_VERTS];
dtriangle_t triangles[MAX_TRIANGLES];

static int triangle_st[MAX_TRIANGLES][3][2];

// the command list holds counts, s/t values, and xyz indexes
// that are valid for every frame
int commands[16384];
int numcommands;
int numglverts;
int used[MAX_TRIANGLES];

char g_skins[MAX_MD2SKINS][64];

char cdarchive[1024];
char cdpartial[1024];
char cddir[1024];

char modelname[64];         // empty unless $modelname issued (players)

extern char        *g_outputDir;

#define NUMVERTEXNORMALS    162

float avertexnormals[NUMVERTEXNORMALS][3] =
{
	#include "anorms.h"
};

unsigned char pic[SKINPAGE_HEIGHT * SKINPAGE_WIDTH], pic_palette[768];

FILE    *headerouthandle = NULL;

//==============================================================

/*
   ===============
   ClearModel
   ===============
 */
static void ClearModel( void ){
	memset( &model, 0, sizeof( model ) );

	modelname[0] = 0;
	jointed = NOT_JOINTED;
	clustered = 0;
	scale_up = 1.0;
	VectorCopy( vec3_origin, adjust );
	g_fixedwidth = g_fixedheight = 0;
	g_skipmodel = false;
}


void H_printf( char *fmt, ... ){
	va_list argptr;
	char name[1024];

	if ( !headerouthandle ) {
		sprintf( name, "%s/tris.h", cddir );
		headerouthandle = SafeOpenWrite( name );
		fprintf( headerouthandle, "// %s\n\n", cddir );
		fprintf( headerouthandle, "// This file generated by qdata - Do NOT Modify\n\n" );
	}

	va_start( argptr, fmt );
	vfprintf( headerouthandle, fmt, argptr );
	va_end( argptr );
}

#if 1
/*
   ============
   WriteModelFile
   ============
 */
void WriteCommonModelFile( FILE *modelouthandle, PartialAliasFrame_t *outFrames ){
	int i;
	dmdl_t modeltemp;
	int j, k;
	frame_t         *in;
	daliasframe_t   *out;
	byte buffer[MAX_VERTS * 4 + 128];
	float v;
	int c_on, c_off;

	model.version = ALIAS_VERSION;
	model.framesize = (int)&( (daliasframe_t *)0 )->verts[model.num_xyz];
	model.num_glcmds = numcommands;
	model.ofs_skins = sizeof( dmdl_t );
	model.ofs_st = model.ofs_skins + model.num_skins * MAX_SKINNAME;
	model.ofs_tris = model.ofs_st + model.num_st * sizeof( dstvert_t );
	model.ofs_frames = model.ofs_tris + model.num_tris * sizeof( dtriangle_t );
	model.ofs_glcmds = model.ofs_frames + model.num_frames * model.framesize;
	model.ofs_end = model.ofs_glcmds + model.num_glcmds * sizeof( int );
	//
	// write out the model header
	//
	for ( i = 0 ; i < sizeof( dmdl_t ) / 4 ; i++ )
		( (int *)&modeltemp )[i] = LittleLong( ( (int *)&model )[i] );

	SafeWrite( modelouthandle, &modeltemp, sizeof( modeltemp ) );

	//
	// write out the skin names
	//
	SafeWrite( modelouthandle, g_skins, model.num_skins * MAX_SKINNAME );

	//
	// write out the texture coordinates
	//
	c_on = c_off = 0;
	for ( i = 0 ; i < model.num_st ; i++ )
	{
		base_st[i].s = LittleShort( base_st[i].s );
		base_st[i].t = LittleShort( base_st[i].t );
	}

	SafeWrite( modelouthandle, base_st, model.num_st * sizeof( base_st[0] ) );

	//
	// write out the triangles
	//
	for ( i = 0 ; i < model.num_tris ; i++ )
	{
		int j;
		dtriangle_t tri;

		for ( j = 0 ; j < 3 ; j++ )
		{
			tri.index_xyz[j] = LittleShort( triangles[i].index_xyz[j] );
			tri.index_st[j] = LittleShort( triangles[i].index_st[j] );
		}

		SafeWrite( modelouthandle, &tri, sizeof( tri ) );
	}

	//
	// write out the frames
	//
	for ( i = 0 ; i < model.num_frames ; i++ )
	{
		in = &g_frames[i];
		out = (daliasframe_t *)buffer;

		strcpy( out->name, in->name );
		for ( j = 0 ; j < 3 ; j++ )
		{
			out->scale[j] = ( in->maxs[j] - in->mins[j] ) / 255;
			out->translate[j] = in->mins[j];

			if ( outFrames ) {
				outFrames[i].scale[j] = out->scale[j];
				outFrames[i].translate[j] = out->translate[j];
			}
		}

		for ( j = 0 ; j < model.num_xyz ; j++ )
		{
			// all of these are byte values, so no need to deal with endianness
			out->verts[j].lightnormalindex = in->v[j].lightnormalindex;

			for ( k = 0 ; k < 3 ; k++ )
			{
				// scale to byte values & min/max check
				v = Q_rint( ( in->v[j].v[k] - out->translate[k] ) / out->scale[k] );

				// clamp, so rounding doesn't wrap from 255.6 to 0
				if ( v > 255.0 ) {
					v = 255.0;
				}
				if ( v < 0 ) {
					v = 0;
				}
				out->verts[j].v[k] = v;
			}
		}

		for ( j = 0 ; j < 3 ; j++ )
		{
			out->scale[j] = LittleFloat( out->scale[j] );
			out->translate[j] = LittleFloat( out->translate[j] );
		}

		SafeWrite( modelouthandle, out, model.framesize );
	}

	//
	// write out glcmds
	//
	SafeWrite( modelouthandle, commands, numcommands * 4 );
}

/*
   ============
   WriteModelFile
   ============
 */
void WriteModelFile( FILE *modelouthandle ){
	model.ident = IDALIASHEADER;

	WriteCommonModelFile( modelouthandle, NULL );
}

/*
   ============
   WriteJointedModelFile
   ============
 */
void WriteJointedModelFile( FILE *modelouthandle ){
	int i;
	int j, k;
	frame_t         *in;
	float v;
	IntListNode_t   *current, *toFree;
	PartialAliasFrame_t outFrames[MAX_FRAMES];

	model.ident = IDJOINTEDALIASHEADER;

	WriteCommonModelFile( modelouthandle, outFrames );

	// Skeletal Type
	SafeWrite( modelouthandle, &jointed, sizeof( int ) );

	// number of joints
	SafeWrite( modelouthandle, &numJointsForSkeleton[jointed], sizeof( int ) );

	// number of verts in each cluster
	SafeWrite( modelouthandle, &new_num_verts[1], sizeof( int ) * numJointsForSkeleton[jointed] );

	// cluster verts
	for ( i = 0; i < new_num_verts[0]; ++i )
	{
		current = vertLists[i];
		while ( current )
		{
			SafeWrite( modelouthandle, &current->data, sizeof( int ) );
			toFree = current;
			current = current->next;
			free( toFree );  // freeing of memory allocated in ReplaceClusterIndex called in Cmd_Base
		}
	}

	for ( i = 0 ; i < model.num_frames ; i++ )
	{
		in = &g_frames[i];

		for ( j = 0 ; j < new_num_verts[0]; ++j )
		{
			for ( k = 0 ; k < 3 ; k++ )
			{
				// scale to byte values & min/max check
				v = Q_rint( ( in->joints[j].placement.origin[k] - outFrames[i].translate[k] ) / outFrames[i].scale[k] );

				// clamp, so rounding doesn't wrap from 255.6 to 0
				if ( v > 255.0 ) {
					v = 255.0;
				}

				if ( v < 0 ) {
					v = 0;
				}

				// write out origin as a float (there's only a few per model, so it's not really
				// a size issue)
				SafeWrite( modelouthandle, &v, sizeof( float ) );
			}

			for ( k = 0 ; k < 3 ; k++ )
			{
				v = Q_rint( ( in->joints[j].placement.direction[k] - outFrames[i].translate[k] ) / outFrames[i].scale[k] );

				// clamp, so rounding doesn't wrap from 255.6 to 0
				if ( v > 255.0 ) {
					v = 255.0;
				}

				if ( v < 0 ) {
					v = 0;
				}

				// write out origin as a float (there's only a few per model, so it's not really
				// a size issue)
				SafeWrite( modelouthandle, &v, sizeof( float ) );
			}

			for ( k = 0 ; k < 3 ; k++ )
			{
				v = Q_rint( ( in->joints[j].placement.up[k] - outFrames[i].translate[k] ) / outFrames[i].scale[k] );

				// clamp, so rounding doesn't wrap from 255.6 to 0
				if ( v > 255.0 ) {
					v = 255.0;
				}

				if ( v < 0 ) {
					v = 0;
				}

				// write out origin as a float (there's only a few per model, so it's not really
				// a size issue)
				SafeWrite( modelouthandle, &v, sizeof( float ) );
			}
		}
	}
}
#else
/*
   ============
   WriteModelFile
   ============
 */
static void WriteModelFile( FILE *modelouthandle ){
	int i;
	dmdl_t modeltemp;
	int j, k;
	frame_t         *in;
	daliasframe_t   *out;
	byte buffer[MAX_VERTS * 4 + 128];
	float v;
	int c_on, c_off;

	model.ident = IDALIASHEADER;
	model.version = ALIAS_VERSION;
	model.framesize = (int)&( (daliasframe_t *)0 )->verts[model.num_xyz];
	model.num_glcmds = numcommands;
	model.ofs_skins = sizeof( dmdl_t );
	model.ofs_st = model.ofs_skins + model.num_skins * MAX_SKINNAME;
	model.ofs_tris = model.ofs_st + model.num_st * sizeof( dstvert_t );
	model.ofs_frames = model.ofs_tris + model.num_tris * sizeof( dtriangle_t );
	model.ofs_glcmds = model.ofs_frames + model.num_frames * model.framesize;
	model.ofs_end = model.ofs_glcmds + model.num_glcmds * 4;

	//
	// write out the model header
	//
	for ( i = 0 ; i < sizeof( dmdl_t ) / 4 ; i++ )
		( (int *)&modeltemp )[i] = LittleLong( ( (int *)&model )[i] );

	SafeWrite( modelouthandle, &modeltemp, sizeof( modeltemp ) );

	//
	// write out the skin names
	//
	SafeWrite( modelouthandle, g_skins, model.num_skins * MAX_SKINNAME );

	//
	// write out the texture coordinates
	//
	c_on = c_off = 0;
	for ( i = 0 ; i < model.num_st ; i++ )
	{
		base_st[i].s = LittleShort( base_st[i].s );
		base_st[i].t = LittleShort( base_st[i].t );
	}

	SafeWrite( modelouthandle, base_st, model.num_st * sizeof( base_st[0] ) );

	//
	// write out the triangles
	//
	for ( i = 0 ; i < model.num_tris ; i++ )
	{
		int j;
		dtriangle_t tri;

		for ( j = 0 ; j < 3 ; j++ )
		{
			tri.index_xyz[j] = LittleShort( triangles[i].index_xyz[j] );
			tri.index_st[j] = LittleShort( triangles[i].index_st[j] );
		}

		SafeWrite( modelouthandle, &tri, sizeof( tri ) );
	}

	//
	// write out the frames
	//
	for ( i = 0 ; i < model.num_frames ; i++ )
	{
		in = &g_frames[i];
		out = (daliasframe_t *)buffer;

		strcpy( out->name, in->name );
		for ( j = 0 ; j < 3 ; j++ )
		{
			out->scale[j] = ( in->maxs[j] - in->mins[j] ) / 255;
			out->translate[j] = in->mins[j];
		}

		for ( j = 0 ; j < model.num_xyz ; j++ )
		{
			// all of these are byte values, so no need to deal with endianness
			out->verts[j].lightnormalindex = in->v[j].lightnormalindex;

			for ( k = 0 ; k < 3 ; k++ )
			{
				// scale to byte values & min/max check
				v = Q_rint( ( in->v[j].v[k] - out->translate[k] ) / out->scale[k] );

				// clamp, so rounding doesn't wrap from 255.6 to 0
				if ( v > 255.0 ) {
					v = 255.0;
				}
				if ( v < 0 ) {
					v = 0;
				}
				out->verts[j].v[k] = v;
			}
		}

		for ( j = 0 ; j < 3 ; j++ )
		{
			out->scale[j] = LittleFloat( out->scale[j] );
			out->translate[j] = LittleFloat( out->translate[j] );
		}

		SafeWrite( modelouthandle, out, model.framesize );
	}

	//
	// write out glcmds
	//
	SafeWrite( modelouthandle, commands, numcommands * 4 );
}
#endif

/*
   ===============
   FinishModel
   ===============
 */
void FinishModel( void ){
	FILE        *modelouthandle;
	int i;
	char name[1024];

	if ( !model.num_frames ) {
		return;
	}

//
// copy to release directory tree if doing a release build
//
	if ( g_release ) {
		if ( modelname[0] ) {
			sprintf( name, "%s", modelname );
		}
		else{
			sprintf( name, "%s/tris.md2", cdpartial );
		}
		ReleaseFile( name );

		for ( i = 0 ; i < model.num_skins ; i++ )
		{
			ReleaseFile( g_skins[i] );
		}
		model.num_frames = 0;
		return;
	}

//
// write the model output file
//
	if ( modelname[0] ) {
		sprintf( name, "%s%s", g_outputDir, modelname );
	}
	else{
		sprintf( name, "%s/tris.md2", g_outputDir );
	}
	printf( "saving to %s\n", name );
	CreatePath( name );
	modelouthandle = SafeOpenWrite( name );

#if 1
	if ( jointed != NOT_JOINTED ) {
		WriteJointedModelFile( modelouthandle );
	}
	else
#endif
	WriteModelFile( modelouthandle );

	printf( "%3dx%3d skin\n", model.skinwidth, model.skinheight );
	printf( "First frame boundaries:\n" );
	printf( "	minimum x: %3f\n", g_frames[0].mins[0] );
	printf( "	maximum x: %3f\n", g_frames[0].maxs[0] );
	printf( "	minimum y: %3f\n", g_frames[0].mins[1] );
	printf( "	maximum y: %3f\n", g_frames[0].maxs[1] );
	printf( "	minimum z: %3f\n", g_frames[0].mins[2] );
	printf( "	maximum z: %3f\n", g_frames[0].maxs[2] );
	printf( "%4d vertices\n", model.num_xyz );
	printf( "%4d triangles\n", model.num_tris );
	printf( "%4d frame\n", model.num_frames );
	printf( "%4d glverts\n", numglverts );
	printf( "%4d glcmd\n", model.num_glcmds );
	printf( "%4d skins\n", model.num_skins );
	printf( "file size: %d\n", (int)ftell( modelouthandle ) );
	printf( "---------------------\n" );

	fclose( modelouthandle );

	// finish writing header file
	H_printf( "\n" );

	// scale_up is usefull to allow step distances to be adjusted
	H_printf( "#define MODEL_SCALE\t\t%f\n", scale_up );

	fclose( headerouthandle );
	headerouthandle = NULL;
}


/*
   =================================================================

   ALIAS MODEL DISPLAY LIST GENERATION

   =================================================================
 */

int strip_xyz[128];
int strip_st[128];
int strip_tris[128];
int stripcount;

/*
   ================
   StripLength
   ================
 */
static int  StripLength( int starttri, int startv ){
	int m1, m2;
	int st1, st2;
	int j;
	dtriangle_t *last, *check;
	int k;

	used[starttri] = 2;

	last = &triangles[starttri];

	strip_xyz[0] = last->index_xyz[( startv ) % 3];
	strip_xyz[1] = last->index_xyz[( startv + 1 ) % 3];
	strip_xyz[2] = last->index_xyz[( startv + 2 ) % 3];
	strip_st[0] = last->index_st[( startv ) % 3];
	strip_st[1] = last->index_st[( startv + 1 ) % 3];
	strip_st[2] = last->index_st[( startv + 2 ) % 3];

	strip_tris[0] = starttri;
	stripcount = 1;

	m1 = last->index_xyz[( startv + 2 ) % 3];
	st1 = last->index_st[( startv + 2 ) % 3];
	m2 = last->index_xyz[( startv + 1 ) % 3];
	st2 = last->index_st[( startv + 1 ) % 3];

	// look for a matching triangle
nexttri:
	for ( j = starttri + 1, check = &triangles[starttri + 1]
		  ; j < model.num_tris ; j++, check++ )
	{
		for ( k = 0 ; k < 3 ; k++ )
		{
			if ( check->index_xyz[k] != m1 ) {
				continue;
			}
			if ( check->index_st[k] != st1 ) {
				continue;
			}
			if ( check->index_xyz[ ( k + 1 ) % 3 ] != m2 ) {
				continue;
			}
			if ( check->index_st[ ( k + 1 ) % 3 ] != st2 ) {
				continue;
			}

			// this is the next part of the fan

			// if we can't use this triangle, this tristrip is done
			if ( used[j] ) {
				goto done;
			}

			// the new edge
			if ( stripcount & 1 ) {
				m2 = check->index_xyz[ ( k + 2 ) % 3 ];
				st2 = check->index_st[ ( k + 2 ) % 3 ];
			}
			else
			{
				m1 = check->index_xyz[ ( k + 2 ) % 3 ];
				st1 = check->index_st[ ( k + 2 ) % 3 ];
			}

			strip_xyz[stripcount + 2] = check->index_xyz[ ( k + 2 ) % 3 ];
			strip_st[stripcount + 2] = check->index_st[ ( k + 2 ) % 3 ];
			strip_tris[stripcount] = j;
			stripcount++;

			used[j] = 2;
			goto nexttri;
		}
	}
done:

	// clear the temp used flags
	for ( j = starttri + 1 ; j < model.num_tris ; j++ )
		if ( used[j] == 2 ) {
			used[j] = 0;
		}

	return stripcount;
}


/*
   ===========
   FanLength
   ===========
 */
static int  FanLength( int starttri, int startv ){
	int m1, m2;
	int st1, st2;
	int j;
	dtriangle_t *last, *check;
	int k;

	used[starttri] = 2;

	last = &triangles[starttri];

	strip_xyz[0] = last->index_xyz[( startv ) % 3];
	strip_xyz[1] = last->index_xyz[( startv + 1 ) % 3];
	strip_xyz[2] = last->index_xyz[( startv + 2 ) % 3];
	strip_st[0] = last->index_st[( startv ) % 3];
	strip_st[1] = last->index_st[( startv + 1 ) % 3];
	strip_st[2] = last->index_st[( startv + 2 ) % 3];

	strip_tris[0] = starttri;
	stripcount = 1;

	m1 = last->index_xyz[( startv + 0 ) % 3];
	st1 = last->index_st[( startv + 0 ) % 3];
	m2 = last->index_xyz[( startv + 2 ) % 3];
	st2 = last->index_st[( startv + 2 ) % 3];


	// look for a matching triangle
nexttri:
	for ( j = starttri + 1, check = &triangles[starttri + 1]
		  ; j < model.num_tris ; j++, check++ )
	{
		for ( k = 0 ; k < 3 ; k++ )
		{
			if ( check->index_xyz[k] != m1 ) {
				continue;
			}
			if ( check->index_st[k] != st1 ) {
				continue;
			}
			if ( check->index_xyz[ ( k + 1 ) % 3 ] != m2 ) {
				continue;
			}
			if ( check->index_st[ ( k + 1 ) % 3 ] != st2 ) {
				continue;
			}

			// this is the next part of the fan

			// if we can't use this triangle, this tristrip is done
			if ( used[j] ) {
				goto done;
			}

			// the new edge
			m2 = check->index_xyz[ ( k + 2 ) % 3 ];
			st2 = check->index_st[ ( k + 2 ) % 3 ];

			strip_xyz[stripcount + 2] = m2;
			strip_st[stripcount + 2] = st2;
			strip_tris[stripcount] = j;
			stripcount++;

			used[j] = 2;
			goto nexttri;
		}
	}
done:

	// clear the temp used flags
	for ( j = starttri + 1 ; j < model.num_tris ; j++ )
		if ( used[j] == 2 ) {
			used[j] = 0;
		}

	return stripcount;
}



/*
   ================
   BuildGlCmds

   Generate a list of trifans or strips
   for the model, which holds for all frames
   ================
 */
static void BuildGlCmds( void ){
	int i, j, k;
	int startv;
	float s, t;
	int len, bestlen, besttype;
	int best_xyz[1024];
	int best_st[1024];
	int best_tris[1024];
	int type;

	//
	// build tristrips
	//
	numcommands = 0;
	numglverts = 0;
	memset( used, 0, sizeof( used ) );
	for ( i = 0 ; i < model.num_tris ; i++ )
	{
		// pick an unused triangle and start the trifan
		if ( used[i] ) {
			continue;
		}

		bestlen = 0;
		for ( type = 0 ; type < 2 ; type++ )
//	type = 1;
		{
			for ( startv = 0 ; startv < 3 ; startv++ )
			{
				if ( type == 1 ) {
					len = StripLength( i, startv );
				}
				else{
					len = FanLength( i, startv );
				}
				if ( len > bestlen ) {
					besttype = type;
					bestlen = len;
					for ( j = 0 ; j < bestlen + 2 ; j++ )
					{
						best_st[j] = strip_st[j];
						best_xyz[j] = strip_xyz[j];
					}
					for ( j = 0 ; j < bestlen ; j++ )
						best_tris[j] = strip_tris[j];
				}
			}
		}

		// mark the tris on the best strip/fan as used
		for ( j = 0 ; j < bestlen ; j++ )
			used[best_tris[j]] = 1;

		if ( besttype == 1 ) {
			commands[numcommands++] = ( bestlen + 2 );
		}
		else{
			commands[numcommands++] = -( bestlen + 2 );
		}

		numglverts += bestlen + 2;

		for ( j = 0 ; j < bestlen + 2 ; j++ )
		{
			// emit a vertex into the reorder buffer
			k = best_st[j];

			// emit s/t coords into the commands stream
			s = base_st[k].s;
			t = base_st[k].t;

			s = ( s + 0.5 ) / model.skinwidth;
			t = ( t + 0.5 ) / model.skinheight;

			*(float *)&commands[numcommands++] = s;
			*(float *)&commands[numcommands++] = t;
			*(int *)&commands[numcommands++] = best_xyz[j];
		}
	}

	commands[numcommands++] = 0;        // end of list marker
}


/*
   ===============================================================

   BASE FRAME SETUP

   ===============================================================
 */

/*
   ============
   BuildST

   Builds the triangle_st array for the base frame and
   model.skinwidth / model.skinheight

   FIXME: allow this to be loaded from a file for
   arbitrary mappings
   ============
 */
#if 0
static void OldBuildST( triangle_t *ptri, int numtri ){
	int i, j;
	int width, height, iwidth, iheight, swidth;
	float basex, basey;
	float s_scale, t_scale;
	float scale;
	vec3_t mins, maxs;
	float       *pbasevert;
	vec3_t vtemp1, vtemp2, normal;

	//
	// find bounds of all the verts on the base frame
	//
	ClearBounds( mins, maxs );

	for ( i = 0 ; i < numtri ; i++ )
		for ( j = 0 ; j < 3 ; j++ )
			AddPointToBounds( ptri[i].verts[j], mins, maxs );

	for ( i = 0 ; i < 3 ; i++ )
	{
		mins[i] = floor( mins[i] );
		maxs[i] = ceil( maxs[i] );
	}

	width = maxs[0] - mins[0];
	height = maxs[2] - mins[2];

	if ( !g_fixedwidth ) { // old style
		scale = 8;
		if ( width * scale >= 150 ) {
			scale = 150.0 / width;
		}
		if ( height * scale >= 190 ) {
			scale = 190.0 / height;
		}

		s_scale = t_scale = scale;

		iwidth = ceil( width * s_scale );
		iheight = ceil( height * t_scale );

		iwidth += 4;
		iheight += 4;
	}
	else
	{   // new style
		iwidth = g_fixedwidth / 2;
		iheight = g_fixedheight;

		s_scale = (float)( iwidth - 4 ) / width;
		t_scale = (float)( iheight - 4 ) / height;
	}

//
// determine which side of each triangle to map the texture to
//
	for ( i = 0 ; i < numtri ; i++ )
	{
		VectorSubtract( ptri[i].verts[0], ptri[i].verts[1], vtemp1 );
		VectorSubtract( ptri[i].verts[2], ptri[i].verts[1], vtemp2 );
		CrossProduct( vtemp1, vtemp2, normal );

		if ( normal[1] > 0 ) {
			basex = iwidth + 2;
		}
		else
		{
			basex = 2;
		}
		basey = 2;

		for ( j = 0 ; j < 3 ; j++ )
		{
			pbasevert = ptri[i].verts[j];

			triangle_st[i][j][0] = Q_rint( ( pbasevert[0] - mins[0] ) * s_scale + basex );
			triangle_st[i][j][1] = Q_rint( ( maxs[2] - pbasevert[2] ) * t_scale + basey );
		}
	}

// make the width a multiple of 4; some hardware requires this, and it ensures
// dword alignment for each scan
	swidth = iwidth * 2;
	model.skinwidth = ( swidth + 3 ) & ~3;
	model.skinheight = iheight;
}
#endif

//==========================================================================
//
// DrawScreen
//
//==========================================================================

void DrawScreen( float s_scale, float t_scale, float iwidth, float iheight ){
	int i;
	byte *scrpos;
	char buffer[256];

	// Divider
	scrpos = &pic[( INFO_Y - 2 ) * SKINPAGE_WIDTH];
	for ( i = 0; i < SKINPAGE_WIDTH; i++ )
	{
		*scrpos++ = 255;
	}

	sprintf( buffer, "GENSKIN:  " );
	DrawTextChar( 16, INFO_Y, buffer );

	sprintf( buffer, "( %03d * %03d )   SCALE %f %f, SKINWIDTH %d,"
					 " SKINHEIGHT %d", (int)ScaleWidth, (int)ScaleHeight, s_scale, t_scale, (int)iwidth * 2, (int)iheight );
	DrawTextChar( 80, INFO_Y, buffer );
}

/*
   ============
   BuildST

   Builds the triangle_st array for the base frame and
   model.skinwidth / model.skinheight

   FIXME: allow this to be loaded from a file for
   arbitrary mappings
   ============
 */
void BuildST( triangle_t *ptri, int numtri, qboolean DrawSkin ){
	int i, j;
	int width, height, iwidth, iheight, swidth;
	float basex, basey;
	float scale;
	vec3_t mins, maxs;
	float       *pbasevert;
	vec3_t vtemp1, vtemp2, normal;
	float s_scale, t_scale;
	float scWidth;
	float scHeight;

	//
	// find bounds of all the verts on the base frame
	//
	ClearBounds( mins, maxs );

	for ( i = 0 ; i < numtri ; i++ )
		for ( j = 0 ; j < 3 ; j++ )
			AddPointToBounds( ptri[i].verts[j], mins, maxs );

	for ( i = 0 ; i < 3 ; i++ )
	{
		mins[i] = floor( mins[i] );
		maxs[i] = ceil( maxs[i] );
	}

	width = maxs[0] - mins[0];
	height = maxs[2] - mins[2];


	scWidth = ( ScaleWidth / 2 ) * SCALE_ADJUST_FACTOR;
	scHeight = ScaleHeight * SCALE_ADJUST_FACTOR;

	scale = scWidth / width;

	if ( height * scale >= scHeight ) {
		scale = scHeight / height;
	}

	iwidth = ceil( width * scale ) + 4;
	iheight = ceil( height * scale ) + 4;

	s_scale = (float)( iwidth - 4 ) / width;
	t_scale = (float)( iheight - 4 ) / height;
	t_scale = s_scale;

	if ( DrawSkin ) {
		DrawScreen( s_scale, t_scale, iwidth, iheight );
	}


/*	if (!g_fixedwidth)
    {	// old style
        scale = 8;
        if (width*scale >= 150)
            scale = 150.0 / width;
        if (height*scale >= 190)
            scale = 190.0 / height;

        s_scale = t_scale = scale;

        iwidth = ceil(width*s_scale);
        iheight = ceil(height*t_scale);

        iwidth += 4;
        iheight += 4;
    }
    else
    {	// new style
        iwidth = g_fixedwidth / 2;
        iheight = g_fixedheight;

        s_scale = (float)(iwidth-4) / width;
        t_scale = (float)(iheight-4) / height;
    }*/

//
// determine which side of each triangle to map the texture to
//
	for ( i = 0 ; i < numtri ; i++ )
	{
		if ( ptri[i].HasUV ) {
			for ( j = 0 ; j < 3 ; j++ )
			{
				triangle_st[i][j][0] = Q_rint( ptri[i].uv[j][0] * iwidth );
				triangle_st[i][j][1] = Q_rint( ( 1.0f - ptri[i].uv[j][1] ) * iheight );
			}
		}
		else
		{
			VectorSubtract( ptri[i].verts[0], ptri[i].verts[1], vtemp1 );
			VectorSubtract( ptri[i].verts[2], ptri[i].verts[1], vtemp2 );
			CrossProduct( vtemp1, vtemp2, normal );

			if ( normal[1] > 0 ) {
				basex = iwidth + 2;
			}
			else
			{
				basex = 2;
			}
			basey = 2;

			for ( j = 0 ; j < 3 ; j++ )
			{
				pbasevert = ptri[i].verts[j];

				triangle_st[i][j][0] = Q_rint( ( pbasevert[0] - mins[0] ) * s_scale + basex );
				triangle_st[i][j][1] = Q_rint( ( maxs[2] - pbasevert[2] ) * t_scale + basey );
			}
		}

		DrawLine( triangle_st[i][0][0], triangle_st[i][0][1],
				  triangle_st[i][1][0], triangle_st[i][1][1] );
		DrawLine( triangle_st[i][1][0], triangle_st[i][1][1],
				  triangle_st[i][2][0], triangle_st[i][2][1] );
		DrawLine( triangle_st[i][2][0], triangle_st[i][2][1],
				  triangle_st[i][0][0], triangle_st[i][0][1] );
	}

// make the width a multiple of 4; some hardware requires this, and it ensures
// dword alignment for each scan

	swidth = iwidth * 2;
	model.skinwidth = ( swidth + 3 ) & ~3;
	model.skinheight = iheight;
}


static void ReplaceClusterIndex( int newIndex, int oldindex, int **clusters,
								 IntListNode_t **vertLists, int *num_verts, int *new_num_verts ){
	int i, j;
	IntListNode_t *next;

	for ( j = 0; j < num_verts[0]; ++j )
	{
		for ( i = 0; i < num_verts[j + 1]; ++i )
		{
			if ( clusters[j][i] == oldindex ) {
				++new_num_verts[j + 1];

				next = vertLists[j];

				vertLists[j] = (IntListNode_t *) SafeMalloc( sizeof( IntListNode_t ), "ReplaceClusterIndex" );
				// Currently freed in WriteJointedModelFile only

				vertLists[j]->data = newIndex;
				vertLists[j]->next = next;
			}
		}
	}
}

/*
   =================
   Cmd_Base
   =================
 */
void Cmd_Base( void ){
	vec3_t base_xyz[MAX_VERTS];
	triangle_t  *ptri;
	int i, j, k;
#if 1
#else
	int time1;
#endif
	char file1[1024];
	char file2[1024];

	GetScriptToken( false );

	if ( g_skipmodel || g_release || g_archive ) {
		return;
	}

	printf( "---------------------\n" );
#if 1
	sprintf( file1, "%s/%s", cdpartial, token );
	printf( "%s  ", file1 );

	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s", cddir, token );
#else
	sprintf( file1, "%s/%s.%s", cdarchive, token, trifileext );
	printf( "%s\n", file1 );

	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s.%s", cddir, token, trifileext );

	time1 = FileTime( file1 );
	if ( time1 == -1 ) {
		Error( "%s doesn't exist", file1 );
	}
#endif
//
// load the base triangles
//
	if ( do3ds ) {
		Load3DSTriangleList( file1, &ptri, &model.num_tris, NULL, NULL );
	}
	else{
		LoadTriangleList( file1, &ptri, &model.num_tris, NULL, NULL );
	}


	GetScriptToken( false );
	sprintf( file2, "%s/%s.pcx", cddir, token );
//	sprintf (trans_file, "%s/!%s_a.pcx", cddir, token);

	printf( "skin: %s\n", file2 );
	Load256Image( file2, &BasePixels, &BasePalette, &BaseWidth, &BaseHeight );

	if ( BaseWidth != SKINPAGE_WIDTH || BaseHeight != SKINPAGE_HEIGHT ) {
		if ( g_allow_newskin ) {
			ScaleWidth = BaseWidth;
			ScaleHeight = BaseHeight;
		}
		else
		{
			Error( "Invalid skin page size: (%d,%d) should be (%d,%d)",
				   BaseWidth,BaseHeight,SKINPAGE_WIDTH,SKINPAGE_HEIGHT );
		}
	}
	else
	{
		ScaleWidth = (float)ExtractNumber( BasePixels, ENCODED_WIDTH_X,
										   ENCODED_WIDTH_Y );
		ScaleHeight = (float)ExtractNumber( BasePixels, ENCODED_HEIGHT_X,
											ENCODED_HEIGHT_Y );
	}

//
// get the ST values
//
	BuildST( ptri, model.num_tris,false );

//
// run through all the base triangles, storing each unique vertex in the
// base vertex list and setting the indirect triangles to point to the base
// vertices
//
	for ( i = 0 ; i < model.num_tris ; i++ )
	{
		for ( j = 0 ; j < 3 ; j++ )
		{
			// get the xyz index
			for ( k = 0 ; k < model.num_xyz ; k++ )
				if ( VectorCompare( ptri[i].verts[j], base_xyz[k] ) ) {
					break;
				}           // this vertex is already in the base vertex list

			if ( k == model.num_xyz ) { // new index
				VectorCopy( ptri[i].verts[j], base_xyz[model.num_xyz] );

				if ( clustered ) {
					ReplaceClusterIndex( k, ptri[i].indicies[j], (int **)&clusters, (IntListNode_t **)&vertLists, (int *)&num_verts, (int *)&new_num_verts );
				}

				model.num_xyz++;
			}

			triangles[i].index_xyz[j] = k;

			// get the st index
			for ( k = 0 ; k < model.num_st ; k++ )
				if ( triangle_st[i][j][0] == base_st[k].s
					 && triangle_st[i][j][1] == base_st[k].t ) {
					break;
				}           // this vertex is already in the base vertex list

			if ( k == model.num_st ) { // new index
				base_st[model.num_st].s = triangle_st[i][j][0];
				base_st[model.num_st].t = triangle_st[i][j][1];
				model.num_st++;
			}

			triangles[i].index_st[j] = k;
		}
	}

	// build triangle strips / fans
	BuildGlCmds();
}

//===============================================================

char    *FindFrameFile( char *frame ){
	int time1;
	char file1[1024];
	static char retname[1024];
	char base[32];
	char suffix[32];
	char            *s;

	if ( strstr( frame, "." ) ) {
		return frame;       // allready in dot format

	}
	// split 'run1' into 'run' and '1'
	s = frame + strlen( frame ) - 1;

	while ( s != frame && *s >= '0' && *s <= '9' )
		s--;

	strcpy( suffix, s + 1 );
	strcpy( base, frame );
	base[s - frame + 1] = 0;

	sprintf( file1, "%s/%s%s.%s",cddir, base, suffix, "hrc" );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s%s.%s", base, suffix, "hrc" );
		return retname;
	}

	sprintf( file1, "%s/%s%s.%s",cddir, base, suffix, "asc" );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s%s.%s", base, suffix, "asc" );
		return retname;
	}

	sprintf( file1, "%s/%s%s.%s",cddir, base, suffix, "tri" );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s%s.%s", base, suffix, "tri" );
		return retname;
	}

	sprintf( file1, "%s/%s%s.%s",cddir, base, suffix, "3ds" );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s%s.%s", base, suffix, "3ds" );
		return retname;
	}

	sprintf( file1, "%s/%s%s.%s",cddir, base, suffix, "htr" );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s%s.%s", base, suffix, "htr" );
		return retname;
	}

	// check for 'run.1'
	sprintf( file1, "%s/%s.%s",cddir, base, suffix );
	time1 = FileTime( file1 );
	if ( time1 != -1 ) {
		sprintf( retname, "%s.%s", base, suffix );
		return retname;
	}

	Error( "frame %s could not be found",frame );
	return NULL;
}

/*
   ===============
   GrabFrame
   ===============
 */
static void GrabFrame( char *frame ){
	triangle_t      *ptri;
	int i, j;
	trivert_t       *ptrivert;
	int num_tris;
	char file1[1024];
	frame_t         *fr;
	vertexnormals_t vnorms[MAX_VERTS];
	int index_xyz;
	char            *framefile;

	// the frame 'run1' will be looked for as either
	// run.1 or run1.tri, so the new alias sequence save
	// feature an be used
	framefile = FindFrameFile( frame );

	sprintf( file1, "%s/%s", cdarchive, framefile );
	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s",cddir, framefile );

	printf( "grabbing %s  ", file1 );

	if ( model.num_frames >= MAX_FRAMES ) {
		Error( "model.num_frames >= MAX_FRAMES" );
	}
	fr = &g_frames[model.num_frames];
	model.num_frames++;

	strcpy( fr->name, frame );

//
// load the frame
//
	if ( do3ds ) {
		Load3DSTriangleList( file1, &ptri, &num_tris, NULL, NULL );
	}
	else{
		LoadTriangleList( file1, &ptri, &num_tris, NULL, NULL );
	}

	if ( num_tris != model.num_tris ) {
		Error( "%s: number of triangles doesn't match base frame\n", file1 );
	}

//
// allocate storage for the frame's vertices
//
	ptrivert = fr->v;

	for ( i = 0 ; i < model.num_xyz ; i++ )
	{
		vnorms[i].numnormals = 0;
		VectorClear( vnorms[i].normalsum );
	}
	ClearBounds( fr->mins, fr->maxs );

//
// store the frame's vertices in the same order as the base. This assumes the
// triangles and vertices in this frame are in exactly the same order as in the
// base
//
	for ( i = 0 ; i < num_tris ; i++ )
	{
		vec3_t vtemp1, vtemp2, normal;
		float ftemp;

		VectorSubtract( ptri[i].verts[0], ptri[i].verts[1], vtemp1 );
		VectorSubtract( ptri[i].verts[2], ptri[i].verts[1], vtemp2 );
		CrossProduct( vtemp1, vtemp2, normal );

		VectorNormalize( normal, normal );

		// rotate the normal so the model faces down the positive x axis
		ftemp = normal[0];
		normal[0] = -normal[1];
		normal[1] = ftemp;

		for ( j = 0 ; j < 3 ; j++ )
		{
			index_xyz = triangles[i].index_xyz[j];

			// rotate the vertices so the model faces down the positive x axis
			// also adjust the vertices to the desired origin
			ptrivert[index_xyz].v[0] = ( ( -ptri[i].verts[j][1] ) * scale_up ) +
									   adjust[0];
			ptrivert[index_xyz].v[1] = ( ptri[i].verts[j][0] * scale_up ) +
									   adjust[1];
			ptrivert[index_xyz].v[2] = ( ptri[i].verts[j][2] * scale_up ) +
									   adjust[2];

			AddPointToBounds( ptrivert[index_xyz].v, fr->mins, fr->maxs );

			VectorAdd( vnorms[index_xyz].normalsum, normal, vnorms[index_xyz].normalsum );
			vnorms[index_xyz].numnormals++;
		}
	}

//
// calculate the vertex normals, match them to the template list, and store the
// index of the best match
//
	for ( i = 0 ; i < model.num_xyz ; i++ )
	{
		int j;
		vec3_t v;
		float maxdot;
		int maxdotindex;
		int c;

		c = vnorms[i].numnormals;
		if ( !c ) {
			Error( "Vertex with no triangles attached" );
		}

		VectorScale( vnorms[i].normalsum, 1.0 / c, v );
		VectorNormalize( v, v );

		maxdot = -999999.0;
		maxdotindex = -1;

		for ( j = 0 ; j < NUMVERTEXNORMALS ; j++ )
		{
			float dot;

			dot = DotProduct( v, avertexnormals[j] );
			if ( dot > maxdot ) {
				maxdot = dot;
				maxdotindex = j;
			}
		}

		ptrivert[i].lightnormalindex = maxdotindex;
	}

	free( ptri );
}

/*
   ===============
   GrabJointedFrame
   ===============
 */
void GrabJointedFrame( char *frame ){
	char file1[1024];
	char    *framefile;
	frame_t     *fr;

	framefile = FindFrameFile( frame );

	sprintf( file1, "%s/%s", cdarchive, framefile );
	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s",cddir, framefile );

	printf( "grabbing %s\n", file1 );

	fr = &g_frames[model.num_frames - 1]; // last frame read in

	LoadJointList( file1, fr->joints, jointed );
}

/*
   ===============
   GrabGlobals
   ===============
 */
void GrabGlobals( char *frame ){
	char file1[1024];
	char    *framefile;
	frame_t     *fr;

	framefile = FindFrameFile( frame );

	sprintf( file1, "%s/%s", cdarchive, framefile );
	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s",cddir, framefile );

	printf( "grabbing %s\n", file1 );

	fr = &g_frames[model.num_frames - 1]; // last frame read in

	LoadGlobals( file1 );
}

/*
   ===============
   Cmd_Frame
   ===============
 */
void Cmd_Frame( void ){
	while ( ScriptTokenAvailable() )
	{
		GetScriptToken( false );
		if ( g_skipmodel ) {
			continue;
		}
		if ( g_release || g_archive ) {
			model.num_frames = 1;   // don't skip the writeout
			continue;
		}

		H_printf( "#define FRAME_%-16s\t%i\n", token, model.num_frames );

		GrabFrame( token );
	}
}

/*
   ===============
   Cmd_Skin

   Skins aren't actually stored in the file, only a reference
   is saved out to the header file.
   ===============
 */
void Cmd_Skin( void ){
	byte    *palette;
	byte    *pixels;
	int width, height;
	byte    *cropped;
	int y;
	char name[1024], savename[1024];

	GetScriptToken( false );

	if ( model.num_skins == MAX_MD2SKINS ) {
		Error( "model.num_skins == MAX_MD2SKINS" );
	}

	if ( g_skipmodel ) {
		return;
	}

#if 1
	sprintf( name, "%s/%s.pcx", cddir, token );
	sprintf( savename, "%s/!%s.pcx", g_outputDir, token );
	sprintf( g_skins[model.num_skins], "%s/!%s.pcx", cdpartial, token );
#else
	sprintf( name, "%s/%s.lbm", cdarchive, token );
	strcpy( name, ExpandPathAndArchive( name ) );
//	sprintf (name, "%s/%s.lbm", cddir, token);

	if ( ScriptTokenAvailable() ) {
		GetScriptToken( false );
		sprintf( g_skins[model.num_skins], "%s.pcx", token );
		sprintf( savename, "%s%s.pcx", g_outputDir, g_skins[model.num_skins] );
	}
	else
	{
		sprintf( savename, "%s/%s.pcx", g_outputDir, token );
		sprintf( g_skins[model.num_skins], "%s/%s.pcx", cdpartial, token );
	}
#endif

	model.num_skins++;

	if ( g_skipmodel || g_release || g_archive ) {
		return;
	}

	// load the image
	printf( "loading %s\n", name );
	Load256Image( name, &pixels, &palette, &width, &height );
//	RemapZero (pixels, palette, width, height);

	// crop it to the proper size
	cropped = (byte *) SafeMalloc( model.skinwidth * model.skinheight, "Cmd_Skin" );
	for ( y = 0 ; y < model.skinheight ; y++ )
	{
		memcpy( cropped + y * model.skinwidth,
				pixels + y * width, model.skinwidth );
	}

	// save off the new image
	printf( "saving %s\n", savename );
	CreatePath( savename );
	WritePCXfile( savename, cropped, model.skinwidth,
				  model.skinheight, palette );

	free( pixels );
	free( palette );
	free( cropped );
}


/*
   =================
   Cmd_Origin
   =================
 */
void Cmd_Origin( void ){
	// rotate points into frame of reference so model points down the
	// positive x axis
	GetScriptToken( false );
	adjust[1] = -atof( token );

	GetScriptToken( false );
	adjust[0] = atof( token );

	GetScriptToken( false );
	adjust[2] = -atof( token );
}


/*
   =================
   Cmd_ScaleUp
   =================
 */
void Cmd_ScaleUp( void ){
	GetScriptToken( false );
	scale_up = atof( token );
	if ( g_skipmodel || g_release || g_archive ) {
		return;
	}

	printf( "Scale up: %f\n", scale_up );
}


/*
   =================
   Cmd_Skinsize

   Set a skin size other than the default
   =================
 */
void Cmd_Skinsize( void ){
	GetScriptToken( false );
	g_fixedwidth = atoi( token );
	GetScriptToken( false );
	g_fixedheight = atoi( token );
}

/*
   =================
   Cmd_Modelname

   Gives a different name/location for the file, instead of the cddir
   =================
 */
void Cmd_Modelname( void ){
	GetScriptToken( false );
	strcpy( modelname, token );
}

/*
   ===============
   Cmd_Cd
   ===============
 */
void Cmd_Cd( void ){
	char temp[256];

	FinishModel();
	ClearModel();

	GetScriptToken( false );

	// this is a silly mess...
	sprintf( cdpartial, "models/%s", token );
	sprintf( cdarchive, "%smodels/%s", gamedir + strlen( qdir ), token );
	sprintf( cddir, "%s%s", gamedir, cdpartial );

	// Since we also changed directories on the output side (for mirror) make sure the outputdir is set properly too.
	sprintf( temp, "%s%s", g_outputDir, cdpartial );
	strcpy( g_outputDir, temp );

	// if -only was specified and this cd doesn't match,
	// skip the model (you only need to match leading chars,
	// so you could regrab all monsters with -only monsters)
	if ( !g_only[0] ) {
		return;
	}
	if ( strncmp( token, g_only, strlen( g_only ) ) ) {
		g_skipmodel = true;
		printf( "skipping %s\n", cdpartial );
	}
}

/*
   =================
   Cmd_Cluster
   =================
 */
void Cmd_Cluster(){
	char file1[1024];

	GetScriptToken( false );

	printf( "---------------------\n" );
	sprintf( file1, "%s/%s", cdpartial, token );
	printf( "%s\n", file1 );

	ExpandPathAndArchive( file1 );

	sprintf( file1, "%s/%s", cddir, token );

	LoadClusters( file1, (int **)&clusters, (int *)&num_verts, jointed );

	new_num_verts[0] = num_verts[0];

	clustered = 1;
}

// Model construction cover functions.
void MODELCMD_Modelname( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	Cmd_Modelname();
/*
    switch(modeltype)
    {
    case MODEL_MD2:
        Cmd_Modelname ();
        break;
    case MODEL_FM:
        Cmd_FMModelname ();
        break;
    }
 */
}

void MODELCMD_Cd( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Cd();
		break;
	case MODEL_FM:
		Cmd_FMCd();
		break;
	}
}

void MODELCMD_Origin( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	Cmd_Origin();
/*	switch(modeltype)
    {
    case MODEL_MD2:
        Cmd_Origin ();
        break;
    case MODEL_FM:
        Cmd_FMOrigin ();
        break;
    }
 */
}

void MODELCMD_Cluster( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Cluster();
		break;
	case MODEL_FM:
		Cmd_FMCluster();
		break;
	}
}

void MODELCMD_Base( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Base();
		break;
	case MODEL_FM:
		Cmd_FMBase( false );
		break;
	}
}

void MODELCMD_BaseST( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Base();
		break;
	case MODEL_FM:
		Cmd_FMBase( true );
		break;
	}
}

void MODELCMD_ScaleUp( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	Cmd_ScaleUp();
/*	switch(modeltype)
    {
    case MODEL_MD2:
        Cmd_ScaleUp ();
        break;
    case MODEL_FM:
        Cmd_FMScaleUp ();
        break;
    }
 */
}

void MODELCMD_Frame( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Frame();
		break;
	case MODEL_FM:
		Cmd_FMFrame();
		break;
	}
}

void MODELCMD_Skin( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		Cmd_Skin();
		break;
	case MODEL_FM:
		Cmd_FMSkin();
		break;
	}
}

void MODELCMD_Skinsize( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	Cmd_Skinsize();
/*
    switch(modeltype)
    {
    case MODEL_MD2:
        Cmd_Skinsize ();
        break;
    case MODEL_FM:
        Cmd_FMSkinsize ();
        break;
    }
 */
}

void MODELCMD_Skeleton( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		break;
	case MODEL_FM:
		Cmd_FMSkeleton();
		break;
	}
}

void MODELCMD_BeginGroup( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		break;
	case MODEL_FM:
		Cmd_FMBeginGroup();
		break;
	}
}

void MODELCMD_EndGroup( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		break;
	case MODEL_FM:
		Cmd_FMEndGroup();
		break;
	}
}

void MODELCMD_Referenced( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		break;
	case MODEL_FM:
		Cmd_FMReferenced();
		break;
	}
}

void MODELCMD_NodeOrder( int modeltype ){
	if ( g_forcemodel ) {
		modeltype = g_forcemodel;
	}

	switch ( modeltype )
	{
	case MODEL_MD2:
		break;
	case MODEL_FM:
		Cmd_FMNodeOrder();
		break;
	}
}