/*
-Copyright (C) 1999-2007 id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+ 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.
+ 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 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.
+ 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
-*/
+ 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 <assert.h>
/*
-========================================================================
+ ========================================================================
-.FM triangle flexible model file format
+ .FM triangle flexible model file format
-========================================================================
-*/
+ ========================================================================
+ */
//=================================================================
-#define NUMVERTEXNORMALS 162
+#define NUMVERTEXNORMALS 162
-extern float avertexnormals[NUMVERTEXNORMALS][3];
+extern float avertexnormals[NUMVERTEXNORMALS][3];
-#define MAX_GROUPS 128
+#define MAX_GROUPS 128
typedef struct
{
- triangle_t triangle;
- int group;
+ triangle_t triangle;
+ int group;
} trigroup_t;
-#define TRIVERT_DIST .1
+#define TRIVERT_DIST .1
typedef struct
{
- int start_frame;
- int num_frames;
- int degrees;
+ int start_frame;
+ int num_frames;
+ int degrees;
char *mat;
char *ccomp;
char *cbase;
//================================================================
// Initial
-fmheader_t fmheader;
+fmheader_t fmheader;
// Skin
-extern char g_skins[MAX_FM_SKINS][64];
+extern char g_skins[MAX_FM_SKINS][64];
// ST Coord
-extern fmstvert_t base_st[MAX_FM_VERTS];
+extern fmstvert_t base_st[MAX_FM_VERTS];
// Triangles
-extern fmtriangle_t triangles[MAX_FM_TRIANGLES];
+extern fmtriangle_t triangles[MAX_FM_TRIANGLES];
// Frames
-fmframe_t g_frames[MAX_FM_FRAMES];
+fmframe_t g_frames[MAX_FM_FRAMES];
//fmframe_t *g_FMframes;
// GL Commands
-extern int commands[16384];
-extern int numcommands;
+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 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;
+extern char *g_outputDir;
// Mesh Nodes
-mesh_node_t *pmnodes = NULL;
-fmmeshnode_t mesh_nodes[MAX_FM_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];
+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;
+qboolean g_no_opimizations = false;
//
// base frame info
//
-static int triangle_st[MAX_FM_TRIANGLES][3][2];
+static int triangle_st[MAX_FM_TRIANGLES][3][2];
// number of gl vertices
-extern int numglverts;
+extern int numglverts;
// indicates if a triangle has already been used in a glcmd
-extern int used[MAX_FM_TRIANGLES];
+extern int used[MAX_FM_TRIANGLES];
// indicates if a triangle has translucency in it or not
-static qboolean translucent[MAX_FM_TRIANGLES];
+static qboolean translucent[MAX_FM_TRIANGLES];
// main output file handle
-extern FILE *headerouthandle;
+extern FILE *headerouthandle;
// output sizes of buildst()
-static int skin_width, skin_height;
+static int skin_width, skin_height;
// statistics
-static int total_skin_pixels;
-static int skin_pixels_used;
+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);
+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)
-{
+void strupr( char *string ){
int i;
- for (i=0 ; i<strlen(string); i++)
- toupper(string[i]);
+ for ( i = 0 ; i < strlen( string ); i++ )
+ toupper( string[i] );
return;
}
//==============================================================
/*
-===============
-ClearModel
-===============
-*/
-static void ClearModel (void)
-{
- memset (&fmheader, 0, sizeof(fmheader));
+ ===============
+ ClearModel
+ ===============
+ */
+static void ClearModel( void ){
+ memset( &fmheader, 0, sizeof( fmheader ) );
modelname[0] = 0;
- scale_up = 1.0;
- VectorCopy (vec3_origin, adjust);
+ scale_up = 1.0;
+ VectorCopy( vec3_origin, adjust );
g_fixedwidth = g_fixedheight = 0;
g_skipmodel = false;
num_groups = 0;
- if (pmnodes)
- {
- free(pmnodes);
+ if ( pmnodes ) {
+ free( pmnodes );
pmnodes = NULL;
}
}
-extern void H_printf(char *fmt, ...);
+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;
+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
+ 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);
+ 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);
+ else if ( Size == -1 ) {
+ pos = ftell( FH );
}
- memset(&header,0,sizeof(header));
- strcpy(header.ident,Ident);
+ memset( &header,0,sizeof( header ) );
+ strcpy( header.ident,Ident );
header.version = Version;
header.size = Size;
- SafeWrite (FH, &header, sizeof(header));
+ SafeWrite( FH, &header, sizeof( header ) );
- if (Data)
- {
- SafeWrite (FH, Data, Size);
+ if ( Data ) {
+ SafeWrite( FH, Data, Size );
}
- if (pos == -2)
- {
+ if ( pos == -2 ) {
pos = -1;
- fseek(FH, 0, SEEK_END);
+ 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;
+ ============
+ 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;
+ 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
+ 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
+#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];
+ fmheader.framesize = (int)&( (fmaliasframe_t *)0 )->verts[fmheader.num_xyz];
- WriteHeader(modelouthandle, FM_HEADER_NAME, FM_HEADER_VER, sizeof(fmheader), &fmheader);
+ 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);
+ 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++)
+ 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);
+ 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);
+ 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);
+ WriteHeader( modelouthandle, FM_TRI_NAME, FM_TRI_VER, fmheader.num_tris * sizeof( fmtriangle_t ), NULL );
- for (i=0 ; i<fmheader.num_tris ; i++)
+ for ( i = 0 ; i < fmheader.num_tris ; i++ )
{
- int j;
- fmtriangle_t tri;
+ int j;
+ fmtriangle_t tri;
- for (j=0 ; j<3 ; j++)
+ 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]);
+ 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));
+ SafeWrite( modelouthandle, &tri, sizeof( tri ) );
}
- if (!num_groups)
- {
+ 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);
+ 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++)
+ 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++)
+ strcpy( out->name, in->name );
+ for ( j = 0 ; j < 3 ; j++ )
{
- out->scale[j] = (in->maxs[j] - in->mins[j])/255;
+ 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++)
+ for ( j = 0 ; j < fmheader.num_xyz ; j++ )
{
- // all of these are byte values, so no need to deal with endianness
+ // 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++)
+ 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] );
+ // 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)
+ // clamp, so rounding doesn't wrap from 255.6 to 0
+ if ( v > 255.0 ) {
v = 255.0;
- if (v < 0)
+ }
+ if ( v < 0 ) {
v = 0;
+ }
out->verts[j].v[k] = v;
}
}
- for (j=0 ; j<3 ; j++)
+ for ( j = 0 ; j < 3 ; j++ )
{
- out->scale[j] = LittleFloat (out->scale[j]);
- out->translate[j] = LittleFloat (out->translate[j]);
+ out->scale[j] = LittleFloat( out->scale[j] );
+ out->translate[j] = LittleFloat( out->translate[j] );
}
- SafeWrite (modelouthandle, out, fmheader.framesize);
+ SafeWrite( modelouthandle, out, fmheader.framesize );
}
// Go back and finish the header
- // WriteHeader(modelouthandle, FM_FRAME_NAME, FM_FRAME_VER, -1, NULL);
+ // 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++)
+ 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);
+ SafeWrite( modelouthandle,in->name,FRAME_NAME_LEN );
}
- WriteHeader(modelouthandle, FM_NORMAL_NAME, FM_NORMAL_VER,fmheader.num_xyz, NULL);
+ 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);
+ 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);
+ WriteHeader( modelouthandle, FM_GLCMDS_NAME, FM_GLCMDS_VER, numcommands * 4, commands );
//
// write out mesh nodes
//
- for(i=0;i<fmheader.num_mesh_nodes;i++)
+ 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);
+ 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);
+ WriteHeader( modelouthandle, FM_MESH_NAME, FM_MESH_VER, sizeof( fmmeshnode_t ) * fmheader.num_mesh_nodes, mesh_nodes );
- if (num_groups)
- {
+ 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;
-*/
+ 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);
+ 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)
- {
+ if ( g_skelModel.type != SKEL_NULL ) {
size = 0;
- temp = sizeof(int); // change this to a byte
- memcpy(data + size, &g_skelModel.type, temp);
+ 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);
+ 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);
+ 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)
+ for ( i = 0; i < numJointsInSkeleton[g_skelModel.type]; ++i )
{
current = g_skelModel.vertLists[i];
- while(current)
+ while ( current )
{
- temp = sizeof(int); // change this to a short
- memcpy(data + size, ¤t->data, temp);
+ 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
+ free( toFree ); // freeing of memory allocated in ReplaceClusterIndex called in Cmd_Base
}
}
- if(!num_groups) // joints are stored with regular verts for compressed models
- {
+ 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);
+ temp = sizeof( int ); // change this to a byte
+ memcpy( data + size, &framesWritten, temp );
size += temp;
- for (i = 0; i < fmheader.num_frames; ++i)
+ for ( i = 0; i < fmheader.num_frames; ++i )
{
in = &g_frames[i];
- for (j = 0 ; j < numJointsInSkeleton[g_skelModel.type]; ++j)
+ for ( j = 0 ; j < numJointsInSkeleton[g_skelModel.type]; ++j )
{
- for (k=0 ; k<3 ; k++)
+ 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] );
+ 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);
+ 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++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- v = Q_rint ( (in->joints[j].placement.direction[k] - outFrames[i].translate[k]) / outFrames[i].scale[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);
+ 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++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- v = Q_rint ( (in->joints[j].placement.up[k] - outFrames[i].translate[k]) / outFrames[i].scale[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);
+ 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);
+ 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);
+ WriteHeader( modelouthandle, FM_SKELETON_NAME, FM_SKELETON_VER, size, data );
}
- if(g_skelModel.references != REF_NULL)
- {
+ if ( g_skelModel.references != REF_NULL ) {
int refnum;
size = 0;
- if (RefPointNum <= 0)
- { // Hard-coded labels
+ if ( RefPointNum <= 0 ) { // Hard-coded labels
refnum = numReferences[g_skelModel.references];
}
else
- { // Labels indicated in QDT
+ { // Labels indicated in QDT
refnum = RefPointNum;
}
- temp = sizeof(int); // change this to a byte
- memcpy(data2 + size, &g_skelModel.references, temp);
+ temp = sizeof( int ); // change this to a byte
+ memcpy( data2 + size, &g_skelModel.references, temp );
size += temp;
- if(!num_groups)
- {
+ if ( !num_groups ) {
framesWritten = true;
- temp = sizeof(int); // change this to a byte
- memcpy(data2 + size, &framesWritten, temp);
+ temp = sizeof( int ); // change this to a byte
+ memcpy( data2 + size, &framesWritten, temp );
size += temp;
- for (i = 0; i < fmheader.num_frames; ++i)
+ for ( i = 0; i < fmheader.num_frames; ++i )
{
in = &g_frames[i];
- for (j = 0 ; j < refnum; ++j)
+ for ( j = 0 ; j < refnum; ++j )
{
- for (k=0 ; k<3 ; k++)
+ 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] );
+ 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);
+ 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++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- v = Q_rint ( (in->references[j].placement.direction[k] - outFrames[i].translate[k]) / outFrames[i].scale[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);
+ 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++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- v = Q_rint ( (in->references[j].placement.up[k] - outFrames[i].translate[k]) / outFrames[i].scale[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);
+ 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
+ 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);
+ 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);
+ WriteHeader( modelouthandle, FM_REFERENCES_NAME, FM_REFERENCES_VER, size, data2 );
}
}
-static void CompressFrames()
-{
+static void CompressFrames(){
fmgroup_t *g;
int i,j,k;
- fmframe_t *in;
+ fmframe_t *in;
- j=0;
- for (i=0;i<fmheader.num_frames;i++)
+ j = 0;
+ for ( i = 0; i < fmheader.num_frames; i++ )
{
- while (i>=groups[j].start_frame+groups[j].num_frames&&j<num_groups-1)
+ while ( i >= groups[j].start_frame + groups[j].num_frames && j < num_groups - 1 )
j++;
- frame_to_group[i]=j;
+ frame_to_group[i] = j;
}
- for (k=0;k<num_groups;k++)
+ for ( k = 0; k < num_groups; k++ )
{
- g=&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++)
+ 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]);
+ 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);
+ 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 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...");
+ printf( "Optimizing vertices..." );
- memset(vert_used, 0, sizeof(vert_used));
+ memset( vert_used, 0, sizeof( vert_used ) );
- if(g_skelModel.clustered == true)
- {
- memset(newNum_verts, 0, sizeof(newNum_verts));
- memset(newVertLists, 0, sizeof(newVertLists));
+ 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++)
+ for ( i = 0 ; i < fmheader.num_frames ; i++ )
{
in = &g_frames[i];
- for(j=0;j<fmheader.num_xyz;j++)
+ 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])
- {
+ 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])
- {
+ if ( !Found ) {
+ if ( !vert_used[j] ) {
num_unique++;
}
vert_used[j] = true;
}
// recompute the light normals
- for (i=0 ; i<fmheader.num_frames ; i++)
+ for ( i = 0 ; i < fmheader.num_frames ; i++ )
{
in = &g_frames[i];
- for(j=0;j<fmheader.num_xyz;j++)
+ for ( j = 0; j < fmheader.num_xyz; j++ )
{
- if (!vert_used[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);
+ 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++)
+ for ( j = 0 ; j < fmheader.num_xyz ; j++ )
{
- vec3_t v;
- float maxdot;
- int maxdotindex;
- int c;
+ vec3_t v;
+ float maxdot;
+ int maxdotindex;
+ int c;
c = in->v[j].vnorm.numnormals;
- if (!c)
- Error ("Vertex with no triangles attached");
+ if ( !c ) {
+ Error( "Vertex with no triangles attached" );
+ }
- VectorScale (in->v[j].vnorm.normalsum, 1.0/c, v);
- VectorNormalize (v, v);
+ VectorScale( in->v[j].vnorm.normalsum, 1.0 / c, v );
+ VectorNormalize( v, v );
maxdot = -999999.0;
maxdotindex = -1;
- for (k=0 ; k<NUMVERTEXNORMALS ; k++)
+ for ( k = 0 ; k < NUMVERTEXNORMALS ; k++ )
{
- float dot;
+ float dot;
- dot = DotProduct (v, avertexnormals[k]);
- if (dot > maxdot)
- {
+ dot = DotProduct( v, avertexnormals[k] );
+ if ( dot > maxdot ) {
maxdot = dot;
maxdotindex = k;
}
// create substitution list
num_unique = 0;
- for(i=0;i<fmheader.num_xyz;i++)
+ for ( i = 0; i < fmheader.num_xyz; i++ )
{
- if (vert_used[i])
- {
+ if ( vert_used[i] ) {
vert_replacement[i] = num_unique;
num_unique++;
}
// 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)
+ 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)
+ for ( l = 0, current = g_skelModel.vertLists[k];
+ l < g_skelModel.new_num_verts[k + 1]; ++l, current = current->next )
{
- if(current->data == i)
- {
+ 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)
+ for ( m = 0, current2 = newVertLists[k]; m < newNum_verts[k + 1];
+ ++m, current2 = current2->next )
{
- if(current2->data == vert_replacement[i])
- {
+ if ( current2->data == vert_replacement[i] ) {
added = true;
break;
}
}
- if(!added)
- {
- ++newNum_verts[k+1];
+ if ( !added ) {
+ ++newNum_verts[k + 1];
next = newVertLists[k];
- newVertLists[k] = (IntListNode_t *) SafeMalloc(sizeof(IntListNode_t), "OptimizeVertices");
+ newVertLists[k] = (IntListNode_t *) SafeMalloc( sizeof( IntListNode_t ), "OptimizeVertices" );
// freed after model write out
newVertLists[k]->data = vert_replacement[i];
}
// substitute
- for (i=0 ; i<fmheader.num_frames ; i++)
+ for ( i = 0 ; i < fmheader.num_frames ; i++ )
{
in = &g_frames[i];
- for(j=0;j<fmheader.num_xyz;j++)
+ 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)
+ for ( i = 0; i < numJointsInSkeleton[g_skelModel.type]; ++i )
{
IntListNode_t *toFree;
current = g_skelModel.vertLists[i];
- while(current)
+ while ( current )
{
toFree = current;
current = current->next;
- free(toFree); // freeing of memory allocated in ReplaceClusterIndex called in Cmd_Base
+ 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];
+ g_skelModel.new_num_verts[i + 1] = newNum_verts[i + 1];
}
#ifndef NDEBUG
- for(k = 0; k < numJointsInSkeleton[g_skelModel.type]; ++k)
+ 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)
+ 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)
+ 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);
+ 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));
+ 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++)
+ for ( i = 0 ; i < fmheader.num_tris ; i++ )
{
pos = i >> 3;
- bit = 1 << (i & 7 );
+ bit = 1 << ( i & 7 );
- for (j=0 ; j<3 ; j++)
- {
+ 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);
+ set_bit = 1 << ( set_bit & 7 );
- for(k=0;k<fmheader.num_mesh_nodes;k++)
+ for ( k = 0; k < fmheader.num_mesh_nodes; k++ )
{
- if (!(pmnodes[k].tris[pos] & bit))
- {
+ if ( !( pmnodes[k].tris[pos] & bit ) ) {
continue;
}
pmnodes[k].verts[set_pos] |= set_bit;
}
}
- for (i=0;i<numcommands;i++)
+ for ( i = 0; i < numcommands; i++ )
{
j = commands[i];
- if (!j) continue;
+ if ( !j ) {
+ continue;
+ }
- j = abs(j);
- for(i++;j;j--,i+=3)
+ j = abs( j );
+ for ( i++; j; j--,i += 3 )
{
- commands[i+2] = vert_replacement[commands[i+2]];
+ commands[i + 2] = vert_replacement[commands[i + 2]];
}
i--;
}
- printf("Reduced by %d\n",fmheader.num_xyz - num_unique);
-
+ printf( "Reduced by %d\n",fmheader.num_xyz - num_unique );
+
fmheader.num_xyz = num_unique;
- if (num_groups)
- {
+ if ( num_groups ) {
// tack on the reference verts to the regular verts
- if(g_skelModel.references != REF_NULL)
- {
- fmframe_t *in;
+ if ( g_skelModel.references != REF_NULL ) {
+ fmframe_t *in;
int index;
int refnum;
- if (RefPointNum <= 0)
- { // Hard-coded labels
+ if ( RefPointNum <= 0 ) { // Hard-coded labels
refnum = numReferences[g_skelModel.references];
}
else
- { // Labels indicated in QDT
+ { // Labels indicated in QDT
refnum = RefPointNum;
}
- for (i = 0; i < fmheader.num_frames; ++i)
+ for ( i = 0; i < fmheader.num_frames; ++i )
{
in = &g_frames[i];
index = fmheader.num_xyz;
- for (j = 0 ; j < refnum; ++j)
+ for ( j = 0 ; j < refnum; ++j )
{
- VectorCopy(in->references[j].placement.origin, in->v[index].v);
+ VectorCopy( in->references[j].placement.origin, in->v[index].v );
index++;
- VectorCopy(in->references[j].placement.direction, in->v[index].v);
+ VectorCopy( in->references[j].placement.direction, in->v[index].v );
index++;
- VectorCopy(in->references[j].placement.up, in->v[index].v);
+ VectorCopy( in->references[j].placement.up, in->v[index].v );
index++;
}
}
- fmheader.num_xyz += refnum*3;
+ fmheader.num_xyz += refnum * 3;
}
// tack on the skeletal joint verts to the regular verts
- if(g_skelModel.type != SKEL_NULL)
- {
- fmframe_t *in;
+ if ( g_skelModel.type != SKEL_NULL ) {
+ fmframe_t *in;
int index;
- for (i = 0; i < fmheader.num_frames; ++i)
+ 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)
+ for ( j = 0 ; j < numJointsInSkeleton[g_skelModel.type]; ++j )
{
- VectorCopy(in->joints[j].placement.origin, in->v[index].v);
+ VectorCopy( in->joints[j].placement.origin, in->v[index].v );
index++;
- VectorCopy(in->joints[j].placement.direction, in->v[index].v);
+ VectorCopy( in->joints[j].placement.direction, in->v[index].v );
index++;
- VectorCopy(in->joints[j].placement.up, in->v[index].v);
+ VectorCopy( in->joints[j].placement.up, in->v[index].v );
index++;
}
}
- fmheader.num_xyz += numJointsInSkeleton[g_skelModel.type]*3;
+ 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)
+ ===============
+ 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);
+ 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++)
+ for ( i = 0 ; i < fmheader.num_skins ; i++ )
{
- ReleaseFile (g_skins[i]);
+ ReleaseFile( g_skins[i] );
}
fmheader.num_frames = 0;
return;
}
- printf("\n");
+ printf( "\n" );
trans_count = 0;
- for(i=0;i<fmheader.num_tris;i++)
- if (translucent[i])
+ for ( i = 0; i < fmheader.num_tris; i++ )
+ if ( translucent[i] ) {
trans_count++;
+ }
- if (!g_no_opimizations)
- {
+ 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)
- {
+ 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++)
+ 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++)
+ for ( j = 0; j < MAXTRIANGLES; j++ )
{
- pos = (j) >> 3;
- bit = 1 << ((j) & 7 );
- if (pmnodes[i].tris[pos] & bit)
- {
+ pos = ( j ) >> 3;
+ bit = 1 << ( ( j ) & 7 );
+ if ( pmnodes[i].tris[pos] & bit ) {
tris++;
}
}
- for(j=0;j<MAX_FM_VERTS;j++)
+ for ( j = 0; j < MAX_FM_VERTS; j++ )
{
- pos = (j) >> 3;
- bit = 1 << ((j) & 7 );
- if (pmnodes[i].verts[pos] & bit)
- {
+ pos = ( j ) >> 3;
+ bit = 1 << ( ( j ) & 7 );
+ if ( pmnodes[i].verts[pos] & bit ) {
verts++;
}
}
- printf("%-33s %4d %5d\n",pmnodes[i].name,tris,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);
+ printf( "--------------------------------- ---- -----\n" );
+ printf( "%-33s %4d %5d\n","TOTALS",total_tris,total_verts );
}
}
- fclose (modelouthandle);
+ fclose( modelouthandle );
// finish writing header file
- H_printf("\n");
+ 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);
+ 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 ( 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] == ' ')
- {
+ if ( name[j] == ' ' ) {
name[j] = '_';
}
}
- H_printf("#define MESH_%s\t\t%d\n", name, i);
+ H_printf( "#define MESH_%s\t\t%d\n", name, i );
}
}
- fclose (headerouthandle);
+ fclose( headerouthandle );
headerouthandle = NULL;
- free (pmnodes);
+ free( pmnodes );
}
/*
-=================================================================
+ =================================================================
-ALIAS MODEL DISPLAY LIST GENERATION
+ ALIAS MODEL DISPLAY LIST GENERATION
-=================================================================
-*/
+ =================================================================
+ */
-extern int strip_xyz[128];
-extern int strip_st[128];
-extern int strip_tris[128];
-extern int stripcount;
+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;
+ ================
+ 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_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];
+ 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++)
+ 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))
- {
+ bit = 1 << ( j & 7 );
+ if ( !( pmnodes[node].tris[pos] & bit ) ) {
continue;
}
- for (k=0 ; k<3 ; k++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- if (check->index_xyz[k] != m1)
+ if ( check->index_xyz[k] != m1 ) {
continue;
- if (check->index_st[k] != st1)
+ }
+ if ( check->index_st[k] != st1 ) {
continue;
- if (check->index_xyz[ (k+1)%3 ] != m2)
+ }
+ if ( check->index_xyz[ ( k + 1 ) % 3 ] != m2 ) {
continue;
- if (check->index_st[ (k+1)%3 ] != st2)
+ }
+ 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])
+ 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 ];
+ 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 ];
+ 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_xyz[stripcount + 2] = check->index_xyz[ ( k + 2 ) % 3 ];
+ strip_st[stripcount + 2] = check->index_st[ ( k + 2 ) % 3 ];
strip_tris[stripcount] = j;
stripcount++;
done:
// clear the temp used flags
- for (j=starttri+1 ; j<num_tris ; j++)
- if (used[j] == 2)
+ 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;
+ ===========
+ 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_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];
+ 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++)
+ 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))
- {
+ bit = 1 << ( j & 7 );
+ if ( !( pmnodes[node].tris[pos] & bit ) ) {
continue;
}
- for (k=0 ; k<3 ; k++)
+ for ( k = 0 ; k < 3 ; k++ )
{
- if (check->index_xyz[k] != m1)
+ if ( check->index_xyz[k] != m1 ) {
continue;
- if (check->index_st[k] != st1)
+ }
+ if ( check->index_st[k] != st1 ) {
continue;
- if (check->index_xyz[ (k+1)%3 ] != m2)
+ }
+ if ( check->index_xyz[ ( k + 1 ) % 3 ] != m2 ) {
continue;
- if (check->index_st[ (k+1)%3 ] != st2)
+ }
+ 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])
+ 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 ];
+ 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_xyz[stripcount + 2] = m2;
+ strip_st[stripcount + 2] = st2;
strip_tris[stripcount] = j;
stripcount++;
done:
// clear the temp used flags
- for (j=starttri+1 ; j<num_tris ; j++)
- if (used[j] == 2)
+ 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;
+ ================
+ 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
numglverts = 0;
- for(l=0;l<fmheader.num_mesh_nodes;l++)
+ for ( l = 0; l < fmheader.num_mesh_nodes; l++ )
{
- memset (used, 0, sizeof(used));
+ memset( used, 0, sizeof( used ) );
pmnodes[l].start_glcmds = numcommands;
- for(trans_check = 0; trans_check<2; trans_check++)
+ for ( trans_check = 0; trans_check < 2; trans_check++ )
{
- for (i=0 ; i < fmheader.num_tris ; i++)
+ for ( i = 0 ; i < fmheader.num_tris ; i++ )
{
pos = i >> 3;
- bit = 1 << (i & 7 );
- if (!(pmnodes[l].tris[pos] & bit))
- {
+ 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])
- {
+ if ( used[i] || trans_check != translucent[i] ) {
continue;
}
bestlen = 0;
- for (type = 0 ; type < 2 ; type++)
- // type = 1;
+ for ( type = 0 ; type < 2 ; type++ )
+ // type = 1;
{
- for (startv =0 ; startv < 3 ; startv++)
+ 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)
- {
+ 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++)
+ 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++)
+ 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++)
+ for ( j = 0 ; j < bestlen ; j++ )
used[best_tris[j]] = 1;
- if (besttype == 1)
- commands[numcommands++] = (bestlen+2);
- else
- commands[numcommands++] = -(bestlen+2);
+ if ( besttype == 1 ) {
+ commands[numcommands++] = ( bestlen + 2 );
+ }
+ else{
+ commands[numcommands++] = -( bestlen + 2 );
+ }
- numglverts += bestlen+2;
+ numglverts += bestlen + 2;
- for (j=0 ; j<bestlen+2 ; j++)
+ for ( j = 0 ; j < bestlen + 2 ; j++ )
{
// emit a vertex into the reorder buffer
k = best_st[j];
s = base_st[k].s;
t = base_st[k].t;
- s = (s ) / fmheader.skinwidth;
- t = (t ) / fmheader.skinheight;
+ s = ( s ) / fmheader.skinwidth;
+ t = ( t ) / fmheader.skinheight;
*(float *)&commands[numcommands++] = s;
*(float *)&commands[numcommands++] = t;
}
}
}
- commands[numcommands++] = 0; // end of list marker
+ commands[numcommands++] = 0; // end of list marker
pmnodes[l].num_glcmds = numcommands - pmnodes[l].start_glcmds;
}
}
/*
-===============================================================
+ ===============================================================
-BASE FRAME SETUP
+ BASE FRAME SETUP
-===============================================================
-*/
+ ===============================================================
+ */
#define LINE_NORMAL 1
#define ASCII_SPACE 32
int LineType = LINE_NORMAL;
-extern unsigned char pic[SKINPAGE_HEIGHT*SKINPAGE_WIDTH], pic_palette[768];
+extern unsigned char pic[SKINPAGE_HEIGHT * SKINPAGE_WIDTH], pic_palette[768];
unsigned char LineColor = 255;
int ScaleWidth, ScaleHeight;
"*****---*---*---*---*****" // Z
};
-void DrawLine(int x1, int y1, int x2, int y2)
-{
+void DrawLine( int x1, int y1, int x2, int y2 ){
int dx, dy;
int adx, ady;
int count;
dx = x2 - x1;
dy = y2 - y1;
- adx = abs(dx);
- ady = abs(dy);
+ adx = abs( dx );
+ ady = abs( dy );
count = adx > ady ? adx : ady;
count++;
- if(count > 300)
- {
- printf("Bad count\n");
+ 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)
+ 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
+ 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 (u=-0.1 ; u<=0.9 ; u+=0.999)
+ for ( v = -0.1 ; v <= 0.9 ; v += 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;
- }
+ 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);
+ }
+ 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 );
}
}
//
//==========================================================================
-static void DrawCharacter(int x, int y, int character)
-{
+static void DrawCharacter( int x, int y, int character ){
int r, c;
char *def;
- character = toupper(character);
- if(character < ASCII_SPACE || character > 'Z')
- {
+ 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 ( def = CharDefs[character], r = 0; r < 5; r++ )
{
- for(c = 0; c < 5; c++)
+ for ( c = 0; c < 5; c++ )
{
- pic[(y+r)*SKINPAGE_WIDTH+x+c] = *def++ == '*' ? 255 : 0;
+ pic[( y + r ) * SKINPAGE_WIDTH + x + c] = *def++ == '*' ? 255 : 0;
}
}
}
//
//==========================================================================
-void DrawTextChar(int x, int y, char *text)
-{
+void DrawTextChar( int x, int y, char *text ){
int c;
- while((c = *text++) != '\0')
+ while ( ( c = *text++ ) != '\0' )
{
- DrawCharacter(x, y, c);
+ DrawCharacter( x, y, c );
x += 6;
}
}
-extern void DrawScreen(float s_scale, float t_scale, float iwidth, float iheight);
+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];
+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 ( r = 0; r < 5; r++ )
{
- for(c = 0; c < 5; c++)
+ for ( c = 0; c < 5; c++ )
{
- *buffer++ = (pic[(y + r) * SKINPAGE_WIDTH + x + c] == backColor) ? ' ' : '*';
+ *buffer++ = ( pic[( y + r ) * SKINPAGE_WIDTH + x + c] == backColor ) ? ' ' : '*';
}
}
*buffer = '\0';
- for(i = 0; i < 10; i++)
+ for ( i = 0; i < 10; i++ )
{
- if(strcmp(DigitDefs[i], digString) == 0)
- {
+ if ( strcmp( DigitDefs[i], digString ) == 0 ) {
return i;
}
}
- Error("Unable to extract scaling info from skin PCX.");
+ 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);
+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;
+ ============
+ 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);
+ 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
- {
+
+ 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;
+ 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;
}
-
- 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;
+ }
+ scWidth = ScaleWidth * SCALE_ADJUST_FACTOR;
+ if ( backface_flag ) { //we are doubling
+ scWidth /= 2;
+ }
+ scHeight = ScaleHeight * SCALE_ADJUST_FACTOR;
-/* if (!g_fixedwidth)
- { // old style
- scale = 8;
- if (width*scale >= 150)
- scale = 150.0 / width;
- if (height*scale >= 190)
- scale = 190.0 / height;
+ scale = scWidth / width;
- s_scale = t_scale = scale;
+ if ( height * scale >= scHeight ) {
+ scale = scHeight / height;
+ }
- iwidth = ceil(width*s_scale);
- iheight = ceil(height*t_scale);
+ iwidth = ceil( width * scale ) + 4;
+ iheight = ceil( height * scale ) + 4;
- iwidth += 4;
- iheight += 4;
+ s_scale = (float)( iwidth - 4 ) / width;
+ t_scale = (float)( iheight - 4 ) / height;
+ t_scale = s_scale;
}
- else
- { // new style
- iwidth = g_fixedwidth / 2;
- iheight = g_fixedheight;
+ 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;
- s_scale = (float)(iwidth-4) / width;
- t_scale = (float)(iheight-4) / height;
- }*/
+
+/* 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++)
+ for ( i = 0 ; i < numtri ; i++ )
{
- if (ptri[i].HasUV)
- {
- for (j=0 ; j<3 ; j++)
+ 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);
+ 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);
+ 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)
- {
+ if ( normal[1] > 0 ) {
basex = iwidth + 2;
}
else
{
basex = 2;
}
-
- for (j=0 ; j<3 ; j++)
+
+ 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);
+ 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]);
+ 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] );
}
}
// dword alignment for each scan
swidth = iwidth;
- if(backface_flag)
+ if ( backface_flag ) {
swidth *= 2;
- fmheader.skinwidth = (swidth + 3) & ~3;
+ }
+ fmheader.skinwidth = ( swidth + 3 ) & ~3;
fmheader.skinheight = iheight;
skin_width = iwidth;
}
-static void BuildNewST (triangle_t *ptri, int numtri, qboolean DrawSkin)
-{
- int i, j;
+static void BuildNewST( triangle_t *ptri, int numtri, qboolean DrawSkin ){
+ int i, j;
- for (i=0 ; i<numtri ; i++)
+ for ( i = 0 ; i < numtri ; i++ )
{
- if (ptri[i].HasUV)
- {
- for (j=0 ; j<3 ; j++)
+ 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));
+ 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]);
+ 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.skinwidth = ( ScaleWidth + 3 ) & ~3;
fmheader.skinheight = ScaleHeight;
skin_width = ScaleWidth;
-byte *BasePalette;
-byte *BasePixels,*TransPixels;
-int BaseWidth, BaseHeight, TransWidth, TransHeight;
-qboolean BaseTrueColor;
+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];
+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)
+ if ( d < -1 || d > 1 ) {
goto split;
+ }
d = lp2[1] - lp1[1];
- if (d < -1 || d > 1)
+ if ( d < -1 || d > 1 ) {
goto split;
+ }
d = lp3[0] - lp2[0];
- if (d < -1 || d > 1)
+ if ( d < -1 || d > 1 ) {
goto split2;
+ }
d = lp3[1] - lp2[1];
- if (d < -1 || d > 1)
+ if ( d < -1 || d > 1 ) {
goto split2;
+ }
d = lp1[0] - lp3[0];
- if (d < -1 || d > 1)
+ if ( d < -1 || d > 1 ) {
goto split3;
+ }
d = lp1[1] - lp3[1];
- if (d < -1 || d > 1)
- {
+ if ( d < -1 || d > 1 ) {
split3:
temp = lp1;
lp1 = lp3;
goto split;
}
- return 0; // entire tri is filled
+ return 0; // entire tri is filled
split2:
temp = lp1;
split:
// split this edge
- new[0] = (lp1[0] + lp2[0]) >> 1;
- new[1] = (lp1[1] + lp2[1]) >> 1;
+ 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])
+ if ( lp2[1] > lp1[1] ) {
goto nodraw;
- if ((lp2[1] == lp1[1]) && (lp2[0] < lp1[0]))
+ }
+ if ( ( lp2[1] == lp1[1] ) && ( lp2[0] < lp1[0] ) ) {
goto nodraw;
+ }
- if (SetPixel)
- {
- assert ((new[1]*BaseWidth) + new[0] < BaseWidth*BaseHeight);
+ if ( SetPixel ) {
+ assert( ( new[1] * BaseWidth ) + new[0] < BaseWidth * BaseHeight );
- if (BaseTrueColor)
- {
- BasePixels[((new[1]*BaseWidth) + new[0]) * 4] = 1;
+ if ( BaseTrueColor ) {
+ BasePixels[( ( new[1] * BaseWidth ) + new[0] ) * 4] = 1;
}
else
{
- BasePixels[(new[1]*BaseWidth) + new[0]] = 1;
+ BasePixels[( new[1] * BaseWidth ) + new[0]] = 1;
}
}
else
{
- if (TransPixels)
- {
- if (TransPixels[(new[1]*TransWidth) + new[0]] != 255)
+ 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)
+ else if ( BaseTrueColor ) {
+ if ( BasePixels[( ( ( new[1] * BaseWidth ) + new[0] ) * 4 ) + 3] != 255 ) {
return 1;
+ }
}
else
{
nodraw:
// recursively continue
- if (CheckTransRecursiveTri(lp3, lp1, new))
+ if ( CheckTransRecursiveTri( lp3, lp1, new ) ) {
return 1;
+ }
- return CheckTransRecursiveTri(lp3, new, lp2);
+ return CheckTransRecursiveTri( lp3, new, lp2 );
}
-static void ReplaceClusterIndex(int newIndex, int oldindex, int **clusters,
- IntListNode_t **vertLists, int *num_verts, int *new_num_verts)
-{
+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)
+ for ( j = 0; j < numJointsInSkeleton[g_skelModel.type]; ++j )
{
- if(!clusters[j])
- {
+ if ( !clusters[j] ) {
continue;
}
- for(i = 0; i < num_verts[j+1]; ++i)
+ for ( i = 0; i < num_verts[j + 1]; ++i )
{
- if(clusters[j][i] == oldindex)
- {
- ++new_num_verts[j+1];
+ if ( clusters[j][i] == oldindex ) {
+ ++new_num_verts[j + 1];
next = vertLists[j];
- vertLists[j] = (IntListNode_t *) SafeMalloc(sizeof(IntListNode_t), "ReplaceClusterIndex");
+ vertLists[j] = (IntListNode_t *) SafeMalloc( sizeof( IntListNode_t ), "ReplaceClusterIndex" );
// Currently freed in WriteJointedModelFile only
vertLists[j]->data = newIndex;
}
}
-#define FUDGE_EPSILON 0.002
+#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)
+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;
+ =================
+ 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;
+ 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);
+ GetScriptToken( false );
- if (g_skipmodel || g_release || g_archive)
+ if ( g_skipmodel || g_release || g_archive ) {
return;
+ }
- printf ("---------------------\n");
- sprintf (file1, "%s/%s.%s", cdarchive, token, trifileext);
- printf ("%s ", file1);
+ printf( "---------------------\n" );
+ sprintf( file1, "%s/%s.%s", cdarchive, token, trifileext );
+ printf( "%s ", file1 );
- ExpandPathAndArchive (file1);
+ ExpandPathAndArchive( file1 );
// Use the input filepath for this one.
- sprintf (file1, "%s/%s", cddir, token);
+ sprintf( file1, "%s/%s", cddir, token );
// time1 = FileTime (file1);
// if (time1 == -1)
//
// 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 ( 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++)
+ if ( g_ignoreTriUV ) {
+ for ( i = 0; i < fmheader.num_tris; i++ )
{
- ptri[i].HasUV=0;
+ ptri[i].HasUV = 0;
}
}
- GetScriptToken (false);
- sprintf (file2, "%s/%s", cddir, token);
- sprintf (trans_file, "%s/!%s_a.pcx", cddir, token);
+ 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");
+ ExtractFileExtension( file2, extension );
+ if ( extension[0] == 0 ) {
+ strcat( file2, ".pcx" );
}
- printf ("skin: %s\n", file2);
+ printf( "skin: %s\n", file2 );
- BaseTrueColor = LoadAnyImage (file2, &BasePixels, &BasePalette, &BaseWidth, &BaseHeight);
+ BaseTrueColor = LoadAnyImage( file2, &BasePixels, &BasePalette, &BaseWidth, &BaseHeight );
NewSkin = false;
- if (BaseWidth != SKINPAGE_WIDTH || BaseHeight != SKINPAGE_HEIGHT)
- {
- if (g_allow_newskin)
- {
+ 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);
+ 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 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");
+ Error( "Texture coordinates not supported on true color image" );
}
- if (GetST)
- {
- GetScriptToken (false);
+ if ( GetST ) {
+ GetScriptToken( false );
- sprintf (stfile, "%s/%s.%s", cdarchive, token, trifileext);
- printf ("ST: %s ", stfile);
+ sprintf( stfile, "%s/%s.%s", cdarchive, token, trifileext );
+ printf( "ST: %s ", stfile );
- sprintf (stfile, "%s/%s", cddir, token);
+ 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 ( 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);
+ 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++)
+ printf( " matching triangles...\n" );
+ for ( i = 0; i < fmheader.num_tris; i++ )
{
k = -1;
- for(j=0;j<num_st_tris;j++)
+ for ( j = 0; j < num_st_tris; j++ )
{
- for(x=0;x<3;x++)
+ for ( x = 0; x < 3; x++ )
{
- for(y=0;y<3;y++)
+ for ( y = 0; y < 3; y++ )
{
- if (x == y)
- {
+ if ( x == y ) {
continue;
}
- for(z=0;z<3;z++)
+ for ( z = 0; z < 3; z++ )
{
- if (z == x || z == y)
- {
+ 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)
- {
+ 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[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]);
+ 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);
+ if ( k == -1 ) {
+ printf( "No matching triangle %d\n",i );
}
}
- free (st_tri);
+ 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");
+ 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);
+ BuildNewST( ptri, fmheader.num_tris, false );
}
}
else
{
- if (NewSkin)
- {
- Error("Base has new style skin without UVs");
+ if ( NewSkin ) {
+ Error( "Base has new style skin without UVs" );
}
else
{
- BuildST (ptri, fmheader.num_tris, false);
+ 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);
+ 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 );
}
}
}
// base vertex list and setting the indirect triangles to point to the base
// vertices
//
- for(l=0;l<fmheader.num_mesh_nodes;l++)
+ for ( l = 0; l < fmheader.num_mesh_nodes; l++ )
{
- for (i=0 ; i < fmheader.num_tris ; i++)
+ for ( i = 0 ; i < fmheader.num_tris ; i++ )
{
pos = i >> 3;
- bit = 1 << (i & 7 );
- if (!(pmnodes[l].tris[pos] & bit))
- {
+ bit = 1 << ( i & 7 );
+ if ( !( pmnodes[l].tris[pos] & bit ) ) {
continue;
}
- for (j=0 ; j<3 ; j++)
+ for ( j = 0 ; j < 3 ; j++ )
{
// get the xyz index
- for (k=0 ; k<fmheader.num_xyz ; k++)
+ 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 ( 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 ( 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);
+ 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);
+ 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++)
+ 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 ( 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
+ 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]);
+ if ( TransPixels || BaseTrueColor ) {
+ translucent[i] = CheckTransRecursiveTri( triangle_st[i][0], triangle_st[i][1], triangle_st[i][2] );
}
else
{
}
}
- if (!BaseTrueColor)
- {
+ if ( !BaseTrueColor ) {
SetPixel = true;
- memset(BasePixels,0,BaseWidth*BaseHeight);
- for (i=0 ; i < fmheader.num_tris ; i++)
+ 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]);
+ 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 ( i = 0; i < fmheader.skinheight; i++ )
{
- for(j=0;j<fmheader.skinwidth;j++)
+ for ( j = 0; j < fmheader.skinwidth; j++ )
{
- skin_pixels_used += BasePixels[(i*BaseWidth) + j];
+ skin_pixels_used += BasePixels[( i * BaseWidth ) + j];
}
}
- total_skin_pixels = fmheader.skinheight*fmheader.skinwidth;
+ total_skin_pixels = fmheader.skinheight * fmheader.skinwidth;
}
else
{
SetPixel = true;
- memset(BasePixels,0,BaseWidth*BaseHeight*4);
- for (i=0 ; i < fmheader.num_tris ; i++)
+ 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]);
+ 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 ( i = 0; i < fmheader.skinheight; i++ )
{
- for(j=0;j<fmheader.skinwidth;j++)
+ for ( j = 0; j < fmheader.skinwidth; j++ )
{
- skin_pixels_used += BasePixels[((i*BaseWidth) + j)*4];
+ skin_pixels_used += BasePixels[( ( i * BaseWidth ) + j ) * 4];
}
}
- total_skin_pixels = fmheader.skinheight*fmheader.skinwidth;
+ total_skin_pixels = fmheader.skinheight * fmheader.skinwidth;
}
// build triangle strips / fans
- BuildGlCmds ();
+ BuildGlCmds();
- if (TransPixels)
- {
- free(TransPixels);
+ if ( TransPixels ) {
+ free( TransPixels );
}
- free (BasePixels);
- if (BasePalette)
- {
- free (BasePalette);
+ free( BasePixels );
+ if ( BasePalette ) {
+ free( BasePalette );
}
- free(ptri);
+ free( ptri );
}
-void Cmd_FMNodeOrder(void)
-{
- mesh_node_t *newnodes, *pos;
- int i,j;
+void Cmd_FMNodeOrder( void ){
+ mesh_node_t *newnodes, *pos;
+ int i,j;
- if (!pmnodes)
- {
- Error ("Base has not been established yet");
+ if ( !pmnodes ) {
+ Error( "Base has not been established yet" );
}
- pos = newnodes = malloc(sizeof(mesh_node_t) * fmheader.num_mesh_nodes);
+ pos = newnodes = malloc( sizeof( mesh_node_t ) * fmheader.num_mesh_nodes );
- for(i=0;i<fmheader.num_mesh_nodes;i++)
+ for ( i = 0; i < fmheader.num_mesh_nodes; i++ )
{
- GetScriptToken (false);
+ GetScriptToken( false );
- for(j=0;j<fmheader.num_mesh_nodes;j++)
+ for ( j = 0; j < fmheader.num_mesh_nodes; j++ )
{
- if (strcmpi(pmnodes[j].name, token) == 0)
- {
+ 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);
+ if ( j >= fmheader.num_mesh_nodes ) {
+ Error( "Node '%s' not in base list!\n", token );
}
}
- free(pmnodes);
+ free( pmnodes );
pmnodes = newnodes;
}
//===============================================================
-extern char *FindFrameFile (char *frame);
+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;
+ ===============
+ 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);
+ framefile = FindFrameFile( frame );
- sprintf (file1, "%s/%s", cdarchive, framefile);
- ExpandPathAndArchive (file1);
+ sprintf( file1, "%s/%s", cdarchive, framefile );
+ ExpandPathAndArchive( file1 );
- sprintf (file1, "%s/%s",cddir, framefile);
+ sprintf( file1, "%s/%s",cddir, framefile );
- printf ("grabbing %s ", file1);
+ printf( "grabbing %s ", file1 );
- if (fmheader.num_frames >= MAX_FM_FRAMES)
- Error ("fmheader.num_frames >= MAX_FM_FRAMES");
+ 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);
+ 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 ( 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);
+ 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++)
+ for ( i = 0 ; i < fmheader.num_xyz ; i++ )
{
ptrivert[i].vnorm.numnormals = 0;
- VectorClear (ptrivert[i].vnorm.normalsum);
+ VectorClear( ptrivert[i].vnorm.normalsum );
}
- ClearBounds (fr->mins, fr->maxs);
+ 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++)
+ for ( i = 0 ; i < num_tris ; i++ )
{
- vec3_t vtemp1, vtemp2, normal;
- float ftemp;
+ 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);
+ 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);
+ VectorNormalize( normal, normal );
- // rotate the normal so the model faces down the positive x axis
+ // 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++)
+ 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];
+ // 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);
+ AddPointToBounds( ptrivert[index_xyz].v, fr->mins, fr->maxs );
- VectorAdd (ptrivert[index_xyz].vnorm.normalsum, normal, ptrivert[index_xyz].vnorm.normalsum);
+ 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++)
+ for ( i = 0 ; i < fmheader.num_xyz ; i++ )
{
- int j;
- vec3_t v;
- float maxdot;
- int maxdotindex;
- int c;
+ int j;
+ vec3_t v;
+ float maxdot;
+ int maxdotindex;
+ int c;
c = ptrivert[i].vnorm.numnormals;
- if (!c)
- Error ("Vertex with no triangles attached");
+ if ( !c ) {
+ Error( "Vertex with no triangles attached" );
+ }
- VectorScale (ptrivert[i].vnorm.normalsum, 1.0/c, v);
- VectorNormalize (v, v);
+ VectorScale( ptrivert[i].vnorm.normalsum, 1.0 / c, v );
+ VectorNormalize( v, v );
maxdot = -999999.0;
maxdotindex = -1;
- for (j=0 ; j<NUMVERTEXNORMALS ; j++)
+ for ( j = 0 ; j < NUMVERTEXNORMALS ; j++ )
{
- float dot;
+ float dot;
- dot = DotProduct (v, avertexnormals[j]);
- if (dot > maxdot)
- {
+ dot = DotProduct( v, avertexnormals[j] );
+ if ( dot > maxdot ) {
maxdot = dot;
maxdotindex = j;
}
ptrivert[i].lightnormalindex = maxdotindex;
}
- free (ptri);
+ free( ptri );
}
/*
-===============
-Cmd_Frame
-===============
-*/
-void Cmd_FMFrame (void)
-{
- while (ScriptTokenAvailable())
- {
- GetScriptToken (false);
- if (g_skipmodel)
+ ===============
+ 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
+ }
+ 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);
+ 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);
+ if ( ( g_skelModel.type != SKEL_NULL ) || ( g_skelModel.references != REF_NULL ) ) {
+ GrabModelTransform( token );
}
- GrabFrame (token);
+ GrabFrame( token );
- if(g_skelModel.type != SKEL_NULL)
- {
- GrabSkeletalFrame(token);
+ if ( g_skelModel.type != SKEL_NULL ) {
+ GrabSkeletalFrame( token );
}
- if(g_skelModel.references != REF_NULL)
- {
- GrabReferencedFrame(token);
+ if ( g_skelModel.references != REF_NULL ) {
+ GrabReferencedFrame( token );
}
// need to add the up and dir points to the frame bounds here
}
/*
-===============
-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)
+ ===============
+ 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", 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);
+ 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);
+ 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)
+ 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");
+ printf( "loading %s\n", name );
+ ExtractFileExtension( name, extension );
+ if ( extension[0] == 0 ) {
+ strcat( name, ".pcx" );
}
- TrueColor = LoadAnyImage (name, &pixels, &palette, &width, &height);
+ 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++)
+ 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);
+ memcpy( cropped + y * fmheader.skinwidth,
+ pixels + y * width, fmheader.skinwidth );
}
TransPixels = NULL;
- FH = fopen(transname,"rb");
- if (FH)
- {
- fclose(FH);
+ FH = fopen( transname,"rb" );
+ if ( FH ) {
+ fclose( FH );
- strcat(g_skins[fmheader.num_skins-1],".pcx");
- strcat(savename,".pcx");
+ 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);
+ 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);
+ miptex_t *qtex;
+ qtex = CreateMip( cropped, fmheader.skinwidth, fmheader.skinheight, palette, &size, true );
- strcat(g_skins[fmheader.num_skins-1],".m8");
- strcat(savename,".m8");
+ 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);
+ 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");
+ 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);
+ 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++)
+ 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);
+ memcpy( cropped + ( ( y * fmheader.skinwidth ) * 4 ), pixels + ( y * width * 4 ), fmheader.skinwidth * 4 );
}
- qtex32 = CreateMip32((unsigned *)cropped, fmheader.skinwidth, fmheader.skinheight, &size, true);
+ 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");
+ 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);
+ printf( "saving %s\n", savename );
+ CreatePath( savename );
+ SaveFile( savename, (byte *)qtex32, size );
}
- free (pixels);
- if (palette)
- {
- free (palette);
+ free( pixels );
+ if ( palette ) {
+ free( palette );
}
- free (cropped);
+ free( cropped );
}
/*
-===============
-Cmd_Cd
-===============
-*/
-void Cmd_FMCd (void)
-{
+ ===============
+ Cmd_Cd
+ ===============
+ */
+void Cmd_FMCd( void ){
char temp[256];
- FinishModel ();
- ClearModel ();
+ FinishModel();
+ ClearModel();
- GetScriptToken (false);
+ 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);
+ 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);
+ 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])
+ if ( !g_only[0] ) {
return;
- if (strncmp(token, g_only, strlen(g_only)))
- {
+ }
+ if ( strncmp( token, g_only, strlen( g_only ) ) ) {
g_skipmodel = true;
- printf ("skipping %s\n", cdpartial);
+ 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;
+ //=======================
+ // 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 ){
- 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;
+ int i;
+ float hscale, vscale;
+ float scale;
hscale = max[0];
vscale = max[1];
- hscale = (Width-2) / max[0];
- vscale = (Height-2) / max[1];
+ hscale = ( Width - 2 ) / max[0];
+ vscale = ( Height - 2 ) / max[1];
scale = hscale;
- if (scale > vscale)
- {
+ if ( scale > vscale ) {
scale = vscale;
}
- for ( i = 0; i<verts; i++)
+ for ( i = 0; i < verts; i++ )
{
u[i] *= scale;
v[i] *= scale;
}
-void GetOneGroup(trigroup_t *tris, int grp, triangle_t* triangles)
-{
- int i;
+void GetOneGroup( trigroup_t *tris, int grp, triangle_t* triangles ){
+ int i;
int j;
j = 0;
- for (i = 0; i < fmheader.num_tris; i++)
+ for ( i = 0; i < fmheader.num_tris; i++ )
{
- if (tris[i].group == grp)
- {
+ if ( tris[i].group == grp ) {
triangles[j++] = tris[i].triangle;
}
}
}
-int GetNumTris( trigroup_t *tris, int grp)
-{
+int GetNumTris( trigroup_t *tris, int grp ){
int i;
int verts;
verts = 0;
- for (i = 0; i < fmheader.num_tris; i++)
+ for ( i = 0; i < fmheader.num_tris; i++ )
{
- if (tris[i].group == grp)
- {
+ if ( tris[i].group == grp ) {
verts++;
}
}
}
-int ShareVertex( trigroup_t trione, trigroup_t tritwo)
-{
- int i;
- int j;
+int ShareVertex( trigroup_t trione, trigroup_t tritwo ){
+ int i;
+ int j;
i = 1;
j = 1;
- for ( i = 0; i < 3; i++)
+ for ( i = 0; i < 3; i++ )
{
- for ( j = 0; j < 3; j++)
+ for ( j = 0; j < 3; j++ )
{
- if (DistBetween(trione.triangle.verts[i],tritwo.triangle.verts[j]) < TRIVERT_DIST)
- {
- return true;
+ if ( DistBetween( trione.triangle.verts[i],tritwo.triangle.verts[j] ) < TRIVERT_DIST ) {
+ return true;
}
}
}
}
-float DistBetween(vec3_t point1, vec3_t point2)
-{
- float dist;
+float DistBetween( vec3_t point1, vec3_t point2 ){
+ float dist;
- dist = (point1[0] - point2[0]);
+ 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);
+ 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;
+void GenSkin( char *ModelFile, char *OutputName, int Width, int Height ){
+ triangle_t *ptri;
mesh_node_t *pmnodes;
- int i;
+ 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++)
+ 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;
+ ptri[i].HasUV = 0;
}
}
- memset(pic,0,sizeof(pic));
- memset(pic_palette,0,sizeof(pic_palette));
+ 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);
+ BuildST( ptri, fmheader.num_tris, true );
- WritePCXfile (OutputName, pic, SKINPAGE_WIDTH, SKINPAGE_HEIGHT, pic_palette);
+ 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);
+ 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++)
+ if ( fmheader.num_mesh_nodes ) {
+ printf( "\nNodes:\n" );
+ for ( i = 0; i < fmheader.num_mesh_nodes; i++ )
{
- printf(" %s\n",pmnodes[i].name);
+ printf( " %s\n",pmnodes[i].name );
}
}
- free(ptri);
- free(pmnodes);
+ free( ptri );
+ free( pmnodes );
}
-void Cmd_FMBeginGroup (void)
-{
- GetScriptToken (false);
+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);
+ 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)
-{
+void Cmd_FMEndGroup( void ){
groups[num_groups].num_frames = fmheader.num_frames - groups[num_groups].start_frame;
- if(num_groups < MAX_GROUPS - 1)
- {
+ if ( num_groups < MAX_GROUPS - 1 ) {
num_groups++;
}
else
{
- Error("Number of compression groups exceded: %i\n", MAX_GROUPS);
+ Error( "Number of compression groups exceded: %i\n", MAX_GROUPS );
}
}
-
projects / xonotic / netradiant.git / blobdiff