/* ** Command & Conquer Generals Zero Hour(tm) ** Copyright 2025 Electronic Arts Inc. ** ** This program is free software: you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation, either version 3 of the License, or ** (at your option) any later version. ** ** This program is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with this program. If not, see . */ /*********************************************************************************************** *** 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 : Max2W3d * * * * $Archive:: /Commando/Code/Tools/max2w3d/w3dmtl.h $* * * * $Author:: Andre_a $* * * * $Modtime:: 12/07/00 2:47p $* * * * $Revision:: 15 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #if defined(_MSC_VER) #pragma once #endif #ifndef W3DMTL_H #define W3DMTL_H #include "always.h" #include "w3d_file.h" #include "vector.h" class GameMtl; class Mtl; class ChunkSaveClass; /* ** W3dMapClass. ** This class simply ties together the map info and the map filename */ class W3dMapClass { public: W3dMapClass(void) : Filename(NULL), AnimInfo(NULL) {}; W3dMapClass(const W3dMapClass & that); ~W3dMapClass(void); W3dMapClass & operator = (const W3dMapClass & that); void Reset(void); void Set_Filename(const char * name); void Set_Anim_Info(const W3dTextureInfoStruct * info); void Set_Anim_Info(int framecount,float framerate); char * Filename; W3dTextureInfoStruct * AnimInfo; }; /* ** W3dMaterialClass. ** This class ties together w3d structures for up to 'MAX_PASSES' material passes. ** It is typically plugged into the next class (W3dMaterialDescClass) so that ** duplicate members can detected and shared. */ class W3dMaterialClass { public: W3dMaterialClass(void); ~W3dMaterialClass(void); enum { MAX_PASSES = 4, MAX_STAGES = 2 }; void Reset(void); /* ** Construction from Max materials */ void Init(Mtl * mtl, char *materialColorTexture=NULL); void Init(GameMtl * gamemtl, char *materialColorTexture=NULL); /* ** Manual Construction */ void Set_Surface_Type(unsigned int type); void Set_Sort_Level(int level); void Set_Pass_Count(int count); void Set_Vertex_Material(const W3dVertexMaterialStruct & vmat,int pass = 0); void Set_Mapper_Args(const char *args_buffer, int pass = 0, int stage = 0); void Set_Shader(const W3dShaderStruct & shader,int pass = 0); void Set_Texture(const W3dMapClass & map,int pass = 0,int stage = 0); void Set_Map_Channel(int pass,int stage,int channel); /* ** Inspection */ unsigned int Get_Surface_Type(void) const; int Get_Sort_Level(void) const; int Get_Pass_Count(void) const; W3dVertexMaterialStruct * Get_Vertex_Material(int pass = 0) const; const char * Get_Mapper_Args(int pass /*= 0*/, int stage /*= 0*/) const; W3dShaderStruct Get_Shader(int pass = 0) const; W3dMapClass * Get_Texture(int pass = 0,int stage = 0) const; int Get_Map_Channel(int pass = 0,int stage = 0) const; bool Is_Multi_Pass_Transparent(void) const; protected: void Free(void); unsigned int SurfaceType; int SortLevel; int PassCount; W3dShaderStruct Shaders[MAX_PASSES]; W3dVertexMaterialStruct * Materials[MAX_PASSES]; char * MapperArgs[MAX_PASSES][MAX_STAGES]; W3dMapClass * Textures[MAX_PASSES][MAX_STAGES]; int MapChannel[MAX_PASSES][MAX_STAGES]; }; /* ** W3dMaterialDescClass ** This class's purpose is to process the set of w3dmaterials used by a mesh into a set ** of surrender passes with shaders, vertexmaterials, textures. Part of its job is ** to detect duplicated shaders and vertex materials and remove them. */ class W3dMaterialDescClass { public: typedef enum ErrorType { OK = 0, // material description was built successfully INCONSISTENT_PASSES, // material doesn't have same number of passes MULTIPASS_TRANSPARENT, // material is transparent and multi-pass (NO-NO!) INCONSISTENT_SORT_LEVEL, // material doesn't have the same sort level! }; W3dMaterialDescClass(void); ~W3dMaterialDescClass(void); void Reset(void); /* ** Interface for adding a material description. The material will be assigned ** an index based on the order at which they are added. Add your materials in ** order, then use their indices to find the remapped vertex materials, textures, ** and shaders... */ ErrorType Add_Material(const W3dMaterialClass & mat,const char * name = NULL); /* ** Global Information. These methods give access to all of the unique vertex materials, ** shaders, and textures being used. */ int Material_Count(void); int Pass_Count(void); int Vertex_Material_Count(void); int Shader_Count(void); int Texture_Count(void); int Get_Sort_Level(void); W3dVertexMaterialStruct * Get_Vertex_Material(int vmat_index); const char * Get_Mapper_Args(int vmat_index, int stage); W3dShaderStruct * Get_Shader(int shader_index); W3dMapClass * Get_Texture(int texture_index); /* ** Per-Pass Information. These methods convert a material index and pass index pair into ** an index to the desired vertex material, texture or shader. */ int Get_Vertex_Material_Index(int mat_index,int pass); int Get_Shader_Index(int mat_index,int pass); int Get_Texture_Index(int mat_index,int pass,int stage); W3dVertexMaterialStruct * Get_Vertex_Material(int mat_index,int pass); const char * Get_Mapper_Args(int mat_index,int pass,int stage); W3dShaderStruct * Get_Shader(int mat_index,int pass); W3dMapClass * Get_Texture(int mat_index,int pass,int stage); int Get_Map_Channel(int mat_index,int pass,int stage); bool Stage_Needs_Texture_Coordinates(int pass,int stage); bool Pass_Uses_Vertex_Alpha(int pass); bool Pass_Uses_Alpha(int pass); /* ** Vertex Material Names. It will be useful to have named vertex materials. I'll keep ** the name of the first material which contained each vertex material as its name. Use ** these functions to get the name associated with a vertex material */ const char * Get_Vertex_Material_Name(int mat_index,int pass); const char * Get_Vertex_Material_Name(int vmat_index); private: int Add_Vertex_Material(W3dVertexMaterialStruct * vmat,const char *mapper_args0,const char *mapper_args1,int pass,const char * name); int Add_Shader(const W3dShaderStruct & shader,int pass); int Add_Texture(W3dMapClass * map,int pass,int stage); unsigned long Compute_Crc(const W3dVertexMaterialStruct & vmat,const char *mapper_args0,const char *mapper_args1); unsigned long Compute_Crc(const W3dShaderStruct & shader); unsigned long Compute_Crc(const W3dMapClass & map); unsigned long Add_String_To_Crc(const char *str, unsigned long crc); /* ** MaterialRemapClass ** When the user supplies a W3dMaterial to this material description class, ** its sub-parts are installed and an instance of this class is created to ** re-index to each one. */ class MaterialRemapClass { public: MaterialRemapClass(void); bool operator != (const MaterialRemapClass & that); bool operator == (const MaterialRemapClass & that); int PassCount; int VertexMaterialIdx[W3dMaterialClass::MAX_PASSES]; int ShaderIdx[W3dMaterialClass::MAX_PASSES]; int TextureIdx[W3dMaterialClass::MAX_PASSES][W3dMaterialClass::MAX_STAGES]; int MapChannel[W3dMaterialClass::MAX_PASSES][W3dMaterialClass::MAX_STAGES]; }; /* ** VertMatClass ** This class encapsulates a vertex material structure and makes it extendable for ** any purposes needed by the plugin code. For example, the pass index is stored ** so that we can prevent "welding" of vertex materials in different passes (since ** this may not be desireable...) */ class VertMatClass { public: VertMatClass(void); ~VertMatClass(void); VertMatClass & VertMatClass::operator = (const VertMatClass & that); bool operator != (const VertMatClass & that); bool operator == (const VertMatClass & that); void Set_Name(const char * name); void Set_Mapper_Args(const char * args, int stage); W3dVertexMaterialStruct Material; char * MapperArgs[W3dMaterialClass::MAX_STAGES]; // note: these strings are new'ed, not malloc'ed (unlike Name) int PassIndex; // using this to prevent joining of vertmats in different passes. int Crc; // crc, used for quick rejection when checking for matches. char * Name; // material name associated with the first occurence of this vmat. }; /* ** ShadeClass ** Again, simply here to make the shader extendable for any purposes needed by this ** pre-processing code... */ class ShadeClass { public: ShadeClass & operator = (const ShadeClass & that) { Shader = that.Shader; Crc = that.Crc; return *this;} bool operator != (const ShadeClass & that) { return !(*this == that); } bool operator == (const ShadeClass & that) { assert(0); return false; } W3dShaderStruct Shader; int Crc; }; /* ** TexClass ** Simply here to allow extra info to be stored with each texture, as needed by this ** pre-processing code... */ class TexClass { public: TexClass & operator = (const TexClass & that) { Map = that.Map; Crc = that.Crc; return *this; } bool operator != (const TexClass & that) { return !(*this == that); } bool operator == (const TexClass & that) { assert(0); return false; } W3dMapClass Map; int Crc; }; int PassCount; int SortLevel; DynamicVectorClass < MaterialRemapClass > MaterialRemaps; DynamicVectorClass < ShadeClass > Shaders; DynamicVectorClass < VertMatClass > VertexMaterials; DynamicVectorClass < TexClass > Textures; }; #endif