/*
Copyright (C) 1999-2006 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 "qd_fmodel.h"
#include "animcomp.h"
#include "qd_skeletons.h"
#include "skeletons.h"
#include "qdata.h"
#include "flex.h"
#include "reference.h"

#include <assert.h>

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

.FM triangle flexible model file format

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

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

#define NUMVERTEXNORMALS	162

extern float	avertexnormals[NUMVERTEXNORMALS][3];

#define MAX_GROUPS	128

typedef struct
{
	triangle_t	triangle;
	int		group;
} trigroup_t;

#define TRIVERT_DIST	.1

typedef struct
{
	int			start_frame;
	int		num_frames;
	int			degrees;
	char *mat;
	char *ccomp;
	char *cbase;
	float *cscale;
	float *coffset;
	float trans[3];
	float scale[3];
	float bmin[3];
	float bmax[3];
} fmgroup_t;

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

// Initial
fmheader_t	fmheader;

// Skin
extern char			g_skins[MAX_FM_SKINS][64];

// ST Coord
extern fmstvert_t	base_st[MAX_FM_VERTS];

// Triangles
extern fmtriangle_t	triangles[MAX_FM_TRIANGLES];

// Frames
fmframe_t	g_frames[MAX_FM_FRAMES];
//fmframe_t	*g_FMframes;

// GL Commands
extern int			commands[16384];
extern int			numcommands;


//
// varibles set by commands
//
extern float		scale_up;						// set by $scale
extern vec3_t		adjust;							// set by $origin
extern int			g_fixedwidth, g_fixedheight;	// set by $skinsize
extern char			modelname[64];					// set by $modelname


extern 	char		*g_outputDir;


// Mesh Nodes
mesh_node_t	*pmnodes = NULL;
fmmeshnode_t	mesh_nodes[MAX_FM_MESH_NODES]; 

fmgroup_t	groups[MAX_GROUPS];
int			num_groups;
int	frame_to_group[MAX_FM_FRAMES];

//
// variables set by command line arguments
//
qboolean	g_no_opimizations = false;


//
// base frame info
//
static int			triangle_st[MAX_FM_TRIANGLES][3][2];


// number of gl vertices
extern int			numglverts;
// indicates if a triangle has already been used in a glcmd
extern int			used[MAX_FM_TRIANGLES];
// indicates if a triangle has translucency in it or not
static qboolean		translucent[MAX_FM_TRIANGLES];

// main output file handle
extern FILE			*headerouthandle;
// output sizes of buildst()
static int			skin_width, skin_height;


// statistics
static int			total_skin_pixels;
static int			skin_pixels_used;

int ShareVertex( trigroup_t trione, trigroup_t tritwo);
float DistBetween(vec3_t point1, vec3_t point2);
int GetNumTris( trigroup_t *tris, int group);
void GetOneGroup(trigroup_t *tris, int grp, triangle_t* triangles);
void ScaleTris( vec3_t min, vec3_t max, int Width, int Height, float* u, float* v, int verts);
void NewDrawLine(int x1, int y1, int x2, int y2, unsigned char* picture, int width, int height);

#ifndef _WIN32

void strupr(char *string)
{
	int i;

	for (i=0 ; i<strlen(string); i++)
		toupper(string[i]);

	return;
}

#endif
//==============================================================

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

	modelname[0] = 0;
	scale_up = 1.0;	
	VectorCopy (vec3_origin, adjust);
	g_fixedwidth = g_fixedheight = 0;
	g_skipmodel = false;
	num_groups = 0;

	if (pmnodes)
	{
		free(pmnodes);
		pmnodes = NULL;
	}

	ClearSkeletalModel();
}


extern void H_printf(char *fmt, ...);


void WriteHeader(FILE *FH, char *Ident, int Version, int Size, void *Data)
{
	header_t	header;
	static long	pos = -1;
	long		CurrentPos;

	if (Size == 0)
	{	// Don't write out empty packets
		return;
	}

	if (pos != -1)
	{
		CurrentPos = ftell(FH);
		Size = CurrentPos - pos + sizeof(header_t);
		fseek(FH, pos, SEEK_SET);
		pos = -2;
	}
	else if (Size == -1)
	{
		pos = ftell(FH);
	}

	memset(&header,0,sizeof(header));
	strcpy(header.ident,Ident);
	header.version = Version;
	header.size = Size;

	SafeWrite (FH, &header, sizeof(header));

	if (Data)
	{
		SafeWrite (FH, Data, Size);
	}

	if (pos == -2)
	{
		pos = -1;
		fseek(FH, 0, SEEK_END);
	}
}

/*
============
WriteModelFile
============
*/
static void WriteModelFile (FILE *modelouthandle)
{
	int				i;
	int				j, k;
	fmframe_t		*in;
	fmaliasframe_t	*out;
	byte			buffer[MAX_FM_VERTS*4+128];
	float			v;
	int				c_on, c_off;
	IntListNode_t	*current, *toFree;
	qboolean framesWritten = false;
	size_t temp ,size = 0;

	// probably should do this dynamically one of these days
	struct
	{
		float		scale[3];	// multiply byte verts by this
		float		translate[3];	// then add this
	} outFrames[MAX_FM_FRAMES];

#define DATA_SIZE 0x60000		// 384K had better be enough, particularly for the reference points
	byte data[DATA_SIZE];
	byte data2[DATA_SIZE];

	fmheader.num_glcmds = numcommands;
	fmheader.framesize = (int)&((fmaliasframe_t *)0)->verts[fmheader.num_xyz];

	WriteHeader(modelouthandle, FM_HEADER_NAME, FM_HEADER_VER, sizeof(fmheader), &fmheader);

	//
	// write out the skin names
	//

 	WriteHeader(modelouthandle, FM_SKIN_NAME, FM_SKIN_VER, fmheader.num_skins * MAX_FM_SKINNAME, g_skins);

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

	WriteHeader(modelouthandle, FM_ST_NAME, FM_ST_VER, fmheader.num_st * sizeof(base_st[0]), base_st);

	//
	// write out the triangles
	//
	WriteHeader(modelouthandle, FM_TRI_NAME, FM_TRI_VER, fmheader.num_tris * sizeof(fmtriangle_t), NULL);

	for (i=0 ; i<fmheader.num_tris ; i++)
	{
		int				j;
		fmtriangle_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));
	}

	if (!num_groups)
	{
		//
		// write out the frames
		//
		WriteHeader(modelouthandle, FM_FRAME_NAME, FM_FRAME_VER, fmheader.num_frames * fmheader.framesize, NULL);
	//	WriteHeader(modelouthandle, FM_FRAME_NAME, FM_FRAME_VER, -1, NULL);

		for (i=0 ; i<fmheader.num_frames ; i++)
		{
			in = &g_frames[i];
			out = (fmaliasframe_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];

				outFrames[i].scale[j] = out->scale[j];
				outFrames[i].translate[j] = out->translate[j];
			}

			for (j=0 ; j<fmheader.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, fmheader.framesize);
		}

		// Go back and finish the header
	//	WriteHeader(modelouthandle, FM_FRAME_NAME, FM_FRAME_VER, -1, NULL);
	}
	else
	{
		WriteHeader(modelouthandle, FM_SHORT_FRAME_NAME, FM_SHORT_FRAME_VER,FRAME_NAME_LEN*fmheader.num_frames, NULL);
		for (i=0 ; i<fmheader.num_frames ; i++)
		{
			in = &g_frames[i];
			SafeWrite (modelouthandle,in->name,FRAME_NAME_LEN);
		}
		WriteHeader(modelouthandle, FM_NORMAL_NAME, FM_NORMAL_VER,fmheader.num_xyz, NULL);
		in = &g_frames[0];
		for (j=0 ; j<fmheader.num_xyz ; j++)
			SafeWrite (modelouthandle,&in->v[j].lightnormalindex,1);
	}

	//
	// write out glcmds
	//
	WriteHeader(modelouthandle, FM_GLCMDS_NAME, FM_GLCMDS_VER, numcommands*4, commands);

	//
	// write out mesh nodes
	//
	for(i=0;i<fmheader.num_mesh_nodes;i++)
	{
		memcpy(mesh_nodes[i].tris, pmnodes[i].tris, sizeof(mesh_nodes[i].tris));
		memcpy(mesh_nodes[i].verts, pmnodes[i].verts, sizeof(mesh_nodes[i].verts));
		mesh_nodes[i].start_glcmds = LittleShort((short)pmnodes[i].start_glcmds);
		mesh_nodes[i].num_glcmds = LittleShort((short)pmnodes[i].num_glcmds);
	}

	WriteHeader(modelouthandle, FM_MESH_NAME, FM_MESH_VER, sizeof(fmmeshnode_t) * fmheader.num_mesh_nodes, mesh_nodes);

	if (num_groups)
	{

/*
typedef struct
{
	int			start_frame;
	int			num_frames;
	int			degrees;
	char *mat; fmheader.num_xyz*3*g->degrees*sizeof(char)
	char *ccomp; g->num_frames*g->degrees*sizeof(char)
	char *cbase; fmheader.num_xyz*3*sizeof(unsigned char)
	float *cscale; g->degrees*sizeof(float)
	float *coffset; g->degrees*sizeof(float)
	float trans[3]; 3*sizeof(float)
	float scale[3]; 3*sizeof(float)
} fmgroup_t;
*/
		int tmp,k;
		fmgroup_t *g;
		size=sizeof(int)+fmheader.num_frames*sizeof(int);
		for (k=0;k<num_groups;k++)
		{
			g=&groups[k];
			size+=sizeof(int)*3;
			size+=fmheader.num_xyz*3*g->degrees*sizeof(char);
			size+=g->num_frames*g->degrees*sizeof(char);
			size+=fmheader.num_xyz*3*sizeof(unsigned char);
			size+=g->degrees*sizeof(float);
			size+=g->degrees*sizeof(float);
			size+=12*sizeof(float);
		}
		WriteHeader(modelouthandle, FM_COMP_NAME, FM_COMP_VER,size, NULL);
		SafeWrite (modelouthandle,&num_groups,sizeof(int));
		SafeWrite (modelouthandle,frame_to_group,sizeof(int)*fmheader.num_frames);

		for (k=0;k<num_groups;k++)
		{
			g=&groups[k];
			tmp=LittleLong(g->start_frame);
			SafeWrite (modelouthandle,&tmp,sizeof(int));
			tmp=LittleLong(g->num_frames);
			SafeWrite (modelouthandle,&tmp,sizeof(int));
			tmp=LittleLong(g->degrees);
			SafeWrite (modelouthandle,&tmp,sizeof(int));

			SafeWrite (modelouthandle,g->mat,fmheader.num_xyz*3*g->degrees*sizeof(char));
			SafeWrite (modelouthandle,g->ccomp,g->num_frames*g->degrees*sizeof(char));
			SafeWrite (modelouthandle,g->cbase,fmheader.num_xyz*3*sizeof(unsigned char));
			SafeWrite (modelouthandle,g->cscale,g->degrees*sizeof(float));
			SafeWrite (modelouthandle,g->coffset,g->degrees*sizeof(float));
			SafeWrite (modelouthandle,g->trans,3*sizeof(float));
			SafeWrite (modelouthandle,g->scale,3*sizeof(float));
			SafeWrite (modelouthandle,g->bmin,3*sizeof(float));
			SafeWrite (modelouthandle,g->bmax,3*sizeof(float));
			free(g->mat);
			free(g->ccomp);
			free(g->cbase);
			free(g->cscale);
			free(g->coffset);
		}
	}

	// write the skeletal info
	if(g_skelModel.type != SKEL_NULL)
	{
		size = 0;

		temp = sizeof(int);		// change this to a byte
		memcpy(data + size, &g_skelModel.type, temp);
		size += temp;

		// number of joints
		temp = sizeof(int);		// change this to a byte
		memcpy(data + size, &numJointsInSkeleton[g_skelModel.type], temp);
		size += temp;

		// number of verts in each joint cluster
		temp = sizeof(int)*numJointsInSkeleton[g_skelModel.type]; // change this to shorts
		memcpy(data + size, &g_skelModel.new_num_verts[1], temp);
		size += temp;

		// cluster verts
		for(i = 0; i < numJointsInSkeleton[g_skelModel.type]; ++i)
		{
			current = g_skelModel.vertLists[i];
			while(current)
			{
				temp = sizeof(int);	// change this to a short
				memcpy(data + size, &current->data, temp);
				size += temp;
				toFree = current;
				current = current->next;
				free(toFree);  // freeing of memory allocated in ReplaceClusterIndex called in Cmd_Base
			}
		}

		if(!num_groups) // joints are stored with regular verts for compressed models
		{
			framesWritten = true;

			temp = sizeof(int);	// change this to a byte
			memcpy(data + size, &framesWritten, temp);
			size += temp;

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

				for (j = 0 ; j < numJointsInSkeleton[g_skelModel.type]; ++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] );

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data + size, &v, temp);
						size += temp;
					}

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

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data + size, &v, temp);
						size += temp;
					}

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

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data + size, &v, temp);
						size += temp;
					}
				}
			}

		}
		else
		{
			temp = sizeof(int);	// change this to a byte
			memcpy(data + size, &framesWritten, temp);
			size += temp;
		}

		WriteHeader(modelouthandle, FM_SKELETON_NAME, FM_SKELETON_VER, size, data);
	}

	if(g_skelModel.references != REF_NULL)
	{
		int refnum;

		size = 0;
		if (RefPointNum <= 0)
		{	// Hard-coded labels
			refnum = numReferences[g_skelModel.references];
		}
		else
		{	// Labels indicated in QDT
			refnum = RefPointNum;
		}

		temp = sizeof(int);	// change this to a byte
		memcpy(data2 + size, &g_skelModel.references, temp);
		size += temp;

		if(!num_groups)
		{
			framesWritten = true;

			temp = sizeof(int);	// change this to a byte
			memcpy(data2 + size, &framesWritten, temp);
			size += temp;

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

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

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data2 + size, &v, temp);
						size += temp;
					}

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

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data2 + size, &v, temp);
						size += temp;
					}

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

						// write out origin as a float since they arn't clamped
						temp = sizeof(float);	// change this to a short
						assert(size+temp < DATA_SIZE);
						memcpy(data2 + size, &v, temp);
						size += temp;
					}
				}
			}
		}
		else	// FINISH ME: references need to be stored with regular verts for compressed models
		{
			framesWritten = false;

			temp = sizeof(int);	// change this to a byte
			memcpy(data2 + size, &framesWritten, temp);
			size += temp;
		}

		WriteHeader(modelouthandle, FM_REFERENCES_NAME, FM_REFERENCES_VER, size, data2);
	}
}

static void CompressFrames()
{
	fmgroup_t *g;
	int i,j,k;
	fmframe_t	*in;

	j=0;
	for (i=0;i<fmheader.num_frames;i++)
	{
		while (i>=groups[j].start_frame+groups[j].num_frames&&j<num_groups-1)
			j++;
		frame_to_group[i]=j;
	}

	for (k=0;k<num_groups;k++)
	{
		g=&groups[k];

		printf("\nCompressing Frames for group %i...\n", k);
		AnimCompressInit(g->num_frames,fmheader.num_xyz,g->degrees);
		for (i=0;i<g->num_frames;i++)
		{
			in = &g_frames[i+g->start_frame];
			for (j=0;j<fmheader.num_xyz;j++)
				AnimSetFrame(i,j,in->v[j].v[0],in->v[j].v[1],in->v[j].v[2]);
		}
		AnimCompressDoit();
		g->mat= (char *) SafeMalloc(fmheader.num_xyz*3*g->degrees*sizeof(char), "CompressFrames");
		g->ccomp=(char *) SafeMalloc(g->num_frames*g->degrees*sizeof(char), "CompressFrames");
		g->cbase=(char *) SafeMalloc(fmheader.num_xyz*3*sizeof(unsigned char), "CompressFrames");
		g->cscale=(float *) SafeMalloc(g->degrees*sizeof(float), "CompressFrames");
		g->coffset=(float *) SafeMalloc(g->degrees*sizeof(float), "CompressFrames");
		AnimCompressToBytes(g->trans,g->scale,g->mat,g->ccomp,g->cbase,g->cscale,g->coffset,g->bmin,g->bmax);
		AnimCompressEnd();
	}
}

static void OptimizeVertices(void)
{
	qboolean	vert_used[MAX_FM_VERTS];
	short		vert_replacement[MAX_FM_VERTS];
	int			i,j,k,l,pos,bit,set_pos,set_bit;
	fmframe_t	*in;
	qboolean	Found;
	int			num_unique;
	static IntListNode_t *newVertLists[NUM_CLUSTERS];
	static int newNum_verts[NUM_CLUSTERS];
	IntListNode_t *current, *next;

	printf("Optimizing vertices...");

	memset(vert_used, 0, sizeof(vert_used));

	if(g_skelModel.clustered == true)
	{
		memset(newNum_verts, 0, sizeof(newNum_verts));
		memset(newVertLists, 0, sizeof(newVertLists));
	}

	num_unique = 0;

	// search for common points among all the frames
	for (i=0 ; i<fmheader.num_frames ; i++)
	{
		in = &g_frames[i];

		for(j=0;j<fmheader.num_xyz;j++)
		{
			for(k=0,Found=false;k<j;k++)
			{	// starting from the beginning always ensures vert_replacement points to the first point in the array
				if (in->v[j].v[0] == in->v[k].v[0] &&
					in->v[j].v[1] == in->v[k].v[1] &&
					in->v[j].v[2] == in->v[k].v[2])
				{
					Found = true;
					vert_replacement[j] = k;
					break;
				}

			}

			if (!Found)
			{
				if (!vert_used[j])
				{
					num_unique++;
				}
				vert_used[j] = true;
			}
		}
	}

	// recompute the light normals
	for (i=0 ; i<fmheader.num_frames ; i++)
	{
		in = &g_frames[i];

		for(j=0;j<fmheader.num_xyz;j++)
		{
			if (!vert_used[j])
			{
				k = vert_replacement[j];

				VectorAdd (in->v[j].vnorm.normalsum, in->v[k].vnorm.normalsum, in->v[k].vnorm.normalsum);
				in->v[k].vnorm.numnormals += in->v[j].vnorm.numnormals++;
			}
		}

		for (j=0 ; j<fmheader.num_xyz ; j++)
		{
			vec3_t	v;
			float	maxdot;
			int		maxdotindex;
			int		c;

			c = in->v[j].vnorm.numnormals;
			if (!c)
				Error ("Vertex with no triangles attached");

			VectorScale (in->v[j].vnorm.normalsum, 1.0/c, v);
			VectorNormalize (v, v);

			maxdot = -999999.0;
			maxdotindex = -1;

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

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

			in->v[j].lightnormalindex = maxdotindex;
		}
	}

	// create substitution list
	num_unique = 0;
	for(i=0;i<fmheader.num_xyz;i++)
	{
		if (vert_used[i])
		{
			vert_replacement[i] = num_unique;
			num_unique++;
		}
		else
		{
			vert_replacement[i] = vert_replacement[vert_replacement[i]];
		}

		// vert_replacement[i] is the new index, i is the old index
		// need to add the new index to the cluster list if old index was in it
		if(g_skelModel.clustered == true)
		{
			for(k = 0; k < numJointsInSkeleton[g_skelModel.type]; ++k)
			{
				for(l = 0, current = g_skelModel.vertLists[k]; 
					l < g_skelModel.new_num_verts[k+1]; ++l, current = current->next)
				{
					if(current->data == i)
					{
						IntListNode_t *current2;
						int m;
						qboolean added = false;

						for(m = 0, current2 = newVertLists[k]; m < newNum_verts[k+1];
							++m, current2 = current2->next)
						{
							if(current2->data == vert_replacement[i])
							{
								added = true;
								break;
							}
						}

						if(!added)
						{
							++newNum_verts[k+1];

							next = newVertLists[k];

							newVertLists[k] = (IntListNode_t *) SafeMalloc(sizeof(IntListNode_t), "OptimizeVertices");
							// freed after model write out

							newVertLists[k]->data = vert_replacement[i];
							newVertLists[k]->next = next;
						}
						break;
					}
				}
			}
		}
	}

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

		for(j=0;j<fmheader.num_xyz;j++)
		{
			in->v[vert_replacement[j]] = in->v[j];
		}

	}

	for(i = 0; i < numJointsInSkeleton[g_skelModel.type]; ++i)
	{
		IntListNode_t *toFree;
		current = g_skelModel.vertLists[i];

		while(current)
		{
			toFree = current;
			current = current->next;
			free(toFree);  // freeing of memory allocated in ReplaceClusterIndex called in Cmd_Base
		}

		g_skelModel.vertLists[i] = newVertLists[i];
		g_skelModel.new_num_verts[i+1] = newNum_verts[i+1];
	}

#ifndef NDEBUG
	for(k = 0; k < numJointsInSkeleton[g_skelModel.type]; ++k)
	{
		for(l = 0, current = g_skelModel.vertLists[k]; 
			l < g_skelModel.new_num_verts[k+1]; ++l, current = current->next)
		{
			IntListNode_t *current2;
			int m;

			for(m = l+1, current2 = current->next; m < newNum_verts[k+1];
				++m, current2 = current2->next)
			{
				if(current->data == current2->data)
				{
					printf("Warning duplicate vertex:  %d\n", current->data);
					break;
				}
			}
		}
	}
#endif

	for(i=0;i<fmheader.num_mesh_nodes;i++)
	{	// reset the vert bits
		memset(pmnodes[i].verts,0,sizeof(pmnodes[i].verts));
	}

	// repleace the master triangle list vertex indexes and update the vert bits for each mesh node
	for (i=0 ; i<fmheader.num_tris ; i++)
	{
		pos = i >> 3;
		bit = 1 << (i & 7 );

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

			set_pos >>= 3;
			set_bit = 1 << (set_bit & 7);

			for(k=0;k<fmheader.num_mesh_nodes;k++)
			{
				if (!(pmnodes[k].tris[pos] & bit))
				{
					continue;
				}
				pmnodes[k].verts[set_pos] |= set_bit;
			}
		}
	}

	for (i=0;i<numcommands;i++)
	{
		j = commands[i];
		if (!j) continue;

		j = abs(j);
		for(i++;j;j--,i+=3)
		{
			commands[i+2] = vert_replacement[commands[i+2]];
		}
		i--;
	}

	printf("Reduced by %d\n",fmheader.num_xyz - num_unique);
	
	fmheader.num_xyz = num_unique;
	if (num_groups)
	{
		// tack on the reference verts to the regular verts
		if(g_skelModel.references != REF_NULL)
		{
			fmframe_t	*in;
			int index;
			int refnum;

			if (RefPointNum <= 0)
			{	// Hard-coded labels
				refnum = numReferences[g_skelModel.references];
			}
			else
			{	// Labels indicated in QDT
				refnum = RefPointNum;
			}


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

				for (j = 0 ; j < refnum; ++j)
				{
					VectorCopy(in->references[j].placement.origin, in->v[index].v);
					index++;

					VectorCopy(in->references[j].placement.direction, in->v[index].v);
					index++;

					VectorCopy(in->references[j].placement.up, in->v[index].v);
					index++;
				}
			}

			fmheader.num_xyz += refnum*3;
		}

		// tack on the skeletal joint verts to the regular verts
		if(g_skelModel.type != SKEL_NULL)
		{
			fmframe_t	*in;
			int index;

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

				for (j = 0 ; j < numJointsInSkeleton[g_skelModel.type]; ++j)
				{
					VectorCopy(in->joints[j].placement.origin, in->v[index].v);
					index++;

					VectorCopy(in->joints[j].placement.direction, in->v[index].v);
					index++;

					VectorCopy(in->joints[j].placement.up, in->v[index].v);
					index++;
				}
			}

			fmheader.num_xyz += numJointsInSkeleton[g_skelModel.type]*3;
		}

		CompressFrames();
	}
}


/*
===============
FinishModel
===============
*/
void FMFinishModel (void)
{
	FILE		*modelouthandle;
	int			i,j,length,tris,verts,bit,pos,total_tris,total_verts;
	char		name[1024];
	int			trans_count;
	
	if (!fmheader.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.fm", cdpartial);
		ReleaseFile (name);

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

	printf("\n");

	trans_count = 0;
	for(i=0;i<fmheader.num_tris;i++)
		if (translucent[i])
			trans_count++;

	if (!g_no_opimizations)
	{
		OptimizeVertices();
	}

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

	WriteModelFile (modelouthandle);
	
	printf ("%3dx%3d skin\n", fmheader.skinwidth, fmheader.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", fmheader.num_xyz);
	printf ("%4d triangles, %4d of them translucent\n", fmheader.num_tris, trans_count);
	printf ("%4d frame\n", fmheader.num_frames);
	printf ("%4d glverts\n", numglverts);
	printf ("%4d glcmd\n", fmheader.num_glcmds);
	printf ("%4d skins\n", fmheader.num_skins);
	printf ("%4d mesh nodes\n", fmheader.num_mesh_nodes);
	printf ("wasted pixels: %d / %d (%5.2f Percent)\n",total_skin_pixels - skin_pixels_used, 
		total_skin_pixels, (double)(total_skin_pixels - skin_pixels_used) / (double)total_skin_pixels * 100.0);

	printf ("file size: %d\n", (int)ftell (modelouthandle) );
	printf ("---------------------\n");
	
	if (g_verbose)
	{
		if (fmheader.num_mesh_nodes)
		{
			total_tris = total_verts = 0;
			printf("Node Name                         Tris Verts\n");
			printf("--------------------------------- ---- -----\n");
			for(i=0;i<fmheader.num_mesh_nodes;i++)
			{
				tris = 0;
				verts = 0;
				for(j=0;j<MAXTRIANGLES;j++)
				{
					pos = (j) >> 3;
					bit = 1 << ((j) & 7 );
					if (pmnodes[i].tris[pos] & bit)
					{
						tris++;
					}
				}
				for(j=0;j<MAX_FM_VERTS;j++)
				{
					pos = (j) >> 3;
					bit = 1 << ((j) & 7 );
					if (pmnodes[i].verts[pos] & bit)
					{
						verts++;
					}
				}

				printf("%-33s %4d %5d\n",pmnodes[i].name,tris,verts);

				total_tris += tris;
				total_verts += verts;
			}
			printf("--------------------------------- ---- -----\n");
			printf("%-33s %4d %5d\n","TOTALS",total_tris,total_verts);
		}
	}
	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);

	// mesh nodes
	if (fmheader.num_mesh_nodes)
	{
		H_printf("\n");
		H_printf("#define NUM_MESH_NODES\t\t%d\n\n",fmheader.num_mesh_nodes);
		for(i=0;i<fmheader.num_mesh_nodes;i++)
		{
			strcpy(name, pmnodes[i].name);
			strupr(name);
			length = strlen(name);
			for(j=0;j<length;j++)
			{
				if (name[j] == ' ')
				{
					name[j] = '_';
				}
			}
			H_printf("#define MESH_%s\t\t%d\n", name, i);
		}
	}

	fclose (headerouthandle);
	headerouthandle = NULL;
	free (pmnodes);
}


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

ALIAS MODEL DISPLAY LIST GENERATION

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

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

/*
================
StripLength
================
*/
static int	StripLength (int starttri, int startv, int num_tris, int node)
{
	int				m1, m2;
	int				st1, st2;
	int				j;
	fmtriangle_t	*last, *check;
	int				k;
	int				pos, bit;

	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<num_tris ; j++, check++)
	{
		pos = j >> 3;
		bit = 1 << (j & 7 );
		if (!(pmnodes[node].tris[pos] & bit))
		{
			continue;
		}
		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] || translucent[j] != translucent[starttri])
				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<num_tris ; j++)
		if (used[j] == 2)
			used[j] = 0;

	return stripcount;
}


/*
===========
FanLength
===========
*/
static int	FanLength (int starttri, int startv, int num_tris, int node)
{
	int				m1, m2;
	int				st1, st2;
	int				j;
	fmtriangle_t	*last, *check;
	int				k;
	int				pos, bit;

	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<num_tris ; j++, check++)
	{
		pos = j >> 3;
		bit = 1 << (j & 7 );
		if (!(pmnodes[node].tris[pos] & bit))
		{
			continue;
		}
		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] || translucent[j] != translucent[starttri])
				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<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, l;
	int		startv;
	float	s, t;
	int		len, bestlen, besttype;
	int		best_xyz[1024];
	int		best_st[1024];
	int		best_tris[1024];
	int		type;
	int		trans_check;
	int		bit,pos;

	//
	// build tristrips
	//
	numcommands = 0;
	numglverts = 0;


	for(l=0;l<fmheader.num_mesh_nodes;l++)
	{
		memset (used, 0, sizeof(used));

		pmnodes[l].start_glcmds = numcommands;

		for(trans_check = 0; trans_check<2; trans_check++)
		{
			for (i=0 ; i < fmheader.num_tris ; i++)
			{
				pos = i >> 3;
				bit = 1 << (i & 7 );
				if (!(pmnodes[l].tris[pos] & bit))
				{
					continue;
				}

				// pick an unused triangle and start the trifan
				if (used[i] || trans_check != translucent[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, fmheader.num_tris, l);
						else
							len = FanLength (i, startv, fmheader.num_tris, l);
						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  ) / fmheader.skinwidth;
					t = (t  ) / fmheader.skinheight;

					*(float *)&commands[numcommands++] = s;
					*(float *)&commands[numcommands++] = t;
					*(int *)&commands[numcommands++] = best_xyz[j];
				}
			}
		}
		commands[numcommands++] = 0;		// end of list marker
		pmnodes[l].num_glcmds = numcommands - pmnodes[l].start_glcmds;
	}
}


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

BASE FRAME SETUP

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


#define LINE_NORMAL 1
#define LINE_FAT 2
#define LINE_DOTTED 3


#define ASCII_SPACE 32

int LineType = LINE_NORMAL;
extern unsigned char pic[SKINPAGE_HEIGHT*SKINPAGE_WIDTH], pic_palette[768];
unsigned char LineColor = 255;
int ScaleWidth, ScaleHeight;


static char *CharDefs[] =
{
	"-------------------------",
	"-------------------------", // !
	"-------------------------", // "
	"-------------------------", // #
	"-------------------------", // $
	"-------------------------", // %
	"-------------------------", // &
	"--*----*-----------------", // '
	"-*---*----*----*-----*---", // (
	"*-----*----*----*---*----", // )
	"-----*--*--**---**--*--*-", // *
	"-------------------------", // +
	"----------------**--**---", // ,
	"-------------------------", // -
	"----------------**---**--", // .
	"-------------------------", // /
	" *** *  *** * ***  * *** ", // 0
	"   *   **    *    *    * ",
	"****     * *** *    *****",
	"****     * ***     ***** ",
	"  **  * * *  * *****   * ",
	"**** *    ****     ***** ",
	" *** *    **** *   * *** ",
	"*****    *   *   *    *  ",
	" *** *   * *** *   * *** ",
	" *** *   * ****    * *** ", // 9
	"-**---**--------**---**--", // :
	"-------------------------", // ;
	"-------------------------", // <
	"-------------------------", // =
	"-------------------------", // >
	"-------------------------", // ?
	"-------------------------", // @
	"-***-*---*******---**---*", // A
	"****-*---*****-*---*****-",
	"-*****----*----*-----****",
	"****-*---**---**---*****-",
	"******----****-*----*****",
	"******----****-*----*----",
	"-*****----*--***---*-****",
	"*---**---*******---**---*",
	"-***---*----*----*---***-",
	"----*----*----**---*-***-",
	"-*--*-*-*--**---*-*--*--*",
	"-*----*----*----*----****",
	"*---***-***-*-**---**---*",
	"*---***--**-*-**--***---*",
	"-***-*---**---**---*-***-",
	"****-*---*****-*----*----",
	"-***-*---**---*-***----**",
	"****-*---*****-*-*--*--**",
	"-*****-----***-----*****-",
	"*****--*----*----*----*--",
	"*---**---**---**---******",
	"*---**---**---*-*-*---*--",
	"*---**---**-*-***-***---*",
	"*---*-*-*---*---*-*-*---*",
	"*---**---*-*-*---*----*--",
	"*****---*---*---*---*****" // Z
};

void DrawLine(int x1, int y1, int x2, int y2)
{
	int dx, dy;
	int adx, ady;
	int count;
	float xfrac, yfrac, xstep, ystep;
	unsigned sx, sy;
	float u, v;

	dx = x2 - x1;
	dy = y2 - y1;
	adx = abs(dx);
	ady = abs(dy);

	count = adx > ady ? adx : ady;
	count++;

	if(count > 300)
	{
		printf("Bad count\n");
		return; // don't ever hang up on bad data
	}
		
	xfrac = x1;
	yfrac = y1;
	
	xstep = (float)dx/count;
	ystep = (float)dy/count;

	switch(LineType)
	{
		case LINE_NORMAL:
			do
			{
				if(xfrac < SKINPAGE_WIDTH && yfrac < SKINPAGE_HEIGHT)
				{
					pic[(int)yfrac*SKINPAGE_WIDTH+(int)xfrac] = LineColor;
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		case LINE_FAT:
			do
			{
				for (u=-0.1 ; u<=0.9 ; u+=0.999)
				{
					for (v=-0.1 ; v<=0.9 ; v+=0.999)
					{
						sx = xfrac+u;
						sy = yfrac+v;
						if(sx < SKINPAGE_WIDTH && sy < SKINPAGE_HEIGHT)
						{
							pic[sy*SKINPAGE_WIDTH+sx] = LineColor;
						}
					}
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		case LINE_DOTTED:
			do
			{
				if(count&1 && xfrac < SKINPAGE_WIDTH &&
					yfrac < SKINPAGE_HEIGHT)
				{
					pic[(int)yfrac*SKINPAGE_WIDTH+(int)xfrac] = LineColor;
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		default:
			Error("Unknown <linetype> %d.\n", LineType);
	}
}

//==========================================================================
//
// DrawCharacter
//
//==========================================================================

static void DrawCharacter(int x, int y, int character)
{
	int r, c;
	char *def;

	character = toupper(character);
	if(character < ASCII_SPACE || character > 'Z')
	{
		character = ASCII_SPACE;
	}
	character -= ASCII_SPACE;
	for(def = CharDefs[character], r = 0; r < 5; r++)
	{
		for(c = 0; c < 5; c++)
		{
			pic[(y+r)*SKINPAGE_WIDTH+x+c] = *def++ == '*' ? 255 : 0;
		}
	}
}

//==========================================================================
//
// DrawTextChar
//
//==========================================================================

void DrawTextChar(int x, int y, char *text)
{
	int c;

	while((c = *text++) != '\0')
	{
		DrawCharacter(x, y, c);
		x += 6;
	}
}


extern void DrawScreen(float s_scale, float t_scale, float iwidth, float iheight);

//==========================================================================
// ExtractDigit

static int ExtractDigit(byte *pic, int x, int y)
{
	int		i;
	int		r, c;
	char	digString[32];
	char	*buffer;
	byte	backColor;
	char	**DigitDefs;

	backColor = pic[(SKINPAGE_HEIGHT - 1) * SKINPAGE_WIDTH];
	DigitDefs = &CharDefs['0' - ASCII_SPACE];

	buffer = digString;
	for(r = 0; r < 5; r++)
	{
		for(c = 0; c < 5; c++)
		{
			*buffer++ = (pic[(y + r) * SKINPAGE_WIDTH + x + c] == backColor) ? ' ' : '*';
		}
	}
	*buffer = '\0';
	for(i = 0; i < 10; i++)
	{
		if(strcmp(DigitDefs[i], digString) == 0)
		{
			return i;
		}
	}

	Error("Unable to extract scaling info from skin PCX.");
	return 0;
}

//==========================================================================
// ExtractNumber

int ExtractNumber(byte *pic, int x, int y)
{
	return ExtractDigit(pic, x, y) * 100 + ExtractDigit(pic, x + 6, y) * 10 + ExtractDigit(pic, x + 12, y);
}





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

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

  FIXME: allow this to be loaded from a file for
  arbitrary mappings
============
*/
static void BuildST (triangle_t *ptri, int numtri, qboolean DrawSkin)
{
	int			backface_flag;
	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;
	int skinwidth;
	int skinheight;

	//
	// find bounds of all the verts on the base frame
	//
	ClearBounds (mins, maxs);
	backface_flag = false;
	
	if (ptri[0].HasUV)	// if we have the uv already, we don't want to double up or scale
	{
		iwidth = ScaleWidth;
		iheight = ScaleHeight;
		
		t_scale = s_scale = 1.0;
	}
	else
	{
		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];
			
			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)
				{
					backface_flag = true;
					break;
				}
			}
			scWidth = ScaleWidth*SCALE_ADJUST_FACTOR;
			if (backface_flag)	//we are doubling
				scWidth /= 2;
			
			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)
	{
		if(backface_flag)
			DrawScreen(s_scale, t_scale, iwidth*2, iheight);
		else
			DrawScreen(s_scale, t_scale, iwidth, iheight);
	}
	if (backface_flag)
		skinwidth=iwidth*2;
	else
		skinwidth=iwidth;
	skinheight=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
//
	basey = 2;
	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]*skinwidth);
				triangle_st[i][j][1] = Q_rint((1.0f-ptri[i].uv[j][1])*skinheight);
			}
		}
		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;
			}
			
			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);
			}
		}

		if (DrawSkin)
		{
			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;
	if(backface_flag)
		swidth *= 2;
	fmheader.skinwidth = (swidth + 3) & ~3;
	fmheader.skinheight = iheight;

	skin_width = iwidth;
	skin_height = iheight;
}


static void BuildNewST (triangle_t *ptri, int numtri, qboolean DrawSkin)
{
	int			i, j;

	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]*(ScaleWidth-1));
				triangle_st[i][j][1] = Q_rint((1.0f-ptri[i].uv[j][1])*(ScaleHeight-1));
			}
		}

		if (DrawSkin)
		{
			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

	fmheader.skinwidth = (ScaleWidth + 3) & ~3;
	fmheader.skinheight = ScaleHeight;

	skin_width = ScaleWidth;
	skin_height = ScaleHeight;
}




byte			*BasePalette;
byte			*BasePixels,*TransPixels;
int				BaseWidth, BaseHeight, TransWidth, TransHeight;
qboolean		BaseTrueColor;
static qboolean SetPixel = false;

int CheckTransRecursiveTri (int *lp1, int *lp2, int *lp3)
{
	int		*temp;
	int		d;
	int		new[2];

	d = lp2[0] - lp1[0];
	if (d < -1 || d > 1)
		goto split;
	d = lp2[1] - lp1[1];
	if (d < -1 || d > 1)
		goto split;

	d = lp3[0] - lp2[0];
	if (d < -1 || d > 1)
		goto split2;
	d = lp3[1] - lp2[1];
	if (d < -1 || d > 1)
		goto split2;

	d = lp1[0] - lp3[0];
	if (d < -1 || d > 1)
		goto split3;
	d = lp1[1] - lp3[1];
	if (d < -1 || d > 1)
	{
split3:
		temp = lp1;
		lp1 = lp3;
		lp3 = lp2;
		lp2 = temp;

		goto split;
	}

	return 0;			// entire tri is filled

split2:
	temp = lp1;
	lp1 = lp2;
	lp2 = lp3;
	lp3 = temp;

split:
// split this edge
	new[0] = (lp1[0] + lp2[0]) >> 1;
	new[1] = (lp1[1] + lp2[1]) >> 1;

// draw the point if splitting a leading edge
	if (lp2[1] > lp1[1])
		goto nodraw;
	if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
		goto nodraw;

	if (SetPixel)
	{
		assert ((new[1]*BaseWidth) + new[0] < BaseWidth*BaseHeight);

		if (BaseTrueColor)
		{
			BasePixels[((new[1]*BaseWidth) + new[0]) * 4] = 1;
		}
		else
		{
			BasePixels[(new[1]*BaseWidth) + new[0]] = 1;
		}
	}
	else
	{
		if (TransPixels)
		{
			if (TransPixels[(new[1]*TransWidth) + new[0]] != 255)
				return 1;
		}
		else if (BaseTrueColor)
		{
			if (BasePixels[(((new[1]*BaseWidth) + new[0]) * 4) + 3] != 255)
				return 1;
		}
		else
		{
//			pixel = BasePixels[(new[1]*BaseWidth) + new[0]];
		}
	}

nodraw:
// recursively continue
	if (CheckTransRecursiveTri(lp3, lp1, new)) 
		return 1;

	return CheckTransRecursiveTri(lp3, new, lp2);
}

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 < numJointsInSkeleton[g_skelModel.type]; ++j)
	{
		if(!clusters[j])
		{
			continue;
		}

		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;
			}
		}
	}
}

#define	FUDGE_EPSILON	0.002

qboolean VectorFudgeCompare (vec3_t v1, vec3_t v2)
{
	int		i;
	
	for (i=0 ; i<3 ; i++)
		if (fabs(v1[i]-v2[i]) > FUDGE_EPSILON)
			return false;
			
	return true;
}

/*
=================
Cmd_Base
=================
*/
void Cmd_FMBase (qboolean GetST)
{
	triangle_t	*ptri, *st_tri;
	int			num_st_tris;
	int			i, j, k, l;
	int			x,y,z;
//	int			time1;
	char		file1[1024],file2[1024],trans_file[1024], stfile[1024], extension[256];
	vec3_t		base_xyz[MAX_FM_VERTS];
	FILE		*FH;
	int			pos,bit;
	qboolean	NewSkin;

	GetScriptToken (false);

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

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

	ExpandPathAndArchive (file1);

	// Use the input filepath for this one.
	sprintf (file1, "%s/%s", cddir, token);

//	time1 = FileTime (file1);
//	if (time1 == -1)
//		Error ("%s doesn't exist", file1);

//
// load the base triangles
//
	if (do3ds)
		Load3DSTriangleList (file1, &ptri, &fmheader.num_tris, &pmnodes, &fmheader.num_mesh_nodes);
	else
		LoadTriangleList (file1, &ptri, &fmheader.num_tris, &pmnodes, &fmheader.num_mesh_nodes);

	if (g_ignoreTriUV)
	{
		for (i=0;i<fmheader.num_tris;i++)
		{
			ptri[i].HasUV=0;
		}
	}

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

	ExtractFileExtension (file2, extension);
	if (extension[0] == 0)
	{
		strcat(file2, ".pcx");
	}
	printf ("skin: %s\n", file2);

	BaseTrueColor = LoadAnyImage (file2, &BasePixels, &BasePalette, &BaseWidth, &BaseHeight);

	NewSkin = false;
	if (BaseWidth != SKINPAGE_WIDTH || BaseHeight != SKINPAGE_HEIGHT)
	{
		if (g_allow_newskin)
		{
			ScaleWidth = BaseWidth;
			ScaleHeight = BaseHeight;
			NewSkin = true;
		}
		else
		{
			Error("Invalid skin page size: (%d,%d) should be (%d,%d)",
				BaseWidth,BaseHeight,SKINPAGE_WIDTH,SKINPAGE_HEIGHT);
		}
	}
	else if (!BaseTrueColor)
	{
		ScaleWidth = (float)ExtractNumber(BasePixels, ENCODED_WIDTH_X,
			ENCODED_WIDTH_Y);
		ScaleHeight = (float)ExtractNumber(BasePixels, ENCODED_HEIGHT_X,
			ENCODED_HEIGHT_Y);
	}
	else
	{
		Error("Texture coordinates not supported on true color image");
	}

	if (GetST)
	{
		GetScriptToken (false);

		sprintf (stfile, "%s/%s.%s", cdarchive, token, trifileext);
		printf ("ST: %s ", stfile);

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

		if (do3ds)
			Load3DSTriangleList (stfile, &st_tri, &num_st_tris, NULL, NULL);
		else
			LoadTriangleList (stfile, &st_tri, &num_st_tris, NULL, NULL);

		if (num_st_tris != fmheader.num_tris)
		{
			Error ("num st tris mismatch: st %d / base %d", num_st_tris, fmheader.num_tris);
		}

		printf("   matching triangles...\n");
		for(i=0;i<fmheader.num_tris;i++)
		{
			k = -1;
			for(j=0;j<num_st_tris;j++)
			{
				for(x=0;x<3;x++)
				{
					for(y=0;y<3;y++)
					{
						if (x == y)
						{
							continue;
						}
						for(z=0;z<3;z++)
						{
							if (z == x || z == y) 
							{
								continue;
							}

							if (VectorFudgeCompare (ptri[i].verts[0], st_tri[j].verts[x]) &&
							    VectorFudgeCompare (ptri[i].verts[1], st_tri[j].verts[y]) &&
								VectorFudgeCompare (ptri[i].verts[2], st_tri[j].verts[z]))
							{
								if (k == -1)
								{
									k = j;
									ptri[i].HasUV = st_tri[k].HasUV;
									ptri[i].uv[0][0] = st_tri[k].uv[x][0];
									ptri[i].uv[0][1] = st_tri[k].uv[x][1];
									ptri[i].uv[1][0] = st_tri[k].uv[y][0];
									ptri[i].uv[1][1] = st_tri[k].uv[y][1];
									ptri[i].uv[2][0] = st_tri[k].uv[z][0];
									ptri[i].uv[2][1] = st_tri[k].uv[z][1];
									x = y = z = 999;
								}
								else if (k != j)
								{
									printf("Duplicate triangle %d found in st file: %d and %d\n",i,k,j);
									printf("   (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f)\n",
										ptri[i].verts[0][0],ptri[i].verts[0][1],ptri[i].verts[0][2],
										ptri[i].verts[1][0],ptri[i].verts[1][1],ptri[i].verts[1][2],
										ptri[i].verts[2][0],ptri[i].verts[2][1],ptri[i].verts[2][2]);
									printf("   (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f)\n",
										st_tri[k].verts[0][0],st_tri[k].verts[0][1],st_tri[k].verts[0][2],
										st_tri[k].verts[1][0],st_tri[k].verts[1][1],st_tri[k].verts[1][2],
										st_tri[k].verts[2][0],st_tri[k].verts[2][1],st_tri[k].verts[2][2]);
									printf("   (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f) (%0.3f %0.3f %0.3f)\n",
										st_tri[j].verts[0][0],st_tri[j].verts[0][1],st_tri[j].verts[0][2],
										st_tri[j].verts[1][0],st_tri[j].verts[1][1],st_tri[j].verts[1][2],
										st_tri[j].verts[2][0],st_tri[j].verts[2][1],st_tri[j].verts[2][2]);
								}
							}
						}
					}
				}
			}
			if (k == -1)
			{
				printf("No matching triangle %d\n",i);
			}
		}
		free (st_tri);
	}

//
// get the ST values
//
	if (ptri && ptri[0].HasUV)
	{
		if (!NewSkin)
		{
			Error("Base has UVs with old style skin page\nMaybe you want to use -ignoreUV");
		}
		else
		{
			BuildNewST (ptri, fmheader.num_tris, false);
		}
	}
	else
	{
		if (NewSkin)
		{
			Error("Base has new style skin without UVs");
		}
		else
		{
			BuildST (ptri, fmheader.num_tris, false);
		}
	}

	TransPixels = NULL;
	if (!BaseTrueColor)
	{
		FH = fopen(trans_file,"rb");
		if (FH)
		{
			fclose(FH);
			Load256Image (trans_file, &TransPixels, NULL, &TransWidth, &TransHeight);
			if (TransWidth != fmheader.skinwidth || TransHeight != fmheader.skinheight)
			{
				Error ("source image %s dimensions (%d,%d) are not the same as alpha image (%d,%d)\n",file2,fmheader.skinwidth,fmheader.skinheight,TransWidth,TransHeight);
			}
		}
	}

//
// 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(l=0;l<fmheader.num_mesh_nodes;l++)
	{
		for (i=0 ; i < fmheader.num_tris ; i++)
		{
			pos = i >> 3;
			bit = 1 << (i & 7 );
			if (!(pmnodes[l].tris[pos] & bit))
			{
				continue;
			}

			for (j=0 ; j<3 ; j++)
			{
				// get the xyz index
				for (k=0 ; k<fmheader.num_xyz ; k++)
				{
					if (VectorCompare (ptri[i].verts[j], base_xyz[k]))
					{
						break;	// this vertex is already in the base vertex list
					}
				}

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

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

					fmheader.num_xyz++;
				}

				pos = k >> 3;
				bit = 1 << (k & 7);
				pmnodes[l].verts[pos] |= bit;

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

				// get the st index
				for (k=0 ; k<fmheader.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 == fmheader.num_st)
				{ // new index
					base_st[fmheader.num_st].s = triangle_st[i][j][0];
					base_st[fmheader.num_st].t = triangle_st[i][j][1];
					fmheader.num_st++;
				}

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

			if (TransPixels || BaseTrueColor)
			{
				translucent[i] = CheckTransRecursiveTri(triangle_st[i][0], triangle_st[i][1], triangle_st[i][2]);
			}
			else
			{
				translucent[i] = false;
			}
		}
	}

	if (!BaseTrueColor)
	{
		SetPixel = true;
		memset(BasePixels,0,BaseWidth*BaseHeight);
		for (i=0 ; i < fmheader.num_tris ; i++)
		{
			CheckTransRecursiveTri(triangle_st[i][0], triangle_st[i][1], triangle_st[i][2]);
		}
		SetPixel = false;

		skin_pixels_used = 0;
		for(i=0;i<fmheader.skinheight;i++)
		{
			for(j=0;j<fmheader.skinwidth;j++)
			{
				skin_pixels_used += BasePixels[(i*BaseWidth) + j];
			}
		}
		total_skin_pixels = fmheader.skinheight*fmheader.skinwidth;
	}
	else
	{
		SetPixel = true;
		memset(BasePixels,0,BaseWidth*BaseHeight*4);
		for (i=0 ; i < fmheader.num_tris ; i++)
		{
			CheckTransRecursiveTri(triangle_st[i][0], triangle_st[i][1], triangle_st[i][2]);
		}
		SetPixel = false;

		skin_pixels_used = 0;
		for(i=0;i<fmheader.skinheight;i++)
		{
			for(j=0;j<fmheader.skinwidth;j++)
			{
				skin_pixels_used += BasePixels[((i*BaseWidth) + j)*4];
			}
		}
		total_skin_pixels = fmheader.skinheight*fmheader.skinwidth;
	}

	// build triangle strips / fans
	BuildGlCmds ();

	if (TransPixels)
	{
		free(TransPixels);
	}
	free (BasePixels);
	if (BasePalette)
	{
		free (BasePalette);
	}
	free(ptri);
}

void Cmd_FMNodeOrder(void)
{
	mesh_node_t	*newnodes, *pos;
	int			i,j;

	if (!pmnodes)
	{
		Error ("Base has not been established yet");
	}

	pos = newnodes = malloc(sizeof(mesh_node_t) * fmheader.num_mesh_nodes);

	for(i=0;i<fmheader.num_mesh_nodes;i++)
	{
		GetScriptToken (false);

		for(j=0;j<fmheader.num_mesh_nodes;j++)
		{
			if (strcmpi(pmnodes[j].name, token) == 0)
			{
				*pos = pmnodes[j];
				pos++;
				break;
			}
		}
		if (j >= fmheader.num_mesh_nodes)
		{
			Error("Node '%s' not in base list!\n", token);
		}
	}

	free(pmnodes);
	pmnodes = newnodes;
}

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

extern char	*FindFrameFile (char *frame);


/*
===============
GrabFrame
===============
*/
void GrabFrame (char *frame)
{
	triangle_t		*ptri;
	int				i, j;
	fmtrivert_t		*ptrivert;
	int				num_tris;
	char			file1[1024];
	fmframe_t		*fr;
	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 (fmheader.num_frames >= MAX_FM_FRAMES)
		Error ("fmheader.num_frames >= MAX_FM_FRAMES");
	fr = &g_frames[fmheader.num_frames];
	fmheader.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 != fmheader.num_tris)
		Error ("%s: number of triangles (%d) doesn't match base frame (%d)\n", file1, num_tris, fmheader.num_tris);

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

	for (i=0 ; i<fmheader.num_xyz ; i++)
	{
		ptrivert[i].vnorm.numnormals = 0;
		VectorClear (ptrivert[i].vnorm.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 (ptrivert[index_xyz].vnorm.normalsum, normal, ptrivert[index_xyz].vnorm.normalsum);
			ptrivert[index_xyz].vnorm.numnormals++;
		}
	}

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

		c = ptrivert[i].vnorm.numnormals;
		if (!c)
			Error ("Vertex with no triangles attached");

		VectorScale (ptrivert[i].vnorm.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);
}

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

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

		if((g_skelModel.type != SKEL_NULL) || (g_skelModel.references != REF_NULL))
		{
			GrabModelTransform(token);
		}

		GrabFrame (token);

		if(g_skelModel.type != SKEL_NULL)
		{
			GrabSkeletalFrame(token);
		}

		if(g_skelModel.references != REF_NULL)
		{
			GrabReferencedFrame(token);
		}

		// need to add the up and dir points to the frame bounds here
		// using AddPointToBounds (ptrivert[index_xyz].v, fr->mins, fr->maxs);
		// then remove fudge in determining scale on frame write out
	}
}

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

Skins aren't actually stored in the file, only a reference
is saved out to the header file.
===============
*/
void Cmd_FMSkin (void)
{
	byte		*palette;
	byte		*pixels;
	int			width, height;
	byte		*cropped;
	int			y;
	char		name[1024], savename[1024], transname[1024], extension[256];
	miptex32_t	*qtex32;
	int			size;
	FILE		*FH;
	qboolean	TrueColor;

	GetScriptToken (false);

	if (fmheader.num_skins == MAX_FM_SKINS)
		Error ("fmheader.num_skins == MAX_FM_SKINS");

	if (g_skipmodel)
		return;

	sprintf (name, "%s/%s", cdarchive, token);
	strcpy (name, ExpandPathAndArchive( name ) );
//	sprintf (name, "%s/%s.lbm", cddir, token);

	if (ScriptTokenAvailable())
	{
		GetScriptToken (false);
		sprintf (g_skins[fmheader.num_skins], "!%s", token);
		sprintf (savename, "%s!%s", g_outputDir, token);
		sprintf (transname, "%s!%s_a.pcx", gamedir, token);
	}
	else
	{
		sprintf (g_skins[fmheader.num_skins], "%s/!%s", cdpartial, token);
		sprintf (savename, "%s/!%s", g_outputDir, token);
		sprintf (transname, "%s/!%s_a.pcx", cddir, token);
	}

	fmheader.num_skins++;

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

	// load the image
	printf ("loading %s\n", name);
	ExtractFileExtension (name, extension);
	if (extension[0] == 0)
	{
		strcat(name, ".pcx");
	}


	TrueColor = LoadAnyImage (name, &pixels, &palette, &width, &height);
//	RemapZero (pixels, palette, width, height);

	// crop it to the proper size

	if (!TrueColor)
	{
		cropped = (byte *) SafeMalloc (fmheader.skinwidth*fmheader.skinheight, "Cmd_FMSkin");
		for (y=0 ; y<fmheader.skinheight ; y++)
		{
			memcpy (cropped+y*fmheader.skinwidth,
				pixels+y*width, fmheader.skinwidth);
		}

		TransPixels = NULL;
		FH = fopen(transname,"rb");
		if (FH)
		{
			fclose(FH);

			strcat(g_skins[fmheader.num_skins-1],".pcx");
			strcat(savename,".pcx");

			// save off the new image
			printf ("saving %s\n", savename);
			CreatePath (savename);
			WritePCXfile (savename, cropped, fmheader.skinwidth, fmheader.skinheight, palette);
		}
		else
		{
	#if 1
		miptex_t	*qtex;
			qtex = CreateMip(cropped, fmheader.skinwidth, fmheader.skinheight, palette, &size, true);

			strcat(g_skins[fmheader.num_skins-1],".m8");
			strcat(savename,".m8");

			printf ("saving %s\n", savename);
			CreatePath (savename);
			SaveFile (savename, (byte *)qtex, size);
			free(qtex);
	#else
			strcat(g_skins[fmheader.num_skins-1],".pcx");
			strcat(savename,".pcx");

			// save off the new image
			printf ("saving %s\n", savename);
			CreatePath (savename);
			WritePCXfile (savename, cropped, fmheader.skinwidth, fmheader.skinheight, palette);
	#endif
		}
	}
	else
	{
		cropped = (byte *) SafeMalloc (fmheader.skinwidth*fmheader.skinheight*4, "Cmd_FMSkin");
		for (y=0 ; y<fmheader.skinheight ; y++)
		{
			memcpy (cropped+((y*fmheader.skinwidth)*4), pixels+(y*width*4), fmheader.skinwidth*4);
		}

		qtex32 = CreateMip32((unsigned *)cropped, fmheader.skinwidth, fmheader.skinheight, &size, true);

	    StripExtension(g_skins[fmheader.num_skins-1]);
		strcat(g_skins[fmheader.num_skins-1],".m32");
	    StripExtension(savename);
		strcat(savename,".m32");

		printf ("saving %s\n", savename);
		CreatePath (savename);
		SaveFile (savename, (byte *)qtex32, size);
	}

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


/*
===============
Cmd_Cd
===============
*/
void Cmd_FMCd (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);
	}
}


/*

//=======================
//		NEW GEN
//=======================

void NewGen (char *ModelFile, char *OutputName, int width, int height)
{
	trigroup_t  *triangles;
	triangle_t	*ptri;
	triangle_t	*grouptris;
	mesh_node_t	*pmnodes;

	vec3_t		*vertices;
	vec3_t		*uvs;
	vec3_t		aveNorm, crossvect;
	vec3_t		diffvect1, diffvect2;
	vec3_t		v0, v1, v2;
	vec3_t		n, u, v;
	vec3_t		base, zaxis, yaxis;
	vec3_t		uvwMin, uvwMax;
	vec3_t		groupMin, groupMax;
	vec3_t		uvw;
	
	float		*uFinal, *vFinal;
	unsigned char	*newpic;

	int			finalstart = 0, finalcount = 0;
	int			xbase = 0, xwidth = 0, ywidth = 0;
	int			*todo, *done, finished;
	int			i, j, k, l; //counters
	int			groupnum, numtris, numverts, num;
	int			count;
	FILE		*grpfile;
	long		datasize;

	for ( i = 0; i<3; i++)
	{
		aveNorm[i] = 0;
		uvwMin[i] = 1e30f;
		uvwMax[i] = -1e30f;
	}

	pmnodes = NULL;
	ptri = NULL;
	triangles = NULL;
	
	zaxis[0] = 0;
	zaxis[1] = 0;
	zaxis[2] = 1;

	yaxis[0] = 0;
	yaxis[1] = 1;
	yaxis[2] = 0;

	LoadTriangleList (ModelFile, &ptri, &fmheader.num_tris, &pmnodes, &fmheader.num_mesh_nodes);

	todo = (int*)SafeMalloc(fmheader.num_tris*sizeof(int), "NewGen");
	done = (int*)SafeMalloc(fmheader.num_tris*sizeof(int), "NewGen");
	triangles = (trigroup_t*)SafeMalloc(fmheader.num_tris*sizeof(trigroup_t), "NewGen");
	
	for ( i=0; i < fmheader.num_tris; i++)
	{
		todo[i] = false;
		done[i] = false;
		triangles[i].triangle = ptri[i];
		triangles[i].group = 0;
	}

	groupnum = 0;

//  transitive closure algorithm follows
//  put all triangles who transitively share vertices into separate groups

	while (1)
	{
		for ( i = 0; i < fmheader.num_tris; i++)
		{
			if (!done[i])
			{
				break;
			}
		}
		if ( i == fmheader.num_tris)
		{
			break;
		}
		finished = false;
		todo[i] = true;
		while (!finished)
		{
			finished = true;
			for ( i = 0; i < fmheader.num_tris; i++)
			{
				if (todo[i])
				{
					done[i] = true;
					triangles[i].group = groupnum;
					todo[i] = false;
					for ( j = 0; j < fmheader.num_tris; j++)
					{
						if ((!done[j]) && (ShareVertex(triangles[i],triangles[j])))
						{
							todo[j] = true;
							finished = false;
						}
					}
				}
			}
		}
		groupnum++;
	}
		uFinal = (float*)SafeMalloc(3*fmheader.num_tris*sizeof(float), "NewGen");
		vFinal = (float*)SafeMalloc(3*fmheader.num_tris*sizeof(float), "NewGen");

	grpfile = fopen("grpdebug.txt","w");

	
	for (i = 0; i < groupnum; i++)
	{

		fprintf(grpfile,"Group Number: %d\n", i);
		
		numtris = GetNumTris(triangles, i); // number of triangles in group i
		numverts = numtris * 3;

		fprintf(grpfile,"%d triangles.\n", numtris);

		vertices = (vec3_t*)SafeMalloc(numverts*sizeof(vec3_t), "NewGen");
		uvs = (vec3_t*)SafeMalloc(numverts*sizeof(vec3_t), "NewGen");
		grouptris = (triangle_t*)SafeMalloc(numtris*sizeof(triangle_t), "NewGen");
		
		for (count = 0; count < fmheader.num_tris; count++)
		{
			if (triangles[count].group == i)
			{
				fprintf(grpfile,"Triangle %d\n", count);
			}
		}
		fprintf(grpfile,"\n");

		
		
		
		GetOneGroup(triangles, i, grouptris);		
		
		num = 0;
		for (j = 0; j < numtris; j++)
		{
			VectorCopy(grouptris[j].verts[0], v0);
			VectorCopy(grouptris[j].verts[1], v1);
			VectorCopy(grouptris[j].verts[2], v2);
			VectorSubtract(v1, v0, diffvect1);
			VectorSubtract(v2, v1, diffvect2);
			CrossProduct( diffvect1, diffvect2, crossvect);
			VectorAdd(aveNorm, crossvect, aveNorm);	
			VectorCopy(v0,vertices[num]);
			num++;					//  FIXME
			VectorCopy(v1,vertices[num]);
			num++;					//  add routine to add only verts that
			VectorCopy(v2,vertices[num]);
			num++;					// have not already been added
		}

		assert (num >= 3);
// figure out the best plane projections
		DOsvdPlane ((float*)vertices, num, (float *)&n, (float *)&base);
		
		if (DotProduct(aveNorm,n) < 0.0f)
		{
			VectorScale(n, -1.0f, n);
		}
		VectorNormalize(n,n);
		if (fabs(n[2]) < .57)
		{
			CrossProduct( zaxis, n, crossvect);
			VectorCopy(crossvect, u);
		}
		else
		{
			CrossProduct( yaxis, n, crossvect);
			VectorCopy(crossvect, u);
		}
		VectorNormalize(u,u);
		CrossProduct( n, u, crossvect);
		VectorCopy(crossvect, v);
		VectorNormalize(v,v);

		num = 0;

		for ( j = 0; j < 3; j++)
		{
			groupMin[j] = 1e30f;
			groupMax[j] = -1e30f;
		}
		
		for ( j = 0; j < numtris; j++)
		{
			for ( k = 0; k < 3; k++)
			{
				VectorCopy(grouptris[j].verts[k],v0);
				VectorSubtract(v0, base, v0);
				uvw[0] = DotProduct(v0, u);
				uvw[1] = DotProduct(v0, v);
				uvw[2] = DotProduct(v0, n);
				VectorCopy(uvw,uvs[num]);
				num++;
				for ( l = 0; l < 3; l++)
				{
					if (uvw[l] < groupMin[l])
					{
						groupMin[l] = uvw[l];
					}
					if (uvw[l] > groupMax[l])
					{
						groupMax[l] = uvw[l];
					}
				}
			}
		}
		
		xwidth = ceil(0 - groupMin[0]) + 2; // move right of origin and avoid overlap
		ywidth = ceil(0 - groupMin[1]) + 2; // move "above" origin
		
		for ( j=0; j < numverts; j++)
		{
			uFinal[finalcount] = uvs[j][0] + xwidth + xbase;			
			vFinal[finalcount] = uvs[j][1] + ywidth;
			if (uFinal[finalcount] < uvwMin[0])
			{
				uvwMin[0] = uFinal[finalcount];
			}
			if (uFinal[finalcount] > uvwMax[0])
			{
				uvwMax[0] = uFinal[finalcount];
			}
			if (vFinal[finalcount] < uvwMin[1])
			{
				uvwMin[1] = vFinal[finalcount];
			}
			if (vFinal[finalcount] > uvwMax[1])
			{
				uvwMax[1] = vFinal[finalcount];
			}
			finalcount++;
		}

		fprintf(grpfile,"svdPlaned Group min: ( %f , %f )\n",groupMin[0] + xwidth + xbase, groupMin[1] + ywidth);
		fprintf(grpfile,"svdPlaned Group max: ( %f , %f )\n",groupMax[0] + xwidth + xbase, groupMax[1] + ywidth);
		
		finalcount = finalstart;

		for ( count = 0; count < numverts; count++)
		{
			fprintf(grpfile,"Vertex %d: ( %f , %f , %f )\n",count,vertices[count][0],vertices[count][1],vertices[count][2]);
			fprintf(grpfile,"svdPlaned: ( %f , %f )\n",uFinal[finalcount],vFinal[finalcount++]);
		}
		
		finalstart = finalcount;

		fprintf(grpfile,"\n");
		
		free(vertices);
		free(uvs);
		free(grouptris);

		xbase += ceil(groupMax[0] - groupMin[0]) + 2; 		

	}	

	fprintf(grpfile,"Global Min ( %f , %f )\n",uvwMin[0],uvwMin[1]);
	fprintf(grpfile,"Global Max ( %f , %f )\n",uvwMax[0],uvwMax[1]);


	ScaleTris(uvwMin, uvwMax, width, height, uFinal, vFinal, finalcount);

	for (k = 0; k < finalcount; k++)
	{
		fprintf(grpfile, "scaled vertex %d: ( %f , %f )\n",k,uFinal[k],vFinal[k]);
	}
	
	//  i've got the array of vertices in uFinal and vFinal.  Now I need to write them and draw lines

	datasize = width * height*sizeof(unsigned char);
	newpic = (unsigned char*)SafeMalloc(datasize, "NewGen");
	memset(newpic,0,datasize);
	memset(pic_palette,0,sizeof(pic_palette));
	pic_palette[767] = pic_palette[766] = pic_palette[765] = 255;

	k = 0;
	while (k < finalcount)
	{
		NewDrawLine(uFinal[k], vFinal[k], uFinal[k+1], vFinal[k+1], newpic, width, height);
		k++;
		NewDrawLine(uFinal[k], vFinal[k], uFinal[k+1], vFinal[k+1], newpic, width, height);
		k++;
		NewDrawLine(uFinal[k], vFinal[k], uFinal[k-2], vFinal[k-2], newpic, width, height);
		k++;
		fprintf(grpfile, "output tri with verts %d, %d, %d", k-2, k-1, k);
	}

	WritePCXfile (OutputName, newpic, width, height, pic_palette);

	fclose(grpfile);

	free(todo);
	free(done);
	free(triangles);
	free(newpic);	
	return;
}
void NewDrawLine(int x1, int y1, int x2, int y2, unsigned char* picture, int width, int height)
{
	long dx, dy;
	long adx, ady;
	long count;
	float xfrac, yfrac, xstep, ystep;
	unsigned long sx, sy;
	float u, v;

	dx = x2 - x1;
	dy = y2 - y1;
	adx = abs(dx);
	ady = abs(dy);

	count = adx > ady ? adx : ady;
	count++;

	if(count > 300)
	{
		printf("Bad count\n");
		return; // don't ever hang up on bad data
	}
		
	xfrac = x1;
	yfrac = y1;
	
	xstep = (float)dx/count;
	ystep = (float)dy/count;

	switch(LineType)
	{
		case LINE_NORMAL:
			do
			{
				if(xfrac < width && yfrac < height)
				{
					picture[(long)yfrac*width+(long)xfrac] = LineColor;
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		case LINE_FAT:
			do
			{
				for (u=-0.1 ; u<=0.9 ; u+=0.999)
				{
					for (v=-0.1 ; v<=0.9 ; v+=0.999)
					{
						sx = xfrac+u;
						sy = yfrac+v;
						if(sx < width && sy < height)
						{
							picture[sy*width+sx] = LineColor;
						}
					}
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		case LINE_DOTTED:
			do
			{
				if(count&1 && xfrac < width &&
					yfrac < height)
				{
					picture[(long)yfrac*width+(long)xfrac] = LineColor;
				}
				xfrac += xstep;
				yfrac += ystep;
				count--;
			} while (count > 0);
			break;
		default:
			Error("Unknown <linetype> %d.\n", LineType);
	}
}
*/
void ScaleTris( vec3_t min, vec3_t max, int Width, int Height, float* u, float* v, int verts)
{

	int		i;
	float	hscale, vscale;
	float	scale;

	hscale = max[0];
	vscale = max[1];

	hscale = (Width-2) / max[0];
	vscale = (Height-2) / max[1];

	scale = hscale;
	if (scale > vscale)
	{
		scale = vscale;
	}
	for ( i = 0; i<verts; i++)
	{
		u[i] *= scale;
		v[i] *= scale;
	}
	return;
}


void GetOneGroup(trigroup_t *tris, int grp, triangle_t* triangles)
{
	int	i;
	int j;

	j = 0;
	for (i = 0; i < fmheader.num_tris; i++)
	{
		if (tris[i].group == grp)
		{
			triangles[j++] = tris[i].triangle;
		}
	}
	return;
}


int GetNumTris( trigroup_t *tris, int grp)
{
	int i;
	int verts;

	verts = 0;
	for (i = 0; i < fmheader.num_tris; i++)
	{
		if (tris[i].group == grp)
		{
			verts++;
		}
	}
	return verts;
}


int ShareVertex( trigroup_t trione, trigroup_t tritwo)
{
	int	i;
	int	j;

	i = 1;
	j = 1;
	for ( i = 0; i < 3; i++)
	{
		for ( j = 0; j < 3; j++)
		{
			if (DistBetween(trione.triangle.verts[i],tritwo.triangle.verts[j]) < TRIVERT_DIST)
			{
				return true; 
			}
		}
	}
	return false;
}


float DistBetween(vec3_t point1, vec3_t point2)
{
	float	dist;

	dist = (point1[0] - point2[0]);
	dist *= dist;
	dist += (point1[1] - point2[1])*(point1[1]-point2[1]);
	dist += (point1[2] - point2[2])*(point1[2]-point2[2]);
	dist = sqrt(dist);
	return dist;
}


void GenSkin(char *ModelFile, char *OutputName, int Width, int Height)
{
	triangle_t	*ptri;
	mesh_node_t *pmnodes;
	int			i;

	pmnodes = NULL;
	ptri = NULL;

	LoadTriangleList (ModelFile, &ptri, &fmheader.num_tris, &pmnodes, &fmheader.num_mesh_nodes);
	if (g_ignoreTriUV)
	{
		for (i=0;i<fmheader.num_tris;i++)
		{
			ptri[i].HasUV=0;
		}
	}

	memset(pic,0,sizeof(pic));
	memset(pic_palette,0,sizeof(pic_palette));
	pic_palette[767] = pic_palette[766] = pic_palette[765] = 255;

	ScaleWidth = Width;
	ScaleHeight = Height;

	BuildST (ptri, fmheader.num_tris, true);

	WritePCXfile (OutputName, pic, SKINPAGE_WIDTH, SKINPAGE_HEIGHT, pic_palette);

	printf("Gen Skin Stats:\n");
	printf("   Input Base: %s\n",ModelFile);
	printf("   Input Dimensions: %d,%d\n",Width,Height);
	printf("\n");
	printf("   Output File: %s\n",OutputName);
	printf("   Output Dimensions: %d,%d\n",ScaleWidth,ScaleHeight);

	if (fmheader.num_mesh_nodes)
	{
		printf("\nNodes:\n");
		for(i=0;i<fmheader.num_mesh_nodes;i++)
		{
			printf("   %s\n",pmnodes[i].name);
		}
	}

	free(ptri);
	free(pmnodes);
}


void Cmd_FMBeginGroup (void)
{
	GetScriptToken (false);

	g_no_opimizations = false;

	groups[num_groups].start_frame = fmheader.num_frames;
	groups[num_groups].num_frames = 0;

	groups[num_groups].degrees = atol(token);
	if (groups[num_groups].degrees < 1 || groups[num_groups].degrees > 32)
	{
		Error ("Degrees of freedom out of range: %d",groups[num_groups].degrees);
	}
}

void Cmd_FMEndGroup (void)
{
	groups[num_groups].num_frames = fmheader.num_frames - groups[num_groups].start_frame;

	if(num_groups < MAX_GROUPS - 1)
	{
		num_groups++;
	}
	else
	{
		Error("Number of compression groups exceded: %i\n", MAX_GROUPS);
	}
}