Renegade/Code/ww3d2/meshmdlio.cpp

/*
**	Command & Conquer Renegade(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/>.
*/

/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WW3D                                                         *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/ww3d2/meshmdlio.cpp                          $*
 *                                                                                             *
 *                       Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                     $Modtime:: 1/18/02 3:09p                                               $*
 *                                                                                             *
 *                    $Revision:: 27                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   MeshModelClass::Load_W3D -- Load a mesh from a W3D file                                   *
 *   MeshModelClass::read_chunks -- read all of the chunks for a mesh                          *
 *   MeshModelClass::read_vertices -- reads the vertex chunk                                   * 
 *   MeshModelClass::read_texcoords -- read in the texture coordinates chunk                   *
 *   MeshModelClass::read_vertex_normals -- reads a vertex normal chunk from the w3d file      * 
 *   MeshModelClass::read_v3_materials -- Reads in version 3 materials.                        *
 *   MeshModelClass::read_triangles -- read the triangles chunk                                *
 *   MeshModelClass::read_per_tri_materials -- read the material indices for each triangle     *
 *   MeshModelClass::read_user_text -- read in the user text chunk                             * 
 *   MeshModelClass::read_vertex_colors -- read in the vertex colors chunk                     * 
 *   MeshModelClass::read_vertex_influences -- read in the vertex influences chunk             * 
 *   MeshModelClass::read_vertex_shade_indices -- read the shade index chunk                   *
 *   MeshModelClass::read_material_info -- read the material info chunk                        *
 *   MeshModelClass::read_shaders -- read the shaders chunk                                    *
 *   MeshModelClass::read_vertex_materials -- read the vertex materials chunk                  *
 *   MeshModelClass::read_textures -- read the textures chunk                                  *
 *   MeshModelClass::read_material_pass -- read a material pass chunk                          *
 *   MeshModelClass::read_vertex_material_ids -- read the vmat ids for a pass                  *
 *   MeshModelClass::read_shader_ids -- read the shader indexes for a pass                     *
 *   MeshModelClass::read_dcg -- read the per-vertex diffuse color for a pass                  *
 *   MeshModelClass::read_dig -- read the per-vertex diffuse illumination for a pass           *
 *   MeshModelClass::read_scg -- read the specular color for a pass                            *
 *   MeshModelClass::read_texture_stage -- read texture stage chunks                           *
 *   MeshModelClass::read_texture_ids -- read the texture ids for a pass,stage                 *
 *   MeshModelClass::read_stage_texcoords -- read the texcoords for a pass,stage               *
 *	  MeshModelClass::read_per_face_texcoord_ids -- read uv indices for given (pass,stage).	  *
 *	  MeshModelClass::read_prelit_material -- read prelit material chunks.							  *
 *   MeshModelClass::read_aabtree -- loads the aabtree chunk                                   *
 *   MeshModelClass::Save -- Save this mesh model!                                             *
 *   MeshLoadContextClass::MeshLoadContextClass -- constructor for MeshLoadContextClass        *
 *   MeshLoadContextClass::~MeshLoadContextClass -- destructor                                 *
 *   MeshLoadContextClass::Get_Texcoord_Array -- returns the texture coordinates array         *
 *   MeshLoadContextClass::Add_Shader -- adds a shader to the array                            *
 *   MeshLoadContextClass::Add_Vertex_Materail -- adds a vertex material                       *
 *   MeshLoadContextClass::Add_Texture -- adds a texture                                       *
 *   MeshLoadContextClass::Add_Legacy_Material -- adds a legacy material                       *
 *   MeshLoadContextClass::Peek_Legacy_Shader -- returns a legacy shader                       *
 *   MeshLoadContextClass::Peek_Legacy_Vertex_Material -- returns a pointer to a legacy vmat   *
 *   MeshLoadContextClass::Peek_Legacy_Texture -- returns a pointer to a texture               *
 *   MeshSaveContextClass::MeshSaveContextClass -- constructor                                 *
 *   MeshSaveContextClass::~MeshSaveContextClass -- destructor                                 *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "meshmdl.h"
#include "aabtree.h"
#include "matinfo.h"
#include "vertmaterial.h"
#include "shader.h"
#include "texture.h"
#include "chunkio.h"
#include "w3derr.h"
#include "w3d_file.h"
#include "w3d_util.h"
#include "assetmgr.h"
#include "simplevec.h"
#include "realcrc.h"
#include "dx8wrapper.h"

#include <stdio.h>

#ifdef _UNIX
#include "osdep/osdep.h"
#endif

/**
** MeshLoadContextClass
** This class is just used as a temporary scratchpad while a mesh is being
** loaded.  In some cases, a chunk will be encountered before I have a place
** to plug it into the mesh model, etc.  It is also used to convert from the
** old material format to the new one (detecting duplicated materials in the
** process).
**
** This object will hold refs to all of the unique material objects.  These
** objects will later be transferred into the MaterialInfo for the mesh and it
** will own the refs for the mesh.  The load context object is destroyed once
** loading is complete...
*/
class MeshLoadContextClass
{
private:
	MeshLoadContextClass(void);
	~MeshLoadContextClass(void);
	
	W3dTexCoordStruct *		Get_Texcoord_Array(void);

	int							Add_Shader(ShaderClass shader);
	int							Add_Vertex_Material(VertexMaterialClass * vmat);
	int							Add_Texture(TextureClass* tex);

	ShaderClass					Peek_Shader(int index)											{ return Shaders[index]; }
	VertexMaterialClass *	Peek_Vertex_Material(int index)								{ return VertexMaterials[index]; }
	TextureClass *				Peek_Texture(int index)											{ return Textures[index]; }
	
	int							Shader_Count(void)												{ return Shaders.Count(); }
	int							Vertex_Material_Count(void)									{ return VertexMaterials.Count(); }
	int							Texture_Count(void)												{ return Textures.Count(); }

	/*
	** Legacy material support.  
	*/
	void							Add_Legacy_Material(ShaderClass shader,VertexMaterialClass * vmat,TextureClass * tex);
	ShaderClass					Peek_Legacy_Shader(int legacy_material_index);
	VertexMaterialClass *	Peek_Legacy_Vertex_Material(int legacy_material_index);
	TextureClass *				Peek_Legacy_Texture(int legacy_material_index);

	/*
	** Redundant UV detection support.  The context provides a temporary buffer to
	** load the uv coordinates into.
	*/
	Vector2 *					Get_Temporary_UV_Array(int elementcount);


	/*
	** Currently, the only tool that creates DIG chunks is the lightmap tool.  Since DX8 support
	** for linking the emissive material color to an array seems poor, We're just going to multiply
	** the DIG array into the DCG array (or make it the DCG array).  Now, to properly support the
	** "alternate material set", we have to know whether we've already encountered a DIG chunk so
	** these flags provide that functionality. 
	*/
	void							Notify_Loaded_DIG_Chunk(bool onoff = true)				{ LoadedDIG = onoff; }
	bool							Already_Loaded_DIG(void)										{ return LoadedDIG; }

private:

	struct LegacyMaterialClass
	{
		LegacyMaterialClass(void) : VertexMaterialIdx(0),ShaderIdx(0),TextureIdx(0)	{ }
		~LegacyMaterialClass(void)	{ }		
		void		Set_Name(const char * name) { Name=name; }
		
		StringClass Name;
		int		VertexMaterialIdx;
		int		ShaderIdx;
		int		TextureIdx;
	};
	
	
	W3dMeshHeader3Struct		Header;
	W3dTexCoordStruct *		TexCoords;
	W3dMaterialInfoStruct	MatInfo;

	uint32						PrelitChunkID;

	int							CurPass;
	int							CurTexStage;

	DynamicVectorClass < LegacyMaterialClass * >		LegacyMaterials;
	DynamicVectorClass < ShaderClass >					Shaders;
	DynamicVectorClass < VertexMaterialClass * >		VertexMaterials;
	DynamicVectorClass < unsigned long >				VertexMaterialCrcs;
	DynamicVectorClass < TextureClass * >				Textures;			

	/*
	** Alternate material data.  Any alternate material data will be loaded into 
	** this MeshMatDescClass object.  When loading is finished, an alternate MeshMatDescClass 
	** will be allocated in the mesh model.  This MeshMatDescClass will be initialized to be
	** identical to the default MeshMatDescClass and then any data contained in this
	** MeshMatDescClass will replace the relevant arrays.
	*/
	MeshMatDescClass											AlternateMatDesc;

	SimpleVecClass<Vector2>									TempUVArray;

	/*
	** Record when we load the DIG chunk
	*/
	bool															LoadedDIG;

	friend class MeshClass;
	friend class MeshModelClass;
};


/*
** MeshSaveContextClass
** This class is used to pass information between the saving code in a mesh
*/
class MeshSaveContextClass
{
public:
	MeshSaveContextClass(void);
	~MeshSaveContextClass(void);

	int								CurPass;
	int								CurStage;
	MaterialCollectorClass		Materials;
};


/***********************************************************************************************
 * MeshModelClass::Load_W3D -- Load a mesh from a W3D file                                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::Load_W3D(ChunkLoadClass & cload)
{
	MeshLoadContextClass * context = NULL;

	/*
	**	Open the first chunk, it should be the mesh header
	*/
	cload.Open_Chunk();
	
	if (cload.Cur_Chunk_ID() != W3D_CHUNK_MESH_HEADER3) {
		WWDEBUG_SAY(("Old format mesh mesh, no longer supported.\n"));
		goto Error;
	}
	
	context = new MeshLoadContextClass;

	if (cload.Read(&(context->Header),sizeof(W3dMeshHeader3Struct)) != sizeof(W3dMeshHeader3Struct)) {
		goto Error;
	}
	cload.Close_Chunk();

	/*
	** Process the header
	*/
	char *	tmpname;
	int		namelen;
	
	Reset(context->Header.NumTris,context->Header.NumVertices,1);
	
	namelen = strlen(context->Header.ContainerName);
	namelen += strlen(context->Header.MeshName);
	namelen += 2;
	W3dAttributes = context->Header.Attributes;	
	SortLevel = context->Header.SortLevel;
	tmpname = new char[namelen];
	memset(tmpname,0,namelen);

	if (strlen(context->Header.ContainerName) > 0) {
		strcpy(tmpname,context->Header.ContainerName);
		strcat(tmpname,".");
	}
	strcat(tmpname,context->Header.MeshName);

	Set_Name(tmpname);

	delete[] tmpname;
	tmpname = NULL;

	context->AlternateMatDesc.Set_Vertex_Count(VertexCount);
	context->AlternateMatDesc.Set_Polygon_Count(PolyCount);

	/*
	** Set Bounding Info
	*/
	BoundBoxMin.Set(context->Header.Min.X,context->Header.Min.Y,context->Header.Min.Z);
	BoundBoxMax.Set(context->Header.Max.X,context->Header.Max.Y,context->Header.Max.Z);

	BoundSphereCenter.Set(context->Header.SphCenter.X,context->Header.SphCenter.Y,context->Header.SphCenter.Z);
	BoundSphereRadius = context->Header.SphRadius;

	/*
	** Flags
	*/
	if (context->Header.Version >= W3D_MAKE_VERSION(4,1)) {
		int geometry_type = context->Header.Attributes & W3D_MESH_FLAG_GEOMETRY_TYPE_MASK;
		switch (geometry_type) 
		{
			case W3D_MESH_FLAG_GEOMETRY_TYPE_NORMAL:
				break;
			case W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ALIGNED:
				Set_Flag(ALIGNED,true);
				break;
			case W3D_MESH_FLAG_GEOMETRY_TYPE_CAMERA_ORIENTED:
				Set_Flag(ORIENTED,true);
				break;
			case W3D_MESH_FLAG_GEOMETRY_TYPE_SKIN:
				Set_Flag(SKIN,true);
				Set_Flag(ALLOW_NPATCHES,true);
				break;
		} 
	}

	if (context->Header.Attributes & W3D_MESH_FLAG_TWO_SIDED) {
		Set_Flag(TWO_SIDED,true);
	}

	if (context->Header.Attributes & W3D_MESH_FLAG_CAST_SHADOW) {
		Set_Flag(CAST_SHADOW,true);
	}

	if (context->Header.Attributes & W3D_MESH_FLAG_NPATCHABLE) {
		Set_Flag(ALLOW_NPATCHES,true);
	}

	// Configure the load sequence for prelighting.
	if (context->Header.Attributes & W3D_MESH_FLAG_PRELIT_MASK) {

		// Select from the available prelit materials based on current prelit lighting mode.
		// If the model does not have the current prelit mode, select the next highest quality
		// prelit material that is available.
		switch (WW3D::Get_Prelit_Mode()) {

			case WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE:
				if (context->Header.Attributes & W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_TEXTURE) {
					context->PrelitChunkID = W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE;
					Set_Flag (PRELIT_LIGHTMAP_MULTI_TEXTURE, true);
					break;
				}
				// Else fall thru...

			case WW3D::PRELIT_MODE_LIGHTMAP_MULTI_PASS:
				if (context->Header.Attributes & W3D_MESH_FLAG_PRELIT_LIGHTMAP_MULTI_PASS) {
					context->PrelitChunkID = W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS;
					Set_Flag (PRELIT_LIGHTMAP_MULTI_PASS, true);
					break;
				}
				// Else fall thru...

			case WW3D::PRELIT_MODE_VERTEX:
				if (context->Header.Attributes & W3D_MESH_FLAG_PRELIT_VERTEX) {
					context->PrelitChunkID = W3D_CHUNK_PRELIT_VERTEX;
					Set_Flag (PRELIT_VERTEX, true);
					break;
				}
				// Else fall thru...

			default:

				// This prelighting option MUST be available if none of the others are available.
				WWASSERT (context->Header.Attributes & W3D_MESH_FLAG_PRELIT_UNLIT);
				context->PrelitChunkID = W3D_CHUNK_PRELIT_UNLIT;
				break;
		}

	} else {
		
		// For backwards compatibility, test for obsolete lightmap flag.
		if (context->Header.Attributes & OBSOLETE_W3D_MESH_FLAG_LIGHTMAPPED) {
			Set_Flag (PRELIT_LIGHTMAP_MULTI_PASS, true);
		}

		// Else this mesh has no prelighting.
	}

	read_chunks(cload,context);

	/*
	** If this is a pre-3.0 mesh and it has vertex influences,
	** fixup the bone indices to account for the new root node
	*/
	if ((context->Header.Version < W3D_MAKE_VERSION(3,0)) && (Get_Flag(SKIN))) {

		uint16 * links = get_bone_links();
		WWASSERT(links);
		
		for (int bi = 0; bi < Get_Vertex_Count(); bi++) {
			links[bi] += 1;
		}
	}

	/*
	** If this mesh is collideable and no AABTree was in the file, generate one now
	*/
	if (	(((W3dAttributes & W3D_MESH_FLAG_COLLISION_TYPE_MASK) >> W3D_MESH_FLAG_COLLISION_TYPE_SHIFT) != 0) &&
			(CullTree == NULL)) 
	{
		Generate_Culling_Tree();
	}

	/*
	** Transfer the materials into the MatInfo
	*/
	install_materials(context);

	/*
	** Delete the temporary LoadInfo object
	*/
	delete context;

	/*
	** Post-process the model: optimize passes, activate fog etc.
	*/
	post_process();

	return WW3D_ERROR_OK;

Error:

	return WW3D_ERROR_LOAD_FAILED;
}


/***********************************************************************************************
 * MeshModelClass::read_chunks -- read all of the chunks for a mesh                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_chunks(ChunkLoadClass & cload,MeshLoadContextClass * context) 
{
	/*
	**	Read in the chunk header
	** If there are no more chunks within the mesh chunk,
	** we are done.
	*/
	while (cload.Open_Chunk()) {

		/*
		** Process the chunk
		*/
		WW3DErrorType error = WW3D_ERROR_OK;

		switch (cload.Cur_Chunk_ID()) {

			case W3D_CHUNK_VERTICES:
					// call up to MeshGeometryClass
					error = read_vertices(cload);		
					break;

			case W3D_CHUNK_SURRENDER_NORMALS:
			case W3D_CHUNK_VERTEX_NORMALS:
					// call up to MeshGeometryClass
					error = read_vertex_normals(cload);
					break;

			case W3D_CHUNK_TEXCOORDS:
					error = read_texcoords(cload,context);
					break;

			case O_W3D_CHUNK_MATERIALS:
			case O_W3D_CHUNK_MATERIALS2:		
					WWDEBUG_SAY(( "Obsolete material chunk encountered in mesh: %s.%s\r\n", context->Header.ContainerName,context->Header.MeshName));
					WWASSERT(0);
					break;

			case W3D_CHUNK_MATERIALS3:
					WWDEBUG_SAY(( "Obsolete material chunk encountered in mesh: %s.%s\r\n", context->Header.ContainerName,context->Header.MeshName));
					error = read_v3_materials(cload,context);
					break;
				
			case O_W3D_CHUNK_SURRENDER_TRIANGLES:
					WWASSERT_PRINT( 0, "Obsolete Triangle Chunk Encountered!\r\n" );
					break;
			
			case W3D_CHUNK_TRIANGLES:
					// call up to MeshGeometryClass
					error = read_triangles(cload);
					break;

			case W3D_CHUNK_PER_TRI_MATERIALS:
					error = read_per_tri_materials(cload,context);
					break;

			case W3D_CHUNK_MESH_USER_TEXT:
					// call up to MeshGeometryClass
					error = read_user_text(cload);
					break;
			
			case W3D_CHUNK_VERTEX_COLORS:
					error = read_vertex_colors(cload,context);
					break;

			case W3D_CHUNK_VERTEX_INFLUENCES:
					// call up to MeshGeometryClass
					error = read_vertex_influences(cload);
					break;

			case W3D_CHUNK_VERTEX_SHADE_INDICES:
					// call up to MeshGeometryClass
					error = read_vertex_shade_indices(cload);
					break;

			case W3D_CHUNK_MATERIAL_INFO:
					error = read_material_info(cload,context);
					break;

			case W3D_CHUNK_SHADERS:
					error = read_shaders(cload,context);
					break;

			case W3D_CHUNK_VERTEX_MATERIALS:
					error = read_vertex_materials(cload,context);
					break;

			case W3D_CHUNK_TEXTURES:
					error = read_textures(cload,context);
					break;

			case W3D_CHUNK_MATERIAL_PASS:
					error = read_material_pass(cload,context);
					break;

			case W3D_CHUNK_DEFORM:
					WWDEBUG_SAY(("Obsolete deform chunk encountered in mesh: %s.%s\r\n", context->Header.ContainerName,context->Header.MeshName));
					break;
			
			case W3D_CHUNK_DAMAGE:
					WWDEBUG_SAY(("Obsolete damage chunk encountered in mesh: %s.%s\r\n", context->Header.ContainerName,context->Header.MeshName));
					break;

			case W3D_CHUNK_PRELIT_UNLIT:
			case W3D_CHUNK_PRELIT_VERTEX:
			case W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_PASS:
			case W3D_CHUNK_PRELIT_LIGHTMAP_MULTI_TEXTURE:
					read_prelit_material (cload, context);
					break;
			
			case W3D_CHUNK_AABTREE:
					// call up to MeshGeometryClass
					read_aabtree(cload);
					break;

			default:
					break;

		}	
		
		cload.Close_Chunk();

		if (error != WW3D_ERROR_OK) {
			return error;
		}
	}

	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_texcoords -- read in the texture coordinates chunk                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   3/6/98     GTH : Created.                                                                 *
 *   2/16/99    GTH : Moved into MeshModel                                                     *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_texcoords(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	W3dTexCoordStruct texcoord;
	Vector2 * uvarray = 0;
	int elementcount = cload.Cur_Chunk_Length() / sizeof (W3dTexCoordStruct);

	uvarray = context->Get_Temporary_UV_Array(elementcount);

	if (uvarray != NULL) {
		/*
		** Read the uv's into the first u-v pass array
		** NOTE: this is an obsolete function.  Texture coordinates are now
		** loaded in the pass chunks
		*/
		for (int i=0; i<VertexCount; i++) {
			if (cload.Read(&(texcoord),sizeof(W3dTexCoordStruct)) != sizeof(W3dTexCoordStruct)) {
				return WW3D_ERROR_LOAD_FAILED;
			}
			uvarray[i].Set(texcoord.U,1.0f - texcoord.V);
		}
	
		DefMatDesc->Install_UV_Array(context->CurPass,context->CurTexStage,uvarray,elementcount);
	}

	return WW3D_ERROR_OK;	
}

/***********************************************************************************************
 * MeshModelClass::read_v3_materials -- Reads in version 3 materials.                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   4/2/98     GTH : Created.                                                                 *
 *   2/16/99    GTH : Moved into MeshModelClass                                                *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_v3_materials(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	for (unsigned int mi=0; mi<context->Header.NumMaterials; mi++) {

		/*
		** First, we expect a W3D_CHUNK_MATERIAL3 to wrap the entire material
		*/
		if (!cload.Open_Chunk()) goto Error;
		if (cload.Cur_Chunk_ID() != W3D_CHUNK_MATERIAL3) goto Error;

		/*
		** Inside the MATERIAL3 will be the following:
		**
		** W3D_MATERIAL3_NAME - name of the material
		** W3D_MATERIAL3_INFO - equivalent to 1.40 vertex material parameters
		** W3D_MATERIAL3_DC_MAP - diffuse color mapping
		**   W3D_MAP3_FILENAME - filename of the texture map
		**   W3D_MAP3_INFO - animation, etc information
		** W3D_MATERIAL3_DI_MAP - diffuse illumination map
		** W3D_MATERIAL3_SC_MAP - specular color map
		** W3D_MATERIAL3_SI_MAP - specular illumination map
		*/
		VertexMaterialClass *		vmat = NULL;	
		ShaderClass						shader;
		TextureClass *					tex = NULL;
		char								name[256];

		/*
		** Read the material name
		*/
		if (!cload.Open_Chunk()) goto Error;
		if (cload.Cur_Chunk_ID() != W3D_CHUNK_MATERIAL3_NAME) goto Error;
		cload.Read(name,cload.Cur_Chunk_Length());
		if (!cload.Close_Chunk()) goto Error;

		/*
		** Read the vertex material parameters
		*/
		if (!cload.Open_Chunk()) goto Error;

			W3dMaterial3Struct mat;
			if (cload.Cur_Chunk_ID() != W3D_CHUNK_MATERIAL3_INFO) goto Error;
			if (cload.Read(&mat,sizeof(W3dMaterial3Struct)) != sizeof(W3dMaterial3Struct)) goto Error;
			vmat = new VertexMaterialClass;
			vmat->Init_From_Material3(mat);
			vmat->Set_Name(name);
			shader.Init_From_Material3(mat);

			/*
			** If this shader does alpha blending, the mesh must be sorted.
			*/
			if (shader.Get_Dst_Blend_Func() != ShaderClass::DSTBLEND_ZERO) {
				Set_Flag(MeshModelClass::SORT,true);
			}
	
		if (!cload.Close_Chunk()) goto Error;

		/*
		** Look for the DC map and read it in
		*/
		while (cload.Open_Chunk()) {
			if (cload.Cur_Chunk_ID() == W3D_CHUNK_MATERIAL3_DC_MAP) {

				/*
				** Read in the texture filename
				*/
				char filename[_MAX_FNAME + _MAX_EXT];
				if (!cload.Open_Chunk()) goto Error;
					if (cload.Cur_Chunk_ID() != W3D_CHUNK_MAP3_FILENAME) goto Error;
					if (cload.Cur_Chunk_Length() >= sizeof(filename)) goto Error;
					cload.Read(filename,cload.Cur_Chunk_Length());
				if (!cload.Close_Chunk()) goto Error;

				/*
				** Read in the auxiliary map info
				*/
				W3dMap3Struct mapinfo;
				if (!cload.Open_Chunk()) goto Error;
					if (cload.Cur_Chunk_ID() != W3D_CHUNK_MAP3_INFO) goto Error;
					if (cload.Read(&mapinfo,sizeof(W3dMap3Struct)) != sizeof(W3dMap3Struct)) goto Error;
				if (!cload.Close_Chunk()) goto Error;

				if ( mapinfo.FrameCount > 1 ) {
					WWDEBUG_SAY(("ERROR: Obsolete Animated Texture detected in model: %s\r\n",context->Header.MeshName));
				}

				tex = WW3DAssetManager::Get_Instance()->Get_Texture(filename);

				shader.Set_Texturing(ShaderClass::TEXTURING_ENABLE);

			} else if (cload.Cur_Chunk_ID() == W3D_CHUNK_MATERIAL3_SI_MAP) {
				Vector3	diffuse_color;
				vmat->Get_Diffuse( &diffuse_color);
				if ( diffuse_color == Vector3( 0,0,0 ) ) {

					/*
					** Read in the texture filename
					*/
					char filename[_MAX_FNAME + _MAX_EXT];
					if (!cload.Open_Chunk()) goto Error;
						if (cload.Cur_Chunk_ID() != W3D_CHUNK_MAP3_FILENAME) goto Error;
						if (cload.Cur_Chunk_Length() >= sizeof(filename)) goto Error;
						cload.Read(filename,cload.Cur_Chunk_Length());
					if (!cload.Close_Chunk()) goto Error;

					if (tex) tex->Release_Ref();

					/*
					** Read in the auxiliary map info
					*/
					W3dMap3Struct mapinfo;
					if (!cload.Open_Chunk()) goto Error;
						if (cload.Cur_Chunk_ID() != W3D_CHUNK_MAP3_INFO) goto Error;
						if (cload.Read(&mapinfo,sizeof(W3dMap3Struct)) != sizeof(W3dMap3Struct)) goto Error;
					if (!cload.Close_Chunk()) goto Error;
			
					if ( mapinfo.FrameCount > 1 ) {
						WWDEBUG_SAY(("ERROR: Obsolete Animated Texture detected in model: %s\r\n",context->Header.MeshName));
					}

					tex = WW3DAssetManager::Get_Instance()->Get_Texture(filename);

					shader.Set_Texturing(ShaderClass::TEXTURING_ENABLE);
					shader.Set_Dst_Blend_Func(ShaderClass::DSTBLEND_ONE);
					shader.Set_Src_Blend_Func(ShaderClass::SRCBLEND_ONE);
					shader.Set_Primary_Gradient(ShaderClass::GRADIENT_DISABLE);
				}
			}

			cload.Close_Chunk();
		}

		// If not texturing, move the diffuse color to ambient (simulating old behavior)
		if ( shader.Get_Texturing() == ShaderClass::TEXTURING_DISABLE ) {
			Vector3 color;
			vmat->Get_Diffuse( &color );
			vmat->Set_Ambient( color );
			vmat->Set_Diffuse( Vector3( 0, 0, 0 ) );
		}
		
		context->Add_Legacy_Material(shader,vmat,tex);

		vmat->Release_Ref();
		if (tex) tex->Release_Ref();
		vmat = NULL;
		tex = NULL;

		/*
		** Close the W3D_CHUNK_MATERIAL3
		*/
		cload.Close_Chunk();
	}

	/*
	** Install the default materials to use in the absence of an array
	*/
	if (context->Vertex_Material_Count() >= 1) {
		Set_Single_Material(context->Peek_Vertex_Material(0),0);
	}

	if (context->Texture_Count() >= 1) {
		Set_Single_Texture(context->Peek_Texture(0),0);
	}

	if (context->Shader_Count() >= 1) {
		Set_Single_Shader(context->Peek_Shader(0),0);
	}

	return WW3D_ERROR_OK;	

Error:

	return WW3D_ERROR_LOAD_FAILED;

}


/***********************************************************************************************
 * MeshModelClass::read_per_tri_materials -- read the material indices for each triangle       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   4/7/98     GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_per_tri_materials(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	if (context->Header.NumMaterials == 1) return WW3D_ERROR_OK;

	TriIndex * polys = get_polys();

	bool multi_mtl = (context->Vertex_Material_Count() > 1);
	bool multi_tex = (context->Texture_Count() > 1);
	bool multi_shad = (context->Shader_Count() > 1);

	if (!multi_mtl) {
		Set_Single_Material(context->Peek_Legacy_Vertex_Material(0));
	}
	if (!multi_tex) {
		Set_Single_Texture(context->Peek_Legacy_Texture(0));
	}
	if (!multi_shad) {
		Set_Single_Shader(context->Peek_Legacy_Shader(0));
	}

	/*
	** Read in each polygon's material id and assign pointer to the
	** shader, texture, and vertex material as needed.
	*/
	for (int i=0; i<Get_Polygon_Count(); i++) {

		// read in the mat id for this poly
		uint16 matid;

		if (cload.Read(&matid,sizeof(uint16)) != sizeof(uint16)) {
			return WW3D_ERROR_LOAD_FAILED;
		}

		if (multi_shad) {
			Set_Shader(i,context->Peek_Legacy_Shader(matid));
		}
		if (multi_tex) {
			Set_Texture(i,context->Peek_Legacy_Texture(matid));
		}
		if (multi_mtl) {
			Set_Material(polys[i].I,context->Peek_Legacy_Vertex_Material(matid));
			Set_Material(polys[i].J,context->Peek_Legacy_Vertex_Material(matid));
			Set_Material(polys[i].K,context->Peek_Legacy_Vertex_Material(matid));
		}
	}

	return WW3D_ERROR_OK;
}


/*********************************************************************************************** 
 * MeshModelClass::read_vertex_colors -- read in the vertex colors chunk                       * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/28/1997 GH  : Created.                                                                 * 
 *   2/16/99    GTH : Moved into MeshModelClass                                                *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_vertex_colors(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	/*
	** The W3D file format supports arbitrary vertex color arrays for each pass; however since
	** our conversion to hardware T&L, we only support two unique color arrays.  So here is 
	** what is happening in this function:
	**
	** 1 - If this is the first diffuse color array we've encountered, load the values
	** 2 - Always set the DCG source for this pass to the array (vertex materials will be fixed later)
	**
	** A side effect is that if two DCG chunks are encountered, only the first is used...
	*/
	if (CurMatDesc->Has_Color_Array(0) == NULL) {
		W3dRGBStruct color;
		unsigned * dcg = Get_Color_Array(0,true);
		assert(dcg != NULL);

		for (int i=0; i<Get_Vertex_Count(); i++) {

			if (cload.Read(&color,sizeof(W3dRGBStruct)) != sizeof(W3dRGBStruct)) {
				return WW3D_ERROR_LOAD_FAILED;
			}

			Vector4 col;
			col.Set((float)color.R / 255.0f,(float)color.G / 255.0f,(float)color.B / 255.0f, 1.0f);
			dcg[i]=DX8Wrapper::Convert_Color(col);
		}	
	}
	CurMatDesc->Set_DCG_Source(context->CurPass,VertexMaterialClass::COLOR1);

	return WW3D_ERROR_OK;	
}


/***********************************************************************************************
 * MeshModelClass::read_material_info -- read the material info chunk                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_material_info(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	if (cload.Read(&(context->MatInfo),sizeof(W3dMaterialInfoStruct)) != sizeof(W3dMaterialInfoStruct)) {
		return WW3D_ERROR_LOAD_FAILED;
	}
	Set_Pass_Count(context->MatInfo.PassCount);
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_shaders -- read the shaders chunk                                      *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_shaders(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	W3dShaderStruct shader;
	for (unsigned int i=0; i<context->MatInfo.ShaderCount; i++) {
		if (cload.Read(&shader,sizeof(shader)) != sizeof(shader)) {
			return WW3D_ERROR_LOAD_FAILED;
		}
		ShaderClass newshader;
		W3dUtilityClass::Convert_Shader(shader,&newshader);

		int index = context->Add_Shader(newshader);
		WWASSERT(index == (int)i);
	}
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_vertex_materials -- read the vertex materials chunk                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_vertex_materials(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	while (cload.Open_Chunk()) {
		WWASSERT(cload.Cur_Chunk_ID() == W3D_CHUNK_VERTEX_MATERIAL);
		VertexMaterialClass * vmat = NEW_REF(VertexMaterialClass,());
		WW3DErrorType error = vmat->Load_W3D(cload);
		if (error != WW3D_ERROR_OK) {
			return error;
		}
		context->Add_Vertex_Material(vmat);
		vmat->Release_Ref();

		cload.Close_Chunk();
	}
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_textures -- read the textures chunk                                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   3/05/99	 PDS : Broke the guts of this function into a util function in texture.cpp		  *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_textures(ChunkLoadClass & cload,MeshLoadContextClass * context)
{	
	// Keep reading textures until there are no more...
	for (TextureClass *newtex = ::Load_Texture (cload);
		  newtex != NULL;
		  newtex = ::Load_Texture (cload)) {

		// Add this texture to our contex and release our local hold on it
		context->Add_Texture(newtex);
		newtex->Release_Ref();
	}

	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_material_pass -- read a material pass chunk                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_material_pass(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	context->CurTexStage = 0;

	while (cload.Open_Chunk()) {

		WW3DErrorType error = WW3D_ERROR_OK;

		switch (cload.Cur_Chunk_ID()) {
			case W3D_CHUNK_VERTEX_MATERIAL_IDS:
				error = read_vertex_material_ids(cload,context);
				break;

			case W3D_CHUNK_SHADER_IDS:
				error = read_shader_ids(cload,context);
				break;

			case W3D_CHUNK_DCG:
				error = read_dcg(cload,context);
				break;

			case W3D_CHUNK_DIG:
				error = read_dig(cload,context);
				break;

			case W3D_CHUNK_SCG:
				error = read_scg(cload,context);
				break;

			case W3D_CHUNK_TEXTURE_STAGE:
				error = read_texture_stage(cload,context);
				break;
		};

		if (error != WW3D_ERROR_OK) {
			return error;
		}
		cload.Close_Chunk();
	}

	context->CurPass++;
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_vertex_material_ids -- read the vmat ids for a pass                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_vertex_material_ids(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (DefMatDesc->Has_Material_Data(context->CurPass)) {
		matdesc = &(context->AlternateMatDesc);
	}

	/*
	** This chunk will either have a single index in it or an array of indices 
	** with the length equal to the vertex count.
	*/
	uint32 vmat;
	if (cload.Cur_Chunk_Length() == 1*sizeof(uint32)) {
		
		cload.Read(&vmat,sizeof(uint32));
		matdesc->Set_Single_Material(context->Peek_Vertex_Material(vmat),context->CurPass);
	
	} else {

		for (int i=0; i<Get_Vertex_Count(); i++) {
			cload.Read(&vmat,sizeof(uint32));
			matdesc->Set_Material(i,context->Peek_Vertex_Material(vmat),context->CurPass);
		}
	}

	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_shader_ids -- read the shader indexes for a pass                       *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_shader_ids(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (DefMatDesc->Has_Shader_Data(context->CurPass)) {
		matdesc = &(context->AlternateMatDesc);
	}

	/*
	** Read in the shader id's and plug in the appropriate shader
	*/
	uint32 shaderid;
	if (cload.Cur_Chunk_Length() == 1*sizeof(uint32)) {
		
		cload.Read(&shaderid,sizeof(shaderid));
		ShaderClass shader = context->Peek_Shader(shaderid);
		matdesc->Set_Single_Shader(shader,context->CurPass);

		// turn on sorting of pass 0 has non-zero dest blend (unless alpha testing on)
		if (	(context->CurPass == 0) && 
				(shader.Get_Dst_Blend_Func() != ShaderClass::DSTBLEND_ZERO) &&
				(shader.Get_Alpha_Test() == ShaderClass::ALPHATEST_DISABLE) &&
				(SortLevel == SORT_LEVEL_NONE) )
		{
			Set_Flag(SORT,true);
		}
		
	} else {
		
		for (int i=0; i<Get_Polygon_Count(); i++) {
			cload.Read(&shaderid,sizeof(uint32));
			ShaderClass shader = context->Peek_Shader(shaderid);
			matdesc->Set_Shader(i,shader,context->CurPass);

			// turn on sorting of pass 0 has non-zero dest blend (unless alpha testing on)
			if (	(context->CurPass == 0) && 
				(shader.Get_Dst_Blend_Func() != ShaderClass::DSTBLEND_ZERO) &&
				(shader.Get_Alpha_Test() == ShaderClass::ALPHATEST_DISABLE) &&
				(SortLevel == SORT_LEVEL_NONE) )
			{
				Set_Flag(SORT,true);
			}
		}
	}
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_dcg -- read the per-vertex diffuse color for a pass                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *   2/9/2001   gth : converted to handle dx8 limitations                                      *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_dcg(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (DefMatDesc->Get_DCG_Source(context->CurPass) != VertexMaterialClass::MATERIAL) {
		matdesc = &(context->AlternateMatDesc);
	}

	/*
	** The W3D file format supports arbitrary vertex color arrays for each pass; however since
	** our conversion to hardware T&L, we only support two unique color arrays.  So here is 
	** what is happening in this function:
	**
	** 1 - If this is the first diffuse color array we've encountered, load the values.
	** 2 - Otherwise, if we are in PRELIT_VERTEX mode, put the alpha from this array into the color array.
	** 3 - Always set the DCG source for this pass to the array.
	**
	** Our tools *currently* will only generate two color arrays in the case where one of them
	** is being used for alpha and the other is used for precomputed vertex lighting...  This will
	** break if our tools change.  The file format isn't restricting you from defining something
	** we can't render right now...
	*/
	if (matdesc->Has_Color_Array(0) == false) {
		W3dRGBAStruct color;
		unsigned * dcg = matdesc->Get_Color_Array(0);

		for (int i=0; i<Get_Vertex_Count(); i++) {
			cload.Read(&color,sizeof(color));
			Vector4 col;
			W3dUtilityClass::Convert_Color(color,&col);
			dcg[i]=DX8Wrapper::Convert_Color(col);
		}
	} else if (context->PrelitChunkID==W3D_CHUNK_PRELIT_VERTEX) {
		
		W3dRGBAStruct color;
		unsigned * dcg = matdesc->Get_Color_Array(0);

		for (int i=0; i<Get_Vertex_Count(); i++) {
			cload.Read(&color,sizeof(color));
			Vector4 col;
			col=DX8Wrapper::Convert_Color(dcg[i]);
			col.W = float(color.A)/255.0f;
			dcg[i]=DX8Wrapper::Convert_Color(col);
		}
	}

	matdesc->Set_DCG_Source(context->CurPass,VertexMaterialClass::COLOR1);

	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_dig -- read the per-vertex diffuse illumination for a pass             *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *   2/9/2001   gth : converted to handle dx8 limitations                                      *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_dig(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (context->Already_Loaded_DIG()) {
		matdesc = &(context->AlternateMatDesc);
	}
	context->Notify_Loaded_DIG_Chunk(true);

	/*
	** It appears that there isn't wide support for having the emissive material color source
	** be a vertex color array so when there is a pre-existing color array, I'm just multiplying 
	** the DIG values into it.
	*/
	W3dRGBAStruct color;
	if (matdesc->Has_Color_Array(0) == false) {
		unsigned * dcg = matdesc->Get_Color_Array(0);
		for (int i=0; i<Get_Vertex_Count(); i++) {
			cload.Read(&color,sizeof(color));
			Vector4 col;
			col.X = float(color.R)/255.0f;
			col.Y = float(color.G)/255.0f;
			col.Z = float(color.B)/255.0f;
			col.W = 1.0f;
			dcg[i]=DX8Wrapper::Convert_Color(col);


		}
	} else {
		unsigned * dcg = matdesc->Get_Color_Array(0);
		for (int i=0; i<Get_Vertex_Count(); i++) {
			cload.Read(&color,sizeof(color));
			Vector4 col=DX8Wrapper::Convert_Color(dcg[i]);
			col.X *= float(color.R)/255.0f;
			col.Y *= float(color.G)/255.0f;
			col.Z *= float(color.B)/255.0f;
			dcg[i]=DX8Wrapper::Convert_Color(col);
		}
	}

	matdesc->Set_DCG_Source(context->CurPass,VertexMaterialClass::COLOR1);

	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_scg -- read the specular color for a pass                              *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *   2/9/2001   gth : new dx8 code no longer supports this chunk                               *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_scg(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_texture_stage -- read texture stage chunks                             *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_texture_stage(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	while (cload.Open_Chunk()) {

		WW3DErrorType error = WW3D_ERROR_OK;
		
		switch(cload.Cur_Chunk_ID()) {
			case W3D_CHUNK_TEXTURE_IDS:
				error = read_texture_ids(cload,context);
				break;

			case W3D_CHUNK_STAGE_TEXCOORDS:
			case W3D_CHUNK_TEXCOORDS:
				error = read_stage_texcoords(cload,context);
				break;

			case W3D_CHUNK_PER_FACE_TEXCOORD_IDS:
				error = read_per_face_texcoord_ids (cload, context);
				break;

		}

		if (error != WW3D_ERROR_OK) {
			return error;
		}

		cload.Close_Chunk();
	}

	context->CurTexStage++;
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_texture_ids -- read the texture ids for a pass,stage                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_texture_ids(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	uint32 texid;
	int pass = context->CurPass;
	int stage = context->CurTexStage;

	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (DefMatDesc->Has_Texture_Data(pass,stage)) {
		matdesc = &(context->AlternateMatDesc);
	}

	/*
	** Read in the texture(s) array
	*/
	if (cload.Cur_Chunk_Length() == 1*sizeof(uint32)) {
		cload.Read(&texid,sizeof(texid));
		matdesc->Set_Single_Texture(context->Peek_Texture(texid),pass,stage);

	} else {

		for (int i=0; i<Get_Polygon_Count(); i++) {
			cload.Read(&texid,sizeof(uint32));
			if (texid != 0xffffffff) {
				matdesc->Set_Texture(i,context->Peek_Texture(texid),pass,stage);
			} 
		}
	}
	return WW3D_ERROR_OK;
}


/***********************************************************************************************
 * MeshModelClass::read_stage_texcoords -- read the texcoords for a pass,stage                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *   7/14/99    IML : Lightmap support: calculate vertex count directly from chunk size.		  *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_stage_texcoords(ChunkLoadClass & cload,MeshLoadContextClass * context)
{
	unsigned				elementcount;
	Vector2			  *uvs;
	W3dTexCoordStruct texcoord;
	
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
	MeshMatDescClass * matdesc = DefMatDesc;
	if (DefMatDesc->Has_UV(context->CurPass,context->CurTexStage)) {
		matdesc = &(context->AlternateMatDesc);
	}

	/*
	** Read in the texture coordiantes
	*/
	elementcount = cload.Cur_Chunk_Length() / sizeof (W3dTexCoordStruct);
	uvs = context->Get_Temporary_UV_Array(elementcount);
	
	if (uvs != NULL) {
		for (unsigned i = 0; i < elementcount; i++) {
			cload.Read (&texcoord, sizeof (texcoord));
			uvs[i].X = texcoord.U;
			uvs[i].Y = 1.0f - texcoord.V;
		}
	}

	matdesc->Install_UV_Array(context->CurPass,context->CurTexStage,uvs,elementcount);

	return (WW3D_ERROR_OK);
}

	
/***********************************************************************************************
 * MeshModelClass::read_per_face_texcoord_ids -- read uv indices for given (pass,stage).		  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/02/99    IML : Created.                                                                *
 *   9/1/2000   gth : Added alternate material desc support                                    *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_per_face_texcoord_ids (ChunkLoadClass &cload, MeshLoadContextClass *context)
{
	unsigned size;
	
	/*
	** Determine whether this chunk should be read into the default or alternate material description
	*/
//	MeshMatDescClass * matdesc = DefMatDesc;
//	if (DefMatDesc->Has_UVIndex(context->CurPass)) {
//		matdesc = &(context->AlternateMatDesc);
//	}

	/*
	** Read in the texture coordiante indices
	** There must be polygon count vectors in this chunk.
	*/
	size = sizeof (Vector3i) * Get_Polygon_Count();
	if (cload.Cur_Chunk_Length() == size) {
			
//		Vector3i *uvindices;
//	
//		uvindices = matdesc->Get_UVIndex_Array (context->CurPass, true);
//		WWASSERT (uvindices != NULL);

//uvindices=new Vector3i[Get_Polygon_Count()];
//		cload.Read (uvindices, size);
//delete[] uvindices;
		cload.Seek(size);
		return (WW3D_ERROR_OK);
		
	} else {
		return (WW3D_ERROR_LOAD_FAILED);
	}
}


/***********************************************************************************************
 * MeshModelClass::read_prelit_material -- read prelit material chunks.								  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   02/02/99    IML : Created.                                                                *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::read_prelit_material (ChunkLoadClass &cload, MeshLoadContextClass *context)
{
	// If this chunk ID matches the selected prelit chunk ID then load it, otherwise skip it.
	if (cload.Cur_Chunk_ID() == context->PrelitChunkID) {
	
		// While there are chunks in the prelit material chunk wrapper...
		while (cload.Open_Chunk()) {

			WW3DErrorType error = WW3D_ERROR_OK;

			switch (cload.Cur_Chunk_ID()) {

				case W3D_CHUNK_MATERIAL_INFO:
					error = read_material_info (cload,context);
					break;

				case W3D_CHUNK_VERTEX_MATERIALS:
					error = read_vertex_materials (cload,context);
					break;

				case W3D_CHUNK_SHADERS:
					error = read_shaders (cload,context);
					break;

				case W3D_CHUNK_TEXTURES:
					error = read_textures (cload,context);
					break;

				case W3D_CHUNK_MATERIAL_PASS:
					error = read_material_pass (cload,context);
					break;

				default:
					
					// Unknown chunk.
					break;
			}	
			cload.Close_Chunk();
			if (error != WW3D_ERROR_OK) return (error);
		}
	}
	
	return (WW3D_ERROR_OK);
}


/***********************************************************************************************
 * MeshModelClass::post_process -- post loading, perform any processing on this model.			  *			
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   05/02/00   IML : Created.                                                                 *
 *   7/13/2001  hy : Added static sort postprocessing                                          *
 *=============================================================================================*/
void MeshModelClass::post_process()
{
#if 0
	// we want to allow this now due to usage of the static sort 
	// Ensure no sorting, multipass meshes (for they are abomination...)
	if (DefMatDesc->Get_Pass_Count() > 1 && Get_Flag(SORT)) {
		WWDEBUG_SAY(( "Turning SORT off for multipass mesh %s\n",Get_Name() ));
		Set_Flag(SORT, false);
	}
#endif

	// turn off backface culling if the mesh is supposed to be two-sided
	if (Get_Flag(MeshGeometryClass::TWO_SIDED)) {

		DefMatDesc->Disable_Backface_Culling();
		if (AlternateMatDesc != NULL) {
			AlternateMatDesc->Disable_Backface_Culling();
		}

	}

	// fog activation.
	if (WW3DAssetManager::Get_Instance()->Get_Activate_Fog_On_Load()) { 
		post_process_fog();
	}

	// if the mesh is sorting, pick an appropriate static sort level
	// if default isn't set
	if (Get_Flag(SORT) && SortLevel==SORT_LEVEL_NONE && WW3D::Is_Munge_Sort_On_Load_Enabled()) {
		compute_static_sort_levels();
	}
}

void MeshModelClass::post_process_fog(void)
{
	// If two pass...
	if (DefMatDesc->Get_Pass_Count() == 2) {

		// If single shader on both passes...
		if (!DefMatDesc->ShaderArray[0] && !DefMatDesc->ShaderArray[1]) {

			ShaderClass &shader0 = DefMatDesc->Shader [0];
			ShaderClass &shader1 = DefMatDesc->Shader [1];

			// Analyze the mesh to determine if it is the emissive map effect and if it is, fix it up appropriately.
			bool emissive_map_effect = DefMatDesc->PassCount == 2 &&
												shader0.Get_Texturing() == ShaderClass::TEXTURING_DISABLE &&
												shader0.Get_Src_Blend_Func() == ShaderClass::SRCBLEND_ONE &&
												shader0.Get_Dst_Blend_Func() == ShaderClass::DSTBLEND_ZERO &&
												shader0.Get_Primary_Gradient() == ShaderClass::GRADIENT_MODULATE &&
												shader0.Get_Secondary_Gradient() == ShaderClass::SECONDARY_GRADIENT_DISABLE &&
												shader1.Get_Texturing() == ShaderClass::TEXTURING_ENABLE &&
												shader1.Get_Src_Blend_Func() == ShaderClass::SRCBLEND_SRC_ALPHA &&
												shader1.Get_Dst_Blend_Func() == ShaderClass::DSTBLEND_SRC_COLOR;

			if (emissive_map_effect) {

				// Change the shader/texture setting into an equivalent one which will enable setting fog
				// correctly: Note that we are setting up pass 0 to have a texture now.
				shader0.Set_Texturing(ShaderClass::TEXTURING_ENABLE);
				shader1.Set_Dst_Blend_Func(ShaderClass::DSTBLEND_ONE);
				shader0.Set_Fog_Func(ShaderClass::FOG_ENABLE);
				shader1.Set_Fog_Func(ShaderClass::FOG_SCALE_FRAGMENT);

				// Copy pass 1 texture/texture array to pass 0.
				REF_PTR_SET (DefMatDesc->Texture[0][0], DefMatDesc->Texture [1][0]);
				if (DefMatDesc->TextureArray [1][0]) {
					if (!DefMatDesc->TextureArray [0][0]) {
						DefMatDesc->TextureArray [0][0] = NEW_REF (TexBufferClass, (PolyCount));
						for (int i = 0; i < PolyCount; i++) {
							DefMatDesc->TextureArray [0][0]->Set_Element (i, DefMatDesc->TextureArray [1][0]->Peek_Element (i));
						}
					}
				}

				// Make pass 0 point to the same UV array as pass 1. If pass 1 has a vertex material
				// array, we only take the first one for determining UV source. The UV source is
				// used to set the UV source of all the vertex materials in pass 0.
				int uv_source = 0;
				if (DefMatDesc->MaterialArray[1]) {
					uv_source = DefMatDesc->MaterialArray[1]->Peek_Element(0)->Get_UV_Source(0);
				} else {
					DefMatDesc->Material[1]->Get_UV_Source(0);
				}
				if (DefMatDesc->MaterialArray[0]) {
					for (int i = 0; i < VertexCount; i++) {
						DefMatDesc->MaterialArray[0]->Peek_Element(i)->Set_UV_Source(0, uv_source);
					}
				} else {
					DefMatDesc->Material[0]->Set_UV_Source(0, uv_source);
				}

				return;
			}
				
			// Analyze the mesh to determine if it is the shiny mask effect and if it is, fix it up appropriately.
			bool shiny_mask_effect = shader0.Get_Src_Blend_Func() == ShaderClass::SRCBLEND_ONE &&
											 shader0.Get_Dst_Blend_Func() == ShaderClass::DSTBLEND_ZERO &&
											 shader1.Get_Src_Blend_Func() == ShaderClass::SRCBLEND_ONE &&
											(shader1.Get_Dst_Blend_Func() == ShaderClass::DSTBLEND_SRC_ALPHA ||
											 shader1.Get_Dst_Blend_Func() == ShaderClass::DSTBLEND_ONE_MINUS_SRC_ALPHA);

			if (shiny_mask_effect) {
				shader0.Set_Fog_Func(ShaderClass::FOG_SCALE_FRAGMENT);
				shader1.Set_Fog_Func(ShaderClass::FOG_ENABLE);
				return;
			}
		}
	}
		
	// Mesh is not one of the special two-pass combinations. Apply a per-pass generic fix-up.
	for (int pass = 0; pass < DefMatDesc->PassCount; pass++) {
		DefMatDesc->Shader [pass].Enable_Fog (Get_Name());
		if (DefMatDesc->ShaderArray [pass]) {
			for (int tri = 0; tri < DefMatDesc->ShaderArray [pass]->Get_Count(); tri++) {
				DefMatDesc->ShaderArray [pass]->Get_Element (tri).Enable_Fog (Get_Name());
			}
		}
	}
}

unsigned int MeshModelClass::get_sort_flags(int pass) const
{
	unsigned int flags = 0;
	ShaderClass::StaticSortCategoryType scat;
	if (Has_Shader_Array(pass)) {
		for (int tri = 0; tri < CurMatDesc->ShaderArray[pass]->Get_Count(); tri++) {
			scat = CurMatDesc->ShaderArray[pass]->Get_Element(tri).Get_SS_Category();
			flags |= (1 << scat);
		}			
	} else {
		scat = Get_Single_Shader(pass).Get_SS_Category();
		flags |= (1 << scat);
	}
	return flags;
}

unsigned int MeshModelClass::get_sort_flags(void) const
{
	unsigned int flags = 0;
	for (int pass = 0; pass < Get_Pass_Count(); pass++) {
		flags |= get_sort_flags(pass);
	}
	return flags;
}

void MeshModelClass::compute_static_sort_levels(void)
{
	enum StaticSortCategoryBitFieldType
	{
		SSCAT_OPAQUE_BF		= (1 << ShaderClass::SSCAT_OPAQUE),
		SSCAT_ALPHA_TEST_BF	= (1 << ShaderClass::SSCAT_ALPHA_TEST),
		SSCAT_ADDITIVE_BF		= (1 << ShaderClass::SSCAT_ADDITIVE),
		SSCAT_OTHER_BF			= (1 << ShaderClass::SSCAT_OTHER)
	};

	if (get_sort_flags(0) == SSCAT_OPAQUE_BF) {
		SortLevel = SORT_LEVEL_NONE;
		return;
	}

	switch (get_sort_flags())
	{
	case (SSCAT_OPAQUE_BF | SSCAT_ALPHA_TEST_BF):
		SortLevel = SORT_LEVEL_NONE;
		break;

	case SSCAT_ADDITIVE_BF:
		SortLevel = SORT_LEVEL_BIN3;
		break;

	case (SSCAT_ADDITIVE_BF | SSCAT_ALPHA_TEST_BF):
		SortLevel = SORT_LEVEL_BIN2;
		break;
		
	default:
		SortLevel = SORT_LEVEL_BIN1;
		break;
	};
}


void MeshModelClass::install_materials(MeshLoadContextClass * context)
{
	int i;

	/*
	** If alternate material chunks were loaded, initialize the AlternateMatDesc
	*/
	install_alternate_material_desc(context);
	
	/*
	** Finish configuring the vertex materials and color arrays.
	*/
	bool lighting_enabled=true;
	// vertex-lit models need the lighting turned off!
	if (Get_Flag(MeshGeometryClass::PRELIT_VERTEX)) {
		lighting_enabled=false;
	}
	DefMatDesc->Post_Load_Process (lighting_enabled,this);
	if (AlternateMatDesc != NULL) {
		AlternateMatDesc->Post_Load_Process (lighting_enabled,this);
	}

	/*
	** transfer the refs to our textures into the MatInfo
	*/
	for (i=0; i<context->Texture_Count(); i++) {
		MatInfo->Add_Texture(context->Peek_Texture(i));
	}

	/*
	** transfer the refs to our vertex materials into the MatInfo
	*/
	for (i=0; i<context->Vertex_Material_Count(); i++) {
		MatInfo->Add_Vertex_Material(context->Peek_Vertex_Material(i));
	}
}


void MeshModelClass::clone_materials(const MeshModelClass & srcmesh)
{
	/*
	** Copy the material info and the materials within
	*/
	REF_PTR_RELEASE(MatInfo);
	MatInfo = NEW_REF( MaterialInfoClass,(*(srcmesh.MatInfo)));

	/*
	** remap!
	*/
	MaterialRemapperClass remapper(srcmesh.MatInfo, MatInfo);
	remapper.Remap_Mesh(srcmesh.CurMatDesc, CurMatDesc);
}


void MeshModelClass::install_alternate_material_desc(MeshLoadContextClass * context)
{
	if (context->AlternateMatDesc.Is_Empty() == false) {
		WWASSERT(AlternateMatDesc == NULL);
		AlternateMatDesc = new MeshMatDescClass;
		AlternateMatDesc->Init_Alternate(*DefMatDesc,context->AlternateMatDesc);
	}
}

/***********************************************************************************************
 * MeshLoadContextClass::MeshLoadContextClass -- constructor for MeshLoadContextClass          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
MeshLoadContextClass::MeshLoadContextClass(void)
{
	memset(&Header,0,sizeof(Header));
	memset(&MatInfo,0,sizeof(MatInfo));
	PrelitChunkID = 0xffffffff;
	CurPass = 0;
	CurTexStage = 0;
	TexCoords = NULL;
	LoadedDIG = false;
}


/***********************************************************************************************
 * MeshLoadContextClass::~MeshLoadContextClass -- destructor                                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
MeshLoadContextClass::~MeshLoadContextClass(void)
{
	int i;

	if (TexCoords != NULL) {
		delete TexCoords;
		TexCoords = NULL;
	}
	for (i=0; i<Textures.Count(); i++) {
		Textures[i]->Release_Ref();
	}
	for (i=0; i<VertexMaterials.Count(); i++) {
		VertexMaterials[i]->Release_Ref();
	}
	for (i=0; i<LegacyMaterials.Count(); i++) {
		delete LegacyMaterials[i];
	}
}


/***********************************************************************************************
 * MeshLoadContextClass::Get_Texcoord_Array -- returns the texture coordinates array           *
 *                                                                                             *
 * This function mainly exists to support the obsolete version 3.0 w3d files                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
W3dTexCoordStruct * MeshLoadContextClass::Get_Texcoord_Array(void)
{
	if (TexCoords == NULL) {
		TexCoords = new W3dTexCoordStruct[Header.NumVertices];
	}
	return TexCoords;
}


/***********************************************************************************************
 * MeshLoadContextClass::Add_Shader -- adds a shader to the array                              *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
int MeshLoadContextClass::Add_Shader(ShaderClass shader)								
{ 
	int index = Shaders.Count();
	Shaders.Add(shader); 
	return index;
}


/***********************************************************************************************
 * MeshLoadContextClass::Add_Vertex_Materail -- adds a vertex material                         *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
int MeshLoadContextClass::Add_Vertex_Material(VertexMaterialClass * vmat)			
{ 
	WWASSERT(vmat != NULL);
	vmat->Add_Ref();
	int index = VertexMaterials.Count();
	VertexMaterials.Add(vmat); 
	return index;
}


/***********************************************************************************************
 * MeshLoadContextClass::Add_Texture -- adds a texture                                         *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
int MeshLoadContextClass::Add_Texture(TextureClass * tex)							
{ 
	WWASSERT(tex != NULL);
	tex->Add_Ref();
	int index = Textures.Count();
	Textures.Add(tex); 
	return index;
}


/***********************************************************************************************
 * MeshLoadContextClass::Add_Legacy_Material -- adds a legacy material                         *
 *                                                                                             *
 * This function will check to see if the parameters of any of the parts of the material are   *
 * duplicated.  Only unique shaders/vertexmaterials will be actually added.                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
void MeshLoadContextClass::Add_Legacy_Material(ShaderClass shader,VertexMaterialClass * vmat,TextureClass * tex)
{
	// create a new legacy material
	LegacyMaterialClass * mat = new LegacyMaterialClass;

	// add the shader if it is unique
	for (int si=0; si<Shaders.Count(); si++) {
		if (Shaders[si] == shader) break;
	}
	if (si == Shaders.Count()) {
		mat->ShaderIdx = Add_Shader(shader);
	} else {
		mat->ShaderIdx = si;
	}

	// add the vertex material if it is unique
	if (vmat == NULL) {
		mat->VertexMaterialIdx = -1;
	} else {
		unsigned long crc = vmat->Get_CRC();	
		for (int vi=0; vi<VertexMaterialCrcs.Count(); vi++) {
			if (VertexMaterialCrcs[vi] == crc) break;
		}
		if (vi == VertexMaterials.Count()) {
			mat->VertexMaterialIdx = Add_Vertex_Material(vmat);
			VertexMaterialCrcs.Add(crc);
			WWASSERT(VertexMaterialCrcs.Count() == VertexMaterials.Count());
		} else {
			mat->VertexMaterialIdx = vi;
		}
	}

	// add the texture if it is unique
	if (tex == NULL) {
		mat->TextureIdx = -1;
	} else {
		for (int ti=0; ti<Textures.Count(); ti++) {
			if (Textures[ti] == tex) break;
			if (stricmp(Textures[ti]->Get_Texture_Name(),tex->Get_Texture_Name()) == 0) break;
		}
		if (ti == Textures.Count()) {
			mat->TextureIdx = Add_Texture(tex);
		} else {
			mat->TextureIdx = ti;
		}
	}

	LegacyMaterials.Add(mat);
}


/***********************************************************************************************
 * MeshLoadContextClass::Peek_Legacy_Shader -- returns a legacy shader								  *		
 *                                                                                             *
 * This function does the re-indexing to go from the legacy shader index to the actual shader  *
 * index and then returns that shader                                                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
ShaderClass MeshLoadContextClass::Peek_Legacy_Shader(int legacy_material_index)
{
	WWASSERT(legacy_material_index >= 0);
	WWASSERT(legacy_material_index < LegacyMaterials.Count());
	int si = LegacyMaterials[legacy_material_index]->ShaderIdx;
	return Peek_Shader(si);
}


/***********************************************************************************************
 * MeshLoadContextClass::Peek_Legacy_Vertex_Material -- returns a pointer to a legacy vertex ma*
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
VertexMaterialClass * MeshLoadContextClass::Peek_Legacy_Vertex_Material(int legacy_material_index)
{
	WWASSERT(legacy_material_index >= 0);
	WWASSERT(legacy_material_index < LegacyMaterials.Count());
	int vi = LegacyMaterials[legacy_material_index]->VertexMaterialIdx;
	if (vi != -1) {
		return Peek_Vertex_Material(vi);
	} else {
		return NULL;
	}
}


/***********************************************************************************************
 * MeshLoadContextClass::Peek_Legacy_Texture -- returns a pointer to a texture                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   12/10/98   GTH : Created.                                                                 *
 *=============================================================================================*/
TextureClass * MeshLoadContextClass::Peek_Legacy_Texture(int legacy_material_index)
{
	WWASSERT(legacy_material_index >= 0);
	WWASSERT(legacy_material_index < LegacyMaterials.Count());
	int ti = LegacyMaterials[legacy_material_index]->TextureIdx;
	if (ti != -1) {
		return Peek_Texture(ti);
	} else {
		return NULL;
	}
}


Vector2 * MeshLoadContextClass::Get_Temporary_UV_Array(int elementcount)
{
	TempUVArray.Uninitialised_Grow(elementcount);
	return &(TempUVArray[0]);
}



/***********************************************************************************************
 * MeshSaveContextClass::MeshSaveContextClass -- constructor                                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
MeshSaveContextClass::MeshSaveContextClass(void) :
	CurPass(0),
	CurStage(0)
{
}


/***********************************************************************************************
 * MeshSaveContextClass::~MeshSaveContextClass -- destructor                                   *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
MeshSaveContextClass::~MeshSaveContextClass(void)
{
}





#if 0 // MESH SAVING CODE HAS NOT BEEN MAINTAINED... Leaving here for future reference if we ever need it :-)

/***********************************************************************************************
 * MeshModelClass::Save -- Save this mesh model!                                               *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/16/99    GTH : Created.                                                                 *
 *=============================================================================================*/
WW3DErrorType MeshModelClass::Save_W3D(ChunkSaveClass & csave)
{
	MeshSaveContextClass * context = new MeshSaveContextClass;
	context->Materials.Collect_Materials(this);

	write_chunks(csave,context);

	delete context;
	return WW3D_ERROR_OK;
}


WW3DErrorType MeshModelClass::write_chunks(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	
	// write the header
	write_header(csave,context);
	write_user_text(csave,context);

	// write the geometry
	write_triangles(csave,context);	
	write_vertices(csave,context);
	write_vertex_normals(csave,context);
	write_vertex_shade_indices(csave,context);
	write_vertex_influences(csave,context);
	//write_cull_tree(csave);

	// material stuff
	write_material_info(csave,context);
	write_vertex_materials(csave,context);
	write_shaders(csave,context);
	write_textures(csave,context);

	// passes
	for (int i=0; i<Get_Pass_Count(); i++) {
		context->CurPass = i;
		write_material_pass(csave,context);
	}
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_header(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	W3dMeshHeader3Struct header;
	memset(&header,0,sizeof(header));
	
	// Set names
	if (MeshName) {

		char * name = MeshName->Get_Array();
		char * mesh_name = strchr(name,'.');
		
		int hierarchy_name_len = 0;
		if (mesh_name == NULL) {
			mesh_name = name;
		} else {
			hierarchy_name_len = (int)mesh_name - (int)name;
			mesh_name++;
		}
		assert( hierarchy_name_len <= W3D_NAME_LEN);
		strncpy( header.MeshName, mesh_name, W3D_NAME_LEN);
		strncpy( header.ContainerName, name, hierarchy_name_len);
	} else {
		sprintf(header.MeshName,"UnNamed");
	}

	header.Version = W3D_CURRENT_MESH_VERSION;
	header.Attributes = W3dAttributes;
	header.NumTris = Get_Polygon_Count();
	header.NumVertices = Get_Vertex_Count();
	header.NumMaterials = 0;
	header.NumDamageStages = 0;

	header.VertexChannels = W3D_VERTEX_CHANNEL_LOCATION;
	if (Get_Flag(SKIN)) {
		header.VertexChannels |= W3D_VERTEX_CHANNEL_BONEID;
	}

	header.FaceChannels = W3D_FACE_CHANNEL_FACE;

	W3dUtilityClass::Convert_Vector(BoundBoxMin,&(header.Min));
	W3dUtilityClass::Convert_Vector(BoundBoxMax,&(header.Max));
	W3dUtilityClass::Convert_Vector(BoundSphereCenter,&header.SphCenter);
	header.SphRadius = BoundSphereRadius;

	csave.Begin_Chunk(W3D_CHUNK_MESH_HEADER3);
	if (csave.Write(&header,sizeof(header)) != sizeof(header)) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	csave.End_Chunk();

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_user_text(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	if (UserText == NULL) return WW3D_ERROR_OK;
	if (strlen(UserText->Get_Array()) < 1) return WW3D_ERROR_OK;

	csave.Begin_Chunk(W3D_CHUNK_MESH_USER_TEXT);
	csave.Write(UserText->Get_Array(),strlen(UserText->Get_Array()) + 1);
	csave.End_Chunk();

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_triangles(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	if (!csave.Begin_Chunk(W3D_CHUNK_TRIANGLES)) {
		return WW3D_ERROR_LOAD_FAILED;
	}

	TriIndex	* poly_verts = Poly->Get_Array();
	Vector4 * poly_eq = (PlaneEq ? PlaneEq->Get_Array() : NULL);

	for (int i=0; i<Get_Polygon_Count(); i++) {

		W3dTriStruct tri;
		memset(&tri,0,sizeof(W3dTriStruct));

		// convert each triangle into surrender format
		tri.Vindex[0] =			poly_verts[i].I;
		tri.Vindex[1] = 			poly_verts[i].J;
		tri.Vindex[2] = 			poly_verts[i].K;

		if (poly_eq)  {
			tri.Attributes =		0;
			tri.Normal.X = 		poly_eq[i].X;
			tri.Normal.Y = 		poly_eq[i].Y;
			tri.Normal.Z = 		poly_eq[i].Z;
			tri.Dist =				poly_eq[i].W;
		} else {
			
			Vector3 a,b,normal;
			Vector3 * verts = Vertex->Get_Array();
			const Vector3 & p0= verts[poly_verts[i][0]];

			Vector3::Subtract(verts[poly_verts[i][1]],p0,&a);
			Vector3::Subtract(verts[poly_verts[i][2]],p0,&b);
			Vector3::Cross_Product(a,b,&normal);
			normal.Normalize();

			tri.Attributes =		0;
			tri.Normal.X =			normal.X;
			tri.Normal.Y =			normal.Y;
			tri.Normal.Z =			normal.Z;
			tri.Dist =				Vector3::Dot_Product(p0,normal);
		}

		if (csave.Write(&tri,sizeof(W3dTriStruct)) != sizeof(W3dTriStruct)) {
			return WW3D_ERROR_SAVE_FAILED;
		} 
	}

	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertices(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	if (!csave.Begin_Chunk(W3D_CHUNK_VERTICES)) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	
	WWASSERT(Get_Vertex_Count() > 0);
	Vector3 * verts = Vertex->Get_Array();

	for (int i=0; i<Get_Vertex_Count(); i++) {

		W3dVectorStruct vert;
   	vert.X = verts[i].X;
		vert.Y = verts[i].Y;
		vert.Z = verts[i].Z;
		
		if (csave.Write(&(vert),sizeof(W3dVectorStruct)) != sizeof(W3dVectorStruct)) {
			return WW3D_ERROR_SAVE_FAILED;
		}
	}
	
	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertex_normals(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	WWASSERT( Get_Vertex_Count() > 0);
	if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_NORMALS)) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	
	const Vector3 * verts = Get_Vertex_Normal_Array();
	
	for (int i=0; i<Get_Vertex_Count(); i++) {

		W3dVectorStruct vert;
   	vert.X = verts[i].X;
		vert.Y = verts[i].Y;
		vert.Z = verts[i].Z;
		
		if (csave.Write(&(vert),sizeof(W3dVectorStruct)) != sizeof(W3dVectorStruct)) {
			return WW3D_ERROR_SAVE_FAILED;
		}
	}
	
	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertex_shade_indices(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	WWASSERT(Get_Vertex_Count() > 0);
	if (VertexShadeIdx == NULL) return WW3D_ERROR_OK;

	if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_SHADE_INDICES)) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	for (int i=0; i<Get_Vertex_Count(); i++) {
		uint32 idx = VertexShadeIdx->Get_Array()[i];
		if (csave.Write(&idx,sizeof(idx)) != sizeof(idx)) {
			return WW3D_ERROR_SAVE_FAILED;
		}
	}

	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertex_influences(ChunkSaveClass & csave,MeshSaveContextClass * /*context*/)
{
	WWASSERT(Get_Vertex_Count() > 0);
	if (VertexBoneLink == NULL) return WW3D_ERROR_OK;

	if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_INFLUENCES)) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	W3dVertInfStruct vinf;
	memset(&vinf,0,sizeof(vinf));

	for (int i=0; i<Get_Vertex_Count(); i++) {
		vinf.BoneIdx = VertexBoneLink->Get_Array()[i];
		if (csave.Write(&vinf,sizeof(vinf)) != sizeof(vinf)) {
			return WW3D_ERROR_SAVE_FAILED;
		}
	}

	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_material_info(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (!csave.Begin_Chunk(W3D_CHUNK_MATERIAL_INFO)) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	W3dMaterialInfoStruct info;
	memset(&info,0,sizeof(info));

	info.PassCount = DefMatDesc->PassCount;
	info.VertexMaterialCount = context->Materials.Get_Vertex_Material_Count();
	info.TextureCount = context->Materials.Get_Texture_Count();
	info.ShaderCount = context->Materials.Get_Shader_Count();

	if (csave.Write(&info,sizeof(info)) != sizeof(info)) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	if (!csave.End_Chunk()) {
		return WW3D_ERROR_SAVE_FAILED;
	}

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_shaders(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (context->Materials.Get_Shader_Count() <= 0) {
		return WW3D_ERROR_OK;
	}

	if (!csave.Begin_Chunk(W3D_CHUNK_SHADERS)) return WW3D_ERROR_SAVE_FAILED;

	for (int si=0; si<context->Materials.Get_Shader_Count(); si++) {
		W3dShaderStruct file_shader;
		ShaderClass	shader = context->Materials.Peek_Shader(si);
		W3dUtilityClass::Convert_Shader(shader,&file_shader);

		if (csave.Write(&file_shader,sizeof(file_shader)) != sizeof(file_shader)) {
			return WW3D_ERROR_SAVE_FAILED;
		}
	}

	if (!csave.End_Chunk()) return WW3D_ERROR_SAVE_FAILED;
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertex_materials(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (context->Materials.Get_Vertex_Material_Count() <= 0) return WW3D_ERROR_OK;
	if (!csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIALS)) return WW3D_ERROR_SAVE_FAILED;
	
	for (int vi=0; vi<context->Materials.Get_Vertex_Material_Count(); vi++) {
		
		csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL);
		VertexMaterialClass * vmat = context->Materials.Peek_Vertex_Material(vi);
		vmat->Save_W3D(csave);
		csave.End_Chunk();
	}

	if (!csave.End_Chunk()) return WW3D_ERROR_SAVE_FAILED;
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_textures(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (context->Materials.Get_Texture_Count() <= 0) return WW3D_ERROR_OK;
	if (!csave.Begin_Chunk(W3D_CHUNK_TEXTURES)) return WW3D_ERROR_SAVE_FAILED;
	
	for (int ti=0; ti<context->Materials.Get_Texture_Count(); ti++) {
		TextureClass * tex = context->Materials.Peek_Texture(ti);
		Save_Texture(tex,csave);
	}

	if (!csave.End_Chunk()) return WW3D_ERROR_SAVE_FAILED;
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_material_pass(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	context->CurStage = 0;
	csave.Begin_Chunk(W3D_CHUNK_MATERIAL_PASS);

	write_vertex_material_ids(csave,context);
	write_shader_ids(csave,context);
	write_dcg(csave,context);
	write_dig(csave,context);
	write_scg(csave,context);
	write_texture_stage(csave,context);
	write_texture_stage(csave,context);

	csave.End_Chunk();
	context->CurPass++;

	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_vertex_material_ids(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	// first check if all vertex material pointers are Null (is this legal?)
	if (	(DefMatDesc->Material[context->CurPass] == NULL) && 
			(DefMatDesc->MaterialArray[context->CurPass] == NULL)) return WW3D_ERROR_OK;

	csave.Begin_Chunk(W3D_CHUNK_VERTEX_MATERIAL_IDS);

	uint32 id = 0;
	if (DefMatDesc->MaterialArray[context->CurPass] == NULL) {
		
		id = context->Materials.Find_Vertex_Material(DefMatDesc->Material[context->CurPass]);
		csave.Write(&id,sizeof(id));

	} else {

		VertexMaterialClass ** array = DefMatDesc->MaterialArray[context->CurPass]->Get_Array();
		for (int vi=0; vi<Get_Vertex_Count(); vi++) {
			id = context->Materials.Find_Vertex_Material(array[vi]);
			csave.Write(&id,sizeof(id));
		}

	}

	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_shader_ids(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	csave.Begin_Chunk(W3D_CHUNK_SHADER_IDS);

	uint32 id = 0;
	if (DefMatDesc->ShaderArray[context->CurPass] == NULL) {
		
		id = context->Materials.Find_Shader(DefMatDesc->Shader[context->CurPass]);
		csave.Write(&id,sizeof(id));

	} else {
		
		ShaderClass * array = DefMatDesc->ShaderArray[context->CurPass]->Get_Array();
		for (int pi=0; pi<Get_Polygon_Count(); pi++) {
			id = context->Materials.Find_Shader(array[pi]);
			csave.Write(&id,sizeof(id));
		}
	}

	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_scg(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (DefMatDesc->SCG[context->CurPass] == NULL) return WW3D_ERROR_OK;
	csave.Begin_Chunk(W3D_CHUNK_SCG);
	
	W3dRGBAStruct color;
	Vector4 * color_array = DefMatDesc->SCG[context->CurPass]->Get_Array();
	for (int vi=0; vi<Get_Vertex_Count(); vi++) {
		W3dUtilityClass::Convert_Color(color_array[vi],&color);
		csave.Write(&color,sizeof(color));
	}

	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_dig(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (DefMatDesc->DIG[context->CurPass] == NULL) return WW3D_ERROR_OK;
	csave.Begin_Chunk(W3D_CHUNK_DIG);

	W3dRGBStruct color;
	Vector3 * color_array = DefMatDesc->DIG[context->CurPass]->Get_Array();
	for (int vi=0; vi<Get_Vertex_Count(); vi++) {
		W3dUtilityClass::Convert_Color(color_array[vi],&color);
		csave.Write(&color,sizeof(color));
	}
	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_dcg(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (DefMatDesc->DCG[context->CurPass] == NULL) return WW3D_ERROR_OK;
	csave.Begin_Chunk(W3D_CHUNK_DCG);

	W3dRGBAStruct color;
	Vector4 * color_array = DefMatDesc->DCG[context->CurPass]->Get_Array();
	for (int vi=0; vi<Get_Vertex_Count(); vi++) {
		W3dUtilityClass::Convert_Color(color_array[vi],&color);
		csave.Write(&color,sizeof(color));
	}
	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_texture_stage(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (	(DefMatDesc->Texture[context->CurPass][context->CurStage] == NULL) &&
			(DefMatDesc->TextureArray[context->CurPass][context->CurStage] == NULL)) return WW3D_ERROR_OK;
	
	csave.Begin_Chunk(W3D_CHUNK_TEXTURE_STAGE);
	write_texture_ids(csave,context);
	write_stage_texcoords(csave,context);
	csave.End_Chunk();

	context->CurStage++;
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_texture_ids(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	csave.Begin_Chunk(W3D_CHUNK_TEXTURE_IDS);
	
	uint32 id = 0;
	if (DefMatDesc->TextureArray[context->CurPass][context->CurStage] == NULL) {
		
		id = context->Materials.Find_Texture(DefMatDesc->Texture[context->CurPass][context->CurStage]);
		csave.Write(&id,sizeof(id));

	} else {
		
		srTextureIFace ** array = DefMatDesc->TextureArray[context->CurPass][context->CurStage]->Get_Array();
		for (int pi=0; pi<Get_Polygon_Count(); pi++) {
			id = context->Materials.Find_Texture(array[pi]);
			csave.Write(&id,sizeof(id));
		}
	}

	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

WW3DErrorType MeshModelClass::write_stage_texcoords(ChunkSaveClass & csave,MeshSaveContextClass * context)
{
	if (DefMatDesc->UV[context->CurPass][context->CurStage] == NULL) return WW3D_ERROR_OK;
	csave.Begin_Chunk(W3D_CHUNK_STAGE_TEXCOORDS);

	W3dTexCoordStruct tex;
	Vector2 * array = DefMatDesc->UV[context->CurPass][context->CurStage]->Get_Array();

	for (int vi=0; vi<Get_Vertex_Count(); vi++) {

		tex.U = array[vi].X;
		tex.V = 1.0f - array[vi].Y;
		
		csave.Write(&tex,sizeof(tex));
	}

	csave.End_Chunk();
	return WW3D_ERROR_OK;
}

#endif // 0 (disabled mesh saving code)