@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/AABoxCast.h

@@ -0,0 +1,20 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Geometry/AABox.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Structure that holds AABox moving linearly through 3d space
+struct AABoxCast
+{
+	JPH_OVERRIDE_NEW_DELETE
+
+	AABox						mBox;						///< Axis aligned box at starting location
+	Vec3						mDirection;					///< Direction and length of the cast (anything beyond this length will not be reported as a hit)
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/ActiveEdgeMode.h

@@ -0,0 +1,17 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// How to treat active/inactive edges.
+/// An active edge is an edge that either has no neighbouring edge or if the angle between the two connecting faces is too large, see: ActiveEdges
+enum class EActiveEdgeMode : uint8
+{
+	CollideOnlyWithActive,								///< Do not collide with inactive edges. For physics simulation, this gives less ghost collisions.
+	CollideWithAll,										///< Collide with all edges. Use this when you're interested in all collisions.
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/ActiveEdges.h

@@ -0,0 +1,114 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Geometry/ClosestPoint.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// An active edge is an edge that either has no neighbouring edge or if the angle between the two connecting faces is too large.
+namespace ActiveEdges
+{
+	/// Helper function to check if an edge is active or not
+	/// @param inNormal1 Triangle normal of triangle on the left side of the edge (when looking along the edge from the top)
+	/// @param inNormal2 Triangle normal of triangle on the right side of the edge
+	/// @param inEdgeDirection Vector that points along the edge
+	/// @param inCosThresholdAngle Cosine of the threshold angle (if the angle between the two triangles is bigger than this, the edge is active, note that a concave edge is always inactive)
+	inline static bool					IsEdgeActive(Vec3Arg inNormal1, Vec3Arg inNormal2, Vec3Arg inEdgeDirection, float inCosThresholdAngle)
+	{
+		// If normals are opposite the edges are active (the triangles are back to back)
+		float cos_angle_normals = inNormal1.Dot(inNormal2);
+		if (cos_angle_normals < -0.999848f) // cos(179 degrees)
+			return true;
+
+		// Check if concave edge, if so we are not active
+		if (inNormal1.Cross(inNormal2).Dot(inEdgeDirection) < 0.0f)
+			return false;
+
+		// Convex edge, active when angle bigger than threshold
+		return cos_angle_normals < inCosThresholdAngle;
+	}
+
+	/// Replace normal by triangle normal if a hit is hitting an inactive edge
+	/// @param inV0 , inV1 , inV2 form the triangle
+	/// @param inTriangleNormal is the normal of the provided triangle (does not need to be normalized)
+	/// @param inActiveEdges bit 0 = edge v0..v1 is active, bit 1 = edge v1..v2 is active, bit 2 = edge v2..v0 is active
+	/// @param inPoint Collision point on the triangle
+	/// @param inNormal Collision normal on the triangle (does not need to be normalized)
+	/// @param inMovementDirection Can be zero. This gives an indication of in which direction the motion is to determine if when we hit an inactive edge/triangle we should return the triangle normal.
+	/// @return Returns inNormal if an active edge was hit, otherwise returns inTriangleNormal
+	inline static Vec3					FixNormal(Vec3Arg inV0, Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inTriangleNormal, uint8 inActiveEdges, Vec3Arg inPoint, Vec3Arg inNormal, Vec3Arg inMovementDirection)
+	{
+		// Check: All of the edges are active, we have the correct normal already. No need to call this function!
+		JPH_ASSERT(inActiveEdges != 0b111);
+
+		// If inNormal would affect movement less than inTriangleNormal use inNormal
+		// This is done since it is really hard to make a distinction between sliding over a horizontal triangulated grid and hitting an edge (in this case you want to use the triangle normal)
+		// and sliding over a triangulated grid and grazing a vertical triangle with an inactive edge (in this case using the triangle normal will cause the object to bounce back so we want to use the calculated normal).
+		// To solve this we take a movement hint to give an indication of what direction our object is moving. If the edge normal results in less motion difference than the triangle normal we use the edge normal.
+		float normal_length = inNormal.Length();
+		float triangle_normal_length = inTriangleNormal.Length();
+		if (inMovementDirection.Dot(inNormal) * triangle_normal_length < inMovementDirection.Dot(inTriangleNormal) * normal_length)
+			return inNormal;
+
+		// Check: None of the edges are active, we need to use the triangle normal
+		if (inActiveEdges == 0)
+			return inTriangleNormal;
+
+		// Some edges are active.
+		// If normal is parallel to the triangle normal we don't need to check the active edges.
+		if (inTriangleNormal.Dot(inNormal) > 0.999848f * normal_length * triangle_normal_length) // cos(1 degree)
+			return inNormal;
+
+		const float cEpsilon = 1.0e-4f;
+		const float cOneMinusEpsilon = 1.0f - cEpsilon;
+
+		uint colliding_edge;
+
+		// Test where the contact point is in the triangle
+		float u, v, w;
+		ClosestPoint::GetBaryCentricCoordinates(inV0 - inPoint, inV1 - inPoint, inV2 - inPoint, u, v, w);
+		if (u > cOneMinusEpsilon)
+		{
+			// Colliding with v0, edge 0 or 2 needs to be active
+			colliding_edge = 0b101;
+		}
+		else if (v > cOneMinusEpsilon)
+		{
+			// Colliding with v1, edge 0 or 1 needs to be active
+			colliding_edge = 0b011;
+		}
+		else if (w > cOneMinusEpsilon)
+		{
+			// Colliding with v2, edge 1 or 2 needs to be active
+			colliding_edge = 0b110;
+		}
+		else if (u < cEpsilon)
+		{
+			// Colliding with edge v1, v2, edge 1 needs to be active
+			colliding_edge = 0b010;
+		}
+		else if (v < cEpsilon)
+		{
+			// Colliding with edge v0, v2, edge 2 needs to be active
+			colliding_edge = 0b100;
+		}
+		else if (w < cEpsilon)
+		{
+			// Colliding with edge v0, v1, edge 0 needs to be active
+			colliding_edge = 0b001;
+		}
+		else
+		{
+			// Interior hit
+			return inTriangleNormal;
+		}
+
+		// If this edge is active, use the provided normal instead of the triangle normal
+		return (inActiveEdges & colliding_edge) != 0? inNormal : inTriangleNormal;
+	}
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/BackFaceMode.h

@@ -0,0 +1,16 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// How collision detection functions will treat back facing triangles
+enum class EBackFaceMode : uint8
+{
+	IgnoreBackFaces,									///< Ignore collision with back facing surfaces/triangles
+	CollideWithBackFaces,								///< Collide with back facing surfaces/triangles
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/BroadPhase/BroadPhase.cpp

@@ -0,0 +1,16 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Collision/BroadPhase/BroadPhase.h>
+
+JPH_NAMESPACE_BEGIN
+
+void BroadPhase::Init(BodyManager *inBodyManager, const BroadPhaseLayerInterface &inLayerInterface)
+{
+	mBodyManager = inBodyManager;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/BroadPhase/BroadPhase.h

@@ -0,0 +1,109 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseQuery.h>
+#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseLayer.h>
+
+JPH_NAMESPACE_BEGIN
+
+// Shorthand function to ifdef out code if broadphase stats tracking is off
+#ifdef JPH_TRACK_BROADPHASE_STATS
+	#define JPH_IF_TRACK_BROADPHASE_STATS(...) __VA_ARGS__
+#else
+	#define JPH_IF_TRACK_BROADPHASE_STATS(...)
+#endif // JPH_TRACK_BROADPHASE_STATS
+
+class BodyManager;
+struct BodyPair;
+
+using BodyPairCollector = CollisionCollector<BodyPair, CollisionCollectorTraitsCollideShape>;
+
+/// Used to do coarse collision detection operations to quickly prune out bodies that will not collide.
+class JPH_EXPORT BroadPhase : public BroadPhaseQuery
+{
+public:
+	/// Initialize the broadphase.
+	/// @param inBodyManager The body manager singleton
+	/// @param inLayerInterface Interface that maps object layers to broadphase layers.
+	/// Note that the broadphase takes a pointer to the data inside inObjectToBroadPhaseLayer so this object should remain static.
+	virtual void		Init(BodyManager *inBodyManager, const BroadPhaseLayerInterface &inLayerInterface);
+
+	/// Should be called after many objects have been inserted to make the broadphase more efficient, usually done on startup only
+	virtual void		Optimize()															{ /* Optionally overridden by implementation */ }
+
+	/// Must be called just before updating the broadphase when none of the body mutexes are locked
+	virtual void		FrameSync()															{ /* Optionally overridden by implementation */ }
+
+	/// Must be called before UpdatePrepare to prevent modifications from being made to the tree
+	virtual void		LockModifications()													{ /* Optionally overridden by implementation */ }
+
+	/// Context used during broadphase update
+	struct UpdateState { void *mData[4]; };
+
+	/// Update the broadphase, needs to be called frequently to update the internal state when bodies have been modified.
+	/// The UpdatePrepare() function can run in a background thread without influencing the broadphase
+	virtual	UpdateState	UpdatePrepare()														{ return UpdateState(); }
+
+	/// Finalizing the update will quickly apply the changes
+	virtual void		UpdateFinalize([[maybe_unused]] const UpdateState &inUpdateState)	{ /* Optionally overridden by implementation */ }
+
+	/// Must be called after UpdateFinalize to allow modifications to the broadphase
+	virtual void		UnlockModifications()												{ /* Optionally overridden by implementation */ }
+
+	/// Handle used during adding bodies to the broadphase
+	using AddState = void *;
+
+	/// Prepare adding inNumber bodies at ioBodies to the broadphase, returns a handle that should be used in AddBodiesFinalize/Abort.
+	/// This can be done on a background thread without influencing the broadphase.
+	/// ioBodies may be shuffled around by this function and should be kept that way until AddBodiesFinalize/Abort is called.
+	virtual AddState	AddBodiesPrepare([[maybe_unused]] BodyID *ioBodies, [[maybe_unused]] int inNumber) { return nullptr; } // By default the broadphase doesn't support this
+
+	/// Finalize adding bodies to the broadphase, supply the return value of AddBodiesPrepare in inAddState.
+	/// Please ensure that the ioBodies array passed to AddBodiesPrepare is unmodified and passed again to this function.
+	virtual void		AddBodiesFinalize(BodyID *ioBodies, int inNumber, AddState inAddState) = 0;
+
+	/// Abort adding bodies to the broadphase, supply the return value of AddBodiesPrepare in inAddState.
+	/// This can be done on a background thread without influencing the broadphase.
+	/// Please ensure that the ioBodies array passed to AddBodiesPrepare is unmodified and passed again to this function.
+	virtual void		AddBodiesAbort([[maybe_unused]] BodyID *ioBodies, [[maybe_unused]] int inNumber, [[maybe_unused]] AddState inAddState)	{ /* By default nothing needs to be done */ }
+
+	/// Remove inNumber bodies in ioBodies from the broadphase.
+	/// ioBodies may be shuffled around by this function.
+	virtual void		RemoveBodies(BodyID *ioBodies, int inNumber) = 0;
+
+	/// Call whenever the aabb of a body changes (can change order of ioBodies array)
+	/// inTakeLock should be false if we're between LockModifications/UnlockModifications, in which case care needs to be taken to not call this between UpdatePrepare/UpdateFinalize
+	virtual void		NotifyBodiesAABBChanged(BodyID *ioBodies, int inNumber, bool inTakeLock = true) = 0;
+
+	/// Call whenever the layer (and optionally the aabb as well) of a body changes (can change order of ioBodies array)
+	virtual void		NotifyBodiesLayerChanged(BodyID *ioBodies, int inNumber) = 0;
+
+	/// Find all colliding pairs between dynamic bodies
+	/// Note that this function is very specifically tailored for the PhysicsSystem::Update function, hence it is not part of the BroadPhaseQuery interface.
+	/// One of the assumptions it can make is that no locking is needed during the query as it will only be called during a very particular part of the update.
+	/// @param ioActiveBodies is a list of bodies for which we need to find colliding pairs (this function can change the order of the ioActiveBodies array). This can be a subset of the set of active bodies in the system.
+	/// @param inNumActiveBodies is the size of the ioActiveBodies array.
+	/// @param inSpeculativeContactDistance Distance at which speculative contact points will be created.
+	/// @param inObjectVsBroadPhaseLayerFilter is the filter that determines if an object can collide with a broadphase layer.
+	/// @param inObjectLayerPairFilter is the filter that determines if two objects can collide.
+	/// @param ioPairCollector receives callbacks for every body pair found.
+	virtual void		FindCollidingPairs(BodyID *ioActiveBodies, int inNumActiveBodies, float inSpeculativeContactDistance, const ObjectVsBroadPhaseLayerFilter &inObjectVsBroadPhaseLayerFilter, const ObjectLayerPairFilter &inObjectLayerPairFilter, BodyPairCollector &ioPairCollector) const = 0;
+
+	/// Same as BroadPhaseQuery::CastAABox but can be implemented in a way to take no broad phase locks.
+	virtual void		CastAABoxNoLock(const AABoxCast &inBox, CastShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const = 0;
+
+#ifdef JPH_TRACK_BROADPHASE_STATS
+	/// Trace the collected broadphase stats in CSV form.
+	/// This report can be used to judge and tweak the efficiency of the broadphase.
+	virtual void		ReportStats()														{ /* Can be implemented by derived classes */ }
+#endif // JPH_TRACK_BROADPHASE_STATS
+
+protected:
+	/// Link to the body manager that manages the bodies in this broadphase
+	BodyManager *		mBodyManager = nullptr;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/BroadPhase/BroadPhaseBruteForce.cpp

@@ -0,0 +1,313 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+#include <Jolt/Physics/Collision/BroadPhase/BroadPhaseBruteForce.h>
+#include <Jolt/Physics/Collision/RayCast.h>
+#include <Jolt/Physics/Collision/AABoxCast.h>
+#include <Jolt/Physics/Collision/CastResult.h>
+#include <Jolt/Physics/Body/BodyManager.h>
+#include <Jolt/Physics/Body/BodyPair.h>
+#include <Jolt/Geometry/RayAABox.h>
+#include <Jolt/Geometry/OrientedBox.h>
+#include <Jolt/Core/QuickSort.h>
+
+JPH_NAMESPACE_BEGIN
+
+void BroadPhaseBruteForce::AddBodiesFinalize(BodyID *ioBodies, int inNumber, AddState inAddState)
+{
+	lock_guard lock(mMutex);
+
+	BodyVector &bodies = mBodyManager->GetBodies();
+
+	// Allocate space
+	uint32 idx = (uint32)mBodyIDs.size();
+	mBodyIDs.resize(idx + inNumber);
+
+	// Add bodies
+	for (const BodyID *b = ioBodies, *b_end = ioBodies + inNumber; b < b_end; ++b)
+	{
+		Body &body = *bodies[b->GetIndex()];
+
+		// Validate that body ID is consistent with array index
+		JPH_ASSERT(body.GetID() == *b);
+		JPH_ASSERT(!body.IsInBroadPhase());
+
+		// Add it to the list
+		mBodyIDs[idx] = body.GetID();
+		++idx;
+
+		// Indicate body is in the broadphase
+		body.SetInBroadPhaseInternal(true);
+	}
+
+	// Resort
+	QuickSort(mBodyIDs.begin(), mBodyIDs.end());
+}
+
+void BroadPhaseBruteForce::RemoveBodies(BodyID *ioBodies, int inNumber)
+{
+	lock_guard lock(mMutex);
+
+	BodyVector &bodies = mBodyManager->GetBodies();
+
+	JPH_ASSERT((int)mBodyIDs.size() >= inNumber);
+
+	// Remove bodies
+	for (const BodyID *b = ioBodies, *b_end = ioBodies + inNumber; b < b_end; ++b)
+	{
+		Body &body = *bodies[b->GetIndex()];
+
+		// Validate that body ID is consistent with array index
+		JPH_ASSERT(body.GetID() == *b);
+		JPH_ASSERT(body.IsInBroadPhase());
+
+		// Find body id
+		Array<BodyID>::const_iterator it = std::lower_bound(mBodyIDs.begin(), mBodyIDs.end(), body.GetID());
+		JPH_ASSERT(it != mBodyIDs.end());
+
+		// Remove element
+		mBodyIDs.erase(it);
+
+		// Indicate body is no longer in the broadphase
+		body.SetInBroadPhaseInternal(false);
+	}
+}
+
+void BroadPhaseBruteForce::NotifyBodiesAABBChanged(BodyID *ioBodies, int inNumber, bool inTakeLock)
+{
+	// Do nothing, we directly reference the body
+}
+
+void BroadPhaseBruteForce::NotifyBodiesLayerChanged(BodyID * ioBodies, int inNumber)
+{
+	// Do nothing, we directly reference the body
+}
+
+void BroadPhaseBruteForce::CastRay(const RayCast &inRay, RayCastBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	// Load ray
+	Vec3 origin(inRay.mOrigin);
+	RayInvDirection inv_direction(inRay.mDirection);
+
+	// For all bodies
+	float early_out_fraction = ioCollector.GetEarlyOutFraction();
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with ray
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			float fraction = RayAABox(origin, inv_direction, bounds.mMin, bounds.mMax);
+			if (fraction < early_out_fraction)
+			{
+				// Store hit
+				BroadPhaseCastResult result { b, fraction };
+				ioCollector.AddHit(result);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+				early_out_fraction = ioCollector.GetEarlyOutFraction();
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CollideAABox(const AABox &inBox, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	// For all bodies
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with box
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			if (bounds.Overlaps(inBox))
+			{
+				// Store hit
+				ioCollector.AddHit(b);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CollideSphere(Vec3Arg inCenter, float inRadius, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	float radius_sq = Square(inRadius);
+
+	// For all bodies
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with box
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			if (bounds.GetSqDistanceTo(inCenter) <= radius_sq)
+			{
+				// Store hit
+				ioCollector.AddHit(b);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CollidePoint(Vec3Arg inPoint, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	// For all bodies
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with box
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			if (bounds.Contains(inPoint))
+			{
+				// Store hit
+				ioCollector.AddHit(b);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CollideOrientedBox(const OrientedBox &inBox, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	// For all bodies
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with box
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			if (inBox.Overlaps(bounds))
+			{
+				// Store hit
+				ioCollector.AddHit(b);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CastAABoxNoLock(const AABoxCast &inBox, CastShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	shared_lock lock(mMutex);
+
+	// Load box
+	Vec3 origin(inBox.mBox.GetCenter());
+	Vec3 extent(inBox.mBox.GetExtent());
+	RayInvDirection inv_direction(inBox.mDirection);
+
+	// For all bodies
+	float early_out_fraction = ioCollector.GetPositiveEarlyOutFraction();
+	for (BodyID b : mBodyIDs)
+	{
+		const Body &body = mBodyManager->GetBody(b);
+
+		// Test layer
+		if (inObjectLayerFilter.ShouldCollide(body.GetObjectLayer()))
+		{
+			// Test intersection with ray
+			const AABox &bounds = body.GetWorldSpaceBounds();
+			float fraction = RayAABox(origin, inv_direction, bounds.mMin - extent, bounds.mMax + extent);
+			if (fraction < early_out_fraction)
+			{
+				// Store hit
+				BroadPhaseCastResult result { b, fraction };
+				ioCollector.AddHit(result);
+				if (ioCollector.ShouldEarlyOut())
+					break;
+				early_out_fraction = ioCollector.GetPositiveEarlyOutFraction();
+			}
+		}
+	}
+}
+
+void BroadPhaseBruteForce::CastAABox(const AABoxCast &inBox, CastShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const
+{
+	CastAABoxNoLock(inBox, ioCollector, inBroadPhaseLayerFilter, inObjectLayerFilter);
+}
+
+void BroadPhaseBruteForce::FindCollidingPairs(BodyID *ioActiveBodies, int inNumActiveBodies, float inSpeculativeContactDistance, const ObjectVsBroadPhaseLayerFilter &inObjectVsBroadPhaseLayerFilter, const ObjectLayerPairFilter &inObjectLayerPairFilter, BodyPairCollector &ioPairCollector) const
+{
+	shared_lock lock(mMutex);
+
+	// Loop through all active bodies
+	size_t num_bodies = mBodyIDs.size();
+	for (int b1 = 0; b1 < inNumActiveBodies; ++b1)
+	{
+		BodyID b1_id = ioActiveBodies[b1];
+		const Body &body1 = mBodyManager->GetBody(b1_id);
+		const ObjectLayer layer1 = body1.GetObjectLayer();
+
+		// Expand the bounding box by the speculative contact distance
+		AABox bounds1 = body1.GetWorldSpaceBounds();
+		bounds1.ExpandBy(Vec3::sReplicate(inSpeculativeContactDistance));
+
+		// For all other bodies
+		for (size_t b2 = 0; b2 < num_bodies; ++b2)
+		{
+			// Check if bodies can collide
+			BodyID b2_id = mBodyIDs[b2];
+			const Body &body2 = mBodyManager->GetBody(b2_id);
+			if (!Body::sFindCollidingPairsCanCollide(body1, body2))
+				continue;
+
+			// Check if layers can collide
+			const ObjectLayer layer2 = body2.GetObjectLayer();
+			if (!inObjectLayerPairFilter.ShouldCollide(layer1, layer2))
+				continue;
+
+			// Check if bounds overlap
+			const AABox &bounds2 = body2.GetWorldSpaceBounds();
+			if (!bounds1.Overlaps(bounds2))
+				continue;
+
+			// Store overlapping pair
+			ioPairCollector.AddHit({ b1_id, b2_id });
+		}
+	}
+}
+
+AABox BroadPhaseBruteForce::GetBounds() const
+{
+	shared_lock lock(mMutex);
+
+	AABox bounds;
+	for (BodyID b : mBodyIDs)
+		bounds.Encapsulate(mBodyManager->GetBody(b).GetWorldSpaceBounds());
+	return bounds;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/BroadPhase/BroadPhaseBruteForce.h

@@ -0,0 +1,38 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/BroadPhase/BroadPhase.h>
+#include <Jolt/Core/Mutex.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Test BroadPhase implementation that does not do anything to speed up the operations. Can be used as a reference implementation.
+class JPH_EXPORT BroadPhaseBruteForce final : public BroadPhase
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	// Implementing interface of BroadPhase (see BroadPhase for documentation)
+	virtual void		AddBodiesFinalize(BodyID *ioBodies, int inNumber, AddState inAddState) override;
+	virtual void		RemoveBodies(BodyID *ioBodies, int inNumber) override;
+	virtual void		NotifyBodiesAABBChanged(BodyID *ioBodies, int inNumber, bool inTakeLock) override;
+	virtual void		NotifyBodiesLayerChanged(BodyID *ioBodies, int inNumber) override;
+	virtual void		CastRay(const RayCast &inRay, RayCastBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CollideAABox(const AABox &inBox, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CollideSphere(Vec3Arg inCenter, float inRadius, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CollidePoint(Vec3Arg inPoint, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CollideOrientedBox(const OrientedBox &inBox, CollideShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CastAABoxNoLock(const AABoxCast &inBox, CastShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		CastAABox(const AABoxCast &inBox, CastShapeBodyCollector &ioCollector, const BroadPhaseLayerFilter &inBroadPhaseLayerFilter, const ObjectLayerFilter &inObjectLayerFilter) const override;
+	virtual void		FindCollidingPairs(BodyID *ioActiveBodies, int inNumActiveBodies, float inSpeculativeContactDistance, const ObjectVsBroadPhaseLayerFilter &inObjectVsBroadPhaseLayerFilter, const ObjectLayerPairFilter &inObjectLayerPairFilter, BodyPairCollector &ioPairCollector) const override;
+	virtual AABox		GetBounds() const override;
+
+private:
+	Array<BodyID>		mBodyIDs;
+	mutable SharedMutex	mMutex;
+};
+
+JPH_NAMESPACE_END