/* ** 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 . */ /*********************************************************************************************** *** 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 : WWPhys * * * * $Archive:: /Commando/Code/wwphys/movephys.cpp $* * * * Author:: Greg Hjelstrom * * * * $Modtime:: 11/24/01 5:40p $* * * * $Revision:: 47 $* * * *---------------------------------------------------------------------------------------------* * Functions: * * MoveablePhysClass::MoveablePhysClass -- Constructor * * MoveablePhysClass::~MoveablePhysClass -- Destructor * * MoveablePhysClass::Post_Timestep_Process -- perform post-timestep processing * * MoveablePhysClass::Update_Shadow -- Update the shadow for this object * * MoveablePhysClass::Allocate_Shadow -- ensure that a shadow object is allocated * * MoveablePhysClass::Release_Shadow -- release the shadow object * * MoveablePhysClass::Get_Shadow_Blob_Box -- Return the object space AABox for the shadow * * MoveablePhysClass::Link_To_Carrier -- Link this object to a carrier object * * MoveablePhysClass::Peek_Carrier_Sub_Object -- returns the carrier sub object pointer * * MoveablePhysClass::Save -- persistant object save support * * MoveablePhysClass::Load -- persistant object load support * * MoveablePhysClass::On_Post_Load -- Post-Load callback for MoveablePhysClass * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #if defined(_MSC_VER) #pragma once #endif #include "movephys.h" #include "colmathaabox.h" #include "pscene.h" #include "dyntexproject.h" #include "chunkio.h" #include "saveload.h" #include "wwhack.h" #include "assetmgr.h" #include "physcoltest.h" #include "light.h" DECLARE_FORCE_LINK(movephys); #define SINGLE_SHADOW_CODE 1 #define TRUE_PERSPECTIVE_SHADOWS 0 /*********************************************************************************************** ** ** MoveablePhysClass Implementation ** ***********************************************************************************************/ /* ** Chunk ID's used by MoveablePhysClass */ enum { MOVEABLE_CHUNK_PHYS = 0x00803000, // obsolete parent class MOVEABLE_CHUNK_VARIABLES, MOVEABLE_CHUNK_DYNAMICPHYS, // current parent class MOVEABLE_VARIABLE_MASS = 0x00, MOVEABLE_VARIABLE_GRAVSCALE, MOVEABLE_VARIABLE_ELASTICITY, MOVEABLE_VARIABLE_CONTROLLER, MOVEABLE_VARIABLE_CARRIER, }; /*********************************************************************************************** * MoveablePhysClass::MoveablePhysClass -- Constructor * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * *=============================================================================================*/ MoveablePhysClass::MoveablePhysClass(void) : Mass(1.0f), MassInv(1.0f), GravScale(1.0f), Elasticity(0.5f), Controller(NULL), Carrier(NULL), CarrierSubObject(NULL), ShadowManager(*this) { } /*********************************************************************************************** * MoveablePhysClass::~MoveablePhysClass -- Destructor * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 12/21/99 gth : Created. * *=============================================================================================*/ MoveablePhysClass::~MoveablePhysClass(void) { Link_To_Carrier(NULL); } /*********************************************************************************************** * MoveablePhysClass::Init -- inits from a MoveablePhysDefClass * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * *=============================================================================================*/ void MoveablePhysClass::Init(const MoveablePhysDefClass & def) { Mass = def.Mass; MassInv = 1.0f / Mass; GravScale = def.GravScale; Elasticity = def.Elasticity; DynamicPhysClass::Init(def); } /*********************************************************************************************** * MoveablePhysClass::Definition_Changed -- recopy an cached constants from our def * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * *=============================================================================================*/ void MoveablePhysClass::Definition_Changed(void) { DynamicPhysClass::Definition_Changed(); MoveablePhysDefClass * def = (MoveablePhysDefClass *)Definition; Mass = def->Mass; MassInv = 1.0f / Mass; GravScale = def->GravScale; Elasticity = def->Elasticity; } /*********************************************************************************************** * MoveablePhysClass::Post_Timestep_Process -- perform post-timestep processing * * * * MoveablePhysClass's update their shadow objects in post-timestep if needed. * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 1/4/00 gth : Created. * *=============================================================================================*/ void MoveablePhysClass::Post_Timestep_Process(void) { ShadowManager.Update_Shadow(); } /*********************************************************************************************** * MoveablePhysClass::Get_Shadow_Blob_Box -- Return the object space AABox for the shadow * * * * This is only the default implementation which doesn't really do anything useful. Derived * * classes should over-ride this!!! * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 1/4/00 gth : Created. * *=============================================================================================*/ void MoveablePhysClass::Get_Shadow_Blob_Box(AABoxClass * set_obj_space_box) { // NOTE: derived classes should really override this!!! WWASSERT(set_obj_space_box != NULL); set_obj_space_box->Center.Set(0,0,0); set_obj_space_box->Extent.Set(1,1,1); } /*********************************************************************************************** * MoveablePhysClass::Link_To_Carrier -- Link this object to a carrier object * * * * This function will make this object move with the specified carrier object. You can * * pass in NULL to clear out the linkage as well. * * * * INPUT: * * carrier - physics object that this object is "standing" on. * * carrier_sub_obj - possible render object within the physics object. This makes a * * if groundobj is an animated static object for example. * * * * OUTPUT: * * * * WARNINGS: * * This is the only function that should ever call Internal_Link_Rider or Internal_Unlink...* * * * HISTORY: * * 2/11/2000 gth : Created. * *=============================================================================================*/ void MoveablePhysClass::Link_To_Carrier(PhysClass * carrier,RenderObjClass * carrier_sub_obj) { // If this is the same carrier we already have, just return if ((Carrier == carrier) && (CarrierSubObject == carrier_sub_obj)) return; // If we had a different carrier, unlink from it if (Carrier != NULL) { Carrier->Internal_Unlink_Rider(this); Carrier = NULL; CarrierSubObject = NULL; } if (carrier) { if (carrier->Internal_Link_Rider(this) == true) { // only track carriers who are tracking us! Carrier = carrier; CarrierSubObject = carrier_sub_obj; } } } /*********************************************************************************************** * MoveablePhysClass::Peek_Carrier_Object -- returns the carrier object pointer * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 8/15/2001 tss : Created. * *=============================================================================================*/ PhysClass * MoveablePhysClass::Peek_Carrier_Object(void) { return Carrier; } /*********************************************************************************************** * MoveablePhysClass::Peek_Carrier_Sub_Object -- returns the carrier sub object pointer * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 7/24/2000 gth : Created. * *=============================================================================================*/ RenderObjClass * MoveablePhysClass::Peek_Carrier_Sub_Object(void) { return CarrierSubObject; } /*********************************************************************************************** * MoveablePhysClass::Cinematic_Move_To -- attempts to teleport to the desired transform * * * * This function attempts to teleport the object to the desired transform and "pushes" all * * dynamic objects out of the way if possible. * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 7/24/2000 gth : Created. * *=============================================================================================*/ bool MoveablePhysClass::Cinematic_Move_To(const Matrix3D &new_tm) { int cinematic_move_mode = MoveablePhysDefClass::CINEMATIC_COLLISION_PUSH; if (Get_MoveablePhysDef() != NULL) { cinematic_move_mode = Get_MoveablePhysDef()->CinematicCollisionMode; } // // Check if we can teleport to the desired location. // NonRefPhysListClass intersection_list; bool ok = false; if (cinematic_move_mode == MoveablePhysDefClass::CINEMATIC_COLLISION_NONE) { ok = true; } else { ok = Can_Teleport(new_tm, true, &intersection_list); } // // Handle the intersection if needed // if (!ok) { if (cinematic_move_mode == MoveablePhysDefClass::CINEMATIC_COLLISION_PUSH) { // // Try to shove everyone out of our way! // NOTE: this won't work for objects where orientation matters and the object // is rotating as part of the teleportation. May have to implement this // separately for RBody... // Vector3 position; Get_Position(&position); Vector3 move = new_tm.Get_Translation() - position; NonRefPhysListIterator it(&intersection_list); while (!it.Is_Done()) { it.Peek_Obj()->Push(move); it.Next(); } } else if (cinematic_move_mode == MoveablePhysDefClass::CINEMATIC_COLLISION_KILL ) { // // Try to kill all objects intersecting us at the destination point // NonRefPhysListIterator it(&intersection_list); while (!it.Is_Done()) { // // (gth) rbody objects are currently including static objects in // the list of intersected objects. Don't kill them please. // if (it.Peek_Obj()->As_DynamicPhysClass() != NULL) { it.Peek_Obj()->Expire(); } it.Next(); } } // // check one more time unless we are in "stop" mode // if (cinematic_move_mode != MoveablePhysDefClass::CINEMATIC_COLLISION_STOP) { ok = Can_Teleport(new_tm, true); } } // // If the position is clear, teleport there // if (ok) { Set_Transform(new_tm); } return ok; } /*********************************************************************************************** * MoveablePhysClass::Save -- persistant object save support * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 1/4/00 gth : Created. * *=============================================================================================*/ bool MoveablePhysClass::Save(ChunkSaveClass &csave) { csave.Begin_Chunk(MOVEABLE_CHUNK_DYNAMICPHYS); DynamicPhysClass::Save(csave); csave.End_Chunk(); csave.Begin_Chunk(MOVEABLE_CHUNK_VARIABLES); WRITE_MICRO_CHUNK(csave,MOVEABLE_VARIABLE_MASS,Mass); WRITE_MICRO_CHUNK(csave,MOVEABLE_VARIABLE_GRAVSCALE,GravScale); WRITE_MICRO_CHUNK(csave,MOVEABLE_VARIABLE_ELASTICITY,Elasticity); if (Controller != NULL) { WRITE_MICRO_CHUNK(csave,MOVEABLE_VARIABLE_CONTROLLER,Controller); } if (Carrier != NULL) { WRITE_MICRO_CHUNK(csave,MOVEABLE_VARIABLE_CARRIER,Carrier); } csave.End_Chunk(); return true; } /*********************************************************************************************** * MoveablePhysClass::Load -- persistant object load support * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 1/4/00 gth : Created. * *=============================================================================================*/ bool MoveablePhysClass::Load(ChunkLoadClass &cload) { Controller = NULL; Carrier = NULL; while (cload.Open_Chunk()) { switch(cload.Cur_Chunk_ID()) { case MOVEABLE_CHUNK_PHYS: PhysClass::Load(cload); break; case MOVEABLE_CHUNK_DYNAMICPHYS: DynamicPhysClass::Load(cload); break; case MOVEABLE_CHUNK_VARIABLES: while (cload.Open_Micro_Chunk()) { switch(cload.Cur_Micro_Chunk_ID()) { READ_MICRO_CHUNK(cload,MOVEABLE_VARIABLE_MASS,Mass); READ_MICRO_CHUNK(cload,MOVEABLE_VARIABLE_GRAVSCALE,GravScale); READ_MICRO_CHUNK(cload,MOVEABLE_VARIABLE_ELASTICITY,Elasticity); READ_MICRO_CHUNK(cload,MOVEABLE_VARIABLE_CONTROLLER,Controller); READ_MICRO_CHUNK(cload,MOVEABLE_VARIABLE_CARRIER,Carrier); } cload.Close_Micro_Chunk(); } break; default: WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__)); break; } cload.Close_Chunk(); } if (Controller != NULL) { REQUEST_POINTER_REMAP((void**)&Controller); } if (Carrier != NULL) { REQUEST_POINTER_REMAP((void**)&Carrier); } SaveLoadSystemClass::Register_Post_Load_Callback(this); if (Mass < 0.01f) { Mass = 0.01f; } MassInv = 1.0f / Mass; return true; } /*********************************************************************************************** * MoveablePhysClass::On_Post_Load -- Post-Load callback for MoveablePhysClass * * * * INPUT: * * * * OUTPUT: * * * * WARNINGS: * * * * HISTORY: * * 2/11/2000 gth : Created. * *=============================================================================================*/ void MoveablePhysClass::On_Post_Load(void) { DynamicPhysClass::On_Post_Load(); // Force our carrier to get correctly linked up, the way I do this // is to just clear it out and call the Set_Carrier function again. PhysClass * tmp_carrier = Carrier; Carrier = NULL; Link_To_Carrier(tmp_carrier); } /*********************************************************************************************** ** ** MoveablePhysDefClass Implementation ** ***********************************************************************************************/ /* ** Chunk ID's used by MoveablePhysDefClass */ enum { MOVEABLEPHYSDEF_CHUNK_PHYSDEF = 0x04486000, // obsolete parent class MOVEABLEPHYSDEF_CHUNK_VARIABLES, MOVEABLEPHYSDEF_CHUNK_DYNAMICPHYSDEF, // current parent class MOVEABLEPHYSDEF_VARIABLE_MASS = 0x00, MOVEABLEPHYSDEF_VARIABLE_GRAVSCALE, MOVEABLEPHYSDEF_VARIABLE_ELASTICITY, MOVEABLEPHYSDEF_VARIABLE_CINEMATICCOLLISIONMODE, }; MoveablePhysDefClass::MoveablePhysDefClass(void) : Mass(1.0f), GravScale(1.0f), Elasticity(0.1f), CinematicCollisionMode(CINEMATIC_COLLISION_PUSH) { // make our parameters editable! FLOAT_EDITABLE_PARAM(MoveablePhysDefClass, Mass, 0.01f, 100000.0f); FLOAT_EDITABLE_PARAM(MoveablePhysDefClass, GravScale, 0.0f, 10.0f); FLOAT_EDITABLE_PARAM(MoveablePhysDefClass, Elasticity, 0.0f, 1.0f); #ifdef PARAM_EDITING_ON EnumParameterClass *cinematic_param = new EnumParameterClass(&CinematicCollisionMode); cinematic_param->Set_Name ("CinematicCollisionMode"); cinematic_param->Add_Value("NONE",CINEMATIC_COLLISION_NONE); cinematic_param->Add_Value("STOP",CINEMATIC_COLLISION_STOP); cinematic_param->Add_Value("PUSH",CINEMATIC_COLLISION_PUSH); cinematic_param->Add_Value("KILL",CINEMATIC_COLLISION_KILL); GENERIC_EDITABLE_PARAM( MoveablePhysDefClass, cinematic_param); #endif } bool MoveablePhysDefClass::Save(ChunkSaveClass &csave) { csave.Begin_Chunk(MOVEABLEPHYSDEF_CHUNK_DYNAMICPHYSDEF); DynamicPhysDefClass::Save(csave); csave.End_Chunk(); csave.Begin_Chunk(MOVEABLEPHYSDEF_CHUNK_VARIABLES); WRITE_MICRO_CHUNK(csave,MOVEABLEPHYSDEF_VARIABLE_MASS,Mass); WRITE_MICRO_CHUNK(csave,MOVEABLEPHYSDEF_VARIABLE_GRAVSCALE,GravScale); WRITE_MICRO_CHUNK(csave,MOVEABLEPHYSDEF_VARIABLE_ELASTICITY,Elasticity); WRITE_MICRO_CHUNK(csave,MOVEABLEPHYSDEF_VARIABLE_CINEMATICCOLLISIONMODE,CinematicCollisionMode); csave.End_Chunk(); return true; } bool MoveablePhysDefClass::Load(ChunkLoadClass &cload) { while (cload.Open_Chunk()) { switch(cload.Cur_Chunk_ID()) { case MOVEABLEPHYSDEF_CHUNK_PHYSDEF: PhysDefClass::Load(cload); break; case MOVEABLEPHYSDEF_CHUNK_DYNAMICPHYSDEF: DynamicPhysDefClass::Load(cload); break; case MOVEABLEPHYSDEF_CHUNK_VARIABLES: while (cload.Open_Micro_Chunk()) { switch(cload.Cur_Micro_Chunk_ID()) { READ_MICRO_CHUNK(cload,MOVEABLEPHYSDEF_VARIABLE_MASS,Mass); READ_MICRO_CHUNK(cload,MOVEABLEPHYSDEF_VARIABLE_GRAVSCALE,GravScale); READ_MICRO_CHUNK(cload,MOVEABLEPHYSDEF_VARIABLE_ELASTICITY,Elasticity); READ_MICRO_CHUNK(cload,MOVEABLEPHYSDEF_VARIABLE_CINEMATICCOLLISIONMODE,CinematicCollisionMode); } cload.Close_Micro_Chunk(); } break; default: WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__)); break; } cload.Close_Chunk(); } return true; } bool MoveablePhysDefClass::Is_Type(const char * type_name) { if (stricmp(type_name,MoveablePhysDefClass::Get_Type_Name()) == 0) { return true; } else { return DynamicPhysDefClass::Is_Type(type_name); } }