Renegade/Code/Tools/max2w3d/gamemtl.h

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

/* $Header: /Commando/Code/Tools/max2w3d/gamemtl.h 46    3/01/02 6:43p Moumine_ballo $ */
/*********************************************************************************************** 
 ***                            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 GMaxMtlDlg;
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
#if defined W3D_GMAXDEV
		void					SetParamDlg(GMaxMtlDlg * pd)								{ MaterialDialog = pd; }
#else
		void					SetParamDlg(GameMtlDlg * pd)								{ MaterialDialog = pd; }
#endif
		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;}
#if defined W3D_MAX4
		//BOOL					SupportsMultiMapsInViewport(){return TRUE;}
		//virtual int			VPDisplaySubMtl(){return -1;}
		//MtlBase				*MtlInSlotOne;
#endif
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		
#if defined W3D_GMAXDEV
		GMaxMtlDlg *		MaterialDialog;	// Dialog
#else
		GameMtlDlg *		MaterialDialog;	// Dialog
#endif
		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;
};
#if defined W3D_GMAXDEV
GameMtl*	CreateNewGameMtl();
const ActionTableId kGameMtlActions = 0x7ea7bca5;
const ActionContextId kGameMtlContext = 0x7ea7bca5; 
#define NumElements(array) (sizeof(array) / sizeof(array[0]))
class GameMtlActionCB : public ActionCallback {
	public:
		GameMtl*		game_mtl;
		GameMtlActionCB(GameMtl *var_mtl) { game_mtl = var_mtl; }
		~GameMtlActionCB(){delete game_mtl;}
		BOOL GameMtlActionCB::IsEnabled(int cmdID) { return TRUE;}
		BOOL	ExecuteAction(int id); 
};
#endif

Mtl * CreateGameMtl();

#endif