@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Geometry/ConvexHullBuilder2D.h

@@ -0,0 +1,105 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/NonCopyable.h>
+
+//#define JPH_CONVEX_BUILDER_2D_DEBUG
+
+JPH_NAMESPACE_BEGIN
+
+/// A convex hull builder that tries to create 2D hulls as accurately as possible. Used for offline processing.
+class JPH_EXPORT ConvexHullBuilder2D : public NonCopyable
+{
+public:
+	using Positions = Array<Vec3>;
+	using Edges = Array<int>;
+
+	/// Constructor
+	/// @param inPositions Positions used to make the hull. Uses X and Y component of Vec3 only!
+	explicit			ConvexHullBuilder2D(const Positions &inPositions);
+
+	/// Destructor
+						~ConvexHullBuilder2D();
+
+	/// Result enum that indicates how the hull got created
+	enum class EResult
+	{
+		Success,													///< Hull building finished successfully
+		MaxVerticesReached,											///< Hull building finished successfully, but the desired accuracy was not reached because the max vertices limit was reached
+	};
+
+	/// Takes all positions as provided by the constructor and use them to build a hull
+	/// Any points that are closer to the hull than inTolerance will be discarded
+	/// @param inIdx1 , inIdx2 , inIdx3 The indices to use as initial hull (in any order)
+	/// @param inMaxVertices Max vertices to allow in the hull. Specify INT_MAX if there is no limit.
+	/// @param inTolerance Max distance that a point is allowed to be outside of the hull
+	/// @param outEdges On success this will contain the list of indices that form the hull (counter clockwise)
+	/// @return Status code that reports if the hull was created or not
+	EResult				Initialize(int inIdx1, int inIdx2, int inIdx3, int inMaxVertices, float inTolerance, Edges &outEdges);
+
+private:
+#ifdef JPH_CONVEX_BUILDER_2D_DEBUG
+	/// Factor to scale convex hull when debug drawing the construction process
+	static constexpr Real cDrawScale = 10;
+#endif
+
+	class Edge;
+
+	/// Frees all edges
+	void				FreeEdges();
+
+	/// Assigns a position to one of the supplied edges based on which edge is closest.
+	/// @param inPositionIdx Index of the position to add
+	/// @param inEdges List of edges to consider
+	void				AssignPointToEdge(int inPositionIdx, const Array<Edge *> &inEdges) const;
+
+#ifdef JPH_CONVEX_BUILDER_2D_DEBUG
+	/// Draw state of algorithm
+	void				DrawState();
+#endif
+
+#ifdef JPH_ENABLE_ASSERTS
+	/// Validate that the edge structure is intact
+	void				ValidateEdges() const;
+#endif
+
+	using ConflictList = Array<int>;
+
+	/// Linked list of edges
+	class Edge
+	{
+	public:
+		JPH_OVERRIDE_NEW_DELETE
+
+		/// Constructor
+		explicit		Edge(int inStartIdx)						: mStartIdx(inStartIdx) { }
+
+		/// Calculate the center of the edge and the edge normal
+		void			CalculateNormalAndCenter(const Vec3 *inPositions);
+
+		/// Check if this edge is facing inPosition
+		inline bool		IsFacing(Vec3Arg inPosition) const			{ return mNormal.Dot(inPosition - mCenter) > 0.0f; }
+
+		Vec3			mNormal;									///< Normal of the edge (not normalized)
+		Vec3			mCenter;									///< Center of the edge
+		ConflictList	mConflictList;								///< Positions associated with this edge (that are closest to this edge). Last entry is the one furthest away from the edge, remainder is unsorted.
+		Edge *			mPrevEdge = nullptr;						///< Previous edge in circular list
+		Edge *			mNextEdge = nullptr;						///< Next edge in circular list
+		int				mStartIdx;									///< Position index of start of this edge
+		float			mFurthestPointDistanceSq = 0.0f;			///< Squared distance of furthest point from the conflict list to the edge
+	};
+
+	const Positions &	mPositions;									///< List of positions (some of them are part of the hull)
+	Edge *				mFirstEdge = nullptr;						///< First edge of the hull
+	int					mNumEdges = 0;								///< Number of edges in hull
+
+#ifdef JPH_CONVEX_BUILDER_2D_DEBUG
+	RVec3				mOffset;									///< Offset to use for state drawing
+	Vec3				mDelta;										///< Delta offset between next states
+#endif
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Geometry/ConvexSupport.h

@@ -0,0 +1,188 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Math/Mat44.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Helper functions to get the support point for a convex object
+/// Structure that transforms a convex object (supports only uniform scaling)
+template <typename ConvexObject>
+struct TransformedConvexObject
+{
+	/// Create transformed convex object.
+	TransformedConvexObject(Mat44Arg inTransform, const ConvexObject &inObject) :
+		mTransform(inTransform),
+		mObject(inObject)
+	{
+	}
+
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport(Vec3Arg inDirection) const
+	{
+		return mTransform * mObject.GetSupport(mTransform.Multiply3x3Transposed(inDirection));
+	}
+
+	/// Get the vertices of the face that faces inDirection the most
+	template <class VERTEX_ARRAY>
+	void					GetSupportingFace(Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
+	{
+		mObject.GetSupportingFace(mTransform.Multiply3x3Transposed(inDirection), outVertices);
+
+		for (Vec3 &v : outVertices)
+			v = mTransform * v;
+	}
+
+	Mat44					mTransform;
+	const ConvexObject &	mObject;
+};
+
+/// Structure that adds a convex radius
+template <typename ConvexObject>
+struct AddConvexRadius
+{
+	AddConvexRadius(const ConvexObject &inObject, float inRadius) :
+		mObject(inObject),
+		mRadius(inRadius)
+	{
+	}
+
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport(Vec3Arg inDirection) const
+	{
+		float length = inDirection.Length();
+		return length > 0.0f ? mObject.GetSupport(inDirection) + (mRadius / length) * inDirection : mObject.GetSupport(inDirection);
+	}
+
+	const ConvexObject &	mObject;
+	float					mRadius;
+};
+
+/// Structure that performs a Minkowski difference A - B
+template <typename ConvexObjectA, typename ConvexObjectB>
+struct MinkowskiDifference
+{
+	MinkowskiDifference(const ConvexObjectA &inObjectA, const ConvexObjectB &inObjectB) :
+		mObjectA(inObjectA),
+		mObjectB(inObjectB)
+	{
+	}
+
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport(Vec3Arg inDirection) const
+	{
+		return mObjectA.GetSupport(inDirection) - mObjectB.GetSupport(-inDirection);
+	}
+
+	const ConvexObjectA &	mObjectA;
+	const ConvexObjectB &	mObjectB;
+};
+
+/// Class that wraps a point so that it can be used with convex collision detection
+struct PointConvexSupport
+{
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport([[maybe_unused]] Vec3Arg inDirection) const
+	{
+		return mPoint;
+	}
+
+	Vec3					mPoint;
+};
+
+/// Class that wraps a triangle so that it can used with convex collision detection
+struct TriangleConvexSupport
+{
+	/// Constructor
+							TriangleConvexSupport(Vec3Arg inV1, Vec3Arg inV2, Vec3Arg inV3) :
+		mV1(inV1),
+		mV2(inV2),
+		mV3(inV3)
+	{
+	}
+
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport(Vec3Arg inDirection) const
+	{
+		// Project vertices on inDirection
+		float d1 = mV1.Dot(inDirection);
+		float d2 = mV2.Dot(inDirection);
+		float d3 = mV3.Dot(inDirection);
+
+		// Return vertex with biggest projection
+		if (d1 > d2)
+		{
+			if (d1 > d3)
+				return mV1;
+			else
+				return mV3;
+		}
+		else
+		{
+			if (d2 > d3)
+				return mV2;
+			else
+				return mV3;
+		}
+	}
+
+	/// Get the vertices of the face that faces inDirection the most
+	template <class VERTEX_ARRAY>
+	void					GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY &outVertices) const
+	{
+		outVertices.push_back(mV1);
+		outVertices.push_back(mV2);
+		outVertices.push_back(mV3);
+	}
+
+	/// The three vertices of the triangle
+	Vec3					mV1;
+	Vec3					mV2;
+	Vec3					mV3;
+};
+
+/// Class that wraps a polygon so that it can used with convex collision detection
+template <class VERTEX_ARRAY>
+struct PolygonConvexSupport
+{
+	/// Constructor
+	explicit				PolygonConvexSupport(const VERTEX_ARRAY &inVertices) :
+		mVertices(inVertices)
+	{
+	}
+
+	/// Calculate the support vector for this convex shape.
+	Vec3					GetSupport(Vec3Arg inDirection) const
+	{
+		Vec3 support_point = mVertices[0];
+		float best_dot = mVertices[0].Dot(inDirection);
+
+		for (typename VERTEX_ARRAY::const_iterator v = mVertices.begin() + 1; v < mVertices.end(); ++v)
+		{
+			float dot = v->Dot(inDirection);
+			if (dot > best_dot)
+			{
+				best_dot = dot;
+				support_point = *v;
+			}
+		}
+
+		return support_point;
+	}
+
+	/// Get the vertices of the face that faces inDirection the most
+	template <class VERTEX_ARRAY_ARG>
+	void					GetSupportingFace([[maybe_unused]] Vec3Arg inDirection, VERTEX_ARRAY_ARG &outVertices) const
+	{
+		for (Vec3 v : mVertices)
+			outVertices.push_back(v);
+	}
+
+	/// The vertices of the polygon
+	const VERTEX_ARRAY &	mVertices;
+};
+
+JPH_NAMESPACE_END