tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Tools/LevelEdit/TerrainNode.cpp

992 lines
24 KiB
C++
Raw Permalink Blame History

/*
** 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 ;
}
Reference in a new issue View git blame Copy permalink