Initial commit of Command & Conquer Renegade source code.

Code/Tools/LevelEdit/TerrainNode.cpp

@@ -0,0 +1,992 @@
+/*
+**	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/TerrainNode.cpp              $*
+ *                                                                                             *
+ *                       Author:: Patrick Smith                                                *
+ *                                                                                             *
+ *                     $Modtime:: 2/12/02 4:07p                                               $*
+ *                                                                                             *
+ *                    $Revision:: 36                                                          $*
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#include "stdafx.h"
+#include "terrainnode.h"
+#include "staticphys.h"
+#include "sceneeditor.h"
+#include "terraindefinition.h"
+#include "filemgr.h"
+#include "_assetmgr.h"
+#include "editorassetmgr.h"
+#include "w3d_file.h"
+#include "hlod.h"
+#include "cameramgr.h"
+#include "collisiongroups.h"
+#include "persistfactory.h"
+#include "editorchunkids.h"
+#include "preset.h"
+#include "collect.h"
+#include "presetmgr.h"
+#include "nodemgr.h"
+#include "editorsaveload.h"
+#include "terrainsectionpersist.h"
+#include "lightphys.h"
+#include "lightnode.h"
+#include "leveleditview.h"
+#include "hlod.h"
+
+//////////////////////////////////////////////////////////////////////////////
+//	Persist factory
+//////////////////////////////////////////////////////////////////////////////
+SimplePersistFactoryClass<TerrainNodeClass, CHUNKID_NODE_TERRAIN> _TerrainNodePersistFactory;
+SimplePersistFactoryClass<TerrainNodeClass, CHUNKID_NODE_TERRAIN_SECTION> _TerrainSectionNodePersistFactory;
+
+
+enum
+{
+	CHUNKID_VARIABLES					= 0x10251130,
+	CHUNKID_BASE_CLASS,
+	CHUNKID_SECTION_PERSISTDATA,
+	CHUNKID_SECTION_PERSIST_LIST
+};
+
+enum
+{
+	XXX_VARID_VISID			= 0x01,
+	VARID_SECTIONID_OLD,
+	VARID_SECTIONID,
+	VARID_TM
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	TerrainNodeClass
+//
+//////////////////////////////////////////////////////////////////////////////
+TerrainNodeClass::TerrainNodeClass (PresetClass *preset)	:
+	Transform (1),
+	LoadedTransform (1),
+	NodeClass (preset)
+{
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	~TerrainNodeClass
+//
+//////////////////////////////////////////////////////////////////////////////
+TerrainNodeClass::~TerrainNodeClass (void)
+{
+	Remove_From_Scene ();
+	Free_Sections ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Free_Section_Data
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Free_Section_Data (void)
+{
+	m_TerrainSectionInfo.Free_List ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Free_Sections
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Free_Sections (void)
+{
+	//
+	//	Release our hold on all the physics pointers
+	//
+	for (int index = 0; index < m_Sections.Count (); index ++) {
+		NodeClass *sub_node = m_Sections[index];
+		MEMBER_RELEASE (sub_node);
+
+		//
+		//	Remove the file dependencies for this tile from the file manager.
+		//
+		if (sub_node != NULL && sub_node->Get_Type () != NODE_TYPE_TERRAIN_SECTION) {
+			::Get_File_Mgr ()->Update (sub_node, false);
+		}
+	}
+
+	m_Sections.Delete_All ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Add_To_Scene
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Add_To_Scene (void)
+{
+	SceneEditorClass *scene = ::Get_Scene_Editor ();
+
+	//
+	//	Add all the sections to the scene
+	//
+	for (int index = 0; index < m_Sections.Count (); index ++) {
+		NodeClass *sub_node = m_Sections[index];
+		sub_node->Add_To_Scene ();
+	}
+
+	m_IsInScene = true;
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Remove_From_Scene
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Remove_From_Scene (void)
+{
+	SceneEditorClass *scene = ::Get_Scene_Editor ();
+	if (scene != NULL && m_IsInScene) {
+		Build_Section_ID_List ();
+
+		//
+		//	Remove all the sections from the scene
+		//
+		for (int index = 0; index < m_Sections.Count (); index ++) {
+			NodeClass *sub_node = m_Sections[index];
+			sub_node->Remove_From_Scene ();
+		}
+
+		m_IsInScene = false;
+	}
+	
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Set_Transform
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Set_Transform (const Matrix3D &tm)
+{
+	Special_Set_Transform (tm);
+	Transform = tm;	
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Special_Set_Transform
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Special_Set_Transform (const Matrix3D &tm)
+{
+	Matrix3D curr_tm = Get_Transform ();
+	Matrix3D inv_tm (1);
+	curr_tm.Get_Orthogonal_Inverse (inv_tm);
+
+	//
+	//	Move all the sub-sections
+	//
+	for (int index = 0; index < m_Sections.Count (); index ++) {
+		NodeClass *sub_node = (TerrainSectionNodeClass *)m_Sections[index];
+
+		if (sub_node->Get_Type () == NODE_TYPE_TERRAIN_SECTION) {
+			
+			//
+			//	Check to see if this sub-object is a dazzle.  If it is, then
+			// transform it relative to the terrain...
+			//
+			RenderObjClass *model = sub_node->Peek_Render_Obj ();		
+			if (model != NULL && model->Class_ID () == RenderObjClass::CLASSID_DAZZLE) {
+				Matrix3D sub_obj_tm		= sub_node->Get_Transform ();
+				Matrix3D rel_sub_obj_tm	= inv_tm * sub_obj_tm;
+
+				Matrix3D new_tm = tm * rel_sub_obj_tm;
+				((TerrainSectionNodeClass *)sub_node)->Special_Set_Transform (new_tm);
+			} else {
+				((TerrainSectionNodeClass *)sub_node)->Special_Set_Transform (tm);
+			}
+			
+		} else if (sub_node->Get_Type () == NODE_TYPE_TERRAIN) {
+			((TerrainNodeClass *)sub_node)->Special_Set_Transform (tm);
+		} else  {
+			//
+			//	Transform this object relative to the terrain
+			//
+			Matrix3D sub_obj_tm		= sub_node->Get_Transform ();
+			Matrix3D rel_sub_obj_tm	= inv_tm * sub_obj_tm;
+
+			Matrix3D new_tm = tm * rel_sub_obj_tm;
+			sub_node->Set_Transform (new_tm);
+		}
+	}
+
+	NodeClass::Set_Transform (tm);
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//	Initialize
+//
+//	Note:  This may be called more than once.  It is used as an 'initialize'
+// and a 're-initialize'.
+//
+//////////////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Initialize (void)
+{
+	Build_Section_ID_List ();
+	Free_Sections ();
+
+	TerrainDefinitionClass *definition = static_cast<TerrainDefinitionClass *> (m_Preset->Get_Definition ());
+	if (definition != NULL) {
+
+		//
+		//	Make sure all assets are loaded into memory before this tile is created...
+		//
+		m_Preset->Load_All_Assets ();
+		
+		CString filename		= definition->Get_Model_Name ();
+		CString asset_name	= ::Asset_Name_From_Filename (filename);
+
+		//
+		//	Filename valid?
+		//
+		if (filename.GetLength () > 0) {
+			filename = ::Get_File_Mgr ()->Make_Full_Path (filename);
+			_pThe3DAssetManager->Set_Current_Directory (::Strip_Filename_From_Path (filename));
+
+			//
+			// Create the terrain
+			//
+			RenderObjClass *terrain = ::Create_Render_Obj (asset_name);
+			if (terrain != NULL) {
+
+				//
+				// Loop through all the sections inside the mesh collection and
+				// create static phys objects for each one.
+				//
+				int section_count = terrain->Get_Num_Sub_Objects ();
+				if (section_count > 0) {
+					for (int index = 0; index < section_count; index ++) {
+						RenderObjClass *sub_obj = terrain->Get_Sub_Object (index);
+						if (sub_obj != NULL) {
+
+							//
+							//	Create a new terrain section and add it to our list
+							//
+							TerrainSectionNodeClass *sub_node = new TerrainSectionNodeClass;
+							sub_node->Create (sub_obj);
+							sub_node->Set_Terrain (this);
+							m_Sections.Add (sub_node);
+							
+							MEMBER_RELEASE (sub_obj);
+						}																		
+					}
+				}
+				
+				//
+				//	Build a list of proxy objects
+				//
+				DynamicVectorClass<ProxyClass> proxy_list;
+				if (terrain->Class_ID () == RenderObjClass::CLASSID_COLLECTION) {
+
+					//
+					//	Add all the proxies from the collection to our list
+					//
+					CollectionClass *collection = (CollectionClass *)terrain;
+					for (int index = 0; index < collection->Get_Proxy_Count (); index ++) {
+						ProxyClass proxy;
+						if (collection->Get_Proxy (index, proxy)) {
+							proxy_list.Add (proxy);
+						}
+					}
+
+				} else  if (terrain->Class_ID () == RenderObjClass::CLASSID_HLOD) {
+
+					//
+					//	Add all the proxies from the HLOD to our list
+					//
+					HLodClass *hlod = reinterpret_cast<HLodClass *>(terrain);
+					for (int index = 0; index < hlod->Get_Proxy_Count (); index ++) {
+						ProxyClass proxy;
+						if (hlod->Get_Proxy (index, proxy)) {
+							proxy_list.Add (proxy);
+						}
+					}					
+				}
+				
+				//
+				//	Create the proxy objects
+				//
+				Create_Proxies (proxy_list);
+
+				//
+				//	Create all the lights that are associated with this terrain
+				//
+				Create_Lights ();
+
+				MEMBER_RELEASE (terrain);
+			}
+		}
+
+		//
+		//	Make sure we restore all the VIS ids (if necessary)
+		//
+		Assign_Section_IDs ();
+	}
+
+	return ;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Assign_Section_IDs
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Assign_Section_IDs (void)
+{
+	m_TerrainSectionInfo.Assign_Section_IDs (this);
+	return ;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Build_Section_ID_List
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Build_Section_ID_List (void)
+{
+	//
+	//	Rebuild the list from scratch (if there is anything to do)
+	//
+	if (In_Scene () && m_Sections.Count () > 0) {
+		Free_Section_Data ();
+		m_TerrainSectionInfo.Build_List (m_Sections);
+	}
+
+	return ;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Get_Factory
+//
+////////////////////////////////////////////////////////////////
+const PersistFactoryClass &
+TerrainNodeClass::Get_Factory (void) const
+{	
+	return _TerrainNodePersistFactory;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Add_Vis_Points
+//
+/////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Add_Vis_Points
+(
+	VisPointGeneratorClass &	generator,
+	RenderObjClass *				render_obj
+)
+{
+	/*for (int index = 0; index < m_Sections.Count (); index ++) {
+		StaticPhysClass *phys_obj = m_Sections[index];
+
+		//
+		//	Pass all the sections onto the generator
+		//
+		RenderObjClass *render_obj = phys_obj->Peek_Model ();
+		if (render_obj != NULL) {
+			NodeClass::Add_Vis_Points (generator, render_obj);
+		}
+	}*/
+
+	return ;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Hide
+//
+/////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Hide (bool hide)
+{
+	for (int index = 0; index < m_Sections.Count (); index ++) {
+		NodeClass *node = m_Sections[index];
+		node->Hide (hide);
+	}
+
+	return ;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Is_Hidden
+//
+/////////////////////////////////////////////////////////////////
+bool
+TerrainNodeClass::Is_Hidden (void) const
+{
+	bool retval = false;
+
+	if (m_Sections.Count () > 0) {
+		NodeClass *node = m_Sections[0];
+		retval = node->Is_Hidden ();
+	}
+
+	return retval;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Save
+//
+/////////////////////////////////////////////////////////////////
+bool
+TerrainNodeClass::Save (ChunkSaveClass &csave)
+{
+	csave.Begin_Chunk (CHUNKID_BASE_CLASS);
+		NodeClass::Save (csave);
+	csave.End_Chunk ();	
+
+	//
+	//	Write a chunk for each section so we can store instance
+	// specific data.
+	//
+	Build_Section_ID_List ();
+	csave.Begin_Chunk (CHUNKID_SECTION_PERSIST_LIST);
+		m_TerrainSectionInfo.Save (csave);
+	csave.End_Chunk ();
+
+	csave.Begin_Chunk (CHUNKID_VARIABLES);
+		WRITE_MICRO_CHUNK (csave, VARID_TM, Transform)
+	csave.End_Chunk ();
+	return true;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Load
+//
+/////////////////////////////////////////////////////////////////
+bool
+TerrainNodeClass::Load (ChunkLoadClass &cload)
+{
+	while (cload.Open_Chunk ()) {		
+		switch (cload.Cur_Chunk_ID ()) {
+
+			case CHUNKID_BASE_CLASS:
+				NodeClass::Load (cload);
+				break;
+			
+			case CHUNKID_VARIABLES:
+				Load_Variables (cload);
+				break;
+
+			case CHUNKID_SECTION_PERSIST_LIST:
+				m_TerrainSectionInfo.Load (cload);
+				break;
+		}
+
+		cload.Close_Chunk ();
+	}
+
+	SaveLoadSystemClass::Register_Post_Load_Callback (this);
+	return true;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Load_Variables
+//
+/////////////////////////////////////////////////////////////////
+bool
+TerrainNodeClass::Load_Variables (ChunkLoadClass &cload)
+{
+	while (cload.Open_Micro_Chunk ()) {
+		switch (cload.Cur_Micro_Chunk_ID ()) {
+
+			READ_MICRO_CHUNK (cload, VARID_TM, LoadedTransform)
+			
+			case VARID_SECTIONID_OLD:
+			case VARID_SECTIONID:
+			{
+				//
+				//	Force vis to be reset
+				//
+				PhysicsSceneClass::Get_Instance ()->Reset_Vis ();
+				EditorSaveLoadClass::Set_Loaded_Vis_Valid (false);
+				::Output_Message ("Old-style terrain section ID found, resetting VIS data.\r\n");
+			}
+			break;
+		}
+
+		cload.Close_Micro_Chunk ();
+	}
+
+	return true;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Create_Lights
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Create_Lights (void)
+{	
+	if (::Get_Scene_Editor ()->Is_Proxy_Creation_Enabled () == false) {
+		return ;
+	}
+
+	//
+	//	Get the terrain's definition
+	//
+	TerrainDefinitionClass *definition = static_cast<TerrainDefinitionClass *> (m_Preset->Get_Definition ());
+	if (definition == NULL) {
+		return ;
+	}
+	::Get_Main_View ()->Allow_Repaint (false);
+
+	//
+	//	Get the filename for the light database
+	//
+	CString full_path = ::Get_File_Mgr ()->Make_Full_Path (definition->Get_Light_Filename ());
+	DynamicVectorClass<StringClass> filename_list;
+	filename_list.Add ((LPCTSTR)full_path);
+
+	//
+	//	Import the lights into the level
+	//
+	DynamicVectorClass<LightNodeClass *> node_list;
+	::Get_Scene_Editor ()->Import_Lights (filename_list, &node_list);
+	
+	//
+	//	Add all these lights to our section list
+	//
+	for (int index = 0; index < node_list.Count (); index ++) {
+		LightNodeClass *node = node_list[index];
+		if (node != NULL) {
+			
+			//
+			//	Transform this light from world-relative to terrain relative
+			//
+			node->Set_Transform (Get_Transform () * node->Get_Transform ());
+
+			//
+			//	Add the light to our section list and 'remove' it from the node manager
+			//			
+			node->Lock (true);
+			m_Sections.Add (node);
+			NodeMgrClass::Remove_Node (node);
+		}
+	}
+
+	::Get_Main_View ()->Allow_Repaint (true);
+	return ;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Find_Proxy_Preset
+//
+////////////////////////////////////////////////////////////////
+PresetClass *
+TerrainNodeClass::Find_Proxy_Preset (const char *preset_name)
+{
+	bool is_restricted_user = ::Get_File_Mgr ()->Is_Special_User ();
+	
+	PresetClass *retval = NULL;
+
+	//
+	//	Loop over all the presets, until we've found one that matches the
+	// requirements
+	//
+	bool keep_going	= true;
+	bool is_preferred	= false;
+	for (	PresetClass *preset = PresetMgrClass::Get_First ();
+			preset != NULL && keep_going;
+			preset = PresetMgrClass::Get_Next (preset))
+	{
+		//
+		//	Is this the preset we are looking for?
+		//
+		if (::lstrcmpi (preset->Get_Name (), preset_name) == 0) {
+			
+			if (is_preferred == false) {
+				retval = preset;
+			}
+
+			if (preset->Is_A_Parent (PROXY_TESTS_FOLDER)) {
+				retval = preset;
+				keep_going = false;
+			} else if (is_restricted_user == preset->Is_A_Parent (SPECIAL_USER_FOLDER)) {
+				
+				//
+				//	Restricted users prefer presets under their folder, other's prefer
+				// presets not under the restricted presets folder.
+				//
+				is_preferred = true;
+			}
+		}
+	}
+
+	return retval;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Create_Proxies
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Create_Proxies (DynamicVectorClass<ProxyClass> &proxy_list)
+{
+	if (::Get_Scene_Editor ()->Is_Proxy_Creation_Enabled () == false) {
+		return ;
+	}
+
+	//
+	//	Loop over all the proxy objects in the list
+	//
+	int count = proxy_list.Count ();
+	for (int index = 0; index < count; index ++) {
+		
+		//
+		// Get information about this proxy
+		//
+		Matrix3D rel_transform	= proxy_list[index].Get_Transform ();
+		CString preset_name		= proxy_list[index].Get_Name ();
+
+		//
+		// Find the preset this placeholder references
+		//
+		PresetClass *preset = Find_Proxy_Preset (preset_name);
+		if (preset != NULL) {						
+			
+			//
+			// Create the node from the base
+			//
+			NodeClass *node = ::Get_Scene_Editor ()->Create_Node (preset, &rel_transform, 0, false);
+			ASSERT (node != NULL);
+			if (node != NULL) {
+								
+				//
+				//	Change some flags on the object
+				//
+				node->Restrict_Rotation (false);
+				node->Set_Is_Proxied (true);
+
+				//
+				//	Is the node configured correctly?
+				//
+				if (node->Peek_Physics_Obj () != NULL || node->Get_Type () == NODE_TYPE_TERRAIN) {
+
+					//
+					// Normalize the rotation of this node
+					//
+					node->Rotate (Matrix3D (1), Matrix3D (1));
+					node->Lock (true);
+
+					//
+					//	We have to tell the terrain it can really be moved...
+					//
+					if (node->Get_Type () == NODE_TYPE_TERRAIN) {
+						((TerrainNodeClass *)node)->Special_Set_Transform (rel_transform);
+					}
+
+					//
+					// Remove this node from the system, and add it to our
+					// local sub-node list.
+					//
+					node->Add_Ref ();
+					m_Sections.Add (node);
+					NodeMgrClass::Remove_Node (node);
+					::Get_File_Mgr ()->Update (node, true);
+
+				} else {
+
+					::Get_Scene_Editor ()->Delete_Node (node, false);
+
+					CString message;
+					message.Format ("Unable to create physics object for placeholder %s.\r\n", (LPCTSTR)preset_name);
+					::Output_Message (message);
+				}
+			}
+
+		} else {
+
+			CString message;
+			message.Format ("Unable to find preset for placeholder %s.\r\n", (LPCTSTR)preset_name);
+			::Output_Message (message);
+		}
+	}
+
+	return ;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Update_Cached_Vis_IDs
+//
+/////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Update_Cached_Vis_IDs (void)
+{
+	//
+	//	Pass this call onto all subobjects
+	//
+	for (int index = 0; index < m_Sections.Count (); index ++) {
+		NodeClass *node = m_Sections[index];
+		if (node != NULL) {
+			node->Update_Cached_Vis_IDs ();
+		}
+	}
+
+	Build_Section_ID_List ();
+	return ;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//
+//	Reload
+//
+/////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Reload (void)
+{
+	NodeClass::Reload ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//
+//	Pre_Export
+//
+//////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Pre_Export (void)
+{
+	NodeClass::Pre_Export ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//
+//	Post_Export
+//
+//////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::Post_Export (void)
+{
+	NodeClass::Post_Export ();
+	return ;
+}
+
+
+//////////////////////////////////////////////////////////////////////
+//
+//	Is_A_Child_Node
+//
+//////////////////////////////////////////////////////////////////////
+bool
+TerrainNodeClass::Is_A_Child_Node (NodeClass *node) const
+{
+	bool retval = false;
+
+	//
+	//	Test each sub object
+	//
+	for (int index = 0; retval == false && index < m_Sections.Count (); index ++) {
+		NodeClass *curr_node = m_Sections[index];
+		if (curr_node != NULL) {
+			
+			//
+			//	Is this the node we are looking for?
+			//
+			if (curr_node == node) {
+				retval = true;
+			} else {
+				
+				//
+				//	Pass this call onto the child
+				//
+				retval = curr_node->Is_A_Child_Node (node);
+			}			
+		}
+	}
+
+	return retval;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+//
+//	On_Post_Load
+//
+///////////////////////////////////////////////////////////////////////
+void
+TerrainNodeClass::On_Post_Load (void)
+{
+	m_TerrainSectionInfo.Initialize_Virgin_Sections ();
+
+	//
+	//	Transform the terrain to its new position
+	//
+	if (m_IsProxied == false && LoadedTransform != Matrix3D::Identity) {
+		Set_Transform (LoadedTransform);	
+	}
+
+	return ;
+}
+
+
+//******************************************************************************//
+//*
+//*	Start of TerrainSectionNodeClass
+//*
+//******************************************************************************//
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Get_Factory
+//
+////////////////////////////////////////////////////////////////
+const PersistFactoryClass &
+TerrainSectionNodeClass::Get_Factory (void) const
+{	
+	return _TerrainSectionNodePersistFactory;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Create
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainSectionNodeClass::Create (RenderObjClass *render_obj)
+{
+	MEMBER_RELEASE (m_PhysObj);
+	
+	//
+	// Create the new terrain section from the render object
+	//
+	m_PhysObj = new StaticPhysClass;
+	m_PhysObj->Set_Model (render_obj);
+	m_PhysObj->Set_Transform (render_obj->Get_Transform ());	
+
+	//
+	//	Give this section an ID (and pass it along to its physics obj)
+	//
+	m_PhysObj->Set_ID (Get_ID ());
+	Set_ID (NodeMgrClass::Get_Node_ID (Get_Type ()));
+	m_PhysObj->Peek_Model ()->Set_User_Data ((PVOID)&m_HitTestInfo, FALSE);
+
+	//
+	//	Give the new node a name
+	//
+	Set_Name (render_obj->Get_Name ());
+	return ;
+}
+
+
+////////////////////////////////////////////////////////////////
+//
+//	Set_Transform
+//
+////////////////////////////////////////////////////////////////
+void
+TerrainSectionNodeClass::Set_Transform (const Matrix3D &tm)
+{
+	if (Terrain == NULL) {
+		return ;
+	}
+
+	//
+	//	Get the inverse tranform of the terrain section
+	//
+	Matrix3D curr_tm = Get_Transform ();
+	Matrix3D inv_tm;
+	curr_tm.Get_Orthogonal_Inverse (inv_tm);
+
+	Matrix3D delta_tm = inv_tm * tm;
+
+	//
+	//	Transform the terrain object relative to this section
+	//
+	Matrix3D terrain_obj_tm			= Terrain->Get_Transform ();
+	//Matrix3D rel_terrain_obj_tm	= inv_tm * terrain_obj_tm;
+
+	Matrix3D new_tm = terrain_obj_tm * delta_tm;
+	Terrain->Set_Transform (new_tm);
+	return ;
+}