mirror of
https://github.com/UberGames/GtkRadiant.git
synced 2024-12-18 16:31:25 +00:00
9998050654
git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/branches/ZeroRadiant@183 8a3a26a2-13c4-0310-b231-cf6edde360e5
3404 lines
74 KiB
C
3404 lines
74 KiB
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 "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, ¤t->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);
|
|
}
|
|
}
|
|
|