@bloomengine/engine 0.3.1

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

@@ -0,0 +1,139 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/Shape/CompoundShape.h>
+#include <Jolt/Physics/Collision/SortReverseAndStore.h>
+#include <Jolt/Math/HalfFloat.h>
+
+JPH_NAMESPACE_BEGIN
+
+class CollideShapeSettings;
+class TempAllocator;
+
+/// Class that constructs a StaticCompoundShape. Note that if you only want a compound of 1 shape, use a RotatedTranslatedShape instead.
+class JPH_EXPORT StaticCompoundShapeSettings final : public CompoundShapeSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, StaticCompoundShapeSettings)
+
+public:
+	// See: ShapeSettings
+	virtual ShapeResult				Create() const override;
+
+	/// Specialization of Create() function that allows specifying a temp allocator to avoid temporary memory allocations on the heap
+	ShapeResult						Create(TempAllocator &inTempAllocator) const;
+};
+
+/// A compound shape, sub shapes can be rotated and translated.
+/// Sub shapes cannot be modified once the shape is constructed.
+/// Shifts all child objects so that they're centered around the center of mass.
+class JPH_EXPORT StaticCompoundShape final : public CompoundShape
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+									StaticCompoundShape() : CompoundShape(EShapeSubType::StaticCompound) { }
+									StaticCompoundShape(const StaticCompoundShapeSettings &inSettings, TempAllocator &inTempAllocator, ShapeResult &outResult);
+
+	// 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::CollectTransformedShapes
+	virtual void					CollectTransformedShapes(const AABox &inBox, Vec3Arg inPositionCOM, QuatArg inRotation, Vec3Arg inScale, const SubShapeIDCreator &inSubShapeIDCreator, TransformedShapeCollector &ioCollector, const ShapeFilter &inShapeFilter) const override;
+
+	// See: CompoundShape::GetIntersectingSubShapes
+	virtual int						GetIntersectingSubShapes(const AABox &inBox, uint *outSubShapeIndices, int inMaxSubShapeIndices) const override;
+
+	// See: CompoundShape::GetIntersectingSubShapes
+	virtual int						GetIntersectingSubShapes(const OrientedBox &inBox, uint *outSubShapeIndices, int inMaxSubShapeIndices) const override;
+
+	// See Shape
+	virtual void					SaveBinaryState(StreamOut &inStream) const override;
+
+	// See Shape::GetStats
+	virtual Stats					GetStats() const override								{ return Stats(sizeof(*this) + mSubShapes.size() * sizeof(SubShape) + mNodes.size() * sizeof(Node), 0); }
+
+	// Register shape functions with the registry
+	static void						sRegister();
+
+protected:
+	// See: Shape::RestoreBinaryState
+	virtual void					RestoreBinaryState(StreamIn &inStream) override;
+
+private:
+	// Visitor for GetIntersectingSubShapes
+	template <class BoxType>
+	struct GetIntersectingSubShapesVisitorSC : public GetIntersectingSubShapesVisitor<BoxType>
+	{
+		using GetIntersectingSubShapesVisitor<BoxType>::GetIntersectingSubShapesVisitor;
+
+		JPH_INLINE bool				ShouldVisitNode(int inStackTop) const
+		{
+			return true;
+		}
+
+		JPH_INLINE int				VisitNodes(Vec4Arg inBoundsMinX, Vec4Arg inBoundsMinY, Vec4Arg inBoundsMinZ, Vec4Arg inBoundsMaxX, Vec4Arg inBoundsMaxY, Vec4Arg inBoundsMaxZ, UVec4 &ioProperties, int inStackTop)
+		{
+			// Test if point overlaps with box
+			UVec4 collides = GetIntersectingSubShapesVisitor<BoxType>::TestBounds(inBoundsMinX, inBoundsMinY, inBoundsMinZ, inBoundsMaxX, inBoundsMaxY, inBoundsMaxZ);
+			return CountAndSortTrues(collides, ioProperties);
+		}
+	};
+
+	/// Sorts ioBodyIdx spatially into 2 groups. Second groups starts at ioBodyIdx + outMidPoint.
+	/// After the function returns ioBodyIdx and ioBounds will be shuffled
+	static void						sPartition(uint *ioBodyIdx, AABox *ioBounds, int inNumber, int &outMidPoint);
+
+	/// Sorts ioBodyIdx from inBegin to (but excluding) inEnd spatially into 4 groups.
+	/// outSplit needs to be 5 ints long, when the function returns each group runs from outSplit[i] to (but excluding) outSplit[i + 1]
+	/// After the function returns ioBodyIdx and ioBounds will be shuffled
+	static void						sPartition4(uint *ioBodyIdx, AABox *ioBounds, int inBegin, int inEnd, int *outSplit);
+
+	// Helper functions called by CollisionDispatch
+	static void						sCollideCompoundVsShape(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						sCollideShapeVsCompound(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						sCastShapeVsCompound(const ShapeCast &inShapeCast, const ShapeCastSettings &inShapeCastSettings, const Shape *inShape, Vec3Arg inScale, const ShapeFilter &inShapeFilter, Mat44Arg inCenterOfMassTransform2, const SubShapeIDCreator &inSubShapeIDCreator1, const SubShapeIDCreator &inSubShapeIDCreator2, CastShapeCollector &ioCollector);
+
+	// Maximum size of the stack during tree walk
+	static constexpr int			cStackSize = 128;
+
+	template <class Visitor>
+	JPH_INLINE void					WalkTree(Visitor &ioVisitor) const;						///< Walk the node tree calling the Visitor::VisitNodes for each node encountered and Visitor::VisitShape for each sub shape encountered
+
+	/// Bits used in Node::mNodeProperties
+	enum : uint32
+	{
+		IS_SUBSHAPE					= 0x80000000,											///< If this bit is set, the other bits index in mSubShape, otherwise in mNodes
+		INVALID_NODE				= 0x7fffffff,											///< Signifies an invalid node
+	};
+
+	/// Node structure
+	struct Node
+	{
+		void						SetChildBounds(uint inIndex, const AABox &inBounds);	///< Set bounding box for child inIndex to inBounds
+		void						SetChildInvalid(uint inIndex);							///< Mark the child inIndex as invalid and set its bounding box to invalid
+
+		HalfFloat					mBoundsMinX[4];											///< 4 child bounding boxes
+		HalfFloat					mBoundsMinY[4];
+		HalfFloat					mBoundsMinZ[4];
+		HalfFloat					mBoundsMaxX[4];
+		HalfFloat					mBoundsMaxY[4];
+		HalfFloat					mBoundsMaxZ[4];
+		uint32						mNodeProperties[4];										///< 4 child node properties
+	};
+
+	static_assert(sizeof(Node) == 64, "Node should be 64 bytes");
+
+	using Nodes = Array<Node>;
+
+	Nodes							mNodes;													///< Quad tree node structure
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,138 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// @brief A sub shape id contains a path to an element (usually a triangle or other primitive type) of a compound shape
+///
+/// Each sub shape knows how many bits it needs to encode its ID, so knows how many bits to take from the sub shape ID.
+///
+/// For example:
+/// * We have a CompoundShape A with 5 child shapes (identify sub shape using 3 bits AAA)
+/// * One of its child shapes is CompoundShape B which has 3 child shapes (identify sub shape using 2 bits BB)
+/// * One of its child shapes is MeshShape C which contains enough triangles to need 7 bits to identify a triangle (identify sub shape using 7 bits CCCCCCC, note that MeshShape is block based and sorts triangles spatially, you can't assume that the first triangle will have bit pattern 0000000).
+///
+/// The bit pattern of the sub shape ID to identify a triangle in MeshShape C will then be CCCCCCCBBAAA.
+///
+/// A sub shape ID will become invalid when the structure of the shape changes. For example, if a child shape is removed from a compound shape, the sub shape ID will no longer be valid.
+/// This can be a problem when caching sub shape IDs from one frame to the next. See comments at ContactListener::OnContactPersisted / OnContactRemoved.
+class SubShapeID
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Underlying storage type
+	using Type = uint32;
+
+	/// Type that is bigger than the underlying storage type for operations that would otherwise overflow
+	using BiggerType = uint64;
+
+	static_assert(sizeof(BiggerType) > sizeof(Type), "The calculation below assumes BiggerType is a bigger type than Type");
+
+	/// How many bits we can store in this ID
+	static constexpr uint MaxBits = 8 * sizeof(Type);
+
+	/// Constructor
+						SubShapeID() = default;
+
+	/// Get the next id in the chain of ids (pops parents before children)
+	Type				PopID(uint inBits, SubShapeID &outRemainder) const
+	{
+		Type mask_bits = Type((BiggerType(1) << inBits) - 1);
+		Type fill_bits = Type(BiggerType(cEmpty) << (MaxBits - inBits)); // Fill left side bits with 1 so that if there's no remainder all bits will be set, note that we do this using a BiggerType since on intel 0xffffffff << 32 == 0xffffffff
+		Type v = mValue & mask_bits;
+		outRemainder = SubShapeID(Type(BiggerType(mValue) >> inBits) | fill_bits);
+		return v;
+	}
+
+	/// Get the value of the path to the sub shape ID
+	inline Type			GetValue() const
+	{
+		return mValue;
+	}
+
+	/// Set the value of the sub shape ID (use with care!)
+	inline void			SetValue(Type inValue)
+	{
+		mValue = inValue;
+	}
+
+	/// Check if there is any bits of subshape ID left.
+	/// Note that this is not a 100% guarantee as the subshape ID could consist of all 1 bits. Use for asserts only.
+	inline bool			IsEmpty() const
+	{
+		return mValue == cEmpty;
+	}
+
+	/// Check equal
+	inline bool			operator == (const SubShapeID &inRHS) const
+	{
+		return mValue == inRHS.mValue;
+	}
+
+	/// Check not-equal
+	inline bool			operator != (const SubShapeID &inRHS) const
+	{
+		return mValue != inRHS.mValue;
+	}
+
+private:
+	friend class SubShapeIDCreator;
+
+	/// An empty SubShapeID has all bits set
+	static constexpr Type cEmpty = ~Type(0);
+
+	/// Constructor
+	explicit			SubShapeID(const Type &inValue) : mValue(inValue) { }
+
+	/// Adds an id at a particular position in the chain
+	/// (this should really only be called by the SubShapeIDCreator)
+	void				PushID(Type inValue, uint inFirstBit, uint inBits)
+	{
+		// First clear the bits
+		mValue &= ~(Type((BiggerType(1) << inBits) - 1) << inFirstBit);
+
+		// Then set them to the new value
+		mValue |= inValue << inFirstBit;
+	}
+
+	Type				mValue = cEmpty;
+};
+
+/// A sub shape id creator can be used to create a new sub shape id by recursing through the shape
+/// hierarchy and pushing new ID's onto the chain
+class SubShapeIDCreator
+{
+public:
+	/// Add a new id to the chain of id's and return it
+	SubShapeIDCreator	PushID(uint inValue, uint inBits) const
+	{
+		JPH_ASSERT(inValue < (SubShapeID::BiggerType(1) << inBits));
+		SubShapeIDCreator copy = *this;
+		copy.mID.PushID(inValue, mCurrentBit, inBits);
+		copy.mCurrentBit += inBits;
+		JPH_ASSERT(copy.mCurrentBit <= SubShapeID::MaxBits);
+		return copy;
+	}
+
+	// Get the resulting sub shape ID
+	const SubShapeID &	GetID() const
+	{
+		return mID;
+	}
+
+	/// Get the number of bits that have been written to the sub shape ID so far
+	inline uint			GetNumBitsWritten() const
+	{
+		return mCurrentBit;
+	}
+
+private:
+	SubShapeID			mID;
+	uint				mCurrentBit = 0;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,65 @@
+// 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/Physics/Collision/Shape/SubShapeID.h>
+#include <Jolt/Core/HashCombine.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// A pair of bodies and their sub shape ID's. Can be used as a key in a map to find a contact point.
+class SubShapeIDPair
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+							SubShapeIDPair() = default;
+							SubShapeIDPair(const BodyID &inBody1ID, const SubShapeID &inSubShapeID1, const BodyID &inBody2ID, const SubShapeID &inSubShapeID2) : mBody1ID(inBody1ID), mSubShapeID1(inSubShapeID1), mBody2ID(inBody2ID), mSubShapeID2(inSubShapeID2) { }
+	SubShapeIDPair &		operator = (const SubShapeIDPair &) = default;
+							SubShapeIDPair(const SubShapeIDPair &) = default;
+
+	/// Equality operator
+	inline bool				operator == (const SubShapeIDPair &inRHS) const
+	{
+		return UVec4::sLoadInt4(reinterpret_cast<const uint32 *>(this)) == UVec4::sLoadInt4(reinterpret_cast<const uint32 *>(&inRHS));
+	}
+
+	/// Less than operator, used to consistently order contact points for a deterministic simulation
+	inline bool				operator < (const SubShapeIDPair &inRHS) const
+	{
+		if (mBody1ID != inRHS.mBody1ID)
+			return mBody1ID < inRHS.mBody1ID;
+
+		if (mSubShapeID1.GetValue() != inRHS.mSubShapeID1.GetValue())
+			return mSubShapeID1.GetValue() < inRHS.mSubShapeID1.GetValue();
+
+		if (mBody2ID != inRHS.mBody2ID)
+			return mBody2ID < inRHS.mBody2ID;
+
+		return mSubShapeID2.GetValue() < inRHS.mSubShapeID2.GetValue();
+	}
+
+	const BodyID &			GetBody1ID() const				{ return mBody1ID; }
+	const SubShapeID &		GetSubShapeID1() const			{ return mSubShapeID1; }
+	const BodyID &			GetBody2ID() const				{ return mBody2ID; }
+	const SubShapeID &		GetSubShapeID2() const			{ return mSubShapeID2; }
+
+	uint64					GetHash() const					{ return HashBytes(this, sizeof(SubShapeIDPair)); }
+
+private:
+	BodyID					mBody1ID;
+	SubShapeID				mSubShapeID1;
+	BodyID					mBody2ID;
+	SubShapeID				mSubShapeID2;
+};
+
+static_assert(sizeof(SubShapeIDPair) == 16, "Unexpected size");
+static_assert(alignof(SubShapeIDPair) == 4, "Assuming 4 byte aligned");
+
+JPH_NAMESPACE_END
+
+JPH_MAKE_STD_HASH(JPH::SubShapeIDPair)