@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/PathConstraintPathHermite.h

@@ -1,54 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Constraints/PathConstraintPath.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// A path that follows a Hermite spline
-class JPH_EXPORT PathConstraintPathHermite final : public PathConstraintPath
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PathConstraintPathHermite)
-
-public:
-	// See PathConstraintPath::GetPathMaxFraction
-	virtual float		GetPathMaxFraction() const override									{ return float(IsLooping()? mPoints.size() : mPoints.size() - 1); }
-
-	// See PathConstraintPath::GetClosestPoint
-	virtual float		GetClosestPoint(Vec3Arg inPosition, float inFractionHint) const override;
-
-	// See PathConstraintPath::GetPointOnPath
-	virtual void		GetPointOnPath(float inFraction, Vec3 &outPathPosition, Vec3 &outPathTangent, Vec3 &outPathNormal, Vec3 &outPathBinormal) const override;
-
-	/// Adds a point to the path
-	void				AddPoint(Vec3Arg inPosition, Vec3Arg inTangent, Vec3Arg inNormal)	{ mPoints.push_back({ inPosition, inTangent, inNormal}); }
-
-	// See: PathConstraintPath::SaveBinaryState
-	virtual void		SaveBinaryState(StreamOut &inStream) const override;
-
-	struct Point
-	{
-		JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Point)
-
-		Vec3			mPosition;															///< Position on the path
-		Vec3			mTangent;															///< Tangent of the path, does not need to be normalized (in the direction of the path)
-		Vec3			mNormal;															///< Normal of the path (together with the tangent along the curve this forms a basis for the constraint)
-	};
-
-protected:
-	// See: PathConstraintPath::RestoreBinaryState
-	virtual void		RestoreBinaryState(StreamIn &inStream) override;
-
-private:
-	/// Helper function that returns the index of the path segment and the fraction t on the path segment based on the full path fraction
-	inline void			GetIndexAndT(float inFraction, int &outIndex, float &outT) const;
-
-	using Points = Array<Point>;
-
-	Points				mPoints;															///< Points on the Hermite spline
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/PointConstraint.cpp

@@ -1,157 +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/Constraints/PointConstraint.h>
-#include <Jolt/Physics/Body/Body.h>
-#include <Jolt/ObjectStream/TypeDeclarations.h>
-#include <Jolt/Core/StreamIn.h>
-#include <Jolt/Core/StreamOut.h>
-#ifdef JPH_DEBUG_RENDERER
-	#include <Jolt/Renderer/DebugRenderer.h>
-#endif // JPH_DEBUG_RENDERER
-
-JPH_NAMESPACE_BEGIN
-
-JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(PointConstraintSettings)
-{
-	JPH_ADD_BASE_CLASS(PointConstraintSettings, TwoBodyConstraintSettings)
-
-	JPH_ADD_ENUM_ATTRIBUTE(PointConstraintSettings, mSpace)
-	JPH_ADD_ATTRIBUTE(PointConstraintSettings, mPoint1)
-	JPH_ADD_ATTRIBUTE(PointConstraintSettings, mPoint2)
-}
-
-void PointConstraintSettings::SaveBinaryState(StreamOut &inStream) const
-{
-	ConstraintSettings::SaveBinaryState(inStream);
-
-	inStream.Write(mSpace);
-	inStream.Write(mPoint1);
-	inStream.Write(mPoint2);
-}
-
-void PointConstraintSettings::RestoreBinaryState(StreamIn &inStream)
-{
-	ConstraintSettings::RestoreBinaryState(inStream);
-
-	inStream.Read(mSpace);
-	inStream.Read(mPoint1);
-	inStream.Read(mPoint2);
-}
-
-TwoBodyConstraint *PointConstraintSettings::Create(Body &inBody1, Body &inBody2) const
-{
-	return new PointConstraint(inBody1, inBody2, *this);
-}
-
-PointConstraint::PointConstraint(Body &inBody1, Body &inBody2, const PointConstraintSettings &inSettings) :
-	TwoBodyConstraint(inBody1, inBody2, inSettings)
-{
-	if (inSettings.mSpace == EConstraintSpace::WorldSpace)
-	{
-		// If all properties were specified in world space, take them to local space now
-		mLocalSpacePosition1 = Vec3(inBody1.GetInverseCenterOfMassTransform() * inSettings.mPoint1);
-		mLocalSpacePosition2 = Vec3(inBody2.GetInverseCenterOfMassTransform() * inSettings.mPoint2);
-	}
-	else
-	{
-		mLocalSpacePosition1 = Vec3(inSettings.mPoint1);
-		mLocalSpacePosition2 = Vec3(inSettings.mPoint2);
-	}
-}
-
-void PointConstraint::NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM)
-{
-	if (mBody1->GetID() == inBodyID)
-		mLocalSpacePosition1 -= inDeltaCOM;
-	else if (mBody2->GetID() == inBodyID)
-		mLocalSpacePosition2 -= inDeltaCOM;
-}
-
-void PointConstraint::SetPoint1(EConstraintSpace inSpace, RVec3Arg inPoint1)
-{
-	if (inSpace == EConstraintSpace::WorldSpace)
-		mLocalSpacePosition1 = Vec3(mBody1->GetInverseCenterOfMassTransform() * inPoint1);
-	else
-		mLocalSpacePosition1 = Vec3(inPoint1);
-}
-
-void PointConstraint::SetPoint2(EConstraintSpace inSpace, RVec3Arg inPoint2)
-{
-	if (inSpace == EConstraintSpace::WorldSpace)
-		mLocalSpacePosition2 = Vec3(mBody2->GetInverseCenterOfMassTransform() * inPoint2);
-	else
-		mLocalSpacePosition2 = Vec3(inPoint2);
-}
-
-void PointConstraint::CalculateConstraintProperties()
-{
-	mPointConstraintPart.CalculateConstraintProperties(*mBody1, Mat44::sRotation(mBody1->GetRotation()), mLocalSpacePosition1, *mBody2, Mat44::sRotation(mBody2->GetRotation()), mLocalSpacePosition2);
-}
-
-void PointConstraint::SetupVelocityConstraint(float inDeltaTime)
-{
-	CalculateConstraintProperties();
-}
-
-void PointConstraint::ResetWarmStart()
-{
-	mPointConstraintPart.Deactivate();
-}
-
-void PointConstraint::WarmStartVelocityConstraint(float inWarmStartImpulseRatio)
-{
-	// Warm starting: Apply previous frame impulse
-	mPointConstraintPart.WarmStart(*mBody1, *mBody2, inWarmStartImpulseRatio);
-}
-
-bool PointConstraint::SolveVelocityConstraint(float inDeltaTime)
-{
-	return mPointConstraintPart.SolveVelocityConstraint(*mBody1, *mBody2);
-}
-
-bool PointConstraint::SolvePositionConstraint(float inDeltaTime, float inBaumgarte)
-{
-	// Update constraint properties (bodies may have moved)
-	CalculateConstraintProperties();
-
-	return mPointConstraintPart.SolvePositionConstraint(*mBody1, *mBody2, inBaumgarte);
-}
-
-#ifdef JPH_DEBUG_RENDERER
-void PointConstraint::DrawConstraint(DebugRenderer *inRenderer) const
-{
-	// Draw constraint
-	inRenderer->DrawMarker(mBody1->GetCenterOfMassTransform() * mLocalSpacePosition1, Color::sRed, 0.1f);
-	inRenderer->DrawMarker(mBody2->GetCenterOfMassTransform() * mLocalSpacePosition2, Color::sGreen, 0.1f);
-}
-#endif // JPH_DEBUG_RENDERER
-
-void PointConstraint::SaveState(StateRecorder &inStream) const
-{
-	TwoBodyConstraint::SaveState(inStream);
-
-	mPointConstraintPart.SaveState(inStream);
-}
-
-void PointConstraint::RestoreState(StateRecorder &inStream)
-{
-	TwoBodyConstraint::RestoreState(inStream);
-
-	mPointConstraintPart.RestoreState(inStream);
-}
-
-Ref<ConstraintSettings> PointConstraint::GetConstraintSettings() const
-{
-	PointConstraintSettings *settings = new PointConstraintSettings;
-	ToConstraintSettings(*settings);
-	settings->mSpace = EConstraintSpace::LocalToBodyCOM;
-	settings->mPoint1 = RVec3(mLocalSpacePosition1);
-	settings->mPoint2 = RVec3(mLocalSpacePosition2);
-	return settings;
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/PointConstraint.h

@@ -1,94 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
-#include <Jolt/Physics/Constraints/ConstraintPart/PointConstraintPart.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Point constraint settings, used to create a point constraint
-class JPH_EXPORT PointConstraintSettings final : public TwoBodyConstraintSettings
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PointConstraintSettings)
-
-public:
-	// See: ConstraintSettings::SaveBinaryState
-	virtual void				SaveBinaryState(StreamOut &inStream) const override;
-
-	/// Create an instance of this constraint
-	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
-
-	/// This determines in which space the constraint is setup, all properties below should be in the specified space
-	EConstraintSpace			mSpace = EConstraintSpace::WorldSpace;
-
-	/// Body 1 constraint position (space determined by mSpace).
-	RVec3						mPoint1 = RVec3::sZero();
-
-	/// Body 2 constraint position (space determined by mSpace).
-	/// Note: Normally you would set mPoint1 = mPoint2 if the bodies are already placed how you want to constrain them (if mSpace = world space).
-	RVec3						mPoint2 = RVec3::sZero();
-
-protected:
-	// See: ConstraintSettings::RestoreBinaryState
-	virtual void				RestoreBinaryState(StreamIn &inStream) override;
-};
-
-/// A point constraint constrains 2 bodies on a single point (removing 3 degrees of freedom)
-class JPH_EXPORT PointConstraint final : public TwoBodyConstraint
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Construct point constraint
-								PointConstraint(Body &inBody1, Body &inBody2, const PointConstraintSettings &inSettings);
-
-	// Generic interface of a constraint
-	virtual EConstraintSubType	GetSubType() const override									{ return EConstraintSubType::Point; }
-	virtual void				NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM) override;
-	virtual void				SetupVelocityConstraint(float inDeltaTime) override;
-	virtual void				ResetWarmStart() override;
-	virtual void				WarmStartVelocityConstraint(float inWarmStartImpulseRatio) override;
-	virtual bool				SolveVelocityConstraint(float inDeltaTime) override;
-	virtual bool				SolvePositionConstraint(float inDeltaTime, float inBaumgarte) override;
-#ifdef JPH_DEBUG_RENDERER
-	virtual void				DrawConstraint(DebugRenderer *inRenderer) const override;
-#endif // JPH_DEBUG_RENDERER
-	virtual void				SaveState(StateRecorder &inStream) const override;
-	virtual void				RestoreState(StateRecorder &inStream) override;
-	virtual Ref<ConstraintSettings> GetConstraintSettings() const override;
-
-	/// Update the attachment point for body 1
-	void						SetPoint1(EConstraintSpace inSpace, RVec3Arg inPoint1);
-
-	/// Update the attachment point for body 2
-	void						SetPoint2(EConstraintSpace inSpace, RVec3Arg inPoint2);
-
-	/// Get the attachment point for body 1 relative to body 1 COM (transform by Body::GetCenterOfMassTransform to take to world space)
-	inline Vec3					GetLocalSpacePoint1() const									{ return mLocalSpacePosition1; }
-
-	/// Get the attachment point for body 2 relative to body 2 COM (transform by Body::GetCenterOfMassTransform to take to world space)
-	inline Vec3					GetLocalSpacePoint2() const									{ return mLocalSpacePosition2; }
-
-	// See: TwoBodyConstraint
-	virtual Mat44				GetConstraintToBody1Matrix() const override					{ return Mat44::sTranslation(mLocalSpacePosition1); }
-	virtual Mat44				GetConstraintToBody2Matrix() const override					{ return Mat44::sTranslation(mLocalSpacePosition2); } // Note: Incorrect rotation as we don't track the original rotation difference, should not matter though as the constraint is not limiting rotation.
-
-	///@name Get Lagrange multiplier from last physics update (the linear impulse applied to satisfy the constraint)
-	inline Vec3					GetTotalLambdaPosition() const								{ return mPointConstraintPart.GetTotalLambda(); }
-
-private:
-	// Internal helper function to calculate the values below
-	void						CalculateConstraintProperties();
-
-	// Local space constraint positions
-	Vec3						mLocalSpacePosition1;
-	Vec3						mLocalSpacePosition2;
-
-	// The constraint part
-	PointConstraintPart			mPointConstraintPart;
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/PulleyConstraint.cpp

@@ -1,253 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Physics/Constraints/PulleyConstraint.h>
-#include <Jolt/Physics/Body/Body.h>
-#include <Jolt/ObjectStream/TypeDeclarations.h>
-#include <Jolt/Core/StreamIn.h>
-#include <Jolt/Core/StreamOut.h>
-#ifdef JPH_DEBUG_RENDERER
-	#include <Jolt/Renderer/DebugRenderer.h>
-#endif // JPH_DEBUG_RENDERER
-
-JPH_NAMESPACE_BEGIN
-
-using namespace literals;
-
-JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(PulleyConstraintSettings)
-{
-	JPH_ADD_BASE_CLASS(PulleyConstraintSettings, TwoBodyConstraintSettings)
-
-	JPH_ADD_ENUM_ATTRIBUTE(PulleyConstraintSettings, mSpace)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mBodyPoint1)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mFixedPoint1)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mBodyPoint2)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mFixedPoint2)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mRatio)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mMinLength)
-	JPH_ADD_ATTRIBUTE(PulleyConstraintSettings, mMaxLength)
-}
-
-void PulleyConstraintSettings::SaveBinaryState(StreamOut &inStream) const
-{
-	ConstraintSettings::SaveBinaryState(inStream);
-
-	inStream.Write(mSpace);
-	inStream.Write(mBodyPoint1);
-	inStream.Write(mFixedPoint1);
-	inStream.Write(mBodyPoint2);
-	inStream.Write(mFixedPoint2);
-	inStream.Write(mRatio);
-	inStream.Write(mMinLength);
-	inStream.Write(mMaxLength);
-}
-
-void PulleyConstraintSettings::RestoreBinaryState(StreamIn &inStream)
-{
-	ConstraintSettings::RestoreBinaryState(inStream);
-
-	inStream.Read(mSpace);
-	inStream.Read(mBodyPoint1);
-	inStream.Read(mFixedPoint1);
-	inStream.Read(mBodyPoint2);
-	inStream.Read(mFixedPoint2);
-	inStream.Read(mRatio);
-	inStream.Read(mMinLength);
-	inStream.Read(mMaxLength);
-}
-
-TwoBodyConstraint *PulleyConstraintSettings::Create(Body &inBody1, Body &inBody2) const
-{
-	return new PulleyConstraint(inBody1, inBody2, *this);
-}
-
-PulleyConstraint::PulleyConstraint(Body &inBody1, Body &inBody2, const PulleyConstraintSettings &inSettings) :
-	TwoBodyConstraint(inBody1, inBody2, inSettings),
-	mFixedPosition1(inSettings.mFixedPoint1),
-	mFixedPosition2(inSettings.mFixedPoint2),
-	mRatio(inSettings.mRatio),
-	mMinLength(inSettings.mMinLength),
-	mMaxLength(inSettings.mMaxLength)
-{
-	if (inSettings.mSpace == EConstraintSpace::WorldSpace)
-	{
-		// If all properties were specified in world space, take them to local space now
-		mLocalSpacePosition1 = Vec3(inBody1.GetInverseCenterOfMassTransform() * inSettings.mBodyPoint1);
-		mLocalSpacePosition2 = Vec3(inBody2.GetInverseCenterOfMassTransform() * inSettings.mBodyPoint2);
-		mWorldSpacePosition1 = inSettings.mBodyPoint1;
-		mWorldSpacePosition2 = inSettings.mBodyPoint2;
-	}
-	else
-	{
-		// If properties were specified in local space, we need to calculate world space positions
-		mLocalSpacePosition1 = Vec3(inSettings.mBodyPoint1);
-		mLocalSpacePosition2 = Vec3(inSettings.mBodyPoint2);
-		mWorldSpacePosition1 = inBody1.GetCenterOfMassTransform() * inSettings.mBodyPoint1;
-		mWorldSpacePosition2 = inBody2.GetCenterOfMassTransform() * inSettings.mBodyPoint2;
-	}
-
-	// Calculate min/max length if it was not provided
-	float current_length = GetCurrentLength();
-	if (mMinLength < 0.0f)
-		mMinLength = current_length;
-	if (mMaxLength < 0.0f)
-		mMaxLength = current_length;
-
-	// Initialize the normals to a likely valid axis in case the fixed points overlap with the attachment points (most likely the fixed points are above both bodies)
-	mWorldSpaceNormal1 = mWorldSpaceNormal2 = -Vec3::sAxisY();
-}
-
-void PulleyConstraint::NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM)
-{
-	if (mBody1->GetID() == inBodyID)
-		mLocalSpacePosition1 -= inDeltaCOM;
-	else if (mBody2->GetID() == inBodyID)
-		mLocalSpacePosition2 -= inDeltaCOM;
-}
-
-float PulleyConstraint::CalculatePositionsNormalsAndLength()
-{
-	// Update world space positions (the bodies may have moved)
-	mWorldSpacePosition1 = mBody1->GetCenterOfMassTransform() * mLocalSpacePosition1;
-	mWorldSpacePosition2 = mBody2->GetCenterOfMassTransform() * mLocalSpacePosition2;
-
-	// Calculate world space normals
-	Vec3 delta1 = Vec3(mWorldSpacePosition1 - mFixedPosition1);
-	float delta1_len = delta1.Length();
-	if (delta1_len > 0.0f)
-		mWorldSpaceNormal1 = delta1 / delta1_len;
-
-	Vec3 delta2 = Vec3(mWorldSpacePosition2 - mFixedPosition2);
-	float delta2_len = delta2.Length();
-	if (delta2_len > 0.0f)
-		mWorldSpaceNormal2 = delta2 / delta2_len;
-
-	// Calculate length
-	return delta1_len + mRatio * delta2_len;
-}
-
-void PulleyConstraint::CalculateConstraintProperties()
-{
-	// Calculate attachment points relative to COM
-	Vec3 r1 = Vec3(mWorldSpacePosition1 - mBody1->GetCenterOfMassPosition());
-	Vec3 r2 = Vec3(mWorldSpacePosition2 - mBody2->GetCenterOfMassPosition());
-
-	mIndependentAxisConstraintPart.CalculateConstraintProperties(*mBody1, *mBody2, r1, mWorldSpaceNormal1, r2, mWorldSpaceNormal2, mRatio);
-}
-
-void PulleyConstraint::SetupVelocityConstraint(float inDeltaTime)
-{
-	// Determine if the constraint is active
-	float current_length = CalculatePositionsNormalsAndLength();
-	bool min_length_violation = current_length <= mMinLength;
-	bool max_length_violation = current_length >= mMaxLength;
-	if (min_length_violation || max_length_violation)
-	{
-		// Determine max lambda based on if the length is too big or small
-		mMinLambda = max_length_violation? -FLT_MAX : 0.0f;
-		mMaxLambda = min_length_violation? FLT_MAX : 0.0f;
-
-		CalculateConstraintProperties();
-	}
-	else
-		mIndependentAxisConstraintPart.Deactivate();
-}
-
-void PulleyConstraint::ResetWarmStart()
-{
-	mIndependentAxisConstraintPart.Deactivate();
-}
-
-void PulleyConstraint::WarmStartVelocityConstraint(float inWarmStartImpulseRatio)
-{
-	mIndependentAxisConstraintPart.WarmStart(*mBody1, *mBody2, mWorldSpaceNormal1, mWorldSpaceNormal2, mRatio, inWarmStartImpulseRatio);
-}
-
-bool PulleyConstraint::SolveVelocityConstraint(float inDeltaTime)
-{
-	if (mIndependentAxisConstraintPart.IsActive())
-		return mIndependentAxisConstraintPart.SolveVelocityConstraint(*mBody1, *mBody2, mWorldSpaceNormal1, mWorldSpaceNormal2, mRatio, mMinLambda, mMaxLambda);
-	else
-		return false;
-}
-
-bool PulleyConstraint::SolvePositionConstraint(float inDeltaTime, float inBaumgarte)
-{
-	// Calculate new length (bodies may have changed)
-	float current_length = CalculatePositionsNormalsAndLength();
-
-	float position_error = 0.0f;
-	if (current_length < mMinLength)
-		position_error = current_length - mMinLength;
-	else if (current_length > mMaxLength)
-		position_error = current_length - mMaxLength;
-
-	if (position_error != 0.0f)
-	{
-		// Update constraint properties (bodies may have moved)
-		CalculateConstraintProperties();
-
-		return mIndependentAxisConstraintPart.SolvePositionConstraint(*mBody1, *mBody2, mWorldSpaceNormal1, mWorldSpaceNormal2, mRatio, position_error, inBaumgarte);
-	}
-
-	return false;
-}
-
-#ifdef JPH_DEBUG_RENDERER
-void PulleyConstraint::DrawConstraint(DebugRenderer *inRenderer) const
-{
-	// Color according to length vs min/max length
-	float current_length = GetCurrentLength();
-	Color color = Color::sGreen;
-	if (current_length < mMinLength)
-		color = Color::sYellow;
-	else if (current_length > mMaxLength)
-		color = Color::sRed;
-
-	// Draw constraint
-	inRenderer->DrawLine(mWorldSpacePosition1, mFixedPosition1, color);
-	inRenderer->DrawLine(mFixedPosition1, mFixedPosition2, color);
-	inRenderer->DrawLine(mFixedPosition2, mWorldSpacePosition2, color);
-
-	// Draw current length
-	inRenderer->DrawText3D(0.5_r * (mFixedPosition1 + mFixedPosition2), StringFormat("%.2f", (double)current_length));
-}
-#endif // JPH_DEBUG_RENDERER
-
-void PulleyConstraint::SaveState(StateRecorder &inStream) const
-{
-	TwoBodyConstraint::SaveState(inStream);
-
-	mIndependentAxisConstraintPart.SaveState(inStream);
-	inStream.Write(mWorldSpaceNormal1); // When distance to fixed point = 0, the normal is used from last frame so we need to store it
-	inStream.Write(mWorldSpaceNormal2);
-}
-
-void PulleyConstraint::RestoreState(StateRecorder &inStream)
-{
-	TwoBodyConstraint::RestoreState(inStream);
-
-	mIndependentAxisConstraintPart.RestoreState(inStream);
-	inStream.Read(mWorldSpaceNormal1);
-	inStream.Read(mWorldSpaceNormal2);
-}
-
-Ref<ConstraintSettings> PulleyConstraint::GetConstraintSettings() const
-{
-	PulleyConstraintSettings *settings = new PulleyConstraintSettings;
-	ToConstraintSettings(*settings);
-	settings->mSpace = EConstraintSpace::LocalToBodyCOM;
-	settings->mBodyPoint1 = RVec3(mLocalSpacePosition1);
-	settings->mFixedPoint1 = mFixedPosition1;
-	settings->mBodyPoint2 = RVec3(mLocalSpacePosition2);
-	settings->mFixedPoint2 = mFixedPosition2;
-	settings->mRatio = mRatio;
-	settings->mMinLength = mMinLength;
-	settings->mMaxLength = mMaxLength;
-	return settings;
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/PulleyConstraint.h

@@ -1,137 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
-#include <Jolt/Physics/Constraints/ConstraintPart/IndependentAxisConstraintPart.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Pulley constraint settings, used to create a pulley constraint.
-/// A pulley connects two bodies via two fixed world points to each other similar to a distance constraint.
-/// We define Length1 = |BodyPoint1 - FixedPoint1| where Body1 is a point on body 1 in world space and FixedPoint1 a fixed point in world space
-/// Length2 = |BodyPoint2 - FixedPoint2|
-/// The constraint keeps the two line segments constrained so that
-/// MinDistance <= Length1 + Ratio * Length2 <= MaxDistance
-class JPH_EXPORT PulleyConstraintSettings final : public TwoBodyConstraintSettings
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, PulleyConstraintSettings)
-
-public:
-	// See: ConstraintSettings::SaveBinaryState
-	virtual void				SaveBinaryState(StreamOut &inStream) const override;
-
-	/// Create an instance of this constraint
-	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const override;
-
-	/// This determines in which space the constraint is setup, specified properties below should be in the specified space
-	EConstraintSpace			mSpace = EConstraintSpace::WorldSpace;
-
-	/// Body 1 constraint attachment point (space determined by mSpace).
-	RVec3						mBodyPoint1 = RVec3::sZero();
-
-	/// Fixed world point to which body 1 is connected (always world space)
-	RVec3						mFixedPoint1 = RVec3::sZero();
-
-	/// Body 2 constraint attachment point (space determined by mSpace)
-	RVec3						mBodyPoint2 = RVec3::sZero();
-
-	/// Fixed world point to which body 2 is connected (always world space)
-	RVec3						mFixedPoint2 = RVec3::sZero();
-
-	/// Ratio between the two line segments (see formula above), can be used to create a block and tackle
-	float						mRatio = 1.0f;
-
-	/// The minimum length of the line segments (see formula above), use -1 to calculate the length based on the positions of the objects when the constraint is created.
-	float						mMinLength = 0.0f;
-
-	/// The maximum length of the line segments (see formula above), use -1 to calculate the length based on the positions of the objects when the constraint is created.
-	float						mMaxLength = -1.0f;
-
-protected:
-	// See: ConstraintSettings::RestoreBinaryState
-	virtual void				RestoreBinaryState(StreamIn &inStream) override;
-};
-
-/// A pulley constraint.
-class JPH_EXPORT PulleyConstraint final : public TwoBodyConstraint
-{
-public:
-	JPH_OVERRIDE_NEW_DELETE
-
-	/// Construct pulley constraint
-								PulleyConstraint(Body &inBody1, Body &inBody2, const PulleyConstraintSettings &inSettings);
-
-	// Generic interface of a constraint
-	virtual EConstraintSubType	GetSubType() const override									{ return EConstraintSubType::Pulley; }
-	virtual void				NotifyShapeChanged(const BodyID &inBodyID, Vec3Arg inDeltaCOM) override;
-	virtual void				SetupVelocityConstraint(float inDeltaTime) override;
-	virtual void				ResetWarmStart() override;
-	virtual void				WarmStartVelocityConstraint(float inWarmStartImpulseRatio) override;
-	virtual bool				SolveVelocityConstraint(float inDeltaTime) override;
-	virtual bool				SolvePositionConstraint(float inDeltaTime, float inBaumgarte) override;
-#ifdef JPH_DEBUG_RENDERER
-	virtual void				DrawConstraint(DebugRenderer *inRenderer) const override;
-#endif // JPH_DEBUG_RENDERER
-	virtual void				SaveState(StateRecorder &inStream) const override;
-	virtual void				RestoreState(StateRecorder &inStream) override;
-	virtual Ref<ConstraintSettings> GetConstraintSettings() const override;
-
-	// See: TwoBodyConstraint
-	virtual Mat44				GetConstraintToBody1Matrix() const override					{ return Mat44::sTranslation(mLocalSpacePosition1); }
-	virtual Mat44				GetConstraintToBody2Matrix() const override					{ return Mat44::sTranslation(mLocalSpacePosition2); } // Note: Incorrect rotation as we don't track the original rotation difference, should not matter though as the constraint is not limiting rotation.
-
-	/// Update the minimum and maximum length for the constraint
-	void						SetLength(float inMinLength, float inMaxLength)				{ JPH_ASSERT(inMinLength >= 0.0f && inMinLength <= inMaxLength); mMinLength = inMinLength; mMaxLength = inMaxLength; }
-	float						GetMinLength() const										{ return mMinLength; }
-	float						GetMaxLength() const										{ return mMaxLength; }
-
-	/// Get the current length of both segments (multiplied by the ratio for segment 2)
-	float						GetCurrentLength() const									{ return Vec3(mWorldSpacePosition1 - mFixedPosition1).Length() + mRatio * Vec3(mWorldSpacePosition2 - mFixedPosition2).Length(); }
-
-	///@name Get Lagrange multiplier from last physics update (the linear impulse applied to satisfy the constraint)
-	inline float				GetTotalLambdaPosition() const								{ return mIndependentAxisConstraintPart.GetTotalLambda(); }
-
-private:
-	// Calculates world positions and normals and returns current length
-	float						CalculatePositionsNormalsAndLength();
-
-	// Internal helper function to calculate the values below
-	void						CalculateConstraintProperties();
-
-	// CONFIGURATION PROPERTIES FOLLOW
-
-	// Local space constraint positions on the bodies
-	Vec3						mLocalSpacePosition1;
-	Vec3						mLocalSpacePosition2;
-
-	// World space fixed positions
-	RVec3						mFixedPosition1;
-	RVec3						mFixedPosition2;
-
-	/// Ratio between the two line segments
-	float						mRatio;
-
-	// The minimum/maximum length of the line segments
-	float						mMinLength;
-	float						mMaxLength;
-
-	// RUN TIME PROPERTIES FOLLOW
-
-	// World space positions and normal
-	RVec3						mWorldSpacePosition1;
-	RVec3						mWorldSpacePosition2;
-	Vec3						mWorldSpaceNormal1;
-	Vec3						mWorldSpaceNormal2;
-
-	// Depending on if the length < min or length > max we can apply forces to prevent further violations
-	float						mMinLambda;
-	float						mMaxLambda;
-
-	// The constraint part
-	IndependentAxisConstraintPart mIndependentAxisConstraintPart;
-};
-
-JPH_NAMESPACE_END