initial softimage extractor tool port: only model, no animation yet

pandatool/src/softegg/soft2Egg.c

@@ -0,0 +1,4933 @@
+// 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://www.panda3d.org/license.txt .
+//
+// To contact the maintainers of this program write to
+// [email protected] .
+//
+////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////
+// 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