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/wwphys/pscene.cpp

2155 lines
101 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** 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 : WWPhys *
* *
* $Archive:: /Commando/Code/wwphys/pscene.cpp $*
* *
* Author:: Greg Hjelstrom *
* *
* $Modtime:: 3/28/02 6:48p $*
* *
* $Revision:: 218 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* PhysicsSceneClass::PhysicsSceneClass -- Constructor *
* PhysicsSceneClass::~PhysicsSceneClass -- Destructor *
* PhysicsSceneClass::Update -- Simulates the entire scene forward one timestep *
* PhysicsSceneClass::Add_Dynamic_Object -- Adds a dynamic object to the scene *
* PhysicsSceneClass::Internal_Add_Dynamic_Object -- internal function finishes adding a dyn *
* PhysicsSceneClass::Add_Static_Object -- Adds a static object to the scene *
* PhysicsSceneClass::Internal_Add_Static_Object -- internal add static object... *
* PhysicsSceneClass::Add_Static_Light -- Adds a static light to the system *
* PhysicsSceneClass::Internal_Add_Static_Light -- internal add static light... *
* PhysicsSceneClass::Delayed_Remove_Object -- registers an object for removal *
* PhysicsSceneClass::Process_Release_List -- Removes all objects in the ReleaseList *
* PhysicsSceneClass::Remove_Object -- Remove an object from the scene *
* PhysicsSceneClass::Remove_All -- Removes all objects from the scene *
* PhysicsSceneClass::Contains -- Tests if the scene contains the given object *
* PhysicsSceneClass::Get_Dynamic_Object_Iterator -- returns an iterator for the dynamic obj *
* PhysicsSceneClass::Get_Static_Object_Iterator -- return an iterator for the static objs *
* PhysicsSceneClass::Get_Static_Anim_Object_Iterator -- returns an iterator for static anim *
* PhysicsSceneClass::Get_Static_Light_Iterator -- returns an iterator for static lights *
* PhysicsSceneClass::Get_Static_Projector_Iterator -- returns an iterator for static projec *
* PhysicsSceneClass::Get_Dynamic_Projector_Iterator -- returns an iterator for dynamic proj *
* PhysicsSceneClass::Add_To_Dirty_Cull_List -- adds something to the "dirty cull" list *
* PhysicsSceneClass::Remove_From_Dirty_Cull_List -- removes an object from the dirty cull l *
* PhysicsSceneClass::Is_In_Dirty_Cull_List -- tests whether an object is in the dirty cull *
* PhysicsSceneClass::Add_Render_Object -- Adds a render object to the scene *
* PhysicsSceneClass::Remove_Render_Object -- removes a render object from the scene *
* PhysicsSceneClass::Register -- rengisters given render object *
* PhysicsSceneClass::Unregister -- Unregisters the given render object *
* PhysicsSceneClass::Set_Vis_Sample_Point -- Set the current vis sample point *
* PhysicsSceneClass::Pre_Render_Processing -- processing which occurs prior to rendering *
* PhysicsSceneClass::Post_Render_Processing -- processing that occurs after rendering *
* PhysicsSceneClass::Optimize_LODs -- Set the LOD level for each object *
* PhysicsSceneClass::Render -- Render the scene *
* PhysicsSceneClass::Render_Objects -- Render the visible objects *
* PhysicsSceneClass::Render_Object -- Render an individual object *
* PhysicsSceneClass::Render_Backface_Occluders -- Render backfaces of all occluders *
* PhysicsSceneClass::Re_Partition_Static_Objects -- partition the static objects *
* PhysicsSceneClass::Re_Partition_Static_Lights -- partition the static lights *
* PhysicsSceneClass::Re_Partition_Dynamic_Culling_System -- partition the dynamic culling s *
* PhysicsSceneClass::Re_Partition_Static_Projectors -- partition the static projectors *
* PhysicsSceneClass::Update_Culling_System_Bounding_Boxes -- updates the cull systems *
* PhysicsSceneClass::Get_Level_Extents -- returns the bounds of the level *
* PhysicsSceneClass::Set_Polygon_Budgets -- set the budgets for the LOD system *
* PhysicsSceneClass::Get_Polygon_Budgets -- returns the budgets for the LOD system *
* PhysicsSceneClass::Per_Frame_Statistics_Update -- statistics tracking *
* PhysicsSceneClass::Get_Statistics -- returns statistics *
* PhysicsSceneClass::Find_Static_Object -- Find static object with the given ID *
* PhysicsSceneClass::Shatter_Mesh -- Clips a mesh into pieces and scatters them *
* PhysicsSceneClass::Verify_Culling_Systems -- Verify the culling systems *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "pscene.h"
#include "rinfo.h"
#include "light.h"
#include "wwdebug.h"
#include "wwhack.h"
#include "wwprofile.h"
#include "wwmemlog.h"
#include "physgridcull.h"
#include "staticaabtreecull.h"
#include "dynamicaabtreecull.h"
#include "lightcull.h"
#include "camera.h"
#include "wwphystrig.h"
#include "vertmaterial.h"
#include "predlod.h"
#include "widgets.h"
#include "renderobjphys.h"
#include "pathfind.h"
#include "lightexclude.h"
#include "physdecalsys.h"
#include "quat.h"
#include "shader.h"
#include "lookuptable.h"
#include "shattersystem.h"
#include "projectile.h"
#include "staticphys.h"
#include "vistable.h"
#include "meshmdl.h"
#include "camerashakesystem.h"
#include "lightenvironment.h"
#include "dx8wrapper.h"
#include "physresourcemgr.h"
#include "phys3.h"
#include "umbrasupport.h"
#define STATISTICS_FRAMES 20 // number of frames to average statistics across
#define SHATTER_DEBUG 0 // debugging, freeze shattered particles in place for 60sec
/*
** Static members of PhysicsSceneClass
*/
bool PhysicsSceneClass::AllowCollisionFlags[NUM_COLLISION_FLAGS];
PhysicsSceneClass * PhysicsSceneClass::TheScene = NULL;
/*
** Constants
*/
const float MAX_TIMESTEP = 1.0f / 15.0f;
const Vector3 MIN_GRID_CELL_SIZE(15.0f,15.0f,15.0f);
const int MAX_GRID_CELL_COUNT = 8192;
const float MAX_DYNAMIC_OBJ_RADIUS = 5.0f;
const int DEFAULT_DYNAMIC_LOD_BUDGET = 4000;
const int DEFAULT_STATIC_LOD_BUDGET = 4000;
/******************************************************************************************
**
**
** PhysicsSceneClass Implementation
**
**
******************************************************************************************/
/***********************************************************************************************
* PhysicsSceneClass::PhysicsSceneClass -- Constructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
PhysicsSceneClass::PhysicsSceneClass(void) :
FrameNum(0),
LastCameraPosition(0,0,0),
LastValidVisId(-1),
DebugDisplayEnabled(false),
ProjectorDebugDisplayEnabled(false),
DirtyCullDebugDisplayEnabled(false),
LightingDebugDisplayEnabled(false),
StaticCullingSystem(NULL),
DynamicCullingSystem(NULL),
StaticLightingSystem(NULL),
StaticProjectorCullingSystem(NULL),
DynamicProjectorCullingSystem(NULL),
DynamicPolyBudget(DEFAULT_DYNAMIC_LOD_BUDGET),
StaticPolyBudget(DEFAULT_STATIC_LOD_BUDGET),
LightingMode(LIGHTING_MODE_CHEAP),
SceneAmbientLight(0.5f,0.5f,0.5f),
UseSun(false),
SunLight(NULL),
VisEnabled(true),
VisInverted(false),
VisQuickAndDirty(false),
VisResetNeeded(false),
VisSectorDisplayEnabled(false),
VisSectorHistoryEnabled(false),
VisGridDisplayMode(VIS_GRID_DISPLAY_NONE),
VisSectorMissing(false),
VisSectorFallbackEnabled(true),
BackfaceDebugEnabled(false),
VisSamplePointLocked(false),
LockedVisSamplePoint(0,0,0),
VisCamera(NULL),
CurrentVisTable(NULL),
StaticProjectorsEnabled(false),
DynamicProjectorsEnabled(false),
ShadowMode(SHADOW_MODE_NONE),
ShadowAttenStart(25.0f),
ShadowAttenEnd(40.0f),
ShadowNormalIntensity(0.45f),
ShadowBlobTexture(NULL),
ShadowCamera(NULL),
ShadowRenderContext(NULL),
ShadowMaterialPass(NULL),
ShadowResWidth(128),
ShadowResHeight(128),
DecalSystem(NULL),
Pathfinder(NULL),
CameraShakeSystem(NULL),
HighlightMaterialPass(NULL),
UpdateOnlyVisibleObjects(false),
CurrentFrameNumber(0)
{
WWASSERT_PRINT(TheScene == NULL,"Only one instance of the PhysicsSceneClass is allowed.\r\n");
WWMEMLOG(MEM_PHYSICSDATA);
TheScene = this;
/*
** Initialize Umbra
*/
#if (UMBRASUPPORT)
UmbraSupport::Init();
#endif
/*
** Clear the collision flags
*/
memset(AllowCollisionFlags,0,NUM_COLLISION_FLAGS);
/*
** Allocate culling systems
*/
StaticCullingSystem = new StaticAABTreeCullClass(this);
DynamicCullingSystem = new PhysGridCullClass(this);
DynamicObjVisSystem = new DynamicAABTreeCullClass(this);
StaticLightingSystem = new StaticLightCullClass;
StaticProjectorCullingSystem = new TypedAABTreeCullSystemClass<TexProjectClass>;
DynamicProjectorCullingSystem = new TypedGridCullSystemClass<TexProjectClass>;
/*
** Allocate pathfind object
*/
Pathfinder = new PathfindClass;
/*
** Allocate the camera shake system
*/
CameraShakeSystem = new CameraShakeSystemClass;
/*
** Allocate the sun light
*/
SunLight = NEW_REF(LightClass,(LightClass::DIRECTIONAL));
Reset_Sun_Light();
/*
** Initialize the debug code
*/
WidgetSystem::Init_Debug_Widgets();
/*
** Allocate decal resources
*/
Allocate_Decal_Resources();
}
/***********************************************************************************************
* PhysicsSceneClass::~PhysicsSceneClass -- Destructor *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
PhysicsSceneClass::~PhysicsSceneClass(void)
{
Remove_All();
delete StaticCullingSystem;
delete DynamicCullingSystem;
delete DynamicObjVisSystem;
delete StaticLightingSystem;
delete StaticProjectorCullingSystem;
delete DynamicProjectorCullingSystem;
delete Pathfinder;
delete CameraShakeSystem;
REF_PTR_RELEASE(SunLight);
Release_Vis_Resources();
Release_Projector_Resources();
Release_Decal_Resources();
WidgetSystem::Release_Debug_Widgets();
WWASSERT(TheScene == this);
TheScene = NULL;
/*
** Shutdown UMBRA
*/
#if (UMBRASUPPORT)
UmbraSupport::Shutdown();
#endif
}
/***********************************************************************************************
* PhysicsSceneClass::Update -- Simulates the entire scene forward one timestep *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Update(float dt,int frameid)
{
WWPROFILE("PhysicsScene::Update");
Generate_Static_Shadow_Projectors();
FrameNum = frameid;
if (dt == 0.0f) {
return;
}
/*
** Timestep all of the physics objects
*/
{
WWPROFILE("Timestep");
float remaining = dt;
while (remaining > 0) {
float step = min(remaining,MAX_TIMESTEP);
/*
** Loop through each object telling each to time-step itself.
*/
RefPhysListIterator it(&TimestepList);
for (it.First(); !it.Is_Done(); it.Next()) {
PhysClass* phys_obj=it.Peek_Obj();
// Little optimization hack - only update vehicles that are visible (for now update all other physics
// objects regardless of the visibility to avoid problems, vehicles are the most expensive anyway).
// This same thing is done to Post Timestep couple lines lower.
if (phys_obj->Is_Object_Simulating()) {
if (!UpdateOnlyVisibleObjects ||
phys_obj->Get_Last_Visible_Frame()==CurrentFrameNumber ||
!phys_obj->As_VehiclePhysClass()) {
phys_obj->Timestep(step);
}
}
}
remaining -= step;
}
}
{
WWPROFILE("Post Timestep");
RefPhysListIterator it(&TimestepList);
for (it.First(); !it.Is_Done(); it.Next()) {
// if (it.Peek_Obj()->Is_Object_Simulating()) {
// if (!UpdateOnlyVisibleObjects || it.Peek_Obj()->Get_Last_Visible_Frame()==CurrentFrameNumber) {
PhysClass* phys_obj=it.Peek_Obj();
if (phys_obj->Is_Object_Simulating()) {
if (!UpdateOnlyVisibleObjects ||
phys_obj->Get_Last_Visible_Frame()==CurrentFrameNumber ||
!phys_obj->As_VehiclePhysClass()) {
phys_obj->Post_Timestep_Process();
}
}
}
}
/*
** Timestep the camera shakers
*/
{
WWPROFILE("CameraShakeSystem");
CameraShakeSystem->Timestep(dt);
}
/*
** Timestep the material effects
*/
{
WWPROFILE("MaterialEffects");
MaterialEffectClass::Timestep_All_Effects(dt);
}
/*
** Process pending release requests
** Put here prior to rendering to insure items won't draw too many times.
*/
Process_Release_List();
CurrentFrameNumber++;
}
/***********************************************************************************************
* PhysicsSceneClass::Add_Dynamic_Object -- Adds a dynamic object to the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Add_Dynamic_Object(PhysClass * newobj)
{
WWASSERT(newobj != NULL);
WWASSERT(newobj->Peek_Model() != NULL);
WWASSERT(newobj->Get_Culling_System() == NULL);
// Add the object to the dynamic culling system
DynamicCullingSystem->Add_Object(newobj);
// Add the object to the lists in the physics scene
Internal_Add_Dynamic_Object(newobj);
// Clean up any cached visibility data that may have been in the object
DynamicPhysClass * dynobj = newobj->As_DynamicPhysClass();
WWASSERT(dynobj != NULL);
if (dynobj != NULL) {
dynobj->Update_Visibility_Status();
}
}
/***********************************************************************************************
* PhysicsSceneClass::Internal_Add_Dynamic_Object -- internal function finishes adding a dynam *
* *
* This function is called both by the loading code and the Add_Dynamic_Object function. *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Internal_Add_Dynamic_Object(PhysClass * newobj)
{
// Add the object to the appropriate lists
ObjList.Add(newobj);
SceneClass::Add_Render_Object(newobj->Peek_Model());
if (newobj->Needs_Timestep()) {
TimestepList.Add(newobj);
}
}
/***********************************************************************************************
* PhysicsSceneClass::Add_Static_Object -- Adds a static object to the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Add_Static_Object(StaticPhysClass * newtile,int cull_node_id/*=-1*/)
{
WWASSERT(newtile != NULL);
WWASSERT(newtile->Peek_Model() != NULL);
WWASSERT(newtile->Get_Culling_System() == NULL);
// Add the object to the static culling system
StaticCullingSystem->Add_Object(newtile,cull_node_id);
// Add the object to the lists in the physics scene
Internal_Add_Static_Object(newtile);
}
/***********************************************************************************************
* PhysicsSceneClass::Internal_Add_Static_Object -- internal add static object... *
* *
* This function is called by both the loading code and the Add_Static_Object function *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Internal_Add_Static_Object(StaticPhysClass * newtile)
{
// Add the object to the appropriate lists
StaticObjList.Add(newtile);
SceneClass::Add_Render_Object(newtile->Peek_Model());
if (newtile->Needs_Timestep()) {
TimestepList.Add(newtile);
}
if (newtile->As_StaticAnimPhysClass() != NULL) {
StaticAnimList.Add(newtile);
}
}
/***********************************************************************************************
* PhysicsSceneClass::Add_Static_Light -- Adds a static light to the system *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Add_Static_Light(LightPhysClass * newlight,int cull_node_id/*=-1*/)
{
WWASSERT(newlight != NULL);
WWASSERT(newlight->Peek_Model() != NULL);
WWASSERT(newlight->Get_Culling_System() == NULL);
// Add the light to the static light culling system
StaticLightingSystem->Add_Object(newlight);
// Add the light to all of the appropriate lists
Internal_Add_Static_Light(newlight);
}
/***********************************************************************************************
* PhysicsSceneClass::Internal_Add_Static_Light -- internal add static light... *
* *
* This function is called by both the loading code and the Add_Static_Light function *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Internal_Add_Static_Light(LightPhysClass * newlight)
{
// Add the object to the appropriate lists
StaticLightList.Add(newlight);
//(gth) hack, I don't want static lights to get registered as vertex processors.
//so don't let the scene class know about them ;-) I should probably come up with
//a better mechanism for this...
//SceneClass::Add_Render_Object(newlight->Peek_Model());
if (newlight->Needs_Timestep()) {
TimestepList.Add(newlight);
}
}
/***********************************************************************************************
* PhysicsSceneClass::Delayed_Remove_Object -- registers an object for removal *
* *
* The object will be released by the scene at the end of the next frame. *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Delayed_Remove_Object(PhysClass * obj)
{
if (!ReleaseList.Contains(obj)) {
ReleaseList.Add(obj);
}
}
/***********************************************************************************************
* PhysicsSceneClass::Process_Release_List -- Removes all objects in the ReleaseList *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Process_Release_List(void)
{
while(!ReleaseList.Is_Empty()) {
PhysClass * obj = ReleaseList.Remove_Head();
Remove_Object(obj);
obj->Release_Ref();
}
}
/***********************************************************************************************
* PhysicsSceneClass::Remove_Object -- Remove an object from the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Remove_Object(PhysClass * obj)
{
// NOTE: sometimes the game tries to 'remove' objects that havent been added...
if (!Contains(obj)) return;
// Assert that the object is valid
WWASSERT(obj != NULL);
WWASSERT(obj->Peek_Model() != NULL);
// Notify the model that it is being removed from the scene
SceneClass::Remove_Render_Object(obj->Peek_Model());
// Notify the observer (if it has one)
if (obj->Get_Observer() != NULL) {
obj->Get_Observer()->Object_Removed_From_Scene(obj);
}
// Pull the object out of any of the "extra-processing" lists
Remove_From_Dirty_Cull_List(obj);
TimestepList.Remove(obj);
StaticAnimList.Remove(obj);
// Pull the physics object out of whatever system it is in
CullSystemClass * cullsys = obj->Get_Culling_System();
if (cullsys == DynamicCullingSystem) {
DynamicCullingSystem->Remove_Object(obj);
ObjList.Remove(obj);
} else if (cullsys == StaticCullingSystem) {
WWASSERT(obj->As_StaticPhysClass() != NULL);
StaticCullingSystem->Remove_Object(obj->As_StaticPhysClass());
StaticObjList.Remove(obj);
} else if (cullsys == StaticLightingSystem) {
WWASSERT(obj->As_LightPhysClass() != NULL);
StaticLightingSystem->Remove_Object(obj->As_LightPhysClass());
StaticLightList.Remove(obj);
} else {
WWASSERT(0); // should never happen!
}
}
/***********************************************************************************************
* PhysicsSceneClass::Remove_All -- Removes all objects from the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Remove_All(void)
{
PhysClass * obj = ObjList.Peek_Head();
while (obj) {
Remove_Object(obj);
obj = ObjList.Peek_Head();
}
StaticPhysClass * tile = (StaticPhysClass *)StaticObjList.Peek_Head();
while (tile) {
Remove_Object(tile);
tile = (StaticPhysClass *)StaticObjList.Peek_Head();
}
LightPhysClass * light = (LightPhysClass *)StaticLightList.Peek_Head();
while(light) {
Remove_Object(light);
light = (LightPhysClass *)StaticLightList.Peek_Head();
}
TexProjectClass * static_proj = StaticProjectorList.Peek_Head();
while(static_proj) {
Remove_Static_Texture_Projector(static_proj);
static_proj = StaticProjectorList.Peek_Head();
}
TexProjectClass * dynamic_proj = DynamicProjectorList.Peek_Head();
while(dynamic_proj) {
Remove_Dynamic_Texture_Projector(dynamic_proj);
dynamic_proj = DynamicProjectorList.Peek_Head();
}
Pathfinder->Reset_Sectors ();
}
/***********************************************************************************************
* PhysicsSceneClass::Contains -- Tests if the scene contains the given object *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
bool PhysicsSceneClass::Contains(PhysClass * obj)
{
if (ObjList.Is_In_List(obj)) return true;
if (StaticObjList.Is_In_List(obj)) return true;
if (StaticLightList.Is_In_List(obj)) return true;
return false;
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Dynamic_Object_Iterator -- returns an iterator for the dynamic objec *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
RefPhysListIterator PhysicsSceneClass::Get_Dynamic_Object_Iterator(void)
{
return RefPhysListIterator(&ObjList);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Static_Object_Iterator -- return an iterator for the static objs *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
RefPhysListIterator PhysicsSceneClass::Get_Static_Object_Iterator(void)
{
return RefPhysListIterator(&StaticObjList);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Static_Anim_Object_Iterator -- returns an iterator for static anim o *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
RefPhysListIterator PhysicsSceneClass::Get_Static_Anim_Object_Iterator(void)
{
return RefPhysListIterator(&StaticAnimList);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Static_Light_Iterator -- returns an iterator for static lights *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
RefPhysListIterator PhysicsSceneClass::Get_Static_Light_Iterator(void)
{
return RefPhysListIterator(&StaticLightList);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Static_Projector_Iterator -- returns an iterator for static projecto *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
TexProjListIterator PhysicsSceneClass::Get_Static_Projector_Iterator(void)
{
return TexProjListIterator(&StaticProjectorList);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Dynamic_Projector_Iterator -- returns an iterator for dynamic projec *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
TexProjListIterator PhysicsSceneClass::Get_Dynamic_Projector_Iterator(void)
{
return TexProjListIterator(&DynamicProjectorList);
}
/***********************************************************************************************
* PhysicsSceneClass::Add_To_Dirty_Cull_List -- adds something to the "dirty cull" list *
* *
* objects in the dirty cull list have their visiblity and cull box re-computed each *
* frame. We should try to keep things like this to a minimum. Particle buffers are *
* an example of something that would end up in the "dirty cull" list *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Add_To_Dirty_Cull_List(PhysClass *obj)
{
DirtyCullList.Add (obj);
}
/***********************************************************************************************
* PhysicsSceneClass::Remove_From_Dirty_Cull_List -- removes an object from the dirty cull lis *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Remove_From_Dirty_Cull_List(PhysClass *obj)
{
DirtyCullList.Remove (obj);
}
/***********************************************************************************************
* PhysicsSceneClass::Is_In_Dirty_Cull_List -- tests whether an object is in the dirty cull li *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 11/29/2000 gth : Created. *
*=============================================================================================*/
bool PhysicsSceneClass::Is_In_Dirty_Cull_List(PhysClass *obj)
{
return DirtyCullList.Contains (obj);
}
/***********************************************************************************************
* PhysicsSceneClass::Add_Render_Object -- Adds a render object to the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* This interface is less efficient than wrapping your render objects in some kind of physics *
* object. *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Add_Render_Object(RenderObjClass * obj)
{
WWMEMLOG(MEM_PHYSICSDATA); // Right category?
// NOTE: The *ONLY* way this code should get activated is when the user
// or some deep dark w3d code is directly adding and removing render objects
// in the physics scene. In this case, I wrap the render objects with
// RenderObjPhysClass's and set the UserData pointer to point back to this
// wrapper.
WWASSERT(obj != NULL);
RenderObjPhysClass * cullnode = NEW_REF(RenderObjPhysClass,());
cullnode->Set_Model(obj);
Add_Dynamic_Object(cullnode);
Add_To_Dirty_Cull_List(cullnode);
//
// Make sure we don't save particle buffers or lines
//
if ((obj->Class_ID () == RenderObjClass::CLASSID_PARTICLEBUFFER) ||
(obj->Class_ID () == RenderObjClass::CLASSID_SEGLINE))
{
cullnode->Enable_Dont_Save(true);
}
cullnode->Release_Ref();
SceneClass::Add_Render_Object(obj);
}
/***********************************************************************************************
* PhysicsSceneClass::Remove_Render_Object -- removes a render object from the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Remove_Render_Object(RenderObjClass * obj)
{
// NOTE: The *ONLY* way this code should get activated is when the user
// or some deep dark w3d code is directly adding and removing render objects
// in the physics scene. In this case, I wrap the render objects with
// RenderObjPhysClass's and set the UserData pointer to point back to this
// wrapper.
SceneClass::Remove_Render_Object(obj);
WWASSERT(obj != NULL);
PhysClass * cullnode = (PhysClass *)obj->Get_User_Data();
WWASSERT(cullnode != NULL);
WWASSERT(cullnode->As_RenderObjPhysClass() != NULL);
Remove_Object(cullnode);
}
/***********************************************************************************************
* PhysicsSceneClass::Register -- rengisters given render object *
* *
* Render objects can be registered for On_Frame_Update calls, added to the vertex *
* processor list, or added to the release list. *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Register(RenderObjClass * obj,RegType for_what)
{
WWASSERT(obj != NULL);
switch (for_what)
{
case ON_FRAME_UPDATE:
UpdateList.Add(obj);
break;
case LIGHT:
VertexProcList.Add(obj);
break;
case RELEASE:
{
if (obj->Get_Container() != NULL) {
obj->Get_Container()->Remove_Sub_Object(obj);
} else {
PhysClass * wrapper = (PhysClass *)obj->Get_User_Data();
/*
** If there is no wrapper, the object isn't actually in the scene so do nothing
*/
if (wrapper != NULL) {
Delayed_Remove_Object(wrapper);
}
}
}
break;
}
}
/***********************************************************************************************
* PhysicsSceneClass::Unregister -- Unregisters the given render object *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Unregister(RenderObjClass * obj,RegType for_what)
{
WWASSERT(obj != NULL);
switch (for_what)
{
case ON_FRAME_UPDATE:
UpdateList.Remove(obj);
break;
case LIGHT:
VertexProcList.Remove(obj);
break;
case RELEASE:
WWASSERT_PRINT(0,("Error! Object %s tried to un-register from the release list\r\n",obj->Get_Name()));
break;
}
}
/***********************************************************************************************
* PhysicsSceneClass::Pre_Render_Processing -- processing which occurs prior to rendering *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Pre_Render_Processing(CameraClass & camera)
{
WWPROFILE("Pre_Render_Processing");
LastCameraPosition = camera.Get_Position();
DecalSystem->Update_Decal_Fade_Distances(camera);
// Do the needed 'On_Frame_Update's
RefRenderObjListIterator rit(&UpdateList);
for (rit.First(); !rit.Is_Done(); rit.Next()) {
rit.Peek_Obj()->On_Frame_Update();
}
// Update culling info for all of the objects in the "dirty cull" list (these are
// objects which were added to the scene as pure render objects so I don't assume
// that the I have control over when their transform or bounding box is changed...)
RefPhysListIterator it(&DirtyCullList);
for (it.First(); !it.Is_Done(); it.Next()) {
PhysClass * obj = it.Peek_Obj();
obj->Update_Cull_Box();
if (obj->As_DynamicPhysClass()) {
obj->As_DynamicPhysClass()->Update_Visibility_Status();
}
if (DirtyCullDebugDisplayEnabled) {
const AABoxClass & box = obj->Get_Cull_Box();
if (box.Extent.Length2() > 0.0f) {
DEBUG_RENDER_AABOX(obj->Get_Cull_Box(),Vector3(1,1,1),0.25f);
}
}
}
// Get the pvs
VisTableClass * pvs = Get_Vis_Table_For_Rendering(camera);
// Collect the visible objects
bool use_umbra = false;
#if (UMBRASUPPORT)
use_umbra = UmbraSupport::Is_Umbra_Enabled();
#endif
if (!use_umbra) {
// Get the lists of visible objects
{
WWPROFILE( "Collect Static Objs" );
StaticCullingSystem->Collect_Visible_Objects(camera.Get_Frustum(),pvs,VisibleStaticObjectList,VisibleWSMeshList);
}
// Collect list of the visible dynamic objects
{
WWPROFILE( "Collect Dynamic Objs" );
DynamicCullingSystem->Collect_Visible_Objects(camera.Get_Frustum(),pvs,VisibleDynamicObjectList);
}
// LOD processing
Optimize_LODs(camera,&VisibleDynamicObjectList,&VisibleStaticObjectList,&VisibleWSMeshList);
// Texture projectors
Apply_Projectors(camera);
} else {
#if (UMBRASUPPORT)
RefPhysListClass vis_obj_list;
{
WWPROFILE("Umbra!");
UmbraSupport::Collect_Visible_Objects(camera,VisibleDynamicObjectList);
}
#endif
}
// release the visibility table
REF_PTR_RELEASE(pvs);
}
/***********************************************************************************************
* PhysicsSceneClass::Post_Render_Processing -- processing that occurs after rendering *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Post_Render_Processing(void)
{
WWPROFILE("Post_Render_Processing");
// Release the visible object lists, release the shadow textures
VisibleDynamicObjectList.Reset_List();
VisibleStaticObjectList.Reset_List();
VisibleWSMeshList.Reset_List();
// Update statistics
Per_Frame_Statistics_Update();
}
/***********************************************************************************************
* PhysicsSceneClass::Optimize_LODs -- Set the LOD level for each object *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Optimize_LODs
(
CameraClass & camera,
RefPhysListClass * dyn_objs,
RefPhysListClass * static_objs,
RefPhysListClass * static_ws_meshes
)
{
WWPROFILE("Optimize_LODs");
// process the dynamic objects
PredictiveLODOptimizerClass::Clear();
RefPhysListIterator it(dyn_objs);
for (it.First(); !it.Is_Done(); it.Next()) {
it.Peek_Obj()->Peek_Model()->Prepare_LOD(camera);
it.Peek_Obj()->Set_Last_Visible_Frame(CurrentFrameNumber);
}
PredictiveLODOptimizerClass::Optimize_LODs(DynamicPolyBudget);
// process the static objects
PredictiveLODOptimizerClass::Clear();
for (it.First(static_objs); !it.Is_Done(); it.Next()) {
it.Peek_Obj()->Peek_Model()->Prepare_LOD(camera);
it.Peek_Obj()->Set_Last_Visible_Frame(CurrentFrameNumber);
}
for (it.First(static_ws_meshes); !it.Is_Done(); it.Next()) {
it.Peek_Obj()->Peek_Model()->Prepare_LOD(camera);
it.Peek_Obj()->Set_Last_Visible_Frame(CurrentFrameNumber);
}
PredictiveLODOptimizerClass::Optimize_LODs(StaticPolyBudget);
}
/***********************************************************************************************
* PhysicsSceneClass::Render -- Render the scene *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Customized_Render(RenderInfoClass & rinfo)
{
WWPROFILE("PhysicsSceneClass::Render");
/*
** Render the normal models
*/
Render_Objects(rinfo,&VisibleWSMeshList,&VisibleStaticObjectList,&VisibleDynamicObjectList);
/*
** Backface Debug rendering
*/
#ifdef WWDEBUG
Render_Backface_Occluders(rinfo,&VisibleWSMeshList,&VisibleStaticObjectList);
#endif
/*
** Debug widget rendering
*/
{
static LightEnvironmentClass _defaultlightenvironment;
_defaultlightenvironment.Reset(Vector3(0,0,0),Get_Ambient_Light());
_defaultlightenvironment.Add_Light(*SunLight);
rinfo.light_environment = &_defaultlightenvironment;
Render_Debug_Widgets(rinfo);
Reset_Debug_Widget_List();
rinfo.light_environment = NULL;
}
if (Pathfinder != NULL) {
Pathfinder->Render_Debug_Widgets(rinfo);
}
/*
** Vis Sector Debugging
*/
if (VisSectorDisplayEnabled || VisSectorHistoryEnabled) {
// list of previous vis sectors so we can render them
static StaticPhysClass * old_vis_sectors[3] = { NULL, NULL, NULL };
static int old_vis_index = 0;
Vector3 vis_sample_point;
Compute_Vis_Sample_Point(rinfo.Camera,&vis_sample_point);
StaticPhysClass * vis_sector = StaticCullingSystem->Find_Vis_Tile(vis_sample_point);
if (vis_sector != NULL) {
MaterialPassClass * matpass = PhysResourceMgrClass::Get_Highlight_Material_Pass();
if (matpass) {
// flush all rendering, set wireframe render mode
WW3D::Flush(rinfo);
DX8Wrapper::Set_DX8_Render_State(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
// set wireframe mode and draw the vis sector
rinfo.Push_Material_Pass(matpass);
rinfo.Push_Override_Flags(RenderInfoClass::RINFO_OVERRIDE_ADDITIONAL_PASSES_ONLY);
if (VisSectorHistoryEnabled) {
// render the previous vis sectors
for (int i=0; i<3; i++) {
if (old_vis_sectors[i] != NULL) {
old_vis_sectors[i]->Render_Vis_Meshes(rinfo);
}
}
// add this one to the history if it is new
int prev_index = (old_vis_index + 2) % 3;
if (old_vis_sectors[prev_index] != vis_sector) {
old_vis_sectors[old_vis_index] = vis_sector;
old_vis_index = (old_vis_index + 1) % 3;
}
} else {
// Just draw the current vis sector
vis_sector->Render_Vis_Meshes(rinfo);
}
WW3D::Flush(rinfo);
rinfo.Pop_Material_Pass();
rinfo.Pop_Override_Flags();
// restore previous render mode
switch(Get_Polygon_Mode()) {
case POINT:
DX8Wrapper::Set_DX8_Render_State(D3DRS_FILLMODE,D3DFILL_POINT);
break;
case LINE:
DX8Wrapper::Set_DX8_Render_State(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
break;
case FILL:
DX8Wrapper::Set_DX8_Render_State(D3DRS_FILLMODE,D3DFILL_SOLID);
break;
}
// release resources
REF_PTR_RELEASE(matpass);
}
}
}
/*
** Dynamic Vis, Virtual Occludee Debugging
*/
if (VisGridDisplayMode == VIS_GRID_DISPLAY_ACTUAL_BOXES) {
VisTableClass * pvs = Get_Vis_Table_For_Rendering(rinfo.Camera);
if ((pvs != NULL) && (DynamicObjVisSystem != NULL)) {
DynamicObjVisSystem->Render_Visible_Cells(rinfo,pvs,DynamicAABTreeCullClass::DISPLAY_ACTUAL_BOXES);
}
REF_PTR_RELEASE(pvs);
}
/*
** Light Source Debugging, render debug widgets at each light transform
*/
static bool ACTIVE_ONLY = true;
if (LightingDebugDisplayEnabled) {
StaticLightingSystem->Reset_Collection();
StaticLightingSystem->Collect_Objects(rinfo.Camera.Get_Frustum());
LightPhysClass * light = StaticLightingSystem->Peek_First_Collected_Object();
while (light != NULL) {
if ((!light->Is_Disabled()) || (!ACTIVE_ONLY)) {
DEBUG_RENDER_AXES(light->Get_Transform(),Vector3(1.0f,1.0f,1.0f));
}
light = StaticLightingSystem->Peek_Next_Collected_Object(light);
}
}
}
/***********************************************************************************************
* PhysicsSceneClass::Render_Objects -- Render the visible objects *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 4/24/2001 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Render_Objects(
RenderInfoClass& rinfo,
RefPhysListClass * static_ws_list,
RefPhysListClass * static_list,
RefPhysListClass * dyn_list)
{
WWPROFILE("Render_Meshes");
RefPhysListIterator it(static_ws_list);
if (WW3D::Get_Mesh_Draw_Mode()!=WW3D::MESH_DRAW_MODE_NONE) {
if (Is_Backface_Occluder_Debug_Enabled()) {
// render the static world-space meshes
{
WWPROFILE("world-space meshes");
for (it.First(static_ws_list); !it.Is_Done(); it.Next()) {
// Only render occluders when backface debug is on
if (it.Peek_Obj()->As_StaticPhysClass()->Is_Occluder() != 0) {
Render_Object(rinfo,it.Peek_Obj());
}
}
}
// render the other static objects
{
WWPROFILE("static objects");
for (it.First(static_list); !it.Is_Done(); it.Next()) {
// Only render occluders when backface debug is on
if (it.Peek_Obj()->As_StaticPhysClass()->Is_Occluder() != 0) {
Render_Object(rinfo,it.Peek_Obj());
}
}
}
} else {
// render the static world-space meshes
{
WWPROFILE("world-space meshes");
for (it.First(static_ws_list); !it.Is_Done(); it.Next()) {
Render_Object(rinfo,it.Peek_Obj());
}
}
// render the other static objects
{
WWPROFILE("static objects");
for (it.First(static_list); !it.Is_Done(); it.Next()) {
Render_Object(rinfo,it.Peek_Obj());
}
}
}
}
// render the dynamic objects
// render dynamic objects even if the render type is "NONE"
{
WWPROFILE("dynamic objects");
for (it.First(dyn_list); !it.Is_Done(); it.Next()) {
Render_Object(rinfo,it.Peek_Obj());
}
}
}
/***********************************************************************************************
* PhysicsSceneClass::Render_Object -- Render an individual object *
* *
* This function installs the lighting environment and renders the object. *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 4/24/2001 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Render_Object(RenderInfoClass & context,PhysClass * obj)
{
if ((obj->Peek_Model() == NULL) || (obj->Is_Rendering_Disabled())) {
return;
}
/*
** Set up the lighting environment for this object
*/
bool do_lighting = ( (obj->Is_Pre_Lit() == false) &&
(obj->Peek_Model()->Is_Not_Hidden_At_All()) );
if (do_lighting) {
WWPROFILE("setup lights");
LightEnvironmentClass & light_env = *(obj->Get_Static_Lighting_Environment());
light_env.Pre_Render_Update(context.Camera.Get_Transform());
/*
** If lighting debugging is enabled, display a vector to each light source
*/
#if WWDEBUG
Vector3 pos = obj->Peek_Model()->Get_Bounding_Box().Center;
if (LightingDebugDisplayEnabled) {
if ((pos - context.Camera.Get_Position()).Length2() < 30.0f * 30.0f) {
for (int i=0; i<light_env.Get_Light_Count(); i++) {
DEBUG_RENDER_VECTOR(pos,light_env.Get_Light_Direction(i),light_env.Get_Light_Diffuse(i));
}
}
}
#endif
context.light_environment = &light_env;
} else {
static LightEnvironmentClass _emptylightenvironment;
_emptylightenvironment.Reset(Vector3(0,0,0),Vector3(1,1,1));
context.light_environment = &_emptylightenvironment;
}
/*
** Render the object
*/
{
WWPROFILE("render");
obj->Render(context);
}
/*
** Remove the lighting environment
*/
if (do_lighting) {
context.light_environment = NULL;
}
}
/***********************************************************************************************
* PhysicsSceneClass::Render_Backface_Occluders -- Render backfaces of all occluders *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 4/24/2001 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Render_Backface_Occluders
(
RenderInfoClass & context,
RefPhysListClass * static_ws_list,
RefPhysListClass * static_list
)
{
static LightEnvironmentClass lenv;
if (BackfaceDebugEnabled) {
MaterialPassClass * matpass = PhysResourceMgrClass::Get_Highlight_Material_Pass();
if (matpass != NULL) {
/*
** Flush the system and invert the backface culling check
*/
WW3D::Flush(context);
ShaderClass::Invert_Backface_Culling(true);
/*
** Set up the render context to render everything bright green
*/
ShaderClass shader = matpass->Peek_Shader();
shader.Set_Depth_Compare(ShaderClass::PASS_LESS);
matpass->Set_Shader(shader);
context.Push_Material_Pass(matpass);
context.Push_Override_Flags(RenderInfoClass::RINFO_OVERRIDE_ADDITIONAL_PASSES_ONLY);
lenv.Reset(Vector3(0,0,0),Vector3(1,1,1));
context.light_environment = &lenv;
/*
** Render the world-space mesh that are occluders
*/
RefPhysListIterator it(static_ws_list);
while (!it.Is_Done()) {
StaticPhysClass * sphys = it.Peek_Obj()->As_StaticPhysClass();
if (sphys && sphys->Is_Occluder()) {
sphys->Render(context);
}
it.Next();
}
/*
** Render the static objects that are occluders
*/
it.First(static_list);
while (!it.Is_Done()) {
StaticPhysClass * sphys = it.Peek_Obj()->As_StaticPhysClass();
if (sphys && sphys->Is_Occluder()) {
sphys->Render(context);
}
it.Next();
}
/*
** Flush all rendering and restore the normal backface culling state
*/
WW3D::Flush(context);
ShaderClass::Invert_Backface_Culling(false);
context.Pop_Material_Pass();
context.Pop_Override_Flags();
REF_PTR_RELEASE(matpass);
}
}
}
/***********************************************************************************************
* PhysicsSceneClass::Re_Partition_Static_Objects -- partition the static objects *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* This should be done in the editor. VIS data is invalidated when you do this... *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Re_Partition_Static_Objects(void)
{
StaticCullingSystem->Re_Partition();
}
/***********************************************************************************************
* PhysicsSceneClass::Re_Partition_Static_Lights -- partition the static lights *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* This should be done in the editor. VIS data is invalidated when you do this... *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Re_Partition_Static_Lights(void)
{
StaticLightingSystem->Re_Partition();
}
/***********************************************************************************************
* PhysicsSceneClass::Re_Partition_Dynamic_Culling_System -- partition the dynamic culling sys *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* This should be done in the editor. VIS data is invalidated when you do this... *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Re_Partition_Dynamic_Culling_System(void)
{
Vector3 wmin,wmax;
Get_Level_Extents(wmin,wmax);
DynamicCullingSystem->Re_Partition( wmin,wmax,
MAX_DYNAMIC_OBJ_RADIUS );
DynamicObjVisSystem->Re_Partition( NULL,
wmin,wmax,
MIN_GRID_CELL_SIZE,
MAX_GRID_CELL_COUNT,
MAX_DYNAMIC_OBJ_RADIUS );
Reset_Vis();
}
/***********************************************************************************************
* PhysicsSceneClass::Re_Partition_Dynamic_Culling_System -- partition the dynamic culling sys *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* This should be done in the editor. VIS data is invalidated when you do this... *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Re_Partition_Dynamic_Culling_System(DynamicVectorClass<AABoxClass> & virtual_occludees)
{
Vector3 wmin,wmax;
Get_Level_Extents(wmin,wmax);
DynamicCullingSystem->Re_Partition( wmin,wmax,
MAX_DYNAMIC_OBJ_RADIUS );
AABoxClass bounds(virtual_occludees[0]);
for (int i=0; i<virtual_occludees.Count(); i++) {
bounds.Add_Box(virtual_occludees[i]);
}
DynamicObjVisSystem->Re_Partition( &virtual_occludees,
bounds.Center - bounds.Extent,
bounds.Center + bounds.Extent,
MIN_GRID_CELL_SIZE,
MAX_GRID_CELL_COUNT,
MAX_DYNAMIC_OBJ_RADIUS );
Reset_Vis();
}
/***********************************************************************************************
* PhysicsSceneClass::Re_Partition_Static_Projectors -- partition the static projectors *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Re_Partition_Static_Projectors(void)
{
StaticProjectorCullingSystem->Re_Partition();
}
/***********************************************************************************************
* PhysicsSceneClass::Update_Culling_System_Bounding_Boxes -- updates the cull systems *
* *
* This should be performed by the level editor when geometry may have changed but we do not *
* want to do a re-partition due to the loss of hierarchical VIS data. Basically, the editor *
* will call this every time it loads an LVL in case the user has changed the geometry. It *
* causes all bounding boxes in the static culling systems to be validated. *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 9/3/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Update_Culling_System_Bounding_Boxes(void)
{
StaticCullingSystem->Update_Bounding_Boxes();
StaticLightingSystem->Update_Bounding_Boxes();
}
/***********************************************************************************************
* PhysicsSceneClass::Verify_Culling_Systems -- Verify the culling systems *
* *
* This function asks the culling systems to verify that all of thier bounding boxes *
* are properly constructed. I.e. they contain the objects they claim to contain, etc. *
* *
* INPUT: *
* error_report - will be filled in with a description of any errors encountered *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 9/28/2000 gth : Created. *
*=============================================================================================*/
bool PhysicsSceneClass::Verify_Culling_Systems(StringClass & set_error_report)
{
return StaticCullingSystem->Verify(set_error_report);
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Level_Extents -- returns the bounds of the level *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Get_Level_Extents(Vector3 &min, Vector3 &max)
{
const AABoxClass & level_bounds = StaticCullingSystem->Get_Bounding_Box();
min = level_bounds.Center - level_bounds.Extent;
max = level_bounds.Center + level_bounds.Extent;
}
/***********************************************************************************************
* PhysicsSceneClass::Set_Polygon_Budgets -- set the budgets for the LOD system *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Set_Polygon_Budgets(int static_count,int dynamic_count)
{
StaticPolyBudget = static_count;
DynamicPolyBudget = dynamic_count;
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Polygon_Budgets -- returns the budgets for the LOD system *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Get_Polygon_Budgets(int * static_count,int * dynamic_count)
{
*static_count = StaticPolyBudget;
*dynamic_count = DynamicPolyBudget;
}
/***********************************************************************************************
* PhysicsSceneClass::Per_Frame_Statistics_Update -- statistics tracking *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Per_Frame_Statistics_Update(void)
{
CurrentStats.FrameCount ++;
if (CurrentStats.FrameCount >= STATISTICS_FRAMES) {
/*
** Collect the culling system stats
*/
const GridCullSystemClass::StatsStruct & dyn_stats = DynamicCullingSystem->Get_Statistics();
const AABTreeCullSystemClass::StatsStruct & static_stats = StaticCullingSystem->Get_Statistics();
const AABTreeCullSystemClass::StatsStruct & light_stats = StaticLightingSystem->Get_Statistics();
CurrentStats.CullNodeCount = dyn_stats.NodeCount + static_stats.NodeCount + light_stats.NodeCount;
CurrentStats.CullNodesAccepted = dyn_stats.NodesAccepted + static_stats.NodesAccepted + light_stats.NodesAccepted;
CurrentStats.CullNodesTriviallyAccepted = dyn_stats.NodesTriviallyAccepted + static_stats.NodesTriviallyAccepted + light_stats.NodesTriviallyAccepted;
CurrentStats.CullNodesRejected = dyn_stats.NodesRejected + static_stats.NodesRejected + light_stats.NodesRejected;
DynamicCullingSystem->Reset_Statistics();
StaticCullingSystem->Reset_Statistics();
StaticLightingSystem->Reset_Statistics();
/*
** Copy over LastValidStats, reset
*/
LastValidStats = CurrentStats;
CurrentStats.Reset();
}
}
/***********************************************************************************************
* PhysicsSceneClass::Get_Statistics -- returns statistics *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
const PhysicsSceneClass::StatsStruct & PhysicsSceneClass::Get_Statistics(void)
{
return LastValidStats;
}
/***********************************************************************************************
* PhysicsSceneClass::Find_Static_Object -- Find static object with the given ID *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
StaticPhysClass * PhysicsSceneClass::Find_Static_Object( int instance_id )
{
RefPhysListIterator it(&StaticObjList);
for (it.First(); !it.Is_Done(); it.Next()) {
if ( (int)(it.Peek_Obj()->Get_ID()) == instance_id ) {
return (StaticPhysClass*)it.Peek_Obj();
}
}
return NULL;
}
/***********************************************************************************************
* PhysicsSceneClass::Shatter_Mesh -- Clips a mesh into pieces and scatters them *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 7/7/2000 gth : Created. *
*=============================================================================================*/
void PhysicsSceneClass::Shatter_Mesh
(
MeshClass * mesh,
const Vector3 & impact_point,
const Vector3 & impact_normal,
const Vector3 & impact_velocity
)
{
LookupTableClass * vel_table = LookupTableMgrClass::Get_Table("ShatterVel.tbl");
LookupTableClass * avel_table = LookupTableMgrClass::Get_Table("ShatterAVel.tbl");
/*
** Clip the mesh into fragments
*/
ShatterSystem::Shatter_Mesh(mesh,impact_point,impact_normal);
/*
** Wake up any dynamic objects in the area
*/
if (mesh->Get_Collision_Type() & COLLISION_TYPE_PHYSICAL) {
AABoxClass bounds = mesh->Get_Bounding_Box();
bounds.Extent *= 1.05f;
Force_Dynamic_Objects_Awake(bounds);
}
/*
** Disable the original mesh so that it doesn't shatter repeatedly
*/
mesh->Set_Hidden(true);
mesh->Set_Collision_Type(0);
/*
** Now create new auto-destructing projectiles for each fragment
*/
for (int i=0; i<ShatterSystem::Get_Fragment_Count(); i++) {
ProjectileClass * frag = NEW_REF(ProjectileClass,());
RenderObjClass * frag_model = ShatterSystem::Peek_Fragment(i);
Matrix3D frag_tm = frag_model->Get_Transform();
frag->Set_Model(frag_model);
frag->Set_Transform(frag_tm);
frag->Set_Orientation_Mode_Tumbling();
frag->Set_Lifetime(3.0f);
frag->Set_Gravity_Multiplier(2.0f);
frag->Set_Bounce_Count(1);
/*
** Vector from the impact to the center of the fragment is
** used in generating the initial velocity and rotation of the fragment
*/
Vector3 dc = frag_tm.Get_Translation() - impact_point;
float dclen = dc.Length();
dc /= dclen;
/*
** Generate a suitable velocity for the fragment
*/
Vector3 frag_vel = impact_velocity;
frag_vel.Normalize();
if (rand() & 0x00000100) {
frag_vel *= -1.0f;
}
frag_vel += 0.2f*dc;
frag_vel *= vel_table->Get_Value(dclen);
frag->Set_Velocity(frag_vel);
/*
** Generate a rotation for the fragment. The axis it rotates about
** will be in the plane of the impact, perpendicular to a vector from
** the impact to the CM
*/
Vector3 axis;
Vector3::Cross_Product(impact_velocity,dc,&axis);
frag->Set_Orientation_Mode_Tumbling(axis,avel_table->Get_Value(dclen));
/*
** We cannot allow these object to get saved since their model was
** procedurally generated and it will not get loaded...
*/
frag->Enable_Dont_Save(true);
/*
** Debugging, Stop the velocity, set life to infinite, move along initial velocity to offset pieces
*/
#if (SHATTER_DEBUG)
Matrix3D tm = frag->Get_Transform();
Vector3 pos,vel;
tm.Get_Translation(&pos);
frag->Get_Velocity(&vel);
tm.Set_Translation(pos+vel*0.1f);
frag->Set_Transform(tm);
frag->Set_Velocity(Vector3(0,0,0));
frag->Set_Lifetime(60.0f);
frag->Set_Gravity_Multiplier(0.0f);
frag->Set_Bounce_Count(100);
frag->Set_Orientation_Mode_Fixed();
#endif
/*
** Add the fragment to the scene
*/
Add_Dynamic_Object(frag);
REF_PTR_RELEASE(frag);
}
/*
** Done, have the shatter system release the fragments
*/
ShatterSystem::Release_Fragments();
vel_table->Release_Ref();
avel_table->Release_Ref();
}
void PhysicsSceneClass::Add_Camera_Shake
(
const Vector3 & position,
float radius,
float duration,
float power
)
{
WWASSERT(CameraShakeSystem != NULL);
CameraShakeSystem->Add_Camera_Shake(position,radius,duration,power);
}
void PhysicsSceneClass::Apply_Camera_Shakes(CameraClass & camera)
{
CameraShakeSystem->Update_Camera(camera);
}
float PhysicsSceneClass::Compute_Vis_Mesh_Ram(void)
{
float total = 0.0f;
RefPhysListIterator it(&StaticObjList);
for (it.First(); !it.Is_Done(); it.Next()) {
total += ((StaticPhysClass *)it.Peek_Obj())->Compute_Vis_Mesh_Ram();
}
return total;
}
void PhysicsSceneClass::Force_Dynamic_Objects_Awake(const AABoxClass & box)
{
/*
** Collect the objects that touch this box and wake them up.
*/
NonRefPhysListClass list;
Collect_Objects(box,false,true,&list);
NonRefPhysListIterator it(&list);
while (!it.Is_Done()) {
PhysClass * obj = it.Peek_Obj();
obj->Force_Awake();
if (obj->As_Phys3Class() != NULL) {
obj->As_Phys3Class()->Invalidate_Ground_State();
}
it.Next();
}
}
/******************************************************************************************
**
**
** PhysicsSceneClass::StatsStruct Implementation
**
**
******************************************************************************************/
PhysicsSceneClass::StatsStruct::StatsStruct(void)
{
Reset();
}
void PhysicsSceneClass::StatsStruct::Reset(void)
{
FrameCount = 0;
CullNodeCount = 0;
CullNodesAccepted = 0;
CullNodesTriviallyAccepted = 0;
CullNodesRejected = 0;
}
/*
** Force-Link relevant modules from WWPhys
*/
void Force_Link_Modules(void)
{
FORCE_LINK(decophys);
FORCE_LINK(humanphys);
FORCE_LINK(lightphys);
FORCE_LINK(motorcycle);
FORCE_LINK(movephys);
FORCE_LINK(phys3);
FORCE_LINK(rbody);
FORCE_LINK(staticphys);
FORCE_LINK(staticanimphys);
FORCE_LINK(wheelvehicle);
FORCE_LINK(projectile);
FORCE_LINK(timeddecophys);
FORCE_LINK(trackedvehicle);
FORCE_LINK(vtolvehicle);
FORCE_LINK(waypath);
FORCE_LINK(waypoint);
FORCE_LINK(dynamicanimphys);
FORCE_LINK(shakeablestaticphys);
FORCE_LINK(RenegadeTerrainPatch);
}
Reference in a new issue Copy permalink