//========================================================================
// Copyright (C) 2002 Radical Entertainment Ltd. All rights reserved.
//
// File: DynaPhysLoader.cpp
//
// Description: Implementation for DynaPhysLoader class.
//
// History: Implemented --Devin [5/27/2002]
//========================================================================
//========================================
// System Includes
//========================================
#include <simcollision/collisionobject.hpp>
#include <p3d/chunkfile.hpp>
#include <p3d/utility.hpp>
//========================================
// Project Includes
//========================================
#include <render/Loaders/DynaPhysLoader.h>
#include <render/Loaders/GeometryWrappedLoader.h>
#include <render/Loaders/AllWrappers.h>
#include <render/DSG/InstDynaPhysDSG.h>
#include <constants/srrchunks.h>
#include <constants/chunkids.hpp>
#include <constants/blobshadownames.h>
#include <memory/srrmemory.h>
#include <atc/atcmanager.h>
#ifndef RAD_RELEASE
#include <memory/propstats.h>
#endif
//************************************************************************
//
// Global Data, Local Data, Local Classes
//
//************************************************************************
//************************************************************************
//
// Public Member Functions : DynaPhysLoader Interface
//
//************************************************************************
//========================================================================
// DynaPhysLoader::
//========================================================================
//
// Description:
//
// Parameters: None.
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
DynaPhysLoader::DynaPhysLoader() :
tSimpleChunkHandler(SRR2::ChunkID::DYNA_PHYS_DSG)
{
HeapMgr()->PushHeap( GMA_PERSISTENT );
mpCollObjLoader = new sim::CollisionObjectLoader();
mpCollObjLoader->AddRef();
mpPhysObjLoader = new sim::PhysicsObjectLoader();
mpPhysObjLoader->AddRef();
mpCompDLoader = new tCompositeDrawableLoader;
mpCompDLoader->AddRef();
HeapMgr()->PopHeap(GMA_PERSISTENT);
mpListenerCB = NULL;
mUserData = -1;
}
//========================================================================
// DynaPhysLoader::
//========================================================================
//
// Description:
//
// Parameters: None.
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
DynaPhysLoader::~DynaPhysLoader()
{
mpCollObjLoader->Release();
mpPhysObjLoader->Release();
mpCompDLoader->Release();
}
///////////////////////////////////////////////////////////////////////
// tSimpleChunkHandler
///////////////////////////////////////////////////////////////////////
//========================================================================
// DynaPhysLoader::
//========================================================================
//
// Description:
//
// Parameters: None.
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
tEntity* DynaPhysLoader::LoadObject(tChunkFile* f, tEntityStore* store)
{
IEntityDSG::msDeletionsSafe=true;
char objName[128];
char name[128];
f->GetPString(objName);
#ifndef RAD_RELEASE
PropStats::StartTracking( objName );
#endif
bool test = tName::MakeUID(objName) == tName::MakeUID("l1_streetlamp_Shape");
static bool doTestOnce = true;
// Lets see if theis object has a shadow associated with it
const char* pShadowName = BlobbyShadowNames::FindShadowName( objName );
tDrawable* pShadow;
if ( pShadowName != NULL )
{
pShadow = p3d::find< tDrawable > ( pShadowName );
}
else
{
pShadow = NULL;
}
int instanceCount = 0;
int version = f->GetLong();
int HasAlpha = f->GetLong();
//pDynaPhysDSG->SetName(name);
sim::CollisionObject* pCollObj = NULL;
sim::PhysicsObject* pPhysObj = NULL;
tDrawable* pDrawable = NULL;
sim::SimState* pSimState = NULL;
CollisionAttributes* pCollAttr = NULL;
bool foundInstances = false;
InstDynaPhysDSG* pCurDynaPhysDSG = static_cast<InstDynaPhysDSG*>(GetAllWrappers()->GetGlobalEntity(tName::MakeUID(objName)));
//new InstDynaPhysDSG;
while(f->ChunksRemaining())
{
f->BeginChunk();
switch(f->GetCurrentID())
{
case SRR2::ChunkID::INSTANCES:
{
//Instances >> Scenegraph
f->BeginChunk();
//Scenegraph >> ScenegraphRoot
f->BeginChunk();
//ScenegraphRoot >> ScenegraphBranch
f->BeginChunk();
//ScenegraphBranch >> ScenegraphTransform
f->BeginChunk();
foundInstances = true;
//ScenegraphTransform >> real ScenegraphTransform
//f->BeginChunk();
for(;f->ChunksRemaining();)
{
instanceCount++;
f->BeginChunk();
f->GetPString(name);
int numChild = f->GetLong();
rmt::Matrix matrix;
f->GetData(&matrix,16,tFile::DWORD);
if(pCurDynaPhysDSG == 0)
{
pCurDynaPhysDSG = new InstDynaPhysDSG();
rAssert(pCurDynaPhysDSG);
pCurDynaPhysDSG->SetName(name);
pCurDynaPhysDSG->mTranslucent = ( HasAlpha != 0 ) || pShadow;
pSimState = sim::SimState::CreateSimState(pCollObj,pPhysObj);
// I suppose this could have just as easily gone into LoadSetUp
pSimState->SetControl(sim::simAICtrl);
pSimState->SetTransform(matrix);
pCurDynaPhysDSG->LoadSetUp(pSimState, pCollAttr, matrix, pDrawable, pShadow );
mpListenerCB->OnChunkLoaded( pCurDynaPhysDSG, mUserData, _id );
pCurDynaPhysDSG = 0;
}
else
{
InstDynaPhysDSG* clone = pCurDynaPhysDSG->Clone(name, matrix);
mpListenerCB->OnChunkLoaded(clone, mUserData, _id);
}
f->EndChunk();
}
//ScenegraphBranch >> ScenegraphTransform
f->EndChunk();
//ScenegraphRoot >> ScenegraphBranch
f->EndChunk();
//Scenegraph >> ScenegraphRoot
f->EndChunk();
//Instances >> Scenegraph
f->EndChunk();
}
break;
case Pure3D::Mesh::MESH:
{
if(pCurDynaPhysDSG == 0)
{
tGeometry* pGeo = (tGeometry*)((GeometryWrappedLoader*)GetAllWrappers()->mpLoader(AllWrappers::msGeometry))->LoadObject(f,store);
if( pGeo )
{
tRefCounted::Assign(pDrawable,(tDrawable*)pGeo);
}
}
}
break;
case P3D_COMPOSITE_DRAWABLE:
{
if(pCurDynaPhysDSG == 0)
{
tCompositeDrawable* pCompD = static_cast<tCompositeDrawable*>( mpCompDLoader->LoadObject( f, store ) );
if( store->TestCollision( pCompD->GetUID(), pCompD ) )
{
HandleCollision( pCompD );
pCompD = NULL;
}
else
{
store->Store( pCompD );
tRefCounted::Assign(pDrawable,(tDrawable*)pCompD);
}
}
}
break;
case Simulation::Physics::OBJECT:
{
if(pCurDynaPhysDSG == 0)
{
tRefCounted::Assign(pPhysObj,(sim::PhysicsObject*)mpPhysObjLoader->LoadObject(f,store));
}
}
break;
case Simulation::Collision::OBJECT:
{
if(pCurDynaPhysDSG == 0)
{
tRefCounted::Assign(pCollObj,(sim::CollisionObject*)mpCollObjLoader->LoadObject(f, store));
// TBJ [7/9/2002]
// Added this to store collision objects in the inventory.
// A normal loader stores the top level chunk, in this case the StaticPhysDSG.
// Since we want the Collision Object in the inventory, we have to store it here.
//
if ( pCollObj )
{
if( store->TestCollision( pCollObj->GetUID(), pCollObj ) )
{
HandleCollision(pCollObj);
// TBJ [7/9/2002]
// Don't know what to do with this code? Doesn't seem right to assign to NULL if
// the collObj does in fact exist.
// I'll take it out for now.
//
//pCollObj = NULL;
//return LOAD_ERROR;
}
else
{
store->Store(pCollObj);
}
}
}
}
break;
case SRR2::ChunkID::OBJECT_ATTRIBUTES:
{
if(pCurDynaPhysDSG == 0)
{
int classType = f->GetLong();
int physPropID = f->GetLong();
char tempsound [64];
f->GetString(tempsound);
// MS10 GREG TODO: This isn't even being used and calling it is leaking memory.
//
// we need to pass in volume for this thing to be able to set the mass properly in the PhysicsProperties
rAssert(pPhysObj);
float volume = pPhysObj->GetVolume();
tRefCounted::Assign(pCollAttr,GetATCManager()->CreateCollisionAttributes(classType, physPropID, volume));
pCollAttr->SetSound(tempsound);
}
}
break;
default:
break;
} // switch
f->EndChunk();
} // while
if( foundInstances == false || (test && doTestOnce) )
{
doTestOnce = false;
//This must be a global entity.
rmt::Matrix matrix;
matrix.Identity();
pCurDynaPhysDSG = new InstDynaPhysDSG();
rAssert(pCurDynaPhysDSG);
pCurDynaPhysDSG->SetName(objName);
pCurDynaPhysDSG->mTranslucent = HasAlpha != 0;
pSimState = sim::SimState::CreateSimState(pCollObj, pPhysObj);
pSimState->SetControl(sim::simAICtrl);
pSimState->SetTransform(matrix);
pCurDynaPhysDSG->LoadSetUp(pSimState, pCollAttr, matrix, pDrawable, pShadow );
GetAllWrappers()->AddGlobalEntity(pCurDynaPhysDSG);
instanceCount++;
}
//
// Spin Pure3D async loading.
//
///p3d::loadManager->SwitchTask();
tRefCounted::Release(pCollObj);
tRefCounted::Release(pPhysObj);
tRefCounted::Release(pDrawable);
tRefCounted::Release(pCollAttr);
#ifndef RAD_RELEASE
PropStats::StopTracking( objName, instanceCount );
#endif
IEntityDSG::msDeletionsSafe=false;
return NULL;
}
///////////////////////////////////////////////////////////////////////
// IWrappedLoader
///////////////////////////////////////////////////////////////////////
//========================================================================
// DynaPhysLoader::SetRegdListener
//========================================================================
//
// Description: Register a new listener/caretaker, notify old listener of
// severed connection.
//
// Parameters: pListenerCB: Callback to call OnChunkLoaded
// pUserData: Data to pass along for filtering, etc
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
void DynaPhysLoader::SetRegdListener
(
ChunkListenerCallback* pListenerCB,
int iUserData
)
{
//
// Follow protocol; notify old Listener, that it has been
// "disconnected".
//
if( mpListenerCB != NULL )
{
mpListenerCB->OnChunkLoaded( NULL, iUserData, 0 );
}
mpListenerCB = pListenerCB;
mUserData = iUserData;
}
//========================================================================
// DynaPhysLoader::ModRegdListener
//========================================================================
//
// Description: Just fuck with the current pUserData
//
// Parameters: None.
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
void DynaPhysLoader::ModRegdListener
(
ChunkListenerCallback* pListenerCB,
int iUserData
)
{
#if 0
char DebugBuf[255];
sprintf( DebugBuf, "GeometryWrappedLoader::ModRegdListener: pListenerCB %X vs mpListenerCB %X\n", pListenerCB, mpListenerCB );
rDebugString( DebugBuf );
#endif
rAssert( pListenerCB == mpListenerCB );
mUserData = iUserData;
}
//************************************************************************
//
// Protected Member Functions : DynaPhysLoader
//
//************************************************************************
//************************************************************************
//
// Private Member Functions : DynaPhysLoader
//
//************************************************************************
