/*
** 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 : 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);
void Init(GameMtl * gamemtl);
/*
** 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