594 lines
20 KiB
C++
594 lines
20 KiB
C++
|
|
#pragma once
|
|
|
|
#include "vjolt_controller_fluid.h"
|
|
|
|
struct JoltPhysicsContactPair
|
|
{
|
|
JoltPhysicsContactPair( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
: pObject1(pObject1), pObject2(pObject2)
|
|
{
|
|
}
|
|
|
|
JoltPhysicsObject *pObject1 = nullptr;
|
|
JoltPhysicsObject *pObject2 = nullptr;
|
|
};
|
|
|
|
enum VPhysicsGameFlags : uint32
|
|
{
|
|
FVPHYSICS_DMG_SLICE = 0x0001,
|
|
FVPHYSICS_CONSTRAINT_STATIC = 0x0002,
|
|
FVPHYSICS_PLAYER_HELD = 0x0004,
|
|
FVPHYSICS_PART_OF_RAGDOLL = 0x0008,
|
|
FVPHYSICS_MULTIOBJECT_ENTITY = 0x0010,
|
|
FVPHYSICS_HEAVY_OBJECT = 0x0020,
|
|
FVPHYSICS_PENETRATING = 0x0040,
|
|
FVPHYSICS_NO_PLAYER_PICKUP = 0x0080,
|
|
FVPHYSICS_WAS_THROWN = 0x0100,
|
|
FVPHYSICS_DMG_DISSOLVE = 0x0200,
|
|
FVPHYSICS_NO_IMPACT_DMG = 0x0400,
|
|
FVPHYSICS_NO_NPC_IMPACT_DMG = 0x0800,
|
|
FVPHYSICS_PUSH_PLAYER = 0x1000,
|
|
FVPHYSICS_NO_SELF_COLLISIONS = 0x8000,
|
|
};
|
|
|
|
class JoltPhysicsContactListener final : public JPH::ContactListener
|
|
{
|
|
public:
|
|
JoltPhysicsContactListener( JPH::PhysicsSystem &physicsSystem )
|
|
: m_PhysicsSystem( physicsSystem )
|
|
{
|
|
}
|
|
|
|
JPH::ValidateResult OnContactValidate( const JPH::Body &inBody1, const JPH::Body &inBody2, const JPH::CollideShapeResult &inCollisionResult ) override
|
|
{
|
|
return JPH::ValidateResult::AcceptAllContactsForThisBodyPair;
|
|
}
|
|
|
|
void OnContactAdded( const JPH::Body &inBody1, const JPH::Body &inBody2, const JPH::ContactManifold &inManifold, JPH::ContactSettings &ioSettings ) override
|
|
{
|
|
JoltPhysicsObject* pObject1 = reinterpret_cast<JoltPhysicsObject*>( inBody1.GetUserData() );
|
|
JoltPhysicsObject* pObject2 = reinterpret_cast<JoltPhysicsObject*>( inBody2.GetUserData() );
|
|
|
|
bool bShouldCollide = ShouldCollide( pObject1, pObject2 );
|
|
// If the game says we shouldn't collide, we will treat this as a sensor
|
|
// to satisfy the StartTouch/EndTouch events.
|
|
ioSettings.mIsSensor = !bShouldCollide || ioSettings.mIsSensor;
|
|
|
|
if ( !m_pGameListener )
|
|
return;
|
|
|
|
if ( pObject1->IsFluid() || pObject2->IsFluid() )
|
|
{
|
|
const uint32 uThreadId = GetThreadId();
|
|
|
|
if ( pObject1->IsFluid() && ( pObject2->GetCallbackFlags() & CALLBACK_FLUID_TOUCH ) )
|
|
m_FluidStartTouchEvents.EmplaceBack( uThreadId, pObject1, pObject2 );
|
|
|
|
if ( pObject2->IsFluid() && ( pObject1->GetCallbackFlags() & CALLBACK_FLUID_TOUCH ) )
|
|
m_FluidStartTouchEvents.EmplaceBack( uThreadId, pObject2, pObject1 );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( pObject1->IsTrigger() || pObject2->IsTrigger() )
|
|
{
|
|
const uint32 uThreadId = GetThreadId();
|
|
|
|
if ( pObject1->IsTrigger() )
|
|
m_EnterTriggerEvents.EmplaceBack( uThreadId, pObject1, pObject2 );
|
|
|
|
if ( pObject2->IsTrigger() )
|
|
m_EnterTriggerEvents.EmplaceBack( uThreadId, pObject2, pObject1 );
|
|
|
|
return;
|
|
}
|
|
|
|
const bool bIsCollision = bShouldCollide && JoltPhysicsCollisionEvent::IsCollision ( pObject1, pObject2 );
|
|
const bool bIsShadowCollision = bShouldCollide && JoltPhysicsCollisionEvent::IsShadowCollision( pObject1, pObject2 );
|
|
|
|
if ( bIsCollision || bIsShadowCollision )
|
|
{
|
|
// Josh:
|
|
// We know ahead of time what this is used for (playing sounds and such)
|
|
// and it is not easily threadable
|
|
// (unlike the StartTouch objects which we can get away as long as the objects themselves aren't concurrent it seems)
|
|
// To avoid this causing locks and therefore lagging with many objects,
|
|
// we can just know ahead of time what is going to cause a sound to play, which is
|
|
// hardcoded at speed > 70.0f and deltaTime < 0.05 (the latter of which we don't track)
|
|
// So we can just avoid sending these PreCollision in this case.
|
|
|
|
const Vector vecCollideNormal = Vector( inManifold.mWorldSpaceNormal.GetX(), inManifold.mWorldSpaceNormal.GetY(), inManifold.mWorldSpaceNormal.GetZ() );
|
|
const float flCollisionSpeed = JoltPhysicsCollisionEvent::GetCollisionSpeed( pObject1, pObject2, vecCollideNormal );
|
|
|
|
const bool bHasSound =
|
|
flCollisionSpeed >= 70.0f &&
|
|
pObject1->GetGameMaterialAllowsSounds() &&
|
|
pObject2->GetGameMaterialAllowsSounds();
|
|
|
|
const bool bSane = m_GlobalCollisionEventCount < MaxCollisionEvents;
|
|
|
|
const bool bSendCollisionCallback = ( bHasSound && bSane ) || bIsShadowCollision;
|
|
|
|
if ( bSendCollisionCallback )
|
|
{
|
|
m_CollisionEvents.EmplaceBack( GetThreadId(), JoltPhysicsCollisionInfo( pObject1, pObject2, inManifold ) );
|
|
m_GlobalCollisionEventCount++;
|
|
}
|
|
}
|
|
|
|
if ( ShouldTouchCallback( pObject1, pObject2 ) )
|
|
m_StartTouchEvents.EmplaceBack( GetThreadId(), JoltPhysicsCollisionInfo( pObject1, pObject2, inManifold ) );
|
|
}
|
|
|
|
void OnContactPersisted( const JPH::Body &inBody1, const JPH::Body &inBody2, const JPH::ContactManifold &inManifold, JPH::ContactSettings &ioSettings ) override
|
|
{
|
|
JoltPhysicsObject* pObject1 = reinterpret_cast<JoltPhysicsObject*>( inBody1.GetUserData() );
|
|
JoltPhysicsObject* pObject2 = reinterpret_cast<JoltPhysicsObject*>( inBody2.GetUserData() );
|
|
|
|
bool bShouldCollide = ShouldCollide( pObject1, pObject2 );
|
|
// If the game says we shouldn't collide, we will treat this as a sensor
|
|
// to satisfy the StartTouch/EndTouch events.
|
|
ioSettings.mIsSensor = !bShouldCollide || ioSettings.mIsSensor;
|
|
|
|
if ( !m_pGameListener )
|
|
return;
|
|
|
|
// TODO(Josh): Need a way to calculate the energy to send friction callbacks.
|
|
//
|
|
//JoltPhysicsObject *pObject1 = reinterpret_cast< JoltPhysicsObject * >( inBody1.GetUserData() );
|
|
//JoltPhysicsObject *pObject2 = reinterpret_cast< JoltPhysicsObject * >( inBody2.GetUserData() );
|
|
//
|
|
//if ( !ShouldFrictionCallback( pObject1, pObject2 ) )
|
|
// return;
|
|
//
|
|
//JoltPhysicsCollisionData data( inManifold );
|
|
//std::unique_lock lock( m_CallbackMutex );
|
|
//m_pGameListener->Friction( pObject1, 15500.0f, pObject1->GetMaterialIndex(), pObject2->GetMaterialIndex(), &data );
|
|
//m_pGameListener->Friction( pObject2, 15500.0f, pObject2->GetMaterialIndex(), pObject1->GetMaterialIndex(), &data );
|
|
}
|
|
|
|
void OnContactRemoved( const JPH::SubShapeIDPair &inSubShapePair )
|
|
{
|
|
if ( !m_pGameListener )
|
|
return;
|
|
|
|
// This is always called with all bodies locked.
|
|
const JPH::BodyLockInterfaceNoLock &bodyInterface = m_PhysicsSystem.GetBodyLockInterfaceNoLock();
|
|
|
|
JPH::Body *pBody1 = bodyInterface.TryGetBody( inSubShapePair.GetBody1ID() );
|
|
JPH::Body *pBody2 = bodyInterface.TryGetBody( inSubShapePair.GetBody2ID() );
|
|
|
|
// One of the bodies may have been deleted.
|
|
// TODO(Josh): Handle calling end touch when we delete a body.
|
|
if ( !pBody1 || !pBody2 )
|
|
return;
|
|
|
|
JoltPhysicsObject *pObject1 = reinterpret_cast< JoltPhysicsObject * >( pBody1->GetUserData() );
|
|
JoltPhysicsObject *pObject2 = reinterpret_cast< JoltPhysicsObject * >( pBody2->GetUserData() );
|
|
|
|
if ( pObject1->IsFluid() || pObject2->IsFluid() )
|
|
{
|
|
const uint32 uThreadId = GetThreadId();
|
|
|
|
if ( pObject1->IsFluid() && ( pObject2->GetCallbackFlags() & CALLBACK_FLUID_TOUCH ) )
|
|
m_FluidEndTouchEvents.EmplaceBack( uThreadId, pObject1, pObject2 );
|
|
|
|
if ( pObject2->IsFluid() && ( pObject1->GetCallbackFlags() & CALLBACK_FLUID_TOUCH ) )
|
|
m_FluidEndTouchEvents.EmplaceBack( uThreadId, pObject2, pObject1 );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( pObject1->IsTrigger() || pObject2->IsTrigger() )
|
|
{
|
|
const uint32 uThreadId = GetThreadId();
|
|
|
|
if ( pObject1->IsTrigger() )
|
|
m_LeaveTriggerEvents.EmplaceBack( uThreadId, pObject1, pObject2 );
|
|
|
|
if ( pObject2->IsTrigger() )
|
|
m_LeaveTriggerEvents.EmplaceBack( uThreadId, pObject2, pObject1 );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( !ShouldTouchCallback( pObject1, pObject2 ) )
|
|
return;
|
|
|
|
const uint32 uThreadId = GetThreadId();
|
|
|
|
// Josh:
|
|
// We don't have any collision data here
|
|
// and caching it would be annoying and expensive.
|
|
//
|
|
// Lucky for us though, the game simply just calls the stuff
|
|
// to retrieve the contact point and normal, then just never uses it
|
|
// so we can return anything we want and it will change *nothing*!
|
|
m_EndTouchEvents.EmplaceBack( uThreadId, JoltPhysicsCollisionInfo( pObject1, pObject2 ) );
|
|
}
|
|
|
|
bool ShouldCollide( JoltPhysicsObject *pObject0, JoltPhysicsObject *pObject1 )
|
|
{
|
|
VJoltAssert( pObject0 != pObject1 );
|
|
|
|
if ( !pObject0 || !pObject1 )
|
|
return false;
|
|
|
|
if ( ( pObject0->GetCallbackFlags() & CALLBACK_ENABLING_COLLISION ) && ( pObject1->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE ) )
|
|
return false;
|
|
|
|
if ( ( pObject1->GetCallbackFlags() & CALLBACK_ENABLING_COLLISION ) && ( pObject0->GetCallbackFlags() & CALLBACK_MARKED_FOR_DELETE ) )
|
|
return false;
|
|
|
|
if ( !m_pGameSolver )
|
|
return true;
|
|
|
|
// Josh:
|
|
// Do some work the game does ahead of time to
|
|
// avoid needless locking.
|
|
if ( !PreEmptGameShouldCollide( pObject0, pObject1 ) )
|
|
return false;
|
|
|
|
// Actually ask the game now, locking both bodies so they cannot have
|
|
// concurrent ShouldCollide calls.
|
|
//JoltPhysicsObjectPairLock lock( pObject0->GetCollisionTestLock(), pObject1->GetCollisionTestLock() );
|
|
std::unique_lock lock( m_ShouldCollideLock );
|
|
return m_pGameSolver->ShouldCollide( pObject0, pObject1, pObject0->GetGameData(), pObject1->GetGameData() );
|
|
}
|
|
|
|
bool PreEmptGameShouldCollide( JoltPhysicsObject *pObject0, JoltPhysicsObject *pObject1 )
|
|
{
|
|
// This function pre-empts the result of the
|
|
// game's ShouldCollide implementation to avoid needless locking.
|
|
|
|
// Check if the entities are the same and self-collisions are disabled.
|
|
if ( pObject0->GetGameData() == pObject1->GetGameData() )
|
|
{
|
|
if ( ( pObject0->GetGameFlags() | pObject1->GetGameFlags() ) & FVPHYSICS_NO_SELF_COLLISIONS )
|
|
return false;
|
|
}
|
|
|
|
// If both of these are constrained to the world, they shouldn't collide.
|
|
if ( pObject0->GetGameFlags() & pObject1->GetGameFlags() & FVPHYSICS_CONSTRAINT_STATIC )
|
|
return false;
|
|
|
|
// We do wheels separately, the IS_VEHICLE_WHEEL is just to have some dummy object to return to the game.
|
|
if ( ( pObject0->GetCallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL ) || ( pObject1->GetCallbackFlags() & CALLBACK_IS_VEHICLE_WHEEL ) )
|
|
return false;
|
|
|
|
// Two shadow controlled objects should not collide.
|
|
if ( pObject0->GetShadowController() && pObject1->GetShadowController() )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ShouldFrictionCallback( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
{
|
|
if ( !( pObject1->GetCallbackFlags() & CALLBACK_GLOBAL_FRICTION ) )
|
|
return false;
|
|
|
|
if ( !( pObject2->GetCallbackFlags() & CALLBACK_GLOBAL_FRICTION ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ShouldTouchCallback( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
{
|
|
uint32 uFlags = 0;
|
|
uFlags |= pObject1->GetCallbackFlags();
|
|
uFlags |= pObject2->GetCallbackFlags();
|
|
|
|
if ( !( uFlags & CALLBACK_GLOBAL_TOUCH ) )
|
|
return false;
|
|
|
|
if ( !( uFlags & CALLBACK_GLOBAL_TOUCH_STATIC ) && ( pObject1->IsStatic() || pObject2->IsStatic() ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
IPhysicsCollisionEvent *GetGameListener()
|
|
{
|
|
return m_pGameListener;
|
|
}
|
|
|
|
void SetGameListener( IPhysicsCollisionEvent *pListener )
|
|
{
|
|
m_pGameListener = pListener;
|
|
}
|
|
|
|
IPhysicsCollisionSolver *GetGameSolver()
|
|
{
|
|
return m_pGameSolver;
|
|
}
|
|
|
|
void SetGameSolver( IPhysicsCollisionSolver *pSolver )
|
|
{
|
|
m_pGameSolver = pSolver;
|
|
}
|
|
|
|
void FlushCallbacks()
|
|
{
|
|
if ( !m_pGameListener )
|
|
return;
|
|
|
|
// Send PreCollision events
|
|
//
|
|
// Don't clear the collision events the first time around as we have
|
|
// the post-collisde event to send too!
|
|
m_CollisionEvents.ForEach< false >( [ this ]( JoltPhysicsCollisionEvent& event )
|
|
{
|
|
// Fake the velocities for the objects during the PreCollision callback so
|
|
// we get a proper delta velocity between Pre/Post for damage callbacks to work.
|
|
JPH::Vec3 object1Vel = event.m_Data.GetPair().pObject1->FakeJoltLinearVelocity( event.m_Data.GetObject1PreCollisionVelocity() );
|
|
JPH::Vec3 object2Vel = event.m_Data.GetPair().pObject2->FakeJoltLinearVelocity( event.m_Data.GetObject2PreCollisionVelocity() );
|
|
m_pGameListener->PreCollision( &event.m_Event );
|
|
event.m_Data.GetPair().pObject1->RestoreJoltLinearVelocity( object1Vel );
|
|
event.m_Data.GetPair().pObject2->RestoreJoltLinearVelocity( object2Vel );
|
|
});
|
|
|
|
// Send StartTouch events
|
|
m_StartTouchEvents.ForEach< true >( [ this ]( JoltPhysicsCollisionData& event )
|
|
{
|
|
m_pGameListener->StartTouch( event.GetPair().pObject1, event.GetPair().pObject2, &event );
|
|
});
|
|
|
|
// Send EnterTrigger events
|
|
m_EnterTriggerEvents.ForEach< true >( [ this ]( JoltPhysicsContactPair& event )
|
|
{
|
|
m_pGameListener->ObjectEnterTrigger( event.pObject1, event.pObject2 );
|
|
});
|
|
|
|
// Send FluidStartTouch events
|
|
m_FluidStartTouchEvents.ForEach< true >( [ this ]( JoltPhysicsContactPair& event )
|
|
{
|
|
m_pGameListener->FluidStartTouch( event.pObject2, event.pObject1->GetFluidController() );
|
|
});
|
|
|
|
// Send PostCollision events
|
|
//
|
|
// Clear it this time as we are done with these!
|
|
m_CollisionEvents.ForEach< true >( [ this ]( JoltPhysicsCollisionEvent& event )
|
|
{
|
|
m_pGameListener->PostCollision( &event.m_Event );
|
|
});
|
|
|
|
// Send EndTouch events
|
|
m_EndTouchEvents.ForEach< true >( [ this ]( JoltPhysicsCollisionData& event )
|
|
{
|
|
m_pGameListener->EndTouch( event.GetPair().pObject1, event.GetPair().pObject2, &event );
|
|
});
|
|
|
|
// Send LeaveTrigger events
|
|
m_LeaveTriggerEvents.ForEach< true >( [ this ]( JoltPhysicsContactPair& event )
|
|
{
|
|
m_pGameListener->ObjectLeaveTrigger( event.pObject1, event.pObject2 );
|
|
});
|
|
|
|
// Send FluidEndTouch events
|
|
m_FluidEndTouchEvents.ForEach< true >( [ this ]( JoltPhysicsContactPair& event )
|
|
{
|
|
m_pGameListener->FluidEndTouch( event.pObject2, event.pObject1->GetFluidController() );
|
|
});
|
|
|
|
// Reset the collision event counter.
|
|
m_GlobalCollisionEventCount = 0u;
|
|
}
|
|
|
|
void PostSimulationFrame()
|
|
{
|
|
if ( m_pGameListener )
|
|
m_pGameListener->PostSimulationFrame();
|
|
}
|
|
|
|
private:
|
|
|
|
static uint32 GetThreadId()
|
|
{
|
|
static thread_local uint32 s_ThreadId = ~0u;
|
|
static std::atomic< uint32 > s_ThreadCtr = { 0u };
|
|
if ( s_ThreadId == ~0u )
|
|
s_ThreadId = s_ThreadCtr++;
|
|
return s_ThreadId;
|
|
}
|
|
|
|
const JPH::PhysicsSystem &m_PhysicsSystem;
|
|
|
|
IPhysicsCollisionEvent *m_pGameListener = nullptr;
|
|
IPhysicsCollisionSolver *m_pGameSolver = nullptr;
|
|
|
|
std::mutex m_ShouldCollideLock;
|
|
|
|
class JoltPhysicsCollisionInfo
|
|
{
|
|
public:
|
|
JoltPhysicsCollisionInfo( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
: m_CollisionPair{ pObject1, pObject2 }
|
|
{
|
|
}
|
|
|
|
JoltPhysicsCollisionInfo( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2, const JPH::ContactManifold &inManifold )
|
|
: m_CollisionPair{ pObject1, pObject2 }
|
|
// Slart: Note this negated vector, it is important, Portal 2 bouncy paint needs it negated otherwise things fly into the surface they hit
|
|
, m_SurfaceNormal( -Vector( inManifold.mWorldSpaceNormal.GetX(), inManifold.mWorldSpaceNormal.GetY(), inManifold.mWorldSpaceNormal.GetZ() ) )
|
|
, m_ContactPoint( JoltToSource::Distance( inManifold.mWorldSpaceContactPointsOn1[0] ) )
|
|
// Unused...
|
|
, m_ContactSpeed( vec3_origin )
|
|
, m_Velocity0( pObject1->GetBody()->GetLinearVelocity() )
|
|
, m_Velocity1( pObject2->GetBody()->GetLinearVelocity() )
|
|
{
|
|
}
|
|
|
|
JoltPhysicsContactPair m_CollisionPair;
|
|
|
|
Vector m_SurfaceNormal = vec3_origin;
|
|
Vector m_ContactPoint = vec3_origin;
|
|
Vector m_ContactSpeed = vec3_origin;
|
|
|
|
JPH::Vec3 m_Velocity0 = JPH::Vec3::sZero();
|
|
JPH::Vec3 m_Velocity1 = JPH::Vec3::sZero();
|
|
};
|
|
|
|
class JoltPhysicsCollisionData final : public IPhysicsCollisionData
|
|
{
|
|
public:
|
|
JoltPhysicsCollisionData( const JoltPhysicsCollisionInfo &info )
|
|
: m_CollisionData{ info }
|
|
{
|
|
}
|
|
|
|
void GetSurfaceNormal( Vector &out ) override
|
|
{
|
|
out = m_CollisionData.m_SurfaceNormal;
|
|
}
|
|
|
|
void GetContactPoint( Vector &out ) override
|
|
{
|
|
out = m_CollisionData.m_ContactPoint;
|
|
}
|
|
|
|
void GetContactSpeed( Vector &out ) override
|
|
{
|
|
out = m_CollisionData.m_ContactSpeed;
|
|
}
|
|
|
|
JoltPhysicsContactPair GetPair() const
|
|
{
|
|
return m_CollisionData.m_CollisionPair;
|
|
}
|
|
|
|
JPH::Vec3 GetObject1PreCollisionVelocity() const
|
|
{
|
|
return m_CollisionData.m_Velocity0;
|
|
}
|
|
|
|
JPH::Vec3 GetObject2PreCollisionVelocity() const
|
|
{
|
|
return m_CollisionData.m_Velocity1;
|
|
}
|
|
private:
|
|
JoltPhysicsCollisionInfo m_CollisionData;
|
|
};
|
|
|
|
class JoltPhysicsCollisionEvent
|
|
{
|
|
public:
|
|
JoltPhysicsCollisionEvent( const JoltPhysicsCollisionInfo &info )
|
|
: m_Data{ info }
|
|
{
|
|
JoltPhysicsObject *pObject1 = m_Data.GetPair().pObject1;
|
|
JoltPhysicsObject* pObject2 = m_Data.GetPair().pObject2;
|
|
|
|
m_Event.pObjects[0] = pObject1;
|
|
m_Event.pObjects[1] = pObject2;
|
|
m_Event.surfaceProps[0] = pObject1->GetMaterialIndex();
|
|
m_Event.surfaceProps[1] = pObject2->GetMaterialIndex();
|
|
m_Event.isCollision = IsCollision( pObject1, pObject2 );
|
|
m_Event.isShadowCollision = IsShadowCollision( pObject1, pObject2 );
|
|
m_Event.deltaCollisionTime = 100.0f;
|
|
m_Event.collisionSpeed = GetCollisionSpeed( pObject1, pObject2, info.m_SurfaceNormal );
|
|
m_Event.pInternalData = &m_Data;
|
|
}
|
|
|
|
JoltPhysicsCollisionEvent( const JoltPhysicsCollisionEvent &other )
|
|
: m_Event( other.m_Event )
|
|
, m_Data ( other.m_Data )
|
|
{
|
|
// Re-target the event's internal data pointer to our own structure.
|
|
m_Event.pInternalData = &m_Data;
|
|
}
|
|
|
|
JoltPhysicsCollisionEvent( JoltPhysicsCollisionEvent &&other )
|
|
: m_Event( std::move( other.m_Event ) )
|
|
, m_Data ( std::move( other.m_Data ) )
|
|
{
|
|
// Re-target the event's internal data pointer to our own structure.
|
|
m_Event.pInternalData = &m_Data;
|
|
}
|
|
|
|
static bool IsCollision( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
{
|
|
bool bIsCollision = ( pObject1->GetCallbackFlags() & pObject2->GetCallbackFlags() ) & CALLBACK_GLOBAL_COLLISION;
|
|
|
|
if ( pObject1->IsStatic() && !( pObject2->GetCallbackFlags() & CALLBACK_GLOBAL_COLLIDE_STATIC ) )
|
|
bIsCollision = false;
|
|
if ( pObject2->IsStatic() && !( pObject1->GetCallbackFlags() & CALLBACK_GLOBAL_COLLIDE_STATIC ) )
|
|
bIsCollision = false;
|
|
|
|
return bIsCollision;
|
|
}
|
|
|
|
static bool IsShadowCollision( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2 )
|
|
{
|
|
return ( pObject1->GetCallbackFlags() ^ pObject2->GetCallbackFlags() ) & CALLBACK_SHADOW_COLLISION;
|
|
}
|
|
|
|
static float GetCollisionSpeed( JoltPhysicsObject *pObject1, JoltPhysicsObject *pObject2, Vector vecNormal )
|
|
{
|
|
const Vector vecCollisionSpeed = pObject1->GetVelocity() - pObject2->GetVelocity();
|
|
return fabsf( vecCollisionSpeed.Dot( vecNormal ) );
|
|
}
|
|
|
|
vcollisionevent_t m_Event = {};
|
|
JoltPhysicsCollisionData m_Data;
|
|
};
|
|
|
|
template < typename Data >
|
|
struct JoltPhysicsEventTracker
|
|
{
|
|
public:
|
|
template < typename... T >
|
|
void EmplaceBack( uint32 uThreadId, T&&... val)
|
|
{
|
|
m_Mask |= 1ull << uThreadId;
|
|
m_Events[ uThreadId ].emplace_back( std::forward< T >( val )... );
|
|
}
|
|
|
|
template < bool bClear, typename FuncType >
|
|
void ForEach( FuncType func )
|
|
{
|
|
for ( uint32 thread = m_Mask; thread; thread &= thread - 1 )
|
|
{
|
|
const uint32 i = JPH::CountTrailingZeros( thread );
|
|
for ( auto &event : m_Events[ i ] )
|
|
func( event );
|
|
|
|
if constexpr ( bClear )
|
|
m_Events[ i ].clear();
|
|
}
|
|
|
|
if constexpr ( bClear )
|
|
m_Mask = 0ull;
|
|
}
|
|
|
|
private:
|
|
static constexpr uint32 kMaxThreads = 64;
|
|
std::atomic< uint64_t > m_Mask = { 0ull };
|
|
std::vector< Data > m_Events[ kMaxThreads ];
|
|
};
|
|
|
|
// The maximum number of sent collision events to send per-frame.
|
|
// This is used to play stuff like sounds and physics fx.
|
|
// This is quite expensive to do so, we rate-limit this quite aggressively.
|
|
static constexpr uint32_t MaxCollisionEvents = 4;
|
|
std::atomic< uint32 > m_GlobalCollisionEventCount = { 0u };
|
|
|
|
JoltPhysicsEventTracker< JoltPhysicsCollisionEvent > m_CollisionEvents;
|
|
|
|
JoltPhysicsEventTracker< JoltPhysicsCollisionData > m_StartTouchEvents;
|
|
JoltPhysicsEventTracker< JoltPhysicsCollisionData > m_EndTouchEvents;
|
|
|
|
JoltPhysicsEventTracker< JoltPhysicsContactPair > m_EnterTriggerEvents;
|
|
JoltPhysicsEventTracker< JoltPhysicsContactPair > m_LeaveTriggerEvents;
|
|
|
|
// For the fluid events:
|
|
// Object1 = the fluid
|
|
// Object2 = the object
|
|
JoltPhysicsEventTracker< JoltPhysicsContactPair > m_FluidStartTouchEvents;
|
|
JoltPhysicsEventTracker< JoltPhysicsContactPair > m_FluidEndTouchEvents;
|
|
|
|
};
|