This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/ww3d2/meshmdlio.cpp

2696 lines
No EOL
107 KiB
C++

/*
** 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)