//=============================================================================
// Copyright (C) 2002 Radical Entertainment Ltd. All rights reserved.
//
// File: triggervolumetracker.cpp
//
// Description: Implement TriggerVolumeTracker
//
// History: 13/05/2002 + Created -- NAME
//
//=============================================================================
//========================================
// System Includes
//========================================
// Foundation Tech
#include <raddebug.hpp>
#include <raddebugwatch.hpp>
#include <radmath/radmath.hpp>
#include <radtime.hpp>
#include <p3d/debugdraw.hpp>
//========================================
// Project Includes
//========================================
#include <meta/triggervolumetracker.h>
#include <meta/triggervolume.h>
#include <meta/triggerlocator.h>
#include <meta/locatorevents.h>
#include <meta/eventlocator.h>
#include <meta/locatortypes.h>
#include <meta/zoneeventlocator.h>
#include <main/commandlineoptions.h>
#include <memory/srrmemory.h>
#include <worldsim/avatarmanager.h>
#include <worldsim/avatar.h>
#include <worldsim/vehiclecentral.h>
#include <worldsim/redbrick/vehicle.h>
#include <mission/gameplaymanager.h>
#include <debug/profiler.h>
#include <render/intersectmanager/intersectmanager.h>
#include <camera/supercammanager.h>
#include <camera/supercamcentral.h>
#include <camera/supercam.h>
#include <simcommon/simstate.hpp>
#include <simcommon/simstatearticulated.hpp>
#include <simcommon/simulatedobject.hpp>
#include <simcommon/simenvironment.hpp>
#include <simcollision/collisionobject.hpp>
#include <simcollision/collisionvolume.hpp>
#include <simcollision/collisionmanager.hpp>
LocatorEvent::Event ALLOWED_AI_EVENTS[] =
{
LocatorEvent::DEATH,
LocatorEvent::PARKED_BIRDS,
LocatorEvent::WHACKY_GRAVITY,
LocatorEvent::GOO_DAMAGE
};
unsigned int NUM_ALLOWED_AI_EVENTS = sizeof( ALLOWED_AI_EVENTS ) / sizeof( ALLOWED_AI_EVENTS[0] );
//******************************************************************************
//
// Global Data, Local Data, Local Classes
//
//******************************************************************************
// Static pointer to instance of singleton.
TriggerVolumeTracker* TriggerVolumeTracker::spInstance = NULL;
rmt::Vector TriggerVolumeTracker::sP1;
rmt::Vector TriggerVolumeTracker::sP2;
rmt::Vector TriggerVolumeTracker::sP3;
rmt::Vector TriggerVolumeTracker::sP4;
sim::CollisionVolumeTypeEnum TriggerVolumeTracker::sColType;
//******************************************************************************
//
// Public Member Functions
//
//******************************************************************************
void TriggerVolumeTracker::CreateInstance()
{
MEMTRACK_PUSH_GROUP( "TriggerVolumeTracker" );
rAssert( spInstance == NULL );
spInstance = new(GMA_PERSISTENT) TriggerVolumeTracker();
rAssert( spInstance );
MEMTRACK_POP_GROUP( "TriggerVolumeTracker" );
}
//=============================================================================
// TriggerVolumeTracker::GetInstance
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: TriggerVolumeTracker
//
//=============================================================================
TriggerVolumeTracker* TriggerVolumeTracker::GetInstance()
{
//rAssert( spInstance );
return spInstance;
}
//=============================================================================
// TriggerVolumeTracker::DestroyInstance
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::DestroyInstance()
{
if( spInstance != NULL )
{
delete( GMA_PERSISTENT, spInstance );
spInstance = NULL;
}
}
//==============================================================================
// TriggerVolumeTracker::TriggerVolumeTracker
//==============================================================================
// Description: Constructor.
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
TriggerVolumeTracker::TriggerVolumeTracker() :
mpTriggerSphere( NULL ),
mNumRegisteredAI( 0 ),
mIgnoreTriggers ( false )
#ifndef RAD_RELEASE
,
mDisplayAmbients( false ),
mDisplayActive( true ),
mDisplayInactive( false ),
mDisplayAll( false )
#endif
{
int i;
for( i = 0; i < MAX_PLAYERS; i++ )
{
mActiveCount[ i ] = 0;
}
for ( i = 0; i < MAX_AI; ++i )
{
mAICount[ i ] = 0;
}
mTriggerCount = 0;
#ifndef RAD_RELEASE
radDbgWatchAddBoolean( &mDisplayActive, "Display Active Vols" , "Trigger Volume Tracker" );
radDbgWatchAddBoolean( &mDisplayInactive, "Display Inactive Vols" , "Trigger Volume Tracker" );
radDbgWatchAddBoolean( &mDisplayAll, "Display ALL" , "Trigger Volume Tracker" );
for ( i = 0; i < LocatorType::NUM_TYPES; ++i )
{
char name[256];
sprintf( name, "Display %s", LocatorType::Name[i] );
radDbgWatchAddBoolean( &mDisplayEnable[i], name , "Trigger Volume Tracker" );
mDisplayEnable[i] = false;
}
radDbgWatchAddBoolean( &mDisplayAmbients, "Display Ambients", "Trigger Volume Tracker" );
material = NULL;
#endif
}
#ifndef RAD_RELEASE
pddiShader* TriggerVolumeTracker::GetMaterial(void)
{
if(!material)
{
HeapMgr()->PushHeap(GMA_PERSISTENT);
material = p3d::device->NewShader( "simple" );
material->AddRef();
material->SetInt( PDDI_SP_BLENDMODE, PDDI_BLEND_ADD);
material->SetColour( PDDI_SP_AMBIENT, pddiColour( 128, 128, 128, 64 ));
material->SetColour( PDDI_SP_DIFFUSE, pddiColour( 128, 128, 128, 64 ));
HeapMgr()->PopHeap(GMA_PERSISTENT);
}
return material;
}
#endif
//==============================================================================
// TriggerVolumeTracker::~TriggerVolumeTracker
//==============================================================================
// Description: Destructor.
//
// Parameters: None.
//
// Return: N/A.
//
//==============================================================================
TriggerVolumeTracker::~TriggerVolumeTracker()
{
Cleanup();
#ifndef RAD_RELEASE
radDbgWatchDelete( &mDisplayActive );
radDbgWatchDelete( &mDisplayInactive );
radDbgWatchDelete( &mDisplayAll );
int i;
for ( i = 0; i < LocatorType::NUM_TYPES; ++i )
{
radDbgWatchDelete( &mDisplayEnable[i] );
}
radDbgWatchDelete( &mDisplayAmbients );
if ( material )
{
material->Release();
}
#endif
}
//=============================================================================
// TriggerVolumeTracker::Cleanup
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::Cleanup()
{
unsigned int i;
int j;
for( j = 0; j < MAX_PLAYERS; j++ )
{
for( i = 0; i < mActiveCount[ j ]; i++ )
{
mActiveVolumes[ j ][ i ]->Release();
mActiveVolumes[ j ][ i ] = NULL;
}
mActiveCount[ j ] = 0;
}
for ( j = 0; j < MAX_AI; ++j )
{
for ( i = 0; i < mAICount[ j ]; ++i )
{
mActiveAIVolumes[ j ][ i ]->Release();
mActiveAIVolumes[ j ][ i ] = NULL;
}
mAICount[ j ] = 0;
}
if ( mNumRegisteredAI > 0 )
{
for ( i = 0; i < mNumRegisteredAI; ++i )
{
mRegisteredVehicles[ i ].mVehicle->Release();
mRegisteredVehicles[ i ].mVehicle = NULL;
}
}
mNumRegisteredAI = 0;
for( i = 0; i < mTriggerCount; i++ )
{
mTriggerVolumes[ i ]->Release();
mTriggerVolumes[ i ] = NULL;
}
mTriggerCount = 0;
}
//=============================================================================
// TriggerVolumeTracker::Update
//=============================================================================
// Description: Comment
//
// Parameters: ( int elapsedTime )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::Update( int elapsedTime )
{
if ( mIgnoreTriggers )
{
//Do nothing
return;
}
BEGIN_PROFILE("Trigger Tracker");
rmt::Vector center;
const float radius = 1.0f;
unsigned int iNumPlayers = GetGameplayManager()->GetNumPlayers();
unsigned int i;
for( i = 0; i < iNumPlayers; i++ )
{
// get the player's location and bounding sphere radius
GetAvatarManager()->GetAvatarForPlayer( i )->GetPosition( center );
CheckForActiveVolumes( i, center, radius );
}
VehicleCentral* vc = GetVehicleCentral();
for ( i = 0; i < mNumRegisteredAI; ++i )
{
rmt::Vector pos;
mRegisteredVehicles[ i ].mVehicle->GetPosition( &pos );
int id = vc->GetVehicleId( mRegisteredVehicles[ i ].mVehicle );
CheckForActiveVolumes( id + MAX_PLAYERS, pos, radius );
}
END_PROFILE("Trigger Tracker");
}
//=============================================================================
// TriggerVolumeTracker::AddTrigger
//=============================================================================
// Description: Comment
//
// Parameters: ( TriggerVolume* triggerVolume )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::AddTrigger( TriggerVolume* triggerVolume )
{
rAssert( mTriggerCount < MAX_VOLUMES );
unsigned int index;
for( index = 0; index < mTriggerCount; index++ )
{
if( mTriggerVolumes[ index ] == triggerVolume )
{
return;
}
}
mTriggerVolumes[ mTriggerCount ] = triggerVolume;
triggerVolume->AddRef();
mTriggerCount++;
}
//=============================================================================
// TriggerVolumeTracker::RemoveTrigger
//=============================================================================
// Description: Comment
//
// Parameters: ( TriggerVolume* triggerVolume )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::RemoveTrigger( TriggerVolume* triggerVolume )
{
unsigned int index;
for( index = 0; index < mTriggerCount; index++ )
{
if( mTriggerVolumes[ index ] == triggerVolume )
{
//Shift the last trigger into the new empty position.
mTriggerVolumes[ index ] = mTriggerVolumes[ mTriggerCount-1 ];
triggerVolume->Release();
mTriggerCount--;
break;
}
}
for( int player = 0; player < GetGameplayManager()->GetNumPlayers(); player++ )
{
for( index = 0; index < mActiveCount[ player ]; index++ )
{
if( mActiveVolumes[ player ][ index ] == triggerVolume )
{
RemoveActive( player, index );
break;
}
}
}
for ( unsigned int ai = 0; ai < mNumRegisteredAI; ++ai )
{
for ( index = 0; index < mAICount[ ai ]; ++index )
{
if ( mActiveAIVolumes[ ai ][ index ] == triggerVolume )
{
RemoveAIActive( ai, index );
}
}
}
}
//=============================================================================
// TriggerVolumeTracker::UnregisterFromInventory
//=============================================================================
// Description: Comment
//
// Parameters: ( tInventory* inv )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::UnregisterFromInventory( tInventory* inv )
{
//BEGIN_PROFILE( "Trigger Tracker Unregister Inventory ");
rAssert( inv );
if ( inv )
{
HeapMgr()->PushHeap( GMA_TEMP );
tInventory::Iterator<TriggerVolume> it;
HeapMgr()->PopHeap( GMA_TEMP );
TriggerVolume* tv = it.First();
while ( tv != NULL )
{
RemoveTrigger( tv );
tv = it.Next();
}
}
//END_PROFILE( "Trigger Tracker Unregister Inventory ");
}
//=============================================================================
// TriggerVolumeTracker::HandleEvent
//=============================================================================
// Description: Comment
//
// Parameters: ( EventEnum id, void* pEventData )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::HandleEvent( EventEnum id, void* pEventData )
{
switch( id )
{
case EVENT_LOCATOR:
{
break;
}
default:
{
// implement all events this class is registered for!
rAssert( false );
}
}
}
//=============================================================================
// TriggerVolumeTracker::Render
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::Render()
{
#ifndef RAD_RELEASE
const Locator* locator;
unsigned int i;
/*
Avatar* playerAvatar = GetAvatarManager()->GetAvatarForPlayer( 0 );
rAssert( playerAvatar );
if ( playerAvatar->IsInCar() )
{
//Test the car like it was the "Green Lantern" | 0 |. Two lines and
//a sphere.
//Get the BBOX of the car
Vehicle* vehicle = playerAvatar->GetVehicle();
sim::CollisionVolume* vecol = vehicle->GetSimState()->GetCollisionObject()->GetCollisionVolume()->GetSubCollisionVolume( 0 );
rAssert( vecol->Type() == sim::OBBoxVolumeType );
sim::OBBoxVolume* obBox = static_cast<sim::OBBoxVolume*>( vecol );
rmt::Vector minCorner, maxCorner;
minCorner.x = - obBox->mLength[0];
minCorner.y = - obBox->mLength[1];
minCorner.z = - obBox->mLength[2];
maxCorner.x = obBox->mLength[0];
maxCorner.y = obBox->mLength[1];
maxCorner.z = obBox->mLength[2];
p3d::stack->Push();
rmt::Matrix positionMatrix;
positionMatrix.Identity();
positionMatrix.Row(0) = obBox->mAxis[0];
positionMatrix.Row(1) = obBox->mAxis[1];
positionMatrix.Row(2) = obBox->mAxis[2];
positionMatrix.Row(3) = obBox->mPosition;
p3d::stack->Multiply(positionMatrix);
tShader* shader = new tShader("simple");
shader->AddRef();
P3DDrawOrientedBox( minCorner, maxCorner, *shader );
shader->Release();
p3d::stack->Pop();
}
*/
for( i = 0; i < mTriggerCount; i++ )
{
if ( mDisplayAll )
{
mTriggerVolumes[ i ]->Render();
continue;
}
locator = mTriggerVolumes[ i ]->GetLocator();
if ( CommandLineOptions::Get( CLO_SHOW_DYNA_ZONES ) && locator->GetDataType() == LocatorType::DYNAMIC_ZONE )
{
mTriggerVolumes[ i ]->Render();
}
else if ( !locator )
{
}
else if ( mDisplayActive && locator->GetFlag( Locator::ACTIVE ) )
{
if ( mDisplayEnable[ locator->GetDataType() ] )
{
mTriggerVolumes[ i ]->Render();
}
else if ( locator->GetDataType() == LocatorType::EVENT )
{
//We want to look at the ambient events.
EventLocator* evtLoc = (EventLocator*)( locator );
LocatorEvent::Event event = evtLoc->GetEventType();
if ( mDisplayAmbients &&
(( event >= LocatorEvent::AMBIENT_SOUND_CITY &&
event <= LocatorEvent::AMBIENT_SOUND_MANSION_INTERIOR ) ||
( event >= LocatorEvent::AMBIENT_SOUND_COUNTRY_NIGHT &&
event <= LocatorEvent::AMBIENT_SOUND_PLACEHOLDER9 ) ||
( event >= LocatorEvent::AMBIENT_SOUND_SEASIDE_NIGHT &&
event <= LocatorEvent::AMBIENT_SOUND_PLACEHOLDER16 ))
)
{
mTriggerVolumes[ i ]->Render();
}
}
}
else if ( mDisplayInactive && !locator->GetFlag( Locator::ACTIVE ) )
{
if ( mDisplayEnable[ locator->GetDataType() ] )
{
mTriggerVolumes[ i ]->Render();
}
}
}
/*
rmt::Vector center;
GetAvatarManager()->GetAvatarForPlayer( 0 )->GetPosition( center );
IntersectManager* im = IntersectManager::GetInstance();
rAssert( im );
ReserveArray<TriggerVolume*> volDSGList;
//float radius = GetSuperCamManager()->GetSCC( 0 )->GetActiveSuperCam()->GetFarPlane();
float radius = 180.0f;
im->FindTrigVolElems( center, radius, volDSGList );
unsigned int time = radTimeGetMilliseconds();
//Test all the triggers around the car
for ( i = 0; i < static_cast<unsigned int>(volDSGList.mUseSize); ++i )
{
TriggerVolume* vol = volDSGList[ i ];
if ( mDisplayAll )
{
vol->Render();
continue;
}
locator = vol->GetLocator();
if ( mDisplayActive && locator->GetFlag( Locator::ACTIVE ) )
{
if ( mDisplayEnable[ locator->GetDataType() ] )
{
vol->Render();
}
}
else if ( mDisplayInactive && !locator->GetFlag( Locator::ACTIVE ) )
{
if ( mDisplayEnable[ locator->GetDataType() ] )
{
vol->Render();
}
}
}
*/
#endif
}
//=============================================================================
// TriggerVolumeTracker::GetTriggerByName
//=============================================================================
// Description: Comment
//
// Parameters: ( const char* name )
//
// Return: TriggerVolume
//
//=============================================================================
TriggerVolume* TriggerVolumeTracker::GetTriggerByName( const char* name )
{
unsigned int i;
for( i = 0; i < mTriggerCount; i++ )
{
if( strcmp( name, mTriggerVolumes[ i ]->GetName() ) == 0 )
{
return( mTriggerVolumes[ i ] );
}
}
return( NULL );
}
//=============================================================================
// TriggerVolumeTracker::RegisterAI
//=============================================================================
// Description: Comment
//
// Parameters: ( Vehicle* ai, int locatorTypes )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::RegisterAI( Vehicle* ai, int locatorTypes )
{
rAssert( mNumRegisteredAI < MAX_AI );
#ifdef RAD_DEBUG
unsigned int i;
for ( i = 0; i < mNumRegisteredAI; ++i )
{
rAssert( mRegisteredVehicles[ i ].mVehicle != ai );
}
#endif
if ( mNumRegisteredAI < MAX_AI )
{
tRefCounted::Assign( mRegisteredVehicles[ mNumRegisteredAI ].mVehicle, ai );
mRegisteredVehicles[ mNumRegisteredAI ].mTriggerTypes = locatorTypes;
}
mNumRegisteredAI++;
}
//=============================================================================
// TriggerVolumeTracker::UnregisterAI
//=============================================================================
// Description: Comment
//
// Parameters: ( Vehicle* ai )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::UnregisterAI( Vehicle* ai )
{
unsigned int i;
for ( i = 0; i < mNumRegisteredAI; ++i )
{
if ( mRegisteredVehicles[ i ].mVehicle == ai )
{
mRegisteredVehicles[ i ].mVehicle->Release();
mRegisteredVehicles[ i ].mVehicle = NULL;
if ( mNumRegisteredAI > 1 )
{
mRegisteredVehicles[ i ] = mRegisteredVehicles[ mNumRegisteredAI - 1 ];
mRegisteredVehicles[ mNumRegisteredAI - 1 ].mVehicle = NULL;
}
mNumRegisteredAI -= 1;
break;
}
}
}
//=============================================================================
// TriggerVolumeTracker::GetAI
//=============================================================================
// Description: Comment
//
// Parameters: ( int id )
//
// Return: Vehicle
//
//=============================================================================
Vehicle* TriggerVolumeTracker::GetAI( int id )
{
rAssert( id - MAX_PLAYERS < static_cast<int>(mNumRegisteredAI) );
return mRegisteredVehicles[ id - MAX_PLAYERS ].mVehicle;
}
//=============================================================================
// TriggerVolumeTracker::RegisterLocatorTypeForAI
//=============================================================================
// Description: Comment
//
// Parameters: ( LocatorType::Type type, Vehicle* ai )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::RegisterLocatorTypeForAI( LocatorType::Type type, Vehicle* ai )
{
unsigned int i;
for ( i = 0; i < mNumRegisteredAI; ++i )
{
if ( mRegisteredVehicles[ i ].mVehicle == ai )
{
mRegisteredVehicles[ i ].mTriggerTypes |= ( 1 << type );
break;
}
}
}
//=============================================================================
// TriggerVolumeTracker::UnregisterLocatorTypeForAI
//=============================================================================
// Description: Comment
//
// Parameters: ( LocatorType::Type type, Vehicle* ai )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::UnregisterLocatorTypeForAI( LocatorType::Type type, Vehicle* ai )
{
unsigned int i;
for ( i = 0; i < mNumRegisteredAI; ++i )
{
if ( mRegisteredVehicles[ i ].mVehicle == ai )
{
mRegisteredVehicles[ i ].mTriggerTypes &= ~( 1 << type );
break;
}
}
}
//=============================================================================
// TriggerVolumeTracker::ResetDynaloadZones
//=============================================================================
// Description: Comment
//
// Parameters: ()
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::ResetDynaloadZones()
{
for( int player = 0; player < GetGameplayManager()->GetNumPlayers(); player++ )
{
for( int index = 0; index < static_cast<int>( mActiveCount[ player ] ); index++ )
{
Locator* loc = mActiveVolumes[ player ][ index ]->GetLocator();
if ( !loc )
{
continue;
}
if( loc->GetDataType() == LocatorType::DYNAMIC_ZONE )
{
RemoveActive( player, index );
break;
}
}
}
}
//========================================================================
// triggervolumetracker::
//========================================================================
//
// Description:
//
// Parameters: None.
//
// Return: None.
//
// Constraints: None.
//
//========================================================================
void TriggerVolumeTracker::ActivateNearestInteriorLoadZone(int iPlayerID, rmt::Vector& irPosnRef, float iMaxDistance)
{
ZoneEventLocator* pNearestZEL = NULL;
float nearestLocatorDistSqr = iMaxDistance*iMaxDistance;
Locator* loc = NULL;
rmt::Sphere sphere;
int i;
for ( i = 0; i < static_cast<int>( mTriggerCount ); ++i )
{
loc = mTriggerVolumes[i]->GetLocator();
if(loc == NULL) continue;
if( loc->GetDataType() == LocatorType::DYNAMIC_ZONE )
{
ZoneEventLocator* pZEL = (ZoneEventLocator*)(loc);
if(pZEL->IsInteriorLoad())
{
mTriggerVolumes[i]->GetBoundingSphere(&sphere);
rmt::Vector dist;
dist.Sub(sphere.centre, irPosnRef);
float curDistSqr = dist.MagnitudeSqr();
if( (curDistSqr < nearestLocatorDistSqr)
&& (curDistSqr < ((iMaxDistance + sphere.radius) * (iMaxDistance + sphere.radius))))
{
pNearestZEL = pZEL;
nearestLocatorDistSqr = curDistSqr;
}
}
}
}
if(pNearestZEL!=NULL)
{
pNearestZEL->Trigger(iPlayerID,true);
}
}
//******************************************************************************
//
// Private Member Functions
//
//******************************************************************************
//=============================================================================
// TriggerVolumeTracker::AddActive
//=============================================================================
// Description: Comment
//
// Parameters: ( int playerID, TriggerVolume* triggerVolume )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::AddActive( int playerID, TriggerVolume* triggerVolume )
{
rAssert( triggerVolume != NULL );
if ( triggerVolume == NULL || !triggerVolume->TriggerAllowed( playerID ) )
return;
rAssert( mActiveCount[ playerID ] < MAX_ACTIVE );
mActiveVolumes[ playerID ][ mActiveCount[ playerID ] ] = triggerVolume;
mActiveCount[ playerID ]++;
triggerVolume->AddRef();
TriggerLocator* trigLoc = triggerVolume->GetLocator();
if ( trigLoc && trigLoc->IsPlayerTracked( playerID ) == 0 ) //returns number tracked.
{
triggerVolume->Trigger( playerID, true );
}
triggerVolume->SetTrackingPlayer( playerID, true );
}
//=============================================================================
// TriggerVolumeTracker::CheckForActiveVolumes
//=============================================================================
// Description: Comment
//
// Parameters: ( int playerID, rmt::Vector& center, float radius )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::CheckForActiveVolumes( int playerID, rmt::Vector& center, float radius )
{
unsigned int time = radTimeGetMilliseconds();
unsigned int i;
//BEGIN_PROFILE( "CheckForActiveVolumes" );
// IntersectManager* im = IntersectManager::GetInstance();
// rAssert( im );
//
// ReserveArray<TriggerVolume*> volDSGList;
//
//BEGIN_PROFILE( "Query Intersect Manager" );
// im->FindTrigVolElems( center, radius, volDSGList );
//END_PROFILE( "Query Intersect Manager" );
//BEGIN_PROFILE( "Car Triggers" );
//Test all the triggers around the car
// for ( i = 0; i < static_cast<unsigned int>(volDSGList.mUseSize); ++i )
// {
// TriggerVolume* vol = volDSGList[ i ];
//
// TestVolume( vol, center, radius, playerID, time );
// }
//END_PROFILE( "Car Triggers" );
int localID = playerID;
if ( playerID >= MAX_PLAYERS )
{
//localize the id
VehicleCentral* vc = GetVehicleCentral();
for ( i = 0; i < mNumRegisteredAI; ++i )
{
if ( mRegisteredVehicles[ i ].mVehicle == vc->GetVehicle( playerID - MAX_PLAYERS ) )
{
localID = i + MAX_PLAYERS;
break;
}
}
rAssert( localID != -1 );
}
else
{
//This is a player. Store their points for testing.
//Test the car like it was the "Green Lantern" | 0 |. Two lines and
//a sphere.
//Get the BBOX of the car
Avatar* playerAvatar = GetAvatarManager()->GetAvatarForPlayer( playerID );
Vehicle* vehicle = playerAvatar->GetVehicle();
if ( vehicle )
{
/*
rmt::Vector box = vehicle->GetExtents();
rmt::Matrix carToWorld = vehicle->GetTransform();
sP1.x = -box.x;
sP1.y = -box.y;
sP1.z = -box.z;
sP1.Transform( carToWorld );
sP2.x = +box.x;
sP2.y = -box.y;
sP2.z = -box.z;
sP2.Transform( carToWorld );
sP3.x = +box.x;
sP3.y = +box.y;
sP3.z = +box.z;
sP3.Transform( carToWorld );
sP4.x = -box.x;
sP4.y = +box.y;
sP4.z = +box.z;
sP4.Transform( carToWorld );
*/
sim::CollisionVolume* vecol = vehicle->GetSimState()->GetCollisionObject()->GetCollisionVolume()->GetSubCollisionVolume( 0 );
sColType = vecol->Type();
if( sColType == sim::OBBoxVolumeType )
{
sim::OBBoxVolume* obBox = static_cast<sim::OBBoxVolume*>( vecol );
sP1.x = - obBox->mLength[0];
sP1.y = - obBox->mLength[1];
sP1.z = - obBox->mLength[2];
sP2.x = obBox->mLength[0];
sP2.y = - obBox->mLength[1];
sP2.z = - obBox->mLength[2];
sP3.x = obBox->mLength[0];
sP3.y = obBox->mLength[1];
sP3.z = obBox->mLength[2];
sP4.x = - obBox->mLength[0];
sP4.y = obBox->mLength[1];
sP4.z = obBox->mLength[2];
rmt::Matrix positionMatrix;
positionMatrix.Identity();
positionMatrix.Row(0) = obBox->mAxis[0];
positionMatrix.Row(1) = obBox->mAxis[1];
positionMatrix.Row(2) = obBox->mAxis[2];
positionMatrix.Row(3) = obBox->mPosition;
sP1.Transform( positionMatrix );
sP2.Transform( positionMatrix );
sP3.Transform( positionMatrix );
sP4.Transform( positionMatrix );
radius = rmt::Sqrt(obBox->mLength[0] + obBox->mLength[1]);
}
}
}
//BEGIN_PROFILE( "Added Triggers" );
//Test all the triggers added to the trigger tracker
for ( i = 0; i < mTriggerCount; ++i )
{
rmt::Sphere sphere;
mTriggerVolumes[ i ]->GetBoundingSphere(&sphere);
rmt::Vector dist;
dist.Sub(sphere.centre, center);
if(dist.MagnitudeSqr() < ((radius + sphere.radius) * (radius + sphere.radius)))
{
TestVolume( mTriggerVolumes[ i ], center, radius, localID, time );
}
}
//END_PROFILE( "Added Triggers" );
if ( playerID < MAX_PLAYERS )
{
//BEGIN_PROFILE( "Active Triggers" );
//Test for triggers that we've left.
for( i = 0; i < mActiveCount[ playerID ]; ++i )
{
// Added a test for the active trigger volume, because it would
// seem that if a locator were not active, you wouldn't want
// the TV in the active list.
//
// TBJ [8/23/2002]
//
if( (mActiveVolumes[ playerID ][ i ]->GetLocator() && !mActiveVolumes[ playerID ][ i ]->GetLocator()->GetFlag( Locator::ACTIVE )) ||
mActiveVolumes[ playerID ][ i ]->GetFrameUsed() != time )
{
RemoveActive( playerID, i );
}
}
//END_PROFILE( "Active Triggers" );
}
else
{
localID -= MAX_PLAYERS;
for ( i = 0; i < mAICount[ localID ]; ++i )
{
if ( !mActiveAIVolumes[ localID ][ i ]->GetLocator()->GetFlag( Locator::ACTIVE ) ||
mActiveAIVolumes[ localID ][ i ]->GetFrameUsed() != time )
{
RemoveAIActive( localID, i );
}
}
}
//END_PROFILE( "CheckForActiveVolumes" );
}
//=============================================================================
// TriggerVolumeTracker::RemoveActive
//=============================================================================
// Description: Comment
//
// Parameters: ( int playerID, int index )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::RemoveActive( int playerID, int index )
{
TriggerVolume* vol = mActiveVolumes[ playerID ][ index ];
TriggerLocator* trigLoc = vol->GetLocator();
if ( trigLoc && trigLoc->IsPlayerTracked( playerID ) <= 1 ) //Some locators are screwy so they never track trigger voluemes. Gags, mostly
{
vol->Trigger( playerID, false );
}
vol->SetTrackingPlayer( playerID, false );
vol->Release();
if ( mActiveCount[ playerID ] > 0 )
{
mActiveVolumes[ playerID ][ index ] = mActiveVolumes[ playerID ][ mActiveCount[ playerID ] - 1 ];
mActiveVolumes[ playerID ][ mActiveCount[ playerID ] - 1 ] = NULL;
}
mActiveCount[ playerID ]--;
}
//=============================================================================
// TriggerVolumeTracker::AddAIActive
//=============================================================================
// Description: Comment
//
// Parameters: ( int playerID, TriggerVolume* triggerVolume )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::AddAIActive( int playerID, TriggerVolume* triggerVolume )
{
rAssert( mAICount[ playerID ] < MAX_AI_VOLUMES );
if ( !triggerVolume->TriggerAllowed( playerID ) )
{
return;
}
mActiveAIVolumes[ playerID ][ mAICount[ playerID ] ] = triggerVolume;
triggerVolume->AddRef();
TriggerLocator* trigLoc = triggerVolume->GetLocator();
if ( trigLoc && trigLoc->IsPlayerTracked( playerID + MAX_PLAYERS ) == 0 )
{
triggerVolume->Trigger( playerID + MAX_PLAYERS, true ); //And the hacks go on
}
triggerVolume->SetTrackingPlayer( playerID + MAX_PLAYERS, true );
mAICount[ playerID ] += 1;
}
//=============================================================================
// TriggerVolumeTracker::RemoveAIActive
//=============================================================================
// Description: Comment
//
// Parameters: ( int playerID, int index )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::RemoveAIActive( int playerID, int index )
{
TriggerVolume* vol = mActiveAIVolumes[ playerID ][ index ];
TriggerLocator* trigLoc = vol->GetLocator();
if ( trigLoc && trigLoc->IsPlayerTracked( playerID + MAX_PLAYERS ) == 1 )
{
vol->Trigger( playerID + MAX_PLAYERS, false );
}
vol->SetTrackingPlayer( playerID + MAX_PLAYERS, false ); //This is a hack.
vol->Release();
if ( mAICount[ playerID ] > 0 )
{
mActiveAIVolumes[ playerID ][ index ] = mActiveAIVolumes[ playerID ][ mAICount[ playerID ] - 1 ];
mActiveAIVolumes[ playerID ][ mAICount[ playerID ] - 1 ] = NULL;
}
mAICount[ playerID ] -= 1;
}
//=============================================================================
// TriggerVolumeTracker::TestVolume
//=============================================================================
// Description: Comment
//
// Parameters: ( TriggerVolume* vol, rmt::Vector& center, float radius, int playerID, unsigned int time )
//
// Return: void
//
//=============================================================================
void TriggerVolumeTracker::TestVolume( TriggerVolume* vol,
rmt::Vector& center,
float radius,
int playerID,
unsigned int time )
{
rAssert( vol );
// This is added because the AmbientDialogueTriggers do not have a locator associated with them
// with them.
if ( vol->GetLocator() != NULL )
{
if ( playerID >= MAX_PLAYERS &&
( ((1 << vol->GetLocator()->GetDataType()) & mRegisteredVehicles[ playerID - MAX_PLAYERS ].mTriggerTypes) == 0 ) )
{
return;
}
else if ( playerID >= MAX_PLAYERS )
{
//Test if this is a legal event.
if ( vol->GetLocator()->GetDataType() == LocatorType::EVENT )
{
EventLocator* evtLoc = static_cast<EventLocator*>(vol->GetLocator());
unsigned int i;
for ( i = 0; i < NUM_ALLOWED_AI_EVENTS; ++i )
{
if ( evtLoc->GetEventType() == ALLOWED_AI_EVENTS[ i ] )
{
break;
}
}
if ( i == NUM_ALLOWED_AI_EVENTS )
{
//Not allowed to trigger this.
return;
}
}
}
}
bool collision = false;
Locator* loc = vol->GetLocator();
if ( playerID < MAX_PLAYERS &&
GetAvatarManager()->GetAvatarForPlayer( playerID )->IsInCar() &&
( loc && loc->GetDataType() != LocatorType::OCCLUSION ) )
{
if ( GetGameplayManager()->GetGameType() == GameplayManager::GT_SUPERSPRINT )
{
collision = (!loc || loc->GetFlag( Locator::ACTIVE )) && vol->IntersectsSphere( center, 1.5f );
}
else
{
collision = (!loc || loc->GetFlag( Locator::ACTIVE )) &&
(vol->IntersectsSphere( center, 1.5f ) || vol->IntersectsBox( sP1, sP2, sP4, sP3 ));
}
}
else
{
collision = (!loc || loc->GetFlag( Locator::ACTIVE )) &&
vol->Contains( center, radius );
}
//BEGIN_PROFILE( "Test Volume" );
if ( collision )
{
//Test to see if this is a DEATH volume.
if ( loc->GetDataType() == LocatorType::EVENT )
{
EventLocator* evtLoc = static_cast<EventLocator*>(loc);
if ( evtLoc->GetEventType() == LocatorEvent::DEATH )
{
//This is so that death volumes always say you're in them until you leave.
//Hack for Chuka.
vol->Trigger( playerID, true );
return; //Early death.
}
}
//BEGIN_PROFILE( "Is Player Tracking" );
if ( !vol->IsPlayerTracking( playerID ) )
{
//New trigger!
#ifdef RAD_DEBUG
char name[256];
sprintf(name, "Hit trigger: %s\n", vol->GetName() );
rDebugString( name );
#endif
if ( playerID < MAX_PLAYERS )
{
//BEGIN_PROFILE( "AddActive" );
AddActive( playerID, vol );
//END_PROFILE( "AddActive" );
}
else
{
AddAIActive( playerID - MAX_PLAYERS, vol );
}
}
vol->SetFrameUsed( time, (int)this );
}
//END_PROFILE( "Test Volume" );
}
