valve/halflife25-sdk
0
0
Fork 0
mirror of https://github.com/shawns-valve/halflife.git synced 2024-11-25 05:31:11 +00:00
Code Issues Projects Releases Packages Wiki Activity
halflife25-sdk/utils/studiomdl/studiomdl.c

3439 lines
71 KiB
C
Raw Permalink Normal View History

initial seed of Half-Life 1 SDK
2013-08-30 20:34:05 +00:00
/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
****/
//
// studiomdl.c: generates a studio .mdl file from a .qc script
// models/<scriptname>.mdl.
//
#pragma warning( disable : 4244 )
#pragma warning( disable : 4237 )
#pragma warning( disable : 4305 )
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <math.h>
#include "archtypes.h"
#include "cmdlib.h"
#include "lbmlib.h"
#include "scriplib.h"
#include "mathlib.h"
#define EXTERN
#include "../../engine/studio.h"
#include "studiomdl.h"
#include "../../dlls/activity.h"
#include "../../dlls/activitymap.h"
static int force_powerof2_textures = 0;
void Sys_Error (char *error, ...) {};
void clip_rotations( vec3_t rot );
#define strcpyn( a, b ) strncpy( a, b, sizeof( a ) )
/*
=================
=================
*/
int k_memtotal;
void *kalloc( int num, int size )
{
// printf( "calloc( %d, %d )\n", num, size );
// printf( "%d ", num * size );
k_memtotal += num * size;
return calloc( num, size );
}
void kmemset( void *ptr, int value, int size )
{
// printf( "kmemset( %x, %d, %d )\n", ptr, value, size );
memset( ptr, value, size );
return;
}
/*
=================
=================
*/
void ClearModel (void)
{
}
void ExtractMotion( )
{
int i, j, k;
int q;
// extract linear motion
for (i = 0; i < numseq; i++)
{
if (sequence[i].numframes > 1)
{
// assume 0 for now.
int type;
vec3_t *ppos;
vec3_t motion = { 0,0,0};
type = sequence[i].motiontype;
ppos = sequence[i].panim[0]->pos[0];
k = sequence[i].numframes - 1;
if (type & STUDIO_LX)
motion[0] = ppos[k][0] - ppos[0][0];
if (type & STUDIO_LY)
motion[1] = ppos[k][1] - ppos[0][1];
if (type & STUDIO_LZ)
motion[2] = ppos[k][2] - ppos[0][2];
// printf("%f %f %f\n", motion[0], motion[1], motion[2] );
for (j = 0; j < sequence[i].numframes; j++)
{
vec3_t adj;
for (k = 0; k < sequence[i].panim[0]->numbones; k++)
{
if (sequence[i].panim[0]->node[k].parent == -1)
{
ppos = sequence[i].panim[0]->pos[k];
VectorScale( motion, j * 1.0 / (sequence[i].numframes - 1), adj );
// printf(" %f %f %f\n", adj[0], adj[1], adj[2] );
for (q = 0; q < sequence[i].numblends; q++)
{
VectorSubtract( sequence[i].panim[q]->pos[k][j], adj, sequence[i].panim[q]->pos[k][j] );
}
}
}
}
VectorCopy( motion, sequence[i].linearmovement );
}
else
{
VectorSubtract( sequence[i].linearmovement, sequence[i].linearmovement, sequence[i].linearmovement );
}
}
// extract unused motion
for (i = 0; i < numseq; i++)
{
int type;
type = sequence[i].motiontype;
for (k = 0; k < sequence[i].panim[0]->numbones; k++)
{
if (sequence[i].panim[0]->node[k].parent == -1)
{
for (q = 0; q < sequence[i].numblends; q++)
{
float motion[6];
motion[0] = sequence[i].panim[q]->pos[k][0][0];
motion[1] = sequence[i].panim[q]->pos[k][0][1];
motion[2] = sequence[i].panim[q]->pos[k][0][2];
motion[3] = sequence[i].panim[q]->rot[k][0][0];
motion[4] = sequence[i].panim[q]->rot[k][0][1];
motion[5] = sequence[i].panim[q]->rot[k][0][2];
for (j = 0; j < sequence[i].numframes; j++)
{
/*
if (type & STUDIO_X)
sequence[i].panim[q]->pos[k][j][0] = motion[0];
if (type & STUDIO_Y)
sequence[i].panim[q]->pos[k][j][1] = motion[1];
if (type & STUDIO_Z)
sequence[i].panim[q]->pos[k][j][2] = motion[2];
*/
if (type & STUDIO_XR)
sequence[i].panim[q]->rot[k][j][0] = motion[3];
if (type & STUDIO_YR)
sequence[i].panim[q]->rot[k][j][1] = motion[4];
if (type & STUDIO_ZR)
sequence[i].panim[q]->rot[k][j][2] = motion[5];
}
}
}
}
}
// extract auto motion
for (i = 0; i < numseq; i++)
{
// assume 0 for now.
int type;
vec3_t *ppos;
vec3_t *prot;
vec3_t motion = { 0,0,0};
vec3_t angles = { 0,0,0};
type = sequence[i].motiontype;
// printf("%f %f %f\n", motion[0], motion[1], motion[2] );
for (j = 0; j < sequence[i].numframes; j++)
{
ppos = sequence[i].panim[0]->pos[0];
prot = sequence[i].panim[0]->rot[0];
if (type & STUDIO_AX)
motion[0] = ppos[j][0] - ppos[0][0];
if (type & STUDIO_AY)
motion[1] = ppos[j][1] - ppos[0][1];
if (type & STUDIO_AZ)
motion[2] = ppos[j][2] - ppos[0][2];
if (type & STUDIO_AXR)
angles[0] = prot[j][0] - prot[0][0];
if (type & STUDIO_AYR)
angles[1] = prot[j][1] - prot[0][1];
if (type & STUDIO_AZR)
angles[2] = prot[j][2] - prot[0][2];
VectorCopy( motion, sequence[i].automovepos[j] );
VectorCopy( angles, sequence[i].automoveangle[j] );
for (k = 0; k < sequence[i].panim[0]->numbones; k++)
{
if (sequence[i].panim[0]->node[k].parent == -1)
{
// printf(" %f %f %f\n", adj[0], adj[1], adj[2] );
for (q = 0; q < sequence[i].numblends; q++)
{
// VectorSubtract( sequence[i].panim[q]->pos[k][j], motion, sequence[i].panim[q]->pos[k][j] );
// VectorSubtract( sequence[i].panim[q]->rot[k][j], angles, sequence[i].panim[q]->pos[k][j] );
}
}
}
}
}
}
void OptimizeAnimations(void)
{
int i, j;
int n, m;
int type;
int q;
int iError = 0;
// optimize animations
for (i = 0; i < numseq; i++)
{
sequence[i].numframes = sequence[i].panim[0]->endframe - sequence[i].panim[0]->startframe + 1;
// force looping animations to be looping
if (sequence[i].flags & STUDIO_LOOPING)
{
for (j = 0; j < sequence[i].panim[0]->numbones; j++)
{
for (q = 0; q < sequence[i].numblends; q++)
{
vec3_t *ppos = sequence[i].panim[q]->pos[j];
vec3_t *prot = sequence[i].panim[q]->rot[j];
n = 0; // sequence[i].panim[q]->startframe;
m = sequence[i].numframes - 1; // sequence[i].panim[q]->endframe;
type = sequence[i].motiontype;
if (!(type & STUDIO_LX))
ppos[m][0] = ppos[n][0];
if (!(type & STUDIO_LY))
ppos[m][1] = ppos[n][1];
if (!(type & STUDIO_LZ))
ppos[m][2] = ppos[n][2];
prot[m][0] = prot[n][0];
prot[m][1] = prot[n][1];
prot[m][2] = prot[n][2];
}
}
}
for (j = 0; j < sequence[i].numevents; j++)
{
if (sequence[i].event[j].frame < sequence[i].panim[0]->startframe)
{
printf( "sequence %s has event (%d) before first frame (%d)\n", sequence[i].name, sequence[i].event[j].frame, sequence[i].panim[0]->startframe );
sequence[i].event[j].frame = sequence[i].panim[0]->startframe;
iError++;
}
if (sequence[i].event[j].frame > sequence[i].panim[0]->endframe)
{
printf( "sequence %s has event (%d) after last frame (%d)\n", sequence[i].name, sequence[i].event[j].frame, sequence[i].panim[0]->endframe );
sequence[i].event[j].frame = sequence[i].panim[0]->endframe;
iError++;
}
}
sequence[i].frameoffset = sequence[i].panim[0]->startframe;
// printf("\n");
}
/*
if (iError)
exit(1);
*/
}
int findNode( char *name )
{
int k;
for (k = 0; k < numbones; k++)
{
if (strcmp( bonetable[k].name, name ) == 0)
{
return k;
}
}
return -1;
}
void MatrixCopy (float in[3][4], float out[3][4])
{
int i, j;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
out[i][j] = in[i][j];
}
}
}
void MakeTransitions( )
{
int i, j, k;
int iHit;
// add in direct node transitions
for (i = 0; i < numseq; i++)
{
if (sequence[i].entrynode != sequence[i].exitnode)
{
xnode[sequence[i].entrynode-1][sequence[i].exitnode-1] = sequence[i].exitnode;
if (sequence[i].nodeflags)
{
xnode[sequence[i].exitnode-1][sequence[i].entrynode-1] = sequence[i].entrynode;
}
}
if (sequence[i].entrynode > numxnodes)
numxnodes = sequence[i].entrynode;
}
// add multi-stage transitions
do
{
iHit = 0;
for (i = 1; i <= numxnodes; i++)
{
for (j = 1; j <= numxnodes; j++)
{
// if I can't go there directly
if (i != j && xnode[i-1][j-1] == 0)
{
for (k = 1; k < numxnodes; k++)
{
// but I found someone who knows how that I can get to
if (xnode[k-1][j-1] > 0 && xnode[i-1][k-1] > 0)
{
// then go to them
xnode[i-1][j-1] = -xnode[i-1][k-1];
iHit = 1;
break;
}
}
}
}
}
// reset previous pass so the links can be used in the next pass
for (i = 1; i <= numxnodes; i++)
{
for (j = 1; j <= numxnodes; j++)
{
xnode[i-1][j-1] = abs( xnode[i-1][j-1] );
}
}
}
while (iHit);
}
void SimplifyModel (void)
{
int i, j, k;
int n, m, q;
vec3_t *defaultpos[MAXSTUDIOSRCBONES];
vec3_t *defaultrot[MAXSTUDIOSRCBONES];
int iError = 0;
OptimizeAnimations( );
ExtractMotion( );
MakeTransitions( );
// find used bones
for (i = 0; i < nummodels; i++)
{
for (k = 0; k < MAXSTUDIOSRCBONES; k++)
{
model[i]->boneref[k] = 0;
}
for (j = 0; j < model[i]->numverts; j++)
{
model[i]->boneref[model[i]->vert[j].bone] = 1;
}
for (k = 0; k < MAXSTUDIOSRCBONES; k++)
{
// tag parent bones as used if child has been used
if (model[i]->boneref[k])
{
n = model[i]->node[k].parent;
while (n != -1 && !model[i]->boneref[n])
{
model[i]->boneref[n] = 1;
n = model[i]->node[n].parent;
}
}
}
}
// rename model bones if needed
for (i = 0; i < nummodels; i++)
{
for (j = 0; j < model[i]->numbones; j++)
{
for (k = 0; k < numrenamedbones; k++)
{
if (!strcmp( model[i]->node[j].name, renamedbone[k].from))
{
strcpy( model[i]->node[j].name, renamedbone[k].to );
break;
}
}
}
}
// union of all used bones
numbones = 0;
for (i = 0; i < nummodels; i++)
{
for (k = 0; k < MAXSTUDIOSRCBONES; k++)
{
model[i]->boneimap[k] = -1;
}
for (j = 0; j < model[i]->numbones; j++)
{
if (model[i]->boneref[j])
{
k = findNode( model[i]->node[j].name );
if (k == -1)
{
// create new bone
// printf("%d : %s\n", numbones, model[i]->node[j].name );
k = numbones;
strcpyn( bonetable[k].name, model[i]->node[j].name );
if ((n = model[i]->node[j].parent) != -1)
bonetable[k].parent = findNode( model[i]->node[n].name );
else
bonetable[k].parent = -1;
bonetable[k].bonecontroller = 0;
bonetable[k].flags = 0;
// set defaults
defaultpos[k] = kalloc( MAXSTUDIOANIMATIONS, sizeof( vec3_t ) );
defaultrot[k] = kalloc( MAXSTUDIOANIMATIONS, sizeof( vec3_t ) );
for (n = 0; n < MAXSTUDIOANIMATIONS; n++)
{
VectorCopy( model[i]->skeleton[j].pos, defaultpos[k][n] );
VectorCopy( model[i]->skeleton[j].rot, defaultrot[k][n] );
}
VectorCopy( model[i]->skeleton[j].pos, bonetable[k].pos );
VectorCopy( model[i]->skeleton[j].rot, bonetable[k].rot );
numbones++;
}
else
{
// double check parent assignments
n = model[i]->node[j].parent;
if (n != -1)
n = findNode( model[i]->node[n].name );
m = bonetable[k].parent;
if (n != m)
{
printf("illegal parent bone replacement in model \"%s\"\n\t\"%s\" has \"%s\", previously was \"%s\"\n",
model[i]->name,
model[i]->node[j].name,
(n != -1) ? bonetable[n].name : "ROOT",
(m != -1) ? bonetable[m].name : "ROOT" );
iError++;
}
}
model[i]->bonemap[j] = k;
model[i]->boneimap[k] = j;
}
}
}
if (iError && !(ignore_warnings))
{
exit( 1 );
}
if (numbones >= MAXSTUDIOBONES)
{
Error( "Too many bones used in model, used %d, max %d\n", numbones, MAXSTUDIOBONES );
}
// rename sequence bones if needed
for (i = 0; i < numseq; i++)
{
for (j = 0; j < sequence[i].panim[0]->numbones; j++)
{
for (k = 0; k < numrenamedbones; k++)
{
if (!strcmp( sequence[i].panim[0]->node[j].name, renamedbone[k].from))
{
strcpy( sequence[i].panim[0]->node[j].name, renamedbone[k].to );
break;
}
}
}
}
// map each sequences bone list to master list
for (i = 0; i < numseq; i++)
{
for (k = 0; k < MAXSTUDIOSRCBONES; k++)
{
sequence[i].panim[0]->boneimap[k] = -1;
}
for (j = 0; j < sequence[i].panim[0]->numbones; j++)
{
k = findNode( sequence[i].panim[0]->node[j].name );
if (k == -1)
{
// printf("unknown bone \"%s\" in sequence \"%s\"\n", sequence[i].panim[0]->node[j].name, sequence[i].name );
sequence[i].panim[0]->bonemap[j] = -1;
}
else
{
char *szAnim = "ROOT";
char *szNode = "ROOT";
// whoa, check parent connections!
if (sequence[i].panim[0]->node[j].parent != -1)
szAnim = sequence[i].panim[0]->node[sequence[i].panim[0]->node[j].parent].name;
if (bonetable[k].parent != -1)
szNode = bonetable[bonetable[k].parent].name;
if (strcmp(szAnim, szNode))
{
printf("illegal parent bone replacement in sequence \"%s\"\n\t\"%s\" has \"%s\", reference has \"%s\"\n",
sequence[i].name,
sequence[i].panim[0]->node[j].name,
szAnim,
szNode );
iError++;
}
sequence[i].panim[0]->bonemap[j] = k;
sequence[i].panim[0]->boneimap[k] = j;
// VectorCopy( sequence[i].panim[0]->pos[j][0].org, bonetable[k].pos );
// VectorCopy( sequence[i].panim[0]->rot[j][0].org, bonetable[k].rot );
}
}
}
if (iError && !(ignore_warnings))
{
exit( 1 );
}
// link bonecontrollers
for (i = 0; i < numbonecontrollers; i++)
{
for (j = 0; j < numbones; j++)
{
if (stricmp( bonecontroller[i].name, bonetable[j].name) == 0)
break;
}
if (j >= numbones)
{
Error("unknown bonecontroller link '%s'\n", bonecontroller[i].name );
}
bonecontroller[i].bone = j;
}
// link attachments
for (i = 0; i < numattachments; i++)
{
for (j = 0; j < numbones; j++)
{
if (stricmp( attachment[i].bonename, bonetable[j].name) == 0)
break;
}
if (j >= numbones)
{
Error("unknown attachment link '%s'\n", attachment[i].bonename );
}
attachment[i].bone = j;
}
// relink model
for (i = 0; i < nummodels; i++)
{
for (j = 0; j < model[i]->numverts; j++)
{
model[i]->vert[j].bone = model[i]->bonemap[model[i]->vert[j].bone];
}
for (j = 0; j < model[i]->numnorms; j++)
{
model[i]->normal[j].bone = model[i]->bonemap[model[i]->normal[j].bone];
}
}
// set hitgroups
for (k = 0; k < numbones; k++)
{
bonetable[k].group = -9999;
}
for (j = 0; j < numhitgroups; j++)
{
for (k = 0; k < numbones; k++)
{
if (strcmpi( bonetable[k].name, hitgroup[j].name) == 0)
{
bonetable[k].group = hitgroup[j].group;
break;
}
}
if (k >= numbones)
Error( "cannot find bone %s for hitgroup %d\n", hitgroup[j].name, hitgroup[j].group );
}
for (k = 0; k < numbones; k++)
{
if (bonetable[k].group == -9999)
{
if (bonetable[k].parent != -1)
bonetable[k].group = bonetable[bonetable[k].parent].group;
else
bonetable[k].group = 0;
}
}
if (numhitboxes == 0)
{
// find intersection box volume for each bone
for (k = 0; k < numbones; k++)
{
for (j = 0; j < 3; j++)
{
bonetable[k].bmin[j] = 0.0;
bonetable[k].bmax[j] = 0.0;
}
}
// try all the connect vertices
for (i = 0; i < nummodels; i++)
{
vec3_t p;
for (j = 0; j < model[i]->numverts; j++)
{
VectorCopy( model[i]->vert[j].org, p );
k = model[i]->vert[j].bone;
if (p[0] < bonetable[k].bmin[0]) bonetable[k].bmin[0] = p[0];
if (p[1] < bonetable[k].bmin[1]) bonetable[k].bmin[1] = p[1];
if (p[2] < bonetable[k].bmin[2]) bonetable[k].bmin[2] = p[2];
if (p[0] > bonetable[k].bmax[0]) bonetable[k].bmax[0] = p[0];
if (p[1] > bonetable[k].bmax[1]) bonetable[k].bmax[1] = p[1];
if (p[2] > bonetable[k].bmax[2]) bonetable[k].bmax[2] = p[2];
}
}
// add in all your children as well
for (k = 0; k < numbones; k++)
{
if ((j = bonetable[k].parent) != -1)
{
if (bonetable[k].pos[0] < bonetable[j].bmin[0]) bonetable[j].bmin[0] = bonetable[k].pos[0];
if (bonetable[k].pos[1] < bonetable[j].bmin[1]) bonetable[j].bmin[1] = bonetable[k].pos[1];
if (bonetable[k].pos[2] < bonetable[j].bmin[2]) bonetable[j].bmin[2] = bonetable[k].pos[2];
if (bonetable[k].pos[0] > bonetable[j].bmax[0]) bonetable[j].bmax[0] = bonetable[k].pos[0];
if (bonetable[k].pos[1] > bonetable[j].bmax[1]) bonetable[j].bmax[1] = bonetable[k].pos[1];
if (bonetable[k].pos[2] > bonetable[j].bmax[2]) bonetable[j].bmax[2] = bonetable[k].pos[2];
}
}
for (k = 0; k < numbones; k++)
{
if (bonetable[k].bmin[0] < bonetable[k].bmax[0] - 1
&& bonetable[k].bmin[1] < bonetable[k].bmax[1] - 1
&& bonetable[k].bmin[2] < bonetable[k].bmax[2] - 1)
{
hitbox[numhitboxes].bone = k;
hitbox[numhitboxes].group = bonetable[k].group;
VectorCopy( bonetable[k].bmin, hitbox[numhitboxes].bmin );
VectorCopy( bonetable[k].bmax, hitbox[numhitboxes].bmax );
if (dump_hboxes)
{
printf("$hbox %d \"%s\" %.2f %.2f %.2f %.2f %.2f %.2f\n",
hitbox[numhitboxes].group,
bonetable[hitbox[numhitboxes].bone].name,
hitbox[numhitboxes].bmin[0], hitbox[numhitboxes].bmin[1], hitbox[numhitboxes].bmin[2],
hitbox[numhitboxes].bmax[0], hitbox[numhitboxes].bmax[1], hitbox[numhitboxes].bmax[2] );
}
numhitboxes++;
}
}
}
else
{
for (j = 0; j < numhitboxes; j++)
{
for (k = 0; k < numbones; k++)
{
if (strcmpi( bonetable[k].name, hitbox[j].name) == 0)
{
hitbox[j].bone = k;
break;
}
}
if (k >= numbones)
Error( "cannot find bone %s for bbox\n", hitbox[j].name );
}
}
// relink animations
for (i = 0; i < numseq; i++)
{
vec3_t *origpos[MAXSTUDIOSRCBONES];
vec3_t *origrot[MAXSTUDIOSRCBONES];
for (q = 0; q < sequence[i].numblends; q++)
{
// save pointers to original animations
for (j = 0; j < sequence[i].panim[q]->numbones; j++)
{
origpos[j] = sequence[i].panim[q]->pos[j];
origrot[j] = sequence[i].panim[q]->rot[j];
}
for (j = 0; j < numbones; j++)
{
if ((k = sequence[i].panim[0]->boneimap[j]) >= 0)
{
// link to original animations
sequence[i].panim[q]->pos[j] = origpos[k];
sequence[i].panim[q]->rot[j] = origrot[k];
}
else
{
// link to dummy animations
sequence[i].panim[q]->pos[j] = defaultpos[j];
sequence[i].panim[q]->rot[j] = defaultrot[j];
}
}
}
// printf("%s %f\n", sequence[i].name, sequence[i].panim[0]->pos[3][0][0] );
}
// find scales for all bones
for (j = 0; j < numbones; j++)
{
for (k = 0; k < 6; k++)
{
float minv, maxv, scale;
if (k < 3)
{
minv = -128.0;
maxv = 128.0;
}
else
{
minv = -Q_PI / 8.0;
maxv = Q_PI / 8.0;
}
for (i = 0; i < numseq; i++)
{
for (q = 0; q < sequence[i].numblends; q++)
{
for (n = 0; n < sequence[i].numframes; n++)
{
float v;
switch(k)
{
case 0:
case 1:
case 2:
v = ( sequence[i].panim[q]->pos[j][n][k] - bonetable[j].pos[k] );
break;
case 3:
case 4:
case 5:
v = ( sequence[i].panim[q]->rot[j][n][k-3] - bonetable[j].rot[k-3] );
if (v >= Q_PI)
v -= Q_PI * 2;
if (v < -Q_PI)
v += Q_PI * 2;
break;
}
if (v < minv)
minv = v;
if (v > maxv)
maxv = v;
}
}
}
if (minv < maxv)
{
if (-minv> maxv)
{
scale = minv / -32768.0;
}
else
{
scale = maxv / 32767;
}
}
else
{
scale = 1.0 / 32.0;
}
switch(k)
{
case 0:
case 1:
case 2:
bonetable[j].posscale[k] = scale;
break;
case 3:
case 4:
case 5:
bonetable[j].rotscale[k-3] = scale;
break;
}
// printf("%.0f ", 1.0 / scale );
}
// printf("\n" );
}
// find bounding box for each sequence
for (i = 0; i < numseq; i++)
{
vec3_t bmin, bmax;
// find intersection box volume for each bone
for (j = 0; j < 3; j++)
{
bmin[j] = 9999.0;
bmax[j] = -9999.0;
}
for (q = 0; q < sequence[i].numblends; q++)
{
for (n = 0; n < sequence[i].numframes; n++)
{
float bonetransform[MAXSTUDIOBONES][3][4]; // bone transformation matrix
float bonematrix[3][4]; // local transformation matrix
vec3_t pos;
for (j = 0; j < numbones; j++)
{
vec3_t angle;
// convert to degrees
angle[0] = sequence[i].panim[q]->rot[j][n][0] * (180.0 / Q_PI);
angle[1] = sequence[i].panim[q]->rot[j][n][1] * (180.0 / Q_PI);
angle[2] = sequence[i].panim[q]->rot[j][n][2] * (180.0 / Q_PI);
AngleMatrix( angle, bonematrix );
bonematrix[0][3] = sequence[i].panim[q]->pos[j][n][0];
bonematrix[1][3] = sequence[i].panim[q]->pos[j][n][1];
bonematrix[2][3] = sequence[i].panim[q]->pos[j][n][2];
if (bonetable[j].parent == -1)
{
MatrixCopy( bonematrix, bonetransform[j] );
}
else
{
R_ConcatTransforms (bonetransform[bonetable[j].parent], bonematrix, bonetransform[j]);
}
}
for (k = 0; k < nummodels; k++)
{
for (j = 0; j < model[k]->numverts; j++)
{
VectorTransform( model[k]->vert[j].org, bonetransform[model[k]->vert[j].bone], pos );
if (pos[0] < bmin[0]) bmin[0] = pos[0];
if (pos[1] < bmin[1]) bmin[1] = pos[1];
if (pos[2] < bmin[2]) bmin[2] = pos[2];
if (pos[0] > bmax[0]) bmax[0] = pos[0];
if (pos[1] > bmax[1]) bmax[1] = pos[1];
if (pos[2] > bmax[2]) bmax[2] = pos[2];
}
}
}
}
VectorCopy( bmin, sequence[i].bmin );
VectorCopy( bmax, sequence[i].bmax );
/*
printf("%s : %.0f %.0f %.0f %.0f %.0f %.0f\n",
sequence[i].name, bmin[0], bmax[0], bmin[1], bmax[1], bmin[2], bmax[2] );
*/
// printf("%s %.2f\n", sequence[i].name, sequence[i].panim[0]->pos[9][0][0] / bonetable[9].pos[0] );
}
// reduce animations
{
int total = 0;
int changes = 0;
int p;
for (i = 0; i < numseq; i++)
{
for (q = 0; q < sequence[i].numblends; q++)
{
for (j = 0; j < numbones; j++)
{
for (k = 0; k < 6; k++)
{
mstudioanimvalue_t *pcount, *pvalue;
float v;
short value[MAXSTUDIOANIMATIONS];
mstudioanimvalue_t data[MAXSTUDIOANIMATIONS];
for (n = 0; n < sequence[i].numframes; n++)
{
switch(k)
{
case 0:
case 1:
case 2:
value[n] = ( sequence[i].panim[q]->pos[j][n][k] - bonetable[j].pos[k] ) / bonetable[j].posscale[k];
break;
case 3:
case 4:
case 5:
v = ( sequence[i].panim[q]->rot[j][n][k-3] - bonetable[j].rot[k-3] );
if (v >= Q_PI)
v -= Q_PI * 2;
if (v < -Q_PI)
v += Q_PI * 2;
value[n] = v / bonetable[j].rotscale[k-3];
break;
}
}
if (n == 0)
Error("no animation frames: \"%s\"\n", sequence[i].name );
sequence[i].panim[q]->numanim[j][k] = 0;
memset( data, 0, sizeof( data ) );
pcount = data;
pvalue = pcount + 1;
pcount->num.valid = 1;
pcount->num.total = 1;
pvalue->value = value[0];
pvalue++;
for (m = 1, p = 0; m < n; m++)
{
if (abs(value[p] - value[m]) > 1600)
{
changes++;
p = m;
}
}
// this compression algorithm needs work
for (m = 1; m < n; m++)
{
if (pcount->num.total == 255)
{
// too many, force a new entry
pcount = pvalue;
pvalue = pcount + 1;
pcount->num.valid++;
pvalue->value = value[m];
pvalue++;
}
// insert value if they're not equal,
// or if we're not on a run and the run is less than 3 units
else if ((value[m] != value[m-1])
|| ((pcount->num.total == pcount->num.valid) && ((m < n - 1) && value[m] != value[m+1])))
{
total++;
if (pcount->num.total != pcount->num.valid)
{
//if (j == 0) printf("%d:%d ", pcount->num.valid, pcount->num.total );
pcount = pvalue;
pvalue = pcount + 1;
}
pcount->num.valid++;
pvalue->value = value[m];
pvalue++;
}
pcount->num.total++;
}
//if (j == 0) printf("%d:%d\n", pcount->num.valid, pcount->num.total );
sequence[i].panim[q]->numanim[j][k] = pvalue - data;
if (sequence[i].panim[q]->numanim[j][k] == 2 && value[0] == 0)
{
sequence[i].panim[q]->numanim[j][k] = 0;
}
else
{
sequence[i].panim[q]->anim[j][k] = kalloc( pvalue - data, sizeof( mstudioanimvalue_t ) );
memmove( sequence[i].panim[q]->anim[j][k], data, (pvalue - data) * sizeof( mstudioanimvalue_t ) );
}
// printf("%d(%d) ", sequence[i].panim[q]->numanim[j][k], n );
}
// printf("\n");
}
}
}
// printf("total %.0f changes %.0f\n", total, changes );
}
// auto groups
if (numseqgroups == 1 && maxseqgroupsize < 1024 * 1024)
{
int current = 0;
numseqgroups = 2;
for (i = 0; i < numseq; i++)
{
int accum = 0;
if (sequence[i].activity == 0)
{
for (q = 0; q < sequence[i].numblends; q++)
{
for (j = 0; j < numbones; j++)
{
for (k = 0; k < 6; k++)
{
accum += sequence[i].panim[q]->numanim[j][k] * sizeof( mstudioanimvalue_t );
}
}
}
accum += sequence[i].numblends * numbones * sizeof( mstudioanim_t );
if (current && current + accum > maxseqgroupsize)
{
numseqgroups++;
current = accum;
}
else
{
current += accum;
}
// printf("%d %d %d\n", numseqgroups, current, accum );
sequence[i].seqgroup = numseqgroups - 1;
}
else
{
sequence[i].seqgroup = 0;
}
}
}
}
/*
=================
=================
*/
int lookupControl( char *string )
{
if (stricmp(string,"X")==0) return STUDIO_X;
if (stricmp(string,"Y")==0) return STUDIO_Y;
if (stricmp(string,"Z")==0) return STUDIO_Z;
if (stricmp(string,"XR")==0) return STUDIO_XR;
if (stricmp(string,"YR")==0) return STUDIO_YR;
if (stricmp(string,"ZR")==0) return STUDIO_ZR;
if (stricmp(string,"LX")==0) return STUDIO_LX;
if (stricmp(string,"LY")==0) return STUDIO_LY;
if (stricmp(string,"LZ")==0) return STUDIO_LZ;
if (stricmp(string,"AX")==0) return STUDIO_AX;
if (stricmp(string,"AY")==0) return STUDIO_AY;
if (stricmp(string,"AZ")==0) return STUDIO_AZ;
if (stricmp(string,"AXR")==0) return STUDIO_AXR;
if (stricmp(string,"AYR")==0) return STUDIO_AYR;
if (stricmp(string,"AZR")==0) return STUDIO_AZR;
return -1;
}
// search case-insensitive for string2 in string
char *stristr( const char *string, const char *string2 )
{
int c, len;
c = tolower( *string2 );
len = strlen( string2 );
while (string) {
for (; *string && tolower( *string ) != c; string++);
if (*string) {
if (strnicmp( string, string2, len ) == 0) {
break;
}
string++;
}
else {
return NULL;
}
}
return (char *)string;
}
/*
=================
=================
*/
int lookup_texture( char *texturename )
{
int i;
for (i = 0; i < numtextures; i++) {
if (stricmp( texture[i].name, texturename ) == 0) {
return i;
}
}
strcpyn( texture[i].name, texturename );
if (stristr( texturename, "chrome" ) != NULL) {
texture[i].flags = STUDIO_NF_FLATSHADE | STUDIO_NF_CHROME;
}
else {
texture[i].flags = 0;
}
numtextures++;
return i;
}
s_mesh_t *lookup_mesh( s_model_t *pmodel, char *texturename )
{
int i, j;
j = lookup_texture( texturename );
for (i = 0; i < pmodel->nummesh; i++) {
if (pmodel->pmesh[i]->skinref == j) {
return pmodel->pmesh[i];
}
}
if (i >= MAXSTUDIOMESHES) {
Error( "too many textures in model: \"%s\"\n", pmodel->name );
}
pmodel->nummesh = i + 1;
pmodel->pmesh[i] = kalloc( 1, sizeof( s_mesh_t ) );
pmodel->pmesh[i]->skinref = j;
return pmodel->pmesh[i];
}
s_trianglevert_t *lookup_triangle( s_mesh_t *pmesh, int index )
{
if (index >= pmesh->alloctris) {
int start = pmesh->alloctris;
pmesh->alloctris = index + 256;
if (pmesh->triangle) {
pmesh->triangle = realloc( pmesh->triangle, pmesh->alloctris * sizeof( *pmesh->triangle ) );
kmemset( &pmesh->triangle[start], 0, (pmesh->alloctris - start) * sizeof( *pmesh->triangle ) );
}
else {
pmesh->triangle = kalloc( pmesh->alloctris, sizeof( *pmesh->triangle ) );
}
}
return pmesh->triangle[index];
}
int lookup_normal( s_model_t *pmodel, s_normal_t *pnormal )
{
int i;
for (i = 0; i < pmodel->numnorms; i++) {
// if (VectorCompare( pmodel->normal[i].org, pnormal->org )
if (DotProduct( pmodel->normal[i].org, pnormal->org ) > normal_blend
&& pmodel->normal[i].bone == pnormal->bone
&& pmodel->normal[i].skinref == pnormal->skinref) {
return i;
}
}
if (i >= MAXSTUDIOVERTS) {
Error( "too many normals in model: \"%s\"\n", pmodel->name);
}
VectorCopy( pnormal->org, pmodel->normal[i].org );
pmodel->normal[i].bone = pnormal->bone;
pmodel->normal[i].skinref = pnormal->skinref;
pmodel->numnorms = i + 1;
return i;
}
int lookup_vertex( s_model_t *pmodel, s_vertex_t *pv )
{
int i;
// assume 2 digits of accuracy
pv->org[0] = (int)(pv->org[0] * 100) / 100.0;
pv->org[1] = (int)(pv->org[1] * 100) / 100.0;
pv->org[2] = (int)(pv->org[2] * 100) / 100.0;
for (i = 0; i < pmodel->numverts; i++) {
if (VectorCompare( pmodel->vert[i].org, pv->org )
&& pmodel->vert[i].bone == pv->bone) {
return i;
}
}
if (i >= MAXSTUDIOVERTS) {
Error( "too many vertices in model: \"%s\"\n", pmodel->name);
}
VectorCopy( pv->org, pmodel->vert[i].org );
pmodel->vert[i].bone = pv->bone;
pmodel->numverts = i + 1;
return i;
}
void adjust_vertex( float *org )
{
org[0] = (org[0] - adjust[0]);
org[1] = (org[1] - adjust[1]);
org[2] = (org[2] - adjust[2]);
}
void scale_vertex( float *org )
{
float tmp = org[0];
org[0] = org[0] * scale_up;
org[1] = org[1] * scale_up;
org[2] = org[2] * scale_up;
}
/*
============
SetSkinValues
Called for the base frame
============
*/
void TextureCoordRanges( s_mesh_t *pmesh, s_texture_t *ptexture )
{
int i, j;
if (ptexture->flags & STUDIO_NF_CHROME) {
ptexture->skintop = 0;
ptexture->skinleft = 0;
ptexture->skinwidth = (ptexture->srcwidth + 3) & ~3;
ptexture->skinheight = ptexture->srcheight;
for (i=0 ; i<pmesh->numtris ; i++) {
for (j = 0; j < 3; j++) {
pmesh->triangle[i][j].s = 0;
pmesh->triangle[i][j].t = 0;
}
ptexture->max_s = 63;
ptexture->min_s = 0;
ptexture->max_t = 63;
ptexture->min_t = 0;
}
return;
}
// clip texture coords.
for (i=0 ; i<pmesh->numtris ; i++) {
if (pmesh->triangle[i][0].u > 100.0 || pmesh->triangle[i][1].u > 100.0 || pmesh->triangle[i][2].u > 100.0)
{
// printf("%d : %f %f %f\n", i, pmesh->triangle[i][0].u, pmesh->triangle[i][1].u, pmesh->triangle[i][2].u );
}
if (pmesh->triangle[i][0].v > 100.0 || pmesh->triangle[i][1].v > 100.0 || pmesh->triangle[i][2].v > 100.0)
{
// printf("%d : %f %f %f\n", i, pmesh->triangle[i][0].v, pmesh->triangle[i][1].v, pmesh->triangle[i][2].v );
}
}
for (i=0 ; i<pmesh->numtris ; i++) {
for (j = 0; j < 3; j++) {
if (pmesh->triangle[i][j].u > 2.0) pmesh->triangle[i][j].u = 2.0;
if (pmesh->triangle[i][j].u < -1.0) pmesh->triangle[i][j].u = -1.0;
if (pmesh->triangle[i][j].v > 2.0) pmesh->triangle[i][j].v = 2.0;
if (pmesh->triangle[i][j].v < -1.0) pmesh->triangle[i][j].v = -1.0;
}
}
// pack texture coords
if (!clip_texcoords)
{
int k, n;
do
{
float min_u = 10;
float max_u = -10;
float k_max_u, n_min_u;
k = -1;
n = -1;
for (i=0 ; i<pmesh->numtris ; i++)
{
float local_min, local_max;
local_min = min( pmesh->triangle[i][0].u, min( pmesh->triangle[i][1].u, pmesh->triangle[i][2].u ));
local_max = max( pmesh->triangle[i][0].u, max( pmesh->triangle[i][1].u, pmesh->triangle[i][2].u ));
if (local_min < min_u) { min_u = local_min; k = i; k_max_u = local_max; }
if (local_max > max_u) { max_u = local_max; n = i; n_min_u = local_min; }
}
if (k_max_u + 1.0 < max_u)
{
//printf("%d %f %f\n", k, k_max_u, max_u );
for (j = 0; j < 3; j++)
pmesh->triangle[k][j].u += 1.0;
}
else if (n_min_u - 1.0 > min_u)
{
//printf("%d %f %f\n", n, n_min_u, min_u );
for (j = 0; j < 3; j++)
pmesh->triangle[n][j].u -= 1.0;
}
else
{
break;
}
} while (1);
do
{
float min_v = 10;
float max_v = -10;
float k_max_v, n_min_v;
k = -1;
n = -1;
for (i=0 ; i<pmesh->numtris ; i++)
{
float local_min, local_max;
local_min = min( pmesh->triangle[i][0].v, min( pmesh->triangle[i][1].v, pmesh->triangle[i][2].v ));
local_max = max( pmesh->triangle[i][0].v, max( pmesh->triangle[i][1].v, pmesh->triangle[i][2].v ));
if (local_min < min_v) { min_v = local_min; k = i; k_max_v = local_max; }
if (local_max > max_v) { max_v = local_max; n = i; n_min_v = local_min; }
}
if (k_max_v + 1.0 < max_v)
{
//printf("%d %f %f\n", k, k_max_v, max_v );
for (j = 0; j < 3; j++)
pmesh->triangle[k][j].v += 1.0;
}
else if (n_min_v - 1.0 > min_v)
{
//printf("%d %f %f\n", n, n_min_v, min_v );
for (j = 0; j < 3; j++)
pmesh->triangle[n][j].v -= 1.0;
}
else
{
break;
}
} while (1);
}
else
{
for (i=0 ; i<pmesh->numtris ; i++)
{
for (j = 0; j < 3; j++)
{
if (pmesh->triangle[i][j].u < 0) pmesh->triangle[i][j].u = 0;
if (pmesh->triangle[i][j].u > 1) pmesh->triangle[i][j].u = 1;
if (pmesh->triangle[i][j].v < 0) pmesh->triangle[i][j].v = 0;
if (pmesh->triangle[i][j].v > 1) pmesh->triangle[i][j].v = 1;
}
}
}
// convert to pixel coordinates
for (i=0 ; i<pmesh->numtris ; i++) {
for (j = 0; j < 3; j++) {
// FIXME losing texture coord resultion!
pmesh->triangle[i][j].s = pmesh->triangle[i][j].u * (ptexture->srcwidth - 1);
pmesh->triangle[i][j].t = pmesh->triangle[i][j].v * (ptexture->srcheight - 1);
}
}
// find the range
if (!clip_texcoords)
{
for (i=0 ; i<pmesh->numtris ; i++) {
for (j = 0; j < 3; j++) {
ptexture->max_s = max( pmesh->triangle[i][j].s, ptexture->max_s );
ptexture->min_s = min( pmesh->triangle[i][j].s, ptexture->min_s );
ptexture->max_t = max( pmesh->triangle[i][j].t, ptexture->max_t );
ptexture->min_t = min( pmesh->triangle[i][j].t, ptexture->min_t );
}
}
}
else
{
ptexture->max_s = ptexture->srcwidth-1;
ptexture->min_s = 0;
ptexture->max_t = ptexture->srcheight-1;
ptexture->min_t = 0;
}
//printf("%d %d : ", ptexture->srcwidth, ptexture->srcheight );
//printf("%.0f %.0f %.0f %.0f\n", ptexture->min_s, ptexture->max_s, ptexture->min_t, ptexture->max_t );
}
void ResetTextureCoordRanges( s_mesh_t *pmesh, s_texture_t *ptexture )
{
int i, j;
// adjust top, left edge
for (i=0 ; i<pmesh->numtris ; i++) {
for (j = 0; j < 3; j++) {
pmesh->triangle[i][j].s -= ptexture->min_s;
// quake wants t inverted
pmesh->triangle[i][j].t = (ptexture->max_t - ptexture->min_t) - (pmesh->triangle[i][j].t - ptexture->min_t);
}
}
}
/*
===============
Grab_Skin
===============
*/
void Grab_BMP ( char *filename, s_texture_t *ptexture )
{
int result;
if (result = LoadBMP(filename, &ptexture->ppicture, (byte **)&ptexture->ppal )) {
Error("error %d reading BMP image \"%s\"\n", result, filename );
}
ptexture->srcwidth = bmhd.w;
ptexture->srcheight = bmhd.h;
}
#define MIN_DIMENSION 8
#define MAX_DIMENSION 512
int GetBestPowerOf2( int value )
{
int i;
int power = MIN_DIMENSION;
for(i=0;i<32;i++)
{
if ( (1<<i) < MIN_DIMENSION )
continue;
if ( (1<<i) > MAX_DIMENSION )
continue;
power=(1<<i);
if(power>=value)
{
break;
}
}
return power;
}
int GetSkinWidth( int rawsize )
{
if ( !force_powerof2_textures )
{
return (int)( rawsize + 3) & ~3;
}
return GetBestPowerOf2( rawsize );
}
int GetSkinHeight( int rawsize )
{
if ( !force_powerof2_textures )
{
return ( rawsize );
}
return GetBestPowerOf2( rawsize );
}
void ResizeTexture( s_texture_t *ptexture )
{
int i, j, s, t;
byte *pdest;
int srcadjwidth;
// make the width a multiple of 4; some hardware requires this, and it ensures
// dword alignment for each scan
ptexture->skintop = ptexture->min_t;
ptexture->skinleft = ptexture->min_s;
ptexture->skinwidth = GetSkinWidth( ptexture->max_s - ptexture->min_s + 1);
ptexture->skinheight = GetSkinHeight(ptexture->max_t - ptexture->min_t + 1);
ptexture->size = ptexture->skinwidth * ptexture->skinheight + 256 * 3;
printf ("BMP %s [%d %d] (%.0f%%) %6d bytes\n", ptexture->name, ptexture->skinwidth, ptexture->skinheight,
((ptexture->skinwidth * ptexture->skinheight) / (float)(ptexture->srcwidth * ptexture->srcheight)) * 100.0,
ptexture->size );
if (ptexture->size > 640 * 480)
{
printf("%.0f %.0f %.0f %.0f\n", ptexture->min_s, ptexture->max_s, ptexture->min_t, ptexture->max_t );
Error("texture too large\n");
}
pdest = malloc( ptexture->size );
ptexture->pdata = pdest;
// data is saved as a multiple of 4
srcadjwidth = (ptexture->srcwidth + 3) & ~3;
// move the picture data to the model area, replicating missing data, deleting unused data.
for (i = 0, t = ptexture->srcheight - ptexture->skinheight - ptexture->skintop + 10 * ptexture->srcheight; i < ptexture->skinheight; i++, t++) {
while (t >= ptexture->srcheight) t -= ptexture->srcheight;
while (t < 0) t += ptexture->srcheight;
for (j = 0, s = ptexture->skinleft + 10 * ptexture->srcwidth; j < ptexture->skinwidth; j++, s++) {
while (s >= ptexture->srcwidth) s -= ptexture->srcwidth;
*(pdest++) = *(ptexture->ppicture + s + t * srcadjwidth);
}
}
// TODO: process the texture and flag it if fullbright or transparent are used.
// TODO: only save as many palette entries as are actually used.
if (gamma != 1.8)
{
// gamma correct the monster textures to a gamma of 1.8
float g;
byte *psrc = (byte *)ptexture->ppal;
g = gamma / 1.8;
for (i = 0; i < 768; i++)
{
pdest[i] = pow( psrc[i] / 255.0, g ) * 255;
}
}
else
{
memcpy( pdest, ptexture->ppal, 256 * sizeof( rgb_t ) );
}
free( ptexture->ppicture );
free( ptexture->ppal );
}
void Grab_Skin ( s_texture_t *ptexture )
{
char file1[1024];
int time1;
sprintf (file1, "%s/%s", cdpartial, ptexture->name);
ExpandPathAndArchive (file1);
if (cdtextureset)
{
int i;
for (i = 0; i < cdtextureset; i++)
{
sprintf (file1, "%s/%s", cdtexture[i], ptexture->name);
time1 = FileTime (file1);
if (time1 != -1)
break;
}
if (time1 == -1)
Error( "%s not found", file1);
}
else
{
sprintf (file1, "%s/%s", cddir, ptexture->name);
}
if (stricmp( ".bmp", &file1[strlen(file1)-4]) == 0) {
Grab_BMP( file1, ptexture );
}
else {
Error("unknown graphics type: \"%s\"\n", file1 );
}
}
void SetSkinValues( )
{
int i, j;
int index;
for (i = 0; i < numtextures; i++)
{
Grab_Skin ( &texture[i] );
texture[i].max_s = -9999999;
texture[i].min_s = 9999999;
texture[i].max_t = -9999999;
texture[i].min_t = 9999999;
}
for (i = 0; i < nummodels; i++)
{
for (j = 0; j < model[i]->nummesh; j++)
{
TextureCoordRanges( model[i]->pmesh[j], &texture[model[i]->pmesh[j]->skinref] );
}
}
for (i = 0; i < numtextures; i++)
{
if (texture[i].max_s < texture[i].min_s )
{
// must be a replacement texture
if (texture[i].flags & STUDIO_NF_CHROME)
{
texture[i].max_s = 63;
texture[i].min_s = 0;
texture[i].max_t = 63;
texture[i].min_t = 0;
}
else
{
texture[i].max_s = texture[texture[i].parent].max_s;
texture[i].min_s = texture[texture[i].parent].min_s;
texture[i].max_t = texture[texture[i].parent].max_t;
texture[i].min_t = texture[texture[i].parent].min_t;
}
}
ResizeTexture( &texture[i] );
}
for (i = 0; i < nummodels; i++)
{
for (j = 0; j < model[i]->nummesh; j++)
{
ResetTextureCoordRanges( model[i]->pmesh[j], &texture[model[i]->pmesh[j]->skinref] );
}
}
// build texture groups
for (i = 0; i < MAXSTUDIOSKINS; i++)
{
for (j = 0; j < MAXSTUDIOSKINS; j++)
{
skinref[i][j] = j;
}
}
index = 0;
for (i = 0; i < numtexturelayers[0]; i++)
{
for (j = 0; j < numtexturereps[0]; j++)
{
skinref[i][texturegroup[0][0][j]] = texturegroup[0][i][j];
}
}
if (i != 0)
{
numskinfamilies = i;
}
else
{
numskinfamilies = 1;
numskinref = numtextures;
}
// printf ("width: %i height: %i\n",width, height);
/*
printf ("adjusted width: %i height: %i top : %i left: %i\n",
pmesh->skinwidth, pmesh->skinheight, pmesh->skintop, pmesh->skinleft );
*/
}
/*
=================
=================
*/
char filename[1024];
FILE *input;
char line[1024];
int linecount;
void Build_Reference( s_model_t *pmodel)
{
int i, parent;
float angle[3];
for (i = 0; i < pmodel->numbones; i++)
{
float m[3][4];
vec3_t p;
// convert to degrees
angle[0] = pmodel->skeleton[i].rot[0] * (180.0 / Q_PI);
angle[1] = pmodel->skeleton[i].rot[1] * (180.0 / Q_PI);
angle[2] = pmodel->skeleton[i].rot[2] * (180.0 / Q_PI);
parent = pmodel->node[i].parent;
if (parent == -1) {
// scale the done pos.
// calc rotational matrices
AngleMatrix( angle, bonefixup[i].m );
AngleIMatrix( angle, bonefixup[i].im );
VectorCopy( pmodel->skeleton[i].pos, bonefixup[i].worldorg );
}
else {
// calc compound rotational matrices
// FIXME : Hey, it's orthogical so inv(A) == transpose(A)
AngleMatrix( angle, m );
R_ConcatTransforms( bonefixup[parent].m, m, bonefixup[i].m );
AngleIMatrix( angle, m );
R_ConcatTransforms( m, bonefixup[parent].im, bonefixup[i].im );
// calc true world coord.
VectorTransform(pmodel->skeleton[i].pos, bonefixup[parent].m, p );
VectorAdd( p, bonefixup[parent].worldorg, bonefixup[i].worldorg );
}
// printf("%3d %f %f %f\n", i, bonefixup[i].worldorg[0], bonefixup[i].worldorg[1], bonefixup[i].worldorg[2] );
/*
AngleMatrix( angle, m );
printf("%8.4f %8.4f %8.4f\n", m[0][0], m[1][0], m[2][0] );
printf("%8.4f %8.4f %8.4f\n", m[0][1], m[1][1], m[2][1] );
printf("%8.4f %8.4f %8.4f\n", m[0][2], m[1][2], m[2][2] );
*/
}
}
void Grab_Triangles( s_model_t *pmodel )
{
int i, j;
int tcount = 0;
int ncount = 0;
vec3_t vmin, vmax;
vmin[0] = vmin[1] = vmin[2] = 99999;
vmax[0] = vmax[1] = vmax[2] = -99999;
Build_Reference( pmodel );
//
// load the base triangles
//
while (1)
{
if (fgets( line, sizeof( line ), input ) != NULL)
{
s_mesh_t *pmesh;
char texturename[64];
s_trianglevert_t *ptriv;
int bone;
vec3_t vert[3];
vec3_t norm[3];
linecount++;
// check for end
if (strcmp( "end\n", line ) == 0)
return;
// strip off trailing smag
strcpy( texturename, line );
for (i = strlen( texturename ) - 1; i >= 0 && ! isgraph( texturename[i] ); i--) ;
texturename[i + 1] = '\0';
// funky texture overrides
for (i = 0; i < numrep; i++)
{
if (sourcetexture[i][0] == '\0')
{
strcpy( texturename, defaulttexture[i] );
break;
}
if (stricmp( texturename, sourcetexture[i]) == 0)
{
strcpy( texturename, defaulttexture[i] );
break;
}
}
if (texturename[0] == '\0')
{
// weird model problem, skip them
fgets( line, sizeof( line ), input );
fgets( line, sizeof( line ), input );
fgets( line, sizeof( line ), input );
linecount += 3;
continue;
}
pmesh = lookup_mesh( pmodel, texturename );
for (j = 0; j < 3; j++)
{
if (flip_triangles)
// quake wants them in the reverse order
ptriv = lookup_triangle( pmesh, pmesh->numtris ) + 2 - j;
else
ptriv = lookup_triangle( pmesh, pmesh->numtris ) + j;
if (fgets( line, sizeof( line ), input ) != NULL)
{
s_vertex_t p;
vec3_t tmp;
s_normal_t normal;
linecount++;
if (sscanf( line, "%d %f %f %f %f %f %f %f %f",
&bone,
&p.org[0], &p.org[1], &p.org[2],
&normal.org[0], &normal.org[1], &normal.org[2],
&ptriv->u, &ptriv->v ) == 9)
{
if (bone < 0 || bone >= pmodel->numbones)
{
fprintf( stderr, "bogus bone index\n" );
fprintf(stderr, "%d %s :\n%s", linecount, filename, line );
exit(1);
}
/*
if (ptriv->u > 2.0)
{
printf("%d %f\n", linecount, ptriv->u );
}
*/
VectorCopy( p.org, vert[j] );
VectorCopy( normal.org, norm[j] );
p.bone = bone;
normal.bone = bone;
normal.skinref = pmesh->skinref;
if (p.org[2] < vmin[2]) vmin[2] = p.org[2];
adjust_vertex( p.org );
scale_vertex( p.org );
// move vertex position to object space.
VectorSubtract( p.org, bonefixup[p.bone].worldorg, tmp );
VectorTransform(tmp, bonefixup[p.bone].im, p.org );
// move normal to object space.
VectorCopy( normal.org, tmp );
VectorTransform(tmp, bonefixup[p.bone].im, normal.org );
VectorNormalize( normal.org );
ptriv->normindex = lookup_normal( pmodel, &normal );
ptriv->vertindex = lookup_vertex( pmodel, &p );
// tag bone as being used
// pmodel->bone[bone].ref = 1;
}
else
{
Error("%s: error on line %d: %s", filename, linecount, line );
}
}
}
if (tag_reversed || tag_normals)
{
// check triangle direction
if (DotProduct( norm[0], norm[1] ) < 0.0
|| DotProduct( norm[1], norm[2] ) < 0.0
|| DotProduct( norm[2], norm[0] ) < 0.0 ) {
ncount++;
if (tag_normals)
{
// steal the triangle and make it white
s_trianglevert_t *ptriv2;
pmesh = lookup_mesh( pmodel, "..\\white.bmp" );
ptriv2 = lookup_triangle( pmesh, pmesh->numtris );
ptriv2[0] = ptriv[0];
ptriv2[1] = ptriv[1];
ptriv2[2] = ptriv[2];
}
}
else
{
vec3_t a1, a2, sn;
float x, y, z;
VectorSubtract( vert[1], vert[0], a1 );
VectorSubtract( vert[2], vert[0], a2 );
CrossProduct( a1, a2, sn );
VectorNormalize( sn );
x = DotProduct( sn, norm[0] );
y = DotProduct( sn, norm[1] );
z = DotProduct( sn, norm[2] );
if (x < 0.0 || y < 0.0 || z < 0.0)
{
if (tag_reversed)
{
// steal the triangle and make it white
s_trianglevert_t *ptriv2;
printf("triangle reversed (%f %f %f)\n",
DotProduct( norm[0], norm[1] ),
DotProduct( norm[1], norm[2] ),
DotProduct( norm[2], norm[0] ) );
pmesh = lookup_mesh( pmodel, "..\\white.bmp" );
ptriv2 = lookup_triangle( pmesh, pmesh->numtris );
ptriv2[0] = ptriv[0];
ptriv2[1] = ptriv[1];
ptriv2[2] = ptriv[2];
}
}
}
}
pmodel->trimesh[tcount] = pmesh;
pmodel->trimap[tcount] = pmesh->numtris++;
tcount++;
}
else {
break;
}
}
if (ncount) printf("%d triangles with misdirected normals\n", ncount );
if (vmin[2] != 0.0)
{
printf("lowest vector at %f\n", vmin[2] );
}
}
void Grab_Skeleton( s_node_t *pnodes, s_bone_t *pbones )
{
float x, y, z, xr, yr, zr;
char cmd[1024];
int index;
while (fgets( line, sizeof( line ), input ) != NULL)
{
linecount++;
if (sscanf( line, "%d %f %f %f %f %f %f", &index, &x, &y, &z, &xr, &yr, &zr ) == 7)
{
pbones[index].pos[0] = x;
pbones[index].pos[1] = y;
pbones[index].pos[2] = z;
scale_vertex( pbones[index].pos );
if (pnodes[index].mirrored)
VectorScale( pbones[index].pos, -1.0, pbones[index].pos );
pbones[index].rot[0] = xr;
pbones[index].rot[1] = yr;
pbones[index].rot[2] = zr;
clip_rotations( pbones[index].rot );
}
else if (sscanf( line, "%s %d", cmd, &index ))
{
if (strcmp( cmd, "time" ) == 0)
{
// pbones = pnode->bones[index] = kalloc(1, sizeof( s_bones_t ));
}
else if (strcmp( cmd, "end") == 0)
{
return;
}
}
}
}
int Grab_Nodes( s_node_t *pnodes )
{
int index;
char name[1024];
int parent;
int numbones = 0;
int i;
while (fgets( line, sizeof( line ), input ) != NULL)
{
linecount++;
if (sscanf( line, "%d \"%[^\"]\" %d", &index, name, &parent ) == 3)
{
// check for duplicated bones
/*
if (strlen(pnodes[index].name) != 0)
{
Error( "bone \"%s\" exists more than once\n", name );
}
*/
strcpyn( pnodes[index].name, name );
pnodes[index].parent = parent;
numbones = index;
// check for mirrored bones;
for (i = 0; i < nummirrored; i++)
{
if (strcmp( name, mirrored[i] ) == 0)
pnodes[index].mirrored = 1;
}
if ((! pnodes[index].mirrored) && parent != -1)
{
pnodes[index].mirrored = pnodes[pnodes[index].parent].mirrored;
}
}
else
{
return numbones + 1;
}
}
Error( "Unexpected EOF at line %d\n", linecount );
return 0;
}
void Grab_Studio ( s_model_t *pmodel )
{
int time1;
char cmd[1024];
int option;
sprintf (filename, "%s/%s.smd", cddir, pmodel->name);
time1 = FileTime (filename);
if (time1 == -1)
Error ("%s doesn't exist", filename);
printf ("grabbing %s\n", filename);
if ((input = fopen(filename, "r")) == 0) {
fprintf(stderr,"reader: could not open file '%s'\n", filename);
}
linecount = 0;
while (fgets( line, sizeof( line ), input ) != NULL) {
linecount++;
sscanf( line, "%s %d", cmd, &option );
if (strcmp( cmd, "version" ) == 0) {
if (option != 1) {
Error("bad version\n");
}
}
else if (strcmp( cmd, "nodes" ) == 0) {
pmodel->numbones = Grab_Nodes( pmodel->node );
}
else if (strcmp( cmd, "skeleton" ) == 0) {
Grab_Skeleton( pmodel->node, pmodel->skeleton );
}
else if (strcmp( cmd, "triangles" ) == 0) {
Grab_Triangles( pmodel );
}
else
{
printf("unknown studio command\n" );
}
}
fclose( input );
}
void clip_rotations( vec3_t rot )
{
int j;
// clip everything to : -Q_PI <= x < Q_PI
for (j = 0; j < 3; j++) {
while (rot[j] >= Q_PI)
rot[j] -= Q_PI*2;
while (rot[j] < -Q_PI)
rot[j] += Q_PI*2;
}
}
/*
=================
Cmd_Eyeposition
=================
*/
void Cmd_Eyeposition (void)
{
// rotate points into frame of reference so model points down the positive x
// axis
GetToken (false);
eyeposition[1] = atof (token);
GetToken (false);
eyeposition[0] = -atof (token);
GetToken (false);
eyeposition[2] = atof (token);
}
/*
=================
Cmd_Flags
=================
*/
void Cmd_Flags (void)
{
GetToken (false);
gflags = atoi (token);
}
/*
=================
Cmd_Modelname
=================
*/
void Cmd_Modelname (void)
{
GetToken (false);
strcpyn (outname, token);
}
/*
===============
===============
*/
void Option_Studio( )
{
if (!GetToken (false)) return;
model[nummodels] = kalloc( 1, sizeof( s_model_t ) );
bodypart[numbodyparts].pmodel[bodypart[numbodyparts].nummodels] = model[nummodels];
strcpyn( model[nummodels]->name, token );
flip_triangles = 1;
scale_up = default_scale;
while (TokenAvailable())
{
GetToken(false);
if (stricmp( "reverse", token ) == 0)
{
flip_triangles = 0;
}
else if (stricmp( "scale", token ) == 0)
{
GetToken(false);
scale_up = atof( token );
}
}
Grab_Studio( model[nummodels] );
bodypart[numbodyparts].nummodels++;
nummodels++;
scale_up = default_scale;
}
int Option_Blank( )
{
model[nummodels] = kalloc( 1, sizeof( s_model_t ) );
bodypart[numbodyparts].pmodel[bodypart[numbodyparts].nummodels] = model[nummodels];
strcpyn( model[nummodels]->name, "blank" );
bodypart[numbodyparts].nummodels++;
nummodels++;
return 0;
}
void Cmd_Bodygroup( )
{
int is_started = 0;
if (!GetToken(false)) return;
if (numbodyparts == 0) {
bodypart[numbodyparts].base = 1;
}
else {
bodypart[numbodyparts].base = bodypart[numbodyparts-1].base * bodypart[numbodyparts-1].nummodels;
}
strcpyn( bodypart[numbodyparts].name, token );
do
{
GetToken (true);
if (endofscript)
return;
else if (token[0] == '{')
is_started = 1;
else if (token[0] == '}')
break;
else if (stricmp("studio", token ) == 0)
Option_Studio( );
else if (stricmp("blank", token ) == 0)
Option_Blank( );
} while (1);
numbodyparts++;
return;
}
void Cmd_Body( )
{
int is_started = 0;
if (!GetToken(false)) return;
if (numbodyparts == 0) {
bodypart[numbodyparts].base = 1;
}
else {
bodypart[numbodyparts].base = bodypart[numbodyparts-1].base * bodypart[numbodyparts-1].nummodels;
}
strcpyn(bodypart[numbodyparts].name, token );
Option_Studio( );
numbodyparts++;
}
/*
===============
===============
*/
void Grab_Animation( s_animation_t *panim)
{
vec3_t pos;
vec3_t rot;
char cmd[1024];
int index;
int t = -99999999;
float cz, sz;
int start = 99999;
int end = 0;
for (index = 0; index < panim->numbones; index++)
{
panim->pos[index] = kalloc( MAXSTUDIOANIMATIONS, sizeof( vec3_t ) );
panim->rot[index] = kalloc( MAXSTUDIOANIMATIONS, sizeof( vec3_t ) );
}
cz = cos( zrotation );
sz = sin( zrotation );
while (fgets( line, sizeof( line ), input ) != NULL)
{
linecount++;
if (sscanf( line, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &rot[0], &rot[1], &rot[2] ) == 7)
{
if (t >= panim->startframe && t <= panim->endframe)
{
if (panim->node[index].parent == -1) {
adjust_vertex( pos );
panim->pos[index][t][0] = cz * pos[0] - sz * pos[1];
panim->pos[index][t][1] = sz * pos[0] + cz * pos[1];
panim->pos[index][t][2] = pos[2];
// rotate model
rot[2] += zrotation;
}
else
{
VectorCopy( pos, panim->pos[index][t] );
}
if (t > end)
end = t;
if (t < start)
start = t;
if (panim->node[index].mirrored)
VectorScale( panim->pos[index][t], -1.0, panim->pos[index][t] );
scale_vertex( panim->pos[index][t] );
clip_rotations( rot );
VectorCopy( rot, panim->rot[index][t] );
}
}
else if (sscanf( line, "%s %d", cmd, &index ))
{
if (strcmp( cmd, "time" ) == 0)
{
t = index;
}
else if (strcmp( cmd, "end") == 0)
{
panim->startframe = start;
panim->endframe = end;
return;
}
else
{
Error( "Error(%d) : %s", linecount, line );
}
}
else
{
Error( "Error(%d) : %s", linecount, line );
}
}
Error( "unexpected EOF: %s\n", panim->name );
}
void Shift_Animation( s_animation_t *panim)
{
int j;
int size;
size = (panim->endframe - panim->startframe + 1) * sizeof( vec3_t );
// shift
for (j = 0; j < panim->numbones; j++)
{
vec3_t *ppos;
vec3_t *prot;
k_memtotal -= MAXSTUDIOANIMATIONS * sizeof( vec3_t ) * 2;
k_memtotal += size * 2;
ppos = kalloc( 1, size );
prot = kalloc( 1, size );
memmove( ppos, &panim->pos[j][panim->startframe], size );
memmove( prot, &panim->rot[j][panim->startframe], size );
free( panim->pos[j] );
free( panim->rot[j] );
panim->pos[j] = ppos;
panim->rot[j] = prot;
}
}
void Option_Animation ( char *name, s_animation_t *panim )
{
int time1;
char cmd[1024];
int option;
strcpyn( panim->name, name );
sprintf (filename, "%s/%s.smd", cddir, panim->name);
time1 = FileTime (filename);
if (time1 == -1)
Error ("%s doesn't exist", filename);
printf ("grabbing %s\n", filename);
if ((input = fopen(filename, "r")) == 0) {
fprintf(stderr,"reader: could not open file '%s'\n", filename);
Error(0);
}
linecount = 0;
while (fgets( line, sizeof( line ), input ) != NULL) {
linecount++;
sscanf( line, "%s %d", cmd, &option );
if (strcmp( cmd, "version" ) == 0) {
if (option != 1) {
Error("bad version\n");
}
}
else if (strcmp( cmd, "nodes" ) == 0) {
panim->numbones = Grab_Nodes( panim->node );
}
else if (strcmp( cmd, "skeleton" ) == 0) {
Grab_Animation( panim );
Shift_Animation( panim );
}
else
{
printf("unknown studio command : %s\n", cmd );
while (fgets( line, sizeof( line ), input ) != NULL) {
linecount++;
if (strncmp(line,"end",3)==0)
break;
}
}
}
fclose( input );
}
int Option_Deform ( s_sequence_t *psequence )
{
return 0;
}
/*
===============
===============
*/
int Option_Motion ( s_sequence_t *psequence )
{
while (TokenAvailable())
{
GetToken (false);
psequence->motiontype |= lookupControl( token );
}
return 0;
}
int Option_Event ( s_sequence_t *psequence )
{
int event;
if (psequence->numevents + 1 >= MAXSTUDIOEVENTS)
{
printf("too many events\n");
exit(0);
}
GetToken (false);
event = atoi( token );
psequence->event[psequence->numevents].event = event;
GetToken( false );
psequence->event[psequence->numevents].frame = atoi( token );
psequence->numevents++;
// option token
if (TokenAvailable())
{
GetToken( false );
if (token[0] == '}') // opps, hit the end
return 1;
// found an option
strcpy( psequence->event[psequence->numevents-1].options, token );
}
return 0;
}
int Option_Fps ( s_sequence_t *psequence )
{
GetToken (false);
psequence->fps = atof( token );
return 0;
}
int Option_AddPivot ( s_sequence_t *psequence )
{
if (psequence->numpivots + 1 >= MAXSTUDIOPIVOTS)
{
printf("too many pivot points\n");
exit(0);
}
GetToken (false);
psequence->pivot[psequence->numpivots].index = atoi( token );
GetToken (false);
psequence->pivot[psequence->numpivots].start = atoi( token );
GetToken (false);
psequence->pivot[psequence->numpivots].end = atoi( token );
psequence->numpivots++;
return 0;
}
/*
=================
Option_Origin
=================
*/
void Cmd_Origin (void)
{
GetToken (false);
defaultadjust[0] = atof (token);
GetToken (false);
defaultadjust[1] = atof (token);
GetToken (false);
defaultadjust[2] = atof (token);
if (TokenAvailable()) {
GetToken (false);
defaultzrotation = (atof( token ) + 90) * (Q_PI / 180.0);
}
}
void Option_Origin (void)
{
GetToken (false);
adjust[0] = atof (token);
GetToken (false);
adjust[1] = atof (token);
GetToken (false);
adjust[2] = atof (token);
}
void Option_Rotate(void )
{
GetToken (false);
zrotation = (atof( token ) + 90) * (Q_PI / 180.0);
}
/*
=================
=================
*/
void Cmd_ScaleUp (void)
{
GetToken (false);
default_scale = scale_up = atof (token);
}
void Option_ScaleUp (void)
{
GetToken (false);
scale_up = atof (token);
}
/*
=================
=================
*/
int Cmd_SequenceGroup( )
{
GetToken (false);
strcpyn( sequencegroup[numseqgroups].label, token );
numseqgroups++;
return 0;
}
int Cmd_SequenceGroupSize( )
{
GetToken (false);
maxseqgroupsize = 1024 * atoi( token );
return 0;
}
int lookupActivity( char *szActivity )
{
int i;
for (i = 0; activity_map[i].name; i++)
{
if (stricmp( szActivity, activity_map[i].name ) == 0)
return activity_map[i].type;
}
// match ACT_#
if (strnicmp( szActivity, "ACT_", 4 ) == 0)
{
return atoi( &szActivity[4] );
}
return 0;
}
int Cmd_Sequence( )
{
int depth = 0;
char smdfilename[MAXSTUDIOGROUPS][1024];
int i;
int numblends = 0;
int start = 0;
int end = MAXSTUDIOANIMATIONS - 1;
if (!GetToken(false)) return 0;
strcpyn( sequence[numseq].name, token );
VectorCopy( defaultadjust, adjust );
scale_up = default_scale;
zrotation = defaultzrotation;
sequence[numseq].fps = 30.0;
sequence[numseq].seqgroup = numseqgroups - 1;
sequence[numseq].blendstart[0] = 0.0;
sequence[numseq].blendend[0] = 1.0;
while (1)
{
if (depth > 0)
{
if(!GetToken(true))
{
break;
}
}
else
{
if (!TokenAvailable())
{
break;
}
else
{
GetToken (false);
}
}
if (endofscript)
{
if (depth != 0)
{
printf("missing }\n" );
exit(1);
}
return 1;
}
if (stricmp("{", token ) == 0)
{
depth++;
}
else if (stricmp("}", token ) == 0)
{
depth--;
}
else if (stricmp("deform", token ) == 0)
{
Option_Deform( &sequence[numseq] );
}
else if (stricmp("event", token ) == 0)
{
depth -= Option_Event( &sequence[numseq] );
}
else if (stricmp("pivot", token ) == 0)
{
Option_AddPivot( &sequence[numseq] );
}
else if (stricmp("fps", token ) == 0)
{
Option_Fps( &sequence[numseq] );
}
else if (stricmp("origin", token ) == 0)
{
Option_Origin( );
}
else if (stricmp("rotate", token ) == 0)
{
Option_Rotate( );
}
else if (stricmp("scale", token ) == 0)
{
Option_ScaleUp( );
}
else if (strnicmp("loop", token, 4 ) == 0)
{
sequence[numseq].flags |= STUDIO_LOOPING;
}
else if (strnicmp("frame", token, 5 ) == 0)
{
GetToken( false );
start = atoi( token );
GetToken( false );
end = atoi( token );
}
else if (strnicmp("blend", token, 5 ) == 0)
{
GetToken( false );
sequence[numseq].blendtype[0] = lookupControl( token );
GetToken( false );
sequence[numseq].blendstart[0] = atof( token );
GetToken( false );
sequence[numseq].blendend[0] = atof( token );
}
else if (strnicmp("node", token, 4 ) == 0)
{
GetToken( false );
sequence[numseq].entrynode = sequence[numseq].exitnode = atoi( token );
}
else if (strnicmp("transition", token, 4 ) == 0)
{
GetToken( false );
sequence[numseq].entrynode = atoi( token );
GetToken( false );
sequence[numseq].exitnode = atoi( token );
}
else if (strnicmp("rtransition", token, 4 ) == 0)
{
GetToken( false );
sequence[numseq].entrynode = atoi( token );
GetToken( false );
sequence[numseq].exitnode = atoi( token );
sequence[numseq].nodeflags |= 1;
}
else if (lookupControl( token ) != -1)
{
sequence[numseq].motiontype |= lookupControl( token );
}
else if (stricmp("animation", token ) == 0)
{
GetToken(false);
strcpyn( smdfilename[numblends++], token );
}
else if ((i = lookupActivity( token )) != 0)
{
sequence[numseq].activity = i;
GetToken( false );
sequence[numseq].actweight = atoi( token );
}
else
{
strcpyn( smdfilename[numblends++], token );
}
if (depth < 0)
{
printf("missing {\n");
exit(1);
}
};
if (numblends == 0)
{
printf("no animations found\n");
exit(1);
}
for (i = 0; i < numblends; i++)
{
panimation[numani] = kalloc( 1, sizeof( s_animation_t ) );
sequence[numseq].panim[i] = panimation[numani];
sequence[numseq].panim[i]->startframe = start;
sequence[numseq].panim[i]->endframe = end;
sequence[numseq].panim[i]->flags = 0;
Option_Animation( smdfilename[i], panimation[numani] );
numani++;
}
sequence[numseq].numblends = numblends;
numseq++;
return 0;
}
/*
=================
=================
*/
int Cmd_Root (void)
{
if (GetToken (false))
{
strcpyn( pivotname[0], token );
return 0;
}
return 1;
}
int Cmd_Pivot (void)
{
if (GetToken (false))
{
int index = atoi(token);
if (GetToken(false))
{
strcpyn( pivotname[index], token );
return 0;
}
}
return 1;
}
int Cmd_Controller (void)
{
if (GetToken (false))
{
if (!strcmpi("mouth",token))
{
bonecontroller[numbonecontrollers].index = 4;
}
else
{
bonecontroller[numbonecontrollers].index = atoi(token);
}
if (GetToken(false))
{
strcpyn( bonecontroller[numbonecontrollers].name, token );
GetToken(false);
if ((bonecontroller[numbonecontrollers].type = lookupControl(token)) == -1)
{
printf("unknown bonecontroller type '%s'\n", token );
return 0;
}
GetToken(false);
bonecontroller[numbonecontrollers].start = atof( token );
GetToken(false);
bonecontroller[numbonecontrollers].end = atof( token );
if (bonecontroller[numbonecontrollers].type & (STUDIO_XR | STUDIO_YR | STUDIO_ZR))
{
if (((int)(bonecontroller[numbonecontrollers].start + 360) % 360) == ((int)(bonecontroller[numbonecontrollers].end + 360) % 360))
{
bonecontroller[numbonecontrollers].type |= STUDIO_RLOOP;
}
}
numbonecontrollers++;
}
}
return 1;
}
/*
=================
=================
*/
void Cmd_BBox (void)
{
GetToken (false);
bbox[0][0] = atof( token );
GetToken (false);
bbox[0][1] = atof( token );
GetToken (false);
bbox[0][2] = atof( token );
GetToken (false);
bbox[1][0] = atof( token );
GetToken (false);
bbox[1][1] = atof( token );
GetToken (false);
bbox[1][2] = atof( token );
}
/*
=================
=================
*/
void Cmd_CBox (void)
{
GetToken (false);
cbox[0][0] = atof( token );
GetToken (false);
cbox[0][1] = atof( token );
GetToken (false);
cbox[0][2] = atof( token );
GetToken (false);
cbox[1][0] = atof( token );
GetToken (false);
cbox[1][1] = atof( token );
GetToken (false);
cbox[1][2] = atof( token );
}
/*
=================
=================
*/
void Cmd_Mirror (void)
{
GetToken (false);
strcpyn( mirrored[nummirrored++], token );
}
/*
=================
=================
*/
void Cmd_Gamma (void)
{
GetToken (false);
gamma = atof( token );
}
/*
=================
=================
*/
int Cmd_TextureGroup( )
{
int i;
int depth = 0;
int index = 0;
int group = 0;
if (numtextures == 0)
Error( "texturegroups must follow model loading\n");
if (!GetToken(false)) return 0;
if (numskinref == 0)
numskinref = numtextures;
while (1)
{
if(!GetToken(true))
{
break;
}
if (endofscript)
{
if (depth != 0)
{
Error("missing }\n" );
}
return 1;
}
if (token[0] == '{')
{
depth++;
}
else if (token[0] == '}')
{
depth--;
if (depth == 0)
break;
group++;
index = 0;
}
else if (depth == 2)
{
i = lookup_texture( token );
texturegroup[numtexturegroups][group][index] = i;
if (group != 0)
texture[i].parent = texturegroup[numtexturegroups][0][index];
index++;
numtexturereps[numtexturegroups] = index;
numtexturelayers[numtexturegroups] = group + 1;
}
}
numtexturegroups++;
return 0;
}
/*
=================
=================
*/
int Cmd_Hitgroup( )
{
GetToken (false);
hitgroup[numhitgroups].group = atoi( token );
GetToken (false);
strcpyn( hitgroup[numhitgroups].name, token );
numhitgroups++;
return 0;
}
int Cmd_Hitbox( )
{
GetToken (false);
hitbox[numhitboxes].group = atoi( token );
GetToken (false);
strcpyn( hitbox[numhitboxes].name, token );
GetToken (false);
hitbox[numhitboxes].bmin[0] = atof( token );
GetToken (false);
hitbox[numhitboxes].bmin[1] = atof( token );
GetToken (false);
hitbox[numhitboxes].bmin[2] = atof( token );
GetToken (false);
hitbox[numhitboxes].bmax[0] = atof( token );
GetToken (false);
hitbox[numhitboxes].bmax[1] = atof( token );
GetToken (false);
hitbox[numhitboxes].bmax[2] = atof( token );
numhitboxes++;
return 0;
}
/*
=================
=================
*/
int Cmd_Attachment( )
{
// index
GetToken (false);
attachment[numattachments].index = atoi( token );
// bone name
GetToken (false);
strcpyn( attachment[numattachments].bonename, token );
// position
GetToken (false);
attachment[numattachments].org[0] = atof( token );
GetToken (false);
attachment[numattachments].org[1] = atof( token );
GetToken (false);
attachment[numattachments].org[2] = atof( token );
if (TokenAvailable())
GetToken (false);
if (TokenAvailable())
GetToken (false);
numattachments++;
return 0;
}
/*
=================
=================
*/
void Cmd_Renamebone( )
{
// from
GetToken (false);
strcpy( renamedbone[numrenamedbones].from, token );
// to
GetToken (false);
strcpy( renamedbone[numrenamedbones].to, token );
numrenamedbones++;
}
/*add transparent texture support to models
===================
Cmd_SetTextureRendermode
//paramaters:
// "texturename" "rendermode" renderamt
// acceptable strings for rendermode are:
// "alpha"
// "additive"
// "masked"
===================
*/
void Cmd_SetTextureRendermode( void )
{
int iTextureIndex;
if(!TokenAvailable())
{
printf("*********ERROR!!!*************");
printf("\nmissing texturename after $texrendermode\n");
exit(1);
}
GetToken(false);
iTextureIndex = lookup_texture(token);
if(!TokenAvailable())
{
printf("\n*********ERROR!!!*************\n");
printf("\nmissing rendermode at $texrendermode\n");
exit(1);
}
GetToken(false);
if(!strcmp(token, "additive"))
{
texture[iTextureIndex].flags |= STUDIO_NF_ADDITIVE;
return;
}
else if(!strcmp(token, "masked"))
{
texture[iTextureIndex].flags |= STUDIO_NF_MASKED;
return;
}
else
{
printf("\n*********ERROR!!!*************\n");
printf("\ninvalid rendermode at $texrendermode, choices are :\nadditive\nmasked\n");
exit(1);
}
}
/*
===============
ParseScript
===============
*/
void ParseScript (void)
{
while (1)
{
do
{ // look for a line starting with a $ command
GetToken (true);
if (endofscript)
return;
if (token[0] == '$')
break;
while (TokenAvailable())
GetToken (false);
} while (1);
if (!strcmp (token, "$modelname"))
{
Cmd_Modelname ();
}
else if (!strcmp (token, "$cd"))
{
if (cdset)
Error ("Two $cd in one model");
cdset = true;
GetToken (false);
strcpy (cdpartial, token);
strcpy (cddir, ExpandPath(token));
}
else if (!strcmp (token, "$cdtexture"))
{
while (TokenAvailable())
{
GetToken (false);
strcpy (cdtexture[cdtextureset], ExpandPath(token));
cdtextureset++;
}
}
else if (!strcmp (token, "$scale"))
{
Cmd_ScaleUp ();
}
else if (!strcmp (token, "$root"))
{
Cmd_Root ();
}
else if (!strcmp (token, "$pivot"))
{
Cmd_Pivot ();
}
else if (!strcmp (token, "$controller"))
{
Cmd_Controller ();
}
else if (!strcmp (token, "$body"))
{
Cmd_Body();
}
else if (!strcmp (token, "$bodygroup"))
{
Cmd_Bodygroup();
}
else if (!strcmp (token, "$sequence"))
{
Cmd_Sequence ();
}
else if (!strcmp (token, "$sequencegroup"))
{
Cmd_SequenceGroup ();
}
else if (!strcmp (token, "$sequencegroupsize"))
{
Cmd_SequenceGroupSize ();
}
else if (!strcmp (token, "$eyeposition"))
{
Cmd_Eyeposition ();
}
else if (!strcmp (token, "$origin"))
{
Cmd_Origin ();
}
else if (!strcmp (token, "$bbox"))
{
Cmd_BBox ();
}
else if (!strcmp (token, "$cbox"))
{
Cmd_CBox ();
}
else if (!strcmp (token, "$mirrorbone"))
{
Cmd_Mirror ();
}
else if (!strcmp (token, "$gamma"))
{
Cmd_Gamma ();
}
else if (!strcmp (token, "$flags"))
{
Cmd_Flags ();
}
else if (!strcmp (token, "$texturegroup"))
{
Cmd_TextureGroup ();
}
else if (!strcmp (token, "$hgroup"))
{
Cmd_Hitgroup ();
}
else if (!strcmp (token, "$hbox"))
{
Cmd_Hitbox ();
}
else if (!strcmp (token, "$attachment"))
{
Cmd_Attachment ();
}
else if (!strcmp (token, "$externaltextures"))
{
split_textures = 1;
}
else if (!strcmp (token, "$cliptotextures"))
{
clip_texcoords = 0;
}
else if (!strcmp (token, "$renamebone"))
{
Cmd_Renamebone ();
}
else if (!strcmp (token, "$texrendermode"))
{
Cmd_SetTextureRendermode();
}
else
{
Error ("bad command %s\n", token);
}
}
}
/*
==============
main
==============
*/
int main (int argc, char **argv)
{
int i;
char path[1024];
default_scale = 1.0;
defaultzrotation = Q_PI / 2;
numrep = 0;
tag_reversed = 0;
tag_normals = 0;
flip_triangles = 1;
maxseqgroupsize = 1024 * 1024;
normal_blend = cos( 2.0 * (Q_PI / 180.0));
gamma = 1.8;
if (argc == 1)
Error ("usage: studiomdl [-t texture] -r(tag reversed) -n(tag bad normals) -f(flip all triangles) [-a normal_blend_angle] -h(dump hboxes) -i(ignore warnings) -p(force power of 2 textures) [-g max_sequencegroup_size(K)] file.qc");
for (i = 1; i < argc - 1; i++) {
if (argv[i][0] == '-') {
switch( argv[i][1] ) {
case 't':
i++;
strcpy ( defaulttexture[numrep], argv[i]);
if (i < argc - 2 && argv[i + 1][0] != '-') {
i++;
strcpy ( sourcetexture[numrep], argv[i]);
printf ("Replaceing %s with %s\n", sourcetexture[numrep], defaulttexture[numrep] );
}
printf ("Using default texture: %s\n", defaulttexture);
numrep++;
break;
case 'r':
tag_reversed = 1;
break;
case 'n':
tag_normals = 1;
break;
case 'f':
flip_triangles = 0;
break;
case 'a':
i++;
normal_blend = cos( atof( argv[i] ) * (Q_PI / 180.0));
break;
case 'h':
dump_hboxes = 1;
break;
case 'g':
i++;
maxseqgroupsize = 1024 * atoi( argv[i] );
break;
case 'p':
case '2':
force_powerof2_textures = 1;
break;
case 'i':
ignore_warnings = 1;
break;
}
}
}
strcpy( sequencegroup[numseqgroups].label, "default" );
numseqgroups = 1;
//
// load the script
//
strcpy (path, argv[i]);
DefaultExtension (path, ".qc");
// SetQdirFromPath (path);
LoadScriptFile (path);
//
// parse it
//
ClearModel ();
strcpy (outname, argv[i]);
ParseScript ();
SetSkinValues ();
SimplifyModel ();
WriteFile ();
return 0;
}
Reference in a new issue Copy permalink