@bloomengine/engine 0.4.0 → 0.4.2

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

@@ -1,105 +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>
-
-//#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

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