nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/WW3D/max2w3d/gamemtl.h

374 lines
15 KiB
C++
Raw Permalink Blame History

/*
** 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 <http://www.gnu.org/licenses/>.
*/
/* $Header: /Commando/Code/Tools/max2w3d/gamemtl.h 38 8/22/01 7:56a Greg_h $ */
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando / G 3D engine *
* *
* File Name : GAMEMTL.H *
* *
* Programmer : Greg Hjelstrom *
* *
* Start Date : 06/26/97 *
* *
* Last Update : June 26, 1997 [GH] *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#ifndef GAMEMTL_H
#define GAMEMTL_H
#include <Max.h>
#include "w3dmtl.h"
#include "w3d_file.h"
// GameMtl flags values
#define GAMEMTL_CONVERTED_TO_NOLOD (1<<0) // this material has been converted to use the NO_LOD flag on textures
#define GAMEMTL_DISPLACEMENT_ROLLUP_OPEN (1<<25)
#define GAMEMTL_SURFACE_ROLLUP_OPEN (1<<26)
#define GAMEMTL_PASSCOUNT_ROLLUP_OPEN (1<<27)
#define GAMEMTL_PASS0_ROLLUP_OPEN (1<<28)
#define GAMEMTL_PASS1_ROLLUP_OPEN (1<<29)
#define GAMEMTL_PASS2_ROLLUP_OPEN (1<<30)
#define GAMEMTL_PASS3_ROLLUP_OPEN (1<<31)
#define GAMEMTL_ROLLUP_FLAGS ( GAMEMTL_SURFACE_ROLLUP_OPEN | \
GAMEMTL_DISPLACEMENT_ROLLUP_OPEN | \
GAMEMTL_PASSCOUNT_ROLLUP_OPEN | \
GAMEMTL_PASS0_ROLLUP_OPEN | \
GAMEMTL_PASS1_ROLLUP_OPEN | \
GAMEMTL_PASS2_ROLLUP_OPEN | \
GAMEMTL_PASS3_ROLLUP_OPEN )
#define GAMEMTL_ID_PARTA 0x29397211
#define GAMEMTL_ID_PARTB 0x28c016c2
///////////////////////////////////////////////////////////////////////////
//
// Mapping types
//
///////////////////////////////////////////////////////////////////////////
#define GAMEMTL_MAPPING_UV 0
#define GAMEMTL_MAPPING_ENV 1
#define GAMEMTL_MAPPING_CHEAP_ENV 2
#define GAMEMTL_MAPPING_SCREEN 3
#define GAMEMTL_MAPPING_LINEAR_OFFSET 4
#define GAMEMTL_MAPPING_SILHOUETTE 5
#define GAMEMTL_MAPPING_SCALE 6
#define GAMEMTL_MAPPING_GRID 7
#define GAMEMTL_MAPPING_ROTATE 8
#define GAMEMTL_MAPPING_SINE_LINEAR_OFFSET 9
#define GAMEMTL_MAPPING_STEP_LINEAR_OFFSET 10
#define GAMEMTL_MAPPING_ZIGZAG_LINEAR_OFFSET 11
#define GAMEMTL_MAPPING_WS_CLASSIC_ENV 12
#define GAMEMTL_MAPPING_WS_ENVIRONMENT 13
#define GAMEMTL_MAPPING_GRID_CLASSIC_ENV 14
#define GAMEMTL_MAPPING_GRID_ENVIRONMENT 15
#define GAMEMTL_MAPPING_RANDOM 16
#define GAMEMTL_MAPPING_EDGE 17
#define GAMEMTL_MAPPING_BUMPENV 18
///////////////////////////////////////////////////////////////////////////
//
// PSX Translucency Type
//
///////////////////////////////////////////////////////////////////////////
#define GAMEMTL_PSX_TRANS_NONE 0
#define GAMEMTL_PSX_TRANS_100 1
#define GAMEMTL_PSX_TRANS_50 2
#define GAMEMTL_PSX_TRANS_25 3
#define GAMEMTL_PSX_TRANS_MINUS_100 4
class GameMtlDlg;
class GameMapsClass;
extern Class_ID GameMaterialClassID;
extern ClassDesc * Get_Game_Material_Desc();
// MLL
// For Playstation 2 materials.
extern Class_ID PS2GameMaterialClassID;
extern ClassDesc * Get_PS2_Game_Material_Desc();
extern Class_ID PCToPS2MaterialClassID;
extern ClassDesc * Get_PS2_Material_Conversion();
///////////////////////////////////////////////////////////////////////////
//
// Game Material
// This is a plugin-material which attempts to emulate the material
// used in our in-game 3D engine. It has varying degrees of success
// at making Max render things like our game but it gives us the
// ability to have control over all parameters in our material.
//
///////////////////////////////////////////////////////////////////////////
class GameMtl: public Mtl
{
public:
enum ShaderTypeEnum
{
STE_PC_SHADER,
STE_PS2_SHADER,
};
GameMtl(BOOL loading = FALSE);
~GameMtl(void);
Class_ID ClassID();
SClass_ID SuperClassID();
// From Animatable
void GetClassName(TSTR& s);
void DeleteThis() { delete this; }
int NumSubs();
Animatable * SubAnim(int i);
TSTR SubAnimName(int i);
// References
int NumRefs() { return REF_COUNT; }
RefTargetHandle Clone(RemapDir &remap = NoRemap());
RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message);
void SetReference(int i, RefTargetHandle rtarg);
RefTargetHandle GetReference(int i);
// From MtlBase and Mtl
void SetAmbient(Color c, TimeValue t) { Set_Ambient(0,t,c); }
void SetDiffuse(Color c, TimeValue t) { Set_Diffuse(0,t,c); }
void SetSpecular(Color c, TimeValue t) { Set_Specular(0,t,c); }
void SetShininess(float v, TimeValue t) { Set_Shininess(0,t,v); }
Color GetAmbient(int mtlNum=0, BOOL backFace=FALSE) { return Get_Ambient(0,0); }
Color GetDiffuse(int mtlNum=0, BOOL backFace=FALSE) { return Get_Diffuse(0,0); }
Color GetSpecular(int mtlNum=0, BOOL backFace=FALSE) { return Get_Specular(0,0); }
float GetXParency(int mtlNum=0, BOOL backFace=FALSE) { return 0.0f; }
float GetShininess(int mtlNum=0, BOOL backFace=FALSE) { return Get_Shininess(0,0); }
float GetShinStr(int mtlNum=0, BOOL backFace=FALSE) { return 1.0f; }
void Reset(void);
void Update(TimeValue t, Interval& validr);
Interval Validity(TimeValue t);
int NumSubTexmaps(void);
void SetSubTexmap(int i, Texmap * m);
Texmap * GetSubTexmap(int i);
float EvalDisplacement(ShadeContext& sc);
Interval DisplacementValidity(TimeValue t);
// Rendering
void Shade(ShadeContext& sc);
ULONG Requirements(int subMtlNum);
//ULONG LocalRequirements(int subMtlNum);
// Material editor
void SetParamDlg(GameMtlDlg * pd) { MaterialDialog = pd; }
ParamDlg* CreateParamDlg(HWND hwMtlEdit, IMtlParams *imp);
// IO stuff
IOResult Save(ISave* iSave);
IOResult Load(ILoad* iLoad);
// Accessors...
void Set_Flag(ULONG f, ULONG val) { if (val) Flags|=f; else Flags &= ~f; }
int Get_Flag(ULONG f) { return ((Flags&f) ? 1 : 0); }
void Set_Surface_Type(unsigned int type) { SurfaceType = type; }
unsigned int Get_Surface_Type(void) const { return SurfaceType; }
void Set_Sort_Level(int level) { SortLevel = level; }
int Get_Sort_Level(void) const { return SortLevel; }
void Set_Pass_Count(int passcount);
int Get_Pass_Count(void);
IParamBlock * Get_Parameter_Block(int pass);
int Get_Current_Page(int pass) { return CurPage[pass]; }
Color Get_Ambient(int pass,TimeValue t);
Color Get_Diffuse(int pass,TimeValue t);
Color Get_Specular(int pass,TimeValue t);
Color Get_Emissive(int pass,TimeValue t);
float Get_Shininess(int pass,TimeValue t);
float Get_Opacity(int pass,TimeValue t);
float Get_Translucency(int pass,TimeValue t);
int Get_Copy_Specular_To_Diffuse(int pass);
int Get_Mapping_Type(int pass, int stage=0);
int Get_PSX_Translucency(int pass);
int Get_PSX_Lighting(int pass);
int Get_Depth_Compare(int pass);
int Get_Depth_Mask(int pass);
int Get_Alpha_Test(int pass);
int Get_Dest_Blend(int pass);
int Get_Pri_Gradient(int pass);
int Get_Sec_Gradient(int pass);
int Get_Src_Blend(int pass);
int Get_Detail_Color_Func(int pass);
int Get_Detail_Alpha_Func(int pass);
int Get_PS2_Shader_Param_A(int pass);
int Get_PS2_Shader_Param_B(int pass);
int Get_PS2_Shader_Param_C(int pass);
int Get_PS2_Shader_Param_D(int pass);
int Get_Texture_Enable(int pass,int stage);
int Get_Texture_Publish(int pass,int stage);
int Get_Texture_Resize(int pass,int stage); // NOTE: obsolete, replaced by Get_Texture_No_LOD
int Get_Texture_No_Mipmap(int pass,int stage); // NOTE: obsolete, replaced by Get_Texture_No_LOD
int Get_Texture_Clamp_U(int pass,int stage);
int Get_Texture_Clamp_V(int pass,int stage);
int Get_Texture_No_LOD(int pass,int stage);
int Get_Texture_Alpha_Bitmap(int pass,int stage);
int Get_Texture_Hint(int pass,int stage);
int Get_Texture_Display(int pass,int stage);
float Get_Texture_Frame_Rate(int pass,int stage);
int Get_Texture_Frame_Count(int pass,int stage);
int Get_Texture_Anim_Type(int pass,int stage);
Texmap * Get_Texture(int pass,int stage);
Texmap * Get_Displacement_Map(void) const { return DisplacementMap; }
float Get_Displacement_Amount(void) const { return DisplacementAmt; }
int Get_Displacement_Map_Index(void) const;
int Get_Map_Channel(int pass,int stage);
void Set_Current_Page(int pass,int page) { CurPage[pass] = page; }
void Set_Ambient(int pass,TimeValue t,Color color);
void Set_Diffuse(int pass,TimeValue t,Color color);
void Set_Specular(int pass,TimeValue t,Color color);
void Set_Emissive(int pass,TimeValue t,Color color);
void Set_Shininess(int pass,TimeValue t,float val);
void Set_Opacity(int pass,TimeValue t,float val);
void Set_Translucency(int pass,TimeValue t,float val);
void Set_Copy_Specular_To_Diffuse(int pass,bool val);
void Set_Mapping_Type(int pass,int stage,int val);
void Set_PSX_Translucency(int pass,int val);
void Set_PSX_Lighting(int pass,bool val);
void Set_Depth_Compare(int pass,int val);
void Set_Depth_Mask(int pass,int val);
void Set_Alpha_Test(int pass,int val);
void Set_Dest_Blend(int pass,int val);
void Set_Pri_Gradient(int pass,int val);
void Set_Sec_Gradient(int pass,int val);
void Set_Src_Blend(int pass,int val);
void Set_Detail_Color_Func(int pass,int val);
void Set_Detail_Alpha_Func(int pass,int val);
void Set_PS2_Shader_Param_A(int pass,int val);
void Set_PS2_Shader_Param_B(int pass,int val);
void Set_PS2_Shader_Param_C(int pass,int val);
void Set_PS2_Shader_Param_D(int pass,int val);
void Set_Texture_Enable(int pass,int stage,bool val);
void Set_Texture_Publish(int pass,int stage,bool val);
void Set_Texture_Resize(int pass,int stage,bool val); // NOTE: obsolete: replaced by Set_Texture_No_LOD
void Set_Texture_No_Mipmap(int pass,int stage,bool val); // NOTE: obsolete: replaced by Set_Texture_No_LOD
void Set_Texture_Clamp_U(int pass,int stage,bool val);
void Set_Texture_Clamp_V(int pass,int stage,bool val);
void Set_Texture_No_LOD(int pass,int stage,bool val);
void Set_Texture_Alpha_Bitmap(int pass,int stage,bool val);
void Set_Texture_Hint(int pass,int stage,int val);
void Set_Texture_Display(int pass,int stage,bool val);
void Set_Texture_Frame_Rate(int pass,int stage,float val);
void Set_Texture_Frame_Count(int pass,int stage,int val);
void Set_Texture_Anim_Type(int pass,int stage,int val);
void Set_Texture(int pass,int stage,Texmap * tex);
void Set_Displacement_Amount(float amount) { DisplacementAmt = amount; Notify_Changed (); }
void Set_Map_Channel(int pass,int stage,int channel);
void Notify_Changed(void);
// This returns the mapping args string buffer for that pass after
// assuring that it is at least of length 'len'.
char * Get_Mapping_Arg_Buffer(int pass, int stage=0, unsigned int len = 0U);
int pass_stage_to_texmap_index(int pass,int stage);
void texmap_index_to_pass_stage(int index,int * set_pass,int * set_stage);
// Set and get the type of shader, PC or PS2.
// MLL
int Get_Shader_Type() {return (ShaderType);}
void Set_Shader_Type(int shadertype) {ShaderType = shadertype;}
// Approximate the PS2 shader on the PC.
int Compute_PC_Shader_From_PS2_Shader(int pass);
int Compute_PS2_Shader_From_PC_Shader(int pass);
// IML: Get/set substitute material.
Mtl* Substitute_Material() {return (SubstituteMaterial);}
void Set_Substitute_Material (Mtl *m) {SubstituteMaterial = m;}
private:
int texture_ref_index(int pass,int stage) { return REF_TEXTURE + pass*W3dMaterialClass::MAX_STAGES + stage; }
int pass_ref_index(int pass) { return REF_PASS_PARAMETERS + pass; }
void update_viewport_display();
// Do the shade functions specific to the Playstation 2.
void ps2_shade(ShadeContext& sc);
unsigned int SurfaceType;
int SortLevel;
Interval Ivalid; // Valid interval
GameMtlDlg * MaterialDialog; // Dialog
ULONG Flags; // Flags
int RollScroll; // Rollup scroll position
int CurPage[W3dMaterialClass::MAX_PASSES]; // which page was last open for each pass
GameMapsClass * Maps; // ref 0 (obsolete...)
IParamBlock * MainParameterBlock;
IParamBlock * PassParameterBlock[W3dMaterialClass::MAX_PASSES];
Texmap * Texture[W3dMaterialClass::MAX_PASSES][W3dMaterialClass::MAX_STAGES];
char * MapperArg[W3dMaterialClass::MAX_PASSES][W3dMaterialClass::MAX_STAGES];
unsigned int MapperArgLen[W3dMaterialClass::MAX_PASSES][W3dMaterialClass::MAX_STAGES];
Texmap * DisplacementMap;
float DisplacementAmt;
// MLL
int ShaderType;
enum
{
REF_MAPS = 0, // obsolete, gamemaps object
REF_MAIN = 1, // main parameter block is ref 1
REF_PASS_PARAMETERS = 2, // pass parameter blocks are refs 2,3,4,5
REF_TEXTURE = 6, // textures are refs 6,7,8,9,10,11,12,13,14 (14 is the displacement map)
REF_COUNT = 15
};
Mtl *SubstituteMaterial; // IML: Temporary material used during game to standard material conversion and vice-versa.
friend class GameMtlDlg;
friend class GameMtlPostLoad;
};
Mtl * CreateGameMtl();
#endif
Reference in New Issue View Git Blame Copy Permalink