Renegade/Code/Tools/LevelEdit/Node.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 : LevelEdit                                                    *
 *                                                                                             *
 *                     $Archive:: /Commando/Code/Tools/LevelEdit/Node.h         $*
 *                                                                                             *
 *                       Author:: Patrick Smith                                                *
 *                                                                                             *
 *                     $Modtime:: 4/20/01 10:37a                                              $*
 *                                                                                             *
 *                    $Revision:: 25                                                          $*
 *                                                                                             *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */


#if defined(_MSC_VER)
#pragma once
#endif

#ifndef __NODE_H
#define __NODE_H

#include "refcount.h"
#include "phys.h"
#include "utils.h"
#include "quat.h"
#include "persist.h"
#include "hittestinfo.h"
#include "preset.h"
#include "wwstring.h"

//////////////////////////////////////////////////////////////////
// Forward declarations
//////////////////////////////////////////////////////////////////
class SelectionBoxClass;
class VisPointGeneratorClass;
class ObjectNodeClass;
class TileNodeClass;
class TerrainNodeClass;
class SoundNodeClass;
class LightNodeClass;
class WaypathNodeClass;
class WaypointNodeClass;


//////////////////////////////////////////////////////////////////
//
//	NodeClass
//
//////////////////////////////////////////////////////////////////
class NodeClass : public PersistClass, public RefCountClass
{
public:

	//////////////////////////////////////////////////////////////
	//	Public constructors/destructors
	//////////////////////////////////////////////////////////////
	NodeClass (PresetClass *preset = NULL);
	NodeClass (const NodeClass &src);
	virtual ~NodeClass (void);

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

	//////////////////////////////////////////////////////////////
	//	Public methods
	//////////////////////////////////////////////////////////////
	
	//
	//	Creation methods
	//
	virtual void					Initialize (void) = 0;	
	virtual NodeClass *			Clone (void) = 0;
	
	//
	//	Identification methods
	//
	virtual NODE_TYPE				Get_Type (void) const = 0;
	virtual const char *			Get_Name (void) const;
	virtual void					Set_Name (const char *name);
	virtual uint32					Get_ID (void) const;
	virtual void					Set_ID (uint32 id);
	virtual int						Get_Icon_Index (void) const = 0;
	virtual const char *			Get_Comments (void) const;
	virtual void					Set_Comments (const char *comments);

	//
	//	RTTI
	//
	virtual ObjectNodeClass *		As_ObjectNodeClass (void)		{ return NULL; }
	virtual TileNodeClass *			As_TileNodeClass (void)			{ return NULL; }
	virtual TerrainNodeClass *		As_TerrainNodeClass (void)		{ return NULL; }
	virtual SoundNodeClass *		As_SoundNodeClass (void)		{ return NULL; }
	virtual LightNodeClass *		As_LightNodeClass (void)		{ return NULL; }
	virtual WaypathNodeClass *		As_WaypathNodeClass (void)		{ return NULL; }
	virtual WaypointNodeClass *	As_WaypointNodeClass (void)	{ return NULL; }

	//
	//	Scene methods
	//
	virtual void					Add_To_Scene (void);
	virtual void					Remove_From_Scene (void);
	virtual bool					In_Scene (void) const;
	virtual void					Reload (void);
	virtual uint32					Get_Cull_Link (void) const		{ return m_CullLink; }
	virtual void					Set_Cull_Link (uint32 link)	{ m_CullLink = link; }
	virtual void					Update_Cached_Cull_Link (void);

	//
	//	Transformation methods
	//
	virtual void					Set_Transform (const Matrix3D &tm);
	virtual Matrix3D				Get_Transform (void);
	virtual void					Set_Position (const Vector3 &pos);
	virtual Vector3				Get_Position (void) const;
	virtual void					Set_Orientation (const Quaternion &quat);
	virtual const Quaternion &	Get_Orientation (void) const;
	virtual void					Translate (const Vector3 &vector);
	virtual void					Rotate (const Matrix3D &rotation_matrix, const Matrix3D &coord_system);
	
	//
	//	Movement restriction methods
	//
	virtual bool					Can_Be_Rotated_Freely (void) const;
	virtual bool					Is_Rotation_Restricted (void) const;
	virtual void					Restrict_Rotation (bool restrict);
	virtual bool					Is_Locked (void) const;
	virtual void					Lock (bool lock);	

	//
	//	Intrinsic behavior methods
	//
	virtual bool					Is_Static (void) const = 0;

	//
	//	Notifications
	//
	virtual void					On_Rotate (void);
	virtual void					On_Translate (void);
	virtual void					On_Transform (void);
	virtual void					On_Delete (void) { }
	virtual void					On_Restore (void) { }

	//
	//	Accessors
	//
	virtual PhysClass *			Peek_Physics_Obj (void) const = 0;
	virtual RenderObjClass *	Peek_Render_Obj (void) const;
	virtual PhysClass *			Peek_Collision_Obj (void) const;
	virtual LPCTSTR				Get_Model_Name (void) const;
	void								Set_Preset (PresetClass *preset);
	PresetClass *					Get_Preset (void) const;
	uint32							Get_Preset_ID (void) const;

	//
	//	Visibility methods
	//	
	virtual void					Show_Selection_Box (bool onoff);	
	virtual void					Hide (bool hide);	
	virtual bool					Is_Hidden (void) const;

	//
	//	Attenuation methods
	//
	virtual bool					Is_Attenuation_Sphere_Shown (void)		{ return false; }
	virtual void					Show_Attenuation_Spheres (bool onoff)	{ }
	virtual float					Get_Attenuation_Radius (void)				{ return 0.0F; }
	virtual void					Set_Attenuation_Radius (float radius)	{ }

	//
	//	Editing methods
	//
	virtual bool					Show_Settings_Dialog (void);
	virtual NodeClass *			Add_Child_Node (const Matrix3D &tm)		{ return NULL; }
	virtual NodeClass *			Get_Parent_Node (void) const				{ return NULL; }
	virtual bool					Can_Add_Child_Nodes (void)	const			{ return false; }
	virtual bool					Is_A_Child_Node (NodeClass *) const		{ return false; }
	
	
	virtual bool					Is_Proxied (void) const						{ return m_IsProxied; }
	virtual void					Set_Is_Proxied (bool onoff)				{ m_IsProxied = onoff; }
	virtual uint32					Get_Container_Preset_ID (void) const	{ return m_ContainerPresetID; }
	virtual void					Set_Container_Preset_ID (int id)			{ m_ContainerPresetID = id; }

	//
	//	Export methods
	//
	virtual void					Pre_Export (void)		{ }
	virtual void					Post_Export (void)	{ }

	//
	//	Vis-related methods
	//
	virtual void					Add_Vis_Points (VisPointGeneratorClass &generator, RenderObjClass *render_obj = NULL);
	virtual bool					Has_Vis_Sectors (RenderObjClass *render_obj = NULL);
	virtual void					Update_Cached_Vis_IDs (void) { };

	//
	//	Sub-node Enumeration
	//
	virtual int						Get_Sub_Node_Count (void) const	{ return 0; }
	virtual NodeClass *			Get_Sub_Node (int index)			{ return NULL; }

	//
	//	From PersistClass
	//
	virtual bool					Save (ChunkSaveClass &csave);
	virtual bool					Load (ChunkLoadClass &cload);

	//
	//	Save filtering
	//
	virtual bool					Needs_Save (void) const			{ return m_NeedsSave; }
	virtual void					Set_Needs_Save (bool onoff)	{ m_NeedsSave = onoff; }

	//
	//	Selection box methods
	//
	virtual void					Update_Selection_Color (void);
	virtual void					Update_Selection_Box (void);

	//
	//	Zone edit methods
	//
	virtual void					On_Vertex_Drag_Begin (int vertex_index)			{ }
	virtual void					On_Vertex_Drag (int vertex_index, POINT point)	{ }
	virtual void					On_Vertex_Drag_End (int vertex_index)				{ }

protected:

	//////////////////////////////////////////////////////////////
	//	Protected methods
	//////////////////////////////////////////////////////////////
	
	//
	//	Save/load methods
	//
	bool								Load_Variables (ChunkLoadClass &cload);

	//////////////////////////////////////////////////////////////
	//	Protected member data
	//////////////////////////////////////////////////////////////
	StringClass				m_Name;
	StringClass				m_Comments;
	uint32					m_ID;
	uint32					m_PresetID;
	bool						m_IsLocked;
	bool						m_RotationRestricted;
	bool						m_IsInScene;
	bool						m_NeedsSave;
	bool						m_IsProxied;
	PresetClass *			m_Preset;
	uint32					m_ContainerPresetID;
	SelectionBoxClass *	m_SelectionBox;
	Quaternion				m_Orientation;
	Vector3					m_SelColor;	
	Matrix3D					m_Transform;
	uint32					m_CullLink;


	// For hit-test feedback
	HITTESTINFO				m_HitTestInfo;


	// For use with NodeMgrClass
	NodeClass *				m_NextNode;
	NodeClass *				m_PrevNode;

	//////////////////////////////////////////////////////////////
	//	Friends
	//////////////////////////////////////////////////////////////
	friend class NodeMgrClass;
};


//////////////////////////////////////////////////////////////////
//	Set_Transform
//////////////////////////////////////////////////////////////////
inline void
NodeClass::Set_Transform (const Matrix3D &tm)
{
	m_Transform = tm;

	PhysClass *phys_obj = Peek_Physics_Obj ();		
	if (phys_obj != NULL) {
		phys_obj->Set_Transform (tm);		
		On_Transform ();
	}
	
	return ;
}

//////////////////////////////////////////////////////////////////
//	Get_Transform
//////////////////////////////////////////////////////////////////
inline Matrix3D
NodeClass::Get_Transform (void)
{
	Matrix3D tm (1);

	PhysClass *phys_obj = Peek_Physics_Obj ();		
	if (phys_obj != NULL) {
		tm = phys_obj->Get_Transform ();
	}

	return tm;
}

//////////////////////////////////////////////////////////////////
//	Set_Position
//////////////////////////////////////////////////////////////////
inline void
NodeClass::Set_Position (const Vector3 &pos)
{
	m_Transform.Set_Translation (pos);

	PhysClass *phys_obj = Peek_Physics_Obj ();		
	if (phys_obj != NULL) {
		phys_obj->Set_Transform (m_Transform);		
		On_Translate ();
	}
	
	return ;
}

//////////////////////////////////////////////////////////////////
//	Get_Position
//////////////////////////////////////////////////////////////////
inline Vector3
NodeClass::Get_Position (void) const
{
	return m_Transform.Get_Translation ();
}

//////////////////////////////////////////////////////////////////
//	Can_Be_Rotated_Freely
//////////////////////////////////////////////////////////////////
inline bool
NodeClass::Can_Be_Rotated_Freely (void) const
{
	return true;
}

//////////////////////////////////////////////////////////////////
//	Is_Rotation_Restricted
//////////////////////////////////////////////////////////////////
inline bool
NodeClass::Is_Rotation_Restricted (void) const
{
	return m_RotationRestricted;
}

//////////////////////////////////////////////////////////////////
//	Restrict_Rotation
//////////////////////////////////////////////////////////////////
inline void
NodeClass::Restrict_Rotation (bool restrict)
{
	m_RotationRestricted = restrict;
	return ;
}

//////////////////////////////////////////////////////////////////
//	Get_Preset_ID
//////////////////////////////////////////////////////////////////
inline uint32
NodeClass::Get_Preset_ID (void) const
{
	return m_PresetID;
}

//////////////////////////////////////////////////////////////////
//	Get_Preset
//////////////////////////////////////////////////////////////////
inline PresetClass *
NodeClass::Get_Preset (void) const
{
	return m_Preset;
}

//////////////////////////////////////////////////////////////////
//	Set_Preset
//////////////////////////////////////////////////////////////////
inline void
NodeClass::Set_Preset (PresetClass *preset)
{
	m_Preset = preset;
	if (m_Preset != NULL) {
		m_PresetID = m_Preset->Get_ID ();
	}

	return ;
}

//////////////////////////////////////////////////////////////////
//	In_Scene
//////////////////////////////////////////////////////////////////
inline bool
NodeClass::In_Scene (void) const
{
	return m_IsInScene;
}

//////////////////////////////////////////////////////////////////
//	Get_ID
//////////////////////////////////////////////////////////////////
inline uint32
NodeClass::Get_ID (void) const
{
	return m_ID;
}

//////////////////////////////////////////////////////////////////
//	Peek_Collision_Obj
//////////////////////////////////////////////////////////////////
inline PhysClass *
NodeClass::Peek_Collision_Obj (void) const
{
	return Peek_Physics_Obj ();
}


INLINE_ACCESSOR_CONST (const Quaternion &,	NodeClass, Orientation);
INLINE_ACCESSOR_CONST (const char *,			NodeClass, Name);
//INLINE_ACCESSOR_CONST (uint32,					NodeClass, ID);
INLINE_ACCESSOR_CONST (const char *,			NodeClass, Comments);


#endif //__NODE_H