/* ** 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 . */ /*********************************************************************************************** *** 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 #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 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; iInstall_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; miHeader.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; iPeek_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; iSet_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; iMatInfo.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; iSet_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; iPeek_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; iPrelitChunkID==W3D_CHUNK_PRELIT_VERTEX) { W3dRGBAStruct color; unsigned * dcg = matdesc->Get_Color_Array(0); for (int i=0; iSet_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; iGet_Color_Array(0); for (int i=0; iSet_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; iSet_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; iTexture_Count(); i++) { MatInfo->Add_Texture(context->Peek_Texture(i)); } /* ** transfer the refs to our vertex materials into the MatInfo */ for (i=0; iVertex_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; iRelease_Ref(); } for (i=0; iRelease_Ref(); } for (i=0; iAdd_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; siShaderIdx = 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; viVertexMaterialIdx = 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; tiGet_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; iCurPass = 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; iGet_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 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 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; iGet_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; iGet_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; siMaterials.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; viMaterials.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; tiMaterials.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; viMaterials.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; piMaterials.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; viDIG[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; viDCG[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; viTexture[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; piMaterials.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