@bloomengine/engine 0.4.0 → 0.4.2

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

@@ -1,110 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/TickCounter.h>
-#include <Jolt/Physics/Collision/Shape/Shape.h>
-
-JPH_SUPPRESS_WARNING_PUSH
-JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat-pedantic")
-
-// Shorthand function to ifdef out code if narrow phase stats tracking is off
-#ifdef JPH_TRACK_NARROWPHASE_STATS
-	#define JPH_IF_TRACK_NARROWPHASE_STATS(...) __VA_ARGS__
-#else
-	#define JPH_IF_TRACK_NARROWPHASE_STATS(...)
-#endif // JPH_TRACK_NARROWPHASE_STATS
-
-JPH_SUPPRESS_WARNING_POP
-
-#ifdef JPH_TRACK_NARROWPHASE_STATS
-
-JPH_NAMESPACE_BEGIN
-
-/// Structure that tracks narrow phase timing information for a particular combination of shapes
-class NarrowPhaseStat
-{
-public:
-	/// Trace an individual stat in CSV form.
-	void					ReportStats(const char *inName, EShapeSubType inType1, EShapeSubType inType2, uint64 inTicks100Pct) const;
-
-	/// Trace the collected broadphase stats in CSV form.
-	/// This report can be used to judge and tweak the efficiency of the broadphase.
-	static void				sReportStats();
-
-	atomic<uint64>			mNumQueries = 0;
-	atomic<uint64>			mHitsReported = 0;
-	atomic<uint64>			mTotalTicks = 0;
-	atomic<uint64>			mChildTicks = 0;
-
-	static NarrowPhaseStat	sCollideShape[NumSubShapeTypes][NumSubShapeTypes];
-	static NarrowPhaseStat	sCastShape[NumSubShapeTypes][NumSubShapeTypes];
-};
-
-/// Object that tracks the start and end of a narrow phase operation
-class TrackNarrowPhaseStat
-{
-public:
-							TrackNarrowPhaseStat(NarrowPhaseStat &inStat) :
-		mStat(inStat),
-		mParent(sRoot),
-		mStart(GetProcessorTickCount())
-	{
-		// Make this the new root of the chain
-		sRoot = this;
-	}
-
-							~TrackNarrowPhaseStat()
-	{
-		uint64 delta_ticks = GetProcessorTickCount() - mStart;
-
-		// Notify parent of time spent in child
-		if (mParent != nullptr)
-			mParent->mStat.mChildTicks += delta_ticks;
-
-		// Increment stats at this level
-		mStat.mNumQueries++;
-		mStat.mTotalTicks += delta_ticks;
-
-		// Restore root pointer
-		JPH_ASSERT(sRoot == this);
-		sRoot = mParent;
-	}
-
-	NarrowPhaseStat &		mStat;
-	TrackNarrowPhaseStat *	mParent;
-	uint64					mStart;
-
-	static thread_local TrackNarrowPhaseStat *sRoot;
-};
-
-/// Object that tracks the start and end of a hit being processed by a collision collector
-class TrackNarrowPhaseCollector
-{
-public:
-							TrackNarrowPhaseCollector() :
-		mStart(GetProcessorTickCount())
-	{
-	}
-
-							~TrackNarrowPhaseCollector()
-	{
-		// Mark time spent in collector as 'child' time for the parent
-		uint64 delta_ticks = GetProcessorTickCount() - mStart;
-		if (TrackNarrowPhaseStat::sRoot != nullptr)
-			TrackNarrowPhaseStat::sRoot->mStat.mChildTicks += delta_ticks;
-
-		// Notify all parents of a hit
-		for (TrackNarrowPhaseStat *track = TrackNarrowPhaseStat::sRoot; track != nullptr; track = track->mParent)
-			track->mStat.mHitsReported++;
-	}
-
-private:
-	uint64					mStart;
-};
-
-JPH_NAMESPACE_END
-
-#endif // JPH_TRACK_NARROWPHASE_STATS

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

@@ -1,111 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/NonCopyable.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Layer that objects can be in, determines which other objects it can collide with
-#ifndef JPH_OBJECT_LAYER_BITS
-	#define JPH_OBJECT_LAYER_BITS 16
-#endif // JPH_OBJECT_LAYER_BITS
-#if JPH_OBJECT_LAYER_BITS == 16
-	using ObjectLayer = uint16;
-#elif JPH_OBJECT_LAYER_BITS == 32
-	using ObjectLayer = uint32;
-#else
-	#error "JPH_OBJECT_LAYER_BITS must be 16 or 32"
-#endif
-
-/// Constant value used to indicate an invalid object layer
-static constexpr ObjectLayer cObjectLayerInvalid = ObjectLayer(~ObjectLayer(0U));
-
-/// Filter class for object layers
-class JPH_EXPORT ObjectLayerFilter : public NonCopyable
-{
-public:
-	/// Destructor
-	virtual					~ObjectLayerFilter() = default;
-
-	/// Function to filter out object layers when doing collision query test (return true to allow testing against objects with this layer)
-	virtual bool			ShouldCollide([[maybe_unused]] ObjectLayer inLayer) const
-	{
-		return true;
-	}
-
-#ifdef JPH_TRACK_BROADPHASE_STATS
-	/// Get a string that describes this filter for stat tracking purposes
-	virtual String			GetDescription() const
-	{
-		return "No Description";
-	}
-#endif // JPH_TRACK_BROADPHASE_STATS
-};
-
-/// Filter class to test if two objects can collide based on their object layer. Used while finding collision pairs.
-class JPH_EXPORT ObjectLayerPairFilter : public NonCopyable
-{
-public:
-	/// Destructor
-	virtual					~ObjectLayerPairFilter() = default;
-
-	/// Returns true if two layers can collide
-	virtual bool			ShouldCollide([[maybe_unused]] ObjectLayer inLayer1, [[maybe_unused]] ObjectLayer inLayer2) const
-	{
-		return true;
-	}
-};
-
-/// Default filter class that uses the pair filter in combination with a specified layer to filter layers
-class JPH_EXPORT DefaultObjectLayerFilter : public ObjectLayerFilter
-{
-public:
-	/// Constructor
-							DefaultObjectLayerFilter(const ObjectLayerPairFilter &inObjectLayerPairFilter, ObjectLayer inLayer) :
-		mObjectLayerPairFilter(inObjectLayerPairFilter),
-		mLayer(inLayer)
-	{
-	}
-
-	/// Copy constructor
-							DefaultObjectLayerFilter(const DefaultObjectLayerFilter &inRHS) :
-		mObjectLayerPairFilter(inRHS.mObjectLayerPairFilter),
-		mLayer(inRHS.mLayer)
-	{
-	}
-
-	// See ObjectLayerFilter::ShouldCollide
-	virtual bool			ShouldCollide(ObjectLayer inLayer) const override
-	{
-		return mObjectLayerPairFilter.ShouldCollide(mLayer, inLayer);
-	}
-
-private:
-	const ObjectLayerPairFilter & mObjectLayerPairFilter;
-	ObjectLayer				mLayer;
-};
-
-/// Allows objects from a specific layer only
-class JPH_EXPORT SpecifiedObjectLayerFilter : public ObjectLayerFilter
-{
-public:
-	/// Constructor
-	explicit				SpecifiedObjectLayerFilter(ObjectLayer inLayer) :
-		mLayer(inLayer)
-	{
-	}
-
-	// See ObjectLayerFilter::ShouldCollide
-	virtual bool			ShouldCollide(ObjectLayer inLayer) const override
-	{
-		return mLayer == inLayer;
-	}
-
-private:
-	ObjectLayer				mLayer;
-};
-
-JPH_NAMESPACE_END

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

@@ -1,52 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/ObjectLayer.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Filter class to test if two objects can collide based on their object layer. Used while finding collision pairs.
-/// Uses group bits and mask bits. Two layers can collide if Object1.Group & Object2.Mask is non-zero and Object2.Group & Object1.Mask is non-zero.
-/// The behavior is similar to that in e.g. Bullet.
-/// This implementation works together with BroadPhaseLayerInterfaceMask and ObjectVsBroadPhaseLayerFilterMask
-class ObjectLayerPairFilterMask : public ObjectLayerPairFilter
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Number of bits for the group and mask bits
-	static constexpr uint32 cNumBits = JPH_OBJECT_LAYER_BITS / 2;
-	static constexpr uint32	cMask = (1 << cNumBits) - 1;
-
-	/// Construct an ObjectLayer from a group and mask bits
-	static ObjectLayer		sGetObjectLayer(uint32 inGroup, uint32 inMask = cMask)
-	{
-		JPH_ASSERT((inGroup & ~cMask) == 0);
-		JPH_ASSERT((inMask & ~cMask) == 0);
-		return ObjectLayer((inGroup & cMask) | (inMask << cNumBits));
-	}
-
-	/// Get the group bits from an ObjectLayer
-	static inline uint32	sGetGroup(ObjectLayer inObjectLayer)
-	{
-		return uint32(inObjectLayer) & cMask;
-	}
-
-	/// Get the mask bits from an ObjectLayer
-	static inline uint32	sGetMask(ObjectLayer inObjectLayer)
-	{
-		return uint32(inObjectLayer) >> cNumBits;
-	}
-
-	/// Returns true if two layers can collide
-	virtual bool			ShouldCollide(ObjectLayer inObject1, ObjectLayer inObject2) const override
-	{
-		return (sGetGroup(inObject1) & sGetMask(inObject2)) != 0
-			&& (sGetGroup(inObject2) & sGetMask(inObject1)) != 0;
-	}
-};
-
-JPH_NAMESPACE_END

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

@@ -1,78 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/ObjectLayer.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Filter class to test if two objects can collide based on their object layer. Used while finding collision pairs.
-/// This implementation uses a table to determine if two layers can collide.
-class ObjectLayerPairFilterTable : public ObjectLayerPairFilter
-{
-private:
-	/// Get which bit corresponds to the pair (inLayer1, inLayer2)
-	uint					GetBit(ObjectLayer inLayer1, ObjectLayer inLayer2) const
-	{
-		// We store the lower left half only, so swap the inputs when trying to access the top right half
-		if (inLayer1 > inLayer2)
-			std::swap(inLayer1, inLayer2);
-
-		JPH_ASSERT(inLayer2 < mNumObjectLayers);
-
-		// Calculate at which bit the entry for this pair resides
-		// We use the fact that a row always starts at inLayer2 * (inLayer2 + 1) / 2
-		// (this is the amount of bits needed to store a table of inLayer2 entries)
-		return (inLayer2 * (inLayer2 + 1)) / 2 + inLayer1;
-	}
-
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Constructs the table with inNumObjectLayers Layers, initially all layer pairs are disabled
-	explicit				ObjectLayerPairFilterTable(uint inNumObjectLayers) :
-		mNumObjectLayers(inNumObjectLayers)
-	{
-		// By default nothing collides
-		// For the first layer we only need to store 1 bit, for the second 2 bits, for the third 3 bits, etc.
-		// We use the formula Sum_i=1^N i = N * (N + 1) / 2 to calculate the size of the table
-		int table_size = (inNumObjectLayers * (inNumObjectLayers + 1) / 2 + 7) / 8;
-		mTable.resize(table_size, 0);
-	}
-
-	/// Get the number of object layers
-	uint					GetNumObjectLayers() const
-	{
-		return mNumObjectLayers;
-	}
-
-	/// Disable collision between two object layers
-	void					DisableCollision(ObjectLayer inLayer1, ObjectLayer inLayer2)
-	{
-		uint bit = GetBit(inLayer1, inLayer2);
-		mTable[bit >> 3] &= (0xff ^ (1 << (bit & 0b111)));
-	}
-
-	/// Enable collision between two object layers
-	void					EnableCollision(ObjectLayer inLayer1, ObjectLayer inLayer2)
-	{
-		uint bit = GetBit(inLayer1, inLayer2);
-		mTable[bit >> 3] |= 1 << (bit & 0b111);
-	}
-
-	/// Returns true if two layers can collide
-	virtual bool			ShouldCollide(ObjectLayer inObject1, ObjectLayer inObject2) const override
-	{
-		// Test if the bit is set for this group pair
-		uint bit = GetBit(inObject1, inObject2);
-		return (mTable[bit >> 3] & (1 << (bit & 0b111))) != 0;
-	}
-
-private:
-	uint					mNumObjectLayers;							///< The number of layers that this table supports
-	Array<uint8>			mTable;										///< The table of bits that indicates which layers collide
-};
-
-JPH_NAMESPACE_END

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

@@ -1,35 +0,0 @@
-// 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/PhysicsMaterial.h>
-#include <Jolt/Physics/Collision/PhysicsMaterialSimple.h>
-#include <Jolt/Core/StreamUtils.h>
-
-JPH_NAMESPACE_BEGIN
-
-RefConst<PhysicsMaterial> PhysicsMaterial::sDefault;
-
-JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(PhysicsMaterial)
-{
-	JPH_ADD_BASE_CLASS(PhysicsMaterial, SerializableObject)
-}
-
-void PhysicsMaterial::SaveBinaryState(StreamOut &inStream) const
-{
-	inStream.Write(GetRTTI()->GetHash());
-}
-
-void PhysicsMaterial::RestoreBinaryState(StreamIn &inStream)
-{
-	// RTTI hash is read in sRestoreFromBinaryState
-}
-
-PhysicsMaterial::PhysicsMaterialResult PhysicsMaterial::sRestoreFromBinaryState(StreamIn &inStream)
-{
-	return StreamUtils::RestoreObject<PhysicsMaterial>(inStream, &PhysicsMaterial::RestoreBinaryState);
-}
-
-JPH_NAMESPACE_END

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

@@ -1,57 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/Reference.h>
-#include <Jolt/Core/Color.h>
-#include <Jolt/Core/Result.h>
-#include <Jolt/ObjectStream/SerializableObject.h>
-
-JPH_NAMESPACE_BEGIN
-
-class StreamIn;
-class StreamOut;
-
-/// This structure describes the surface of (part of) a shape. You should inherit from it to define additional
-/// information that is interesting for the simulation. The 2 materials involved in a contact could be used
-/// to decide which sound or particle effects to play.
-///
-/// If you inherit from this material, don't forget to create a suitable default material in sDefault
-class JPH_EXPORT PhysicsMaterial : public SerializableObject, public RefTarget<PhysicsMaterial>
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PhysicsMaterial)
-
-public:
-	/// Constructor
-											PhysicsMaterial() = default;
-	virtual									~PhysicsMaterial() override = default;
-
-	/// Default material that is used when a shape has no materials defined
-	static RefConst<PhysicsMaterial>		sDefault;
-
-	// Properties
-	virtual const char *					GetDebugName() const			{ return "Unknown"; }
-	virtual Color							GetDebugColor() const			{ return Color::sGrey; }
-
-	/// Saves the contents of the material in binary form to inStream.
-	virtual void							SaveBinaryState(StreamOut &inStream) const;
-
-	using PhysicsMaterialResult = Result<Ref<PhysicsMaterial>>;
-
-	/// Creates a PhysicsMaterial of the correct type and restores its contents from the binary stream inStream.
-	static PhysicsMaterialResult			sRestoreFromBinaryState(StreamIn &inStream);
-
-protected:
-	/// Don't allow copy constructing this base class, but allow derived classes to copy themselves
-											PhysicsMaterial(const PhysicsMaterial &) = default;
-	PhysicsMaterial &						operator = (const PhysicsMaterial &) = default;
-
-	/// This function should not be called directly, it is used by sRestoreFromBinaryState.
-	virtual void							RestoreBinaryState(StreamIn &inStream);
-};
-
-using PhysicsMaterialList = Array<RefConst<PhysicsMaterial>>;
-
-JPH_NAMESPACE_END

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

@@ -1,38 +0,0 @@
-// 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/PhysicsMaterialSimple.h>
-#include <Jolt/ObjectStream/TypeDeclarations.h>
-#include <Jolt/Core/StreamIn.h>
-#include <Jolt/Core/StreamOut.h>
-
-JPH_NAMESPACE_BEGIN
-
-JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(PhysicsMaterialSimple)
-{
-	JPH_ADD_BASE_CLASS(PhysicsMaterialSimple, PhysicsMaterial)
-
-	JPH_ADD_ATTRIBUTE(PhysicsMaterialSimple, mDebugName)
-	JPH_ADD_ATTRIBUTE(PhysicsMaterialSimple, mDebugColor)
-}
-
-void PhysicsMaterialSimple::SaveBinaryState(StreamOut &inStream) const
-{
-	PhysicsMaterial::SaveBinaryState(inStream);
-
-	inStream.Write(mDebugName);
-	inStream.Write(mDebugColor);
-}
-
-void PhysicsMaterialSimple::RestoreBinaryState(StreamIn &inStream)
-{
-	PhysicsMaterial::RestoreBinaryState(inStream);
-
-	inStream.Read(mDebugName);
-	inStream.Read(mDebugColor);
-}
-
-JPH_NAMESPACE_END

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

@@ -1,37 +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/PhysicsMaterial.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Sample implementation of PhysicsMaterial that just holds the needed properties directly
-class JPH_EXPORT PhysicsMaterialSimple : public PhysicsMaterial
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PhysicsMaterialSimple)
-
-public:
-	/// Constructor
-											PhysicsMaterialSimple() = default;
-											PhysicsMaterialSimple(const string_view &inName, ColorArg inColor) : mDebugName(inName), mDebugColor(inColor) { }
-
-	// Properties
-	virtual const char *					GetDebugName() const override		{ return mDebugName.c_str(); }
-	virtual Color							GetDebugColor() const override		{ return mDebugColor; }
-
-	// See: PhysicsMaterial::SaveBinaryState
-	virtual void							SaveBinaryState(StreamOut &inStream) const override;
-
-protected:
-	// See: PhysicsMaterial::RestoreBinaryState
-	virtual void							RestoreBinaryState(StreamIn &inStream) override;
-
-private:
-	String									mDebugName;							///< Name of the material, used for debugging purposes
-	Color									mDebugColor = Color::sGrey;			///< Color of the material, used to render the shapes
-};
-
-JPH_NAMESPACE_END

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

@@ -1,87 +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/BackFaceMode.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Structure that holds a single ray cast
-template <class Vec, class Mat, class RayCastType>
-struct RayCastT
-{
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Constructors
-								RayCastT() = default; // Allow raycast to be created uninitialized
-								RayCastT(typename Vec::ArgType inOrigin, Vec3Arg inDirection) : mOrigin(inOrigin), mDirection(inDirection) { }
-								RayCastT(const RayCastT<Vec, Mat, RayCastType> &) = default;
-
-	/// Transform this ray using inTransform
-	RayCastType					Transformed(typename Mat::ArgType inTransform) const
-	{
-		Vec ray_origin = inTransform * mOrigin;
-		Vec3 ray_direction(inTransform * (mOrigin + mDirection) - ray_origin);
-		return { ray_origin, ray_direction };
-	}
-
-	/// Translate ray using inTranslation
-	RayCastType					Translated(typename Vec::ArgType inTranslation) const
-	{
-		return { inTranslation + mOrigin, mDirection };
-	}
-
-	/// Get point with fraction inFraction on ray (0 = start of ray, 1 = end of ray)
-	inline Vec					GetPointOnRay(float inFraction) const
-	{
-		return mOrigin + inFraction * mDirection;
-	}
-
-	Vec							mOrigin;					///< Origin of the ray
-	Vec3						mDirection;					///< Direction and length of the ray (anything beyond this length will not be reported as a hit)
-};
-
-struct RayCast : public RayCastT<Vec3, Mat44, RayCast>
-{
-	using RayCastT<Vec3, Mat44, RayCast>::RayCastT;
-};
-
-struct RRayCast : public RayCastT<RVec3, RMat44, RRayCast>
-{
-	using RayCastT<RVec3, RMat44, RRayCast>::RayCastT;
-
-	/// Convert from RayCast, converts single to double precision
-	explicit					RRayCast(const RayCast &inRay) :
-		RRayCast(RVec3(inRay.mOrigin), inRay.mDirection)
-	{
-	}
-
-	/// Convert to RayCast, which implies casting from double precision to single precision
-	explicit					operator RayCast() const
-	{
-		return RayCast(Vec3(mOrigin), mDirection);
-	}
-};
-
-/// Settings to be passed with a ray cast
-class RayCastSettings
-{
-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 back facing hits for triangle based shapes, e.g. MeshShape/HeightFieldShape?)
-	EBackFaceMode				mBackFaceModeTriangles		= EBackFaceMode::IgnoreBackFaces;
-
-	/// How backfacing convex objects should be treated (should we report back facing hits for convex shapes?)
-	EBackFaceMode				mBackFaceModeConvex			= EBackFaceMode::IgnoreBackFaces;
-
-	/// If convex shapes should be treated as solid. When true, a ray starting inside a convex shape will generate a hit at fraction 0.
-	bool						mTreatConvexAsSolid			= true;
-};
-
-JPH_NAMESPACE_END