meshsave.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/* $Header: /Commando/Code/Tools/max2w3d/meshsave.cpp 107   8/21/01 10:28a Greg_h $ */
/*********************************************************************************************** 
 ***                            Confidential - Westwood Studios                              *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Commando / G                                                 * 
 *                                                                                             * 
 *                    File Name : MESHSAVE.CPP                                                 * 
 *                                                                                             * 
 *                   Programmer : Greg Hjelstrom                                               * 
 *                                                                                             * 
 *                   Start Date : 06/10/97                                                     * 
 *                                                                                             * 
 *                  Last Update : 10/20/1999997 [GH]                                           * 
 *                                                                                             * 
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 *   MeshSaveClass::MeshSaveClass -- constructor, processes a Max mesh                         * 
 *   MeshSaveClass::~MeshSaveClass -- destructor, frees all allocated memory                   * 
 *   MeshSaveClass::write_verts -- write the vertex chunk into a wtm file                      * 
 *   MeshSaveClass::write_header -- write a mesh header chunk into a wtm file                  * 
 *   MeshSaveClass::Write_To_File -- Append the mesh to an open wtm file                       * 
 *   MeshSaveClass::write_normals -- writes the vertex normals chunk into a wtm file           * 
 *   MeshSaveClass::write_vert_normals -- Writes the surrender normal chunk into a wtm file    * 
 *   MeshSaveClass::write_triangles -- Write the triangles chunk into a wtm file.              * 
 *   MeshSaveClass::write_sr_triangles -- writes the triangles in surrender friendly format    * 
 *   MeshSaveClass::write_triangles -- write the triangles chunk                               *
 *   MeshSaveClass::compute_surrender_vertex -- Compute the surrender vertex normals           * 
 *   MeshSaveClass::setup_material -- Gets the texture names and base colors for a material    * 
 *   MeshSaveClass::compute_bounding_volumes -- computes a bounding box and bounding sphere for* 
 *   MeshSaveClass::set_transform -- set the default transformation matrix for the mesh        * 
 *   MeshSaveClass::compute_physical_properties -- computes the volume and moment of inertia   * 
 *   MeshSaveClass::prep_mesh -- pre-transform the MAX mesh by a specified matrix              * 
 *   MeshSaveClass::write_user_text -- write the user text chunk                               * 
 *   MeshSaveClass::get_htree_bone_index_for_inode -- searches the htree for the given INode   *
 *   MeshSaveClass::get_skin_modifier_objects -- Searches for the WWSkin modifier for this mes *
 *   MeshSaveClass::inv_deform_mesh -- preprocess the mesh for skinning                        * 
 *   MeshSaveClass::create_materials -- create the materials for this mesh                     * 
 *   MeshSaveClass::write_ps2_shaders -- Write shaders specific to the PS2 in their own chunk. * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
 
#include "meshsave.h"
#include <Max.h>
#include <stdmat.h>
#include <modstack.h>
#include "gamemtl.h"
#include "errclass.h"
#include "vxl.h"
#include "vxldbg.h"
#include "nodelist.h"
#include "hiersave.h"
#include "util.h"
#include "w3dappdata.h"
#include "skin.h"
#include "skindata.h"
#include "meshbuild.h"
#include "alphamodifier.h"
#include "aabtreebuilder.h"
#include "exportlog.h"
 
 
static char _string1[512];
const int VOXEL_RESOLUTION = 64;        // resolution to use when computing I, V and CM
 
#define DEBUG_VOXELS                0
#define MIN_AABTREE_POLYGONS    8
#define DIFFUSE_HOUSECOLOR_TEXTURE_PREFIX 0x4443485A        //'ZHCD' prefix put on all code generated textures
#define DIFFUSE_COLOR_TEXTURE_PREFIX 0x44434d5A     //'ZMCD' prefix put on all code generated textures
#define DIFFUSE_COLOR_TEXTURE_MASK   0x4443005A
 
/************************************************************************************
**
** Compute the determinant of the 3x3 portion of the given matrix
**
************************************************************************************/
float Compute_3x3_Determinant(const Matrix3 & tm)
{
    float det = tm[0][0] * (tm[1][1]*tm[2][2] - tm[1][2]*tm[2][1]);
    det -=      tm[0][1] * (tm[1][0]*tm[2][2] - tm[1][2]*tm[2][0]);
    det +=      tm[0][2] * (tm[1][0]*tm[2][1] - tm[1][1]*tm[2][0]);
 
    return det;
}
 
/************************************************************************************
**
** check if this is a mesh which should use a simple rendering method.  I don't
** compute vertex normals or store u-v's in that case (prevents vertex splitting)
**
************************************************************************************/
bool use_simple_rendering(int geo_type) 
{
    geo_type &= W3D_MESH_FLAG_GEOMETRY_TYPE_MASK;
 
    if (    (geo_type == OBSOLETE_W3D_MESH_FLAG_GEOMETRY_TYPE_SHADOW) ||
            (geo_type == W3D_MESH_FLAG_GEOMETRY_TYPE_AABOX) ||
            (geo_type == W3D_MESH_FLAG_GEOMETRY_TYPE_OBBOX) ) 
    {
        return true;
    } else {
        return false;
    }
}       
 
/************************************************************************************
**
** build the bitfield of W3D mesh attributes for the given node
**
************************************************************************************/
uint32 setup_mesh_attributes(INode * node)
{
    uint32 attributes = W3D_MESH_FLAG_NONE;
 
    /*
    ** Mesh will be one of:
    ** W3D_MESH_FLAG_NONE,
    ** W3D_MESH_FLAG_COLLISION_BOX,
    ** W3D_MESH_FLAG_SKIN,
    ** W3D_MESH_FLAG_ALIGNED
    ** W3D_MESH_FLAG_ORIENTED
    */
    if (Is_Collision_AABox(node)) {
        attributes = W3D_MESH_FLAG_GEOMETRY_TYPE_AABOX;
    } else if (Is_Collision_OBBox(node)) {
        attributes = W3D_MESH_FLAG_GEOMETRY_TYPE_OBBOX;
    } else if (Is_Skin(node)) {
        attributes = W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN;
    } else if (Is_Camera_Aligned_Mesh(node)) {
        attributes = W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ALIGNED;
    } else if (Is_Camera_Oriented_Mesh(node)) {
        attributes = W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ORIENTED;
    }
 
    /*
    ** And, a mesh may have one or more types of collision detection enabled.
    ** W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL
    ** W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE
    ** However, if the mesh is SKIN, SHADOW, ALIGNED, ORIENTED or NULL, don't let
    ** the collision bits get set...
    */
    if (    attributes != W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN &&
            attributes != W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ALIGNED &&
            attributes != W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ORIENTED ) 
    {
    
        if (Is_Physical_Collision(node)) {
            attributes |= W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL;
        }
 
        if (Is_Projectile_Collision(node)) {
            attributes |= W3D_MESH_FLAG_COLLISION_TYPE_PROJECTILE;
        }
 
        if (Is_Vis_Collision(node)) {
            attributes |= W3D_MESH_FLAG_COLLISION_TYPE_VIS;
        }
 
        if (Is_Camera_Collision(node)) {
            attributes |= W3D_MESH_FLAG_COLLISION_TYPE_CAMERA;
        }
    
        if (Is_Vehicle_Collision(node)) {
            attributes |= W3D_MESH_FLAG_COLLISION_TYPE_VEHICLE;
        }
 
    }
 
    /*
    ** A mesh may have one of the following bits set as well
    */
    if (Is_Hidden(node)) {
        attributes |= W3D_MESH_FLAG_HIDDEN;
    }
    if (Is_Two_Sided(node)) {
        attributes |= W3D_MESH_FLAG_TWO_SIDED;
    }
    if (Is_Shadow(node)) {
        attributes |= W3D_MESH_FLAG_CAST_SHADOW;
    }
    if (Is_Shatterable(node)) {
        attributes |= W3D_MESH_FLAG_SHATTERABLE;
    }
    if (Is_NPatchable(node)) {
        attributes |= W3D_MESH_FLAG_NPATCHABLE;
    }
 
    return attributes;
}
 
 
 
/*********************************************************************************************** 
 * MeshSaveClass::MeshSaveClass -- constructor, processes a Max mesh                           * 
 *                                                                                             * 
 * This class takes a MAX mesh and computes the information for a W3D mesh or skin.            * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * inode - the max INode containing the mesh/skin to export                                    * 
 * exportspace - matrix defining the desired coordinate system for the mesh                    * 
 * htree - hierarchy tree that this mesh is being connected to                                 * 
 * curtime - current time in Max.                                                              * 
 * meter - progress meter                                                                      * 
 * mesh_name - name to use for the mesh                                                        * 
 * container_name - name of the container                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
MeshSaveClass::MeshSaveClass
(
    char * mesh_name,
    char * container_name,
    INode * inode,
    const Mesh * input_mesh,
    Matrix3 & exportspace,
    W3DAppData2Struct  & exportoptions,
    HierarchySaveClass * htree,
    TimeValue curtime,
    Progress_Meter_Class & meter,
    unsigned int *  materialColors,
    int &numMaterialColors,
    int &numHouseColors,
    char *materialColorTexture,
    WorldInfoClass * world_info
) :
    MaxINode(inode),
    ExportOptions(exportoptions),
    CurTime(curtime),
    ExportSpace(exportspace),
    HTree(htree),
    UserText(NULL),
    VertInfluences(NULL),
    MaterialRemapTable(NULL)
{
    Mesh            mesh = *input_mesh;     // copy the mesh so we can modify it
    Mtl *          nodemtl = inode->GetMtl();
    DWORD         wirecolor = inode->GetWireColor();
 
    PS2Material = FALSE;
 
    // Check to see if the mesh uses PS2 game materials.  If so, set a flag so
    // that write_shaders will know to make a PS2 shader chunk.
    if (nodemtl) {
        if (nodemtl->ClassID() == PS2GameMaterialClassID) {
            PS2Material = TRUE;
        } else if (nodemtl->IsMultiMtl()) {
            for (int i = 0; i < nodemtl->NumSubMtls(); i++) {
                Mtl *sub = nodemtl->GetSubMtl(i);
                if (sub->ClassID() == PS2GameMaterialClassID) {
                    PS2Material = TRUE;
                }
            }
        }
    } 

    // Check if the mesh is being inverted by its transform.  If this
    // is the case, then we will need to reverse the winding of all 
    // polygons later.
    Matrix3 objtm = MaxINode->GetObjectTM(curtime);
    MeshInverted = (Compute_3x3_Determinant(objtm) < 0.0f);

    // Prep the mesh by transforming it by the delta between exportspace
    // and this INodes current space
    // (this is the delta between the bone and the mesh if one exists...)
    MeshToExportSpace = objtm * Inverse(ExportSpace);
    prep_mesh(mesh,MeshToExportSpace);

    // Prepare the mesh header.
    assert(mesh_name != NULL);
    assert(container_name != NULL);
 
    memset(&Header,0,sizeof(Header));
    Set_W3D_Name(Header.MeshName,mesh_name);
    Set_W3D_Name(Header.ContainerName,container_name);
 
    Header.Version = W3D_CURRENT_MESH_VERSION;
    Header.Attributes = setup_mesh_attributes(MaxINode);
 
    meter.Finish_In_Steps(   
            3*Header.NumTris +      // normals
            Header.NumVertices +        // surrender normals
            64                              // voxelization         
    );
 
    ExportLog::printf("\nProcessing Mesh: %s\n",Header.MeshName);

    // Enforce that we have enough data to actually make a mesh
    if (mesh.getNumFaces() <= 0) {
        throw ErrorClass("No Triangles in Mesh: %s",Header.MeshName);
    }
 
    if (mesh.getNumVerts() <= 0) {
        throw ErrorClass("No Vertices in Mesh: %s",Header.MeshName);
    }

    // process the materials
    DebugPrint("processing materials\n");
    scan_used_materials(mesh,nodemtl);
    create_materials(nodemtl,wirecolor,materialColorTexture);
    
    // what face and vertex attributes are we going to export?
    Header.FaceChannels = W3D_FACE_CHANNEL_FACE;
    Header.VertexChannels = W3D_VERTEX_CHANNEL_LOCATION;
 
    if (!use_simple_rendering(Header.Attributes)) {
        Header.VertexChannels |= W3D_VERTEX_CHANNEL_NORMAL;
    } 
 
    if (((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) == W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN) && (HTree != NULL)) {
        Header.VertexChannels |= W3D_VERTEX_CHANNEL_BONEID;
    }
    
    // Process the mesh
    Builder.Set_World_Info (world_info);
    Build_Mesh(mesh, nodemtl, materialColors, numMaterialColors, numHouseColors);
 
    if (materialColorTexture)
    {   //diffuse color materials are replaced by textures
        //set diffuse to 255,255,255 so it has no effect.
        fix_diffuse_materials(numHouseColors != 0);
    }

    // Create damage (deform) information for the mesh
    Object *ref_obj = MaxINode->GetObjectRef ();
    DeformSave.Initialize(Builder, ref_obj, mesh, &MeshToExportSpace);

    // Determine if the deformer should use alpha or v-color info
    if (ExportOptions.Is_Vertex_Alpha_Enabled()) {
        unsigned int alpha_passes = 0;
        for (int pass=0; pass < MaterialDesc.Pass_Count(); pass++) {
            if (MaterialDesc.Pass_Uses_Vertex_Alpha(pass)) {
                alpha_passes |= (1 << pass);
            }
        }
        DeformSave.Set_Alpha_Passes(alpha_passes);
    }

    // Set the counts in the mesh header
    Header.NumTris = Builder.Get_Face_Count();
    Header.NumVertices = Builder.Get_Vertex_Count();

    // Compute the mesh's bounding box and sphere. This must be done
    // before we pre-deform the mesh (if its a skin).
    compute_bounding_volumes();

    // Voxelize the mesh and compute the Moment of Inertia and
    // Center of Mass.  This must come after we compute the bounding
    // volumes and before we pre-deform the mesh.
    Progress_Meter_Class voxelmeter(meter, 64.0f * meter.Increment);
    compute_physical_constants(MaxINode,voxelmeter,false /*usevoxelizer*/);
    
    // If this is a skin, pre-deform the mesh.
    if (((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) == W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN) && (HTree != NULL)) {
        inv_deform_mesh();
    }
    
    // Get the user text from MAX's properties window.
    TSTR usertext;
    MaxINode->GetUserPropBuffer(usertext);
    CStr usertext8 = usertext;
 
    if (usertext8.Length() > 0) {
        UserText = new char[usertext8.Length() + 1];
        memset(UserText,0,usertext8.Length() + 1);
        memcpy(UserText,usertext8.data(),usertext8.Length());
    }
}
 
/*********************************************************************************************** 
 * MeshSaveClass::~MeshSaveClass -- destructor, frees all allocated memory                     * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
MeshSaveClass::~MeshSaveClass(void)
{
    if (UserText) {
        delete[] UserText;
        UserText = NULL;
    }
 
    if (VertInfluences) {
        delete[] VertInfluences;
        VertInfluences = NULL;
    }
    
    if (MaterialRemapTable) {
        delete[] MaterialRemapTable;
        MaterialRemapTable = NULL;
    }
}
 
//search through previously found material colors and return index.  house colors are always placed in top row.
void getMaterialUV(UVVert &tvert,unsigned int diffuse, unsigned int *materialColors, int &numMaterialColors, int &numHouseColors, bool house)
{
    int i;
 
    if (house)
    {   //this material is a house color, place it in first row.
        for (i=0; i<16; i++)
        {
            if (materialColors[i]==diffuse)
            {
                tvert.x=((double)(i%16)+0.5)/16.0;  
                tvert.y=1.0-((double)(i/16)+0.5)/16.0;
                numHouseColors=16;
                return;
            }
        }
 
        ExportLog::printf("\nUndefined House Color %d,%d,%d",(diffuse>>16)&0xff,(diffuse>>8)&0xff,diffuse&0xff);
        assert(0);  //all house colors must be from a predefined range of reds
    }
 
    for (i=16; i<(16+numMaterialColors); i++)
    {
        if (materialColors[i]==diffuse)
        {
            tvert.x=((double)(i%16)+0.5)/16.0;  
            tvert.y=1.0-((double)(i/16)+0.5)/16.0;
            return;
        }
    }
 
    //new color found
    tvert.x=((double)(i%16)+0.5)/16.0;  
    tvert.y=1.0-((double)(i/16)+0.5)/16.0;
 
    materialColors[i]=diffuse;
    numMaterialColors++;
}
 
void MeshSaveClass::Build_Mesh(Mesh & mesh, Mtl *node_mtl, unsigned int *materialColors, int &numMaterialColors, int &numHouseColors)
{
    int vert_counter;
    int face_index;
    int pass;
    int stage;
    float *vdata = NULL;
    int firstSolidColoredMaterial=-1;
 
    Builder.Reset(true,mesh.getNumFaces(),mesh.getNumFaces()/3);
 
    // Get a pointer to the channel that has alpha values entered by the artist.
    // This pointer will be NULL if they didn't use the channel.
    vdata = mesh.vertexFloat(ALPHA_VERTEX_CHANNEL);
 
    /*
    ** Get the skin info
    */
    bool                                is_skin = false;
    SkinDataClass *             skindata = NULL;
    SkinWSMObjectClass *            skinobj = NULL;
    
    get_skin_modifier_objects(&skindata,&skinobj);
    
    if (    ((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) == W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN) && 
            (HTree != NULL) ) 
    { 
        is_skin = ((skindata != NULL) && (skinobj != NULL));
    }
 
    /*
    ** Submit all of the faces
    */
    MeshBuilderClass::FaceClass face;
    for (face_index = 0; face_index < mesh.getNumFaces(); face_index++) {
 
        Face maxface = mesh.faces[face_index];
 
        int mat_index = 0;
        if (Header.NumMaterials > 0) {
            mat_index = MaterialRemapTable[(maxface.getMatID() % Header.NumMaterials)];
        }       
        assert(mat_index != -1); 
 
        for (pass=0; pass<MaterialDesc.Pass_Count(); pass++) {
            face.ShaderIndex[pass] = MaterialDesc.Get_Shader_Index(mat_index,pass);
            for (stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++) {
                face.TextureIndex[pass][stage] = MaterialDesc.Get_Texture_Index(mat_index,pass,stage);
            }
        }
    
        int geo_type = Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK;
 
        if ( use_simple_rendering(geo_type) ) {
            face.SmGroup = 0xFFFFFFFF;
        } else {
            face.SmGroup = maxface.getSmGroup();
        }
 
        face.Index = face_index;
        face.Attributes = 0;
        face.SurfaceType = 0;
 
        /*
        **  Lookup this face's surface type
        */
        Mtl *mtl_to_use = node_mtl;
        if ((node_mtl != NULL) && (node_mtl->NumSubMtls() > 1)) {
            mtl_to_use = node_mtl->GetSubMtl (maxface.getMatID() % node_mtl->NumSubMtls());
        }
 
        if ((mtl_to_use != NULL) && ((mtl_to_use->ClassID() == GameMaterialClassID) || 
             (mtl_to_use->ClassID() == PS2GameMaterialClassID))) {            
            face.SurfaceType = ((GameMtl *)mtl_to_use)->Get_Surface_Type ();
        }
 
        for (vert_counter = 0; vert_counter < 3; vert_counter++) {
 
            /*
            ** if this mesh is being inverted, we need to insert the verts in
            ** the opposite order.  max_vert_counter will count backwards
            ** in this case; causing all vertex data to be entered in the
            ** reverse winding.
            */
            int max_vert_counter;
            
            if (MeshInverted) {
                max_vert_counter = 2 - vert_counter;
            } else {
                max_vert_counter = vert_counter;
            }
    
            int max_vert_index = maxface.v[max_vert_counter];
 
            /*
            ** Vertex Id, to prevent unwanted welding!
            */
            face.Verts[vert_counter].Id = max_vert_index;
 
            /*
            ** Vertex Position
            */
            face.Verts[vert_counter].Position.X = mesh.verts[max_vert_index].x;
            face.Verts[vert_counter].Position.Y = mesh.verts[max_vert_index].y;
            face.Verts[vert_counter].Position.Z = mesh.verts[max_vert_index].z;
 
            if (vdata) {
 
                // If an alpha channel has been created, use its value.
                for (int pass=0; pass < MaterialDesc.Pass_Count(); pass++) {
                    if (MaterialDesc.Pass_Uses_Vertex_Alpha(pass)) {
                        // Mulitiply by .01 to change from percentage.
                        face.Verts[vert_counter].Alpha[pass] = vdata[max_vert_index] * .01;
                    }
                }
            }
 
 
            /*
            ** Texture coordinate.  Apply uv coords if the mesh has them and is not being
            ** instructed to ignore them.  
            ** - check if the mesh needs them (uses_simple_rendering() == false)
            ** - for each pass and stage, look up what map channel this face's material is using
            ** - ask Max for the tfaces and tverts for that map channel
            ** - copy the values into each vertex
            */
            for (pass=0; pass<MaterialDesc.Pass_Count(); pass++) {
                for (stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++) {
 
                    /*
                    ** Start with a 0,0 uv coordinate
                    */
                    UVVert tvert(0.0,0.0,0.0);
 
                    W3dVertexMaterialStruct *vmat=MaterialDesc.Get_Vertex_Material(mat_index, pass);
                    //Check if this material needs material color texture substitution.
                    W3dMapClass *map3d=MaterialDesc.Get_Texture(mat_index,pass,stage);
                    if (map3d && map3d->Filename && *((unsigned int *)map3d->Filename) == DIFFUSE_COLOR_TEXTURE_PREFIX) //check for prefix
                    {
                        double Diffuse = vmat->Diffuse.Get_Color() >> 8;    //get material color
 
                        //MW: Encode the material color into the u texture coordinate
                        tvert.x=Diffuse;
                        tvert.y=Diffuse;
 
                        //find out material color location within texture page
                        if (strnicmp(MaterialDesc.Get_Vertex_Material_Name(mat_index,pass),"HouseColor",10)==0)
                            getMaterialUV(tvert,vmat->Diffuse.Get_Color() >> 8, materialColors, numMaterialColors, numHouseColors, true);
                        else
                            getMaterialUV(tvert,vmat->Diffuse.Get_Color() >> 8, materialColors, numMaterialColors, numHouseColors, false);
 
                        //Keep track of first vertex material converted, so we can remap all other non-textured
                        //materials to use the same material.
                        if (firstSolidColoredMaterial == -1)
                            firstSolidColoredMaterial=MaterialDesc.Get_Vertex_Material_Index(mat_index,pass);
                    }
 
                    /*
                    ** If the mesh needs uv coords and they are present, copy the uv into tvert
                    */
                    else
                    if (!use_simple_rendering(Header.Attributes)) {
                    
                        int channel = MaterialDesc.Get_Map_Channel(mat_index,pass,stage);
                        
                        UVVert * uvarray = mesh.mapVerts(channel);
                        TVFace * tvfacearray = mesh.mapFaces(channel);

                        W3dMapClass *map3d=MaterialDesc.Get_Texture(mat_index,pass,stage);
 
                        if (map3d && (uvarray != NULL) && (tvfacearray != NULL)) {
                            
                            int tvert_index = tvfacearray[face_index].t[max_vert_counter];
                            tvert = uvarray[tvert_index];
                        }
                    }
 
                    /*
                    ** Copy the texture coordinate into the vertex structure
                    */
                    face.Verts[vert_counter].TexCoord[pass][stage].X = tvert.x;
                    face.Verts[vert_counter].TexCoord[pass][stage].Y = tvert.y;
 
                }
            }
 
            /*
            ** Vertex Color
            */
            if (mesh.vcFace) {
                
                /*
                ** If the mesh is being mirrored, remap the index
                */
                int max_cvert_index = mesh.vcFace[face_index].t[max_vert_counter];
                
                VertColor vc;
                vc = mesh.vertCol[max_cvert_index];
                
                /*              
                ** If Vertex Alpha is specified, the vertex color is converted
                ** to alpha.  If the (obsolete) Node-flag for vertex alpha is enabled,
                ** the alpha is put into each pass which has alpha enabled.  Otherwise,
                ** we check the material settings for which passes should get the alpha
                ** values.  If neither alpha options are enabled, we put the color
                ** value into the first pass.
                */
                if (ExportOptions.Is_Vertex_Alpha_Enabled()) {
                
                    float   alpha = (vc.x + vc.y + vc.z) / 3.0f;
                    for (int pass=0; pass < MaterialDesc.Pass_Count(); pass++) {
                        if (MaterialDesc.Pass_Uses_Vertex_Alpha(pass)) {
                            face.Verts[vert_counter].Alpha[pass] = alpha;
                        }
                    }
                } else {
                    face.Verts[vert_counter].DiffuseColor[0].X = vc.x;
                    face.Verts[vert_counter].DiffuseColor[0].Y = vc.y;
                    face.Verts[vert_counter].DiffuseColor[0].Z = vc.z;
                }
                
                face.Verts[vert_counter].MaxVertColIndex = max_cvert_index;
 
            } else {
                face.Verts[vert_counter].MaxVertColIndex = 0;
            }
 
            /*
            ** Vertex materials (get's index of sub-material)
            */
            for (pass = 0; pass<MaterialDesc.Pass_Count(); pass++) {
 
                //if solid-color texture substitution, replace the vertex material with first solid one found.
                W3dMapClass *map3d=MaterialDesc.Get_Texture(mat_index,pass,0);
                if (map3d && map3d->Filename && *((unsigned int *)map3d->Filename) == DIFFUSE_COLOR_TEXTURE_PREFIX) //check for prefix
                    face.Verts[vert_counter].VertexMaterialIndex[pass]=firstSolidColoredMaterial;
                else
                    face.Verts[vert_counter].VertexMaterialIndex[pass] = MaterialDesc.Get_Vertex_Material_Index(mat_index,pass);
            }
 
            face.Verts[vert_counter].Attribute0 = max_vert_index;
            face.Verts[vert_counter].Attribute1 = face_index;
 
            /*
            ** Skin attachment
            */
            face.Verts[vert_counter].BoneIndex = 0;
            if (is_skin) {
                
                int skin_bone_index = skindata->VertData[max_vert_index].BoneIdx[0];
    
                // If this is a valid bone, try to find the corresponding bone index in the HTree
                if (    (skin_bone_index != -1) && 
                        (skin_bone_index < skinobj->Num_Bones()) &&
                        (skinobj->BoneTab[skin_bone_index] != NULL)  ) 
                {
                    face.Verts[vert_counter].BoneIndex = get_htree_bone_index_for_inode(skinobj->BoneTab[skin_bone_index]);
                }
            } 
        }
        
        Builder.Add_Face(face);
    }
 
    /*
    ** Process the mesh
    */
    Builder.Build_Mesh(true);
 
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
    int vcount = Builder.Get_Vertex_Count();
    int pcount = mesh.numFaces;
    float vert_poly_ratio = (float)vcount / (float)pcount;
    
    ExportLog::printf(" triangle count: %d\n",pcount);
    ExportLog::printf(" final vertex count: %d\n",vcount);
    ExportLog::printf(" vertex/triangle ratio: %f\n",vert_poly_ratio);
    ExportLog::printf(" strip count: %d\n",stats.StripCount);
    ExportLog::printf(" average strip length: %f\n",stats.AvgStripLength);
    ExportLog::printf(" longest strip: %d\n",stats.MaxStripLength);
}
 
 
/***********************************************************************************************
 * MeshSaveClass::get_skin_modifier_objects -- Searches for the WWSkin modifier for this mesh  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
void MeshSaveClass::get_skin_modifier_objects(SkinDataClass ** skin_data_ptr,SkinWSMObjectClass ** skin_obj_ptr)
{   
    *skin_data_ptr = NULL;
    *skin_obj_ptr = NULL;
 
    // loop through the references that our node has
    for (int i = 0; i < MaxINode->NumRefs(); i++) {
 
        ReferenceTarget *refTarg = MaxINode->GetReference(i);
     
        // if the reference is a WSM Derived Object.
        if (refTarg != NULL && refTarg->ClassID() == Class_ID(WSM_DERIVOB_CLASS_ID,0)) {
 
            IDerivedObject * wsm_der_obj = (IDerivedObject *)refTarg;
 
            // loop through the WSM's attached to this WSM Derived object
            for (int j = 0; j < wsm_der_obj->NumModifiers(); j++) {
                Modifier * mod = wsm_der_obj->GetModifier(j);
                if (mod->ClassID() == SKIN_MOD_CLASS_ID) {
 
                    // This is our modifier!  Get the data from it!
                    SkinModifierClass * skinmod = (SkinModifierClass *)mod;
                    ModContext * mc = wsm_der_obj->GetModContext(j);    
                    *skin_data_ptr = (SkinDataClass *)(mc->localData);
                    *skin_obj_ptr = (SkinWSMObjectClass *)skinmod->GetReference(SkinModifierClass::OBJ_REF);
                }
            }
        }
    }
}
 
 
/***********************************************************************************************
 * MeshSaveClass::get_htree_bone_index_for_inode -- searches the htree for the given INode     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   5/1/2000   gth : Created.                                                                 *
 *=============================================================================================*/
int MeshSaveClass::get_htree_bone_index_for_inode(INode * node)
{
    // index of this INode in the hierarchy tree (it better be there :-)
    char w3dname[W3D_NAME_LEN];
    Set_W3D_Name(w3dname,node->GetName());
    int bindex = HTree->Find_Named_Node(w3dname);
 
    // If the desired bone isn't being exported, export the point
    // relative to the root.
    if (bindex == -1) {
        bindex = 0;
    }
 
    return bindex;
}
 
/*********************************************************************************************** 
 * MeshSaveClass::inv_deform_mesh -- preprocess the mesh for skinning                          * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/26/1997 GH  : Created.                                                                 * 
 *   5/1/2000   gth : Created.                                                                 *
 *=============================================================================================*/
void MeshSaveClass::inv_deform_mesh()
{
    // Got the skinning info, now pre-deform each vertex and
    // create an array of vertex influence indexes.
    VertInfluences = new W3dVertInfStruct[Builder.Get_Vertex_Count()];
    memset(VertInfluences,0,sizeof(W3dVertInfStruct) * Builder.Get_Vertex_Count());
    Header.VertexChannels |= W3D_VERTEX_CHANNEL_BONEID;
 
    for (int vert_index = 0; vert_index < Builder.Get_Vertex_Count(); vert_index++) {
                
        MeshBuilderClass::VertClass & vert = Builder.Get_Vertex(vert_index);
 
        if (vert.BoneIndex == 0) {
 
            // set the influence to 0 (root node) and leave the vert and normal unchanged
            // (gth) 07/11/2000: Note that in this case, the mesh coordinates have already been 
            // transformed relative to the user or scene origin and do not need to be further modified.
            VertInfluences[vert_index].BoneIdx = 0;
 
        } else {
        
            // here we go! get the matrix from the hierarchy tree and transform
            // the point into the bone's coordinate system. 
            // (gth) 07/11/2000: The origin_offset_tm is no longer needed because
            // skin meshes are transformed into the origin coordinate system before
            // we get to this code.
            Matrix3 bonetm = HTree->Get_Node_Transform(vert.BoneIndex);
            Matrix3 invbonetm = Inverse(bonetm);
            Point3 pos;
            
            pos.x = vert.Position.X;
            pos.y = vert.Position.Y;
            pos.z = vert.Position.Z;
            
            pos = pos * invbonetm;
            
            vert.Position.X = pos.x;
            vert.Position.Y = pos.y;
            vert.Position.Z = pos.z;
 
            // Now, transform the normal into the bone's coordinate system.  
            invbonetm.NoTrans();
            Point3 norm;
 
            norm.x = vert.Normal.X;
            norm.y = vert.Normal.Y;
            norm.z = vert.Normal.Z;
 
            norm = norm * invbonetm;
 
            vert.Normal.X = norm.x;
            vert.Normal.Y = norm.y;
            vert.Normal.Z = norm.z;
 
            VertInfluences[vert_index].BoneIdx = vert.BoneIndex;
        }
    }
}
 
 
/*********************************************************************************************** 
 * MeshSaveClass::Write_To_File -- Append the mesh to an open wtm file                         * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *    csave - ChunkSaveClass object to handle writing the chunk-based file                        * 
 *  export_aabtree - should we generate an aabtree for this mesh                             *
 *                                                                                                                        * 
 * OUTPUT:                                                                                                                * 
 *    0 if nothing went wrong, Non-Zero otherwise                                                             * 
 *                                                                                                                        * 
 * WARNINGS:                                                                                                              * 
 *                                                                                             * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::Write_To_File(ChunkSaveClass & csave,bool export_aabtree)
{
    if (!csave.Begin_Chunk(W3D_CHUNK_MESH)) {
        return 1;
    }
 
    if (write_header(csave) != 0) {
        return 1;
    }
 
    if (write_user_text(csave) != 0) {
        return 1;
    }
 
    if (write_verts(csave) != 0) {
        return 1;
    }
 
    if (write_vert_normals(csave) != 0) {
        return 1;
    }
 
    if (write_triangles(csave) != 0) {
        return 1;
    }
 
    if (write_vert_influences(csave) != 0) {
        return 1;
    }
 
    if (write_vert_shade_indices(csave) != 0) {
        return 1;
    }
 
    if (write_material_info(csave) != 0) {
        return 1;
    }
 
    if (write_vertex_materials(csave) != 0) {
        return 1;
    }
    
    if (PS2Material == TRUE) {
 
        // The ps2 shaders must be written out first.
        if (write_ps2_shaders(csave) != 0) {
            return 1;
        }
    }
 
    if (write_shaders(csave) != 0) {
        return 1;
    }
 
    
    if (write_textures(csave) != 0) {
        return 1;
    }
 
    for (int pass=0; pass<MaterialDesc.Pass_Count(); pass++) {
        if (write_pass(csave,pass) != 0) {
            return 1;
        }
    }
 
    if (DeformSave.Export (csave) != true) {
        return 1;
    }   
 
    if (export_aabtree == true) {
        if (write_aabtree(csave) != 0) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
/*********************************************************************************************** 
 * MeshSaveClass::write_header -- write a mesh header chunk into a wtm file                    * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *    csave - chunk save object                                                                           * 
 *                                                                                                                        * 
 * OUTPUT:                                                                                                                * 
 *    0 if nothing went wrong, Non-Zero otherwise                                                             * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::write_header(ChunkSaveClass & csave)
{
    if (!csave.Begin_Chunk(W3D_CHUNK_MESH_HEADER3)) {
        return 1;
    }
    
    if (csave.Write(&Header,sizeof(W3dMeshHeader3Struct)) != sizeof(W3dMeshHeader3Struct)) {
        return 1;
    }
    
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
/*********************************************************************************************** 
 * MeshSaveClass::write_user_text -- write the user text chunk                                 * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   08/20/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::write_user_text(ChunkSaveClass & csave)
{
    // If there's no user text, just don't write the chunk
    if (UserText == NULL) {
        return 0;
    }
 
    if (!csave.Begin_Chunk(W3D_CHUNK_MESH_USER_TEXT)) {
        return 1;
    }
    
    // write the user text buffer (writing one extra byte to include the NULL)
    if (csave.Write(UserText,strlen(UserText) + 1) != strlen(UserText) + 1) {
        return 1;
    } 
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
/*********************************************************************************************** 
 * MeshSaveClass::write_verts -- write the vertex chunk into a wtm file                        * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *    csave - chunk save object                                                                           * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *    0 if nothing went wrong, Non-Zero otherwise                                                             * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::write_verts(ChunkSaveClass & csave)
{
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTICES)) {
        return 1;
    }
    
    assert(Builder.Get_Vertex_Count() > 0);
    assert(Builder.Get_Vertex_Count() == (int)Header.NumVertices);
 
    for (int i=0; i<Builder.Get_Vertex_Count(); i++) {
 
        const MeshBuilderClass::VertClass & vert = Builder.Get_Vertex(i);
 
        if ((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) != W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN) {
            
            assert(vert.Position.X <= Header.Max.X);
            assert(vert.Position.Y <= Header.Max.Y);
            assert(vert.Position.Z <= Header.Max.Z);
 
            assert(vert.Position.X >= Header.Min.X);
            assert(vert.Position.Y >= Header.Min.Y);
            assert(vert.Position.Z >= Header.Min.Z);
        
        }
 
        W3dVectorStruct w3dvert;
        w3dvert.X = vert.Position.X;
        w3dvert.Y = vert.Position.Y;
        w3dvert.Z = vert.Position.Z;
        
        if (csave.Write(&(w3dvert),sizeof(W3dVectorStruct)) != sizeof(W3dVectorStruct)) {
            return 1;
        }
    }
    
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
 
/*********************************************************************************************** 
 * MeshSaveClass::write_vert_normals -- Writes the surrender normal chunk into a wtm file      * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *    csave - chunk save object                                                                           * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *    0 if nothing went wrong, Non-Zero otherwise                                                             * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::write_vert_normals(ChunkSaveClass & csave)
{
    if (!(Header.VertexChannels & W3D_VERTEX_CHANNEL_NORMAL)) return 0;
    
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_NORMALS)) {
        return 1;
    }
    
    for (int i=0; i < Builder.Get_Vertex_Count(); i++) {
 
        const MeshBuilderClass::VertClass & vert = Builder.Get_Vertex(i);
 
        W3dVectorStruct norm;
 
        if (ExportOptions.Is_ZNormals_Enabled()) {
            norm.X = 0.0f;
            norm.Y = 0.0f;
            norm.Z = 1.0f;
        } else {
            norm.X = vert.Normal.X;
            norm.Y = vert.Normal.Y;
            norm.Z = vert.Normal.Z;
        }
        
        if (csave.Write(&(norm),sizeof(W3dVectorStruct)) != sizeof(W3dVectorStruct)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
/*********************************************************************************************** 
 * MeshSaveClass::write_vert_influences -- skins will have this chunk that binds verts to bones* 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *    csave - chunk save object                                                                               * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *    0 if nothing went wrong, Non-Zero otherwise                                                             * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   06/10/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
int MeshSaveClass::write_vert_influences(ChunkSaveClass & csave)
{
    if (((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK) != W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN) || 
         !(Header.VertexChannels & W3D_VERTEX_CHANNEL_BONEID) || 
         (VertInfluences == NULL)) {
        return 0;
    }
 
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_INFLUENCES)) {
        return 1;
    }
    
    int count = Builder.Get_Vertex_Count();
    if (csave.Write(VertInfluences,count * sizeof(W3dVertInfStruct)) != count * sizeof(W3dVertInfStruct)) {
        return 1;
    }
    
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
 
/***********************************************************************************************
 * MeshSaveClass::write_triangles -- write the triangles chunk                                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   4/7/98     GTH : Created.                                                                 *
 *=============================================================================================*/
int MeshSaveClass::write_triangles(ChunkSaveClass & csave)
{
    if (!csave.Begin_Chunk(W3D_CHUNK_TRIANGLES)) {
        return 1;
    }
 
    assert(Builder.Get_Face_Count() == (int)Header.NumTris);
    for (int i=0; i<Builder.Get_Face_Count(); i++) {
 
        const MeshBuilderClass::FaceClass & face = Builder.Get_Face(i);
 
        W3dTriStruct tri;
        memset(&tri,0,sizeof(W3dTriStruct));
 
        // convert each triangle into surrender format
        tri.Vindex[0] =           face.VertIdx[0];
        tri.Vindex[1] =           face.VertIdx[1];
        tri.Vindex[2] =           face.VertIdx[2];
        
        tri.Attributes =          face.SurfaceType;
        tri.Normal.X =           face.Normal.X;
        tri.Normal.Y =           face.Normal.Y;
        tri.Normal.Z =           face.Normal.Z;
        tri.Dist =                  face.Dist;
 
        // write each triangle
        if (csave.Write(&tri,sizeof(W3dTriStruct)) != sizeof(W3dTriStruct)) {
            return 1;
        } 
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
int MeshSaveClass::write_vert_shade_indices(ChunkSaveClass & csave)
{
    if (!(Header.VertexChannels & W3D_VERTEX_CHANNEL_NORMAL)) return 0;
    
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_SHADE_INDICES)) {
        return 1;
    }
    
    for (int i=0; i < Builder.Get_Vertex_Count(); i++) {
 
        const MeshBuilderClass::VertClass & vert = Builder.Get_Vertex(i);
 
        uint32 shade_index = vert.ShadeIndex;
        
        if (csave.Write(&(shade_index),sizeof(shade_index)) != sizeof(shade_index)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return 0;
}
 
int MeshSaveClass::write_material_info(ChunkSaveClass & csave)
{
    if (!csave.Begin_Chunk(W3D_CHUNK_MATERIAL_INFO)) {
        return 1;
    }
 
    W3dMaterialInfoStruct matinfo;
    matinfo.PassCount = MaterialDesc.Pass_Count();
    matinfo.VertexMaterialCount = MaterialDesc.Vertex_Material_Count();
    matinfo.ShaderCount = MaterialDesc.Shader_Count();
    matinfo.TextureCount = MaterialDesc.Texture_Count();
 
    if (csave.Write(&matinfo,sizeof(matinfo)) != sizeof(matinfo)) {
        return 1;
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_vertex_materials(ChunkSaveClass & csave)
{
    if (MaterialDesc.Vertex_Material_Count() <= 0) return 0;
 
    // open a chunk which wraps all of the vertex materials
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIALS)) {
        return 1;
    }
 
    for (int i=0; i<MaterialDesc.Vertex_Material_Count(); i++) {
        
        csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL);
        
        // write the filename
        const char * name = MaterialDesc.Get_Vertex_Material_Name(i);
        if (name != NULL) {
            csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL_NAME);
            if (csave.Write(name,strlen(name) + 1) != strlen(name) + 1) {
                return 1;
            }
            csave.End_Chunk();
        }
 
        // write the struct
        W3dVertexMaterialStruct * vmat = MaterialDesc.Get_Vertex_Material(i);
        csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL_INFO);
        if (csave.Write(vmat,sizeof(W3dVertexMaterialStruct)) != sizeof(W3dVertexMaterialStruct)) {
            return 1;
        }
        csave.End_Chunk();
 
        // write the mapper args
        const char * args = MaterialDesc.Get_Mapper_Args(i, 0);
        if (args != NULL) {
            csave.Begin_Chunk(W3D_CHUNK_VERTEX_MAPPER_ARGS0);
            if (csave.Write(args,strlen(args) + 1) != strlen(args) + 1) {
                return 1;
            }
            csave.End_Chunk();
        }
        args = MaterialDesc.Get_Mapper_Args(i, 1);
        if (args != NULL) {
            csave.Begin_Chunk(W3D_CHUNK_VERTEX_MAPPER_ARGS1);
            if (csave.Write(args,strlen(args) + 1) != strlen(args) + 1) {
                return 1;
            }
            csave.End_Chunk();
        }
 
        csave.End_Chunk();
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_shaders(ChunkSaveClass & csave)
{
    assert(MaterialDesc.Shader_Count() > 0);
    
    if (PS2Material == TRUE) {
 
        // Make the PC shader as close to the PS2 shader as possible.
        // This will allow for viewing in W3D View.
        setup_PC_shaders_from_PS2_shaders();
    }
 
    if (!csave.Begin_Chunk(W3D_CHUNK_SHADERS)) {
        return 1;
    }
 
    W3dShaderStruct * shader;
 
    for (int i=0; i<MaterialDesc.Shader_Count(); i++) {
        shader = MaterialDesc.Get_Shader(i);
        if (csave.Write(shader,sizeof(W3dShaderStruct)) != sizeof(W3dShaderStruct)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
 
/***********************************************************************************************
 * MeshSaveClass::write_ps2_shaders -- Write shaders specific to the PS2 in their own chunk.   *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   10/20/1999MLL: Created.                                                                   *
 *=============================================================================================*/
int MeshSaveClass::write_ps2_shaders(ChunkSaveClass & csave)
{
 
    if (!csave.Begin_Chunk(W3D_CHUNK_PS2_SHADERS)) {
        return 1;
    }
 
    W3dShaderStruct *shader;
    W3dPS2ShaderStruct ps2shader;
 
    for (int i=0; i<MaterialDesc.Shader_Count(); i++) {
        shader = MaterialDesc.Get_Shader(i);
 
        ps2shader.AlphaTest = W3d_Shader_Get_Alpha_Test(shader);
        ps2shader.AParam = W3d_Shader_Get_PS2_Param_A(shader);
        ps2shader.BParam = W3d_Shader_Get_PS2_Param_B(shader);
        ps2shader.CParam = W3d_Shader_Get_PS2_Param_C(shader);
        ps2shader.DParam = W3d_Shader_Get_PS2_Param_D(shader);
 
        // Write out the PS2 native form.
        switch (W3d_Shader_Get_Depth_Compare(shader))
        {
            case PSS_DEPTHCOMPARE_PASS_NEVER: 
                ps2shader.DepthCompare = 0;
                break;
            case PSS_DEPTHCOMPARE_PASS_LESS:
                ps2shader.DepthCompare = 3;
                break;
            case PSS_DEPTHCOMPARE_PASS_ALWAYS:  
                ps2shader.DepthCompare = 1;
                break;
            case PSS_DEPTHCOMPARE_PASS_LEQUAL:
                ps2shader.DepthCompare = 2;
                break;
        }
 
        ps2shader.DepthMask = !W3d_Shader_Get_Depth_Mask(shader);
 
        switch (W3d_Shader_Get_Pri_Gradient(shader))
        {
            case PSS_PRIGRADIENT_MODULATE:
                ps2shader.PriGradient = PSS_PS2_PRIGRADIENT_MODULATE;
                break;
 
            case PSS_PRIGRADIENT_HIGHLIGHT:
                ps2shader.PriGradient = PSS_PS2_PRIGRADIENT_HIGHLIGHT;
                break;
 
            case PSS_PRIGRADIENT_HIGHLIGHT2:
                ps2shader.PriGradient = PSS_PS2_PRIGRADIENT_HIGHLIGHT2;
                break;
 
            case PSS_PRIGRADIENT_DECAL:
                ps2shader.PriGradient = PSS_PS2_PRIGRADIENT_DECAL;
                break;
 
        }
 
        ps2shader.Texturing = W3d_Shader_Get_Texturing(shader);
 
        if (csave.Write(&ps2shader,sizeof(W3dPS2ShaderStruct)) != sizeof(W3dPS2ShaderStruct)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
 
    return (0);
}
 
void MeshSaveClass::setup_PC_shaders_from_PS2_shaders()
{
 
    W3dShaderStruct *shader;
 
    for (int i=0; i<MaterialDesc.Shader_Count(); i++) {
        shader = MaterialDesc.Get_Shader(i);
 
        // DepthCompare on the PS2 doesn't have as many options as on the PC.
        switch (W3d_Shader_Get_Depth_Compare(shader))
        {
            case PSS_DEPTHCOMPARE_PASS_NEVER:
                W3d_Shader_Set_Depth_Compare(shader, W3DSHADER_DEPTHCOMPARE_PASS_NEVER);
                break;
            case PSS_DEPTHCOMPARE_PASS_LESS:          
                W3d_Shader_Set_Depth_Compare(shader, W3DSHADER_DEPTHCOMPARE_PASS_LESS);
                break;
            case PSS_DEPTHCOMPARE_PASS_LEQUAL:              
                W3d_Shader_Set_Depth_Compare(shader, W3DSHADER_DEPTHCOMPARE_PASS_LEQUAL);
                break;
            case PSS_DEPTHCOMPARE_PASS_ALWAYS:
                W3d_Shader_Set_Depth_Compare(shader, W3DSHADER_DEPTHCOMPARE_PASS_ALWAYS);
                break;
        }
 
        // The PS2 has more gradient functions than the PC.
        switch (W3d_Shader_Get_Pri_Gradient(shader))
        {
            case PSS_PRIGRADIENT_MODULATE:
                W3d_Shader_Set_Pri_Gradient(shader, W3DSHADER_PRIGRADIENT_MODULATE);
                break;
 
            // No PC equivalent.  Set to default: modulate.
            case PSS_PRIGRADIENT_HIGHLIGHT:
            case PSS_PRIGRADIENT_HIGHLIGHT2:
            case PSS_PRIGRADIENT_DECAL:
                W3d_Shader_Set_Pri_Gradient(shader, W3DSHADER_PRIGRADIENT_MODULATE);
                break;
        }
 
 
    }
 
}
 
int MeshSaveClass::write_textures(ChunkSaveClass & csave)
{
    if (MaterialDesc.Texture_Count() <= 0) return 0;
 
    // open a chunk which wraps all textures
    if (!csave.Begin_Chunk(W3D_CHUNK_TEXTURES)) {
        return 1;
    }
 
    for (int i=0; i<MaterialDesc.Texture_Count(); i++) {
        
        W3dMapClass * map = MaterialDesc.Get_Texture(i);
        
        csave.Begin_Chunk(W3D_CHUNK_TEXTURE);
        
        // write the filename
        csave.Begin_Chunk(W3D_CHUNK_TEXTURE_NAME);
        if (csave.Write(map->Filename,strlen(map->Filename) + 1) != strlen(map->Filename) + 1) return 1;
        csave.End_Chunk();
 
        // optionally write an animation info chunk
        if (map->AnimInfo != NULL) {
            csave.Begin_Chunk(W3D_CHUNK_TEXTURE_INFO);
            if (csave.Write(map->AnimInfo,sizeof(W3dTextureInfoStruct)) != sizeof(W3dTextureInfoStruct)) return 1;
            csave.End_Chunk();
        }
 
        csave.End_Chunk();
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_pass(ChunkSaveClass & csave,int pass)
{
    assert(pass >= 0);
    assert(pass < MaterialDesc.Pass_Count());
 
    if (!csave.Begin_Chunk(W3D_CHUNK_MATERIAL_PASS)) {
        return 1;
    }
 
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
 
    if (stats.HasVertexMaterial[pass]) {
        write_vertex_material_ids(csave,pass);
    }
 
    if (stats.HasShader[pass]) {
        write_shader_ids(csave,pass);
    }
 
    if (stats.HasDiffuseColor[pass] || DeformSave.Does_Deformer_Modify_DCG ()) {
        write_dcg(csave,pass);
    }
 
    for (int stage = 0; stage < MeshBuilderClass::MAX_STAGES; stage++) {
        write_texture_stage(csave,pass,stage);
    }
    
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_vertex_material_ids(ChunkSaveClass & csave,int pass)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
 
    if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL_IDS)) {
        return 1;
    }
 
    uint32 matid;
 
    if (stats.HasPerVertexMaterial[pass]) {
        for (int i=0; i<Builder.Get_Vertex_Count(); i++) {
            matid = Builder.Get_Vertex(i).VertexMaterialIndex[pass];
            if (csave.Write(&matid,sizeof(uint32)) != sizeof(uint32)) return 1;
        }
    } else {
        matid = Builder.Get_Vertex(0).VertexMaterialIndex[pass];
        if (csave.Write(&matid,sizeof(uint32)) != sizeof(uint32)) return 1;
    }
        
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_shader_ids(ChunkSaveClass & csave,int pass)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
 
    if (!csave.Begin_Chunk(W3D_CHUNK_SHADER_IDS)) {
        return 1;
    }
 
    uint32 shaderid;
    if (stats.HasPerPolyShader[pass]) {
        for (int i=0; i<Builder.Get_Face_Count(); i++) {
            shaderid = Builder.Get_Face(i).ShaderIndex[pass];
            if (csave.Write(&shaderid,sizeof(uint32)) != sizeof(uint32)) return 1;
        }
    } else {
        shaderid = Builder.Get_Face(0).ShaderIndex[pass];
        if (csave.Write(&shaderid,sizeof(uint32)) != sizeof(uint32)) return 1;
    }
        
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_dcg(ChunkSaveClass & csave,int pass)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
 
    if (!csave.Begin_Chunk(W3D_CHUNK_DCG)) {
        return 1;
    }
 
    for (int i=0; i<Builder.Get_Vertex_Count(); i++) {
        Vector3 vcolor = Builder.Get_Vertex(i).DiffuseColor[pass];
        W3dRGBAStruct color;
        color.R = (uint8)(255.0f * vcolor.X);
        color.G = (uint8)(255.0f * vcolor.Y);
        color.B = (uint8)(255.0f * vcolor.Z);
 
        float a = Builder.Get_Vertex(i).Alpha[pass];
        color.A = (uint8)(255.0f * a);
 
        if (csave.Write(&(color),sizeof(W3dRGBAStruct)) != sizeof(W3dRGBAStruct)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_texture_stage(ChunkSaveClass & csave,int pass,int stage)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
    if (!stats.HasTexture[pass][stage]) return 0;
 
    if (!csave.Begin_Chunk(W3D_CHUNK_TEXTURE_STAGE)) {
        return 1;
    }
    
    write_texture_ids(csave,pass,stage);
    write_texture_coords(csave,pass,stage);
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
 
int MeshSaveClass::write_texture_ids(ChunkSaveClass & csave,int pass,int stage)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
 
    if (!csave.Begin_Chunk(W3D_CHUNK_TEXTURE_IDS)) {
        return 1;
    }
 
    uint32 texid;
    if (stats.HasPerPolyTexture[pass][stage]) {
        for (int i=0; i<Builder.Get_Face_Count(); i++) {
            texid = Builder.Get_Face(i).TextureIndex[pass][stage];
            if (csave.Write(&texid,sizeof(uint32)) != sizeof(uint32)) return 1;
        }
    } else {
        texid = Builder.Get_Face(0).TextureIndex[pass][stage];
        if (csave.Write(&texid,sizeof(uint32)) != sizeof(uint32)) return 1;
    }
        
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_texture_coords(ChunkSaveClass & csave,int pass,int stage)
{
    const MeshBuilderClass::MeshStatsStruct & stats = Builder.Get_Mesh_Stats();
    if (stats.HasTexCoords[pass][stage] == false) return 0;
 
    if (!csave.Begin_Chunk(W3D_CHUNK_STAGE_TEXCOORDS)) {
        return 1;
    }
 
    for (int i=0; i<Builder.Get_Vertex_Count(); i++) {
        W3dTexCoordStruct tex;
        tex.U = Builder.Get_Vertex(i).TexCoord[pass][stage].X;
        tex.V = Builder.Get_Vertex(i).TexCoord[pass][stage].Y;
        
        if (csave.Write(&(tex),sizeof(W3dTexCoordStruct)) != sizeof(W3dTexCoordStruct)) {
            return 1;
        }
    }
 
    if (!csave.End_Chunk()) {
        return 1;
    }
    return 0;
}
 
int MeshSaveClass::write_aabtree(ChunkSaveClass & csave)
{
    /*
    ** Don't bother with an AABTree if this not a normal mesh or if it has very few polygons
    */
    if (    (Builder.Get_Face_Count() >= MIN_AABTREE_POLYGONS) && 
            ((Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK)  == W3D_MESH_FLAG_GEOMETRY_TYPE_NORMAL)
        ) 
    {
 
        /*
        ** Build temporary array representations of the mesh
        */
        int vertcount = Builder.Get_Vertex_Count();
        int polycount = Builder.Get_Face_Count();
        Vector3 * verts = new Vector3[vertcount];
        Vector3i * polys = new Vector3i[polycount];
        
        for (int vi=0; vi<vertcount; vi++) {
            verts[vi] = Builder.Get_Vertex(vi).Position;
        }
 
        for (int pi=0; pi<polycount; pi++) {
            polys[pi].I = Builder.Get_Face(pi).VertIdx[0];
            polys[pi].J = Builder.Get_Face(pi).VertIdx[1];
            polys[pi].K = Builder.Get_Face(pi).VertIdx[2];
        }
 
        /*
        ** Build the AABTree and save it
        */
        AABTreeBuilderClass aabtree_builder;
        aabtree_builder.Build_AABTree(polycount,polys,vertcount,verts);
        aabtree_builder.Export(csave);
            
        /*
        ** Release the allocated resources
        */
        delete[] verts;
        delete[] polys;
    }
    
    return 0;
}
 
int MeshSaveClass::scan_used_materials(Mesh & mesh,Mtl * nodemtl)
{
    int face_index;
    int mat_index;
 
    if ((nodemtl == NULL) || (nodemtl->NumSubMtls() <= 1)) {
 
        MaterialRemapTable = new int[1];
        MaterialRemapTable[0] = 0;
        return 1;
 
    } else {
        
        int sub_mtl_count = nodemtl->NumSubMtls();
        MaterialRemapTable = new int[sub_mtl_count];
        
        // Initialize each remap to -1 (indicates that the material is un-used)
        for (mat_index=0; mat_index<sub_mtl_count; mat_index++) {
            MaterialRemapTable[mat_index] = -1;
        }
 
        // Set a 1 for each material actually referenced by the mesh
        for (face_index=0; face_index<mesh.getNumFaces(); face_index++) {
            int max_mat_index = mesh.faces[face_index].getMatID();
            int mat_index = (max_mat_index % sub_mtl_count);
            MaterialRemapTable[mat_index] = 1;
        }
 
        // Replace each 1 entry with an incrementing material index
        int matcount = 0;
        for (mat_index=0; mat_index<sub_mtl_count; mat_index++) {
            if (MaterialRemapTable[mat_index] == 1) {
                MaterialRemapTable[mat_index] = matcount;
                matcount++;
            }
        }
        
        assert(matcount > 0);
        return matcount;
    }
}
 
//Check if material is solid, non-textured.
int isTexturedMaterial(Mtl * mtl)
{
    Texmap * tmap;
 
    tmap = mtl->GetSubTexmap(ID_DI);
    if (mtl->ClassID() == GameMaterialClassID)
    {
        GameMtl * gamemtl=(GameMtl *)mtl;
 
        for (int pass=0;pass<gamemtl->Get_Pass_Count(); pass++)
        {
            for (int stage=0; stage < W3dMaterialClass::MAX_STAGES; stage++)
            {   if (gamemtl->Get_Texture_Enable(pass,stage) && gamemtl->Get_Texture(pass,stage))
                    return 1;   //using a texture
            }
        }
        return 0;
    }
    else
    {
        return (tmap && tmap->ClassID() == Class_ID(BMTEX_CLASS_ID,0));
    }
}
 
//count number of used solid materials (no texture)
int MeshSaveClass::getNumSolidMaterials(Mtl * nodemtl)
{
    int mat_index;
    int numSolid=0;
 
    if ((nodemtl == NULL) || (nodemtl->NumSubMtls() <= 1))
    {   //Check if diffuse texture present
        if (isTexturedMaterial(nodemtl))
            return 00;
        return 1;
    } 
    else
    {
        int sub_mtl_count = nodemtl->NumSubMtls();
    
        for (mat_index=0; mat_index<sub_mtl_count; mat_index++)
        {
            if (MaterialRemapTable[mat_index] != -1)
            {   //material is used on some faces
                if (isTexturedMaterial(nodemtl->GetSubMtl(mat_index)))
                    continue;
                numSolid++;
            }
        }
        return numSolid;
    }
}
 
//Cancels out the material colors by setting them to white.
//Also changes prefix on texture names to use DIFFUSE_HOUSECOLOR_TEXTURE_PREFIX
//if house color is used.
void MeshSaveClass::fix_diffuse_materials(bool isHouseColor)
{
    uint8 color=255;
    char    materialColorFilename[_MAX_FNAME + 1];
 
    for (int mat_index=0; mat_index<MaterialDesc.Material_Count(); mat_index++)
    {
        for (int pass=0; pass<MaterialDesc.Pass_Count(); pass++)
        {
            W3dVertexMaterialStruct *vmat=MaterialDesc.Get_Vertex_Material(mat_index,pass);
 
            for (int stage=0; stage<W3dMaterialClass::MAX_STAGES; stage++)
            {
                W3dMapClass *map3d=MaterialDesc.Get_Texture(mat_index,pass,stage);
                if (map3d && map3d->Filename && (*((unsigned int *)map3d->Filename) & 0xffff00ff) == DIFFUSE_COLOR_TEXTURE_MASK)  //check for 'TXC^' prefix
                {   //found a material which had its material color replaced by a texture
                    //set the material color to white so it's not being used.
                    vmat->Diffuse.Set(color,color,color);
                    vmat->Ambient.Set(color,color,color);
 
                    if (isHouseColor && *(map3d->Filename+1) != 'H')
                    {   //our material texture contains house colors, adjust the name
                        //by adding H prefix.
                        sprintf(materialColorFilename,"%s%s","ZHCD",map3d->Filename+4);
                        map3d->Set_Filename(materialColorFilename);
                    }
                }
            }
        }
    }
}
 
/*********************************************************************************************** 
 * MeshSaveClass::create_materials -- create the materials for this mesh                       * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/26/1997 GH  : Created.                                                                 * 
 *   2/8/99     GTH : modified to use the MaterialRemapTable                                   *
 *=============================================================================================*/
void MeshSaveClass::create_materials(Mtl * nodemtl,DWORD wirecolor, char *materialColorTexture)
{
    bool domaps = !use_simple_rendering(Header.Attributes);
    
    // Create materials
    // Four cases:
    // - Creating a collision object: use a hard-coded material
    // - The material is null: use wire color
    // - The material is a simple material: create one material
    // - The material is a multi-material: create n materials
    int geo_type = Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK;
    if ((geo_type == W3D_MESH_FLAG_GEOMETRY_TYPE_AABOX) || 
            (geo_type == W3D_MESH_FLAG_GEOMETRY_TYPE_OBBOX)) 
    {
        Header.NumMaterials = 1;
 
        W3dVertexMaterialStruct vmat;
        W3dShaderStruct shader;
        W3dMaterialClass material;
 
        Color diffuse;
        if (Header.Attributes & W3D_MESH_FLAG_COLLISION_TYPE_PHYSICAL) {
            diffuse.r = 0.0f;
            diffuse.g = 0.0f;
            diffuse.b = 1.0f;
        } else {
            diffuse.r = 0.4f;
            diffuse.g = 1.0f;
            diffuse.b = 0.4f;
        }
 
        W3d_Shader_Reset(&shader);
        W3d_Shader_Set_Dest_Blend_Func(&shader,W3DSHADER_DESTBLENDFUNC_ONE_MINUS_SRC_ALPHA);
        W3d_Shader_Set_Src_Blend_Func(&shader,W3DSHADER_SRCBLENDFUNC_SRC_ALPHA);
 
        W3d_Vertex_Material_Reset(&vmat);
        vmat.Opacity = 0.5f;
 
        // add material 0
        vmat.Diffuse.R = (uint8)(diffuse.r * 255.0f);
        vmat.Diffuse.G = (uint8)(diffuse.g * 255.0f);
        vmat.Diffuse.B = (uint8)(diffuse.b * 255.0f);
        material.Set_Pass_Count(1);
        material.Set_Vertex_Material(vmat,0);
        material.Set_Shader(shader,0);
        MaterialDesc.Add_Material(material);
 
        assert(MaterialDesc.Material_Count() == 1);
 
    } else if (!nodemtl) {
 
        // Create a single material using the wire color
        Header.NumMaterials = 1;
    
        W3dVertexMaterialStruct vmat;
        W3dShaderStruct shader;
        W3dMaterialClass material;
 
        W3d_Vertex_Material_Reset(&vmat);
        W3d_Shader_Reset(&shader);
 
        vmat.Diffuse.R = GetRValue(wirecolor);
        vmat.Diffuse.G = GetGValue(wirecolor);
        vmat.Diffuse.B = GetBValue(wirecolor);
 
        material.Set_Pass_Count(1);
        material.Set_Vertex_Material(vmat,0);
        material.Set_Shader(shader,0);
 
        MaterialDesc.Add_Material(material,"WireColor");
        assert(MaterialDesc.Material_Count() == 1);
 
    } else if (!nodemtl->IsMultiMtl()) {
 
        Header.NumMaterials = 1;
        W3dMaterialClass mat;
 
        if (isTexturedMaterial(nodemtl) == 0)
            mat.Init(nodemtl,materialColorTexture);
        else
            mat.Init(nodemtl,NULL);
 
        W3dMaterialDescClass::ErrorType err;
        err = MaterialDesc.Add_Material(mat,nodemtl->GetName());
        if (err == W3dMaterialDescClass::MULTIPASS_TRANSPARENT) {
            sprintf(_string1,"Exporting Materials for Mesh: %s\nMaterial %s is multi-pass and transparent\nMulti-pass transparent materials are not allowed.\n",
                    Header.MeshName,
                    nodemtl->GetName());
            ExportLog::printf(_string1);
            throw ErrorClass(_string1);
        }
        assert(MaterialDesc.Material_Count() == 1);
 
    } else {
 
        Header.NumMaterials = nodemtl->NumSubMtls();
        W3dMaterialClass mat;
 
        for (unsigned mi = 0; mi < Header.NumMaterials; mi++) {
 
            // only process materials that were found to be used in the scan_used_materials call
            if (MaterialRemapTable[mi] != -1) {
 
                if (isTexturedMaterial(nodemtl->GetSubMtl(mi)) == 0)
                    mat.Init(nodemtl->GetSubMtl(mi),materialColorTexture);
                else
                    mat.Init(nodemtl->GetSubMtl(mi),NULL);
 
                char * name;
                W3dMaterialDescClass::ErrorType err;
 
                name = nodemtl->GetSubMtl(mi)->GetName();
                err = MaterialDesc.Add_Material(mat,name);
                
                if (err == W3dMaterialDescClass::INCONSISTENT_PASSES) {
                    sprintf(_string1,"Exporting Materials for Mesh: %s\nMaterial %s has %d passes.\nThe other materials have %d passes.\nAll Materials must have the same number of passes.\n",
                            Header.MeshName,
                            nodemtl->GetSubMtl(mi)->GetName(),
                            mat.Get_Pass_Count(),
                            MaterialDesc.Pass_Count());
                    ExportLog::printf(_string1);
                    throw ErrorClass(_string1);
                }
                if (err == W3dMaterialDescClass::MULTIPASS_TRANSPARENT) {
                    sprintf(_string1,"Exporting Materials for Mesh: %s\nMaterial %s is multi-pass and transparent\nMulti-pass transparent materials are not allowed.\n",
                            Header.MeshName,
                            nodemtl->GetSubMtl(mi)->GetName());
                    throw ErrorClass(_string1);
                }
                if (err == W3dMaterialDescClass::INCONSISTENT_SORT_LEVEL) {
                    sprintf(_string1,"Exporting Materials for Mesh: %s\nMaterial %s does not have the same Static Sort Level as other materials used on the mesh.\nAll materials for a mesh must use the same Static Sort Level value.\n",
                            Header.MeshName,
                            nodemtl->GetSubMtl(mi)->GetName());
                    ExportLog::printf(_string1);
                    throw ErrorClass(_string1);
                }
            }
        }
    }
 
    // Store the material's sort level in the mesh header.
    Header.SortLevel = MaterialDesc.Get_Sort_Level();
}
 
/*********************************************************************************************** 
 * MeshSaveClass::compute_bounding_volumes -- computes a bounding box and bounding sphere for  * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   08/01/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
void MeshSaveClass::compute_bounding_volumes(void)
{
    Vector3 min,max,center;
    float radius;
 
    Builder.Compute_Bounding_Box(&min,&max);
    Builder.Compute_Bounding_Sphere(&center,&radius);
 
    Header.SphCenter.X = center.X;
    Header.SphCenter.Y = center.Y;
    Header.SphCenter.Z = center.Z;
    Header.SphRadius = radius;
 
    Header.Min.X = min.X;
    Header.Min.Y = min.Y;
    Header.Min.Z = min.Z;
    Header.Max.X = max.X;
    Header.Max.Y = max.Y;
    Header.Max.Z = max.Z;
}
 
 
/*********************************************************************************************** 
 * MeshSaveClass::compute_physical_properties -- computes the volume and moment of inertia     * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   08/01/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
void MeshSaveClass::compute_physical_constants
(
    INode * inode,
    Progress_Meter_Class & meter,
    bool voxelize
)
{
 
#if 0 // IF we need this again, move the data to a physics chunk (header doesn't have it anymore)
 
    if (voxelize) {
    
        // Create an INodeList object for this mesh
        AnyINodeFilter nodefilt;
        INodeListClass meshlist(CurTime,&nodefilt);
        meshlist.Insert(inode);
 
        // Create a Voxel object for this mesh
        VoxelClass * voxel = new VoxelClass
        (
            meshlist,
            VOXEL_RESOLUTION,
            ExportSpace,
            CurTime,
            meter
        );
 
#if DEBUG_VOXELS
        VoxelDebugWindowClass dbgwin(voxel);
        dbgwin.Display_Window();
#endif
        
        double vol[1];
        double cm[3];
        double inertia[9];
 
        voxel->Compute_Physical_Properties(vol,cm,inertia);
 
        Header.Volume = (float)vol[0];
 
        Header.MassCenter.X = (float)cm[0];
        Header.MassCenter.Y = (float)cm[1];
        Header.MassCenter.Z = (float)cm[2];
 
        Header.Inertia[0] = (float)inertia[0];
        Header.Inertia[1] = (float)inertia[1];
        Header.Inertia[2] = (float)inertia[2];
        Header.Inertia[3] = (float)inertia[3];
        Header.Inertia[4] = (float)inertia[4];
        Header.Inertia[5] = (float)inertia[5];
        Header.Inertia[6] = (float)inertia[6];
        Header.Inertia[7] = (float)inertia[7];
        Header.Inertia[8] = (float)inertia[8];
 
    } else {
 
        // Set mass center to the center of the bounding box
        Header.MassCenter.X = (Header.Max.X + Header.Min.X) / 2.0f;
        Header.MassCenter.Y = (Header.Max.Y + Header.Min.Y) / 2.0f;
        Header.MassCenter.Z = (Header.Max.Z + Header.Min.Z) / 2.0f;
 
        // Set inertia tensor to inertia tensor of the bounding box
        // (gth) !!!! DO THIS !!!!
        Header.Inertia[0] = 1.0f;
        Header.Inertia[1] = 0.0f;
        Header.Inertia[2] = 0.0f;
        Header.Inertia[3] = 0.0f;
        Header.Inertia[4] = 1.0f;
        Header.Inertia[5] = 0.0f;
        Header.Inertia[6] = 0.0f;
        Header.Inertia[7] = 0.0f;
        Header.Inertia[8] = 1.0f;
 
        Header.Volume = (Header.Max.X - Header.Min.X) * (Header.Max.Y - Header.Min.Y) * (Header.Max.Z - Header.Min.Z);
    }
 
#endif
}
 
 
/*********************************************************************************************** 
 * MeshSaveClass::prep_mesh -- pre-transform the MAX mesh by a specified matrix                * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   08/01/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
void MeshSaveClass::prep_mesh(Mesh & mesh,Matrix3 & objoff)
{
    int vert_index;
 
    // Transform the mesh's vertices so that they are relative to the coordinate 
    // system that we want to use with the mesh
    for (vert_index = 0; vert_index < mesh.getNumVerts (); vert_index++) {
        mesh.verts[vert_index] = mesh.verts[vert_index] * objoff;
    }
 
    // Re-Build the normals.
    mesh.buildNormals();
}