RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/pandatool/src/softegg/soft2Egg.c

4934 lines
170 KiB
C
Executable File
Raw Blame History

// Filename: soft2Egg.c
// Created by: masad (26Sep03)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) 2003, Disney Enterprises, Inc. All rights reserved
//
// All use of this software is subject to the terms of the Panda 3d
// Software license. You should have received a copy of this license
// along with this source code; you will also find a current copy of
// the license at http://etc.cmu.edu/panda3d/docs/license/ .
//
// To contact the maintainers of this program write to
// panda3d-general@lists.sourceforge.net .
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Includes
////////////////////////////////////////////////////////////////////
#include <SAA.h>
#ifdef __cplusplus
extern "C" {
#endif
#include "pandatoolbase.h"
int init_soft2egg(int, char **);
#if 0
// DWD includes
#include "eggBase.h"
#include <eggParametrics.h>
#include <animTable.h>
#include <linMathOutput.h>
// system includes
#include <fstream.h>
#include <strstream.h>
#include <math.h>
#include <assert.h>
#include <unistd.h>
#include <ieeefp.h>
// Performer includes
#include <Performer/pr/pfLinMath.h>
// SoftImage includes
#include <SAA.h>
#include <SI_macros.h>
static const int TEX_PER_MAT = 1;
static FILE *outStream = stdout;
//static FILE *outStream = stderr;
class soft2egg : public EggBase
{
public:
soft2egg() : EggBase("r:d:s:m:t:P:b:e:f:T:S:M:A:N:v:o:FhknpaxiucCD")
{
rsrc_path = "/ful/ufs/soft371_mips2/3D/rsrc";
database_name = NULL;
scene_name = NULL;
model_name = NULL;
animFileName = NULL;
eggFileName = NULL;
tex_path = NULL;
eggGroupName = NULL;
tex_filename = NULL;
search_prefix = NULL;
result = SI_SUCCESS;
skeleton = new EggGroup();
foundRoot = FALSE;
animRoot = NULL;
morphRoot = NULL;
geom_as_joint = 0;
make_anim = 0;
make_nurbs = 0;
make_poly = 0;
make_soft = 0;
make_morph = 1;
make_duv = 1;
make_dart = TRUE;
has_morph = 0;
make_pose = 0;
animData.is_z_up = FALSE;
nurbs_step = 1;
anim_start = -1000;
anim_end = -1000;
anim_rate = 24;
pose_frame = -1;
verbose = 0;
flatten = 0;
shift_textures = 0;
ignore_tex_offsets = 0;
use_prefix = 0;
}
virtual void Help();
virtual void Usage();
virtual void ShowOpts();
virtual boolean UseOutputSwitch() const {
return false;
}
virtual boolean
HandleGetopts(char flag, char *optarg, int &optind, int argc, char **argv);
int isNum( float );
char *GetRootName( const char * );
char *RemovePathName( const char * );
char *GetSliderName( const char * );
char *GetFullName( SAA_Scene *, SAA_Elem * );
char *GetName( SAA_Scene *, SAA_Elem * );
char *GetModelNoteInfo( SAA_Scene *, SAA_Elem * );
char *MakeTableName( const char *, int );
char *DepointellizeName( char * );
SAA_Elem *FindModelByName( char *, SAA_Scene *, SAA_Elem *, int );
char *ConvertTexture( SAA_Scene *, SAA_Elem * );
int *FindClosestTriVert( EggVertexPool *, SAA_DVector *, int );
int *MakeIndexMap( int *, int, int );
int findShapeVert( SAA_DVector, SAA_DVector *, int );
void LoadSoft();
void MakeEgg( EggGroup *, EggJoint *, AnimGroup *, SAA_Scene *, SAA_Elem * );
void MakeSurfaceCurve( SAA_Scene *, SAA_Elem *, EggGroup *,
EggNurbsSurface *&, int , SAA_SubElem *, bool );
EggNurbsCurve *MakeUVNurbsCurve( int, long *, double *, double *,
EggGroup *, char * );
EggNurbsCurve *MakeNurbsCurve( SAA_Scene *, SAA_Elem *, EggGroup *,
float [4][4], char * );
void AddKnots( perf_vector<double> &, double *, int, SAA_Boolean, int );
void MakeJoint( SAA_Scene *, EggJoint *&, AnimGroup *&, SAA_Elem *, char * );
void MakeSoftSkin( SAA_Scene *, SAA_Elem *, SAA_Elem *, int, char * );
void CleanUpSoftSkin( SAA_Scene *, SAA_Elem *, char * );
void MakeAnimTable( SAA_Scene *, SAA_Elem *, char * );
void MakeVertexOffsets( SAA_Scene *, SAA_Elem *, SAA_ModelType type,
int, int, SAA_DVector *, float (*)[4], char * );
void MakeMorphTable( SAA_Scene *, SAA_Elem *, SAA_Elem *, int, char *,
float );
void MakeLinearMorphTable( SAA_Scene *, SAA_Elem *, int, char *, float );
void MakeWeightedMorphTable( SAA_Scene *, SAA_Elem *, SAA_Elem *, int,
int, char *, float );
void MakeExpressionMorphTable( SAA_Scene *, SAA_Elem *, SAA_Elem *, int,
int, char *, float );
void MakeTexAnim( SAA_Scene *, SAA_Elem *, char * );
private:
char *rsrc_path;
char *database_name;
char *scene_name;
char *model_name;
char *eggFileName;
char *animFileName;
char *eggGroupName;
char *tex_path;
char *tex_filename;
char *search_prefix;
SI_Error result;
SAA_Scene scene;
SAA_Elem model;
SAA_Database database;
EggGroup *dart;
EggGroup *skeleton;
AnimGroup *rootAnim;
EggJoint *rootJnt;
AnimGroup *animRoot;
AnimGroup *morphRoot;
EggData animData;
int nurbs_step;
int anim_start;
int anim_end;
int anim_rate;
int pose_frame;
int verbose;
int flatten;
int shift_textures;
int ignore_tex_offsets;
int use_prefix;
bool foundRoot;
bool geom_as_joint;
bool make_anim;
bool make_nurbs;
bool make_poly;
bool make_soft;
bool make_morph;
bool make_duv;
bool make_dart;
bool has_morph;
bool make_pose;
ofstream eggFile;
ofstream animFile;
ofstream texFile;
};
////////////////////////////////////////////////////////////////////
// Function: Help
// Access: Public, Virtual
// Description: Displays the "what is this program" message, along
// with the usage message. Should be overridden in base
// classes to describe the current program.
////////////////////////////////////////////////////////////////////
void soft2egg::
Help()
{
cerr <<
"soft2egg takes a SoftImage scene or model\n"
"and outputs its contents as an egg file\n";
Usage();
}
////////////////////////////////////////////////////////////////////
// Function: Usage
// Access: Public, Virtual
// Description: Displays the usage message.
////////////////////////////////////////////////////////////////////
void soft2egg::
Usage() {
cerr << "\nUsage:\n"
<< _commandName << " [opts] (must specify -m or -s)\n\n"
<< "Options:\n";
ShowOpts();
cerr << "\n";
}
////////////////////////////////////////////////////////////////////
// Function: ShowOpts
// Access: Public, Virtual
// Description: Displays the valid options. Should be extended in
// base classes to show additional options relevant to
// the current program.
////////////////////////////////////////////////////////////////////
void soft2egg::
ShowOpts()
{
cerr <<
" -r <path> - Used to provide soft with the resource\n"
" Defaults to 'c:/Softimage/SOFT_3.9.2/3D/test'.\n"
// " Defaults to '/ful/ufs/soft371_mips2/3D/rsrc'.\n"
" -d <path> - Database path.\n"
" -s <scene> - Indicates that a scene will be converted.\n"
" -m <model> - Indicates that a model will be converted.\n"
" -t <path> - Specify path to place converted textures.\n"
" -T <name> - Specify filename for texture map listing.\n"
" -S <step> - Specify step for nurbs surface triangulation.\n"
" -M <name> - Specify model output filename. Defaults to scene name.\n"
" -A <name> - Specify anim output filename. Defaults to scene name.\n"
" -N <name> - Specify egg group name.\n"
" -k - Enable soft assignment for geometry.\n"
" -n - Specify egg NURBS representation instead of poly's.\n"
" -p - Specify egg polygon output for geometry.\n"
" -P <frame> - Specify frame number for static pose.\n"
" -b <frame> - Specify starting frame for animation (default = first).\n"
" -e <frame> - Specify ending frame for animation (default = last).\n"
" -f <fps> - Specify frame rate for animation playback.\n"
" -a - Compile animation tables if animation present.\n"
" -F - Ignore hierarchy and build a completely flat skeleton.\n"
" -v <level> - Set debug level.\n"
" -x - Shift NURBS parameters to preserve Alias textures.\n"
" -i - Ignore Soft texture uv offsets.\n"
" -u - Use Soft prefix in model names.\n"
" -c - Cancel morph conversion.\n"
" -C - Cancel duv conversion.\n"
" -D - Don't make the output model a character.\n"
" -o <prefix>- Convert only models with given prefix.\n";
EggBase::ShowOpts();
}
////////////////////////////////////////////////////////////////////
// Function: HandleGetopts
// Access: Public, Virtual
// Description:
////////////////////////////////////////////////////////////////////
boolean soft2egg::
HandleGetopts(char flag, char *optarg, int &optind, int argc, char **argv)
{
boolean okflag = true;
switch (flag)
{
case 'r': // Set the resource path for soft.
if ( strcmp( optarg, "" ) )
{
// Get the path.
rsrc_path = optarg;
fprintf( outStream, "using rsrc path %s\n", rsrc_path );
}
break;
case 'd': // Set the database path.
if ( strcmp( optarg, "" ) )
{
// Get the path.
database_name = optarg;
fprintf( outStream, "using database %s\n", database_name );
}
break;
case 's': // Check if its a scene.
if ( strcmp( optarg, "" ) )
{
// Get scene name.
scene_name = optarg;
fprintf( outStream, "loading scene %s\n", scene_name );
}
break;
case 'm': // Check if its a model.
if ( strcmp( optarg, "" ) )
{
// Get model name.
model_name = optarg;
fprintf( outStream, "loading model %s\n", model_name );
}
break;
case 't': // Get converted texture path.
if ( strcmp( optarg, "" ) )
{
// Get tex path name.
tex_path = optarg;
fprintf( outStream, "texture path: %s\n", tex_path );
}
break;
case 'T': // Specify texture list filename.
if ( strcmp( optarg, "") )
{
// Get the name.
tex_filename = optarg;
fprintf( outStream, "creating texture list file: %s\n",
tex_filename );
}
break;
case 'S': // Set NURBS step.
if ( strcmp( optarg, "" ) )
{
nurbs_step = atoi(optarg);
fprintf( outStream, "NURBS step: %d\n", nurbs_step );
}
break;
case 'M': // Set model output file name.
if ( strcmp( optarg, "" ) )
{
eggFileName = optarg;
fprintf( outStream, "Model output filename: %s\n", eggFileName );
}
break;
case 'A': // Set anim output file name.
if ( strcmp( optarg, "" ) )
{
animFileName = optarg;
fprintf( outStream, "Anim output filename: %s\n", animFileName );
}
break;
case 'N': // Set egg model name.
if ( strcmp( optarg, "" ) )
{
eggGroupName = optarg;
fprintf( outStream, "Egg group name: %s\n", eggGroupName );
}
break;
case 'o': // Set search_prefix.
if ( strcmp( optarg, "" ) )
{
search_prefix = optarg;
fprintf( outStream, "Only converting models with prefix: %s\n",
search_prefix );
}
break;
case 'h': // print help message
Help();
exit(1);
break;
case 'c': // Cancel morph animation conversion
make_morph = FALSE;
fprintf( outStream, "canceling morph conversion\n" );
break;
case 'C': // Cancel uv animation conversion
make_duv = FALSE;
fprintf( outStream, "canceling uv animation conversion\n" );
break;
case 'D': // Omit the Dart flag
make_dart = FALSE;
fprintf( outStream, "making a non-character model\n" );
break;
case 'k': // Enable soft skinning
//make_soft = TRUE;
//fprintf( outStream, "enabling soft skinning\n" );
fprintf( outStream, "-k flag no longer necessary\n" );
break;
case 'n': // Generate egg NURBS output
make_nurbs = TRUE;
fprintf( outStream, "outputting egg NURBS info\n" );
break;
case 'p': // Generate egg polygon output
make_poly = TRUE;
fprintf( outStream, "outputting egg polygon info\n" );
break;
case 'P': // Generate static pose from given frame
if ( strcmp( optarg, "" ) )
{
make_pose = TRUE;
pose_frame = atoi(optarg);
fprintf( outStream, "generating static pose from frame %d\n",
pose_frame );
}
break;
case 'a': // Compile animation tables.
make_anim = TRUE;
fprintf( outStream, "attempting to compile anim tables\n" );
break;
case 'F': // Build a flat skeleton.
flatten = TRUE;
fprintf( outStream, "building a flat skeleton!!!\n" );
break;
case 'x': // Shift NURBS parameters to preserve Alias textures.
shift_textures = TRUE;
fprintf( outStream, "shifting NURBS parameters...\n" );
break;
case 'i': // Ignore Soft uv texture offsets
ignore_tex_offsets = TRUE;
fprintf( outStream, "ignoring texture offsets...\n" );
break;
case 'u': // Use Soft prefix in model names
use_prefix = TRUE;
fprintf( outStream, "using prefix in model names...\n" );
break;
case 'v': // print debug messages.
if ( strcmp( optarg, "" ) )
{
verbose = atoi(optarg);
fprintf( outStream, "using debug level %d\n", verbose );
}
break;
case 'b': // Set animation start frame.
if ( strcmp( optarg, "" ) )
{
anim_start = atoi(optarg);
fprintf( outStream, "animation starting at frame: %d\n",
anim_start );
}
break;
case 'e': /// Set animation end frame.
if ( strcmp( optarg, "" ) )
{
anim_end = atoi(optarg);
fprintf( outStream, "animation ending at frame: %d\n", anim_end );
}
break;
case 'f': /// Set animation frame rate.
if ( strcmp( optarg, "" ) )
{
anim_rate = atoi(optarg);
fprintf( outStream, "animation frame rate: %d\n", anim_rate );
}
break;
default:
okflag = EggBase::HandleGetopts(flag, optarg, optind, argc, argv);
}
return (okflag);
}
////////////////////////////////////////////////////////////////////
// Function: isNum
// Access: Public, Virtual
// Description: Take a float and make sure it is of the body.
////////////////////////////////////////////////////////////////////
int soft2egg::
isNum( float num )
{
return( ( num < HUGE_VAL ) && finite( num ) );
}
////////////////////////////////////////////////////////////////////
// Function: GetRootName
// Access: Public
// Description: Given a string, return a copy of the string up to
// the first occurence of '-'.
////////////////////////////////////////////////////////////////////
char *soft2egg::
GetRootName( const char *name )
{
char *hyphen;
char *root;
int len;
hyphen = strchr( name, '-' );
len = hyphen-name;
if ( (hyphen != NULL) && len )
{
root = (char *)malloc(sizeof(char)*(len+1));
strncpy( root, name, len );
root[sizeof(char)*(len)] = '\0';
}
else
{
root = (char *)malloc( sizeof(char)*(strlen(name)+1));
strcpy( root, name );
}
return( root );
}
////////////////////////////////////////////////////////////////////
// Function: RemovePathName
// Access: Public
// Description: Given a string, return a copy of the string after
// the last occurence of '/
////////////////////////////////////////////////////////////////////
char *soft2egg::
RemovePathName( const char *name )
{
char *slash;
char *root;
if ( *name != NULL )
{
slash = strrchr( name, '/' );
root = (char *)malloc( sizeof(char)*(strlen(name)+1));
if ( slash != NULL )
strcpy( root, ++slash );
else
strcpy( root, name );
return( root );
}
fprintf( stderr, "Error: RemovePathName received NULL string!\n" );
return ( (char *)name );
}
////////////////////////////////////////////////////////////////////
// Function: GetSliderName
// Access: Public
// Description: Given a string, return that part of the string after
// the first occurence of '-' and before the last
// occurance of '.'
////////////////////////////////////////////////////////////////////
char *soft2egg::
GetSliderName( const char *name )
{
if ( name != NULL )
{
strstream newStr;
char *hyphen;
char *end;
hyphen = strchr( name, '-' );
// pull off stuff before first hyphen
if (hyphen != NULL)
{
newStr << ++hyphen;
end = newStr.str();
}
char *lastPeriod;
lastPeriod = strrchr( end, '.' );
// ignore stuff after last period
if ( lastPeriod != NULL )
{
*lastPeriod = '\0';
}
if ( verbose >= 1 )
fprintf( stdout, "slider name: '%s'\n", end );
return( end );
}
return( (char *)name );
}
////////////////////////////////////////////////////////////////////
// Function: GetName
// Access: Public
// Description: Given an element, return a copy of the element's
// name WITHOUT prefix.
////////////////////////////////////////////////////////////////////
char *soft2egg::
GetName( SAA_Scene *scene, SAA_Elem *element )
{
int nameLen;
char *name;
// get the name
SAA_elementGetNameLength( scene, element, &nameLen );
name = (char *)malloc(sizeof(char)*++nameLen);
SAA_elementGetName( scene, element, nameLen, name );
return name;
}
////////////////////////////////////////////////////////////////////
// Function: GetFullName
// Access: Public
// Description: Given an element, return a copy of the element's
// name complete with prefix.
////////////////////////////////////////////////////////////////////
char *soft2egg::
GetFullName( SAA_Scene *scene, SAA_Elem *element )
{
int nameLen;
char *name;
// get the name
SAA_elementGetNameLength( scene, element, &nameLen );
name = (char *)malloc(sizeof(char)*++nameLen);
SAA_elementGetName( scene, element, nameLen, name );
int prefixLen;
char *prefix;
// get the prefix
SAA_elementGetPrefixLength( scene, element, &prefixLen );
prefix = (char *)malloc(sizeof(char)*++prefixLen);
SAA_elementGetPrefix( scene, element, prefixLen, prefix );
strstream fullNameStrm;
// add 'em together
fullNameStrm << prefix << "-" << name << ends;
//free( name );
//free( prefix );
return fullNameStrm.str();
}
////////////////////////////////////////////////////////////////////
// Function: GetModelNoteInfo
// Access: Public
// Description: Given an element, return a string containing the
// contents of its MODEL NOTE entry
////////////////////////////////////////////////////////////////////
char *soft2egg::
GetModelNoteInfo( SAA_Scene *scene, SAA_Elem *model )
{
int size;
char *modelNote = NULL;
SAA_Boolean bigEndian;
SAA_elementGetUserDataSize( scene, model, "MNOT", &size );
if ( size != 0 )
{
// allocate modelNote string
modelNote = (char *)malloc(sizeof(char)*(size + 1));
// get ModelNote data from this model
SAA_elementGetUserData( scene, model, "MNOT", size,
&bigEndian, (void *)modelNote );
//strip off newline, if present
char *eol = strchr( modelNote, '\n' );
if ( eol != NULL)
*eol = '\0';
else
modelNote[size] = '\0';
if ( verbose >= 1 )
fprintf( outStream, "\nmodelNote = %s\n",
modelNote );
}
return modelNote;
}
////////////////////////////////////////////////////////////////////
// Function: MakeTableName
// Access: Public
// Description: Given a string, and a number, return a new string
// consisting of "string.number".
////////////////////////////////////////////////////////////////////
char *soft2egg::
MakeTableName( const char *name, int number )
{
strstream namestrm;
namestrm << name << "." << number << ends;
return namestrm.str();
}
////////////////////////////////////////////////////////////////////
// Function: FindModelByName
// Access: Public
// Description: Given a string, find the model in the scene
// whose name corresponds to the given string.
////////////////////////////////////////////////////////////////////
SAA_Elem *soft2egg::
FindModelByName( char *name, SAA_Scene *scene, SAA_Elem *models,
int numModels )
{
char *foundName;
SAA_Elem *foundModel = NULL;
for ( int model = 0; model < numModels; model++ )
{
foundName = GetName( scene, &models[model] );
if ( !strcmp( name, foundName ) )
{
if ( verbose >= 1 )
fprintf( outStream, "foundModel: '%s' = '%s'\n",
name, foundName );
foundModel = &models[model];
return( foundModel );
}
}
fprintf( outStream, "findModelByName: failed to find model named: '%s'\n",
name );
return ( foundModel );
}
////////////////////////////////////////////////////////////////////
// Function: DepointellizeName
// Access: Public
// Description: Given a string, return the string up to the first
// period.
////////////////////////////////////////////////////////////////////
char *soft2egg::
DepointellizeName( char *name )
{
char *endPtr;
char *newName;
newName = (char *)malloc(sizeof(char)*(strlen(name)+1));
sprintf( newName, "%s", name );
endPtr = strchr( newName, '.' );
if ( endPtr != NULL )
*endPtr = '\0';
return ( newName );
}
////////////////////////////////////////////////////////////////////
// Function: ConvertTexture
// Access: Public
// Description: Given a string, return a copy of the string without
// the leading file path, and make an rgb file of the
// same name in the tex_path directory.
////////////////////////////////////////////////////////////////////
char *soft2egg::
ConvertTexture( SAA_Scene *scene, SAA_Elem *texture )
{
char *fileName = NULL;
int fileNameLen = 0;
// get the texture's name
SAA_texture2DGetPicNameLength( scene, texture, &fileNameLen);
if ( fileNameLen )
{
fileName = (char *)malloc(sizeof(char)*++fileNameLen);
SAA_texture2DGetPicName( scene, texture, fileNameLen, fileName );
}
// make sure we are not being passed a NULL image, an empty image
// string or the default image created by egg2soft
if ( (fileName != NULL) && strlen( fileName ) && strcmp( fileName,
"/fat/people/gregw/new_test/PICTURES/default") &&
( strstr( fileName, "noIcon" ) == NULL) )
{
char *texName = NULL;
char *texNamePath = NULL;
char *tmpName = NULL;
char *fileNameExt = NULL;
// strip off path and add .rgb
tmpName = strrchr( fileName, '/' );
if ( tmpName == NULL )
tmpName = fileName;
else
tmpName++;
float transp;
// check for alpha
SAA_texture2DGetTransparency( scene, texture, &transp );
if ( transp != 0.0f ) {
texName = (char *)malloc(sizeof(char)*(strlen(tmpName)+6));
sprintf( texName, "%s.rgba", tmpName );
} else {
texName = (char *)malloc(sizeof(char)*(strlen(tmpName)+5));
sprintf( texName, "%s.rgb", tmpName );
}
fileNameExt = (char *)malloc(sizeof(char)*(strlen(fileName)+5));
sprintf( fileNameExt, "%s.pic", fileName );
if ( verbose >= 1 )
fprintf( outStream, "Looking for texture file: '%s'\n", fileNameExt );
// try to make conversion of file
int found_file = ( access( fileNameExt, F_OK ) == 0);
if ( found_file )
{
if ( tex_path )
{
texNamePath = (char *)malloc(sizeof(char)*(strlen(tex_path) +
strlen(texName) + 2));
sprintf( texNamePath, "%s/%s", tex_path, texName );
if ( texFile )
texFile << texNamePath << ": " << fileNameExt << "\n";
// make sure conversion doesn't already exist
if ( (access( texNamePath, F_OK ) != 0) && !texFile )
{
char *command = (char *)malloc(sizeof(char)*
(strlen(fileNameExt) + strlen(texNamePath) + 20));
sprintf( command, "image-resize -1 %s %s",
fileNameExt, texNamePath );
if ( verbose >=1 )
fprintf( outStream, "executing %s\n", command );
system( command );
//free( command );
}
else
if ( verbose >=1 )
fprintf( outStream, "%s already exists!\n", texNamePath );
}
else
{
if ( verbose >= 1 )
{
fprintf( outStream, "Warning: No texture path defined" );
fprintf( outStream, " - No automatic conversion performed\n" );
}
}
}
else
{
fprintf( outStream, "Warning: Couldn't find texture file: %s\n",
fileNameExt );
}
//free( fileNameExt );
if (tex_path)
return( texNamePath );
else
return( texName );
}
else
{
fprintf( outStream, "Warning: ConvertTexture received NULL fileName\n" );
return( NULL );
}
}
////////////////////////////////////////////////////////////////////
// Function: FindClosestTriVert
// Access: Public
// Description: Given an egg vertex pool, map each vertex therein to
// a vertex within an array of SAA model vertices of
// size numVert. Mapping is done by closest proximity.
////////////////////////////////////////////////////////////////////
int *soft2egg::
FindClosestTriVert( EggVertexPool *vpool, SAA_DVector *vertices, int numVert )
{
int *vertMap = NULL;
int vpoolSize = vpool->NumVertices();
int i,j;
float thisDist;
float closestDist;
int closest;
vertMap = (int *)malloc(sizeof(int)*vpoolSize);
// for each vertex in vpool
for ( i = 0; i < vpoolSize; i++ )
{
// find closest model vertex
for ( j = 0; j < numVert-1; j++ )
{
// calculate distance
thisDist = sqrtf(
powf( vpool->Vertex(i)->position[0] - vertices[j].x , 2 ) +
powf( vpool->Vertex(i)->position[1] - vertices[j].y , 2 ) +
powf( vpool->Vertex(i)->position[2] - vertices[j].z , 2 ) );
// remember this if its the closest so far
if ( !j || ( thisDist < closestDist ) )
{
closest = j;
closestDist = thisDist;
}
}
vertMap[i] = closest;
if ( verbose >= 2 )
{
fprintf( outStream, "mapping v %d of %d:( %f, %f, %f )\n", i,
vpoolSize, vpool->Vertex(i)->position[0],
vpool->Vertex(i)->position[1],
vpool->Vertex(i)->position[2] );
fprintf( outStream, "to cv %d of %d:( %f, %f, %f )\tdelta = %f\n",
closest, numVert-1, vertices[closest].x, vertices[closest].y,
vertices[closest].z, closestDist );
}
}
return( vertMap );
}
////////////////////////////////////////////////////////////////////
// Function: MakeIndexMap
// Access: Public
// Description: Given an array of indices that is a map from one
// set of vertices to another, return an array that
// performs the reverse mapping of the indices array
////////////////////////////////////////////////////////////////////
int *soft2egg::
MakeIndexMap( int *indices, int numIndices, int mapSize )
{
int i, j;
// allocate map array
int *map = (int *)malloc(sizeof(int)*mapSize);
if ( map != NULL )
{
for ( i = 0; i < mapSize; i++ )
{
j = 0;
int found = 0;
while( j < numIndices )
{
if ( indices[j] == i )
{
map[i] = j;
if ( verbose >= 2 )
fprintf( outStream, "map[%d] = %d\n", i, map[i] );
found = 1;
break;
}
j++;
}
if ( !found)
{
if ( verbose >= 2 )
fprintf( outStream, "Warning: orphan vertex (%d)\n", i );
// default to -1 for now
map[i] = -1;
}
}
}
else
fprintf( outStream, "Not enough Memory for index Map...\n");
return( map );
}
////////////////////////////////////////////////////////////////////
// Function: findShapeVert
// Access: Public
// Description: given a vertex, find its corresponding shape vertex
// and return its index.
////////////////////////////////////////////////////////////////////
int soft2egg::
findShapeVert( SAA_DVector vertex, SAA_DVector *vertices, int numVert )
{
int i;
int found = 0;
for ( i = 0; i < numVert && !found ; i++ )
{
if ( ( vertex.x == vertices[i].x ) &&
( vertex.y == vertices[i].y ) &&
( vertex.z == vertices[i].z ) )
{
found = 1;
if ( verbose >= 2)
fprintf( outStream, "found shape vert at index %d\n", i );
}
}
if (!found )
i = -1;
else
i--;
return( i );
}
////////////////////////////////////////////////////////////////////
// Function: LoadSoft
// Access: Public
// Description: Open the SI database and grab the scene & model info
////////////////////////////////////////////////////////////////////
void soft2egg::
LoadSoft()
{
int i;
if ( (scene_name == NULL && model_name == NULL) || database_name == NULL )
{
Usage();
exit( 1 );
}
if ((result = SAA_Init(rsrc_path, FALSE)) != SI_SUCCESS)
{
fprintf( outStream, "Error: Couldn't get resource path!\n");
exit( 1 );
}
if ((result = SAA_databaseLoad(database_name, &database)) != SI_SUCCESS)
{
fprintf( outStream, "Error: Couldn't load database!\n");
exit( 1 );
}
if ((result = SAA_sceneGetCurrent(&scene)) == SI_SUCCESS)
{
// load scene if present
if ( scene_name != NULL )
{
SAA_sceneLoad( &database, scene_name, &scene );
// if no egg filename specified, make up a name
if ( eggFileName == NULL )
{
eggFileName = (char *)malloc(sizeof(char)*
(strlen( scene_name ) + 14 ));
sprintf( eggFileName, "%s", DepointellizeName(scene_name) );
if ( make_nurbs )
strcat( eggFileName, "-nurb" );
strcat( eggFileName, "-mod.egg" );
}
// open an output file for the geometry if necessary
if ( make_poly || make_nurbs )
{
unlink( eggFileName );
eggFile.open( eggFileName, ios::out, 0666 );
if ( !eggFile )
{
fprintf( outStream, "Couldn't open output file: %s\n",
eggFileName );
exit( 1 );
}
}
// open an output file for texture list if specified
if ( tex_filename != NULL )
{
unlink( tex_filename );
texFile.open( tex_filename, ios::out, 0666 );
if ( !texFile )
{
fprintf( outStream, "Couldn't open output file: %s\n",
tex_filename );
exit( 1 );
}
}
if ( SAA_updatelistGet( &scene ) == SI_SUCCESS )
{
float time;
fprintf( outStream, "setting Scene to frame %d...\n", pose_frame );
//SAA_sceneSetPlayCtrlCurrentFrame( &scene, pose_frame );
SAA_frame2Seconds( &scene, pose_frame, &time );
SAA_updatelistEvalScene( &scene, time );
sginap( 100 );
SAA_updatelistEvalScene( &scene, time );
if ( make_pose )
SAA_sceneFreeze( &scene );
}
int numModels;
SAA_Elem *models;
SAA_sceneGetNbModels( &scene, &numModels );
fprintf( outStream, "Scene has %d model(s)...\n", numModels );
if ( numModels )
{
// allocate array of models
models = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numModels);
if ( models != NULL )
{
char *rootName = GetRootName( eggFileName );
if ( eggGroupName == NULL )
dart = _data.CreateGroup( NULL, rootName );
else
dart = _data.CreateGroup( NULL, eggGroupName );
if (make_dart)
dart->flags |= EF_DART;
AnimGroup *rootTable;
rootTable = animData.CreateTable( NULL, eggFileName );
if ( eggGroupName == NULL )
animRoot = animData.CreateBundle( rootTable, rootName );
else
animRoot = animData.CreateBundle( rootTable,
eggGroupName );
// propagate commet to anim data
animData.root_group.children.push_front(
new EggComment( _commandLine ) );
if ( verbose >= 1 )
fprintf( outStream, "made animRoot: %s\n", rootName );
SAA_sceneGetModels( &scene, numModels, models );
for ( i = 0; i < numModels; i++ )
{
int level;
SAA_elementGetHierarchyLevel( &scene, &models[i], &level );
if ( !level )
{
if ( verbose >= 1 )
fprintf( outStream,
"\negging scene model[%d]\n", i );
MakeEgg( dart, NULL, NULL, &scene, &models[i] );
}
}
if ( make_poly || make_nurbs )
{
// generate soft skinning assignments if desired
//
//disabled 1/1/99 to streamline joint assignments.
// all joint assignments now done here. Hard & Soft.
//if ( make_soft)
{
char *name;
char *fullname;
SAA_Boolean isSkeleton;
// search through models and look for skeleton parts
for ( i = 0; i < numModels; i++ )
{
SAA_modelIsSkeleton( &scene, &models[i], &isSkeleton );
// get fullname for splitting files, but
// only use it in file if requested
fullname = GetFullName( &scene, &models[i] );
if ( use_prefix )
name = fullname;
else
name = GetName( &scene, &models[i] );
// split
if ( strstr( fullname, search_prefix ) != NULL )
{
// for every skel part: get soft skin info
if ( isSkeleton )
MakeSoftSkin( &scene, &models[i], models,
numModels, name );
}
//free( name );
}
// make sure all vertices were assigned
// via soft skinning - if not hard assign them
for ( i = 0; i < numModels; i++ )
{
// get fullname for splitting files, but
// only use it in file if requested
fullname = GetFullName( &scene, &models[i] );
if ( use_prefix )
name = fullname;
else
name = GetName( &scene, &models[i] );
// split
if ( strstr( fullname, search_prefix ) != NULL )
CleanUpSoftSkin( &scene, &models[i], name );
//free( name );
}
}
// put the skeleton data into the egg data
dart->StealChildren( *skeleton );
// make sure all elements have unique names
_data.UniquifyNames();
// write out the geometry data if requested
//if ( make_poly || make_nurbs )
//{
eggFile << _data << "\n";
fprintf( outStream, "\nwriting out %s...\n", eggFileName );
eggFile.close();
}
// close texture list file if opened
if ( texFile )
texFile.close();
// generate animation data if desired
if ( make_anim )
{
if ( animFileName == NULL )
{
animFileName = (char *)malloc(sizeof(char)*
(strlen(scene_name)+ 10 ));
sprintf( animFileName, "%s", DepointellizeName(scene_name) );
strcat( animFileName, "-chan.egg" );
}
unlink( animFileName );
animFile.open( animFileName, ios::out, 0666 );
if ( !animFile )
{
fprintf( outStream, "Couldn't open output file: %s\n",
animFileName );
exit( 1 );
}
int frame;
//int frameStep;
float time;
// get all the animation frame info if not specified
// on the command line
if (anim_start == -1000)
SAA_sceneGetPlayCtrlStartFrame( &scene, &anim_start );
if (anim_end == -1000)
SAA_sceneGetPlayCtrlEndFrame( &scene, &anim_end );
//SAA_sceneGetPlayCtrlFrameStep( &scene, &frameStep );
fprintf( outStream, "\nframeStart = %d\n", anim_start );
fprintf( outStream, "frameEnd = %d\n", anim_end );
//fprintf( outStream, "frameStep = %d\n", frameStep );
// start at first frame and go to last
for ( frame = anim_start; frame <= anim_end;
frame += 1)
{
SAA_frame2Seconds( &scene, frame, &time );
SAA_updatelistEvalScene( &scene, time );
sginap( 100 );
SAA_updatelistEvalScene( &scene, time );
fprintf( outStream, "\n> animating frame %d\n", frame );
// for each model
for ( i = 0; i < numModels; i++ )
{
char *name;
char *fullname;
SAA_Boolean isSkeleton;
SAA_ModelType type;
SAA_modelIsSkeleton( &scene, &models[i], &isSkeleton );
// get fullname for splitting files, but
// only use it in file if requested
fullname = GetFullName( &scene, &models[i] );
if ( use_prefix )
name = fullname;
else
name = GetName( &scene, &models[i] );
// split
if ( strstr( fullname, search_prefix ) != NULL )
{
// make the morph table for this critter
if ( make_morph )
{
MakeMorphTable( &scene, &models[i], models,
numModels, name, time );
}
}
// find out what type of node we're dealing with
result = SAA_modelGetType( &scene, &models[i], &type );
int size;
// check for uv texture animation
SAA_elementGetUserDataSize( &scene, &models[i],
"TEX_OFFSETS", &size );
// if so, update for this frame if desired
if ( ( size != 0 ) && make_duv )
MakeTexAnim( &scene, &models[i], name );
// if we have a skeleton or something that acts
// like one - build anim tables
if ( isSkeleton ||
( strstr( name, "joint") != NULL ) )
MakeAnimTable( &scene, &models[i], name );
//free( name );
}
if ( verbose >= 1 )
fprintf( outStream, "\n" );
}
animFile << animData << "\n";
fprintf( outStream, "\nwriting out %s...\n", animFileName );
animFile.close();
}
//free( models );
}
else
fprintf( outStream, "Error: Not enough Memory for models...\n");
}
}
// otherwise try to load a model
else if ( model_name != NULL )
{
if ( eggFileName == NULL )
{
eggFileName =
(char *)malloc(sizeof(char)*(strlen( model_name )+13));
sprintf( eggFileName, "%s", DepointellizeName( model_name ) );
if ( make_nurbs )
strcat( eggFileName, "-nurb" );
strcat( eggFileName, "-mod.egg" );
}
eggFile.open( eggFileName );
if ( !eggFile )
{
fprintf( outStream, "Couldn't open output file: %s\n",
eggFileName );
exit( 1 );
}
if ((result =
SAA_elementLoad(&database, &scene, model_name, &model))
== SI_SUCCESS)
{
fprintf( outStream, "Loading single model...\n");
MakeEgg( NULL, NULL, NULL, &scene, &model );
}
eggFile << _data << "\n";
}
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeEgg
// Access: Public
// Description: Make egg geometry from a given model. This include
// textures, tex coords, colors, normals, and joints.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeEgg( EggGroup *parent, EggJoint *lastJoint, AnimGroup *lastAnim,
SAA_Scene *scene, SAA_Elem *model )
{
char *name;
char *fullname;
SAA_ModelType type;
int id = 0;
int numShapes;
int numTri;
int numVert;
int numTexLoc = 0;
int numTexGlb = 0;
int i, j;
float matrix[4][4];
float *uScale = NULL;
float *vScale = NULL;
float *uOffset = NULL;
float *vOffset = NULL;
SAA_Boolean uv_swap = FALSE;
void *relinfo;
SAA_SubElem *triangles = NULL;
SAA_Elem *materials = NULL;
SAA_SubElem *cvertices = NULL;
SAA_DVector *cvertPos = NULL;
SAA_DVector *vertices = NULL;
SAA_DVector *normals = NULL;
int *indices = NULL;
int *indexMap = NULL;
int *numTexTri = NULL;
SAA_Elem *textures = NULL;
char **texNameArray;
float *uCoords = NULL;
float *vCoords = NULL;
SAA_GeomType gtype = SAA_GEOM_ORIGINAL;
SAA_Boolean visible;
/////////////////////////////////////////////////
// find out what type of node we're dealing with
/////////////////////////////////////////////////
result = SAA_modelGetType( scene, model, &type );
if ( verbose >= 1 )
{
if ( type == SAA_MNILL )
fprintf( outStream, "encountered null\n");
else if ( type == SAA_MPTCH )
fprintf( outStream, "encountered patch\n" );
else if ( type == SAA_MFACE )
fprintf( outStream, "encountered face\n" );
else if ( type == SAA_MSMSH )
fprintf( outStream, "encountered mesh\n" );
else if ( type == SAA_MJNT )
fprintf( outStream, "encountered joint\n" );
else if ( type == SAA_MSPLN )
fprintf( outStream, "encountered spline\n" );
else if ( type == SAA_MMETA )
fprintf( outStream, "encountered meta element\n" );
else if ( type == SAA_MBALL )
fprintf( outStream, "encountered metaball\n" );
else if ( type == SAA_MNCRV )
fprintf( outStream, "encountered nurb curve\n" );
else if ( type == SAA_MNSRF )
fprintf( outStream, "encountered nurbs surf\n" );
else
fprintf( outStream, "encountered unknown type: %d\n", type );
}
/////////////////////////////
// Get the name of the model
/////////////////////////////
// Get the FULL name of the model
fullname = GetFullName( scene, model );
if ( use_prefix )
{
// Get the FULL name of the trim curve
name = fullname;
}
else
{
// Get the name of the trim curve
name = GetName( scene, model );
}
if ( verbose >= 1 )
fprintf( outStream, "element name <%s>\n", name );
fflush( outStream );
// get the model's matrix
SAA_modelGetMatrix( scene, model, SAA_COORDSYS_GLOBAL, matrix );
if ( verbose >= 2 )
{
fprintf( outStream, "model matrix = %f %f %f %f\n", matrix[0][0],
matrix[0][1], matrix[0][2], matrix[0][3] );
fprintf( outStream, "model matrix = %f %f %f %f\n", matrix[1][0],
matrix[1][1], matrix[1][2], matrix[1][3] );
fprintf( outStream, "model matrix = %f %f %f %f\n", matrix[2][0],
matrix[2][1], matrix[2][2], matrix[2][3] );
fprintf( outStream, "model matrix = %f %f %f %f\n", matrix[3][0],
matrix[3][1], matrix[3][2], matrix[3][3] );
}
///////////////////////////////////////////////////////////////////////
// check to see if this is a branch we don't want to descend - this
// will prevent creating geometry for animation control structures
///////////////////////////////////////////////////////////////////////
if ( (strstr( name, "con-" ) == NULL) &&
(strstr( name, "con_" ) == NULL) &&
(strstr( name, "fly_" ) == NULL) &&
(strstr( name, "fly-" ) == NULL) &&
(strstr( name, "camRIG" ) == NULL) &&
(strstr( name, "bars" ) == NULL) &&
// split
(strstr( fullname, search_prefix ) != NULL) )
{
// if making a pose - get deformed geometry
if ( make_pose )
gtype = SAA_GEOM_DEFORMED;
// Get the number of key shapes
SAA_modelGetNbShapes( scene, model, &numShapes );
if ( verbose >= 1 )
fprintf( outStream, "MakeEgg: num shapes: %d\n", numShapes);
///////////////////////////////////////////////////////////////////////
// if multiple key shapes exist create table entries for each
///////////////////////////////////////////////////////////////////////
if ( (numShapes > 0) && make_morph )
{
has_morph = 1;
// make sure root morph table exists
if ( morphRoot == NULL )
morphRoot = animData.CreateTable( animRoot, "morph" );
char *tableName;
// create morph table entry for each key shape
// (start at second shape - as first is the original geometry)
for ( i = 1; i < numShapes; i++ )
{
tableName = MakeTableName( name, i );
SAnimTable *table = new SAnimTable( );
table->name = tableName;
table->fps = anim_rate;
morphRoot->children.push_back( table );
if ( verbose >= 1 )
fprintf( outStream, "created table named: '%s'\n", tableName );
}
//free( tableName );
}
SAA_modelGetNodeVisibility( scene, model, &visible );
if ( verbose >= 1 )
fprintf( outStream, "model visibility: %d\n", visible );
///////////////////////////////////////////////////////////////////////
// Only create egg polygon data if: the node is visible, and its not
// a NULL or a Joint, and we're outputing polys (or if we are outputing
// NURBS and the model is a poly mesh or a face)
///////////////////////////////////////////////////////////////////////
if ( visible &&
(type != SAA_MNILL) &&
(type != SAA_MJNT) &&
((make_poly ||
(make_nurbs && ((type == SAA_MSMSH) || (type == SAA_MFACE )) ))
|| (!make_poly && !make_nurbs && make_duv &&
((type == SAA_MSMSH) || (type == SAA_MFACE )) ))
)
{
// If the model is a NURBS in soft, set its step before tesselating
if ( type == SAA_MNSRF )
SAA_nurbsSurfaceSetStep( scene, model, nurbs_step, nurbs_step );
// If the model is a PATCH in soft, set its step before tesselating
else if ( type == SAA_MPTCH )
SAA_patchSetStep( scene, model, nurbs_step, nurbs_step );
// Get the number of triangles
result = SAA_modelGetNbTriangles( scene, model, gtype, id, &numTri);
if ( verbose >= 1 )
fprintf( outStream, "triangles: %d\n", numTri);
if ( result != SI_SUCCESS )
{
if ( verbose >= 1 ) {
fprintf( outStream,
"Error: couldn't get number of triangles!\n" );
fprintf( outStream, "\tbailing on model: '%s'\n", name );
}
return;
}
// check to see if surface is also skeleton...
SAA_Boolean isSkeleton = FALSE;
SAA_modelIsSkeleton( scene, model, &isSkeleton );
// check to see if this surface is used as a skeleton
// or is animated via constraint only ( these nodes are
// tagged by the animator with the keyword "joint"
// somewhere in the nodes name)
if ( isSkeleton || (strstr( name, "joint" ) != NULL) )
{
if ( verbose >= 1 )
fprintf( outStream, "animating Polys as joint!!!\n" );
MakeJoint( scene, lastJoint, lastAnim, model, name );
}
// model is not a null and has no triangles!
if ( !numTri )
{
if ( verbose >= 1 )
fprintf( outStream, "no triangles!\n");
}
else
{
// allocate array of triangles
triangles = (SAA_SubElem *)malloc(sizeof(SAA_SubElem)*numTri);
if ( triangles != NULL )
{
// triangulate model and read the triangles into array
SAA_modelGetTriangles( scene, model, gtype, id, numTri, triangles );
}
else
fprintf( outStream, "Not enough Memory for triangles...\n");
// allocate array of materials
materials = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numTri);
if ( materials != NULL )
{
// read each triangle's material into array
SAA_triangleGetMaterials( scene, model, numTri, triangles,
materials );
}
else
fprintf( outStream, "Not enough Memory for materials...\n");
// allocate array of textures per triangle
numTexTri = (int *)malloc(sizeof(int)*numTri);
// find out how many local textures per triangle
for ( i = 0; i < numTri; i++ )
{
result = SAA_materialRelationGetT2DLocNbElements( scene,
&materials[i], FALSE, &relinfo, &numTexTri[i] );
// polytex
if ( result == SI_SUCCESS )
numTexLoc += numTexTri[i];
}
// don't need this anymore...
//free( numTexTri );
// get local textures if present
if ( numTexLoc )
{
// ASSUME only one texture per material
textures = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numTri);
for ( i = 0; i < numTri; i++ )
{
// and read all referenced local textures into array
SAA_materialRelationGetT2DLocElements( scene, &materials[i],
TEX_PER_MAT , &textures[i] );
}
if ( verbose >= 1 )
fprintf( outStream, "numTexLoc = %d\n", numTexLoc);
}
// if no local textures, try to get global textures
else
{
SAA_modelRelationGetT2DGlbNbElements( scene, model,
FALSE, &relinfo, &numTexGlb );
if ( numTexGlb )
{
// ASSUME only one texture per model
textures = (SAA_Elem *)malloc(sizeof(SAA_Elem));
// get the referenced texture
SAA_modelRelationGetT2DGlbElements( scene, model,
TEX_PER_MAT, textures );
if ( verbose >= 1 )
fprintf( outStream, "numTexGlb = %d\n", numTexGlb);
}
}
// allocate array of control vertices
cvertices = (SAA_SubElem *)malloc(sizeof(SAA_SubElem)*numTri*3);
if ( cvertices != NULL )
{
// read each triangle's control vertices into array
SAA_triangleGetCtrlVertices( scene, model, gtype, id,
numTri, triangles, cvertices );
if ( verbose >= 2 )
{
cvertPos = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numTri*3);
SAA_ctrlVertexGetPositions( scene, model, numTri*3,
cvertices, cvertPos);
for ( i=0; i < numTri*3; i++ )
{
fprintf( outStream, "cvert[%d] = %f %f %f %f\n", i,
cvertPos[i].x, cvertPos[i].y, cvertPos[i].z,
cvertPos[i].w );
}
}
}
else
fprintf( outStream, "Not enough Memory for control vertices...\n");
// allocate array of control vertex indices
// this array maps from the redundant cvertices array into
// the unique vertices array (cvertices->vertices)
indices = (int *)malloc(sizeof(int)*numTri*3);
if ( indices != NULL )
{
for ( i=0; i < numTri*3; i++ )
indices[i] = 0;
SAA_ctrlVertexGetIndices( scene, model, numTri*3,
cvertices, indices );
if ( verbose >= 2 )
for ( i=0; i < numTri*3; i++ )
fprintf( outStream, "indices[%d] = %d\n", i, indices[i] );
}
else
fprintf( outStream, "Not enough Memory for indices...\n");
// get number of UNIQUE vertices in model
SAA_modelGetNbTriVertices( scene, model, &numVert );
if ( verbose >= 2 )
fprintf( outStream, "num unique verts = %d\n", numVert );
//allocate array of vertices
vertices = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numVert);
// get the UNIQUE vertices of all triangles in model
SAA_modelGetTriVertices( scene, model, numVert, vertices );
if ( verbose >= 2 )
{
for ( i=0; i < numVert; i++ )
{
fprintf( outStream, "vertices[%d] = %f ", i, vertices[i].x );
fprintf( outStream, "%f %f %f\n", vertices[i].y,
vertices[i].z, vertices[i].w );
}
}
// allocate indexMap array
// we contruct this array to map from the unique vertices
// array to the redundant cvertices array - it will save
// us from doing repetitive searches later
indexMap = MakeIndexMap( indices, numTri*3, numVert );
// allocate array of normals
normals = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numTri*3);
if ( normals != NULL )
{
// read each control vertex's normals into an array
SAA_ctrlVertexGetNormals( scene, model, numTri*3,
cvertices, normals );
}
else
fprintf( outStream, "Not enough Memory for normals...\n");
if ( verbose >= 2 )
{
for ( i=0; i<numTri*3; i++ )
fprintf( outStream, "normals[%d] = %f %f %f %f\n", i,
normals[i].x, normals[i].y, normals[i].z, normals[i].w );
}
int uRepeat, vRepeat;
// make sure we have textures before we get t-coords
if ( numTexLoc )
{
// allocate arrays for u & v coords
uCoords = (float *)malloc(sizeof(float)*numTri*numTexLoc*3);
vCoords = (float *)malloc(sizeof(float)*numTri*numTexLoc*3);
// read the u & v coords into the arrays
if ( uCoords != NULL && vCoords != NULL)
{
for ( i = 0; i < numTri*numTexLoc*3; i++ )
uCoords[i] = vCoords[i] = 0.0f;
SAA_ctrlVertexGetUVTxtCoords( scene, model, numTri*3,
cvertices, numTexLoc*3, uCoords, vCoords );
}
else
fprintf( outStream, "Not enough Memory for texture coords...\n");
if ( verbose >= 2 )
{
for ( i=0; i<numTexLoc*3; i++ )
fprintf( outStream, "texcoords[%d] = ( %f , %f )\n", i,
uCoords[i], vCoords[i] );
}
// allocate arrays of texture info
uScale = ( float *)malloc(sizeof(float)*numTri);
vScale = ( float *)malloc(sizeof(float)*numTri);
uOffset = ( float *)malloc(sizeof(float)*numTri);
vOffset = ( float *)malloc(sizeof(float)*numTri);
texNameArray = ( char **)malloc(sizeof(char *)*numTri);
for ( i = 0; i < numTri; i++ )
{
// initialize the array value
texNameArray[i] = NULL;
SAA_Boolean valid = FALSE;
// check to see if texture is present
result = SAA_elementIsValid( scene, &textures[i], &valid );
if ( result != SI_SUCCESS )
fprintf( outStream, "SAA_elementIsValid failed!!!!\n" );
// texture present - get the name and uv info
if ( valid )
{
texNameArray[i] = ConvertTexture( scene, &textures[i] );
if ( verbose >= 2 )
fprintf( outStream, " tritex[%d] named: %s\n", i,
texNameArray[i] );
SAA_texture2DGetUVSwap( scene, &textures[i], &uv_swap );
if ( verbose >= 2 )
if ( uv_swap == TRUE )
fprintf( outStream, " swapping u and v...\n" );
SAA_texture2DGetUScale( scene, &textures[i], &uScale[i] );
SAA_texture2DGetVScale( scene, &textures[i], &vScale[i] );
SAA_texture2DGetUOffset( scene, &textures[i], &uOffset[i] );
SAA_texture2DGetVOffset( scene, &textures[i], &vOffset[i] );
if ( verbose >= 2 )
{
fprintf(outStream, "tritex[%d] uScale: %f vScale: %f\n", i, uScale[i], vScale[i] );
fprintf(outStream, " uOffset: %f vOffset: %f\n",
uOffset[i], vOffset[i] );
}
SAA_texture2DGetRepeats( scene, &textures[i], &uRepeat,
&vRepeat );
if ( verbose >= 2 )
{
fprintf(outStream, "uRepeat = %d, vRepeat = %d\n",
uRepeat, vRepeat );
}
}
else
{
if ( verbose >= 2 )
{
fprintf( outStream, "Invalid texture...\n");
fprintf( outStream, " tritex[%d] named: (null)\n", i );
}
}
}
//debug
//for ( i = 0; i < numTri; i++ )
//{
//if ( texNameArray[i] != NULL )
//fprintf( outStream, " tritex[%d] named: %s\n", i,
//texNameArray[i] );
//else
//fprintf( outStream, " tritex[%d] named: (null)\n", i );
//}
}
// make sure we have textures before we get t-coords
else if ( numTexGlb )
{
SAA_Boolean valid;
// check to see if texture is present
SAA_elementIsValid( scene, textures, &valid );
// texture present - get the name and uv info
if ( valid )
{
SAA_texture2DGetUVSwap( scene, textures, &uv_swap );
if ( verbose >= 1 )
if ( uv_swap == TRUE )
fprintf( outStream, " swapping u and v...\n" );
// allocate arrays for u & v coords
uCoords = (float *)malloc(sizeof(float)*numTri*numTexGlb*3);
vCoords = (float *)malloc(sizeof(float)*numTri*numTexGlb*3);
for ( i = 0; i < numTri*numTexGlb*3; i++ )
{
uCoords[i] = vCoords[i] = 0.0f;
}
// read the u & v coords into the arrays
if ( uCoords != NULL && vCoords != NULL)
{
SAA_triCtrlVertexGetGlobalUVTxtCoords( scene, model,
numTri*3, cvertices, numTexGlb, textures,
uCoords, vCoords );
}
else
fprintf( outStream, "Not enough Memory for texture coords...\n");
if ( verbose >= 2 )
{
for ( i=0; i<numTri*numTexGlb*3; i++ )
fprintf( outStream, "texcoords[%d] = ( %f , %f )\n", i,
uCoords[i], vCoords[i] );
}
texNameArray = ( char **)malloc(sizeof(char *));
*texNameArray = ConvertTexture( scene, textures );
if ( verbose >= 1 )
fprintf( outStream, " global tex named: %s\n",
texNameArray );
// allocate arrays of texture info
uScale = ( float *)malloc(sizeof(float));
vScale = ( float *)malloc(sizeof(float));
uOffset = ( float *)malloc(sizeof(float));
vOffset = ( float *)malloc(sizeof(float));
SAA_texture2DGetUScale( scene, textures, uScale );
SAA_texture2DGetVScale( scene, textures, vScale );
SAA_texture2DGetUOffset( scene, textures, uOffset );
SAA_texture2DGetVOffset( scene, textures, vOffset );
if ( verbose >= 1 )
{
fprintf( outStream, " global tex uScale: %f vScale: %f\n",
*uScale, *vScale );
fprintf( outStream, " uOffset: %f vOffset: %f\n",
*uOffset, *vOffset );
}
SAA_texture2DGetRepeats( scene, textures, &uRepeat,
&vRepeat );
if ( verbose >= 2 )
{
fprintf(outStream, "uRepeat = %d, vRepeat = %d\n",
uRepeat, vRepeat );
}
}
else fprintf( outStream, "Invalid texture...\n");
}
// make the egg vertex pool
EggVertexPool *pool = _data.CreateVertexPool( parent, name );
for ( i = 0; i < numVert; i++ )
{
pfVec3 eggVert;
pfVec3 eggNorm;
//convert to global coords
SAA_DVector local = vertices[i];
SAA_DVector global;
_VCT_X_MAT( global, local, matrix );
// set vertices array to reflect global coords
//vertices[i].x = global.x;
//vertices[i].y = global.y;
//vertices[i].z = global.z;
//eggVert.set( vertices[i].x, vertices[i].y, vertices[i].z );
// we'll preserve original verts for now
eggVert.set( global.x, global.y, global.z );
local = normals[indexMap[i]];
_VCT_X_MAT( global, local, matrix );
eggNorm.set( global.x, global.y, global.z );
eggNorm.normalize();
pool->AddVertex( eggVert, i );
pool->Vertex(i)->attrib.SetNormal( eggNorm );
// translate local uv's to global and add to vertex pool
if ( numTexLoc && (uCoords != NULL && vCoords !=NULL ))
{
float u, v;
if ( ignore_tex_offsets ) {
u = uCoords[indexMap[i]];
v = 1.0f - vCoords[indexMap[i]];
} else {
u = (uCoords[indexMap[i]] - uOffset[indexMap[i]/3]) /
uScale[indexMap[i]/3];
v = 1.0f - ((vCoords[indexMap[i]] - vOffset[indexMap[i]/3]) /
vScale[indexMap[i]/3]);
}
if ( isNum(u) && isNum(v) )
{
if ( uv_swap == TRUE )
pool->Vertex(i)->attrib.SetUV( v, u );
else
pool->Vertex(i)->attrib.SetUV( u, v );
}
}
else if ( numTexGlb && (uCoords != NULL && vCoords !=NULL ) )
{
float u, v;
if ( ignore_tex_offsets ) {
u = uCoords[indexMap[i]];
v = 1.0f - vCoords[indexMap[i]];
} else {
u = (uCoords[indexMap[i]] - *uOffset) / *uScale;
v = 1.0f - (( vCoords[indexMap[i]] - *vOffset ) / *vScale);
}
if ( isNum(u) && isNum(v) )
{
if ( uv_swap == TRUE )
pool->Vertex(i)->attrib.SetUV( v, u );
else
pool->Vertex(i)->attrib.SetUV( u, v );
}
}
// if we've encountered textures and we desire duv anims
if (( numTexLoc || numTexGlb ) && make_duv )
{
int numExp;
SAA_Elem *tex;
// grab the current texture
if ( numTexLoc )
tex = &textures[0];
else
tex = textures;
// find how many expressions for this shape
SAA_elementGetNbExpressions( scene, tex, NULL, FALSE,
&numExp );
// if it has expressions we'll assume its animated
if ( numExp )
{
// if animated object make base duv's, animtables
// for the duv's and store the original offsets
strstream uName, vName;
// create duv target names
uName << name << ".u" << ends;
vName << name << ".v" << ends;
// only create tables and store offsets
// on a per model basis (not per vertex)
if ( !i )
{
// make sure root morph table exists
if ( morphRoot == NULL )
morphRoot = animData.CreateTable( animRoot,
"morph" );
// create morph table entry for each duv
SAnimTable *uTable = new SAnimTable( );
uTable->name = uName.str();
uTable->fps = anim_rate;
morphRoot->children.push_back( uTable );
if ( verbose >= 1 )
fprintf( outStream, "created duv table named: %s\n", uName.str() );
SAnimTable *vTable = new SAnimTable( );
vTable->name = vName.str();
vTable->fps = anim_rate;
morphRoot->children.push_back( vTable );
if ( verbose >= 1 )
fprintf( outStream, "created duv table named: %s\n", vName.str() );
float texOffsets[4];
if ( numTexGlb )
{
texOffsets[0] = *uOffset;
texOffsets[1] = *vOffset;
texOffsets[2] = *uScale;
texOffsets[3] = *vScale;
}
else
{
texOffsets[0] = uOffset[indexMap[i]/3];
texOffsets[1] = vOffset[indexMap[i]/3];
texOffsets[2] = uScale[indexMap[i]/3];
texOffsets[3] = vScale[indexMap[i]/3];
}
// remember original texture offsets future reference
SAA_elementSetUserData( scene, model, "TEX_OFFSETS",
sizeof( texOffsets ), TRUE, (void **)&texOffsets );
}
EggMorphOffset *duvU;
EggMorphOffset *duvV;
// generate base duv's for this vertex
duvU = new EggMorphOffset( uName.str(), 1.0 , 0.0 );
pool->Vertex(i)->attrib.uv_morphs.push_back( *duvU );
duvV = new EggMorphOffset( vName.str(), 0.0 , 1.0 );
pool->Vertex(i)->attrib.uv_morphs.push_back( *duvV );
} // if ( numExp )
} // if ( numTexLoc || numTexGlb )
} // for ( i = 0; i < numVert; i++ )
// if model has key shapes, generate vertex offsets
if ( has_morph && make_morph )
MakeVertexOffsets( scene, model, type, numShapes, numVert,
vertices, matrix, name );
// create vertex ref list for all polygons in the model
EggVertexRef *vref;
vref = new EggVertexRef( pool);
for ( i = 0; i < numVert; i++ )
{
//add each vert in pool to last joint for hard skinning
vref->indices.push_back( EggVertexIndex( i ) );
}
// hard assign poly geometry if no soft-skinning requested
//
//disabled 1/1/99 to streamline joint assignments.
// all hard-skinning now done in CleanUpSoftSkin.
//if ( !make_soft )
//{
//if ( lastJoint != NULL )
//{
//lastJoint->vrefs.AddUniqueNode( *vref );
//if ( verbose >= 1 )
//fprintf( outStream, "hard-skinning %s (%d vertices)\n",
//name, i+1 );
//}
//}
// make an egg group to hold all triangles
EggGroup *group = _data.CreateGroup( parent, name);
// make this group the current parent
parent = group;
EggPolygon *poly = NULL;
EggColor *cref = NULL;
EggTexture *tref = NULL;
// for each triangle
for ( i = 0; i < numTri*3; i+=3 )
{
float r,g,b,a;
pfVec4 color;
// make egg poly for each traingle and reference
// the appropriate vertex in the pool
poly = _data.CreatePolygon( group, pool );
poly->AddVertex(indices[i]);
poly->AddVertex(indices[i+1]);
poly->AddVertex(indices[i+2]);
// check for back face flag in model note info
char *modelNoteStr = GetModelNoteInfo( scene, model );
if ( modelNoteStr != NULL )
{
if ( strstr( modelNoteStr, "bface" ) != NULL )
poly->flags |= EG_BFACE;
}
// check to see if material is present
SAA_Boolean valid;
SAA_elementIsValid( scene, &materials[i/3], &valid );
// material present - get the color
if ( valid )
{
SAA_materialGetDiffuse( scene, &materials[i/3], &r, &g, &b );
SAA_materialGetTransparency( scene, &materials[i/3], &a );
color.set( r, g, b, 1.0f - a );
}
// no material - default to white
else
color.set( 1.0, 1.0, 1.0, 1.0 );
cref = _data.CreateColor(color);
poly->attrib.SetCRef(cref);
strstream uniqueTexName;
if (numTexLoc)
{
// polytex
if ( (texNameArray[i/3] != NULL) &&
(strcmp(texNameArray[i/3], "NULL") != 0) )
{
// append unique identifier to texname for
// this particular object
uniqueTexName << name << "-"
<< RemovePathName(texNameArray[i/3]);
tref = _data.CreateTexture( texNameArray[i/3],
uniqueTexName.str() );
if ( verbose >= 1 )
fprintf( outStream, " tritex[%d] named: %s\n", i/3,
texNameArray[i/3] );
}
}
else if ( numTexGlb )
{
if ( texNameArray != NULL )
{
// append unique identifier to texname for
// this particular object
uniqueTexName << name << "-"
<< RemovePathName(*texNameArray);
tref = _data.CreateTexture( *texNameArray,
uniqueTexName.str() );
if ( verbose >= 1 )
fprintf( outStream, " tritex named: %s\n",
*texNameArray );
}
}
// set the clamp on the texture
if ( tref != NULL )
{
if ( uRepeat > 0 )
tref->wrapu = EggTexture::WM_repeat;
else
tref->wrapu = EggTexture::WM_clamp;
if ( vRepeat > 1 )
tref->wrapv = EggTexture::WM_repeat;
else
tref->wrapv = EggTexture::WM_clamp;
poly->attrib.SetTRef(tref);
}
}
// we're done - trash triangles...
SAA_modelClearTriangles( scene, model );
// free molloc'd memory
//free( triangles );
//free( materials );
//free( normals );
//free( cvertices );
//free( vertices );
//free( indices );
//free( indexMap );
// free these only if they were malloc'd for textures
if (numTexLoc || numTexGlb)
{
//free( textures );
//free( uCoords );
//free( vCoords );
//free( texNameArray );
//free( uScale );
//free( vScale );
//free( uOffset );
//free( vOffset );
}
}
}
else
{
///////////////////////////////////////
// check to see if its a nurbs surface
///////////////////////////////////////
if ( (type == SAA_MNSRF) && ( visible ) && (( make_nurbs )
|| ( !make_nurbs && !make_poly && make_duv )) )
{
// check to see if NURBS is also skeleton...
SAA_Boolean isSkeleton = FALSE;
SAA_modelIsSkeleton( scene, model, &isSkeleton );
// check to see if this NURBS is used as a skeleton
// or is animated via constraint only ( these nodes are
// tagged by the animator with the keyword "joint"
// somewhere in the nodes name)
if ( isSkeleton || (strstr( name, "joint" ) != NULL) )
{
MakeJoint( scene, lastJoint, lastAnim, model, name );
geom_as_joint = 1;
if ( verbose >= 1 )
fprintf( outStream, "animating NURBS as joint!!!\n" );
}
EggNurbsSurface *eggNurbsSurf = new EggNurbsSurface( name );
int uDegree, vDegree;
// create nurbs representation of surface
SAA_nurbsSurfaceGetDegree( scene, model, &uDegree, &vDegree );
eggNurbsSurf->u_order = uDegree + 1;
eggNurbsSurf->v_order = vDegree + 1;
if ( verbose >= 1 )
{
fprintf( outStream, "nurbs degree: %d u, %d v\n",
uDegree, vDegree );
fprintf( outStream, "nurbs order: %d u, %d v\n",
uDegree + 1, vDegree + 1 );
}
SAA_Boolean uClosed = FALSE;
SAA_Boolean vClosed = FALSE;
SAA_nurbsSurfaceGetClosed( scene, model, &uClosed, &vClosed);
if ( verbose >= 1 )
{
if ( uClosed )
fprintf( outStream, "nurbs is closed in u...\n");
if ( vClosed )
fprintf( outStream, "nurbs is closed in v...\n");
}
int uRows, vRows;
SAA_nurbsSurfaceGetNbVertices( scene, model, &uRows, &vRows );
if ( verbose >= 1 )
fprintf( outStream, "nurbs vertices: %d u, %d v\n",
uRows, vRows );
int uCurves, vCurves;
SAA_nurbsSurfaceGetNbCurves( scene, model, &uCurves, &vCurves );
if ( verbose >= 1 )
fprintf( outStream, "nurbs curves: %d u, %d v\n",
uCurves, vCurves );
if ( shift_textures )
{
if ( uClosed )
// shift starting point on NURBS surface for correct textures
SAA_nurbsSurfaceShiftParameterization( scene, model, -2, 0 );
if ( vClosed )
// shift starting point on NURBS surface for correct textures
SAA_nurbsSurfaceShiftParameterization( scene, model, 0, -2 );
}
SAA_nurbsSurfaceSetStep( scene, model, nurbs_step, nurbs_step );
// check for back face flag in model note info
char *modelNoteStr = GetModelNoteInfo( scene, model );
if ( modelNoteStr != NULL )
{
if ( strstr( modelNoteStr, "bface" ) != NULL )
eggNurbsSurf->flags |= EG_BFACE;
}
int numKnotsU, numKnotsV;
SAA_nurbsSurfaceGetNbKnots( scene, model, &numKnotsU, &numKnotsV );
if ( verbose >= 1 )
fprintf( outStream, "nurbs knots: %d u, %d v\n",
numKnotsU, numKnotsV );
double *knotsU, *knotsV;
knotsU = (double *)malloc(sizeof(double)*numKnotsU);
knotsV = (double *)malloc(sizeof(double)*numKnotsV);
SAA_nurbsSurfaceGetKnots( scene, model, gtype, 0,
numKnotsU, numKnotsV, knotsU, knotsV );
if ( verbose >= 2 )
fprintf( outStream, "u knots:\n" );
AddKnots( eggNurbsSurf->u_knots, knotsU, numKnotsU, uClosed, uDegree );
if ( verbose >= 2 )
fprintf( outStream, "v knots:\n" );
AddKnots( eggNurbsSurf->v_knots, knotsV, numKnotsV, vClosed, vDegree);
//free( knotsU );
//free( knotsV );
// set sub_div so we can see it in perfly
eggNurbsSurf->u_subdiv = (uRows-1)*nurbs_step;
eggNurbsSurf->v_subdiv = (vRows-1)*nurbs_step;
SAA_modelGetNbVertices( scene, model, &numVert );
if ( verbose >= 2 )
fprintf( outStream, "%d CV's\n", numVert );
// get the CV's
vertices = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numVert);
SAA_modelGetVertices( scene, model, gtype, 0,
numVert, vertices );
// create pool of NURBS vertices
EggVertexPool *pool = _data.CreateVertexPool( parent, name );
eggNurbsSurf->SetVertexPool( pool );
// create vertex ref list for all cv's in the model
EggVertexRef *vref;
vref = new EggVertexRef( pool);
for ( int k = 0; k<numVert; k++ )
{
if ( verbose >= 2 )
{
fprintf( outStream, "original cv[%d] = %f %f %f %f\n", k,
vertices[k].x, vertices[k].y, vertices[k].z,
vertices[k].w );
}
pfVec4 eggVert;
// convert to global coords
SAA_DVector global;
_VCT_X_MAT( global, vertices[k], matrix );
//preserve original weight
global.w = vertices[k].w;
// normalize coords to weight
global.x *= global.w;
global.y *= global.w;
global.z *= global.w;
// this code is commented out because I
// am no longer sending global data to
// the other routines (ie makevertexoffset)
// set vertices array to reflect global coords
//vertices[k].x = global.x;
//vertices[k].y = global.y;
//vertices[k].z = global.z;
//vertices[k].w = global.w;
//if ( verbose >= 2 )
//{
//fprintf( outStream, "global cv[%d] = %f %f %f %f\n", k,
//vertices[k].x, vertices[k].y, vertices[k].z,
//vertices[k].w );
//}
//eggVert.set( vertices[k].x, vertices[k].y, vertices[k].z,
//vertices[k].w );
if ( verbose >= 2 )
{
fprintf( outStream, "global cv[%d] = %f %f %f %f\n", k,
global.x, global.y, global.z,
global.w );
}
eggVert.set( global.x, global.y, global.z,
global.w );
// populate vertex pool
pool->AddVertex( eggVert, k );
// add vref's to NURBS info
eggNurbsSurf->AddVertex( k );
//add each vert in pool to vref for hard skinning
vref->indices.push_back( EggVertexIndex( k ) );
// check to see if the NURB is closed in u
if ( uClosed )
{
// add first uDegree verts to end of row
if ( (k % uRows) == ( uRows - 1) )
for ( int i = 0; i < uDegree; i++ )
{
// add vref's to NURBS info
eggNurbsSurf->AddVertex( i+((k/uRows)*uRows) );
//add each vert to vref
vref->indices.push_back(
EggVertexIndex( i+((k/uRows)*uRows) ) );
}
}
}
// if hard skinned or this nurb is also a joint
//
//disabled 1/1/99 to streamline joint assignments.
// all hard skinning now done in CleanUpSoftSkin.
//if (!make_soft || geom_as_joint)
//{
//add the new cv references to the last
//joint for hard skinning only
//if ( lastJoint != NULL )
//{
//lastJoint->vrefs.AddUniqueNode( *vref );
//geom_as_joint = 0;
//if ( verbose >= 1 )
//fprintf( outStream, "Doing NURBS hard skinning...\n");
//}
//}
// check to see if the NURB is closed in v
if ( vClosed && !uClosed )
{
// add first vDegree rows of verts to end of list
for ( int i = 0; i < vDegree*uRows; i++ )
eggNurbsSurf->AddVertex( i );
}
// check to see if the NURB is closed in u and v
else if ( vClosed && uClosed )
{
// add the first (degree) v verts and a few
// extra - for good measure
for ( i = 0; i < vDegree; i++ )
{
// add first vDegree rows of verts to end of list
for ( j = 0; j < uRows; j++ )
eggNurbsSurf->AddVertex( j+(i*uRows) );
// if u is closed to we have added uDegree
// verts onto the ends of the rows - add them here too
for ( k = 0; k < uDegree; k++ )
eggNurbsSurf->AddVertex( k+(i*uRows)+((k/uRows)*uRows) );
}
}
// get the color of the NURBS surface
int numNurbMats;
EggColor *nurbCref;
pfVec4 nurbColor;
SAA_modelRelationGetMatNbElements( scene, model, FALSE, &relinfo,
&numNurbMats );
if ( verbose >= 1 )
fprintf( outStream, "nurbs surf has %d materials\n",
numNurbMats );
if ( numNurbMats )
{
float r,g,b,a;
materials = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numNurbMats);
SAA_modelRelationGetMatElements( scene, model, relinfo,
numNurbMats, materials );
SAA_materialGetDiffuse( scene, &materials[0], &r, &g, &b );
SAA_materialGetTransparency( scene, &materials[0], &a );
nurbColor.set( r, g, b, 1.0f - a );
//nurbColor.set( r, g, b, 1.0 );
nurbCref = _data.CreateColor(nurbColor);
eggNurbsSurf->attrib.SetCRef(nurbCref);
//get the texture of the NURBS surface from the material
int numNurbTexLoc = 0;
int numNurbTexGlb = 0;
// ASSUME only one texture per material
SAA_Elem nurbTex;
// find out how many local textures per NURBS surface
// ASSUME it only has one material
SAA_materialRelationGetT2DLocNbElements( scene, &materials[0],
FALSE, &relinfo, &numNurbTexLoc );
// if present, get local textures
if ( numNurbTexLoc )
{
if ( verbose >= 1 )
fprintf( outStream, "%s had %d local tex\n", name,
numNurbTexLoc );
// get the referenced texture
SAA_materialRelationGetT2DLocElements( scene, &materials[0],
TEX_PER_MAT, &nurbTex );
}
// if no locals, try to get globals
else
{
SAA_modelRelationGetT2DGlbNbElements( scene, model,
FALSE, &relinfo, &numNurbTexGlb );
if ( numNurbTexGlb )
{
if ( verbose >= 1 )
fprintf( outStream, "%s had %d global tex\n", name,
numNurbTexGlb );
// get the referenced texture
SAA_modelRelationGetT2DGlbElements( scene,
model, TEX_PER_MAT, &nurbTex );
}
}
// add tex ref's if we found any textures
if ( numNurbTexLoc || numNurbTexGlb)
{
char *texName = NULL;
char *uniqueTexName = NULL;
EggTexture *tref;
pfMatrix nurbTexMat;
// convert the texture to .rgb and adjust name
texName = ConvertTexture( scene, &nurbTex );
// append unique identifier to texname for
// this particular object
uniqueTexName = (char *)malloc(sizeof(char)*
(strlen(name)+strlen(texName)+3) );
sprintf( uniqueTexName, "%s-%s", name,
RemovePathName(texName) );
if ( verbose >= 1 )
{
fprintf( outStream, "creating tref %s\n",
uniqueTexName );
}
tref = _data.CreateTexture( texName, uniqueTexName );
uScale = ( float *)malloc(sizeof(float));
vScale = ( float *)malloc(sizeof(float));
uOffset = ( float *)malloc(sizeof(float));
vOffset = ( float *)malloc(sizeof(float));
// get texture offset info
SAA_texture2DGetUScale( scene, &nurbTex, uScale );
SAA_texture2DGetVScale( scene, &nurbTex, vScale );
SAA_texture2DGetUOffset( scene, &nurbTex, uOffset );
SAA_texture2DGetVOffset( scene, &nurbTex, vOffset );
SAA_texture2DGetUVSwap( scene, &nurbTex, &uv_swap );
if ( verbose >= 1 )
{
fprintf( outStream, "nurbTex uScale: %f\n", *uScale );
fprintf( outStream, "nurbTex vScale: %f\n", *vScale );
fprintf( outStream, "nurbTex uOffset: %f\n", *uOffset );
fprintf( outStream, "nurbTex vOffset: %f\n", *vOffset );
if ( uv_swap )
fprintf( outStream, "nurbTex u & v swapped!\n" );
else
fprintf( outStream, "nurbTex u & v NOT swapped\n" );
}
nurbTexMat.makeIdent();
if ( !ignore_tex_offsets )
{
if ( uv_swap )
{
nurbTexMat[0][0] = 0.0f;
nurbTexMat[1][1] = 0.0f;
nurbTexMat[0][1] = 1 / *vScale;
nurbTexMat[1][0] = 1 / *uScale;
nurbTexMat[2][1] = -(*uOffset / *uScale);
nurbTexMat[2][0] = -(*vOffset / *vScale);
}
else
{
nurbTexMat[0][0] = 1 / *uScale;
nurbTexMat[1][1] = 1 / *vScale;
nurbTexMat[2][0] = -(*uOffset / *uScale);
nurbTexMat[2][1] = -(*vOffset / *vScale);
}
}
//call printMat
if ( verbose >= 2 )
{
fprintf( outStream, "nurb tex matrix = %f %f %f %f\n", nurbTexMat[0][0],
nurbTexMat[0][1], nurbTexMat[0][2], nurbTexMat[0][3] );
fprintf( outStream, "nurb tex matrix = %f %f %f %f\n", nurbTexMat[1][0],
nurbTexMat[1][1], nurbTexMat[1][2], nurbTexMat[1][3] );
fprintf( outStream, "nurb tex matrix = %f %f %f %f\n", nurbTexMat[2][0],
nurbTexMat[2][1], nurbTexMat[2][2], nurbTexMat[2][3] );
fprintf( outStream, "nurb tex matrix = %f %f %f %f\n", nurbTexMat[3][0],
nurbTexMat[3][1], nurbTexMat[3][2], nurbTexMat[3][3] );
}
tref->tex_mat = nurbTexMat;
tref->flags |= EFT_TRANSFORM;
eggNurbsSurf->attrib.SetTRef(tref);
}
// if we've encountered textures and we desire duv anims
if (( numNurbTexLoc || numNurbTexGlb ) && make_duv )
{
int numExp;
// find how many expressions for this shape
SAA_elementGetNbExpressions( scene, &nurbTex, NULL, FALSE,
&numExp );
// if it has expressions we'll assume its animated
if ( numExp )
{
if ( verbose > 1 )
printf( "nurbTex has %d expressions...\n", numExp );
// if animated object make base duv's, animtables
// for the duv's and store the original offsets
strstream uName, vName;
// create duv target names
uName << name << ".u" << ends;
vName << name << ".v" << ends;
// make sure root morph table exists
if ( morphRoot == NULL )
morphRoot = animData.CreateTable( animRoot,
"morph" );
// create morph table entry for each duv
SAnimTable *uTable = new SAnimTable( );
uTable->name = uName.str();
uTable->fps = anim_rate;
morphRoot->children.push_back( uTable );
if ( verbose >= 1 )
fprintf( outStream, "created duv table named: %s\n", uName.str() );
SAnimTable *vTable = new SAnimTable( );
vTable->name = vName.str();
vTable->fps = anim_rate;
morphRoot->children.push_back( vTable );
if ( verbose >= 1 )
fprintf( outStream, "created duv table named: %s\n", vName.str() );
float texOffsets[4];
texOffsets[0] = *uOffset;
texOffsets[1] = *vOffset;
texOffsets[2] = *uScale;
texOffsets[3] = *vScale;
// remember original texture offsets future reference
SAA_elementSetUserData( scene, model, "TEX_OFFSETS",
sizeof( texOffsets ), TRUE, (void **)&texOffsets );
// create UV's and duv's for each vertex
for( i = 0; i < numVert; i++ )
{
pfVec2 tmpUV;
EggMorphOffset *duvU;
EggMorphOffset *duvV;
//create uv's so we can store duv's
eggNurbsSurf->CalcActualUV( i, tmpUV );
pool->Vertex(i)->attrib.SetUV( tmpUV[0], tmpUV[1] );
// generate base duv's for this vertex
duvU = new EggMorphOffset(uName.str(), 1.0 , 0.0);
pool->Vertex(i)->attrib.uv_morphs.push_back(*duvU);
duvV = new EggMorphOffset(vName.str(), 0.0 , 1.0);
pool->Vertex(i)->attrib.uv_morphs.push_back(*duvV);
}
} // if ( numExp )
} // if ( numTexLoc || numTexGlb )
//free( uScale );
//free( vScale );
//free( uOffset );
//free( vOffset );
//free( materials );
}
else
{
// no material present - default to white
nurbColor.set( 1.0, 1.0, 1.0, 1.0 );
}
//////////////////////////////////////////
// check NURBS surface for trim curves
//////////////////////////////////////////
int numTrims;
bool isTrim = TRUE;
SAA_SubElem *trims;
SAA_nurbsSurfaceGetNbTrimCurves( scene, model, SAA_TRIMTYPE_TRIM,
&numTrims );
if ( verbose >= 1 )
fprintf( outStream, "nurbs surf has %d trim curves\n",
numTrims );
if ( numTrims)
{
trims = (SAA_SubElem *)malloc(sizeof(SAA_SubElem)*numTrims);
if ( trims )
{
SAA_nurbsSurfaceGetTrimCurves( scene, model,
gtype, 0, SAA_TRIMTYPE_TRIM, numTrims,
trims );
MakeSurfaceCurve( scene, model, parent, eggNurbsSurf,
numTrims, trims, isTrim );
}
//free( trims );
}
//////////////////////////////////////////
// check NURBS surface for surface curves
//////////////////////////////////////////
isTrim = FALSE;
SAA_nurbsSurfaceGetNbTrimCurves( scene, model,
SAA_TRIMTYPE_PROJECTION, &numTrims );
if ( verbose >= 1 )
fprintf( outStream, "nurbs surf has %d surface curves\n",
numTrims );
if ( numTrims)
{
trims = (SAA_SubElem *)malloc(sizeof(SAA_SubElem)*numTrims);
if ( trims )
{
SAA_nurbsSurfaceGetTrimCurves( scene, model,
gtype, 0, SAA_TRIMTYPE_PROJECTION,
numTrims, trims );
MakeSurfaceCurve( scene, model, parent, eggNurbsSurf,
numTrims, trims, isTrim );
}
//free( trims );
}
// push the NURBS into the egg data
parent->children.push_back( eggNurbsSurf );
// if model has key shapes, generate vertex offsets
if ( has_morph && make_morph )
MakeVertexOffsets( scene, model, type, numShapes, numVert,
vertices, matrix, name );
//free( vertices );
}
/////////////////////////////////////
// check to see if its a NURBS curve
/////////////////////////////////////
else if ( (type == SAA_MNCRV) && ( visible ) && ( make_nurbs ) )
{
// ignore for now
// make the NURBS curve and push it into the egg data
//parent->children.push_back( MakeNurbsCurve( scene, model, parent,
//matrix, name ) );
}
else if ( type == SAA_MJNT )
{
MakeJoint( scene, lastJoint, lastAnim, model, name );
if ( verbose >= 1 )
fprintf( outStream, "encountered IK joint: %s\n", name );
}
/////////////////////
// it must be a NULL
/////////////////////
else
{
SAA_AlgorithmType algo;
SAA_modelGetAlgorithm( scene, model, &algo );
if ( verbose >= 1 )
fprintf( outStream, "null algorithm: %d\n", algo );
if ( algo == SAA_ALG_INV_KIN )
{
MakeJoint( scene, lastJoint, lastAnim, model, name );
if ( verbose >= 1 )
fprintf( outStream, "encountered IK root: %s\n", name );
}
else if ( algo == SAA_ALG_INV_KIN_LEAF )
{
MakeJoint( scene, lastJoint, lastAnim, model, name );
if ( verbose >= 1 )
fprintf( outStream, "encountered IK leaf: %s\n", name );
}
else if ( algo == SAA_ALG_STANDARD )
{
SAA_Boolean isSkeleton = FALSE;
if ( verbose >= 1 )
fprintf( outStream, "encountered Standard null: %s\n", name);
SAA_modelIsSkeleton( scene, model, &isSkeleton );
// check to see if this NULL is used as a skeleton
// or is animated via constraint only ( these nodes are
// tagged by the animator with the keyword "joint"
// somewhere in the nodes name)
if ( isSkeleton || (strstr( name, "joint" ) != NULL) )
{
MakeJoint( scene, lastJoint, lastAnim, model, name );
if ( verbose >= 1 )
fprintf( outStream, "animating Standard null!!!\n" );
}
}
else
if ( verbose >= 1 )
fprintf( outStream, "encountered some other NULL: %d\n",
algo );
}
}
// check for children...
int numChildren;
int thisChild;
SAA_Elem *children;
SAA_modelGetNbChildren( scene, model, &numChildren );
if ( verbose >= 1 )
fprintf( outStream, "Model children: %d\n", numChildren );
if ( numChildren )
{
children = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numChildren);
SAA_modelGetChildren( scene, model, numChildren, children );
if ( children != NULL )
{
for ( thisChild = 0; thisChild < numChildren; thisChild++ )
{
if ( verbose >= 1 )
fprintf( outStream, "\negging child %d...\n", thisChild);
MakeEgg( parent, lastJoint, lastAnim, scene,
&children[thisChild] );
}
}
else
fprintf( outStream, "Not enough Memory for children...\n");
//free( children );
}
fflush( outStream );
}
else
if ( verbose >= 1 )
fprintf( outStream, "Don't descend this branch!\n" );
// we are done for the most part - start cleaning up memory
//free( name );
}
////////////////////////////////////////////////////////////////////
// Function: MakeSurfaceCurve
// Access: Public
// Description: Given a scene and lists of u and v samples create a
// an egg NURBS curve of degree two from the samples
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeSurfaceCurve( SAA_Scene *scene, SAA_Elem *model, EggGroup *parent,
EggNurbsSurface *&nurbsSurf, int numTrims, SAA_SubElem *trims,
bool isTrim )
{
int i;
long totalSamples = 0;
long *numSamples;
double *uSamples;
double *vSamples;
SAA_Elem *trimCurves;
char *name;
//get UV coord data
numSamples = (long *)malloc(sizeof(long)*numTrims);
SAA_surfaceCurveGetNbLinearSamples( scene, model, numTrims, trims,
numSamples );
for ( i = 0; i < numTrims; i++ )
{
totalSamples += numSamples[i];
if ( verbose >= 2 )
fprintf( outStream, "numSamples[%d] = %d\n", i, numSamples[i] );
}
if ( verbose >= 2 )
fprintf( outStream, "total samples = %ld\n", totalSamples );
uSamples = (double *)malloc(sizeof(double)*totalSamples);
vSamples = (double *)malloc(sizeof(double)*totalSamples);
SAA_surfaceCurveGetLinearSamples( scene, model, numTrims, trims,
numSamples, uSamples, vSamples );
if ( verbose >= 2 )
for ( long li = 0; li < totalSamples; li++ )
fprintf( outStream, "master list cv[%ld] = %f, %f\n", li,
uSamples[li], vSamples[li] );
trimCurves = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numTrims);
SAA_surfaceCurveExtract( scene, model, numTrims, trims, trimCurves );
// if it's a trim create a trim to assign trim curves to
EggNurbsSurface::Trim *eggTrim = new EggNurbsSurface::Trim();
// for each trim curve, make an egg curve and
// add it to the trims of the NURBS surface
for ( i = 0; i < numTrims; i++ )
{
if ( use_prefix )
{
// Get the FULL name of the trim curve
name = GetFullName( scene, &trimCurves[i] );
}
else
{
// Get the name of the trim curve
name = GetName( scene, &trimCurves[i] );
}
if ( isTrim )
{
// add to trim list
EggNurbsSurface::Loop *eggLoop = new EggNurbsSurface::Loop();
eggLoop->push_back( MakeUVNurbsCurve( i, numSamples, uSamples,
vSamples, parent, name ) );
eggTrim->push_back( *eggLoop );
}
else
// add to curve list
nurbsSurf->curves.push_back( MakeUVNurbsCurve( i, numSamples, uSamples, vSamples, parent, name ) );
}
if ( isTrim )
// pus trim list onto trims list
nurbsSurf->trims.push_back( *eggTrim );
//free( name );
//free( trimCurves );
//free( uSamples );
//free( vSamples );
}
////////////////////////////////////////////////////////////////////
// Function: MakeUVNurbsCurve
// Access: Public
// Description: Given a scene and lists of u and v samples create a
// an egg NURBS curve of degree two from the samples
////////////////////////////////////////////////////////////////////
EggNurbsCurve *soft2egg::
MakeUVNurbsCurve( int numCurve, long *numSamples, double *uSamples,
double *vSamples, EggGroup *parent, char *name )
{
EggNurbsCurve *eggNurbsCurve = new EggNurbsCurve( name );
eggNurbsCurve->order = 2;
if ( verbose >= 2 )
fprintf( outStream, "nurbs UV curve %s:\n", name );
//set sub_div so we can see it in perfly
//eggNurbsCurve->subdiv = numSamples[numCurve]/4;
// perfly chokes on big numbers - keep it reasonable
eggNurbsCurve->subdiv = 150;
//create pool of NURBS vertices
EggVertexPool *pool = _data.CreateVertexPool( parent, name );
eggNurbsCurve->SetVertexPool( pool );
// calculate offset to this curve's samples
// in list of all curve samples
int offset = 0;
for ( int o = 0; o < numCurve; o++ )
offset += numSamples[o];
for ( int k = 0; k<numSamples[numCurve]; k++ )
{
pfVec3 eggVert;
// index into the array of samples for this curve
eggVert.set( uSamples[k+offset], vSamples[k+offset], 1.0f );
if ( verbose >= 2 )
fprintf( outStream, "cv[%d] = %f %f %f\n", k, eggVert[0],
eggVert[1], eggVert[2] );
//populate vertex pool
pool->AddVertex( eggVert, k );
//add vref's to NURBS info
eggNurbsCurve->AddVertex( k );
}
// create numSamples[numCurve]+2 knots
eggNurbsCurve->knots.push_back( 0 );
for ( k = 0; k < numSamples[numCurve]; k++ )
eggNurbsCurve->knots.push_back( k );
eggNurbsCurve->knots.push_back( numSamples[numCurve] - 1 );
//set color to bright green for now
EggColor *nurbCref;
pfVec4 nurbColor;
nurbColor.set( 0.5, 1.0, 0.5, 1.0 );
nurbCref = _data.CreateColor(nurbColor);
eggNurbsCurve->attrib.SetCRef(nurbCref);
return( eggNurbsCurve );
}
////////////////////////////////////////////////////////////////////
// Function: MakeNurbsCurve
// Access: Public
// Description: Given a scene and a NURBS curve model create the
// the appropriate egg structures
////////////////////////////////////////////////////////////////////
EggNurbsCurve *soft2egg::
MakeNurbsCurve( SAA_Scene *scene, SAA_Elem *model, EggGroup *parent,
float matrix[4][4], char *name )
{
EggNurbsCurve *eggNurbsCurve = new EggNurbsCurve( name );
int degree;
if ( verbose >= 2 )
fprintf( outStream, "nurbs curve %s:\n", name );
//create nurbs representation of surface
SAA_nurbsCurveGetDegree( scene, model, &degree );
eggNurbsCurve->order = degree + 1;
if ( verbose >= 2 )
fprintf( outStream, "nurbs curve order: %d\n", degree + 1 );
SAA_nurbsCurveSetStep( scene, model, nurbs_step );
SAA_Boolean closed = FALSE;
SAA_nurbsCurveGetClosed( scene, model, &closed );
if ( closed )
if ( verbose >= 2 )
fprintf( outStream, "nurbs curve is closed...\n");
int numKnots;
SAA_nurbsCurveGetNbKnots( scene, model, &numKnots );
if ( verbose >= 2 )
fprintf( outStream, "nurbs curve knots: %d\n", numKnots );
double *knots;
knots = (double *)malloc(sizeof(double)*numKnots);
SAA_nurbsCurveGetKnots( scene, model, SAA_GEOM_ORIGINAL, 0,
numKnots, knots );
AddKnots( eggNurbsCurve->knots, knots, numKnots, closed, degree );
//free( knots );
int numCV;
SAA_modelGetNbVertices( scene, model, &numCV );
if ( verbose >= 2 )
fprintf( outStream, "%d CV's (=? %d)\n", numCV, (numKnots-(degree+1)) );
//set sub_div so we can see it in perfly
eggNurbsCurve->subdiv = (numCV-1)*nurbs_step;
// get the CV's
SAA_DVector *cvArray;
cvArray = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numCV);
SAA_modelGetVertices( scene, model, SAA_GEOM_ORIGINAL, 0,
numCV, cvArray );
//create pool of NURBS vertices
EggVertexPool *pool = _data.CreateVertexPool( parent, name );
eggNurbsCurve->SetVertexPool( pool );
for ( int k = 0; k<numCV; k++ )
{
if ( verbose >= 2 )
fprintf( outStream, "cv[%d] = %f %f %f %f\n", k, cvArray[k].x,
cvArray[k].y, cvArray[k].z, cvArray[k].w );
pfVec4 eggVert;
//convert to global coords
SAA_DVector local = cvArray[k];
SAA_DVector global;
_HVCT_X_MAT( global, local, matrix );
eggVert.set( global.x, global.y, global.z, global.w );
//populate vertex pool
pool->AddVertex( eggVert, k );
//add vref's to NURBS info
eggNurbsCurve->AddVertex( k );
}
if ( closed )
{
// need to replicate first (degree) vertices
for ( k = 0; k < degree; k++ )
{
eggNurbsCurve->AddVertex( k );
if ( verbose >= 2 )
fprintf( outStream, "adding cv[%d] = %f %f %f %f\n", k,
cvArray[k].x, cvArray[k].y, cvArray[k].z, cvArray[k].w );
}
}
//free( cvArray );
//set color to bright green for now
EggColor *nurbCref;
pfVec4 nurbColor;
nurbColor.set( 0.5, 1.0, 0.5, 1.0 );
nurbCref = _data.CreateColor(nurbColor);
eggNurbsCurve->attrib.SetCRef(nurbCref);
return( eggNurbsCurve );
}
////////////////////////////////////////////////////////////////////
// Function: AddKnots
// Access: Public
// Description: Given a parametric surface, and its knots, create
// the appropriate egg structure by filling in Soft's
// implicit knots and assigning the rest to eggKnots.
////////////////////////////////////////////////////////////////////
void soft2egg::
AddKnots( perf_vector<double> &eggKnots, double *knots, int numKnots,
SAA_Boolean closed, int degree )
{
int k = 0;
double lastKnot = knots[0];
double *newKnots;
// add initial implicit knot(s)
if ( closed )
{
int i = 0;
newKnots = (double *)malloc(sizeof(double)*degree);
// need to add (degree) number of knots
for ( k = numKnots - 1; k >= numKnots - degree; k-- )
{
// we have to know these in order to calculate
// next knot value so hold them in temp array
newKnots[i] = lastKnot - (knots[k] - knots[k-1]);
lastKnot = newKnots[i];
i++;
}
for ( k = degree - 1; k >= 0; k-- )
{
eggKnots.push_back( newKnots[k] );
if ( verbose >= 2 )
fprintf( outStream, "knots[%d] = %f\n", k, newKnots[k] );
}
//free( newKnots );
}
else
{
eggKnots.push_back( knots[k] );
if ( verbose >= 2 )
fprintf( outStream, "knots[%d] = %f\n", k, knots[k] );
}
// add the regular complement of knots
for (k = 0; k < numKnots; k++)
{
eggKnots.push_back( knots[k] );
if ( verbose >= 2 )
fprintf( outStream, "knots[%d] = %f\n", k+1, knots[k] );
}
lastKnot = knots[numKnots-1];
// add trailing implicit knots
if ( closed )
{
// need to add (degree) number of knots
for ( k = 1; k <= degree; k++ )
{
eggKnots.push_back( lastKnot + (knots[k] - knots[k-1]) );
if ( verbose >= 2 )
fprintf( outStream, "knots[%d] = %f\n", k,
lastKnot + (knots[k] - knots[k-1]) );
lastKnot = lastKnot + (knots[k] - knots[k-1]);
}
}
else
{
eggKnots.push_back( knots[k-1] );
if ( verbose >= 2 )
fprintf( outStream, "knots[%d] = %f\n", k+1, knots[k-1] );
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeJoint
// Access: Public
// Description: Given a name, a parent and a model create a new
// a new EggJoint for that model.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeJoint( SAA_Scene *scene, EggJoint *&lastJoint, AnimGroup *&lastAnim,
SAA_Elem *model, char *name )
{
float matrix[4][4];
pfMatrix Matrix;
EggJoint *joint;
SAA_Boolean globalFlag = FALSE;
int scale_joint = 0;
// this is a quick fix to make scaled skeletons possible
// if the parent contains the keyword "scale" make this joint
// a global root joint instead of a child...
if (lastJoint != NULL)
{
if ( strstr( lastJoint->name.Str(), "scale" ) != NULL )
{
scale_joint = 1;
if ( verbose >= 1 )
fprintf( outStream, "scale joint flag set!\n" );
}
}
// if not root, flatten is false, and last joint had no scaling
// applied to it, then create joint in skeleton tree
if ( (lastJoint != NULL) && !flatten && !scale_joint )
{
if ( verbose >= 1 )
{
fprintf( outStream, "lastJoint = %s\n", lastJoint->name.Str() );
fprintf( outStream, "getting local transform\n" );
}
SAA_elementSetUserData( scene, model, "GLOBAL", sizeof( SAA_Boolean ),
TRUE, (void **)&globalFlag );
// get the local matrix
SAA_modelGetMatrix( scene, model, SAA_COORDSYS_LOCAL, matrix );
// make this into a pfMatrix
Matrix[0][0] = matrix[0][0];
Matrix[0][1] = matrix[0][1];
Matrix[0][2] = matrix[0][2];
Matrix[0][3] = matrix[0][3];
Matrix[1][0] = matrix[1][0];
Matrix[1][1] = matrix[1][1];
Matrix[1][2] = matrix[1][2];
Matrix[1][3] = matrix[1][3];
Matrix[2][0] = matrix[2][0];
Matrix[2][1] = matrix[2][1];
Matrix[2][2] = matrix[2][2];
Matrix[2][3] = matrix[2][3];
Matrix[3][0] = matrix[3][0];
Matrix[3][1] = matrix[3][1];
Matrix[3][2] = matrix[3][2];
Matrix[3][3] = matrix[3][3];
joint = _data.CreateJoint( lastJoint, name );
joint->transform = Matrix;
}
// if we already have a root attach this joint to it
else if (foundRoot)
{
if ( verbose >= 1 )
fprintf( outStream, "getting global transform\n" );
globalFlag = TRUE;
SAA_elementSetUserData( scene, model, "GLOBAL", sizeof( SAA_Boolean ),
TRUE, (void *)&globalFlag );
// get the global matrix
SAA_modelGetMatrix( scene, model, SAA_COORDSYS_GLOBAL, matrix );
// make this into a pfMatrix
Matrix[0][0] = matrix[0][0];
Matrix[0][1] = matrix[0][1];
Matrix[0][2] = matrix[0][2];
Matrix[0][3] = matrix[0][3];
Matrix[1][0] = matrix[1][0];
Matrix[1][1] = matrix[1][1];
Matrix[1][2] = matrix[1][2];
Matrix[1][3] = matrix[1][3];
Matrix[2][0] = matrix[2][0];
Matrix[2][1] = matrix[2][1];
Matrix[2][2] = matrix[2][2];
Matrix[2][3] = matrix[2][3];
Matrix[3][0] = matrix[3][0];
Matrix[3][1] = matrix[3][1];
Matrix[3][2] = matrix[3][2];
Matrix[3][3] = matrix[3][3];
if ( verbose >= 1 )
fprintf( outStream, "attaching orphan chain to root\n" );
joint = _data.CreateJoint( rootJnt, name );
joint->transform = Matrix;
lastAnim = rootAnim;
}
// if root, make a seperate tree for skeleton and
// create required Table for the Egg heirarchy
else
{
if ( verbose >= 1 )
fprintf( outStream, "getting global transform\n" );
globalFlag = TRUE;
SAA_elementSetUserData( scene, model, "GLOBAL", sizeof( SAA_Boolean ),
TRUE, (void *)&globalFlag );
// get the global matrix
SAA_modelGetMatrix( scene, model, SAA_COORDSYS_GLOBAL, matrix );
// make this into a pfMatrix
Matrix[0][0] = matrix[0][0];
Matrix[0][1] = matrix[0][1];
Matrix[0][2] = matrix[0][2];
Matrix[0][3] = matrix[0][3];
Matrix[1][0] = matrix[1][0];
Matrix[1][1] = matrix[1][1];
Matrix[1][2] = matrix[1][2];
Matrix[1][3] = matrix[1][3];
Matrix[2][0] = matrix[2][0];
Matrix[2][1] = matrix[2][1];
Matrix[2][2] = matrix[2][2];
Matrix[2][3] = matrix[2][3];
Matrix[3][0] = matrix[3][0];
Matrix[3][1] = matrix[3][1];
Matrix[3][2] = matrix[3][2];
Matrix[3][3] = matrix[3][3];
rootJnt = _data.CreateJoint( skeleton, "root" );
rootJnt->transform.makeIdent();
if ( verbose >= 1 )
fprintf( outStream, "setting skeleton root\n" );
rootJnt->flags |= EF_TRANSFORM;
joint = _data.CreateJoint( rootJnt, name );
joint->transform = Matrix;
foundRoot = TRUE;
if ( verbose >= 1 )
fprintf( outStream, "found first chain\n" );
// make skeleton table
AnimGroup *skeletonTable;
skeletonTable = animData.CreateTable( animRoot, "<skeleton>" );
rootAnim = animData.CreateTable( skeletonTable, "root" );
XfmSAnimTable *table = new XfmSAnimTable( );
table->name = "xform";
table->fps = anim_rate;
rootAnim->children.push_back( table );
lastAnim = rootAnim;
}
joint->flags |= EF_TRANSFORM;
//if ( make_anim)
//{
AnimGroup *anim = animData.CreateTable( lastAnim, name );
XfmSAnimTable *table = new XfmSAnimTable( );
if ( verbose >= 1 )
fprintf( outStream, "created anim table: %s\n", "xform" );
table->name = "xform";
table->fps = anim_rate;
anim->children.push_back( table );
lastAnim = anim;
//}
// make this joint current parent of chain
lastJoint = joint;
}
////////////////////////////////////////////////////////////////////
// Function: MakeSoftSkin
// Access: Public
// Description: Given a skeleton part find its envelopes (if any)
// get the vertices associated with the envelopes and
// their weights and make vertex ref's for the joint
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeSoftSkin( SAA_Scene *scene, SAA_Elem *model, SAA_Elem *models,
int numModels, char *name )
{
int numEnv;
SAA_ModelType type;
SAA_Elem *envelopes;
if ( verbose >= 1 )
fprintf( outStream, "\n>found skeleton part( %s )!\n", name );
SAA_skeletonGetNbEnvelopes( scene, model, &numEnv );
if ( numEnv )
{
// it's got envelopes - must be soft skinned
if ( verbose >= 1 )
fprintf( outStream, "numEnv = %d\n", numEnv );
// allocate envelope array
envelopes = ( SAA_Elem *)malloc( sizeof( SAA_Elem )*numEnv );
if ( envelopes != NULL )
{
int thisEnv;
SAA_EnvType envType;
bool hasEnvVertices = 0;
SAA_skeletonGetEnvelopes( scene, model, numEnv, envelopes );
for ( thisEnv = 0; thisEnv < numEnv; thisEnv++ )
{
if ( verbose >= 1 )
fprintf( outStream, "env[%d]: ", thisEnv );
SAA_envelopeGetType( scene, &envelopes[thisEnv], &envType );
if ( envType == SAA_ENVTYPE_NONE )
{
if ( verbose >= 1 )
fprintf( outStream, "envType = none\n" );
}
else if ( envType == SAA_ENVTYPE_FLXLCL )
{
if ( verbose >= 1 )
fprintf( outStream, "envType = flexible, local\n" );
hasEnvVertices = 1;
}
else if ( envType == SAA_ENVTYPE_FLXGLB )
{
if ( verbose >= 1 )
fprintf( outStream, "envType = flexible, global\n" );
hasEnvVertices = 1;
}
else if ( envType == SAA_ENVTYPE_RGDGLB )
{
if ( verbose >= 1 )
fprintf( outStream, "envType = rigid, global\n" );
hasEnvVertices = 1;
}
else
{
if ( verbose >= 1 )
fprintf( outStream, "envType = unknown\n" );
}
}
if ( hasEnvVertices)
{
int *numEnvVertices;
SAA_SubElem *envVertices = NULL;
numEnvVertices = (int *)malloc(sizeof(int)*numEnv);
SAA_envelopeGetNbCtrlVertices( scene, model, numEnv,
envelopes, numEnvVertices );
if ( numEnvVertices != NULL )
{
int totalEnvVertices = 0;
int i,j,k;
for( i = 0; i < numEnv; i++ )
{
totalEnvVertices += numEnvVertices[i];
if ( verbose >= 1 )
fprintf( outStream, "numEnvVertices[%d] = %d\n",
i, numEnvVertices[i] );
}
if ( verbose >= 1 )
fprintf( outStream, "total env verts = %d\n",
totalEnvVertices );
if ( totalEnvVertices )
{
envVertices = (SAA_SubElem *)malloc(sizeof(SAA_SubElem)*totalEnvVertices);
if ( envVertices != NULL )
{
SAA_envelopeGetCtrlVertices( scene, model,
numEnv, envelopes, numEnvVertices, envVertices);
// loop through for each envelope
for ( i = 0; i < numEnv; i++ )
{
float *weights = NULL;
int vertArrayOffset = 0;
if ( verbose >= 2 )
fprintf( outStream, "\nenvelope[%d]:\n", i );
weights = (float *)malloc(sizeof(float)*numEnvVertices[i]);
if ( weights )
{
char *envName;
int *vpoolMap = NULL;
for ( j = 0; j < i; j++ )
vertArrayOffset += numEnvVertices[j];
if ( verbose >= 1 )
fprintf( outStream,
"envVertArray offset = %d\n",
vertArrayOffset );
// get the weights of the envelope vertices
SAA_ctrlVertexGetEnvelopeWeights(
scene, model, &envelopes[i],
numEnvVertices[i],
&envVertices[vertArrayOffset], weights );
// Get the name of the envelope model
if ( use_prefix )
{
// Get the FULL name of the envelope
envName = GetFullName( scene, &envelopes[i] );
}
else
{
// Get the name of the envelope
envName = GetName( scene, &envelopes[i] );
}
if ( verbose >= 1 )
fprintf( outStream, "envelope name %s\n", envName );
// find out if envelope geometry is poly or nurb
//SAA_modelGetType( scene,
//FindModelByName( envName, scene,
//models, numModels ), &type );
SAA_modelGetType( scene, &envelopes[i], &type );
if ( verbose >= 1 )
{
fprintf( outStream, "envelope model type ");
if ( type == SAA_MSMSH )
fprintf( outStream, "MESH\n" );
else if ( type == SAA_MNSRF )
fprintf( outStream, "NURBS\n" );
else
fprintf( outStream, "OTHER\n" );
}
int *envVtxIndices = NULL;
envVtxIndices = (int *)malloc(sizeof(int)*numEnvVertices[i]);
// Get the envelope vertex indices
SAA_ctrlVertexGetIndices( scene, &envelopes[i], numEnvVertices[i],
&envVertices[vertArrayOffset], envVtxIndices );
// find out how many vertices the model has
int modelNumVert;
SAA_modelGetNbVertices( scene, &envelopes[i], &modelNumVert );
SAA_DVector *modelVertices = NULL;
modelVertices = (SAA_DVector *)malloc(sizeof(SAA_DVector)*modelNumVert);
// get the model vertices
SAA_modelGetVertices( scene, &envelopes[i],
SAA_GEOM_ORIGINAL, 0, modelNumVert,
modelVertices );
// create array of global model coords
SAA_DVector *globalModelVertices = NULL;
globalModelVertices = (SAA_DVector *)malloc(sizeof(SAA_DVector)*modelNumVert);
float matrix[4][4];
// tranform local model vert coords to global
// first get the global matrix
SAA_modelGetMatrix( scene, &envelopes[i], SAA_COORDSYS_GLOBAL, matrix );
// populate array of global model verts
for ( j = 0; j < modelNumVert; j++ )
{
_VCT_X_MAT( globalModelVertices[j],
modelVertices[j], matrix );
}
// find the egg vertex pool that corresponds
// to this envelope model
EggVertexPool *envPool =
(EggVertexPool *)(_data.pools.FindName( envName ));
// If we are outputting triangles:
// create an array that maps from a referenced
// vertex in the envelope to a corresponding
// vertex in the egg vertex pool
//if ( (type == SAA_MNSRF) && !make_nurbs )
if ( !make_nurbs || (type == SAA_MSMSH) )
{
vpoolMap = FindClosestTriVert( envPool,
globalModelVertices, modelNumVert );
}
if ( envPool != NULL )
{
// find the egg joint that corresponds to this model
EggJoint *joint =
(EggJoint *)(skeleton->FindDescendent( name ));
// this doesn't seem to be necessary 4/7/99
//EggJoint *parent = (EggJoint *)joint->parent;
//assert(parent->IsA(NT_EggJoint));
// for every envelope vertex
for (j = 0; j < numEnvVertices[i]; j++)
{
double scaledWeight = weights[j]/ 100.0f;
// make sure its in legal range
if (( envVtxIndices[j] < modelNumVert )
&& ( envVtxIndices[j] >= 0 ))
{
if ( (type == SAA_MNSRF) && make_nurbs )
{
// assign all referenced control vertices
joint->AddVertex( envPool->Vertex(envVtxIndices[j]), scaledWeight );
if ( verbose >= 2 )
fprintf( outStream,
"%d: adding vref to cv %d with weight %f\n",
j, envVtxIndices[j], scaledWeight );
envPool->Vertex(envVtxIndices[j])->AddJoint( joint, scaledWeight );
// set flag to show this vertex has
// been assigned
envPool->Vertex(envVtxIndices[j])->multipleJoints = 1;
}
else
{
//assign all the tri verts associated
// with this control vertex to joint
for ( k = 0; k < envPool->NumVertices(); k++ )
{
if ( vpoolMap[k] == envVtxIndices[j] )
{
// add each vert in pool to last
// joint for soft skinning
joint->AddVertex(envPool->Vertex(k),
scaledWeight);
if ( verbose >= 2 )
fprintf( outStream,
"%d: adding vref from cv %d to vert %d with weight %f(vpool)\n",
j, envVtxIndices[j], k, scaledWeight );
envPool->Vertex(k)->AddJoint( joint, scaledWeight );
// set flag to show this vertex has
// been assigned
envPool->Vertex(k)->multipleJoints = 1;
}
}
}
}
else
if ( verbose >= 2 )
fprintf( outStream,
"%d: Omitted vref from cv %d with weight %f (out of range 0 to %d )\n",
j, envVtxIndices[j], scaledWeight, modelNumVert );
}
}
else
if ( verbose >= 2 )
fprintf( outStream, "Couldn't find vpool %s!\n", envName );
//free( modelVertices );
//free( globalModelVertices );
//free( envVtxIndices );
//free( envName );
} //if (weights)
//free( weights );
} // for i
} // if (envVertices != NULL)
else
fprintf( outStream, "Not enough memory for envelope vertices...\n");
//free( envVertices );
} // if (totalEnvVertices)
else
if ( verbose >= 1 )
fprintf( outStream, "No envelope vertices present...\n");
//free( numEnvVertices );
} // if (numEnvVertices != NULL)
} // if (hasEnvVertices)
} // if (envelopes != NULL)
else
fprintf( outStream, "Not enough memory for envelopes...\n" );
//free( envelopes );
} //if (numEnv)
else
if ( verbose >= 1 )
fprintf( outStream, "Skeleton member has no envelopes...\n" );
}
////////////////////////////////////////////////////////////////////
// Function: CleanUpSoftSkin
// Access: Public
// Description: Given a model, make sure all its vertices have been
// soft assigned. If not hard assign to the last
// joint we saw.
////////////////////////////////////////////////////////////////////
void soft2egg::
CleanUpSoftSkin( SAA_Scene *scene, SAA_Elem *model, char *name )
{
static EggJoint *joint;
SAA_Elem parent;
SAA_ModelType type;
SAA_Boolean skel;
/////////////////////////////////////////////////
// find out what type of node we're dealing with
/////////////////////////////////////////////////
SAA_modelGetType( scene, model, &type );
char *parentName;
int level;
SAA_Elem *searchNode = model;
if ( verbose >= 1 )
fprintf( outStream, "\nCleaning up model %s\n", name );
// this step is weird - I think I want it here but it seems
// to break some models. Files like props-props_wh_cookietime.3-0 in
// /ful/rnd/pub/vrml/chip/chips_adventure/char/zone1/rooms/warehouse_final
// need to do the "if (skel)" bit.
// am I a skeleton too?
SAA_modelIsSkeleton( scene, model, &skel );
// if not look for the last skeleton part
if ( skel )
parentName = name;
else do
{
SAA_elementGetHierarchyLevel( scene, searchNode, &level );
// make sure we don't try to get the root's parent
if ( level )
{
SAA_modelGetParent( scene, searchNode, &parent );
if ( use_prefix )
{
// Get the FULL name of the parent
parentName = GetFullName( scene, &parent );
}
else
{
// Get the name of the parent
parentName = GetName( scene, &parent );
}
SAA_modelGetType( scene, &parent, &type );
SAA_modelIsSkeleton( scene, &parent, &skel );
if ( verbose >= 1 )
fprintf( outStream, "model %s, level %d, type %d, skel %d\n",
parentName, level, type, skel );
searchNode = &parent;
}
else
{
// we reached the root of the tree
parentName = NULL;
if ( verbose >= 1 )
fprintf( outStream, "at root of tree! level %d\n", level );
break;
}
// look until parent is a joint or acts like one
} while ( !skel && ( strstr( parentName,"joint") == NULL ));
EggJoint *thisJoint = NULL;
if ( parentName != NULL )
{
if ( verbose >= 1 )
{
fprintf( outStream, "found model parent joint %s\n", parentName);
fprintf( outStream, "looking for joint %s\n", parentName );
}
thisJoint = (EggJoint *)(skeleton->FindDescendent( parentName ));
}
else
if ( verbose >= 1 )
fprintf( outStream, "Couldn't find parent joint!\n");
if ( thisJoint != NULL )
{
joint = thisJoint;
if ( verbose >= 1 )
fprintf( outStream, "setting joint to %s\n", parentName );
//find the vpool for this model
EggVertexPool *vPool =
(EggVertexPool *)(_data.pools.FindName( name ));
if (vPool != NULL)
{
int i;
double membership;
int numVerts = vPool->NumVertices() ;
if ( verbose >= 1 )
fprintf( outStream, "found vpool %s w/ %d verts\n",
name, numVerts );
for ( i = 0; i < numVerts; i++ )
{
if ( vPool->Vertex(i)->multipleJoints != 1 )
{
if ( verbose >= 1 )
{
fprintf( outStream, "vpool %s vert %d", name, i );
fprintf( outStream, " not assigned!\n" );
}
// hard skin this vertex
joint->AddVertex( vPool->Vertex(i), 1.0f );
}
else
{
membership = vPool->Vertex(i)->NetMembership();
if ( verbose >= 1 )
{
fprintf( outStream, "vpool %s vert %d", name,
i );
fprintf( outStream, " has membership %f\n",
membership );
}
if ( membership == 0 )
{
if ( verbose >= 1 )
fprintf( outStream, "adding full weight..\n" );
// hard skin this vertex
joint->AddVertex( vPool->Vertex(i), 1.0f );
}
}
}
}
else
if ( verbose >= 1 )
fprintf( outStream, "couldn't find vpool %s\n", name );
}
else
{
if ( parentName != NULL )
if ( verbose >= 1 )
fprintf( outStream, "Couldn't find joint %s\n", parentName );
}
}
//////////////////////////////////////////////////////////////////////
// Function: MakeAnimTable
// Access: Public
// Description: Given a scene and a skeleton part ,get all the
// position, rotation, and scale for the skeleton
// part for this frame and write them out as Egg
// animation tables.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeAnimTable( SAA_Scene *scene, SAA_Elem *skeletonPart, char *name )
{
if ( skeletonPart != NULL )
{
float i,j,k;
float h,p,r;
float x,y,z;
int size;
SAA_Boolean globalFlag = FALSE;
SAA_Boolean bigEndian;
if ( verbose >= 1 )
fprintf( outStream, "\n\nanimating child %s\n", name );
SAA_elementGetUserDataSize( scene, skeletonPart, "GLOBAL", &size );
if ( size != 0 )
SAA_elementGetUserData( scene, skeletonPart, "GLOBAL",
sizeof( SAA_Boolean), &bigEndian, (void *)&globalFlag );
if ( globalFlag )
{
if ( verbose >= 1 )
fprintf( outStream, " using global matrix\n" );
//get SAA orientation
SAA_modelGetRotation( scene, skeletonPart, SAA_COORDSYS_GLOBAL,
&p, &h, &r );
//get SAA translation
SAA_modelGetTranslation( scene, skeletonPart, SAA_COORDSYS_GLOBAL,
&x, &y, &z );
//get SAA scaling
SAA_modelGetScaling( scene, skeletonPart, SAA_COORDSYS_GLOBAL,
&i, &j, &k );
}
else
{
if ( verbose >= 1 )
fprintf( outStream, "using local matrix\n" );
//get SAA orientation
SAA_modelGetRotation( scene, skeletonPart, SAA_COORDSYS_LOCAL,
&p, &h, &r );
//get SAA translation
SAA_modelGetTranslation( scene, skeletonPart, SAA_COORDSYS_LOCAL,
&x, &y, &z );
//get SAA scaling
SAA_modelGetScaling( scene, skeletonPart, SAA_COORDSYS_LOCAL,
&i, &j, &k );
}
if ( verbose >= 2 )
fprintf( outStream, "\nanim data: %f %f %f\n\t%f %f %f\n\t%f %f %f\n",
i, j, k, h, p, r, x, y, z );
// find the appropriate anim table for this skeleton part
AnimGroup *thisGroup;
XfmSAnimTable *thisTable;
//find the anim table associated with this group
thisGroup = (AnimGroup *)(animRoot->FindDescendent( name ));
if ( verbose >= 2 )
fprintf( outStream, "\nlooking for anim group %s\n", name );
if ( thisGroup != NULL )
{
thisTable = (XfmSAnimTable *)(thisGroup->FindDescendent( "xform" ));
if ( thisTable != NULL )
{
thisTable->sub_tables[0].AddElement( i );
thisTable->sub_tables[1].AddElement( j );
thisTable->sub_tables[2].AddElement( k );
thisTable->sub_tables[3].AddElement( p );
thisTable->sub_tables[4].AddElement( h );
thisTable->sub_tables[5].AddElement( r );
thisTable->sub_tables[6].AddElement( x );
thisTable->sub_tables[7].AddElement( y );
thisTable->sub_tables[8].AddElement( z );
}
else
fprintf( outStream, "Couldn't allocate anim table\n" );
}
else
if ( verbose >= 2 )
fprintf( outStream, "Couldn't find anim group %s\n", name );
}
else
{
if ( verbose >= 2 )
fprintf( outStream, "Cannot build anim table - no skeleton\n" );
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeVertexOffsets
// Access: Public
// Description: Given a scene, a model , the vertices of its original
// shape and its name find the difference between the
// geometry of its key shapes and the models original
// geometry and add morph vertices to the egg data to
// reflect these changes.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeVertexOffsets( SAA_Scene *scene, SAA_Elem *model, SAA_ModelType type,
int numShapes, int numOrigVert, SAA_DVector *originalVerts, float
matrix[4][4], char *name )
{
int i, j;
int offset;
int numCV;
char *mTableName;
SAA_DVector *shapeVerts = NULL;
SAA_DVector *uniqueVerts = NULL;
if ( (type == SAA_MNSRF) && make_nurbs )
SAA_nurbsSurfaceSetStep( scene, model, nurbs_step, nurbs_step );
SAA_modelGetNbVertices( scene, model, &numCV );
// get the shape verts
uniqueVerts = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numCV);
SAA_modelGetVertices( scene, model, SAA_GEOM_ORIGINAL, 0,
numCV, uniqueVerts );
if ( verbose >= 2 )
fprintf( outStream, "%d CV's\n", numCV );
if ( verbose >= 2 )
{
for ( i = 0; i < numCV; i++ )
fprintf( outStream, "uniqueVerts[%d] = %f %f %f %f\n", i,
uniqueVerts[i].x, uniqueVerts[i].y,
uniqueVerts[i].z, uniqueVerts[i].w );
}
// iterate through for each key shape (except original)
for ( i = 1; i < numShapes; i++ )
{
mTableName = MakeTableName( name, i );
if ( verbose >= 1 )
{
fprintf( outStream, "\nMaking geometry offsets for %s...\n",
mTableName );
if ( (type == SAA_MNSRF) && make_nurbs )
fprintf( outStream, "calculating NURBS morphs...\n" );
else
fprintf( outStream, "calculating triangle morphs...\n" );
}
// get the shape verts
shapeVerts = (SAA_DVector *)malloc(sizeof(SAA_DVector)*numCV);
SAA_modelGetVertices( scene, model, SAA_GEOM_SHAPE, i+1,
numCV, shapeVerts );
if ( verbose >= 2 )
{
for ( j=0; j < numCV; j++ )
{
fprintf( outStream, "shapeVerts[%d] = %f %f %f\n", j,
shapeVerts[j].x, shapeVerts[j].y, shapeVerts[j].z );
}
}
// find the appropriate vertex pool
EggVertexPool *vPool =
(EggVertexPool *)(_data.pools.FindName( name ));
// for every original vertex, compare to the corresponding
// key shape vertex and see if a vertex offset is needed
for ( j=0; j < numOrigVert; j++ )
{
double dx, dy, dz;
if ( (type == SAA_MNSRF) && make_nurbs )
{
//dx = shapeVerts[j].x - (originalVerts[j].x/originalVerts[j].w);
//dy = shapeVerts[j].y - (originalVerts[j].y/originalVerts[j].w);
//dz = shapeVerts[j].z - (originalVerts[j].z/originalVerts[j].w);
dx = shapeVerts[j].x - originalVerts[j].x;
dy = shapeVerts[j].y - originalVerts[j].y;
dz = shapeVerts[j].z - originalVerts[j].z;
}
else
{
// we need to map from original vertices
// to triangle shape vertices here
offset = findShapeVert( originalVerts[j], uniqueVerts,
numCV );
dx = shapeVerts[offset].x - originalVerts[j].x;
dy = shapeVerts[offset].y - originalVerts[j].y;
dz = shapeVerts[offset].z - originalVerts[j].z;
}
if ( verbose >= 2 )
{
fprintf( outStream, "oVert[%d] = %f %f %f %f\n", j,
originalVerts[j].x, originalVerts[j].y,
originalVerts[j].z, originalVerts[j].w );
if ( (type == SAA_MNSRF) && make_nurbs )
{
fprintf( outStream, "global shapeVerts[%d] = %f %f %f %f\n", j, shapeVerts[j].x, shapeVerts[j].y,
shapeVerts[j].z, shapeVerts[j].w );
}
else
{
fprintf( outStream,
"global shapeVerts[%d] = %f %f %f\n", offset,
shapeVerts[offset].x,
shapeVerts[offset].y,
shapeVerts[offset].z );
}
fprintf( outStream, "%d: dx = %f, dy = %f, dz = %f\n", j,
dx, dy, dz );
}
// if change isn't negligible, make a morph vertex entry
double total = fabs(dx)+fabs(dy)+fabs(dz);
if ( total > 0.00001 )
{
if ( vPool != NULL )
{
// create offset
EggMorphOffset *dxyz =
new EggMorphOffset( mTableName, dx, dy, dz );
EggVertex *eggVert;
// get the appropriate egg vertex
eggVert = vPool->Vertex(j);
// add the offset to the vertex
eggVert->morphs.push_back( *dxyz );
}
else
fprintf( outStream, "Error: couldn't find vertex pool %s\n", name );
} // if total
} //for j
} //for i
}
////////////////////////////////////////////////////////////////////
// Function: MakeMorphTable
// Access: Public
// Description: Given a scene, a model, a name and a frame time,
// determine what type of shape interpolation is
// used and call the appropriate function to extract
// the shape weight info for this frame...
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeMorphTable( SAA_Scene *scene, SAA_Elem *model, SAA_Elem *models,
int numModels, char *name, float time )
{
int numShapes;
SAA_AnimInterpType type;
// Get the number of key shapes
SAA_modelGetNbShapes( scene, model, &numShapes );
if ( numShapes > 0 )
{
if ( verbose >= 1 )
fprintf( outStream, "MakeMorphTable: %s: num shapes: %d\n",
name, numShapes);
SAA_modelGetShapeInterpolation( scene, model, &type );
if ( type == SAA_ANIM_LINEAR || type == SAA_ANIM_CARDINAL )
{
MakeLinearMorphTable( scene, model, numShapes, name, time );
}
else // must be weighted...
{
// check first for expressions
MakeExpressionMorphTable( scene, model, models, numModels,
numShapes, name, time );
}
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeLinearMorphTable
// Access: Public
// Description: Given a scene, a model, its name, and the time,
// get the shape fcurve for the model and determine
// the shape weights for the given time and use them
// to populate the morph table.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeLinearMorphTable( SAA_Scene *scene, SAA_Elem *model, int numShapes,
char *name, float time )
{
int i;
SAA_Elem fcurve;
float curveVal;
SAnimTable *thisTable;
char *tableName;
if ( verbose >= 1 )
fprintf( outStream, "linear interp, getting fcurve\n" );
SAA_modelFcurveGetShape( scene, model, &fcurve );
SAA_fcurveEval( scene, &fcurve, time, &curveVal );
if ( verbose >= 2 )
fprintf( outStream, "at time %f, fcurve for %s = %f\n", time,
name, curveVal );
float nextVal = 0.0f;
// populate morph table values for this frame
for ( i = 1; i < numShapes; i++ )
{
// derive table name from the model name
tableName = MakeTableName( name, i );
if ( verbose >= 2 )
fprintf( outStream, "Linear: looking for table '%s'\n", tableName );
//find the morph table associated with this key shape
thisTable = (SAnimTable *)(morphRoot->FindDescendent( tableName ));
if ( thisTable != NULL )
{
if ( i == (int)curveVal )
{
if ( curveVal - i == 0 )
{
thisTable->AddElement( 1.0f );
if ( verbose >= 2 )
fprintf( outStream, "adding element 1.0f\n" );
}
else
{
thisTable->AddElement( 1.0f - (curveVal - i) );
nextVal = curveVal - i;
if ( verbose >= 2 )
fprintf( outStream, "adding element %f\n", 1.0f - (curveVal - i) );
}
}
else
{
if ( nextVal )
{
thisTable->AddElement( nextVal );
nextVal = 0.0f;
if ( verbose >= 2 )
fprintf( outStream, "adding element %f\n", nextVal );
}
else
{
thisTable->AddElement( 0.0f );
if ( verbose >= 2 )
fprintf( outStream, "adding element 0.0f\n" );
}
}
if ( verbose >= 2 )
fprintf( outStream, " to '%s'\n", tableName );
}
else
fprintf( outStream, "%d: Couldn't find table '%s'\n",
i, tableName );
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeWeightedMorphTable
// Access: Public
// Description: Given a scene, a model, a list of all models in the
// scene, the number of models in the scece, the number
// of key shapes for this model, the name of the model
// and the current time, determine what method of
// controlling the shape weights is used and call the
// appropriate routine.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeWeightedMorphTable( SAA_Scene *scene, SAA_Elem *model, SAA_Elem *models,
int numModels, int numShapes, char *name, float time )
{
SI_Error result;
SAA_Elem *weightCurves;
float curveVal;
SAnimTable *thisTable;
char *tableName;
// allocate array of weight curves (one for each shape)
weightCurves = ( SAA_Elem *)malloc( sizeof( SAA_Elem ) * numShapes );
result = SAA_modelFcurveGetShapeWeights(
scene, model, numShapes, weightCurves );
if ( result == SI_SUCCESS )
{
for ( int i = 1; i < numShapes; i++ )
{
SAA_fcurveEval( scene, &weightCurves[i], time, &curveVal );
// make sure soft gave us a reasonable number
if (!isNum(curveVal))
curveVal = 0.0f;
if ( verbose >= 2 )
fprintf( outStream, "at time %f, weightCurve[%d] for %s = %f\n", time, i, name, curveVal );
// derive table name from the model name
tableName = MakeTableName( name, i );
// find and populate shape table
if ( verbose >= 2 )
fprintf( outStream, "Weight: looking for table '%s'\n",
tableName );
//find the morph table associated with this key shape
thisTable = (SAnimTable *)(morphRoot->FindDescendent( tableName ));
if ( thisTable != NULL )
{
thisTable->AddElement( curveVal );
if ( verbose >= 2 )
fprintf( outStream, "adding element %f\n", curveVal );
}
else
fprintf( outStream, "%d: Couldn't find table '%s'\n",
i, tableName );
}
}
}
////////////////////////////////////////////////////////////////////
// Function: MakeExpressionMorphTable
// Access: Public
// Description: Given a scene, a model and its number of key shapes
// generate a morph table describing transitions btwn
// the key shapes by evaluating the positions of the
// controlling sliders.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeExpressionMorphTable( SAA_Scene *scene, SAA_Elem *model, SAA_Elem *models,
int numModels, int numShapes, char *name, float time )
{
int j;
SAnimTable *thisTable;
char *tableName;
char *sliderName;
char *track;
int numExp;
SAA_Elem *expressions;
float expVal;
float sliderVal;
// populate morph table values for this frame
// compose track name
track = NULL;
// find how many expressions for this shape
SAA_elementGetNbExpressions( scene, model, track, FALSE, &numExp );
if ( verbose >= 2 )
fprintf( outStream, "%s has %d RHS expressions\n", name, numExp );
if ( numExp )
{
// get the expressions for this shape
expressions = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numExp);
if ( verbose >= 1 )
fprintf( outStream, "getting %d RHS expressions...\n", numExp );
result = SAA_elementGetExpressions( scene, model, track, FALSE,
numExp, expressions );
if ( !result )
{
for ( j = 1; j < numExp; j++ )
{
if ( verbose >= 2 )
{
// debug see what we got
int numvars;
SAA_expressionGetNbVars( scene, &expressions[j], &numvars );
int *varnamelen;
int *varstrlen;
int expstrlen;
varnamelen = (int *)malloc(sizeof(int)*numvars);
varstrlen = (int *)malloc(sizeof(int)*numvars);
SAA_expressionGetStringLengths( scene, &expressions[j],
numvars, varnamelen, varstrlen, &expstrlen );
int *varnamesizes;
int *varstrsizes;
varnamesizes = (int *)malloc(sizeof(int)*numvars);
varstrsizes = (int *)malloc(sizeof(int)*numvars);
for ( int k = 0; k < numvars; k++ )
{
varnamesizes[k] = varnamelen[k] + 1;
varstrsizes[k] = varstrlen[k] + 1;
}
int expstrsize = expstrlen + 1;
char **varnames;
char **varstrs;
varnames = (char **)malloc(sizeof(char *)*numvars);
varstrs = (char **)malloc(sizeof(char *)*numvars);
for ( k = 0; k < numvars; k++ )
{
varnames[k] = (char *)malloc(sizeof(char)*
varnamesizes[k]);
varstrs[k] = (char *)malloc(sizeof(char)*
varstrsizes[k]);
}
char *expstr = (char *)malloc(sizeof(char)* expstrsize );
SAA_expressionGetStrings( scene, &expressions[j], numvars,
varnamesizes, varstrsizes, expstrsize, varnames,
varstrs, expstr );
if ( verbose >= 2 )
{
fprintf( outStream, "expression = '%s'\n", expstr );
fprintf( outStream, "has %d variables\n", numvars );
}
} //if verbose
if ( verbose >= 2 )
fprintf( outStream, "evaling expression...\n" );
SAA_expressionEval( scene, &expressions[j], time, &expVal );
if ( verbose >= 2 )
fprintf( outStream, "time %f: exp val %f\n",
time, expVal );
// derive table name from the model name
tableName = MakeTableName( name, j );
if ( verbose >= 2 )
fprintf( outStream, "Exp: looking for table '%s'\n",
tableName );
//find the morph table associated with this key shape
thisTable = (SAnimTable *)
(morphRoot->FindDescendent( tableName ));
if ( thisTable != NULL )
{
thisTable->AddElement( expVal );
if ( verbose >= 1 )
fprintf( outStream, "%d: adding element %f to %s\n",
j, expVal, tableName );
fflush( outStream );
}
else
{
fprintf( outStream, "%d: Couldn't find table '%s'", j,
tableName );
fprintf( outStream, " for value %f\n", expVal );
}
}
}
else
fprintf( outStream, "couldn't get expressions!!!\n" );
}
else
// no expression, use weight curves
MakeWeightedMorphTable( scene, model, models, numModels,
numShapes, name, time );
}
////////////////////////////////////////////////////////////////////
// Function: MakeTexAnim
// Access: Public
// Description: Given a scene, a POLYGON model, and the name
// of the that model, get the u and v offsets for
// the current frame.
////////////////////////////////////////////////////////////////////
void soft2egg::
MakeTexAnim( SAA_Scene *scene, SAA_Elem *model, char *modelName )
{
if ( verbose >= 1 )
fprintf( outStream, "\n\nmaking texture animation for %s...\n",
modelName );
// get the color of the surface
int numMats;
pfVec4 Color;
SAA_Elem *materials;
void *relinfo;
SAA_modelRelationGetMatNbElements( scene, model, FALSE, &relinfo,
&numMats );
if ( verbose >= 2 )
fprintf( outStream, "surface has %d materials\n", numMats );
if ( numMats )
{
float r,g,b,a;
materials = (SAA_Elem *)malloc(sizeof(SAA_Elem)*numMats);
SAA_modelRelationGetMatElements( scene, model, relinfo,
numMats, materials );
SAA_materialGetDiffuse( scene, &materials[0], &r, &g, &b );
SAA_materialGetTransparency( scene, &materials[0], &a );
Color.set( r, g, b, 1.0f - a );
int numTexLoc = 0;
int numTexGlb = 0;
// ASSUME only one texture per material
SAA_Elem tex;
// find out how many local textures per surface
// ASSUME it only has one material
SAA_materialRelationGetT2DLocNbElements( scene, &materials[0],
FALSE, &relinfo, &numTexLoc );
// if present, get local textures
if ( numTexLoc )
{
if ( verbose >= 1 )
fprintf( outStream, "%s had %d local tex\n", modelName,
numTexLoc );
// get the referenced texture
SAA_materialRelationGetT2DLocElements( scene, &materials[0],
TEX_PER_MAT, &tex );
}
// if no locals, try to get globals
else
{
SAA_modelRelationGetT2DGlbNbElements( scene, model,
FALSE, &relinfo, &numTexGlb );
if ( numTexGlb )
{
if ( verbose >= 1 )
fprintf( outStream, "%s had %d global tex\n", modelName, numTexGlb );
// get the referenced texture
SAA_modelRelationGetT2DGlbElements( scene,
model, TEX_PER_MAT, &tex );
}
}
// add tex ref's if we found any textures
if ( numTexLoc || numTexGlb)
{
char *fullTexName = NULL;
char *texName = NULL;
char *uniqueTexName = NULL;
int texNameLen;
// get its name
SAA_texture2DGetPicNameLength( scene, &tex, &texNameLen);
fullTexName = (char *)malloc(sizeof(char)*++texNameLen);
SAA_texture2DGetPicName( scene, &tex, texNameLen,
fullTexName );
// append unique identifier to texname for
// this particular object
uniqueTexName = (char *)malloc(sizeof(char)*
(strlen(modelName)+strlen(texName)+3) );
sprintf( uniqueTexName, "%s-%s", modelName, texName );
if ( verbose >= 2 )
fprintf( outStream, "referencing tref %s\n",
uniqueTexName );
float uScale;
float vScale;
float uOffset;
float vOffset;
SAA_Boolean uv_swap = FALSE;
// get texture offset info
SAA_texture2DGetUScale( scene, &tex, &uScale );
SAA_texture2DGetVScale( scene, &tex, &vScale );
SAA_texture2DGetUOffset( scene, &tex, &uOffset );
SAA_texture2DGetVOffset( scene, &tex, &vOffset );
SAA_texture2DGetUVSwap( scene, &tex, &uv_swap );
if ( verbose >= 2 )
{
fprintf( outStream, "tex uScale: %f\n", uScale );
fprintf( outStream, "tex vScale: %f\n", vScale );
fprintf( outStream, "tex uOffset: %f\n", uOffset );
fprintf( outStream, "tex vOffset: %f\n", vOffset );
if ( uv_swap )
fprintf( outStream, "nurbTex u & v swapped!\n" );
else
fprintf( outStream, "nurbTex u & v NOT swapped\n" );
}
// find the vpool for this model
EggVertexPool *vPool =
(EggVertexPool *)(_data.pools.FindName( modelName ));
// if we found the pool
if ( vPool != NULL )
{
// generate duv's for model
float oldOffsets[4];
double u, v, du, dv;
int size;
SAA_Boolean bigEndian;
SAA_elementGetUserDataSize( scene, model, "TEX_OFFSETS", &size );
if ( size != 0 )
{
// remember original texture offsets future reference
SAA_elementGetUserData( scene, model, "TEX_OFFSETS",
size, &bigEndian, (void *)&oldOffsets );
// get the original scales and offsets
u = oldOffsets[0];
v = oldOffsets[1];
du = u - uOffset;
dv = v - vOffset;
if ( verbose >= 1 )
{
fprintf( outStream, "original u = %f, v = %f\n",
u, v );
fprintf( outStream, "u = %f, v = %f\n",
uOffset, vOffset );
fprintf( outStream, "du = %f, dv = %f\n",
du, dv );
}
strstream uName, vName;
// create duv target names
uName << modelName << ".u" << ends;
vName << modelName << ".v" << ends;
// find the appropriate table to store the
// duv animation info into
SAnimTable *thisTable;
//find the duv U table associated with this model
thisTable = (SAnimTable *)(morphRoot->FindDescendent(
uName.str() ));
if ( thisTable != NULL )
{
thisTable->AddElement( du );
if ( verbose >= 1 )
fprintf( outStream, "adding element %f to %s\n",
du, uName.str() );
}
else
fprintf( outStream, "Couldn't find uTable %s\n",
uName.str() );
//find the duv V table associated with this model
thisTable = (SAnimTable *)(morphRoot->FindDescendent(
vName.str() ));
if ( thisTable != NULL )
{
thisTable->AddElement( dv );
if ( verbose >= 1 )
fprintf( outStream, "adding element %f to %s\n",
dv, uName.str() );
}
else
fprintf( outStream, "Couldn't find vTable %s\n",
uName.str() );
}
}
else
if ( verbose >= 2 )
fprintf( outStream, "Couldn't find vpool %s\n", modelName );
}
//free( materials );
}
}
#endif
////////////////////////////////////////////////////////////////////
// Function: Main
// Access: Private
// Description: Instantiate converter and process a file
////////////////////////////////////////////////////////////////////
EXPCL_MISC SI_Error soft2egg(int argc, char *argv[]) {
// pass control to the c++ system
init_soft2egg(argc, argv);
return SI_SUCCESS;
}
#ifdef __cplusplus
}
#endif
Reference in New Issue View Git Blame Copy Permalink