GeneralsZeroHour/GeneralsMD/Code/Libraries/Source/WWVegas/WW3D2/decalsys.cpp

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

/***********************************************************************************************
 ***              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:: /Commando/Code/ww3d2/decalsys.cpp                           $*
 *                                                                                             *
 *              Original Author:: Greg Hjelstrom                                               *
 *                                                                                             *
 *                      $Author:: Kenny Mitchell                                               * 
 *                                                                                             * 
 *                     $Modtime:: 06/26/02 4:04p                                             $*
 *                                                                                             *
 *                    $Revision:: 8                                                           $*
 *                                                                                             *
 * 06/26/02 KM Matrix name change to avoid MAX conflicts                                       *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 *   DecalSystemClass::DecalSystemClass -- Constructor                                         *
 *   DecalSystemClass::~DecalSystemClass -- Destructor                                         *
 *   DecalSystemClass::Lock_Decal_Generator -- returns a DecalGenerator                        *
 *   DecalSystemClass::Unlock_Decal_Generator -- Destroys the decal generator                  *
 *   DecalSystemClass::Generate_Unique_Global_Decal_Id -- Generates a unique id for a decal    *
 *   DecalGeneratorClass::DecalGeneratorClass -- Constructor                                   *
 *   DecalGeneratorClass::~DecalGeneratorClass -- Destructor                                   *
 *   DecalGeneratorClass::Add_Mesh -- Meshes that generate a decal should add themselves       *
 *   DecalGeneratorClass::Get_Mesh_List -- returns the list of meshes                          *
 *   DecalGeneratorClass::Set_Mesh_Transform -- sets the current mesh coordinate system        *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

#include "decalsys.h"
#include "rendobj.h"
#include "mesh.h"
#include "decalmsh.h"
#include "matrixmapper.h"
#include "texture.h"


uint32 DecalSystemClass::DecalIDGenerator = 0;


/*
** DecalSystemClass Implementation
*/

/***********************************************************************************************
 * DecalSystemClass::DecalSystemClass -- Constructor                                           *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
DecalSystemClass::DecalSystemClass(void)
{
}


/***********************************************************************************************
 * DecalSystemClass::~DecalSystemClass -- Destructor                                           *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *=============================================================================================*/
DecalSystemClass::~DecalSystemClass(void)
{
}


/***********************************************************************************************
 * DecalSystemClass::Lock_Decal_Generator -- returns a DecalGenerator                          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
DecalGeneratorClass * DecalSystemClass::Lock_Decal_Generator(void)
{
	DecalGeneratorClass * gen = W3DNEW DecalGeneratorClass(Generate_Decal_Id(), this);
	return gen;
}


/***********************************************************************************************
 * DecalSystemClass::Unlock_Decal_Generator -- Destroys the decal generator                    *
 *                                                                                             *
 * Derived classes may take a record of the results of the generator here.  Then they can      *
 * put a cap on the total number of decals in the system or whatever...                        *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
void DecalSystemClass::Unlock_Decal_Generator(DecalGeneratorClass * generator)
{
	delete generator;
}


/***********************************************************************************************
 * DecalSystemClass::Generate_Unique_Global_Decal_Id -- Generates a unique id for a decal      *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 * Hopefully you won't use more than 4 billion decals at one time...                           *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
uint32 DecalSystemClass::Generate_Unique_Global_Decal_Id(void)			
{ 
	return DecalIDGenerator++; 
}


/*
** DecalGeneratorClass Implementation
*/

/***********************************************************************************************
 * DecalGeneratorClass::DecalGeneratorClass -- Constructor                                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
DecalGeneratorClass::DecalGeneratorClass(uint32 id,DecalSystemClass * system) :
	DecalID(id),
	System(system),
	BackfaceVal(0.0f),
	ApplyToTranslucentMeshes(false),
	Material(NULL)
{
	Material = NEW_REF(MaterialPassClass,());

	WWASSERT(System != NULL);
	WWASSERT(Material != NULL);
}


/***********************************************************************************************
 * DecalGeneratorClass::~DecalGeneratorClass -- Destructor                                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
DecalGeneratorClass::~DecalGeneratorClass(void)
{
	REF_PTR_RELEASE(Material);
}


/***********************************************************************************************
 * DecalGeneratorClass::Add_Mesh -- Meshes that generate a decal should add themselves         *
 *                                                                                             *
 * This adds a mesh to the internal list.  All meshes that actually add a decal should add     *
 * themselves to this list so that the DecalSystem can keep track of them.                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
void DecalGeneratorClass::Add_Mesh(RenderObjClass * mesh)
{
	WWASSERT(mesh->Class_ID() == RenderObjClass::CLASSID_MESH);
	MeshList.Add(mesh);
}


/***********************************************************************************************
 * DecalGeneratorClass::Get_Mesh_List -- returns the list of meshes                            *
 *                                                                                             *
 * This is the list of meshes which generated decals for this "logical decal"                  *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
NonRefRenderObjListClass & DecalGeneratorClass::Get_Mesh_List(void)
{
	return MeshList;
}


/***********************************************************************************************
 * DecalGeneratorClass::Set_Mesh_Transform -- sets the current mesh coordinate system          *
 *                                                                                             *
 * The coordinate system of the mesh is needed in order to compute texture coordinates for     *
 * the decal polygons.                                                                         *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/26/00    gth : Created.                                                                 *
 *=============================================================================================*/
void DecalGeneratorClass::Set_Mesh_Transform(const Matrix3D & mesh_transform)
{
	/*
	** Mobj-texture = Projection * Mwrld-texture * Mobj-wrld
	*/
	Matrix3D world_to_texture;
	Matrix3D tmp;
	Matrix4x4  mesh_to_texture;

	Transform.Get_Orthogonal_Inverse(world_to_texture);
	Matrix3D::Multiply(world_to_texture,mesh_transform,&tmp);
	Matrix4x4::Multiply(Projection,tmp,&mesh_to_texture);

	/*
	** Plug the matrix and texture size into the mapper
	*/
	if (WW3D::Is_Texturing_Enabled()) {
		float texsize = 64.0f;
		TextureClass * tex = Material->Peek_Texture();
		WWASSERT(tex != NULL);
		if (tex) {
//			SurfaceClass::SurfaceDescription surface_desc;
//			tex->Get_Level_Description(surface_desc);
//			texsize = surface_desc.Width;
			texsize = tex->Get_Width();
		}

		Mapper->Set_Texture_Transform(mesh_to_texture,texsize);
	}
}


/*
** MultiFixedPoolDecalSystemClass implementation
*/

MultiFixedPoolDecalSystemClass::MultiFixedPoolDecalSystemClass(uint32 num_pools, const uint32 *pool_sizes) :
	Pools(0),
	PoolCount(num_pools),
	Generator_PoolID(0),
	Generator_SlotID(0)
{
	if (PoolCount) 
	{
		WWASSERT(pool_sizes);
		Pools = W3DNEWARRAY LogicalDecalPoolClass [PoolCount];
	}
	for (uint32 i = 0; i < PoolCount; i++) {
		assert(pool_sizes[i]);
		Pools[i].Initialize(pool_sizes[i]);
	}
}

MultiFixedPoolDecalSystemClass::MultiFixedPoolDecalSystemClass(const MultiFixedPoolDecalSystemClass & that) :
	Pools(0),
	PoolCount(that.PoolCount),
	Generator_PoolID(that.Generator_PoolID),
	Generator_SlotID(that.Generator_SlotID)
{
	uint32 i;

	// Allocate arrays (we dont' copy array contents because those are mesh-specific and will be
	// filled when the state is set anyway)
	if (PoolCount) Pools = W3DNEWARRAY LogicalDecalPoolClass [PoolCount];
	for (i = 0; i < PoolCount; i++) {
		Pools[i].Initialize(that.Pools[i].Size);
	}
}

MultiFixedPoolDecalSystemClass::~MultiFixedPoolDecalSystemClass(void)
{
	if (Pools) {
		delete [] Pools;
		Pools = 0;
	}
}

// This clears the slot in addition to locking the generator, thus preventing any decal id
// collisions (since any decal previously in that slot will have the same id as the new one).
DecalGeneratorClass * MultiFixedPoolDecalSystemClass::Lock_Decal_Generator(void)
{
	Clear_Decal_Slot(Generator_PoolID, Generator_SlotID);
	return DecalSystemClass::Lock_Decal_Generator();
}

// This will register the decal in the system in the appropriate pool and slot (determined by
// the generator's pool and slot ids), removing any decal which may have been there before.
void MultiFixedPoolDecalSystemClass::Unlock_Decal_Generator(DecalGeneratorClass * generator)
{
	find_logical_decal(generator->Get_Decal_ID()).Set(generator);
	DecalSystemClass::Unlock_Decal_Generator(generator);
}

// This notifies the system that a mesh which has decals on it was destroyed - therefore we
// need to remove the mesh from our list to avoid dangling pointers.
void MultiFixedPoolDecalSystemClass::Decal_Mesh_Destroyed(uint32 decal_id,DecalMeshClass * mesh)
{
	// We must remove this mesh from all lists where it is present. The method is: for each
	// decal id present in the decal mesh, find the logical decal and remove the decal mesh from
	// its list.
	assert(mesh);
	MeshClass *parent = mesh->Peek_Parent();
	find_logical_decal(decal_id).MeshList.Remove(parent);
}

// Not part of the DecalSystemClass interface - this function removes any decal currently in
// the given slot in the given pool.
void MultiFixedPoolDecalSystemClass::Clear_Decal_Slot(uint32 pool_id, uint32 slot_id)
{
	find_logical_decal(pool_id, slot_id).Clear(encode_decal_id(pool_id, slot_id));
}

// This one removes all decals in a given pool.
void MultiFixedPoolDecalSystemClass::Clear_Pool(uint32 pool_id)
{
	LogicalDecalPoolClass & pool = Pools[pool_id];
	uint32 pool_size = pool.Size;
	for (uint32 slot_id = 0; slot_id < pool_size; slot_id++) {
		pool.Array[slot_id].Clear(encode_decal_id(pool_id, slot_id));
	}
}

// And this one removes all decals in the system.
void MultiFixedPoolDecalSystemClass::Clear_All_Decals(void)
{
	for (uint32 pool_id = 0; pool_id < PoolCount; pool_id++) {
		LogicalDecalPoolClass & pool = Pools[pool_id];
		uint32 pool_size = pool.Size;
		for (uint32 slot_id = 0; slot_id < pool_size; slot_id++) {
			pool.Array[slot_id].Clear(encode_decal_id(pool_id, slot_id));
		}
	}
}

// Get a reference to the logical decal at the given pool and slot id (performs range checking)
MultiFixedPoolDecalSystemClass::LogicalDecalClass & MultiFixedPoolDecalSystemClass::find_logical_decal(uint32 pool_id, uint32 slot_id)
{
	assert(pool_id < PoolCount);
	pool_id = MIN(pool_id, PoolCount);
	LogicalDecalPoolClass & pool = Pools[pool_id];
	assert(slot_id < pool.Size);
	slot_id = MIN(slot_id, pool.Size);
	return pool.Array[slot_id];
}

// Get a reference to the logical decal with the given decal id
MultiFixedPoolDecalSystemClass::LogicalDecalClass & MultiFixedPoolDecalSystemClass::find_logical_decal(uint32 decal_id)
{
	uint32 pool_id, slot_id;
	decode_decal_id(decal_id, pool_id, slot_id);
	return find_logical_decal(pool_id, slot_id);
}

	
/*
** MultiFixedPoolDecalSystemClass::LogicalDecalClass implementation
*/

MultiFixedPoolDecalSystemClass::LogicalDecalClass::LogicalDecalClass(void)
{
}

MultiFixedPoolDecalSystemClass::LogicalDecalClass::~LogicalDecalClass(void)
{
	// We don't need to do anything here since the mesh list will get removed automatically and
	// the decals themselves don't neccessarily need to be removed because the logical decal is.
	// (we don't hold references to the meshes in the mesh list)
}

// Sets the logical decal to the one specified by the given generator (clearing any existing
// decal information)
void MultiFixedPoolDecalSystemClass::LogicalDecalClass::Set(DecalGeneratorClass * generator)
{
	Clear(generator->Get_Decal_ID());

	/*
	** Copy the generators' mesh list into our mesh list
	*/
	NonRefRenderObjListIterator gen_mesh_it(&(generator->Get_Mesh_List()));
	for (gen_mesh_it.First(); !gen_mesh_it.Is_Done(); gen_mesh_it.Next()) {
		MeshList.Add(gen_mesh_it.Get_Obj());
	}
}

// Just clears any existing logical decal information, leaving the decal empty.
void MultiFixedPoolDecalSystemClass::LogicalDecalClass::Clear(uint32 decal_id)
{
	// Remove the decal with this ID from all meshes where it appears
	NonRefRenderObjListIterator it(&MeshList);
	for (it.First(); !it.Is_Done(); it.Next()) {
		it.Get_Obj()->Delete_Decal(decal_id);
	}

	// Delete list
	while (!MeshList.Is_Empty()) {
		MeshList.Remove_Head();
	}
}


/*
** MultiFixedPoolDecalSystemClass::LogicalDecalPoolClass implementation
*/

MultiFixedPoolDecalSystemClass::LogicalDecalPoolClass::LogicalDecalPoolClass(void) :
	Array(0),
	Size(0)
{
}

MultiFixedPoolDecalSystemClass::LogicalDecalPoolClass::~LogicalDecalPoolClass(void)
{
	if (Array) {
		delete [] Array;
		Array = 0;
	}
}

void MultiFixedPoolDecalSystemClass::LogicalDecalPoolClass::Initialize(uint32 size)
{
	if (Array) {
		delete [] Array;
		Array = 0;
	}

	Size = size;
	assert(Size);
	Array = W3DNEWARRAY LogicalDecalClass[Size];
}