From bef04a727c8d6598177c79e48e235d4d3cc93cbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?L=C3=A9o=20Lam?= Date: Sun, 20 Mar 2022 11:54:00 +0100 Subject: [PATCH] Havok: Add phantom stubs --- lib/hkStubs/CMakeLists.txt | 10 ++ .../Agent/Query/hkpCdBodyPairCollector.h | 35 ++++++ .../BroadPhase/hkpBroadPhaseListener.h | 12 ++ .../Dynamics/Phantom/hkpAabbPhantom.h | 64 ++++++++++ .../Dynamics/Phantom/hkpCachingShapePhantom.h | 65 ++++++++++ .../Physics2012/Dynamics/Phantom/hkpPhantom.h | 113 ++++++++++++++++++ .../Phantom/hkpPhantomBroadPhaseListener.h | 14 +++ .../Dynamics/Phantom/hkpPhantomListener.h | 21 ++++ .../Dynamics/Phantom/hkpPhantomType.h | 26 ++++ .../Dynamics/Phantom/hkpShapePhantom.h | 56 +++++++++ .../Dynamics/Phantom/hkpSimpleShapePhantom.h | 62 ++++++++++ 11 files changed, 478 insertions(+) create mode 100644 lib/hkStubs/Havok/Physics2012/Collide/Agent/Query/hkpCdBodyPairCollector.h create mode 100644 lib/hkStubs/Havok/Physics2012/Collide/Dispatch/BroadPhase/hkpBroadPhaseListener.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpAabbPhantom.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpCachingShapePhantom.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantom.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomBroadPhaseListener.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomListener.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomType.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpShapePhantom.h create mode 100644 lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpSimpleShapePhantom.h diff --git a/lib/hkStubs/CMakeLists.txt b/lib/hkStubs/CMakeLists.txt index 688bad81..9ebd6815 100644 --- a/lib/hkStubs/CMakeLists.txt +++ b/lib/hkStubs/CMakeLists.txt @@ -95,6 +95,7 @@ add_library(hkStubs OBJECT Havok/Physics2012/Collide/Agent/Collidable/hkpCollidable.h Havok/Physics2012/Collide/Agent/Collidable/hkpCollidableQualityType.h Havok/Physics2012/Collide/Agent/ContactMgr/hkpContactMgr.h + Havok/Physics2012/Collide/Agent/Query/hkpCdBodyPairCollector.h Havok/Physics2012/Collide/Agent/Query/hkpCdPointCollector.h Havok/Physics2012/Collide/Agent3/BvTree3/hkpBvTreeAgent3.h Havok/Physics2012/Collide/Agent3/Machine/Nn/hkpAgentNnTrack.h @@ -102,6 +103,7 @@ add_library(hkStubs OBJECT Havok/Physics2012/Collide/BroadPhase/hkpBroadPhaseHandle.h Havok/Physics2012/Collide/BroadPhase/hkpTypedBroadPhaseHandle.h Havok/Physics2012/Collide/Dispatch/hkpCollisionDispatcher.h + Havok/Physics2012/Collide/Dispatch/BroadPhase/hkpBroadPhaseListener.h Havok/Physics2012/Collide/Dispatch/ContactMgr/hkpContactMgrFactory.h Havok/Physics2012/Collide/Filter/hkpCollidableCollidableFilter.h Havok/Physics2012/Collide/Filter/hkpCollisionFilter.cpp @@ -169,7 +171,15 @@ add_library(hkStubs OBJECT Havok/Physics2012/Dynamics/Motion/Rigid/hkpFixedRigidMotion.h Havok/Physics2012/Dynamics/Motion/Rigid/hkpKeyframedRigidMotion.h Havok/Physics2012/Dynamics/Motion/Rigid/hkpSphereMotion.h + Havok/Physics2012/Dynamics/Phantom/hkpAabbPhantom.h + Havok/Physics2012/Dynamics/Phantom/hkpCachingShapePhantom.h + Havok/Physics2012/Dynamics/Phantom/hkpPhantom.h + Havok/Physics2012/Dynamics/Phantom/hkpPhantomBroadPhaseListener.h + Havok/Physics2012/Dynamics/Phantom/hkpPhantomListener.h Havok/Physics2012/Dynamics/Phantom/hkpPhantomOverlapListener.h + Havok/Physics2012/Dynamics/Phantom/hkpPhantomType.h + Havok/Physics2012/Dynamics/Phantom/hkpShapePhantom.h + Havok/Physics2012/Dynamics/Phantom/hkpSimpleShapePhantom.h Havok/Physics2012/Dynamics/World/hkpPhysicsSystem.h Havok/Physics2012/Dynamics/World/hkpSimulationIsland.h Havok/Physics2012/Dynamics/World/hkpWorld.h diff --git a/lib/hkStubs/Havok/Physics2012/Collide/Agent/Query/hkpCdBodyPairCollector.h b/lib/hkStubs/Havok/Physics2012/Collide/Agent/Query/hkpCdBodyPairCollector.h new file mode 100644 index 00000000..579c4f50 --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Collide/Agent/Query/hkpCdBodyPairCollector.h @@ -0,0 +1,35 @@ +#pragma once + +#include + +class hkpCdBody; + +class hkpCdBodyPairCollector { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpCdBodyPairCollector) + + inline hkpCdBodyPairCollector(); + virtual ~hkpCdBodyPairCollector(); + + virtual void addCdBodyPair(const hkpCdBody& bodyA, const hkpCdBody& bodyB) = 0; + virtual void reset(); + + inline hkBool getEarlyOut() const; + +protected: + hkBool m_earlyOut; +}; + +inline hkpCdBodyPairCollector::hkpCdBodyPairCollector() { + reset(); +} + +inline hkpCdBodyPairCollector::~hkpCdBodyPairCollector() = default; + +inline void hkpCdBodyPairCollector::reset() { + m_earlyOut = true; +} + +inline hkBool hkpCdBodyPairCollector::getEarlyOut() const { + return m_earlyOut; +} diff --git a/lib/hkStubs/Havok/Physics2012/Collide/Dispatch/BroadPhase/hkpBroadPhaseListener.h b/lib/hkStubs/Havok/Physics2012/Collide/Dispatch/BroadPhase/hkpBroadPhaseListener.h new file mode 100644 index 00000000..6cf643e9 --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Collide/Dispatch/BroadPhase/hkpBroadPhaseListener.h @@ -0,0 +1,12 @@ +#pragma once + +class hkpTypedBroadPhaseHandlePair; + +class hkpBroadPhaseListener { +public: + virtual ~hkpBroadPhaseListener() = default; + + virtual void addCollisionPair(hkpTypedBroadPhaseHandlePair& pair) = 0; + + virtual void removeCollisionPair(hkpTypedBroadPhaseHandlePair& pair) = 0; +}; diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpAabbPhantom.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpAabbPhantom.h new file mode 100644 index 00000000..7f3c547a --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpAabbPhantom.h @@ -0,0 +1,64 @@ +#pragma once + +#include +#include + +class hkpCdPointCollector; +struct hkpLinearCastInput; +struct hkpWorldRayCastInput; +struct hkpWorldRayCastOutput; + +class hkpAabbPhantom : public hkpPhantom { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpAabbPhantom) + HK_DECLARE_REFLECTION() + + explicit hkpAabbPhantom(const hkAabb& aabb, hkUint32 collisionFilterInfo = 0); + explicit hkpAabbPhantom(hkFinishLoadedObjectFlag flag); + ~hkpAabbPhantom() override; + + hkpPhantomType getType() const override; + + inline hkArray& getOverlappingCollidables(); + + void castRay(const hkpWorldRayCastInput& input, hkpRayHitCollector& collector) const; + void castRay(const hkpWorldRayCastInput& input, hkpWorldRayCastOutput& output) const; + + void linearCast(const hkpCollidable* const toBeCast, const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, hkpCdPointCollector* startCollector) const; + + void calcAabb(hkAabb& aabb) override; + void addOverlappingCollidable(hkpCollidable* collidable) override; + hkBool isOverlappingCollidableAdded(const hkpCollidable* collidable) override; + void removeOverlappingCollidable(hkpCollidable* collidable) override; + hkpPhantom* clone() const override; + + void setAabb(const hkAabb& newAabb); + inline const hkAabb& getAabb() const; + +protected: + hkMotionState* getMotionState() override { return nullptr; } + + friend class hkpPhantomBatchMoveUtil; + + hkAabb m_aabb; + hkArray m_overlappingCollidables; + +public: + void ensureDeterministicOrder() override; + + class OrderByUid; + hkBool m_orderDirty; + +public: + // Internal. + void deallocateInternalArrays() override; +}; + +inline hkArray& hkpAabbPhantom::getOverlappingCollidables() { + return m_overlappingCollidables; +} + +inline const hkAabb& hkpAabbPhantom::getAabb() const { + return m_aabb; +} diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpCachingShapePhantom.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpCachingShapePhantom.h new file mode 100644 index 00000000..a9a26f8e --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpCachingShapePhantom.h @@ -0,0 +1,65 @@ +#pragma once + +#include + +class hkpCollisionAgent; + +class hkpCachingShapePhantom : public hkpShapePhantom { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpCachingShapePhantom) + HK_DECLARE_REFLECTION() + + hkpCachingShapePhantom(const hkpShape* shape, const hkTransform& transform, + hkUint32 m_collisionFilterInfo = 0); + explicit hkpCachingShapePhantom(hkFinishLoadedObjectFlag flag) : hkpShapePhantom(flag) {} + + ~hkpCachingShapePhantom() override; + + hkpPhantomType getType() const override; + + void setPositionAndLinearCast(const hkVector4& position, const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) override; + + void setTransformAndLinearCast(const hkTransform& transform, const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) override; + + hkpPhantom* clone() const override; + + void getClosestPoints(hkpCdPointCollector& collector, const hkpCollisionInput* input) override; + + void ensureDeterministicOrder() override; + + void getPenetrations(hkpCdBodyPairCollector& collector, + const hkpCollisionInput* input) override; + + struct CollisionDetail { + HK_DECLARE_CLASS_ALLOCATOR(CollisionDetail) + + hkpCollisionAgent* m_agent; + hkpCollidable* m_collidable; + }; + + inline hkArray& getCollisionDetails(); + + void addOverlappingCollidable(hkpCollidable* collidable) override; + void removeOverlappingCollidable(hkpCollidable* collidable) override; + hkBool isOverlappingCollidableAdded(const hkpCollidable* collidable) override; + void updateShapeCollectionFilter() override; + +protected: + hkArray m_collisionDetails; + +public: + void deallocateInternalArrays() override; + + hkBool m_orderDirty; + + class OrderByUid; +}; + +inline hkArray& +hkpCachingShapePhantom::getCollisionDetails() { + return m_collisionDetails; +} diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantom.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantom.h new file mode 100644 index 00000000..b733e4af --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantom.h @@ -0,0 +1,113 @@ +#pragma once + +#include +#include +#include +#include + +class hkpPhantomListener; +class hkpPhantomOverlapListener; + +class hkpPhantom : public hkpWorldObject { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpPhantom) + HK_DECLARE_REFLECTION() + + explicit hkpPhantom(hkFinishLoadedObjectFlag flag) : hkpWorldObject(flag) {} + ~hkpPhantom() override; + + virtual hkpPhantomType getType() const = 0; + + virtual void calcAabb(hkAabb& aabb) = 0; + + virtual void addOverlappingCollidable(hkpCollidable* collidable) = 0; + + virtual hkBool isOverlappingCollidableAdded(const hkpCollidable* collidable) = 0; + + virtual void removeOverlappingCollidable(hkpCollidable* collidable) = 0; + + virtual void ensureDeterministicOrder() = 0; + + virtual hkpPhantom* clone() const = 0; + + void addPhantomListener(hkpPhantomListener* el); + void removePhantomListener(hkpPhantomListener* el); + + void addPhantomOverlapListener(hkpPhantomOverlapListener* el); + void removePhantomOverlapListener(hkpPhantomOverlapListener* el); + + inline const hkArray& getPhantomListeners() const; + inline const hkArray& getPhantomOverlapListeners() const; + + virtual void updateShapeCollectionFilter() {} + + void updateBroadPhase(const hkAabb& aabb); + void setBoundingVolumeData(const hkAabb& aabb); + + void firePhantomAdded(); + void firePhantomRemoved(); + void firePhantomShapeSet(); + +protected: + inline explicit hkpPhantom(const hkpShape* shape); + + inline hkpCollidableAccept fireCollidableAdded(const hkpCollidable* collidable); + inline void fireCollidableRemoved(const hkpCollidable* collidable, hkBool collidableWasAdded); + void firePhantomDeleted(); + + hkArray m_overlapListeners; + hkArray m_phantomListeners; + + friend class hkpPhantomBatchMoveUtil; + + void removeNullOverlapListeners(); + void removeNullPhantomListeners(); + +public: + // Internal. + virtual void deallocateInternalArrays(); +}; + +inline hkpPhantom* hkpGetPhantom(const hkpCollidable* collidable) { + if (collidable->getType() == hkpWorldObject::BROAD_PHASE_PHANTOM) + return static_cast(hkpGetWorldObject(collidable)); + return nullptr; +} + +inline const hkArray& hkpPhantom::getPhantomListeners() const { + return m_phantomListeners; +} + +inline const hkArray& hkpPhantom::getPhantomOverlapListeners() const { + return m_overlapListeners; +} + +inline hkpPhantom::hkpPhantom(const hkpShape* shape) : hkpWorldObject(shape, BROAD_PHASE_PHANTOM) { + m_collidable.setOwner(this); +} + +inline hkpCollidableAccept hkpPhantom::fireCollidableAdded(const hkpCollidable* collidable) { + hkpCollidableAddedEvent event; + event.m_collidable = collidable; + event.m_phantom = this; + event.m_collidableAccept = HK_COLLIDABLE_ACCEPT; + + for (int i = m_overlapListeners.getSize() - 1; i >= 0; i--) { + if (m_overlapListeners[i]) + m_overlapListeners[i]->collidableAddedCallback(event); + } + return event.m_collidableAccept; +} + +inline void hkpPhantom::fireCollidableRemoved(const hkpCollidable* collidable, + hkBool collidableWasAdded) { + hkpCollidableRemovedEvent event; + event.m_collidable = collidable; + event.m_phantom = this; + event.m_collidableWasAdded = collidableWasAdded; + + for (int i = m_overlapListeners.getSize() - 1; i >= 0; i--) { + if (m_overlapListeners[i]) + m_overlapListeners[i]->collidableRemovedCallback(event); + } +} diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomBroadPhaseListener.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomBroadPhaseListener.h new file mode 100644 index 00000000..26c2a16e --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomBroadPhaseListener.h @@ -0,0 +1,14 @@ +#pragma once + +#include +#include + +class hkpPhantomBroadPhaseListener : public hkReferencedObject, public hkpBroadPhaseListener { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpPhantomBroadPhaseListener) + + hkpPhantomBroadPhaseListener() = default; + + void addCollisionPair(hkpTypedBroadPhaseHandlePair& pair) override; + void removeCollisionPair(hkpTypedBroadPhaseHandlePair& pair) override; +}; diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomListener.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomListener.h new file mode 100644 index 00000000..8ff21602 --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomListener.h @@ -0,0 +1,21 @@ +#pragma once + +#include + +class hkpPhantomListener { +public: + virtual ~hkpPhantomListener() = default; + + virtual void phantomAddedCallback(hkpPhantom* phantom) {} + + virtual void phantomRemovedCallback(hkpPhantom* phantom) {} + + virtual void phantomShapeSetCallback(hkpPhantom* phantom) { + if (phantom->getWorld()) { + phantomRemovedCallback(phantom); + phantomAddedCallback(phantom); + } + } + + virtual void phantomDeletedCallback(hkpPhantom* phantom) {} +}; diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomType.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomType.h new file mode 100644 index 00000000..f688844a --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpPhantomType.h @@ -0,0 +1,26 @@ +#pragma once + +enum hkpPhantomType { + /// hkpAabbPhantom + HK_PHANTOM_AABB = 0, + + /// hkpSimpleShapePhantom + HK_PHANTOM_SIMPLE_SHAPE = 1, + + /// hkpCachingShapePhantom + HK_PHANTOM_CACHING_SHAPE = 2, + + /// User-defined types + HK_PHANTOM_USER0, + HK_PHANTOM_USER1, + HK_PHANTOM_USER2, + HK_PHANTOM_USER3, + HK_PHANTOM_USER4, + HK_PHANTOM_USER5, + HK_PHANTOM_USER6, + HK_PHANTOM_USER7, + HK_PHANTOM_USER8, + HK_PHANTOM_USER9, + + HK_PHANTOM_MAX_ID +}; diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpShapePhantom.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpShapePhantom.h new file mode 100644 index 00000000..ba7cf3d5 --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpShapePhantom.h @@ -0,0 +1,56 @@ +#pragma once + +#include +#include + +class hkpCdBodyPairCollector; +class hkpCdPointCollector; +struct hkpCollisionInput; +struct hkpLinearCastInput; + +class hkpShapePhantom : public hkpPhantom { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpShapePhantom) + HK_DECLARE_REFLECTION() + + hkpShapePhantom(const hkpShape* shape, const hkTransform& transform); + explicit hkpShapePhantom(hkFinishLoadedObjectFlag flag) : hkpPhantom(flag) {} + + virtual void setPositionAndLinearCast(const hkVector4& position, + const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) = 0; + + virtual void setTransformAndLinearCast(const hkTransform& transform, + const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) = 0; + + virtual void getClosestPoints(hkpCdPointCollector& collector, + const hkpCollisionInput* input) = 0; + void getClosestPoints(hkpCdPointCollector& collector) { getClosestPoints(collector, nullptr); } + + virtual void getPenetrations(hkpCdBodyPairCollector& collector, + const hkpCollisionInput* input) = 0; + void getPenetrations(hkpCdBodyPairCollector& collector) { getPenetrations(collector, nullptr); } + + inline const hkTransform& getTransform() const; + void setTransform(const hkTransform& transform); + + void setPosition(const hkVector4& position, hkReal extraTolerance = 0.0f); + + hkWorldOperation::Result setShape(const hkpShape* shape) override; + + void calcAabb(hkAabb& aabb) override; + + hkMotionState* getMotionState() override; + + hkMotionState m_motionState; + +public: + void deallocateInternalArrays() override; +}; + +inline const hkTransform& hkpShapePhantom::getTransform() const { + return m_motionState.getTransform(); +} diff --git a/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpSimpleShapePhantom.h b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpSimpleShapePhantom.h new file mode 100644 index 00000000..0ab2deb8 --- /dev/null +++ b/lib/hkStubs/Havok/Physics2012/Dynamics/Phantom/hkpSimpleShapePhantom.h @@ -0,0 +1,62 @@ +#pragma once + +#include + +class hkpSimpleShapePhantom : public hkpShapePhantom { +public: + HK_DECLARE_CLASS_ALLOCATOR(hkpSimpleShapePhantom) + HK_DECLARE_REFLECTION() + + hkpSimpleShapePhantom(const hkpShape* shape, const hkTransform& transform, + hkUint32 m_collisionFilterInfo = 0); + explicit hkpSimpleShapePhantom(hkFinishLoadedObjectFlag flag) : hkpShapePhantom(flag) {} + ~hkpSimpleShapePhantom() override; + + hkpPhantomType getType() const override; + + void setPositionAndLinearCast(const hkVector4& position, const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) override; + + void setTransformAndLinearCast(const hkTransform& transform, const hkpLinearCastInput& input, + hkpCdPointCollector& castCollector, + hkpCdPointCollector* startCollector) override; + + void getClosestPoints(hkpCdPointCollector& collector, const hkpCollisionInput* input) override; + + void ensureDeterministicOrder() override; + + void getPenetrations(hkpCdBodyPairCollector& collector, + const hkpCollisionInput* input) override; + + hkpPhantom* clone() const override; + +public: + void addOverlappingCollidable(hkpCollidable* collidable) override; + hkBool isOverlappingCollidableAdded(const hkpCollidable* collidable) override; + void removeOverlappingCollidable(hkpCollidable* collidable) override; + + struct CollisionDetail { + HK_DECLARE_CLASS_ALLOCATOR(CollisionDetail) + HK_DECLARE_REFLECTION() + + hkpCollidable* m_collidable; + }; + + inline hkArray& getCollisionDetails(); + +protected: + hkArray m_collisionDetails; + +public: + void deallocateInternalArrays() override; + + hkBool m_orderDirty; + + class OrderByUid; +}; + +inline hkArray& +hkpSimpleShapePhantom::getCollisionDetails() { + return m_collisionDetails; +}