@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/Shape/TriangleShape.h

@@ -1,143 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/Shape/ConvexShape.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Class that constructs a TriangleShape
-class JPH_EXPORT TriangleShapeSettings final : public ConvexShapeSettings
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, TriangleShapeSettings)
-
-public:
-	/// Default constructor for deserialization
-							TriangleShapeSettings() = default;
-
-	/// Create a triangle with points (inV1, inV2, inV3) (counter clockwise) and convex radius inConvexRadius.
-	/// Note that the convex radius is currently only used for shape vs shape collision, for all other purposes the triangle is infinitely thin.
-							TriangleShapeSettings(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, float inConvexRadius = 0.0f, const PhysicsMaterial *inMaterial = nullptr) : ConvexShapeSettings(inMaterial), mV1(inV1), mV2(inV2), mV3(inV3), mConvexRadius(inConvexRadius) { }
-
-	// See: ShapeSettings
-	virtual ShapeResult		Create() const override;
-
-	Vec3					mV1;
-	Vec3					mV2;
-	Vec3					mV3;
-	float					mConvexRadius = 0.0f;
-};
-
-/// A single triangle, not the most efficient way of creating a world filled with triangles but can be used as a query shape for example.
-class JPH_EXPORT TriangleShape final : public ConvexShape
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Constructor
-							TriangleShape() : ConvexShape(EShapeSubType::Triangle) { }
-							TriangleShape(const TriangleShapeSettings &inSettings, ShapeResult &outResult);
-
-	/// Create a triangle with points (inV1, inV2, inV3) (counter clockwise) and convex radius inConvexRadius.
-	/// Note that the convex radius is currently only used for shape vs shape collision, for all other purposes the triangle is infinitely thin.
-							TriangleShape(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3, float inConvexRadius = 0.0f, const PhysicsMaterial *inMaterial = nullptr) : ConvexShape(EShapeSubType::Triangle, inMaterial), mV1(inV1), mV2(inV2), mV3(inV3), mConvexRadius(inConvexRadius) { JPH_ASSERT(inConvexRadius >= 0.0f); }
-
-	/// Get the vertices of the triangle
-	inline Vec3				GetVertex1() const																	{ return mV1; }
-	inline Vec3				GetVertex2() const																	{ return mV2; }
-	inline Vec3				GetVertex3() const																	{ return mV3; }
-
-	/// Convex radius
-	float					GetConvexRadius() const																{ return mConvexRadius; }
-
-	// See Shape::GetLocalBounds
-	virtual AABox			GetLocalBounds() const override;
-
-	// See Shape::GetWorldSpaceBounds
-	virtual AABox			GetWorldSpaceBounds(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale) const override;
-	using Shape::GetWorldSpaceBounds;
-
-	// See Shape::GetInnerRadius
-	virtual float			GetInnerRadius() const override														{ return mConvexRadius; }
-
-	// See Shape::GetMassProperties
-	virtual MassProperties	GetMassProperties() const override;
-
-	// See Shape::GetSurfaceNormal
-	virtual Vec3			GetSurfaceNormal(const SubShapeID &inSubShapeID, Vec3Arg inLocalSurfacePosition) const override;
-
-	// See Shape::GetSupportingFace
-	virtual void			GetSupportingFace(const SubShapeID &inSubShapeID, Vec3Arg inDirection, Vec3Arg inScale, Mat44Arg inCenterOfMassTransform, SupportingFace &outVertices) const override;
-
-	// See ConvexShape::GetSupportFunction
-	virtual const Support *	GetSupportFunction(ESupportMode inMode, SupportBuffer &inBuffer, Vec3Arg inScale) const override;
-
-	// See Shape::GetSubmergedVolume
-	virtual void			GetSubmergedVolume(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, const Plane &inSurface, float &outTotalVolume, float &outSubmergedVolume, Vec3 &outCenterOfBuoyancy JPH_IF_DEBUG_RENDERER(, RVec3Arg inBaseOffset)) const override;
-
-#ifdef JPH_DEBUG_RENDERER
-	// See Shape::Draw
-	virtual void			Draw(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, Vec3Arg inScale, ColorArg inColor, bool inUseMaterialColors, bool inDrawWireframe) const override;
-#endif // JPH_DEBUG_RENDERER
-
-	// See Shape::CastRay
-	virtual bool			CastRay(const RayCast &inRay, const SubShapeIDCreator &inSubShapeIDCreator, RayCastResult &ioHit) const override;
-	virtual void			CastRay(const RayCast &inRay, const RayCastSettings &inRayCastSettings, const SubShapeIDCreator &inSubShapeIDCreator, CastRayCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const override;
-
-	// See: Shape::CollidePoint
-	virtual void			CollidePoint(Vec3Arg inPoint, const SubShapeIDCreator &inSubShapeIDCreator, CollidePointCollector &ioCollector, const ShapeFilter &inShapeFilter = { }) const override;
-
-	// See: Shape::CollideSoftBodyVertices
-	virtual void			CollideSoftBodyVertices(Mat44Arg inCenterOfMassTransform, Vec3Arg inScale, const CollideSoftBodyVertexIterator &inVertices, uint inNumVertices, int inCollidingShapeIndex) const override;
-
-	// See Shape::GetTrianglesStart
-	virtual void			GetTrianglesStart(GetTrianglesContext &ioContext, const AABox &inBox, Vec3Arg inPositionCOM, QuatArg inRotation, Vec3Arg inScale) const override;
-
-	// See Shape::GetTrianglesNext
-	virtual int				GetTrianglesNext(GetTrianglesContext &ioContext, int inMaxTrianglesRequested, Float3 *outTriangleVertices, const PhysicsMaterial **outMaterials = nullptr) const override;
-
-	// See Shape
-	virtual void			SaveBinaryState(StreamOut &inStream) const override;
-
-	// See Shape::GetStats
-	virtual Stats			GetStats() const override															{ return Stats(sizeof(*this), 1); }
-
-	// See Shape::GetVolume
-	virtual float			GetVolume() const override															{ return 0; }
-
-	// See Shape::IsValidScale
-	virtual bool			IsValidScale(Vec3Arg inScale) const override;
-
-	// See Shape::MakeScaleValid
-	virtual Vec3			MakeScaleValid(Vec3Arg inScale) const override;
-
-	// Register shape functions with the registry
-	static void				sRegister();
-
-protected:
-	// See: Shape::RestoreBinaryState
-	virtual void			RestoreBinaryState(StreamIn &inStream) override;
-
-private:
-	// Helper functions called by CollisionDispatch
-	static void				sCollideConvexVsTriangle(const Shape *inShape1, const Shape *inShape2, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter);
-	static void				sCollideSphereVsTriangle(const Shape *inShape1, const Shape *inShape2, Vec3Arg inScale1, Vec3Arg inScale2, Mat44Arg inCenterOfMassTransform1, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, const CollideShapeSettings &inCollideShapeSettings, CollideShapeCollector &ioCollector, const ShapeFilter &inShapeFilter);
-	static void				sCastConvexVsTriangle(const ShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, const Shape *inShape, Vec3Arg inScale, const ShapeFilter &inShapeFilter, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, CastShapeCollector &ioCollector);
-	static void				sCastSphereVsTriangle(const ShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, const Shape *inShape, Vec3Arg inScale, const ShapeFilter &inShapeFilter, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, CastShapeCollector &ioCollector);
-
-	// Context for GetTrianglesStart/Next
-	class					TSGetTrianglesContext;
-
-	// Classes for GetSupportFunction
-	class					TriangleNoConvex;
-	class					TriangleWithConvex;
-
-	Vec3					mV1;
-	Vec3					mV2;
-	Vec3					mV3;
-	float					mConvexRadius = 0.0f;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,173 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Geometry/AABox.h>
-#include <Jolt/Physics/Collision/CollideShape.h>
-#include <Jolt/Physics/Collision/Shape/Shape.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Structure that holds a single shape cast (a shape moving along a linear path in 3d space with no rotation)
-template <class Vec, class Mat, class ShapeCastType>
-struct ShapeCastT
-{
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Constructor
-								ShapeCastT(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inCenterOfMassStart, Vec3Arg inDirection, const AABox &inWorldSpaceBounds) :
-		mShape(inShape),
-		mScale(inScale),
-		mCenterOfMassStart(inCenterOfMassStart),
-		mDirection(inDirection),
-		mShapeWorldBounds(inWorldSpaceBounds)
-	{
-	}
-
-	/// Constructor
-								ShapeCastT(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inCenterOfMassStart, Vec3Arg inDirection) :
-		ShapeCastT<Vec, Mat, ShapeCastType>(inShape, inScale, inCenterOfMassStart, inDirection, inShape->GetWorldSpaceBounds(inCenterOfMassStart, inScale))
-	{
-	}
-
-	/// Construct a shape cast using a world transform for a shape instead of a center of mass transform
-	static inline ShapeCastType	sFromWorldTransform(const Shape *inShape, Vec3Arg inScale, typename Mat::ArgType inWorldTransform, Vec3Arg inDirection)
-	{
-		return ShapeCastType(inShape, inScale, inWorldTransform.PreTranslated(inShape->GetCenterOfMass()), inDirection);
-	}
-
-	/// Transform this shape cast using inTransform. Multiply transform on the left left hand side.
-	ShapeCastType				PostTransformed(typename Mat::ArgType inTransform) const
-	{
-		Mat44 start = inTransform * mCenterOfMassStart;
-		Vec3 direction = inTransform.Multiply3x3(mDirection);
-		return { mShape, mScale, start, direction };
-	}
-
-	/// Translate this shape cast by inTranslation.
-	ShapeCastType				PostTranslated(typename Vec::ArgType inTranslation) const
-	{
-		return { mShape, mScale, mCenterOfMassStart.PostTranslated(inTranslation), mDirection };
-	}
-
-	/// Get point with fraction inFraction on ray from mCenterOfMassStart to mCenterOfMassStart + mDirection (0 = start of ray, 1 = end of ray)
-	inline Vec					GetPointOnRay(float inFraction) const
-	{
-		return mCenterOfMassStart.GetTranslation() + inFraction * mDirection;
-	}
-
-	const Shape *				mShape;								///< Shape that's being cast (cannot be mesh shape). Note that this structure does not assume ownership over the shape for performance reasons.
-	const Vec3					mScale;								///< Scale in local space of the shape being cast (scales relative to its center of mass)
-	const Mat					mCenterOfMassStart;					///< Start position and orientation of the center of mass of the shape (construct using sFromWorldTransform if you have a world transform for your shape)
-	const Vec3					mDirection;							///< Direction and length of the cast (anything beyond this length will not be reported as a hit)
-	const AABox					mShapeWorldBounds;					///< Cached shape's world bounds, calculated in constructor
-};
-
-struct ShapeCast : public ShapeCastT<Vec3, Mat44, ShapeCast>
-{
-	using ShapeCastT<Vec3, Mat44, ShapeCast>::ShapeCastT;
-};
-
-struct RShapeCast : public ShapeCastT<RVec3, RMat44, RShapeCast>
-{
-	using ShapeCastT<RVec3, RMat44, RShapeCast>::ShapeCastT;
-
-	/// Convert from ShapeCast, converts single to double precision
-	explicit					RShapeCast(const ShapeCast &inCast) :
-		RShapeCast(inCast.mShape, inCast.mScale, RMat44(inCast.mCenterOfMassStart), inCast.mDirection, inCast.mShapeWorldBounds)
-	{
-	}
-
-	/// Convert to ShapeCast, which implies casting from double precision to single precision
-	explicit					operator ShapeCast() const
-	{
-		return ShapeCast(mShape, mScale, mCenterOfMassStart.ToMat44(), mDirection, mShapeWorldBounds);
-	}
-};
-
-/// Settings to be passed with a shape cast
-class ShapeCastSettings : public CollideSettingsBase
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Set the backfacing mode for all shapes
-	void						SetBackFaceMode(EBackFaceMode inMode) { mBackFaceModeTriangles = mBackFaceModeConvex = inMode; }
-
-	/// How backfacing triangles should be treated (should we report moving from back to front for triangle based shapes, e.g. for MeshShape/HeightFieldShape?)
-	EBackFaceMode				mBackFaceModeTriangles = EBackFaceMode::IgnoreBackFaces;
-
-	/// How backfacing convex objects should be treated (should we report starting inside an object and moving out?)
-	EBackFaceMode				mBackFaceModeConvex = EBackFaceMode::IgnoreBackFaces;
-
-	/// Indicates if we want to shrink the shape by the convex radius and then expand it again. This speeds up collision detection and gives a more accurate normal at the cost of a more 'rounded' shape.
-	bool						mUseShrunkenShapeAndConvexRadius = false;
-
-	/// When true, and the shape is intersecting at the beginning of the cast (fraction = 0) then this will calculate the deepest penetration point (costing additional CPU time)
-	bool						mReturnDeepestPoint = false;
-};
-
-/// Result of a shape cast test
-class ShapeCastResult : public CollideShapeResult
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Default constructor
-								ShapeCastResult() = default;
-
-	/// Constructor
-	/// @param inFraction Fraction at which the cast hit
-	/// @param inContactPoint1 Contact point on shape 1
-	/// @param inContactPoint2 Contact point on shape 2
-	/// @param inContactNormalOrPenetrationDepth Contact normal pointing from shape 1 to 2 or penetration depth vector when the objects are penetrating (also from 1 to 2)
-	/// @param inBackFaceHit If this hit was a back face hit
-	/// @param inSubShapeID1 Sub shape id for shape 1
-	/// @param inSubShapeID2 Sub shape id for shape 2
-	/// @param inBodyID2 BodyID that was hit
-								ShapeCastResult(float inFraction, Vec3Arg inContactPoint1, Vec3Arg inContactPoint2, Vec3Arg inContactNormalOrPenetrationDepth, bool inBackFaceHit, const SubShapeID &inSubShapeID1, const SubShapeID &inSubShapeID2, const BodyID &inBodyID2) :
-		CollideShapeResult(inContactPoint1, inContactPoint2, inContactNormalOrPenetrationDepth, (inContactPoint2 - inContactPoint1).Length(), inSubShapeID1, inSubShapeID2, inBodyID2),
-		mFraction(inFraction),
-		mIsBackFaceHit(inBackFaceHit)
-	{
-	}
-
-	/// Function required by the CollisionCollector. A smaller fraction is considered to be a 'better hit'. For rays/cast shapes we can just use the collision fraction. The fraction and penetration depth are combined in such a way that deeper hits at fraction 0 go first.
-	inline float				GetEarlyOutFraction() const			{ return mFraction > 0.0f? mFraction : -mPenetrationDepth; }
-
-	/// Reverses the hit result, swapping contact point 1 with contact point 2 etc.
-	/// @param inWorldSpaceCastDirection Direction of the shape cast in world space
-	ShapeCastResult				Reversed(Vec3Arg inWorldSpaceCastDirection) const
-	{
-		// Calculate by how much to shift the contact points
-		Vec3 delta = mFraction * inWorldSpaceCastDirection;
-
-		ShapeCastResult result;
-		result.mContactPointOn2 = mContactPointOn1 - delta;
-		result.mContactPointOn1 = mContactPointOn2 - delta;
-		result.mPenetrationAxis = -mPenetrationAxis;
-		result.mPenetrationDepth = mPenetrationDepth;
-		result.mSubShapeID2 = mSubShapeID1;
-		result.mSubShapeID1 = mSubShapeID2;
-		result.mBodyID2 = mBodyID2;
-		result.mFraction = mFraction;
-		result.mIsBackFaceHit = mIsBackFaceHit;
-
-		result.mShape2Face.resize(mShape1Face.size());
-		for (Face::size_type i = 0; i < mShape1Face.size(); ++i)
-			result.mShape2Face[i] = mShape1Face[i] - delta;
-
-		result.mShape1Face.resize(mShape2Face.size());
-		for (Face::size_type i = 0; i < mShape2Face.size(); ++i)
-			result.mShape1Face[i] = mShape2Face[i] - delta;
-
-		return result;
-	}
-
-	float						mFraction;							///< This is the fraction where the shape hit the other shape: CenterOfMassOnHit = Start + value * (End - Start)
-	bool						mIsBackFaceHit;						///< True if the shape was hit from the back side
-};
-
-JPH_NAMESPACE_END

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

@@ -1,73 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Body/BodyID.h>
-#include <Jolt/Core/NonCopyable.h>
-
-JPH_NAMESPACE_BEGIN
-
-class Shape;
-class SubShapeID;
-
-/// Filter class
-class ShapeFilter : public NonCopyable
-{
-public:
-	/// Destructor
-	virtual					~ShapeFilter() = default;
-
-	/// Filter function to determine if we should collide with a shape. Returns true if the filter passes.
-	/// This overload is called when the query doesn't have a source shape (e.g. ray cast / collide point)
-	/// @param inShape2 Shape we're colliding against
-	/// @param inSubShapeIDOfShape2 The sub shape ID that will lead from the root shape to inShape2 (i.e. the shape of mBodyID2)
-	virtual bool			ShouldCollide([[maybe_unused]] const Shape *inShape2, [[maybe_unused]] const SubShapeID &inSubShapeIDOfShape2) const
-	{
-		return true;
-	}
-
-	/// Filter function to determine if two shapes should collide. Returns true if the filter passes.
-	/// This overload is called when querying a shape vs a shape (e.g. collide object / cast object).
-	/// It is called at each level of the shape hierarchy, so if you have a compound shape with a box, this function will be called twice.
-	/// It will not be called on triangles that are part of another shape, i.e a mesh shape will not trigger a callback per triangle. You can filter out individual triangles in the CollisionCollector::AddHit function by their sub shape ID.
-	/// @param inShape1 1st shape that is colliding
-	/// @param inSubShapeIDOfShape1 The sub shape ID that will lead from the root shape to inShape1 (i.e. the shape that is used to collide or cast against shape 2)
-	/// @param inShape2 2nd shape that is colliding
-	/// @param inSubShapeIDOfShape2 The sub shape ID that will lead from the root shape to inShape2 (i.e. the shape of mBodyID2)
-	virtual bool			ShouldCollide([[maybe_unused]] const Shape *inShape1, [[maybe_unused]] const SubShapeID &inSubShapeIDOfShape1, [[maybe_unused]] const Shape *inShape2, [[maybe_unused]] const SubShapeID &inSubShapeIDOfShape2) const
-	{
-		return true;
-	}
-
-	/// Used during NarrowPhase queries and TransformedShape queries. Set to the body ID of inShape2 before calling ShouldCollide.
-	/// Provides context to the filter to indicate which body is colliding.
-	mutable BodyID			mBodyID2;
-};
-
-/// Helper class to reverse the order of the shapes in the ShouldCollide function
-class ReversedShapeFilter : public ShapeFilter
-{
-public:
-	/// Constructor
-	explicit				ReversedShapeFilter(const ShapeFilter &inFilter) : mFilter(inFilter)
-	{
-		mBodyID2 = inFilter.mBodyID2;
-	}
-
-	virtual bool			ShouldCollide(const Shape *inShape2, const SubShapeID &inSubShapeIDOfShape2) const override
-	{
-		return mFilter.ShouldCollide(inShape2, inSubShapeIDOfShape2);
-	}
-
-	virtual bool			ShouldCollide(const Shape *inShape1, const SubShapeID &inSubShapeIDOfShape1, const Shape *inShape2, const SubShapeID &inSubShapeIDOfShape2) const override
-	{
-		return mFilter.ShouldCollide(inShape2, inSubShapeIDOfShape2, inShape1, inSubShapeIDOfShape1);
-	}
-
-private:
-	const ShapeFilter &		mFilter;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,40 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/NonCopyable.h>
-
-JPH_NAMESPACE_BEGIN
-
-class Body;
-class Shape;
-class SubShapeID;
-
-/// Filter class used during the simulation (PhysicsSystem::Update) to filter out collisions at shape level
-class SimShapeFilter : public NonCopyable
-{
-public:
-	/// Destructor
-	virtual					~SimShapeFilter() = default;
-
-	/// Filter function to determine if two shapes should collide. Returns true if the filter passes.
-	/// This overload is called during the simulation (PhysicsSystem::Update) and must be registered with PhysicsSystem::SetSimShapeFilter.
-	/// It is called at each level of the shape hierarchy, so if you have a compound shape with a box, this function will be called twice.
-	/// It will not be called on triangles that are part of another shape, i.e a mesh shape will not trigger a callback per triangle.
-	/// Note that this function is called from multiple threads and must be thread safe. All properties are read only.
-	/// @param inBody1 1st body that is colliding
-	/// @param inShape1 1st shape that is colliding
-	/// @param inSubShapeIDOfShape1 The sub shape ID that will lead from inBody1.GetShape() to inShape1
-	/// @param inBody2 2nd body that is colliding
-	/// @param inShape2 2nd shape that is colliding
-	/// @param inSubShapeIDOfShape2 The sub shape ID that will lead from inBody2.GetShape() to inShape2
-	virtual bool			ShouldCollide([[maybe_unused]] const Body &inBody1, [[maybe_unused]] const Shape *inShape1, [[maybe_unused]] const SubShapeID &inSubShapeIDOfShape1,
-										  [[maybe_unused]] const Body &inBody2, [[maybe_unused]] const Shape *inShape2, [[maybe_unused]] const SubShapeID &inSubShapeIDOfShape2) const
-	{
-		return true;
-	}
-};
-
-JPH_NAMESPACE_END

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

@@ -1,58 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/SimShapeFilter.h>
-#include <Jolt/Physics/Body/Body.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Helper class to forward ShapeFilter calls to a SimShapeFilter
-/// INTERNAL CLASS DO NOT USE!
-class SimShapeFilterWrapper : private ShapeFilter
-{
-public:
-	/// Constructor
-							SimShapeFilterWrapper(const SimShapeFilter *inFilter, const Body *inBody1) :
-		mFilter(inFilter),
-		mBody1(inBody1)
-	{
-		// Fall back to an empty filter if no simulation shape filter is set, this reduces the virtual call to 'return true'
-		mFinalFilter = inFilter != nullptr? this : &mDefault;
-	}
-
-	/// Forward to the simulation shape filter
-	virtual bool			ShouldCollide(const Shape *inShape1, const SubShapeID &inSubShapeIDOfShape1, const Shape *inShape2, const SubShapeID &inSubShapeIDOfShape2) const override
-	{
-		return mFilter->ShouldCollide(*mBody1, inShape1, inSubShapeIDOfShape1, *mBody2, inShape2, inSubShapeIDOfShape2);
-	}
-
-	/// Forward to the simulation shape filter
-	virtual bool			ShouldCollide(const Shape *inShape2, const SubShapeID &inSubShapeIDOfShape2) const override
-	{
-		return mFilter->ShouldCollide(*mBody1, mBody1->GetShape(), SubShapeID(), *mBody2, inShape2, inSubShapeIDOfShape2);
-	}
-
-	/// Set the body we're colliding against
-	void					SetBody2(const Body *inBody2)
-	{
-		mBody2 = inBody2;
-	}
-
-	/// Returns the actual filter to use for collision detection
-	const ShapeFilter &		GetFilter() const
-	{
-		return *mFinalFilter;
-	}
-
-private:
-	const ShapeFilter *		mFinalFilter;
-	const SimShapeFilter *	mFilter;
-	const Body *			mBody1;
-	const Body *			mBody2 = nullptr;
-	const ShapeFilter		mDefault;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,48 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-JPH_NAMESPACE_BEGIN
-
-/// This function will sort values from high to low and only keep the ones that are less than inMaxValue
-/// @param inValues Values to be sorted
-/// @param inMaxValue Values need to be less than this to keep them
-/// @param ioIdentifiers 4 identifiers that will be sorted in the same way as the values
-/// @param outValues The values are stored here from high to low
-/// @return The number of values that were kept
-JPH_INLINE int SortReverseAndStore(Vec4Arg inValues, float inMaxValue, UVec4 &ioIdentifiers, float *outValues)
-{
-	// Sort so that highest values are first (we want to first process closer hits and we process stack top to bottom)
-	Vec4 values = inValues;
-	Vec4::sSort4Reverse(values, ioIdentifiers);
-
-	// Count how many results are less than the max value
-	UVec4 closer = Vec4::sLess(values, Vec4::sReplicate(inMaxValue));
-	int num_results = closer.CountTrues();
-
-	// Shift the values so that only the ones that are less than max are kept
-	values = values.ReinterpretAsInt().ShiftComponents4Minus(num_results).ReinterpretAsFloat();
-	ioIdentifiers = ioIdentifiers.ShiftComponents4Minus(num_results);
-
-	// Store the values
-	values.StoreFloat4(reinterpret_cast<Float4 *>(outValues));
-
-	return num_results;
-}
-
-/// Shift the elements so that the identifiers that correspond with the trues in inValue come first
-/// @param inValue Values to test for true or false
-/// @param ioIdentifiers the identifiers that are shifted, on return they are shifted
-/// @return The number of trues
-JPH_INLINE int CountAndSortTrues(UVec4Arg inValue, UVec4 &ioIdentifiers)
-{
-	// Sort the hits
-	ioIdentifiers = UVec4::sSort4True(inValue, ioIdentifiers);
-
-	// Return the amount of hits
-	return inValue.CountTrues();
-}
-
-JPH_NAMESPACE_END