@bloomengine/engine 0.3.1

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

@@ -0,0 +1,110 @@
+// 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

@@ -0,0 +1,111 @@
+// 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

@@ -0,0 +1,52 @@
+// 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

@@ -0,0 +1,78 @@
+// 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

@@ -0,0 +1,35 @@
+// 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

@@ -0,0 +1,57 @@
+// 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

@@ -0,0 +1,38 @@
+// 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

@@ -0,0 +1,37 @@
+// 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

@@ -0,0 +1,87 @@
+// 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