H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 22:27:05 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
sourcevr
source-engine/utils/motionmapper/motionmapper.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

3273 lines
85 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <math.h>
#include "filesystem_tools.h"
#include "cmdlib.h"
#include "scriplib.h"
#include "mathlib/mathlib.h"
#define EXTERN
#include "studio.h"
#include "motionmapper.h"
#include "tier1/strtools.h"
#include "tier0/icommandline.h"
#include "utldict.h"
#include <windows.h>
#include "UtlBuffer.h"
#include "utlsymbol.h"
bool g_quiet = false;
bool g_verbose = false;
char g_outfile[1024];
bool uselogfile = false;
char g_szFilename[1024];
FILE *g_fpInput;
char g_szLine[4096];
int g_iLinecount;
bool g_bZBrush = false;
bool g_bGaveMissingBoneWarning = false;
//-----------------------------------------------------------------------------
// Purpose:
// Input : depth -
// *fmt -
// ... -
//-----------------------------------------------------------------------------
void vprint( int depth, const char *fmt, ... )
{
char string[ 8192 ];
va_list va;
va_start( va, fmt );
V_vsprintf_safe( string, fmt, va );
va_end( va );
FILE *fp = NULL;
if ( uselogfile )
{
fp = fopen( "log.txt", "ab" );
}
while ( depth-- > 0 )
{
vprint( 0, " " );
OutputDebugString( " " );
if ( fp )
{
fprintf( fp, " " );
}
}
::printf( "%s", string );
OutputDebugString( string );
if ( fp )
{
char *p = string;
while ( *p )
{
if ( *p == '\n' )
{
fputc( '\r', fp );
}
fputc( *p, fp );
p++;
}
fclose( fp );
}
}
int k_memtotal;
void *kalloc( int num, int size )
{
// vprint( 0, "calloc( %d, %d )\n", num, size );
// vprint( 0, "%d ", num * size );
k_memtotal += num * size;
return calloc( num, size );
}
void kmemset( void *ptr, int value, int size )
{
// vprint( 0, "kmemset( %x, %d, %d )\n", ptr, value, size );
memset( ptr, value, size );
return;
}
static bool g_bFirstWarning = true;
void MdlWarning( const char *fmt, ... )
{
va_list args;
static char output[1024];
if (g_quiet)
{
if (g_bFirstWarning)
{
vprint( 0, "%s :\n", fullpath );
g_bFirstWarning = false;
}
vprint( 0, "\t");
}
vprint( 0, "WARNING: ");
va_start( args, fmt );
vprint( 0, fmt, args );
}
void MdlError( char const *fmt, ... )
{
va_list args;
if (g_quiet)
{
if (g_bFirstWarning)
{
vprint( 0, "%s :\n", fullpath );
g_bFirstWarning = false;
}
vprint( 0, "\t");
}
vprint( 0, "ERROR: ");
va_start( args, fmt );
vprint( 0, fmt, args );
exit( -1 );
}
int OpenGlobalFile( char *src )
{
int time1;
char filename[1024];
// local copy of string
strcpy( filename, ExpandPath( src ) );
// Ummm, path sanity checking
int pathLength;
int numBasePaths = CmdLib_GetNumBasePaths();
// This is kinda gross. . . doing the same work in cmdlib on SafeOpenRead.
if( CmdLib_HasBasePath( filename, pathLength ) )
{
char tmp[1024];
int i;
for( i = 0; i < numBasePaths; i++ )
{
strcpy( tmp, CmdLib_GetBasePath( i ) );
strcat( tmp, filename + pathLength );
time1 = FileTime( tmp );
if( time1 != -1 )
{
if ((g_fpInput = fopen(tmp, "r")) == 0)
{
MdlWarning( "reader: could not open file '%s'\n", src );
return 0;
}
else
{
return 1;
}
}
}
return 0;
}
else
{
time1 = FileTime (filename);
if (time1 == -1)
return 0;
// Whoohooo, FOPEN!
if ((g_fpInput = fopen(filename, "r")) == 0)
{
MdlWarning( "reader: could not open file '%s'\n", src );
return 0;
}
return 1;
}
}
bool IsEnd( char const* pLine )
{
if (strncmp( "end", pLine, 3 ) != 0)
return false;
return (pLine[3] == '\0') || (pLine[3] == '\n');
}
//Wrong name for the use of it.
void scale_vertex( Vector &org )
{
org[0] = org[0] * g_currentscale;
org[1] = org[1] * g_currentscale;
org[2] = org[2] * g_currentscale;
}
void clip_rotations( RadianEuler& rot )
{
int j;
// clip everything to : -M_PI <= x < M_PI
for (j = 0; j < 3; j++) {
while (rot[j] >= M_PI)
rot[j] -= M_PI*2;
while (rot[j] < -M_PI)
rot[j] += M_PI*2;
}
}
void clip_rotations( Vector& rot )
{
int j;
// clip everything to : -180 <= x < 180
for (j = 0; j < 3; j++) {
while (rot[j] >= 180)
rot[j] -= 180*2;
while (rot[j] < -180)
rot[j] += 180*2;
}
}
void Build_Reference( s_source_t *psource)
{
int i, parent;
Vector angle;
for (i = 0; i < psource->numbones; i++)
{
matrix3x4_t m;
AngleMatrix( psource->rawanim[0][i].rot, m );
m[0][3] = psource->rawanim[0][i].pos[0];
m[1][3] = psource->rawanim[0][i].pos[1];
m[2][3] = psource->rawanim[0][i].pos[2];
parent = psource->localBone[i].parent;
if (parent == -1)
{
// scale the done pos.
// calc rotational matrices
MatrixCopy( m, psource->boneToPose[i] );
}
else
{
// calc compound rotational matrices
// FIXME : Hey, it's orthogical so inv(A) == transpose(A)
ConcatTransforms( psource->boneToPose[parent], m, psource->boneToPose[i] );
}
// vprint( 0, "%3d %f %f %f\n", i, psource->bonefixup[i].worldorg[0], psource->bonefixup[i].worldorg[1], psource->bonefixup[i].worldorg[2] );
/*
AngleMatrix( angle, m );
vprint( 0, "%8.4f %8.4f %8.4f\n", m[0][0], m[1][0], m[2][0] );
vprint( 0, "%8.4f %8.4f %8.4f\n", m[0][1], m[1][1], m[2][1] );
vprint( 0, "%8.4f %8.4f %8.4f\n", m[0][2], m[1][2], m[2][2] );
*/
}
}
int Grab_Nodes( s_node_t *pnodes )
{
//
// s_node_t structure: index is index!!
//
int index;
char name[1024];
int parent;
int numbones = 0;
// Init parent to none
for (index = 0; index < MAXSTUDIOSRCBONES; index++)
{
pnodes[index].parent = -1;
}
// March through nodes lines
while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
g_iLinecount++;
// get tokens
if (sscanf( g_szLine, "%d \"%[^\"]\" %d", &index, name, &parent ) == 3)
{
// check for duplicated bones
/*
if (strlen(pnodes[index].name) != 0)
{
MdlError( "bone \"%s\" exists more than once\n", name );
}
*/
// copy name to struct array
V_strcpy_safe( pnodes[index].name, name );
// set parent into struct array
pnodes[index].parent = parent;
// increment numbones
if (index > numbones)
{
numbones = index;
}
}
else
{
return numbones + 1;
}
}
MdlError( "Unexpected EOF at line %d\n", g_iLinecount );
return 0;
}
void Grab_Vertexanimation( s_source_t *psource )
{
char cmd[1024];
int index;
Vector pos;
Vector normal;
int t = -1;
int count = 0;
static s_vertanim_t tmpvanim[MAXSTUDIOVERTS*4];
while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
g_iLinecount++;
if (sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &normal[0], &normal[1], &normal[2] ) == 7)
{
if (psource->startframe < 0)
{
MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
}
if (t < 0)
{
MdlError( "VTA Frame Sync (%d) : %s", g_iLinecount, g_szLine );
}
tmpvanim[count].vertex = index;
VectorCopy( pos, tmpvanim[count].pos );
VectorCopy( normal, tmpvanim[count].normal );
count++;
if (index >= psource->numvertices)
psource->numvertices = index + 1;
}
else
{
// flush data
if (count)
{
psource->numvanims[t] = count;
psource->vanim[t] = (s_vertanim_t *)kalloc( count, sizeof( s_vertanim_t ) );
memcpy( psource->vanim[t], tmpvanim, count * sizeof( s_vertanim_t ) );
}
else if (t > 0)
{
psource->numvanims[t] = 0;
}
// next command
if (sscanf( g_szLine, "%1023s %d", cmd, &index ))
{
if (strcmp( cmd, "time" ) == 0)
{
t = index;
count = 0;
if (t < psource->startframe)
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
if (t > psource->endframe)
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
t -= psource->startframe;
}
else if (strcmp( cmd, "end") == 0)
{
psource->numframes = psource->endframe - psource->startframe + 1;
return;
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
}
MdlError( "unexpected EOF: %s\n", psource->filename );
}
void Grab_Animation( s_source_t *psource )
{
Vector pos;
RadianEuler rot;
char cmd[1024];
int index;
int t = -99999999;
int size;
// Init startframe
psource->startframe = -1;
// size per frame
size = psource->numbones * sizeof( s_bone_t );
// march through animation
while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
// linecount
g_iLinecount++;
// split if big enoough
if (sscanf( g_szLine, "%d %f %f %f %f %f %f", &index, &pos[0], &pos[1], &pos[2], &rot[0], &rot[1], &rot[2] ) == 7)
{
// startframe is sanity check for having determined time
if (psource->startframe < 0)
{
MdlError( "Missing frame start(%d) : %s", g_iLinecount, g_szLine );
}
// scale if pertinent
scale_vertex( pos );
VectorCopy( pos, psource->rawanim[t][index].pos );
VectorCopy( rot, psource->rawanim[t][index].rot );
clip_rotations( rot ); // !!!
}
else if (sscanf( g_szLine, "%1023s %d", cmd, &index ))
{
// get time
if (strcmp( cmd, "time" ) == 0)
{
// again time IS an index
t = index;
if (psource->startframe == -1)
{
psource->startframe = t;
}
// sanity check time (little funny logic here, see previous IF)
if (t < psource->startframe)
{
MdlError( "Frame MdlError(%d) : %s", g_iLinecount, g_szLine );
}
// bump up endframe?
if (t > psource->endframe)
{
psource->endframe = t;
}
// make t into pure index
t -= psource->startframe;
// check for memory allocation
if (psource->rawanim[t] == NULL)
{
// Allocate 1 frame of full bonecount
psource->rawanim[t] = (s_bone_t *)kalloc( 1, size );
// duplicate previous frames keys?? preventative sanity?
if (t > 0 && psource->rawanim[t-1])
{
for (int j = 0; j < psource->numbones; j++)
{
VectorCopy( psource->rawanim[t-1][j].pos, psource->rawanim[t][j].pos );
VectorCopy( psource->rawanim[t-1][j].rot, psource->rawanim[t][j].rot );
}
}
}
else
{
// MdlError( "%s has duplicated frame %d\n", psource->filename, t );
}
}
else if (strcmp( cmd, "end") == 0)
{
psource->numframes = psource->endframe - psource->startframe + 1;
for (t = 0; t < psource->numframes; t++)
{
if (psource->rawanim[t] == NULL)
{
MdlError( "%s is missing frame %d\n", psource->filename, t + psource->startframe );
}
}
Build_Reference( psource );
return;
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
else
{
MdlError( "MdlError(%d) : %s", g_iLinecount, g_szLine );
}
}
MdlError( "unexpected EOF: %s\n", psource->filename );
}
int lookup_index( s_source_t *psource, int material, Vector& vertex, Vector& normal, Vector2D texcoord )
{
int i;
for (i = 0; i < numvlist; i++)
{
if (v_listdata[i].m == material
&& DotProduct( g_normal[i], normal ) > normal_blend
&& VectorCompare( g_vertex[i], vertex )
&& g_texcoord[i][0] == texcoord[0]
&& g_texcoord[i][1] == texcoord[1])
{
v_listdata[i].lastref = numvlist;
return i;
}
}
if (i >= MAXSTUDIOVERTS) {
MdlError( "too many indices in source: \"%s\"\n", psource->filename);
}
VectorCopy( vertex, g_vertex[i] );
VectorCopy( normal, g_normal[i] );
Vector2Copy( texcoord, g_texcoord[i] );
v_listdata[i].v = i;
v_listdata[i].m = material;
v_listdata[i].n = i;
v_listdata[i].t = i;
v_listdata[i].firstref = numvlist;
v_listdata[i].lastref = numvlist;
numvlist = i + 1;
return i;
}
void ParseFaceData( s_source_t *psource, int material, s_face_t *pFace )
{
int index[3];
int i, j;
Vector p;
Vector normal;
Vector2D t;
int iCount, bones[MAXSTUDIOSRCBONES];
float weights[MAXSTUDIOSRCBONES];
int bone;
for (j = 0; j < 3; j++)
{
memset( g_szLine, 0, sizeof( g_szLine ) );
if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) == NULL)
{
MdlError("%s: error on g_szLine %d: %s", g_szFilename, g_iLinecount, g_szLine );
}
iCount = 0;
g_iLinecount++;
i = sscanf( g_szLine, "%d %f %f %f %f %f %f %f %f %d %d %f %d %f %d %f %d %f",
&bone,
&p[0], &p[1], &p[2],
&normal[0], &normal[1], &normal[2],
&t[0], &t[1],
&iCount,
&bones[0], &weights[0], &bones[1], &weights[1], &bones[2], &weights[2], &bones[3], &weights[3] );
if (i < 9)
continue;
if (bone < 0 || bone >= psource->numbones)
{
MdlError("bogus bone index\n%d %s :\n%s", g_iLinecount, g_szFilename, g_szLine );
}
//Scale face pos
scale_vertex( p );
// continue parsing more bones.
// FIXME: don't we have a built in parser that'll do this?
if (iCount > 4)
{
int k;
int ctr = 0;
char *token;
for (k = 0; k < 18; k++)
{
while (g_szLine[ctr] == ' ')
{
ctr++;
}
token = strtok( &g_szLine[ctr], " " );
ctr += strlen( token ) + 1;
}
for (k = 4; k < iCount && k < MAXSTUDIOSRCBONES; k++)
{
while (g_szLine[ctr] == ' ')
{
ctr++;
}
token = strtok( &g_szLine[ctr], " " );
ctr += strlen( token ) + 1;
bones[k] = atoi(token);
token = strtok( &g_szLine[ctr], " " );
ctr += strlen( token ) + 1;
weights[k] = atof(token);
}
// vprint( 0, "%d ", iCount );
//vprint( 0, "\n");
//exit(1);
}
// adjust_vertex( p );
// scale_vertex( p );
// move vertex position to object space.
// VectorSubtract( p, psource->bonefixup[bone].worldorg, tmp );
// VectorTransform(tmp, psource->bonefixup[bone].im, p );
// move normal to object space.
// VectorCopy( normal, tmp );
// VectorTransform(tmp, psource->bonefixup[bone].im, normal );
// VectorNormalize( normal );
// invert v
t[1] = 1.0 - t[1];
index[j] = lookup_index( psource, material, p, normal, t );
if (i == 9 || iCount == 0)
{
g_bone[index[j]].numbones = 1;
g_bone[index[j]].bone[0] = bone;
g_bone[index[j]].weight[0] = 1.0;
}
else
{
iCount = SortAndBalanceBones( iCount, MAXSTUDIOBONEWEIGHTS, bones, weights );
g_bone[index[j]].numbones = iCount;
for (i = 0; i < iCount; i++)
{
g_bone[index[j]].bone[i] = bones[i];
g_bone[index[j]].weight[i] = weights[i];
}
}
}
// pFace->material = material; // BUG
pFace->a = index[0];
pFace->b = index[1];
pFace->c = index[2];
Assert( ((pFace->a & 0xF0000000) == 0) && ((pFace->b & 0xF0000000) == 0) &&
((pFace->c & 0xF0000000) == 0) );
if (flip_triangles)
{
j = pFace->b; pFace->b = pFace->c; pFace->c = j;
}
}
int use_texture_as_material( int textureindex )
{
if (g_texture[textureindex].material == -1)
{
// vprint( 0, "%d %d %s\n", textureindex, g_nummaterials, g_texture[textureindex].name );
g_material[g_nummaterials] = textureindex;
g_texture[textureindex].material = g_nummaterials++;
}
return g_texture[textureindex].material;
}
int material_to_texture( int material )
{
int i;
for (i = 0; i < g_numtextures; i++)
{
if (g_texture[i].material == material)
{
return i;
}
}
return -1;
}
int lookup_texture( char *texturename, int maxlen )
{
int i;
Q_StripExtension( texturename, texturename, maxlen );
for (i = 0; i < g_numtextures; i++)
{
if (stricmp( g_texture[i].name, texturename ) == 0)
{
return i;
}
}
if (i >= MAXSTUDIOSKINS)
MdlError("Too many materials used, max %d\n", ( int )MAXSTUDIOSKINS );
// vprint( 0, "texture %d = %s\n", i, texturename );
V_strcpy_safe( g_texture[i].name, texturename );
g_texture[i].material = -1;
/*
if (stristr( texturename, "chrome" ) != NULL) {
texture[i].flags = STUDIO_NF_FLATSHADE | STUDIO_NF_CHROME;
}
else {
texture[i].flags = 0;
}
*/
g_numtextures++;
return i;
}
int SortAndBalanceBones( int iCount, int iMaxCount, int bones[], float weights[] )
{
int i;
// collapse duplicate bone weights
for (i = 0; i < iCount-1; i++)
{
int j;
for (j = i + 1; j < iCount; j++)
{
if (bones[i] == bones[j])
{
weights[i] += weights[j];
weights[j] = 0.0;
}
}
}
// do sleazy bubble sort
int bShouldSort;
do {
bShouldSort = false;
for (i = 0; i < iCount-1; i++)
{
if (weights[i+1] > weights[i])
{
int j = bones[i+1]; bones[i+1] = bones[i]; bones[i] = j;
float w = weights[i+1]; weights[i+1] = weights[i]; weights[i] = w;
bShouldSort = true;
}
}
} while (bShouldSort);
// throw away all weights less than 1/20th
while (iCount > 1 && weights[iCount-1] < 0.05)
{
iCount--;
}
// clip to the top iMaxCount bones
if (iCount > iMaxCount)
{
iCount = iMaxCount;
}
float t = 0;
for (i = 0; i < iCount; i++)
{
t += weights[i];
}
if (t <= 0.0)
{
// missing weights?, go ahead and evenly share?
// FIXME: shouldn't this error out?
t = 1.0 / iCount;
for (i = 0; i < iCount; i++)
{
weights[i] = t;
}
}
else
{
// scale to sum to 1.0
t = 1.0 / t;
for (i = 0; i < iCount; i++)
{
weights[i] = weights[i] * t;
}
}
return iCount;
}
int vlistCompare( const void *elem1, const void *elem2 )
{
v_unify_t *u1 = &v_listdata[*(int *)elem1];
v_unify_t *u2 = &v_listdata[*(int *)elem2];
// sort by material
if (u1->m < u2->m)
return -1;
if (u1->m > u2->m)
return 1;
// sort by last used
if (u1->lastref < u2->lastref)
return -1;
if (u1->lastref > u2->lastref)
return 1;
return 0;
}
int faceCompare( const void *elem1, const void *elem2 )
{
int i1 = *(int *)elem1;
int i2 = *(int *)elem2;
// sort by material
if (g_face[i1].material < g_face[i2].material)
return -1;
if (g_face[i1].material > g_face[i2].material)
return 1;
// sort by original usage
if (i1 < i2)
return -1;
if (i1 > i2)
return 1;
return 0;
}
#define SMALL_FLOAT 1e-12
// NOTE: This routine was taken (and modified) from NVidia's BlinnReflection demo
// Creates basis vectors, based on a vertex and index list.
// See the NVidia white paper 'GDC2K PerPixel Lighting' for a description
// of how this computation works
static void CalcTriangleTangentSpace( s_source_t *pSrc, int v1, int v2, int v3,
Vector &sVect, Vector &tVect )
{
/*
static bool firstTime = true;
static FILE *fp = NULL;
if( firstTime )
{
firstTime = false;
fp = fopen( "crap.out", "w" );
}
*/
/* Compute the partial derivatives of X, Y, and Z with respect to S and T. */
Vector2D t0( pSrc->texcoord[v1][0], pSrc->texcoord[v1][1] );
Vector2D t1( pSrc->texcoord[v2][0], pSrc->texcoord[v2][1] );
Vector2D t2( pSrc->texcoord[v3][0], pSrc->texcoord[v3][1] );
Vector p0( pSrc->vertex[v1][0], pSrc->vertex[v1][1], pSrc->vertex[v1][2] );
Vector p1( pSrc->vertex[v2][0], pSrc->vertex[v2][1], pSrc->vertex[v2][2] );
Vector p2( pSrc->vertex[v3][0], pSrc->vertex[v3][1], pSrc->vertex[v3][2] );
sVect.Init( 0.0f, 0.0f, 0.0f );
tVect.Init( 0.0f, 0.0f, 0.0f );
// x, s, t
Vector edge01 = Vector( p1.x - p0.x, t1.x - t0.x, t1.y - t0.y );
Vector edge02 = Vector( p2.x - p0.x, t2.x - t0.x, t2.y - t0.y );
Vector cross;
CrossProduct( edge01, edge02, cross );
if( fabs( cross.x ) > SMALL_FLOAT )
{
sVect.x += -cross.y / cross.x;
tVect.x += -cross.z / cross.x;
}
// y, s, t
edge01 = Vector( p1.y - p0.y, t1.x - t0.x, t1.y - t0.y );
edge02 = Vector( p2.y - p0.y, t2.x - t0.x, t2.y - t0.y );
CrossProduct( edge01, edge02, cross );
if( fabs( cross.x ) > SMALL_FLOAT )
{
sVect.y += -cross.y / cross.x;
tVect.y += -cross.z / cross.x;
}
// z, s, t
edge01 = Vector( p1.z - p0.z, t1.x - t0.x, t1.y - t0.y );
edge02 = Vector( p2.z - p0.z, t2.x - t0.x, t2.y - t0.y );
CrossProduct( edge01, edge02, cross );
if( fabs( cross.x ) > SMALL_FLOAT )
{
sVect.z += -cross.y / cross.x;
tVect.z += -cross.z / cross.x;
}
// Normalize sVect and tVect
VectorNormalize( sVect );
VectorNormalize( tVect );
/*
// Calculate flat normal
Vector flatNormal;
edge01 = p1 - p0;
edge02 = p2 - p0;
CrossProduct( edge02, edge01, flatNormal );
VectorNormalize( flatNormal );
// Get the average position
Vector avgPos = ( p0 + p1 + p2 ) / 3.0f;
// Draw the svect
Vector endS = avgPos + sVect * .2f;
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 1.0 0.0 0.0\n", endS[0], endS[1], endS[2] );
fvprint( 0, fp, "%f %f %f 1.0 0.0 0.0\n", avgPos[0], avgPos[1], avgPos[2] );
// Draw the tvect
Vector endT = avgPos + tVect * .2f;
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 0.0 1.0 0.0\n", endT[0], endT[1], endT[2] );
fvprint( 0, fp, "%f %f %f 0.0 1.0 0.0\n", avgPos[0], avgPos[1], avgPos[2] );
// Draw the normal
Vector endN = avgPos + flatNormal * .2f;
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 0.0 0.0 1.0\n", endN[0], endN[1], endN[2] );
fvprint( 0, fp, "%f %f %f 0.0 0.0 1.0\n", avgPos[0], avgPos[1], avgPos[2] );
// Draw the wireframe of the triangle in white.
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p0[0], p0[1], p0[2] );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p1[0], p1[1], p1[2] );
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p1[0], p1[1], p1[2] );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p2[0], p2[1], p2[2] );
fvprint( 0, fp, "2\n" );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p2[0], p2[1], p2[2] );
fvprint( 0, fp, "%f %f %f 1.0 1.0 1.0\n", p0[0], p0[1], p0[2] );
// Draw a slightly shrunken version of the geometry to hide surfaces
Vector tmp0 = p0 - flatNormal * .1f;
Vector tmp1 = p1 - flatNormal * .1f;
Vector tmp2 = p2 - flatNormal * .1f;
fvprint( 0, fp, "3\n" );
fvprint( 0, fp, "%f %f %f 0.1 0.1 0.1\n", tmp0[0], tmp0[1], tmp0[2] );
fvprint( 0, fp, "%f %f %f 0.1 0.1 0.1\n", tmp1[0], tmp1[1], tmp1[2] );
fvprint( 0, fp, "%f %f %f 0.1 0.1 0.1\n", tmp2[0], tmp2[1], tmp2[2] );
fflush( fp );
*/
}
typedef CUtlVector<int> CIntVector;
void CalcModelTangentSpaces( s_source_t *pSrc )
{
// Build a map from vertex to a list of triangles that share the vert.
int meshID;
for( meshID = 0; meshID < pSrc->nummeshes; meshID++ )
{
s_mesh_t *pMesh = &pSrc->mesh[pSrc->meshindex[meshID]];
CUtlVector<CIntVector> vertToTriMap;
vertToTriMap.AddMultipleToTail( pMesh->numvertices );
int triID;
for( triID = 0; triID < pMesh->numfaces; triID++ )
{
s_face_t *pFace = &pSrc->face[triID + pMesh->faceoffset];
vertToTriMap[pFace->a].AddToTail( triID );
vertToTriMap[pFace->b].AddToTail( triID );
vertToTriMap[pFace->c].AddToTail( triID );
}
// Calculate the tangent space for each triangle.
CUtlVector<Vector> triSVect;
CUtlVector<Vector> triTVect;
triSVect.AddMultipleToTail( pMesh->numfaces );
triTVect.AddMultipleToTail( pMesh->numfaces );
for( triID = 0; triID < pMesh->numfaces; triID++ )
{
s_face_t *pFace = &pSrc->face[triID + pMesh->faceoffset];
CalcTriangleTangentSpace( pSrc,
pMesh->vertexoffset + pFace->a,
pMesh->vertexoffset + pFace->b,
pMesh->vertexoffset + pFace->c,
triSVect[triID], triTVect[triID] );
}
// calculate an average tangent space for each vertex.
int vertID;
for( vertID = 0; vertID < pMesh->numvertices; vertID++ )
{
const Vector &normal = pSrc->normal[vertID+pMesh->vertexoffset];
Vector4D &finalSVect = pSrc->tangentS[vertID+pMesh->vertexoffset];
Vector sVect, tVect;
sVect.Init( 0.0f, 0.0f, 0.0f );
tVect.Init( 0.0f, 0.0f, 0.0f );
for( triID = 0; triID < vertToTriMap[vertID].Size(); triID++ )
{
sVect += triSVect[vertToTriMap[vertID][triID]];
tVect += triTVect[vertToTriMap[vertID][triID]];
}
// In the case of zbrush, everything needs to be treated as smooth.
if( g_bZBrush )
{
int vertID2;
Vector vertPos1( pSrc->vertex[vertID][0], pSrc->vertex[vertID][1], pSrc->vertex[vertID][2] );
for( vertID2 = 0; vertID2 < pMesh->numvertices; vertID2++ )
{
if( vertID2 == vertID )
{
continue;
}
Vector vertPos2( pSrc->vertex[vertID2][0], pSrc->vertex[vertID2][1], pSrc->vertex[vertID2][2] );
if( vertPos1 == vertPos2 )
{
int triID2;
for( triID2 = 0; triID2 < vertToTriMap[vertID2].Size(); triID2++ )
{
sVect += triSVect[vertToTriMap[vertID2][triID2]];
tVect += triTVect[vertToTriMap[vertID2][triID2]];
}
}
}
}
// make an orthonormal system.
// need to check if we are left or right handed.
Vector tmpVect;
CrossProduct( sVect, tVect, tmpVect );
bool leftHanded = DotProduct( tmpVect, normal ) < 0.0f;
if( !leftHanded )
{
CrossProduct( normal, sVect, tVect );
CrossProduct( tVect, normal, sVect );
VectorNormalize( sVect );
VectorNormalize( tVect );
finalSVect[0] = sVect[0];
finalSVect[1] = sVect[1];
finalSVect[2] = sVect[2];
finalSVect[3] = 1.0f;
}
else
{
CrossProduct( sVect, normal, tVect );
CrossProduct( normal, tVect, sVect );
VectorNormalize( sVect );
VectorNormalize( tVect );
finalSVect[0] = sVect[0];
finalSVect[1] = sVect[1];
finalSVect[2] = sVect[2];
finalSVect[3] = -1.0f;
}
}
}
}
void BuildIndividualMeshes( s_source_t *psource )
{
int i, j, k;
// sort new vertices by materials, last used
static int v_listsort[MAXSTUDIOVERTS]; // map desired order to vlist entry
static int v_ilistsort[MAXSTUDIOVERTS]; // map vlist entry to desired order
for (i = 0; i < numvlist; i++)
{
v_listsort[i] = i;
}
qsort( v_listsort, numvlist, sizeof( int ), vlistCompare );
for (i = 0; i < numvlist; i++)
{
v_ilistsort[v_listsort[i]] = i;
}
// allocate memory
psource->numvertices = numvlist;
psource->localBoneweight = (s_boneweight_t *)kalloc( psource->numvertices, sizeof( s_boneweight_t ) );
psource->globalBoneweight = NULL;
psource->vertexInfo = (s_vertexinfo_t *)kalloc( psource->numvertices, sizeof( s_vertexinfo_t ) );
psource->vertex = new Vector[psource->numvertices];
psource->normal = new Vector[psource->numvertices];
psource->tangentS = new Vector4D[psource->numvertices];
psource->texcoord = (Vector2D *)kalloc( psource->numvertices, sizeof( Vector2D ) );
// create arrays of unique vertexes, normals, texcoords.
for (i = 0; i < psource->numvertices; i++)
{
j = v_listsort[i];
VectorCopy( g_vertex[v_listdata[j].v], psource->vertex[i] );
VectorCopy( g_normal[v_listdata[j].n], psource->normal[i] );
Vector2Copy( g_texcoord[v_listdata[j].t], psource->texcoord[i] );
psource->localBoneweight[i].numbones = g_bone[v_listdata[j].v].numbones;
int k;
for( k = 0; k < MAXSTUDIOBONEWEIGHTS; k++ )
{
psource->localBoneweight[i].bone[k] = g_bone[v_listdata[j].v].bone[k];
psource->localBoneweight[i].weight[k] = g_bone[v_listdata[j].v].weight[k];
}
// store a bunch of other info
psource->vertexInfo[i].material = v_listdata[j].m;
psource->vertexInfo[i].firstref = v_listdata[j].firstref;
psource->vertexInfo[i].lastref = v_listdata[j].lastref;
// vprint( 0, "%4d : %2d : %6.2f %6.2f %6.2f\n", i, psource->boneweight[i].bone[0], psource->vertex[i][0], psource->vertex[i][1], psource->vertex[i][2] );
}
// sort faces by materials, last used.
static int facesort[MAXSTUDIOTRIANGLES]; // map desired order to src_face entry
static int ifacesort[MAXSTUDIOTRIANGLES]; // map src_face entry to desired order
for (i = 0; i < g_numfaces; i++)
{
facesort[i] = i;
}
qsort( facesort, g_numfaces, sizeof( int ), faceCompare );
for (i = 0; i < g_numfaces; i++)
{
ifacesort[facesort[i]] = i;
}
psource->numfaces = g_numfaces;
// find first occurance for each material
for (k = 0; k < MAXSTUDIOSKINS; k++)
{
psource->mesh[k].numvertices = 0;
psource->mesh[k].vertexoffset = psource->numvertices;
psource->mesh[k].numfaces = 0;
psource->mesh[k].faceoffset = g_numfaces;
}
// find first and count of indices per material
for (i = 0; i < psource->numvertices; i++)
{
k = psource->vertexInfo[i].material;
psource->mesh[k].numvertices++;
if (psource->mesh[k].vertexoffset > i)
psource->mesh[k].vertexoffset = i;
}
// find first and count of faces per material
for (i = 0; i < psource->numfaces; i++)
{
k = g_face[facesort[i]].material;
psource->mesh[k].numfaces++;
if (psource->mesh[k].faceoffset > i)
psource->mesh[k].faceoffset = i;
}
/*
for (k = 0; k < MAXSTUDIOSKINS; k++)
{
vprint( 0, "%d : %d:%d %d:%d\n", k, psource->mesh[k].numvertices, psource->mesh[k].vertexoffset, psource->mesh[k].numfaces, psource->mesh[k].faceoffset );
}
*/
// create remapped faces
psource->face = (s_face_t *)kalloc( psource->numfaces, sizeof( s_face_t ));
for (k = 0; k < MAXSTUDIOSKINS; k++)
{
if (psource->mesh[k].numfaces)
{
psource->meshindex[psource->nummeshes] = k;
for (i = psource->mesh[k].faceoffset; i < psource->mesh[k].numfaces + psource->mesh[k].faceoffset; i++)
{
j = facesort[i];
psource->face[i].a = v_ilistsort[g_src_uface[j].a] - psource->mesh[k].vertexoffset;
psource->face[i].b = v_ilistsort[g_src_uface[j].b] - psource->mesh[k].vertexoffset;
psource->face[i].c = v_ilistsort[g_src_uface[j].c] - psource->mesh[k].vertexoffset;
Assert( ((psource->face[i].a & 0xF0000000) == 0) && ((psource->face[i].b & 0xF0000000) == 0) &&
((psource->face[i].c & 0xF0000000) == 0) );
// vprint( 0, "%3d : %4d %4d %4d\n", i, psource->face[i].a, psource->face[i].b, psource->face[i].c );
}
psource->nummeshes++;
}
}
CalcModelTangentSpaces( psource );
}
void Grab_Triangles( s_source_t *psource )
{
int i;
Vector vmin, vmax;
vmin[0] = vmin[1] = vmin[2] = 99999;
vmax[0] = vmax[1] = vmax[2] = -99999;
g_numfaces = 0;
numvlist = 0;
//
// load the base triangles
//
int texture;
int material;
char texturename[64];
while (1)
{
if (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) == NULL)
break;
g_iLinecount++;
// check for end
if (IsEnd( g_szLine ))
break;
// Look for extra junk that we may want to avoid...
int nLineLength = strlen( g_szLine );
if (nLineLength >= 64)
{
MdlWarning("Unexpected data at line %d, (need a texture name) ignoring...\n", g_iLinecount );
continue;
}
// strip off trailing smag
V_strcpy_safe( texturename, g_szLine );
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 source problem, skip them
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
g_iLinecount += 3;
continue;
}
if (stricmp( texturename, "null.bmp") == 0 || stricmp( texturename, "null.tga") == 0)
{
// skip all faces with the null texture on them.
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
fgets( g_szLine, sizeof( g_szLine ), g_fpInput );
g_iLinecount += 3;
continue;
}
texture = lookup_texture( texturename, sizeof( texturename ) );
psource->texmap[texture] = texture; // hack, make it 1:1
material = use_texture_as_material( texture );
s_face_t f;
ParseFaceData( psource, material, &f );
g_src_uface[g_numfaces] = f;
g_face[g_numfaces].material = material;
g_numfaces++;
}
BuildIndividualMeshes( psource );
}
//--------------------------------------------------------------------
// Load a SMD file
//--------------------------------------------------------------------
int Load_SMD ( s_source_t *psource )
{
char cmd[1024];
int option;
// Open file
if (!OpenGlobalFile( psource->filename ))
return 0;
// verbose
if( !g_quiet )
{
printf ("SMD MODEL %s\n", psource->filename);
}
//March through lines
g_iLinecount = 0;
while (fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
g_iLinecount++;
int numRead = sscanf( g_szLine, "%s %d", cmd, &option );
// Blank line
if ((numRead == EOF) || (numRead == 0))
continue;
if (strcmp( cmd, "version" ) == 0)
{
if (option != 1)
{
MdlError("bad version\n");
}
}
// Get hierarchy?
else if (strcmp( cmd, "nodes" ) == 0)
{
psource->numbones = Grab_Nodes( psource->localBone );
}
// Get animation??
else if (strcmp( cmd, "skeleton" ) == 0)
{
Grab_Animation( psource );
}
// Geo?
else if (strcmp( cmd, "triangles" ) == 0)
{
Grab_Triangles( psource );
}
// Geo animation
else if (strcmp( cmd, "vertexanimation" ) == 0)
{
Grab_Vertexanimation( psource );
}
else
{
MdlWarning("unknown studio command\n" );
}
}
fclose( g_fpInput );
is_v1support = true;
return 1;
}
//-----------------------------------------------------------------------------
// Checks to see if the model source was already loaded
//-----------------------------------------------------------------------------
static s_source_t *FindCachedSource( char const* name, char const* xext )
{
int i;
if( xext[0] )
{
// we know what extension is necessary. . look for it.
sprintf (g_szFilename, "%s%s.%s", cddir[numdirs], name, xext );
for (i = 0; i < g_numsources; i++)
{
if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
return g_source[i];
}
}
else
{
// we don't know what extension to use, so look for all of 'em.
sprintf (g_szFilename, "%s%s.vrm", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
return g_source[i];
}
sprintf (g_szFilename, "%s%s.smd", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
return g_source[i];
}
/*
sprintf (g_szFilename, "%s%s.vta", cddir[numdirs], name );
for (i = 0; i < g_numsources; i++)
{
if (stricmp( g_szFilename, g_source[i]->filename ) == 0)
return g_source[i];
}
*/
}
// Not found
return 0;
}
static void FlipFacing( s_source_t *pSrc )
{
unsigned short tmp;
int i, j;
for( i = 0; i < pSrc->nummeshes; i++ )
{
s_mesh_t *pMesh = &pSrc->mesh[i];
for( j = 0; j < pMesh->numfaces; j++ )
{
s_face_t &f = pSrc->face[pMesh->faceoffset + j];
tmp = f.b; f.b = f.c; f.c = tmp;
}
}
}
//-----------------------------------------------------------------------------
// Loads an animation source
//-----------------------------------------------------------------------------
s_source_t *Load_Source( char const *name, const char *ext, bool reverse, bool isActiveModel )
{
// Sanity check number of source files
if ( g_numsources >= MAXSTUDIOSEQUENCES )
MdlError( "Load_Source( %s ) - overflowed g_numsources.", name );
// Sanity check file and init
Assert(name);
int namelen = strlen(name) + 1;
char* pTempName = (char*)_alloca( namelen );
char xext[32];
int result = false;
// Local copy of filename
strcpy( pTempName, name );
// Sanity check file extension?
Q_ExtractFileExtension( pTempName, xext, sizeof( xext ) );
if (xext[0] == '\0')
{
V_strcpy_safe( xext, ext );
}
else
{
Q_StripExtension( pTempName, pTempName, namelen );
}
// Cached source, ie: already loaded model, legacy
// s_source_t* pSource = FindCachedSource( pTempName, xext );
// if (pSource)
// {
// if (isActiveModel)
// pSource->isActiveModel = true;
// return pSource;
// }
// allocate space and whatnot
g_source[g_numsources] = (s_source_t *)kalloc( 1, sizeof( s_source_t ) );
V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
// legacy stuff
if (isActiveModel)
{
g_source[g_numsources]->isActiveModel = true;
}
// more ext sanity check
if ( ( !result && xext[0] == '\0' ) || stricmp( xext, "smd" ) == 0)
{
Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.smd", cddir[numdirs], pTempName );
V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
// Import part, load smd file
result = Load_SMD( g_source[g_numsources] );
}
/*
if ( ( !result && xext[0] == '\0' ) || stricmp( xext, "dmx" ) == 0)
{
Q_snprintf( g_szFilename, sizeof(g_szFilename), "%s%s.dmx", cddir[numdirs], pTempName );
V_strcpy_safe( g_source[g_numsources]->filename, g_szFilename );
// Import part, load smd file
result = Load_DMX( g_source[g_numsources] );
}
*/
// Oops
if ( !result)
{
MdlError( "could not load file '%s'\n", g_source[g_numsources]->filename );
}
// bump up number of sources
g_numsources++;
if( reverse )
{
FlipFacing( g_source[g_numsources-1] );
}
return g_source[g_numsources-1];
}
void SaveNodes( s_source_t *source, CUtlBuffer& buf )
{
if ( source->numbones <= 0 )
return;
buf.Printf( "nodes\n" );
for ( int i = 0; i < source->numbones; ++i )
{
s_node_t *bone = &source->localBone[ i ];
buf.Printf( "%d \"%s\" %d\n", i, bone->name, bone->parent );
}
buf.Printf( "end\n" );
}
// FIXME: since we don't us a .qc, we could have problems with scaling, etc.???
void descale_vertex( Vector &org )
{
float invscale = 1.0f / g_currentscale;
org[0] = org[0] * invscale;
org[1] = org[1] * invscale;
org[2] = org[2] * invscale;
}
void SaveAnimation( s_source_t *source, CUtlBuffer& buf )
{
if ( source->numbones <= 0 )
return;
buf.Printf( "skeleton\n" );
for ( int frame = 0; frame < source->numframes; ++frame )
{
buf.Printf( "time %i\n", frame + source->startframe );
for ( int i = 0; i < source->numbones; ++i )
{
s_bone_t *prev = NULL;
if ( frame > 0 )
{
if ( source->rawanim[ frame - 1 ] )
{
prev = &source->rawanim[ frame - 1 ][ i ];
}
}
Vector pos = source->rawanim[ frame ][ i ].pos;
descale_vertex( pos );
RadianEuler rot = source->rawanim[ frame ][ i ].rot;
// If this is enabled, then we delta this pos vs the prev frame and don't write out a sample if it's the same value...
#if 0
if ( prev )
{
Vector ppos = source->rawanim[ frame -1 ][ i ].pos;
descale_vertex( pos );
RadianEuler prot = source->rawanim[ frame -1 ][ i ].rot;
// Only output it if there's a delta
if ( ( ppos != pos ) ||
Q_memcmp( &prot, &rot, sizeof( prot ) ) )
{
buf.Printf
( "%d %f %f %f %f %f %f\n",
i, // bone index
pos[ 0 ],
pos[ 1 ],
pos[ 2 ],
rot[ 0 ],
rot[ 1 ],
rot[ 2 ]
);
}
}
else
#endif
{
buf.Printf
( "%d %f %f %f %f %f %f\n",
i, // bone index
pos[ 0 ],
pos[ 1 ],
pos[ 2 ],
rot[ 0 ],
rot[ 1 ],
rot[ 2 ]
);
}
}
}
buf.Printf( "end\n" );
}
void Save_SMD( char const *filename, s_source_t *source )
{
// Text buffer
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
buf.Printf( "version 1\n" );
SaveNodes( source, buf );
SaveAnimation( source, buf );
FileHandle_t fh = g_pFileSystem->Open( filename, "wb" );
if ( FILESYSTEM_INVALID_HANDLE != fh )
{
g_pFileSystem->Write( buf.Base(), buf.TellPut(), fh );
g_pFileSystem->Close( fh );
}
}
//--------------------------------------------------------------------
// mikes right handed row based linear algebra
//--------------------------------------------------------------------
struct M_matrix4x4_t
{
M_matrix4x4_t() {
m_flMatVal[0][0] = 1.0; m_flMatVal[0][1] = 0.0; m_flMatVal[0][2] = 0.0; m_flMatVal[0][3] = 0.0;
m_flMatVal[1][0] = 0.0; m_flMatVal[1][1] = 1.0; m_flMatVal[1][2] = 0.0; m_flMatVal[1][3] = 0.0;
m_flMatVal[2][0] = 0.0; m_flMatVal[2][1] = 0.0; m_flMatVal[2][2] = 1.0; m_flMatVal[2][3] = 0.0;
m_flMatVal[3][0] = 0.0; m_flMatVal[3][1] = 0.0; m_flMatVal[3][2] = 0.0; m_flMatVal[3][3] = 1.0;
}
// M_matrix3x4_t(
// float m00, float m01, float m02,
// float m10, float m11, float m12,
// float m20, float m21, float m22,
// float m30, float m31, float m32)
// {
// m_flMatVal[0][0] = m00; m_flMatVal[0][1] = m01; m_flMatVal[0][2] = m02;
// m_flMatVal[1][0] = m10; m_flMatVal[1][1] = m11; m_flMatVal[1][2] = m12;
// m_flMatVal[2][0] = m20; m_flMatVal[2][1] = m21; m_flMatVal[2][2] = m22;
// m_flMatVal[3][0] = m30; m_flMatVal[3][1] = m31; m_flMatVal[3][2] = m32;
// }
float *operator[]( int i ) { Assert(( i >= 0 ) && ( i < 4 )); return m_flMatVal[i]; }
const float *operator[]( int i ) const { Assert(( i >= 0 ) && ( i < 4 )); return m_flMatVal[i]; }
float *Base() { return &m_flMatVal[0][0]; }
const float *Base() const { return &m_flMatVal[0][0]; }
float m_flMatVal[4][4];
};
void M_MatrixAngles( const M_matrix4x4_t& matrix, RadianEuler &angles, Vector &position)
{
float cX, sX, cY, sY, cZ, sZ;
sY = -matrix[0][2];
cY = sqrtf(1.0-(sY*sY));
if (cY != 0.0)
{
sX = matrix[1][2];
cX = matrix[2][2];
sZ = matrix[0][1];
cZ = matrix[0][0];
}
else
{
sX = -matrix[2][1];
cX = matrix[1][1];
sZ = 0.0;
cZ = 1.0;
}
angles[0] = atan2f( sX, cX );
angles[2] = atan2f( sZ, cZ );
sX = sinf(angles[0]);
cX = cosf(angles[0]);
if (sX > cX)
cY = matrix[1][2] / sX;
else
cY = matrix[2][2] / cX;
angles[1] = atan2f( sY, cY );
position.x = matrix[3][0];
position.y = matrix[3][1];
position.z = matrix[3][2];
}
// void M_MatrixAngles( const M_matrix4x4_t& matrix, RadianEuler &angles, Vector &position)
// {
// float cX, sX, cY, sY, cZ, sZ;
// sY = matrix[2][0];
// cY = sqrtf(1.0-(sY*sY));
// if (cY != 0.0)
// {
// sX = -matrix[2][1];
// cX = matrix[2][2];
// sZ = -matrix[1][0];
// cZ = matrix[0][0];
// }
// else
// {
// sX = matrix[0][1];
// cX = matrix[1][1];
// sZ = 0.0;
// cZ = 1.0;
// }
// angles[0] = atan2f( sX, cX );
// angles[2] = atan2f( sZ, cZ );
// sX = sinf(angles[0]);
// cX = cosf(angles[0]);
// if (sX > cX)
// cY = -matrix[2][1] / sX;
// else
// cY = matrix[2][2] / cX;
// angles[1] = atan2f( sY, cY );
// angles[0] = angles[0];
// angles[1] = angles[1];
// angles[2] = angles[2];
// position.x = matrix[3][0];
// position.y = matrix[3][1];
// position.z = matrix[3][2];
// }
void M_MatrixCopy( const M_matrix4x4_t& in, M_matrix4x4_t& out )
{
// Assert( s_bMathlibInitialized );
memcpy( out.Base(), in.Base(), sizeof( float ) * 4 * 4 );
}
void M_RotateZMatrix(float radian, M_matrix4x4_t &resultMatrix)
{
resultMatrix[0][0] = cosf(radian);
resultMatrix[0][1] = sin(radian);
resultMatrix[0][2] = 0.0;
resultMatrix[1][0] =-sin(radian);
resultMatrix[1][1] = cos(radian);
resultMatrix[1][2] = 0.0;
resultMatrix[2][0] = 0.0;
resultMatrix[2][1] = 0.0;
resultMatrix[2][2] = 1.0;
}
// !!! THIS SHIT DOESN'T WORK!! WHY? HAS I EVER?
void M_AngleAboutAxis(Vector &axis, float radianAngle, M_matrix4x4_t &result)
{
float c = cosf(radianAngle);
float s = sinf(radianAngle);
float t = 1.0 - c;
// axis.normalize();
result[0][0] = t * axis[0] * axis[0] + c;
result[0][1] = t * axis[0] * axis[1] - s * axis[2];
result[0][2] = t * axis[0] * axis[2] + s * axis[1];
result[1][0] = t * axis[0] * axis[1] + s * axis[2];
result[1][1] = t * axis[1] * axis[1] + c;
result[1][2] = t * axis[1] * axis[2] - s * axis[0];
result[2][0] = t * axis[1] * axis[2] - s;
result[2][1] = t * axis[1] * axis[2] + s * axis[1];
result[2][2] = t * axis[2] * axis[2] + c * axis[0];
}
void M_MatrixInvert( const M_matrix4x4_t& in, M_matrix4x4_t& out )
{
// Assert( s_bMathlibInitialized );
if ( &in == &out )
{
M_matrix4x4_t in2;
M_MatrixCopy( in, in2 );
M_MatrixInvert( in2, out );
return;
}
float tmp[3];
// I'm guessing this only works on a 3x4 orthonormal matrix
out[0][0] = in[0][0];
out[1][0] = in[0][1];
out[2][0] = in[0][2];
out[0][1] = in[1][0];
out[1][1] = in[1][1];
out[2][1] = in[1][2];
out[0][2] = in[2][0];
out[1][2] = in[2][1];
out[2][2] = in[2][2];
tmp[0] = in[3][0];
tmp[1] = in[3][1];
tmp[2] = in[3][2];
float v1[3], v2[3], v3[3];
v1[0] = out[0][0];
v1[1] = out[1][0];
v1[2] = out[2][0];
v2[0] = out[0][1];
v2[1] = out[1][1];
v2[2] = out[2][1];
v3[0] = out[0][2];
v3[1] = out[1][2];
v3[2] = out[2][2];
out[3][0] = -DotProduct( tmp, v1 );
out[3][1] = -DotProduct( tmp, v2 );
out[3][2] = -DotProduct( tmp, v3 );
// Trivial case
// if (IS_IDENTITY(matrix))
// return SbMatrix::identity();
// // Affine case...
// // SbMatrix affineAnswer;
// // if ( affine_inverse( SbMatrix(matrix), affineAnswer ) )
// // return affineAnswer;
// int index[4];
// float d, invmat[4][4], temp;
// SbMatrix inverse = *this;
// if(inverse.LUDecomposition(index, d)) {
// invmat[0][0] = 1.0;
// invmat[0][1] = 0.0;
// invmat[0][2] = 0.0;
// invmat[0][3] = 0.0;
// inverse.LUBackSubstitution(index, invmat[0]);
// invmat[1][0] = 0.0;
// invmat[1][1] = 1.0;
// invmat[1][2] = 0.0;
// invmat[1][3] = 0.0;
// inverse.LUBackSubstitution(index, invmat[1]);
// invmat[2][0] = 0.0;
// invmat[2][1] = 0.0;
// invmat[2][2] = 1.0;
// invmat[2][3] = 0.0;
// inverse.LUBackSubstitution(index, invmat[2]);
// invmat[3][0] = 0.0;
// invmat[3][1] = 0.0;
// invmat[3][2] = 0.0;
// invmat[3][3] = 1.0;
// inverse.LUBackSubstitution(index, invmat[3]);
// #define SWAP(i,j) \
// temp = invmat[i][j]; \
// invmat[i][j] = invmat[j][i]; \
// invmat[j][i] = temp;
// SWAP(1,0);
// SWAP(2,0);
// SWAP(2,1);
// SWAP(3,0);
// SWAP(3,1);
// SWAP(3,2);
// #undef SWAP
// }
}
/*
================
M_ConcatTransforms
================
*/
void M_ConcatTransforms (const M_matrix4x4_t &in1, const M_matrix4x4_t &in2, M_matrix4x4_t &out)
{
// Assert( s_bMathlibInitialized );
// if ( &in1 == &out )
// {
// matrix3x4_t in1b;
// MatrixCopy( in1, in1b );
// ConcatTransforms( in1b, in2, out );
// return;
// }
// if ( &in2 == &out )
// {
// matrix3x4_t in2b;
// MatrixCopy( in2, in2b );
// ConcatTransforms( in1, in2b, out );
// return;
// }
#define MULT(i,j) (in1[i][0]*in2[0][j] + \
in1[i][1]*in2[1][j] + \
in1[i][2]*in2[2][j] + \
in1[i][3]*in2[3][j])
out[0][0] = MULT(0,0);
out[0][1] = MULT(0,1);
out[0][2] = MULT(0,2);
out[0][3] = MULT(0,3);
out[1][0] = MULT(1,0);
out[1][1] = MULT(1,1);
out[1][2] = MULT(1,2);
out[1][3] = MULT(1,3);
out[2][0] = MULT(2,0);
out[2][1] = MULT(2,1);
out[2][2] = MULT(2,2);
out[2][3] = MULT(2,3);
out[3][0] = MULT(3,0);
out[3][1] = MULT(3,1);
out[3][2] = MULT(3,2);
out[3][3] = MULT(3,3);
#undef MULT
}
void M_AngleMatrix( RadianEuler const &angles, const Vector &position, M_matrix4x4_t& matrix )
{
// Assert( s_bMathlibInitialized );
float sx, sy, sz, cx, cy, cz;
sx = sinf(angles[0]);
cx = cosf(angles[0]);
sy = sinf(angles[1]);
cy = cosf(angles[1]);
sz = sinf(angles[2]);
cz = cosf(angles[2]);
// SinCos( angles[0], &sx, &cx ); // 2
// SinCos( angles[1], &sy, &cy ); // 1
// SinCos( angles[2], &sz, &cz ); // 0
M_matrix4x4_t mx, my, mz, temp1;
// rotation about x
mx[1][1] = cx;
mx[1][2] = sx;
mx[2][1] = -sx;
mx[2][2] = cx;
// rotation about y
my[0][0] = cy;
my[0][2] = -sy;
my[2][0] = sy;
my[2][2] = cy;
// rotation about z
mz[0][0] = cz;
mz[0][1] = sz;
mz[1][0] = -sz;
mz[1][1] = cz;
// z * y * x
M_ConcatTransforms(mx, my, temp1);
M_ConcatTransforms(temp1, mz, matrix);
// put position in
matrix[3][0] = position.x;
matrix[3][1] = position.y;
matrix[3][2] = position.z;
}
//-----------------------------------------------------------------------------
// Motion mapper functions
//-----------------------------------------------------------------------------
#define BONEAXIS 0
#define BONEDIR 0
#define BONESIDE 1
#define BONEUP 2
#define WORLDUP 2
#define PRINTMAT(m) \
printf("\n%f %f %f %f\n", m[0][0], m[0][1], m[0][2], m[0][3]); \
printf("%f %f %f %f\n", m[1][0], m[1][1], m[1][2], m[1][3]); \
printf("%f %f %f %f\n", m[2][0], m[2][1], m[2][2], m[2][3]); \
printf("%f %f %f %f\n", m[3][0], m[3][1], m[3][2], m[3][3]);
struct s_planeConstraint_t
{
char jointNameString[1024];
float floor;
int axis;
};
struct s_iksolve_t
{
char jointNameString[1024];
int reverseSolve;
float extremityScale;
Vector limbRootOffsetScale;
int doRelativeLock;
char relativeLockNameString[1024];
float relativeLockScale;
};
struct s_jointScale_t
{
char jointNameString[1024];
float scale;
};
struct s_template_t
{
char rootScaleJoint[1024];
float rootScaleAmount;
int numIKSolves;
s_iksolve_t *ikSolves[128];
int numJointScales;
s_jointScale_t *jointScales[128];
int numPlaneConstraints;
s_planeConstraint_t *planeConstraints[128];
float toeFloorZ;
int doSkeletonScale;
float skeletonScale;
};
//-----------------------------------------------------------------------------
// Load a template file into structure
//-----------------------------------------------------------------------------
s_template_t *New_Template()
{
s_template_t *pTemplate = (s_template_t *)kalloc(1, sizeof(s_template_t));
pTemplate->rootScaleAmount = 1.0;
pTemplate->numIKSolves = 0;
pTemplate->numJointScales = 0;
pTemplate->toeFloorZ = 2.802277;
pTemplate->numPlaneConstraints = 0;
pTemplate->doSkeletonScale = 0;
pTemplate->skeletonScale = 1.0;
return pTemplate;
}
s_iksolve_t *New_IKSolve()
{
s_iksolve_t *pIKSolve = (s_iksolve_t *)kalloc(1, sizeof(s_iksolve_t));
pIKSolve->reverseSolve = 0;
pIKSolve->extremityScale = 1.0;
pIKSolve->limbRootOffsetScale[0] = pIKSolve->limbRootOffsetScale[1] = pIKSolve->limbRootOffsetScale[2] = 0.0;
pIKSolve->doRelativeLock = 0;
pIKSolve->relativeLockScale = 1.0;
return pIKSolve;
}
s_planeConstraint_t *New_planeConstraint(float floor)
{
s_planeConstraint_t *pConstraint = (s_planeConstraint_t *)kalloc(1, sizeof(s_planeConstraint_t));
pConstraint->floor = floor;
pConstraint->axis = 2;
return pConstraint;
}
void Set_DefaultTemplate(s_template_t *pTemplate)
{
pTemplate->numJointScales = 0;
strcpy(pTemplate->rootScaleJoint, "ValveBiped.Bip01_L_Foot");
pTemplate->rootScaleAmount = 1.0;
pTemplate->numIKSolves = 4;
pTemplate->ikSolves[0] = New_IKSolve();
pTemplate->ikSolves[1] = New_IKSolve();
pTemplate->ikSolves[2] = New_IKSolve();
pTemplate->ikSolves[3] = New_IKSolve();
pTemplate->numPlaneConstraints = 2;
pTemplate->planeConstraints[0] = New_planeConstraint(pTemplate->toeFloorZ);
strcpy(pTemplate->planeConstraints[0]->jointNameString, "ValveBiped.Bip01_L_Toe0");
pTemplate->planeConstraints[1] = New_planeConstraint(pTemplate->toeFloorZ);
strcpy(pTemplate->planeConstraints[1]->jointNameString, "ValveBiped.Bip01_R_Toe0");
strcpy(pTemplate->ikSolves[0]->jointNameString, "ValveBiped.Bip01_L_Foot");
pTemplate->ikSolves[0]->reverseSolve = 0;
pTemplate->ikSolves[0]->extremityScale = 1.0;
pTemplate->ikSolves[0]->limbRootOffsetScale[0] = 1.0;
pTemplate->ikSolves[0]->limbRootOffsetScale[1] = 1.0;
pTemplate->ikSolves[0]->limbRootOffsetScale[2] = 0.0;
strcpy(pTemplate->ikSolves[1]->jointNameString, "ValveBiped.Bip01_R_Foot");
pTemplate->ikSolves[1]->reverseSolve = 0;
pTemplate->ikSolves[1]->extremityScale = 1.0;
pTemplate->ikSolves[1]->limbRootOffsetScale[0] = 1.0;
pTemplate->ikSolves[1]->limbRootOffsetScale[1] = 1.0;
pTemplate->ikSolves[1]->limbRootOffsetScale[2] = 0.0;
strcpy(pTemplate->ikSolves[2]->jointNameString, "ValveBiped.Bip01_R_Hand");
pTemplate->ikSolves[2]->reverseSolve = 1;
pTemplate->ikSolves[2]->extremityScale = 1.0;
pTemplate->ikSolves[2]->limbRootOffsetScale[0] = 0.0;
pTemplate->ikSolves[2]->limbRootOffsetScale[1] = 0.0;
pTemplate->ikSolves[2]->limbRootOffsetScale[2] = 1.0;
strcpy(pTemplate->ikSolves[3]->jointNameString, "ValveBiped.Bip01_L_Hand");
pTemplate->ikSolves[3]->reverseSolve = 1;
pTemplate->ikSolves[3]->extremityScale = 1.0;
pTemplate->ikSolves[3]->limbRootOffsetScale[0] = 0.0;
pTemplate->ikSolves[3]->limbRootOffsetScale[1] = 0.0;
pTemplate->ikSolves[3]->limbRootOffsetScale[2] = 1.0;
// pTemplate->ikSolves[3]->doRelativeLock = 1;
// strcpy(pTemplate->ikSolves[3]->relativeLockNameString, "ValveBiped.Bip01_R_Hand");
// pTemplate->ikSolves[3]->relativeLockScale = 1.0;
}
void split(char *str, char *sep, char **sp)
{
char *r = strtok(str, sep);
while(r != NULL)
{
*sp = r;
sp++;
r = strtok(NULL, sep);
}
*sp = NULL;
}
int checkCommand(char *str, char *cmd, int numOptions, int numSplit)
{
if(strcmp(str, cmd) == 0)
{
if(numOptions <= numSplit)
return 1;
else
{
printf("Error: Number or argument mismatch in template file cmd %s, requires %i, found %i\n", cmd, numOptions, numSplit);
return 0;
}
}
return 0;
}
s_template_t *Load_Template(char *name )
{
// Sanity check file and init
Assert(name);
s_template_t *pTemplate = New_Template();
// Open file
if (!OpenGlobalFile( name ))
return 0;
//March through lines
g_iLinecount = 0;
while(fgets( g_szLine, sizeof( g_szLine ), g_fpInput ) != NULL)
{
g_iLinecount++;
if(g_szLine[0] == '#')
continue;
char *endP = strrchr(g_szLine, '\n');
if(endP != NULL)
*endP = '\0';
char *sp[128];
char **spp = sp;
char sep[] = " ";
split(g_szLine, sep, sp);
int numSplit = 0;
while(*spp != NULL)
{
spp++;
numSplit++;
}
if(numSplit < 1 ||
*sp[0] == '\n')
continue;
// int numRead = sscanf( g_szLine, "%s %s %s", cmd, &option, &option2 );
// // Blank line
// if ((numRead == EOF) || (numRead == 0))
// continue;
// commands
char *cmd;
int numOptions = numSplit - 1;
cmd = sp[0];
if(checkCommand(cmd, "twoJointIKSolve", 1, numOptions))
{
printf("\nCreating two joint IK solve %s\n", sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves] = New_IKSolve();
strcpy(pTemplate->ikSolves[pTemplate->numIKSolves]->jointNameString, sp[1]);
pTemplate->numIKSolves++;
}
else if(checkCommand(cmd, "oneJointPlaneConstraint", 1, numOptions))
{
printf("\nCreating one joint plane constraint %s\n", sp[1]);
pTemplate->planeConstraints[pTemplate->numPlaneConstraints] = New_planeConstraint(pTemplate->toeFloorZ);
strcpy(pTemplate->planeConstraints[pTemplate->numPlaneConstraints]->jointNameString, sp[1]);
pTemplate->numPlaneConstraints++;
}
else if(checkCommand(cmd, "reverseSolve", 1, numOptions))
{
printf("reverseSolve: %s\n", sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->reverseSolve = atoi(sp[1]);
}
else if(checkCommand(cmd, "extremityScale", 1, numOptions))
{
printf("extremityScale: %s\n", sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->extremityScale = atof(sp[1]);
}
else if(checkCommand(cmd, "limbRootOffsetScale", 3, numOptions))
{
printf("limbRootOffsetScale: %s %s %s\n", sp[1], sp[2], sp[3]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->limbRootOffsetScale[0] = atof(sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->limbRootOffsetScale[1] = atof(sp[2]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->limbRootOffsetScale[2] = atof(sp[3]);
}
else if(checkCommand(cmd, "toeFloorZ", 1, numOptions))
{
printf("toeFloorZ: %s\n", sp[1]);
pTemplate->toeFloorZ = atof(sp[1]);
}
else if(checkCommand(cmd, "relativeLock", 2, numOptions))
{
printf("relativeLock: %s\n", sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->doRelativeLock = 1;
strcpy(pTemplate->ikSolves[pTemplate->numIKSolves - 1]->relativeLockNameString, sp[1]);
pTemplate->ikSolves[pTemplate->numIKSolves - 1]->relativeLockScale = atof(sp[2]);
}
else if(checkCommand(cmd, "rootScaleJoint", 1, numOptions))
{
printf("\nrootScaleJoint: %s\n", sp[1]);
strcpy(pTemplate->rootScaleJoint, sp[1]);
}
else if(checkCommand(cmd, "rootScaleAmount", 1, numOptions))
{
printf("rootScaleAmount: %s\n", sp[1]);
pTemplate->rootScaleAmount = atof(sp[1]);
}
else if(checkCommand(cmd, "jointScale", 2, numOptions))
{
printf("\nCreating joint scale %s of %s\n", sp[1], sp[2]);
pTemplate->jointScales[pTemplate->numJointScales] = (s_jointScale_t *)kalloc(1, sizeof(s_jointScale_t));
strcpy(pTemplate->jointScales[pTemplate->numJointScales]->jointNameString, sp[1]);
pTemplate->jointScales[pTemplate->numJointScales]->scale = atof(sp[2]);
pTemplate->numJointScales++;
}
else if(checkCommand(cmd, "skeletonScale", 2, numOptions))
{
printf("\nCreating skeleton scale of %s\n", sp[1]);
pTemplate->doSkeletonScale = 1;
pTemplate->skeletonScale = atof(sp[1]);
}
else
{
MdlWarning("unknown studio command\n" );
}
}
fclose( g_fpInput );
return pTemplate;
}
//-----------------------------------------------------------------------------
// get node index from node string name
//-----------------------------------------------------------------------------
int GetNodeIndex(s_source_t *psource, char *nodeName)
{
for(int i = 0; i < psource->numbones; i++)
{
if(strcmp(nodeName, psource->localBone[i].name) == 0)
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
// get node index from node string name
//-----------------------------------------------------------------------------
void GetNodePath(s_source_t *psource, int startIndex, int endIndex, int *path)
{
*path = endIndex;
s_node_t *nodes;
nodes = psource->localBone;
while(*path != startIndex)
{
int parent = nodes[*path].parent;
path++;
*path = parent;
}
path++;
*path = -1;
}
void SumBonePathTranslations(int *indexPath, s_bone_t *boneArray, Vector &resultVector, int rootOffset = 0)
{
// walk the path
int *pathPtr = indexPath;
// M_matrix4x4_t matrixCum;
// find length of path
int length = 0;
while(*pathPtr != -1)
{
length++;
pathPtr++;
}
int l = length - (1 + rootOffset);
resultVector[0] = 0.0;
resultVector[1] = 0.0;
resultVector[2] = 0.0;
for(int i = l; i > -1; i--)
{
s_bone_t *thisBone = boneArray + indexPath[i];
resultVector += thisBone->pos;
}
}
void CatBonePath(int *indexPath, s_bone_t *boneArray, M_matrix4x4_t &resultMatrix, int rootOffset = 0)
{
// walk the path
int *pathPtr = indexPath;
// M_matrix4x4_t matrixCum;
// find length of path
int length = 0;
while(*pathPtr != -1)
{
length++;
pathPtr++;
}
int l = length - (1 + rootOffset);
for(int i = l; i > -1; i--)
{
s_bone_t *thisBone = boneArray + indexPath[i];
// printf("bone index: %i %i\n", i, indexPath[i]);
// printf("pos: %f %f %f, rot: %f %f %f\n", thisBone->pos.x, thisBone->pos.y, thisBone->pos.z, thisBone->rot.x, thisBone->rot.y, thisBone->rot.z);
M_matrix4x4_t thisMatrix;
M_AngleMatrix(thisBone->rot, thisBone->pos, thisMatrix);
// PRINTMAT(thisMatrix)
M_matrix4x4_t tempCum;
M_MatrixCopy(resultMatrix, tempCum);
M_ConcatTransforms(thisMatrix, tempCum, resultMatrix);
}
// PRINTMAT(matrixCum);
// M_MatrixAngles(matrixCum, resultBone.rot, resultBone.pos);
// printf("pos: %f %f %f, rot: %f %f %f\n", resultBone.pos.x,resultBone.pos.y, resultBone.pos.z, RAD2DEG(resultBone.rot.x),RAD2DEG(resultBone.rot.y),RAD2DEG(resultBone.rot.z));
}
// int ConformSources(s_source_t *pSource, s_source_t *pTarget)
// {
// if(pSource->numbones != *pTarget->numbones)
// {
// printf("ERROR: The number of bones in the target file must match the source file.");
// return 1;
// }
// if(pSource->numframes != pTarget->numframes)
// {
// printf("Note: Source and target frame lengths do not match");
// for(int t = 0; t < pTarget->numframes; t++)
// {
// free(pTarget->rawanim[t]);
// }
// pTarget->numframes = pSource->numframes;
// int size = pTarget->numbones * sizeof( s_bone_t );
// for(t = 0; t < pTarget->numframes; t++)
// {
// pTarget->rawanim[t] = (s_bone_t *) kalloc(1, size);
// memcpy((void *) pSource->rawanim[t], (void *) pTarget->rawanim[t], size
// }
// }
// pTarget->startframe = pSource->startframe;
// pTarget->endframe = pSource->endframe;
void ScaleJointsFrame(s_source_t *pSkeleton, s_jointScale_t *jointScale, int t)
{
int numBones = pSkeleton->numbones;
for(int i = 0; i < numBones; i++)
{
s_node_t pNode = pSkeleton->localBone[i];
s_bone_t *pSkelBone = &pSkeleton->rawanim[t][i];
if(strcmp(jointScale->jointNameString, pNode.name) == 0)
{
// printf("Scaling joint %s\n", pNode.name);
pSkelBone->pos = pSkelBone->pos * jointScale->scale;
}
}
}
void ScaleJoints(s_source_t *pSkeleton, s_jointScale_t *jointScale)
{
int numFrames = pSkeleton->numframes;
for(int t = 0; t < numFrames; t++)
{
ScaleJointsFrame(pSkeleton, jointScale, t);
}
}
void ScaleSkeletonFrame(s_source_t *pSkeleton, float scale, int t)
{
int numBones = pSkeleton->numbones;
for(int i = 0; i < numBones; i++)
{
s_bone_t *pSkelBone = &pSkeleton->rawanim[t][i];
pSkelBone->pos = pSkelBone->pos * scale;
}
}
void ScaleSkeleton(s_source_t *pSkeleton, float scale)
{
int numFrames = pSkeleton->numframes;
for(int t = 0; t < numFrames; t++)
{
ScaleSkeletonFrame(pSkeleton, scale, t);
}
}
void CombineSkeletonAnimationFrame(s_source_t *pSkeleton, s_source_t *pAnimation, s_bone_t **ppAnim, int t)
{
int numBones = pAnimation->numbones;
int size = numBones * sizeof( s_bone_t );
ppAnim[t] = (s_bone_t *) kalloc(1, size);
for(int i = 0; i < numBones; i++)
{
s_node_t pNode = pAnimation->localBone[i];
s_bone_t pAnimBone = pAnimation->rawanim[t][i];
if(pNode.parent > -1)
{
if ( i < pSkeleton->numbones )
{
s_bone_t pSkelBone = pSkeleton->rawanim[0][i];
ppAnim[t][i].pos = pSkelBone.pos;
}
else
{
if ( !g_bGaveMissingBoneWarning )
{
g_bGaveMissingBoneWarning = true;
Warning( "Warning: Target skeleton has less bones than source animation. Reverting to source data for extra bones.\n" );
}
ppAnim[t][i].pos = pAnimBone.pos;
}
}
else
{
ppAnim[t][i].pos = pAnimBone.pos;
}
ppAnim[t][i].rot = pAnimBone.rot;
}
}
void CombineSkeletonAnimation(s_source_t *pSkeleton, s_source_t *pAnimation, s_bone_t **ppAnim)
{
int numFrames = pAnimation->numframes;
for(int t = 0; t < numFrames; t++)
{
CombineSkeletonAnimationFrame(pSkeleton, pAnimation, ppAnim, t);
}
}
//--------------------------------------------------------------------
// MotionMap
//--------------------------------------------------------------------
s_source_t *MotionMap( s_source_t *pSource, s_source_t *pTarget, s_template_t *pTemplate )
{
// scale skeleton
if(pTemplate->doSkeletonScale)
{
ScaleSkeleton(pTarget, pTemplate->skeletonScale);
}
// scale joints
for(int j = 0; j < pTemplate->numJointScales; j++)
{
s_jointScale_t *pJointScale = pTemplate->jointScales[j];
ScaleJoints(pTarget, pJointScale);
}
// root stuff
char rootString[128] = "ValveBiped.Bip01";
// !!! PARAMETER
int rootIndex = GetNodeIndex(pSource, rootString);
int rootScaleIndex = GetNodeIndex(pSource, pTemplate->rootScaleJoint);
int rootScalePath[512];
if(rootScaleIndex > -1)
{
GetNodePath(pSource, rootIndex, rootScaleIndex, rootScalePath);
}
else
{
printf("Error: Can't find node\n");
exit(0);
}
float rootScaleLengthSrc = pSource->rawanim[0][rootScaleIndex].pos[BONEDIR];
float rootScaleParentLengthSrc = pSource->rawanim[0][rootScalePath[1]].pos[BONEDIR];
float rootScaleSrc = rootScaleLengthSrc + rootScaleParentLengthSrc;
float rootScaleLengthTgt = pTarget->rawanim[0][rootScaleIndex].pos[BONEDIR];
float rootScaleParentLengthTgt = pTarget->rawanim[0][rootScalePath[1]].pos[BONEDIR];
float rootScaleTgt = rootScaleLengthTgt + rootScaleParentLengthTgt;
float rootScaleFactor = rootScaleTgt / rootScaleSrc;
if(g_verbose)
printf("Root Scale Factor: %f\n", rootScaleFactor);
// root scale origin
float toeFloorZ = pTemplate->toeFloorZ;
Vector rootScaleOrigin = pSource->rawanim[0][rootIndex].pos;
rootScaleOrigin[2] = toeFloorZ;
// setup workspace
s_bone_t *combinedRefAnimation[MAXSTUDIOANIMFRAMES];
s_bone_t *combinedAnimation[MAXSTUDIOANIMFRAMES];
s_bone_t *sourceAnimation[MAXSTUDIOANIMFRAMES];
CombineSkeletonAnimation(pTarget, pSource, combinedAnimation);
CombineSkeletonAnimation(pTarget, pSource, combinedRefAnimation);
// do source and target sanity checking
int sourceNumFrames = pSource->numframes;
// iterate through limb solves
for(int t = 0; t < sourceNumFrames; t++)
{
// setup pTarget for skeleton comparison
pTarget->rawanim[t] = combinedRefAnimation[t];
printf("Note: Processing frame: %i\n", t);
for(int ii = 0; ii < pTemplate->numIKSolves; ii++)
{
s_iksolve_t *thisSolve = pTemplate->ikSolves[ii];
char *thisJointNameString = thisSolve->jointNameString;
int thisJointIndex = GetNodeIndex(pSource, thisJointNameString);
// init paths to feet
int thisJointPathInRoot[512];
// get paths to feet
if(thisJointIndex > -1)
{
GetNodePath(pSource, rootIndex, thisJointIndex, thisJointPathInRoot);
}
else
{
printf("Error: Can't find node: %s\n" , thisJointNameString);
exit(0);
}
// leg "root" or thigh pointers
//int gParentIndex = thisJointPathInRoot[2];
int *gParentPath = thisJointPathInRoot + 2;
//----------------------------------------------------------------
// get limb lengths
//----------------------------------------------------------------
float thisJointLengthSrc = pSource->rawanim[0][thisJointIndex].pos[BONEDIR];
float parentJointLengthSrc = pSource->rawanim[0][thisJointPathInRoot[1]].pos[BONEDIR];
float thisLimbLengthSrc = thisJointLengthSrc + parentJointLengthSrc;
float thisJointLengthTgt = pTarget->rawanim[0][thisJointIndex].pos[BONEDIR];
float parentJointLengthTgt = pTarget->rawanim[0][thisJointPathInRoot[1]].pos[BONEDIR];
float thisLimbLengthTgt = thisJointLengthTgt + parentJointLengthTgt;
// Factor leg length delta
float thisLimbLength = thisLimbLengthSrc - thisLimbLengthTgt;
float thisLimbLengthFactor = thisLimbLengthTgt / thisLimbLengthSrc;
if(g_verbose)
printf("limb length %s: %i: %f, factor %f\n", thisJointNameString, thisJointIndex, thisLimbLength, thisLimbLengthFactor);
// calculate joint grandparent offset
// Note: because there's no reference pose this doesn't take rotation into account.
// This only works because of the assumption that joint translations aren't animated.
M_matrix4x4_t gParentGlobalMatSrc, gParentGlobalMatTgt;
Vector gParentGlobalSrc, gParentGlobalTgt;
// SumBonePathTranslations(gParentPath, pSource->rawanim[t], gParentGlobalSrc, 1);
// SumBonePathTranslations(gParentPath, pTarget->rawanim[t], gParentGlobalTgt, 1);
// get root path to source parent
CatBonePath(gParentPath, pSource->rawanim[t], gParentGlobalMatSrc, 1);
// check against reference animation
CatBonePath(gParentPath, pTarget->rawanim[t], gParentGlobalMatTgt, 1);
gParentGlobalSrc[0] = gParentGlobalMatSrc[3][0];
gParentGlobalSrc[1] = gParentGlobalMatSrc[3][1];
gParentGlobalSrc[2] = gParentGlobalMatSrc[3][2];
gParentGlobalTgt[0] = gParentGlobalMatTgt[3][0];
gParentGlobalTgt[1] = gParentGlobalMatTgt[3][1];
gParentGlobalTgt[2] = gParentGlobalMatTgt[3][2];
Vector gParentDelta(gParentGlobalTgt - gParentGlobalSrc);
if(g_verbose)
printf("Grand parent delta: %f %f %f\n", gParentDelta[0], gParentDelta[1], gParentDelta[2]);
gParentDelta *= thisSolve->limbRootOffsetScale;
//----------------------------------------------------------------
// time takes effect here
// above waste is unavoidable?
//----------------------------------------------------------------
M_matrix4x4_t rootMat;
M_AngleMatrix(pSource->rawanim[t][rootIndex].rot, pSource->rawanim[t][rootIndex].pos, rootMat);
// OK, time to get it together
// 1) scale foot by legLengthFactor in the non-translated thigh space
// 2) translate foot by legRootDelta in the space of the root
// do we leave everything in the space of the root then? PROBABLY!!
M_matrix4x4_t thisJointMat, parentJointMat, thisJointInGParentMat;
M_AngleMatrix(pSource->rawanim[t][thisJointPathInRoot[0]].rot, pSource->rawanim[t][thisJointPathInRoot[0]].pos, thisJointMat);
M_AngleMatrix(pSource->rawanim[t][thisJointPathInRoot[1]].rot, pSource->rawanim[t][thisJointPathInRoot[1]].pos, parentJointMat);
M_ConcatTransforms(thisJointMat, parentJointMat, thisJointInGParentMat);
if(!thisSolve->doRelativeLock)
{
// scale around grand parent
float effectiveScaleFactor = ((thisLimbLengthFactor - 1.0) * thisSolve->extremityScale ) + 1.0;
thisJointInGParentMat[3][0] *= effectiveScaleFactor;
thisJointInGParentMat[3][1] *= effectiveScaleFactor;
thisJointInGParentMat[3][2] *= effectiveScaleFactor;
}
// adjust into source root space
M_matrix4x4_t gParentInRootMat, thisJointInRootMat;
CatBonePath(gParentPath, pSource->rawanim[t], gParentInRootMat, 1);
M_ConcatTransforms(thisJointInGParentMat, gParentInRootMat, thisJointInRootMat);
if(!thisSolve->doRelativeLock)
{
// adjust by difference of local root
thisJointInRootMat[3][0] += gParentDelta[0];
thisJointInRootMat[3][1] += gParentDelta[1];
thisJointInRootMat[3][2] += gParentDelta[2];
}
else
{
char *relativeJointNameString = thisSolve->relativeLockNameString;
int relativeJointIndex = GetNodeIndex(pSource, relativeJointNameString);
// init paths to feet
int relativeJointPathInRoot[512];
// get paths to feet
if(relativeJointIndex > -1)
{
GetNodePath(pSource, rootIndex, relativeJointIndex, relativeJointPathInRoot);
}
else
{
printf("Error: Can't find node: %s\n" , relativeJointNameString);
exit(0);
}
// get the source relative joint
M_matrix4x4_t relativeJointInRootMatSrc, relativeJointInRootMatSrcInverse, thisJointInRelativeSrcMat;
CatBonePath(relativeJointPathInRoot, pSource->rawanim[t], relativeJointInRootMatSrc, 1);
M_MatrixInvert(relativeJointInRootMatSrc, relativeJointInRootMatSrcInverse);
M_ConcatTransforms(thisJointInRootMat, relativeJointInRootMatSrcInverse, thisJointInRelativeSrcMat);
if(thisSolve->relativeLockScale != 1.0)
{
thisJointInRelativeSrcMat[3][0] *= thisSolve->relativeLockScale;
thisJointInRelativeSrcMat[3][1] *= thisSolve->relativeLockScale;
thisJointInRelativeSrcMat[3][2] *= thisSolve->relativeLockScale;
}
// swap momentarily to get new destination
// NOTE: the relative lock must have already been solved
sourceAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = combinedAnimation[t];
// get new relative location
M_matrix4x4_t relativeJointInRootMatTgt;
CatBonePath(relativeJointPathInRoot, pSource->rawanim[t], relativeJointInRootMatTgt, 1);
M_ConcatTransforms(thisJointInRelativeSrcMat, relativeJointInRootMatTgt, thisJointInRootMat);
// swap back just for cleanliness
// a little overkill as it's just swapped
// just leaving it here for clarity
combinedAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = sourceAnimation[t];
}
//----------------------------------------------------------------
// swap animation
//----------------------------------------------------------------
sourceAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = combinedAnimation[t];
//----------------------------------------------------------------
// make thigh data global based on new skeleton
//----------------------------------------------------------------
// get thigh in global space
M_matrix4x4_t gParentInTgtRootMat, ggParentInTgtRootMat;
// int *gParentPath = thisJointPathInRoot + 2;
CatBonePath(gParentPath, pSource->rawanim[t], gParentInTgtRootMat, 1);
CatBonePath(gParentPath+1, pSource->rawanim[t], ggParentInTgtRootMat, 1);
//----------------------------------------------------------------
// Calculate IK for legs
//----------------------------------------------------------------
float parentJointLength = pSource->rawanim[t][*(thisJointPathInRoot + 1)].pos[BONEDIR];
float thisJointLength = pSource->rawanim[t][thisJointIndex].pos[BONEDIR];
Vector thisLimbHypot;
thisLimbHypot[0] = thisJointInRootMat[3][0] - gParentInTgtRootMat[3][0];
thisLimbHypot[1] = thisJointInRootMat[3][1] - gParentInTgtRootMat[3][1];
thisLimbHypot[2] = thisJointInRootMat[3][2] - gParentInTgtRootMat[3][2];
float thisLimbHypotLength = thisLimbHypot.Length();
// law of cosines!
float gParentCos = (thisLimbHypotLength*thisLimbHypotLength + parentJointLength*parentJointLength - thisJointLength*thisJointLength) / (2*parentJointLength*thisLimbHypotLength);
float parentCos = (parentJointLength*parentJointLength + thisJointLength*thisJointLength - thisLimbHypotLength*thisLimbHypotLength) / (2*parentJointLength*thisJointLength);
VectorNormalize(thisLimbHypot);
Vector thisLimbHypotUnit = thisLimbHypot;
M_matrix4x4_t gParentJointIKMat;
Vector gParentJointIKRot, gParentJointIKOrth;
gParentJointIKRot[0] = gParentInTgtRootMat[BONEUP][0];
gParentJointIKRot[1] = gParentInTgtRootMat[BONEUP][1];
gParentJointIKRot[2] = gParentInTgtRootMat[BONEUP][2];
VectorNormalize(gParentJointIKRot);
gParentJointIKOrth = gParentJointIKRot.Cross(thisLimbHypotUnit);
VectorNormalize(gParentJointIKOrth);
gParentJointIKRot = thisLimbHypotUnit.Cross(gParentJointIKOrth);
VectorNormalize(gParentJointIKRot);
M_MatrixCopy(gParentInTgtRootMat, gParentJointIKMat);
gParentJointIKMat[0][0] = thisLimbHypotUnit[0];
gParentJointIKMat[0][1] = thisLimbHypotUnit[1];
gParentJointIKMat[0][2] = thisLimbHypotUnit[2];
gParentJointIKMat[1][0] = gParentJointIKOrth[0];
gParentJointIKMat[1][1] = gParentJointIKOrth[1];
gParentJointIKMat[1][2] = gParentJointIKOrth[2];
gParentJointIKMat[2][0] = gParentJointIKRot[0];
gParentJointIKMat[2][1] = gParentJointIKRot[1];
gParentJointIKMat[2][2] = gParentJointIKRot[2];
M_matrix4x4_t gParentJointIKRotMat, gParentJointResultMat;
float gParentDeg;
if(thisSolve->reverseSolve)
{
gParentDeg = acos(gParentCos);
}
else
{
gParentDeg = -acos(gParentCos);
}
// sanity check limb length
if(thisLimbHypotLength < thisLimbLengthTgt)
{
M_RotateZMatrix(gParentDeg, gParentJointIKRotMat);
}
M_ConcatTransforms(gParentJointIKRotMat, gParentJointIKMat, gParentJointResultMat);
M_matrix4x4_t parentJointIKRotMat;
//!!! shouldn't need the 180 degree addition, something in the law of cosines!!!
float parentDeg;
if(thisSolve->reverseSolve)
{
parentDeg = acos(parentCos)+M_PI;
}
else
{
parentDeg = -acos(parentCos)+M_PI;
}
// sanity check limb length
if(thisLimbHypotLength < thisLimbLengthTgt)
{
M_RotateZMatrix(parentDeg, parentJointIKRotMat);
}
// Thighs
M_matrix4x4_t ggParentInTgtRootMatInverse, gParentJointLocalMat;
M_MatrixInvert(ggParentInTgtRootMat, ggParentInTgtRootMatInverse);
M_ConcatTransforms(gParentJointResultMat, ggParentInTgtRootMatInverse, gParentJointLocalMat);
s_bone_t resultBone;
// temp test stuff
// M_MatrixAngles(thisJointInRootMat, resultBone.rot, resultBone.pos);
// pSource->rawanim[t][thisJointIndex].rot = resultBone.rot;
// pSource->rawanim[t][thisJointIndex].pos = resultBone.pos;
// M_MatrixAngles(gParentInTgtRootMat, resultBone.rot, resultBone.pos);
// pSource->rawanim[t][gParentIndex].rot = resultBone.rot;
// pSource->rawanim[t][gParentIndex].pos = resultBone.pos;
M_MatrixAngles(gParentJointLocalMat, resultBone.rot, resultBone.pos);
pSource->rawanim[t][*gParentPath].pos = resultBone.pos;
pSource->rawanim[t][*gParentPath].rot = resultBone.rot;
M_MatrixAngles(parentJointIKRotMat, resultBone.rot, resultBone.pos);
pSource->rawanim[t][*(thisJointPathInRoot+1)].rot = resultBone.rot;
M_matrix4x4_t parentJointGlobalMat, parentJointGlobalMatInverse, thisJointLocalMat;
CatBonePath(thisJointPathInRoot+1, pSource->rawanim[t], parentJointGlobalMat, 1);
M_MatrixInvert(parentJointGlobalMat, parentJointGlobalMatInverse);
M_ConcatTransforms(thisJointInRootMat, parentJointGlobalMatInverse, thisJointLocalMat);
M_MatrixAngles(thisJointLocalMat, resultBone.rot, resultBone.pos);
pSource->rawanim[t][thisJointIndex].rot = resultBone.rot;
// swap animation back for next solve
combinedAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = sourceAnimation[t];
}
// swap animation
sourceAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = combinedAnimation[t];
//----------------------------------------------------------------
// adjust root
//----------------------------------------------------------------
Vector originBonePos = pSource->rawanim[t][rootIndex].pos;
Vector rootInScaleOrigin = originBonePos - rootScaleOrigin;
float effectiveRootScale = ((rootScaleFactor - 1.0) * pTemplate->rootScaleAmount) + 1.0;
Vector scaledRoot = rootInScaleOrigin * effectiveRootScale;
pSource->rawanim[t][rootIndex].pos = rootScaleOrigin + scaledRoot;
//------------------------------------------------------------
// plane constraints
//------------------------------------------------------------
for(int ii = 0; ii < pTemplate->numPlaneConstraints; ii++)
{
s_planeConstraint_t *thisSolve = pTemplate->planeConstraints[ii];
char *thisJointNameString = thisSolve->jointNameString;
if(g_verbose)
printf("Executing plane constraint: %s\n", thisJointNameString);
int thisJointIndex = GetNodeIndex(pSource, thisJointNameString);
// init paths to feet
int thisJointPath[512];
// get paths to feet
if(thisJointIndex > -1)
{
GetNodePath(pSource, -1, thisJointIndex, thisJointPath);
}
else
{
printf("Error: Can't find node: %s\n" , thisJointNameString);
exit(0);
}
int parentIndex = thisJointPath[1];
int *parentPath = thisJointPath + 1;
M_matrix4x4_t thisJointGlobalMat, parentJointGlobalMat, gParentJointGlobalMat, gParentJointGlobalMatInverse;
CatBonePath(thisJointPath, pSource->rawanim[t], thisJointGlobalMat, 0);
CatBonePath(parentPath, pSource->rawanim[t], parentJointGlobalMat, 0);
CatBonePath(parentPath+1, pSource->rawanim[t], gParentJointGlobalMat, 0);
M_MatrixInvert(gParentJointGlobalMat, gParentJointGlobalMatInverse);
if(thisJointGlobalMat[3][thisSolve->axis] < thisSolve->floor)
{
// printf("-- broken plane: %f\n", thisJointGlobalMat[3][thisSolve->axis]);
if(parentJointGlobalMat[3][thisSolve->axis] < thisSolve->floor)
{
printf("Error: Constraint parent has broken the plane, this frame's plane constraint unsolvable!\n");
}
else
{
Vector parentJointAtPlane(parentJointGlobalMat[3][0], parentJointGlobalMat[3][1], parentJointGlobalMat[3][2]);
Vector parentPos(parentJointGlobalMat[3][0], parentJointGlobalMat[3][1], parentJointGlobalMat[3][2]);
Vector thisJointAtPlane(thisJointGlobalMat[3][0], thisJointGlobalMat[3][1], thisJointGlobalMat[3][2]);
Vector thisJointPos(thisJointGlobalMat[3][0], thisJointGlobalMat[3][1], thisJointGlobalMat[3][2]);
thisJointAtPlane[thisSolve->axis] = thisSolve->floor;
parentJointAtPlane[thisSolve->axis] = thisSolve->floor;
float thisJointLength = pSource->rawanim[t][thisJointIndex].pos[BONEAXIS];
float parentLengthToPlane = parentPos[thisSolve->axis] - thisSolve->floor;
float adjacent = sqrtf((thisJointLength * thisJointLength) - (parentLengthToPlane * parentLengthToPlane));
Vector parentDirection = thisJointAtPlane - parentJointAtPlane;
VectorNormalize(parentDirection);
Vector newJointPos = parentJointAtPlane + (parentDirection * adjacent);
Vector newParentDir = newJointPos - parentPos;
Vector parentUp(parentJointGlobalMat[BONEUP][0], parentJointGlobalMat[BONEUP][1], parentJointGlobalMat[BONEUP][2]);
VectorNormalize(newParentDir);
VectorNormalize(parentUp);
// Vector parentSide = newParentDir.Cross(parentUp);
Vector parentSide = parentUp.Cross(newParentDir);
VectorNormalize(parentSide);
parentUp = newParentDir.Cross(parentSide);
// parentUp = parentSide.Cross(newParentDir);
VectorNormalize(parentUp);
parentJointGlobalMat[BONEDIR][0] = newParentDir[0];
parentJointGlobalMat[BONEDIR][1] = newParentDir[1];
parentJointGlobalMat[BONEDIR][2] = newParentDir[2];
parentJointGlobalMat[BONEUP][0] = parentUp[0];
parentJointGlobalMat[BONEUP][1] = parentUp[1];
parentJointGlobalMat[BONEUP][2] = parentUp[2];
parentJointGlobalMat[BONESIDE][0] = parentSide[0];
parentJointGlobalMat[BONESIDE][1] = parentSide[1];
parentJointGlobalMat[BONESIDE][2] = parentSide[2];
M_matrix4x4_t newParentJointMat;
M_ConcatTransforms(parentJointGlobalMat, gParentJointGlobalMatInverse, newParentJointMat);
s_bone_t resultBone;
M_MatrixAngles(newParentJointMat, resultBone.rot, resultBone.pos);
pSource->rawanim[t][parentIndex].rot = resultBone.rot;
}
}
}
// swap animation back for next solve
combinedAnimation[t] = pSource->rawanim[t];
pSource->rawanim[t] = sourceAnimation[t];
}
for(int t = 0; t < sourceNumFrames; t++)
{
pTarget->rawanim[t] = combinedAnimation[t];
}
pTarget->numframes = sourceNumFrames;
#if 0
// Process motion mapping into out and return that
s_source_t *out = new s_source_t;
return out;
#else
// Just returns the start animation, to test the Save_SMD API.
return pTarget;
#endif
}
char templates[] =
"\n\
#\n\
# default template file is analogus to not specifying a template file at all\n\
#\n\
\n\
rootScaleJoint ValveBiped.Bip01_L_Foot\n\
rootScaleAmount 1.0\n\
toeFloorZ 2.7777\n\
\n\
twoJointIKSolve ValveBiped.Bip01_L_Foot\n\
reverseSolve 0\n\
extremityScale 1.0\n\
limbRootOffsetScale 1.0 1.0 0.0\n\
\n\
twoJointIKSolve ValveBiped.Bip01_R_Foot\n\
reverseSolve 0\n\
extremityScale 1.0\n\
limbRootOffsetScale 1.0 1.0 0.0\n\
\n\
oneJointPlaneConstraint ValveBiped.Bip01_L_Toe0\n\
\n\
oneJointPlaneConstraint ValveBiped.Bip01_R_Toe0\n\
\n\
twoJointIKSolve ValveBiped.Bip01_R_Hand\n\
reverseSolve 1\n\
extremityScale 1.0\n\
limbRootOffsetScale 0.0 0.0 1.0\n\
\n\
twoJointIKSolve ValveBiped.Bip01_L_Hand\n\
reverseSolve 1\n\
extremityScale 1.0\n\
limbRootOffsetScale 0.0 0.0 1.0\n\
\n\
";
void UsageAndExit()
{
MdlError( "usage: motionmapper [-quiet] [-verbose] [-templateFile filename] [-printTemplates] sourceanim.smd targetskeleton.smd output.smd\n\
\tsourceanim: should contain ref pose and animation data\n\
\ttargetsekeleton: should contain new ref pose, animation data ignored/can be absent\n\
\toutput: animation from source mapped onto target skeleton (contains new ref pose)\n\
\t-templateFile filename : specifies a template file for guiding the mapping of motion\n\
\t-printTemplate: Causes motionmapper to output the contents of an example template file, which can be used in conjunction with the -templateFile argument to create various motion effects.\n\
\n");
}
void PrintHeader()
{
vprint( 0, "Valve Software - motionmapper.exe ((c) Valve Coroporation %s)\n", __DATE__ );
vprint( 0, "--- Maps motion from one animation/skeleton onto another skeleton ---\n" );
}
/*
==============
main
==============
*/
int main (int argc, char **argv)
{
int i;
int useTemplate = 0;
char templateFileName[1024];
// Header
PrintHeader();
// Init command line stuff
CommandLine()->CreateCmdLine( argc, argv );
InstallSpewFunction();
// init math stuff
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
g_currentscale = g_defaultscale = 1.0;
g_defaultrotation = RadianEuler( 0, 0, M_PI / 2 );
// No args?
if (argc == 1)
{
UsageAndExit();
}
// Init variable
g_quiet = false;
// list template hooey
CUtlVector< CUtlSymbol > filenames;
// Get args
for (i = 1; i < argc; i++)
{
// Switches
if (argv[i][0] == '-')
{
if (!stricmp(argv[i], "-allowdebug"))
{
// Ignore, used by interface system to catch debug builds checked into release tree
continue;
}
if (!stricmp(argv[i], "-quiet"))
{
g_quiet = true;
g_verbose = false;
continue;
}
if (!stricmp(argv[i], "-verbose"))
{
g_quiet = false;
g_verbose = true;
continue;
}
if (!stricmp(argv[i], "-printTemplate"))
{
printf("%s\n", templates);
exit(0);
}
if (!stricmp(argv[i], "-templateFile"))
{
if(i + 1 < argc)
{
strcpy( templateFileName, argv[i+1]);
useTemplate = 1;
printf("Note: %s passed as template file", templateFileName);
}
else
{
printf("Error: -templateFile requires an argument, none found!");
UsageAndExit();
}
i++;
continue;
}
}
else
{
// more template stuff
CUtlSymbol sym = argv[ i ];
filenames.AddToTail( sym );
}
}
// Enough file args?
if ( filenames.Count() != 3 )
{
// misformed arguments
// otherwise generating unintended results
printf("Error: 3 file arguments required, %i found!", filenames.Count());
UsageAndExit();
}
// Filename arg indexes
int sourceanim = 0;
int targetskel = 1;
int outputanim = 2;
// Copy arg string to global variable
strcpy( g_outfile, filenames[ outputanim ].String() );
// Init filesystem hooey
CmdLib_InitFileSystem( g_outfile );
// ??
Q_FileBase( g_outfile, g_outfile, sizeof( g_outfile ) );
// Verbose stuff
if (!g_quiet)
{
vprint( 0, "%s, %s, %s, path %s\n", qdir, gamedir, g_outfile );
}
// ??
Q_DefaultExtension(g_outfile, ".smd", sizeof( g_outfile ) );
// Verbose stuff
if (!g_quiet)
{
vprint( 0, "Source animation: %s\n", filenames[ sourceanim ].String() );
vprint( 0, "Target skeleton: %s\n", filenames[ targetskel ].String() );
vprint( 0, "Creating on \"%s\"\n", g_outfile);
}
// fullpath = EXTERNAL GLOBAL!!!???
strcpy( fullpath, g_outfile );
strcpy( fullpath, ExpandPath( fullpath ) );
strcpy( fullpath, ExpandArg( fullpath ) );
// Load source and target data
s_source_t *pSource = Load_Source( filenames[sourceanim].String(), "smd", false, false );
s_source_t *pTarget = Load_Source( filenames[targetskel].String(), "smd", false, false );
//
s_template_t *pTemplate = NULL;
if(useTemplate)
{
pTemplate = Load_Template(templateFileName);
}
else
{
printf("Note: No template file specified, using defaults settings.\n");
pTemplate = New_Template();
Set_DefaultTemplate(pTemplate);
}
// Process skeleton
s_source_t *pMappedAnimation = MotionMap( pSource, pTarget, pTemplate );
// Save output (ref skeleton & animation data);
Save_SMD( fullpath, pMappedAnimation );
Q_StripExtension( filenames[outputanim].String(), outname, sizeof( outname ) );
// Verbose stuff
if (!g_quiet)
{
vprint( 0, "\nCompleted \"%s\"\n", g_outfile);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink