Renegade/Code/ww3d2/vertmaterial.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/>.
*/

/***********************************************************************************************
 ***              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:: /VSS_Sync/ww3d2/vertmaterial.h                              $*
 *                                                                                             *
 *                       Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                     $Modtime:: 8/29/01 7:29p                                               $*
 *                                                                                             *
 *                    $Revision:: 26                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#if defined(_MSC_VER)
#pragma once
#endif

#ifndef VERTMATERIAL_H
#define VERTMATERIAL_H

#include "always.h"

#include "refcount.h"
#include "vector3.h"
#include "w3d_file.h"
#include "meshbuild.h"
#include "w3derr.h"
#include "mapper.h"
#include "wwstring.h"

#include <string.h>

class ChunkLoadClass;
class ChunkSaveClass;
struct _D3DMATERIAL8;

/**
** VertexMaterialClass
** This is simply the typical W3D thin-wrapper around the surrender vertex material.
** The vertex material defines things like the lighting properties of a vertex.
*/
class VertexMaterialClass : public RefCountClass
{
	friend DX8Wrapper;

public:
	/*
	** Similar to the TextureClass, these enumerations are set up to be exactly the same as
	** the surrender material enumerations.  Nearly all functions in this class are inline
	** so that it will go away since the only purpose of Material Class is to protect our
	** application code from the ever-changing surrender...
	*/
	enum MappingType {
		MAPPING_NONE = -1,											// no mapping needed
		MAPPING_UV = W3DMAPPING_UV,								// default, use the u-v values in the model
		MAPPING_ENVIRONMENT = W3DMAPPING_ENVIRONMENT,		// use the environment mapper
	};

	enum FlagsType {
		DEPTH_CUE= 0,					// enable depth cueing (default = false)
		DEPTH_CUE_TO_ALPHA,
		COPY_SPECULAR_TO_DIFFUSE,
	};

	enum ColorSourceType {
		MATERIAL = 0,				// D3DMCS_MATERIAL - the color source should be taken from the material setting
		COLOR1,						// D3DMCS_COLOR1 - the color should be taken from per-vertex color array 1 (aka D3DFVF_DIFFUSE)
		COLOR2,						// D3DMCS_COLOR2 - the color should be taken from per-vertex color array 2 (aka D3DFVF_SPECULAR)
	};

	enum PresetType
	{
		PRELIT_DIFFUSE=0,
		PRELIT_NODIFFUSE,
		PRESET_COUNT
	};
		
	
	VertexMaterialClass(void);
	VertexMaterialClass(const VertexMaterialClass & src);
	~VertexMaterialClass(void);

	VertexMaterialClass &	operator = (const VertexMaterialClass &src);
	VertexMaterialClass *	Clone(void) { VertexMaterialClass * mat = NEW_REF (VertexMaterialClass,()); *mat = *this; return mat;}

	/*
	** Name Access
	*/
	void					Set_Name(const char * name)
	{	
		Name = name;
	}

	const char *		Get_Name(void) const
	{
		return Name;
	}

	/*
	** Control over the material flags
	*/
	void					Set_Flag(FlagsType flag,bool onoff)
	{
		CRCDirty=true;
		if (onoff)
			Flags|=(1<<flag);
		else
			Flags&=~(1<<flag);
	}
	int					Get_Flag(FlagsType flag)
	{ return (Flags>>flag) & 0x1; }

	/*
	** Basic material properties
	*/
	float			Get_Shininess(void) const;
	void			Set_Shininess(float shin);

	float			Get_Opacity(void) const;
	void			Set_Opacity(float o);

	void			Get_Ambient(Vector3 * set_color) const;
	void			Set_Ambient(const Vector3 & color);
	void			Set_Ambient(float r,float g,float b);
	
	void			Get_Diffuse(Vector3 * set_color) const;
	void			Set_Diffuse(const Vector3 & color);
	void			Set_Diffuse(float r,float g,float b);

	void			Get_Specular(Vector3 * set_color) const;
	void			Set_Specular(const Vector3 & color);
	void			Set_Specular(float r,float g,float b);
	
	void			Get_Emissive(Vector3 * set_color) const;
	void			Set_Emissive(const Vector3 & color);
	void			Set_Emissive(float r,float g,float b);

	void			Set_Lighting(bool lighting) { CRCDirty=true; UseLighting=lighting; };
	bool			Get_Lighting() const { return UseLighting; };

	/*
	** Color source control.  Note that if you set one of the sources to be one of
	** the arrays, then the setting in the material is ignored.  (i.e. if you 
	** set the diffuse source to array0, then the diffuse color set into the 
	** vertex material is ignored.
	*/
	void					Set_Ambient_Color_Source(ColorSourceType src);
	ColorSourceType	Get_Ambient_Color_Source(void);

	void					Set_Emissive_Color_Source(ColorSourceType src);
	ColorSourceType	Get_Emissive_Color_Source(void);

	void					Set_Diffuse_Color_Source(ColorSourceType src);
	ColorSourceType	Get_Diffuse_Color_Source(void);

	/*
	** UV source control.  The DX8 FVF can support up to 8 uv-arrays.  The vertex
	** material can/must be configured to index to the uv-arrays that you want to
	** use for the two texture stages.
	*/
	void					Set_UV_Source(int stage,int array_index);
	int					Get_UV_Source(int stage);

	/*
	** Mapper control.  
	*/
	inline void							Set_Mapper(TextureMapperClass *mapper,int stage=0);
	inline TextureMapperClass *	Get_Mapper(int stage=0);
	inline TextureMapperClass *	Peek_Mapper(int stage=0);
	inline void							Reset_Mappers(void);

	/*
	** Loading and saving to W3D files
	*/
	WW3DErrorType		Load_W3D(ChunkLoadClass & cload);
	WW3DErrorType		Save_W3D(ChunkSaveClass & csave);

	void					Init_From_Material3(const W3dMaterial3Struct & mat3);

	/*
	** CRC, used by the loading code to build a list of the unique materials
	*/
	inline unsigned long Get_CRC(void) const
	{
		if (CRCDirty) {
			CRC=Compute_CRC();
			CRCDirty=false;
		}
			
		return CRC;
	}

	/*
	** Test whether this material is using any mappers which require vertex normals
	*/
	bool					Do_Mappers_Need_Normals(void) const;

	/*
	** Test whether this material is using any mappers which are time-variant
	*/
	bool					Are_Mappers_Time_Variant(void) const;

	// Infrastructure to support presets
	static void Init();
	static void Shutdown();
	// TODO: Make Get_Preset const
	static VertexMaterialClass *Get_Preset(PresetType type);

	void Make_Unique();

protected:

	// We're using the pointer instead of the actual structure
	// so we don't have to include the d3d header - HY
	_D3DMATERIAL8 *		Material;
	unsigned int			Flags;
	unsigned int			AmbientColorSource;
	unsigned int			EmissiveColorSource;
	unsigned int			DiffuseColorSource;
	StringClass				Name;
	TextureMapperClass *	Mapper[MeshBuilderClass::MAX_STAGES];
	unsigned int			UVSource[MeshBuilderClass::MAX_STAGES];
	bool						UseLighting;
	unsigned int			UniqueID;
	mutable unsigned long CRC;
	mutable bool			CRCDirty;

private:
	/*
	** Apply the render states to D3D
	*/
	void					Apply(void) const;
	/*
	** Apply the render states corresponding to a NULL vetex material to D3D
	*/
	static void			Apply_Null(void);
	unsigned long		VertexMaterialClass::Compute_CRC(void) const;

	static VertexMaterialClass *Presets[PRESET_COUNT];
};

inline void VertexMaterialClass::Set_Mapper(TextureMapperClass *mapper, int stage)
{
	CRCDirty=true;
	REF_PTR_SET(Mapper[stage],mapper);	
}

inline TextureMapperClass * VertexMaterialClass::Get_Mapper(int stage)
{
	if (Mapper[stage]) {
		Mapper[stage]->Add_Ref();
	}
	return Mapper[stage];
}

inline TextureMapperClass * VertexMaterialClass::Peek_Mapper(int stage)
{
	return Mapper[stage];
}

inline void VertexMaterialClass::Reset_Mappers(void)
{
	for (int stage = 0; stage < MeshBuilderClass::MAX_STAGES; stage++) {
		if (Mapper[stage]) {
			Mapper[stage]->Reset();
		}
	}
}

inline bool VertexMaterialClass::Do_Mappers_Need_Normals(void) const
{
	for (int stage = 0; stage < MeshBuilderClass::MAX_STAGES; stage++) {
		if (Mapper[stage] && (Mapper[stage]->Needs_Normals())) return true;
	}
	return false;
}

inline bool VertexMaterialClass::Are_Mappers_Time_Variant(void) const
{
	for (int stage = 0; stage < MeshBuilderClass::MAX_STAGES; stage++) {
		if (Mapper[stage] && (Mapper[stage]->Is_Time_Variant())) return true;
	}
	return false;
}

#endif //VERTMATERIAL_H