GeneralsZeroHour/GeneralsMD/Code/Libraries/Source/WWVegas/wwshade/shdmesh.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 : WWShade                                                      *
 *                                                                                             *
 *                     $Archive:: wwshade/shdmesh.cpp														$*
 *                                                                                             *
 *                   Org Author:: Jani P                                               *
 *                                                                                             *
 *                       Author : Kenny Mitchell                                               * 
 *                                                                                             * 
 *                     $Modtime:: 07/12/02 10:31a                                              $*
 *                                                                                             *
 *                    $Revision:: 1                                                           $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 *---------------------------------------------------------------------------------------------*/

#include "shdmesh.h"
#include "shdsubmesh.h"
#include "shdrenderer.h"
#include "rinfo.h"
#include "camera.h"
#include "dx8wrapper.h"
#include "wwdebug.h"
#include "wwprofile.h"
#include "mesh.h"
#include "meshmdl.h"

ShdMeshClass::ShdMeshClass() 
: 	Name("UnNamed"),
	LightEnvironment(NULL),
	Applying_Shadow_Map(false)
{
}

ShdMeshClass::ShdMeshClass(const ShdMeshClass & src) 
:	RenderObjClass(src),	
	Name(src.Name),
	LightEnvironment(NULL),
	Applying_Shadow_Map(false)
{
	Free();
	SubMeshes.Resize(src.SubMeshes.Length());
	for (int i=0;i<SubMeshes.Length();++i) 
	{
		SubMeshes[i].Mesh=NULL;
		SubMeshes[i].Renderer=NULL;
		REF_PTR_SET(SubMeshes[i].Mesh,src.SubMeshes[i].Mesh);
	}
}

ShdMeshClass::~ShdMeshClass()
{
	Free();
	// TODO TODO TODO!!!!!
}

RenderObjClass * ShdMeshClass::Clone() const
{
	return new ShdMeshClass(*this);
}

const char * ShdMeshClass::Get_Name() const
{
	return Name;
}

void ShdMeshClass::Set_Name(const char * name)
{
	Name = name;
}

/***********************************************************************************************
 * ShdMeshClass::Free -- Releases all memory/assets in use by this mesh                           *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/6/98     GTH : Created.                                                                 *
 *=============================================================================================*/
void ShdMeshClass::Free()
{
	for (int i=0;i<SubMeshes.Length();++i)
	{
		REF_PTR_RELEASE(SubMeshes[i].Mesh);
		if (SubMeshes[i].Renderer) 
		{
			delete SubMeshes[i].Renderer;
			SubMeshes[i].Renderer=NULL;
		}
	}
}
 
int ShdMeshClass::Get_Num_Polys() const
{
	int count = 0;
	for (int i=0; i<SubMeshes.Length(); i++) 
	{
		count+= SubMeshes[i].Mesh->Get_Polygon_Count();
	}
	return count;
}

int ShdMeshClass::Get_Num_Vertices(void) const
{
	int count = 0;
	for (int i=0; i<SubMeshes.Length(); i++) 
	{
		count+= SubMeshes[i].Mesh->Get_Vertex_Count();
	}
	return count;
}


void ShdMeshClass::Render(RenderInfoClass& rinfo)
{
	WWPROFILE("ShdMeshClass::Render");
	if (Is_Not_Hidden_At_All() == false) 
	{
		return;
	}

//	DX8_RECORD_MESH_RENDER();

	// TODO: Static sort lists
	Set_Lighting_Environment(rinfo.light_environment);
	const FrustumClass & frustum=rinfo.Camera.Get_Frustum();

	// if rendering shadow remember camera info
	if ((rinfo.Current_Override_Flags()&RenderInfoClass::RINFO_OVERRIDE_SHADOW_RENDERING))
	{
		// is generating shadow map
		Set_Is_Self_Shadowed();

		// set texture projector
		Texture_Projector=rinfo.Texture_Projector;

		Unset_Is_Applying_Shadow_Map();
	}
	else if (Is_Self_Shadowed())
	{
		// is applying shadow map
		Set_Is_Applying_Shadow_Map();
		Unset_Is_Self_Shadowed();
	}
	else
	{
		Unset_Is_Applying_Shadow_Map();
	}


	// TODO: What to do with SKINS?
	if (1)//CollisionMath::Overlap_Test(frustum,Get_Bounding_Box())!=CollisionMath::OUTSIDE ) 
	{
//		bool rendered_something = false;

		// TODO: Override flags, decals and material passes (probably in the submesh rendering)
		for (int i=0;i<SubMeshes.Length();++i) 
		{
			if (!SubMeshes[i].Renderer) 
			{
				SubMeshes[i].Renderer=ShdRendererClass::Peek_Instance()->Register_Mesh(this,SubMeshes[i].Mesh);
			}

			SubMeshes[i].Renderer->Render(rinfo);
		}

		// TODO: RendererDebugger
	}


}

//void ShdMeshClass::Render_Material_Pass(MaterialPassClass * pass,IndexBufferClass * ib)
//{
//
//}

void ShdMeshClass::Special_Render(SpecialRenderInfoClass & rinfo)
{
}

/***********************************************************************************************
 * ShdMeshClass::Cast_Ray -- compute a ray intersection with this mesh                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   6/17/98    GTH : Created.                                                                 *
 *=============================================================================================*/
bool ShdMeshClass::Cast_Ray(RayCollisionTestClass & raytest)
{
	if ((Get_Collision_Type() & raytest.CollisionType) == 0) return false;	
	if ((Is_Translucent()!=0) && (!raytest.CheckTranslucent)) return false;
	if (Is_Animation_Hidden()) return false;
	if (raytest.Result->StartBad) return false;

	Matrix3D world_to_obj;
	Matrix3D world=Get_Transform();

	// if aligned or oriented rotate the mesh so that it's aligned to the ray
/*	if (Model->Get_Flag(MeshModelClass::ALIGNED)) {
			Vector3 mesh_position;
			world.Get_Translation(&mesh_position);
			world.Obj_Look_At(mesh_position,mesh_position - raytest.Ray.Get_Dir(),0.0f);
	} else if (Model->Get_Flag(MeshModelClass::ORIENTED)) {		
			Vector3 mesh_position;
			world.Get_Translation(&mesh_position);
			world.Obj_Look_At(mesh_position,raytest.Ray.Get_P0(),0.0f);
	}
*/
	world.Get_Orthogonal_Inverse(world_to_obj);
	RayCollisionTestClass objray(raytest,world_to_obj);

	for (int i=0;i<SubMeshes.Length();++i) {
		if (SubMeshes[i].Mesh->Cast_Ray(objray)) {
			// transform result back into original coordinate system
			raytest.CollidedRenderObj = this;
			Matrix3D::Rotate_Vector(world,raytest.Result->Normal, &(raytest.Result->Normal));
			if (raytest.Result->ComputeContactPoint) {
				Matrix3D::Transform_Vector(world,raytest.Result->ContactPoint, &(raytest.Result->ContactPoint));
			}
			return true;
		}
	}
	
	return false;
}

/***********************************************************************************************
 * ShdMeshClass::Cast_AABox -- cast an AABox against this mesh                                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   6/17/98    GTH : Created.                                                                 *
 *=============================================================================================*/
bool ShdMeshClass::Cast_AABox(AABoxCollisionTestClass & boxtest)
{
	if ((Get_Collision_Type() & boxtest.CollisionType) == 0) return false;
	if (boxtest.Result->StartBad) return false;

	for (int i=0;i<SubMeshes.Length();++i) {
		// This function analyses the tranform to call optimized functions in certain cases
		if (SubMeshes[i].Mesh->Cast_World_Space_AABox(boxtest, Get_Transform())) {
			boxtest.CollidedRenderObj = this;
			return true;
		}
	}

	return false;
}

/***********************************************************************************************
 * Cast_OBBox -- Cast an obbox against this mesh                                               *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   6/17/98    GTH : Created.                                                                 *
 *=============================================================================================*/
bool ShdMeshClass::Cast_OBBox(OBBoxCollisionTestClass & boxtest)
{
	if ((Get_Collision_Type() & boxtest.CollisionType) == 0) return false;
	if (boxtest.Result->StartBad) return false;

	/*
	** transform into the local coordinate system of the mesh.
	*/
	const Matrix3D & tm = Get_Transform();
	Matrix3D world_to_obj;
	tm.Get_Orthogonal_Inverse(world_to_obj);
	OBBoxCollisionTestClass localtest(boxtest,world_to_obj);

	for (int i=0;i<SubMeshes.Length();++i) {
		if (SubMeshes[i].Mesh->Cast_OBBox(localtest)) {

		/*
		** If we hit, transform the result of the test back to the original coordinate system.
		*/
			boxtest.CollidedRenderObj = this;
			Matrix3D::Rotate_Vector(tm,boxtest.Result->Normal, &(boxtest.Result->Normal));
			if (boxtest.Result->ComputeContactPoint) {
				Matrix3D::Transform_Vector(tm,boxtest.Result->ContactPoint, &(boxtest.Result->ContactPoint));
			}
			return true;
		}
	}

	return false;
}

/***********************************************************************************************
 * ShdMeshClass::Intersect_AABox -- test for intersection with given AABox                     *
 *                                                                                             *
 * The AAbox given is assumed to be in world space.  Since meshes aren't generally in world    *
 * space, the test must be transformed into our local coordinate system (which turns it into   *
 * an OBBox...)                                                                                *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/19/00    gth : Created.                                                                 *
 *=============================================================================================*/
bool ShdMeshClass::Intersect_AABox(AABoxIntersectionTestClass & boxtest)
{
	if ((Get_Collision_Type() & boxtest.CollisionType) == 0) return false;

	Matrix3D inv_tm;
	Get_Transform().Get_Orthogonal_Inverse(inv_tm);
	OBBoxIntersectionTestClass local_test(boxtest,inv_tm);
	
	for (int i=0;i<SubMeshes.Length();++i) {
		if (SubMeshes[i].Mesh->Intersect_OBBox(local_test)) return true;
	}
	return false;
}

/***********************************************************************************************
 * ShdMeshClass::Intersect_OBBox -- test for intersection with the given OBBox                 *
 *                                                                                             *
 * The given OBBox is assumed to be in world space so we need to transform it into the mesh's  *
 * local coordinate system.                                                                    *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/19/00    gth : Created.                                                                 *
 *=============================================================================================*/
bool ShdMeshClass::Intersect_OBBox(OBBoxIntersectionTestClass & boxtest)
{
	if ((Get_Collision_Type() & boxtest.CollisionType) == 0) return false;

	Matrix3D inv_tm;
	Get_Transform().Get_Orthogonal_Inverse(inv_tm);
	OBBoxIntersectionTestClass local_test(boxtest,inv_tm);

	for (int i=0;i<SubMeshes.Length();++i) {
		if (SubMeshes[i].Mesh->Intersect_OBBox(local_test)) return true;
	}
	return false;
}

/***********************************************************************************************
 * ShdMeshClass::Add_Dependencies_To_List -- Add dependent files to the list.                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   3/18/99    PDS : Created.                                                                 *
 *   6/05/02	 KJM : Added dependency calculation for shader system
 *=============================================================================================*/
void ShdMeshClass::Add_Dependencies_To_List
(
	DynamicVectorClass<StringClass> &file_list,
	bool										textures_only
)
{
	// loop through sub meshes
	for (int i=0;i<SubMeshes.Length();i++) 
	{
		ShdInterfaceClass* shd=SubMeshes[i].Mesh->Peek_Shader();
			
		for (int tidx=0;tidx<shd->Get_Texture_Count();tidx++)
		{
			TextureClass* texture=shd->Peek_Texture(tidx);	
			if (texture)
			{
				file_list.Add(texture->Get_Full_Path());
			}
		}
	}

	RenderObjClass::Add_Dependencies_To_List (file_list, textures_only);
	return ;
}

/***********************************************************************************************
 * ShdMeshClass::Update_Cached_Bounding_Volumes -- default collision sphere.                      *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   5/14/2001    NH : Created.                                                                *
 *=============================================================================================*/
void ShdMeshClass::Update_Cached_Bounding_Volumes(void) const
{
	Get_Obj_Space_Bounding_Sphere(CachedBoundingSphere);

	Matrix3D::Transform_Vector(Get_Transform(),CachedBoundingSphere.Center,&CachedBoundingSphere.Center);

	// If we are camera-aligned or -oriented, we don't know which way we are facing at this point,
	// so the box we return needs to contain the sphere. Otherewise do the normal computation.
/*	if (Model->Get_Flag(MeshModelClass::ALIGNED) || Model->Get_Flag(MeshModelClass::ORIENTED)) {
		CachedBoundingBox.Center = CachedBoundingSphere.Center;
		CachedBoundingBox.Extent.Set(CachedBoundingSphere.Radius, CachedBoundingSphere.Radius, CachedBoundingSphere.Radius);
	} else {
*/		Get_Obj_Space_Bounding_Box(CachedBoundingBox);
		CachedBoundingBox.Transform(Get_Transform());
//	}

	Validate_Cached_Bounding_Volumes();
}

/***********************************************************************************************
 * ShdMeshClass::Get_Obj_Space_Bounding_Sphere -- returns obj-space bounding sphere            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/19/00    gth : Created.                                                                 *
 *=============================================================================================*/
void ShdMeshClass::Get_Obj_Space_Bounding_Sphere(SphereClass & sphere) const
{
	if (SubMeshes.Length()) {
		SubMeshes[0].Mesh->Get_Bounding_Sphere(&sphere);
		// If there are more than one submesh, merge all bounding spheres
		for (int i=1;i<SubMeshes.Length();++i) {
			SphereClass tmp_s;
			SubMeshes[i].Mesh->Get_Bounding_Sphere(&tmp_s);
			sphere+=tmp_s;
		}
	}
	else {
		sphere.Center.Set(0,0,0);
		sphere.Radius = 1.0f;
	}
}

/***********************************************************************************************
 * ShdMeshClass::Get_Obj_Space_Bounding_Box -- returns the obj-space bounding box                 *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   1/19/00    gth : Created.                                                                 *
 *=============================================================================================*/
void ShdMeshClass::Get_Obj_Space_Bounding_Box(AABoxClass & box) const
{
	if (SubMeshes.Length()) {
		SubMeshes[0].Mesh->Get_Bounding_Box(&box);
		// If there are more than one submesh, merge all bounding boxes
		for (int i=1;i<SubMeshes.Length();++i) {
			AABoxClass tmp_b;
			SubMeshes[i].Mesh->Get_Bounding_Box(&tmp_b);
			
			box.Add_Box(tmp_b);
		}
	}
	else {
		box.Init(Vector3(0,0,0),Vector3(1,1,1));
	}
}

void ShdMeshClass::Init_From_Legacy_Mesh(MeshClass* mesh)
{
	Set_Name(mesh->Get_Name());
	MeshModelClass* model=mesh->Peek_Model();
	if (model) 
	{
		int first_poly=0;
		int sub_mesh_count=0;
		while (first_poly<model->Get_Polygon_Count()) {
			sub_mesh_count++;
			ShdSubMeshClass * sub_mesh = NEW_REF( ShdSubMeshClass, () );
			sub_mesh->Init_From_Legacy_Mesh_Model(model,first_poly);
			SubMeshes.Resize(sub_mesh_count);
			SubMeshes[sub_mesh_count-1].Mesh=sub_mesh;
			SubMeshes[sub_mesh_count-1].Renderer=NULL;
			if (sub_mesh->Get_Visible_Polygon_Count()==0) break;
			first_poly+=sub_mesh->Get_Visible_Polygon_Count();
		}
	}

	// Pull interesting stuff out of the w3d attributes bits
	Set_Collision_Type(mesh->Get_Collision_Type());
	Set_Hidden(mesh->Is_Hidden());
	Set_Translucent(mesh->Is_Translucent());	
}



/*********************************************************************************************** 
 * ShdMeshClass::Load -- creates a shader mesh out of a shader mesh chunk in a .w3d file       * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 * 																														  * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   05/21/2002 KM  : Created.                                                                 * 
 *=============================================================================================*/
WW3DErrorType ShdMeshClass::Load_W3D(ChunkLoadClass& cload)
{
	//	Open the first chunk, it should be the shader mesh name
	cload.Open_Chunk();
	
	if (cload.Cur_Chunk_ID()!=W3D_CHUNK_SHDMESH_NAME)
	{
		WWDEBUG_SAY(("Invalid format shader mesh.\n"));
		return WW3D_ERROR_LOAD_FAILED;
	}

	// read name
	char buf[MAX_PATH];
	cload.Read(buf,cload.Cur_Chunk_Length());
	cload.Close_Chunk();
	Set_Name(buf);

	// open header
	W3dShdMeshHeaderStruct hdr;
	cload.Open_Chunk();
	if 
	(
		cload.Read
		(
			&hdr,
			sizeof(W3dShdMeshHeaderStruct)
		)!=sizeof(W3dShdMeshHeaderStruct)
	)
	{
		return WW3D_ERROR_LOAD_FAILED;
	}
	cload.Close_Chunk();

	// Process the header

	// Set Bounding Info
	Vector3 min(hdr.BoxMin.X,hdr.BoxMin.Y,hdr.BoxMin.Z);
	Vector3 max(hdr.BoxMax.X,hdr.BoxMax.Y,hdr.BoxMax.Z);

	CachedBoundingBox.Init_Min_Max(min,max);

	Vector3 cntr(hdr.SphCenter.X,hdr.SphCenter.Y,hdr.SphCenter.Z);
	CachedBoundingSphere.Init(cntr,hdr.SphRadius);

	// Flags (todo)

	// user text
	

	// next are the sub meshes
	Free();
	SubMeshes.Resize(hdr.NumSubMeshes);
	for (int i=0;i<SubMeshes.Length(); ) 
	{
		cload.Open_Chunk();

		if (cload.Cur_Chunk_ID()==W3D_CHUNK_SHDMESH_USER_TEXT)
		{
			// todo
			cload.Read(buf,cload.Cur_Chunk_Length());
		}
		else
		{
			ShdSubMeshClass* ssmesh=NEW_REF(ShdSubMeshClass,());
			if (ssmesh==NULL) 
			{
				WWDEBUG_SAY(("ShdMeshClass::Load_W3D - Failed to allocate sub mesh\r\n"));
				return WW3D_ERROR_LOAD_FAILED;
			}

			SubMeshes[i].Mesh=ssmesh;
			SubMeshes[i].Renderer=NULL;
			REF_PTR_SET(SubMeshes[i].Mesh,SubMeshes[i].Mesh);

			ssmesh->Load_W3D(cload);
			
			// assign each sub-mesh with a name in the format: <parentmesh>.<index>
			StringClass tmp;
			tmp.Format("%s.%d",Name,i);
			ssmesh->Set_Name(tmp);
			
			i++;
		}

		cload.Close_Chunk();
	}

	// Pull interesting stuff out of the w3d attributes bits
	int col_bits = (hdr.Attributes & W3D_MESH_FLAG_COLLISION_TYPE_MASK) >> W3D_MESH_FLAG_COLLISION_TYPE_SHIFT;
	Set_Collision_Type( col_bits << 1 );
	Set_Hidden(hdr.Attributes & W3D_MESH_FLAG_HIDDEN);
	
	for (i=0;i<SubMeshes.Length(); i++) { 
		bool shadow = (hdr.Attributes & W3D_MESH_FLAG_CAST_SHADOW) == W3D_MESH_FLAG_CAST_SHADOW;
		SubMeshes[i].Mesh->Set_Flag(MeshGeometryClass::CAST_SHADOW,shadow);
	}
	
	// Indicate whether this mesh is translucent.  The mesh is considered translucent
	// if sorting has been enabled (alpha blending on pass 0) or if pass0 contains alpha-test.
	// This flag is used to determine if the mesh can cast a geometric shadow.
	bool is_translucent = false;
	for (i=0;i<SubMeshes.Length(); i++) { 
		if (SubMeshes[i].Mesh) {
			if (SubMeshes[i].Mesh->Is_Sorting()) {
				Set_Translucent(true);
			}
			ShdInterfaceClass * shader = SubMeshes[i].Mesh->Peek_Shader();
			if ((shader) && (!shader->Is_Opaque())) {
				Set_Translucent(true);
			}
		}
	}

	return WW3D_ERROR_OK;
}


int ShdMeshClass::Get_Sub_Mesh_Count(void) const
{
	return SubMeshes.Length();
}

ShdSubMeshClass * ShdMeshClass::Peek_Sub_Mesh(int i) const
{
	return SubMeshes[i].Mesh;
}