Renegade/Code/ww3d2/agg_def.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:: /Commando/Code/ww3d2/agg_def.h                              $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 4/05/01 9:52a                                               $*
 *                                                                                             *
 *                    $Revision:: 2                                                           $*
 *                                                                                             *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#if defined(_MSC_VER)
#pragma once
#endif

#ifndef AGGREGATE_DEF_H
#define AGGREGATE_DEF_H

#include "proto.h"
#include "rendobj.h"
#include "w3d_file.h"
#include "w3derr.h"
#include "vector.h"
#include "bittype.h"
#include <string.h>

#ifdef _UNIX
#include "osdep.h"
#endif


// Forward declarations
class ChunkLoadClass;
class ChunkSaveClass;
class IndirectTextureClass;


///////////////////////////////////////////////////////////////////////////////////
//
//	Macros
//
#ifndef SAFE_FREE
#define SAFE_FREE(pointer)	\
{ \
	if (pointer) {	\
		::free (pointer);	\
		pointer = 0; \
	} \
}

#endif //SAFE_FREE


//////////////////////////////////////////////////////////////////////////////////
//
//	AggregateDefClass
//
//	Description of an aggregate object.  Used by the asset manager
// to construct aggregates.  An  'aggregate' is simply a 'shell' that
//	contains references to a hierarchy model and subobjects to attach to its bones.
//
class AggregateDefClass
{
	public:

		///////////////////////////////////////////////////////////
		//
		//	Public constructors/destructors
		//		
		AggregateDefClass (void);
		AggregateDefClass (RenderObjClass &base_model);
		AggregateDefClass (const AggregateDefClass &src);
		virtual ~AggregateDefClass (void);

		
		///////////////////////////////////////////////////////////
		//
		//	Public operators
		//		
		const AggregateDefClass &operator= (const AggregateDefClass &src);

		///////////////////////////////////////////////////////////
		//
		//	Public methods
		//		
		virtual WW3DErrorType	Load_W3D (ChunkLoadClass &chunk_load);
		virtual WW3DErrorType	Save_W3D (ChunkSaveClass &chunk_save);
		const char *				Get_Name (void) const					{ return m_pName; }
		void							Set_Name (const char *pname)			{ SAFE_FREE (m_pName); m_pName = ::_strdup (pname); }
		RenderObjClass *			Create (void);
		AggregateDefClass *		Clone (void) const						{ return new AggregateDefClass (*this); }

		//
		//	Public accessors
		//
		ULONG							Class_ID (void) const					{ return m_MiscInfo.OriginalClassID; }

		//
		//	Initialization
		//
		void							Initialize (RenderObjClass &base_model);

	protected:

		///////////////////////////////////////////////////////////
		//
		//	Protected data types
		//
		typedef struct _TEXTURE_INFO
		{
			W3dTextureReplacerStruct	names;
			IndirectTextureClass *		pnew_texture;

			bool operator == (_TEXTURE_INFO &src) { return false; }
			bool operator != (_TEXTURE_INFO &src) { return true; }
		} TEXTURE_INFO;
		

		///////////////////////////////////////////////////////////
		//
		//	Protected methods
		//
		
		//
		//	Loading methods
		//
		virtual WW3DErrorType		Read_Header (ChunkLoadClass &chunk_load);
		virtual WW3DErrorType		Read_Info (ChunkLoadClass &chunk_load);
		virtual WW3DErrorType		Read_Subobject (ChunkLoadClass &chunk_load);
		virtual WW3DErrorType		Read_Class_Info (ChunkLoadClass &chunk_load);

		//
		//	Saving methods
		//
		virtual WW3DErrorType		Save_Header (ChunkSaveClass &chunk_save);
		virtual WW3DErrorType		Save_Info (ChunkSaveClass &chunk_save);
		virtual WW3DErrorType		Save_Subobject (ChunkSaveClass &chunk_save, W3dAggregateSubobjectStruct *psubobject);
		virtual WW3DErrorType		Save_Class_Info (ChunkSaveClass &chunk_save);

		//
		//	Creation methods
		//
		virtual void				Attach_Subobjects (RenderObjClass &base_model);

		//
		//	Search methods
		//
		virtual RenderObjClass *			Find_Subobject (RenderObjClass &model, const char mesh_path[MESH_PATH_ENTRIES][MESH_PATH_ENTRY_LEN], const char bone_path[MESH_PATH_ENTRIES][MESH_PATH_ENTRY_LEN]);

		//
		//	Misc. methods
		//
		virtual void				Free_Subobject_List (void);
		virtual void				Add_Subobject (const W3dAggregateSubobjectStruct &subobj_info);
		virtual bool				Load_Assets (const char *asset_name);
		virtual RenderObjClass *Create_Render_Object (const char *passet_name);
		virtual bool				Is_Object_In_List (const char *passet_name, DynamicVectorClass <RenderObjClass *> &node_list);

		virtual void				Build_Subobject_List (RenderObjClass &original_model, RenderObjClass &model);


	private:

		///////////////////////////////////////////////////////////
		//
		//	Private member data
		//
		DWORD																m_Version;
		DynamicVectorClass<W3dAggregateSubobjectStruct *>	m_SubobjectList;
		W3dAggregateInfoStruct										m_Info;
		W3dAggregateMiscInfo											m_MiscInfo;
		char * 															m_pName;
};


///////////////////////////////////////////////////////////////////////////////////
//
//	AggregatePrototypeClass
//
class AggregatePrototypeClass : public PrototypeClass 
{
	public:

		///////////////////////////////////////////////////////////
		//
		//	Public constructors/destructors
		//		
		AggregatePrototypeClass (AggregateDefClass *pdef)		{ m_pDefinition = pdef; }
		virtual ~AggregatePrototypeClass (void)					{ delete m_pDefinition; }
		
		///////////////////////////////////////////////////////////
		//
		//	Public methods
		//
		virtual const char *				Get_Name(void) const			{ return m_pDefinition->Get_Name (); }
		virtual int							Get_Class_ID(void) const	{ return m_pDefinition->Class_ID (); }
		virtual RenderObjClass *		Create (void)					{ return m_pDefinition->Create (); }
		virtual AggregateDefClass	*	Get_Definition (void) const { return m_pDefinition; }
		virtual void						Set_Definition (AggregateDefClass *pdef) { m_pDefinition = pdef; }

	private:

		///////////////////////////////////////////////////////////
		//
		//	Private member data
		//
		AggregateDefClass	*	m_pDefinition;
};


///////////////////////////////////////////////////////////////////////////////////
//
//	AggregateLoaderClass
//
class AggregateLoaderClass : public PrototypeLoaderClass
{
	public:

		virtual int						Chunk_Type (void)  { return W3D_CHUNK_AGGREGATE; }
		virtual PrototypeClass *	Load_W3D (ChunkLoadClass &chunk_load);
};


///////////////////////////////////////////////////////////////////////////////////
//
//	Global variables
//
extern AggregateLoaderClass	_AggregateLoader;


#endif //__AGGREGATE_DEF_H