@bloomengine/engine 0.3.1

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

@@ -0,0 +1,197 @@
+// 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/MotorSettings.h>
+#include <Jolt/Physics/Constraints/ConstraintPart/PointConstraintPart.h>
+#include <Jolt/Physics/Constraints/ConstraintPart/AngleConstraintPart.h>
+#include <Jolt/Physics/Constraints/ConstraintPart/SwingTwistConstraintPart.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Swing twist constraint settings, used to create a swing twist constraint
+/// All values in this structure are copied to the swing twist constraint and the settings object is no longer needed afterwards.
+///
+/// This image describes the limit settings:
+/// @image html Docs/SwingTwistConstraint.png
+class JPH_EXPORT SwingTwistConstraintSettings final : public TwoBodyConstraintSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, SwingTwistConstraintSettings)
+
+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;
+
+	///@name Body 1 constraint reference frame (space determined by mSpace)
+	RVec3						mPosition1 = RVec3::sZero();
+	Vec3						mTwistAxis1 = Vec3::sAxisX();
+	Vec3						mPlaneAxis1 = Vec3::sAxisY();
+
+	///@name Body 2 constraint reference frame (space determined by mSpace)
+	RVec3						mPosition2 = RVec3::sZero();
+	Vec3						mTwistAxis2 = Vec3::sAxisX();
+	Vec3						mPlaneAxis2 = Vec3::sAxisY();
+
+	/// The type of swing constraint that we want to use.
+	ESwingType					mSwingType = ESwingType::Cone;
+
+	///@name Swing rotation limits
+	float						mNormalHalfConeAngle = 0.0f;								///< See image at Detailed Description. Angle in radians.
+	float						mPlaneHalfConeAngle = 0.0f;									///< See image at Detailed Description. Angle in radians.
+
+	///@name Twist rotation limits
+	float						mTwistMinAngle = 0.0f;										///< See image at Detailed Description. Angle in radians. Should be \f$\in [-\pi, \pi]\f$.
+	float						mTwistMaxAngle = 0.0f;										///< See image at Detailed Description. Angle in radians. Should be \f$\in [-\pi, \pi]\f$.
+
+	///@name Friction
+	float						mMaxFrictionTorque = 0.0f;									///< Maximum amount of torque (N m) to apply as friction when the constraint is not powered by a motor
+
+	///@name In case the constraint is powered, this determines the motor settings around the swing and twist axis
+	MotorSettings				mSwingMotorSettings;
+	MotorSettings				mTwistMotorSettings;
+
+protected:
+	// See: ConstraintSettings::RestoreBinaryState
+	virtual void				RestoreBinaryState(StreamIn &inStream) override;
+};
+
+/// A swing twist constraint is a specialized constraint for humanoid ragdolls that allows limited rotation only
+///
+/// @see SwingTwistConstraintSettings for a description of the limits
+class JPH_EXPORT SwingTwistConstraint final : public TwoBodyConstraint
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Construct swing twist constraint
+								SwingTwistConstraint(Body &inBody1, Body &inBody2, const SwingTwistConstraintSettings &inSettings);
+
+	///@name Generic interface of a constraint
+	virtual EConstraintSubType	GetSubType() const override									{ return EConstraintSubType::SwingTwist; }
+	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;
+	virtual void				DrawConstraintLimits(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::sRotationTranslation(mConstraintToBody1, mLocalSpacePosition1); }
+	virtual Mat44				GetConstraintToBody2Matrix() const override					{ return Mat44::sRotationTranslation(mConstraintToBody2, mLocalSpacePosition2); }
+
+	///@name Constraint reference frame
+	inline Vec3					GetLocalSpacePosition1() const								{ return mLocalSpacePosition1; }
+	inline Vec3					GetLocalSpacePosition2() const								{ return mLocalSpacePosition2; }
+	inline Quat					GetConstraintToBody1() const								{ return mConstraintToBody1; }
+	inline Quat					GetConstraintToBody2() const								{ return mConstraintToBody2; }
+
+	///@name Constraint limits
+	inline float				GetNormalHalfConeAngle() const								{ return mNormalHalfConeAngle; }
+	inline void					SetNormalHalfConeAngle(float inAngle)						{ mNormalHalfConeAngle = inAngle; UpdateLimits(); }
+	inline float				GetPlaneHalfConeAngle() const								{ return mPlaneHalfConeAngle; }
+	inline void					SetPlaneHalfConeAngle(float inAngle)						{ mPlaneHalfConeAngle = inAngle; UpdateLimits(); }
+	inline float				GetTwistMinAngle() const									{ return mTwistMinAngle; }
+	inline void					SetTwistMinAngle(float inAngle)								{ mTwistMinAngle = inAngle; UpdateLimits(); }
+	inline float				GetTwistMaxAngle() const									{ return mTwistMaxAngle; }
+	inline void					SetTwistMaxAngle(float inAngle)								{ mTwistMaxAngle = inAngle; UpdateLimits(); }
+
+	///@name Motor settings
+	const MotorSettings &		GetSwingMotorSettings() const								{ return mSwingMotorSettings; }
+	MotorSettings &				GetSwingMotorSettings()										{ return mSwingMotorSettings; }
+	const MotorSettings &		GetTwistMotorSettings() const								{ return mTwistMotorSettings; }
+	MotorSettings &				GetTwistMotorSettings()										{ return mTwistMotorSettings; }
+
+	///@name Friction control
+	void						SetMaxFrictionTorque(float inFrictionTorque)				{ mMaxFrictionTorque = inFrictionTorque; }
+	float						GetMaxFrictionTorque() const								{ return mMaxFrictionTorque; }
+
+	///@name Motor controls
+
+	/// Controls if the motors are on or off
+	void						SetSwingMotorState(EMotorState inState);
+	EMotorState					GetSwingMotorState() const									{ return mSwingMotorState; }
+	void						SetTwistMotorState(EMotorState inState);
+	EMotorState					GetTwistMotorState() const									{ return mTwistMotorState; }
+
+	/// Set the target angular velocity of body 2 in constraint space of body 2
+	void						SetTargetAngularVelocityCS(Vec3Arg inAngularVelocity)		{ mTargetAngularVelocity = inAngularVelocity; }
+	Vec3						GetTargetAngularVelocityCS() const							{ return mTargetAngularVelocity; }
+
+	/// Set the target orientation in constraint space (drives constraint to: GetRotationInConstraintSpace() == inOrientation)
+	void						SetTargetOrientationCS(QuatArg inOrientation);
+	Quat						GetTargetOrientationCS() const								{ return mTargetOrientation; }
+
+	/// Set the target orientation in body space (R2 = R1 * inOrientation, where R1 and R2 are the world space rotations for body 1 and 2).
+	/// Solve: R2 * ConstraintToBody2 = R1 * ConstraintToBody1 * q (see SwingTwistConstraint::GetSwingTwist) and R2 = R1 * inOrientation for q.
+	void						SetTargetOrientationBS(QuatArg inOrientation)				{ SetTargetOrientationCS(mConstraintToBody1.Conjugated() * inOrientation * mConstraintToBody2); }
+
+	/// Get current rotation of constraint in constraint space.
+	/// Solve: R2 * ConstraintToBody2 = R1 * ConstraintToBody1 * q for q.
+	Quat						GetRotationInConstraintSpace() const;
+
+	///@name Get Lagrange multiplier from last physics update (the linear/angular impulse applied to satisfy the constraint)
+	inline Vec3					GetTotalLambdaPosition() const								{ return mPointConstraintPart.GetTotalLambda(); }
+	inline float				GetTotalLambdaTwist() const									{ return mSwingTwistConstraintPart.GetTotalTwistLambda(); }
+	inline float				GetTotalLambdaSwingY() const								{ return mSwingTwistConstraintPart.GetTotalSwingYLambda(); }
+	inline float				GetTotalLambdaSwingZ() const								{ return mSwingTwistConstraintPart.GetTotalSwingZLambda(); }
+	inline Vec3					GetTotalLambdaMotor() const									{ return Vec3(mMotorConstraintPart[0].GetTotalLambda(), mMotorConstraintPart[1].GetTotalLambda(), mMotorConstraintPart[2].GetTotalLambda()); }
+
+private:
+	// Update the limits in the swing twist constraint part
+	void						UpdateLimits();
+
+	// CONFIGURATION PROPERTIES FOLLOW
+
+	// Local space constraint positions
+	Vec3						mLocalSpacePosition1;
+	Vec3						mLocalSpacePosition2;
+
+	// Transforms from constraint space to body space
+	Quat						mConstraintToBody1;
+	Quat						mConstraintToBody2;
+
+	// Limits
+	float						mNormalHalfConeAngle;
+	float						mPlaneHalfConeAngle;
+	float						mTwistMinAngle;
+	float						mTwistMaxAngle;
+
+	// Friction
+	float						mMaxFrictionTorque;
+
+	// Motor controls
+	MotorSettings				mSwingMotorSettings;
+	MotorSettings				mTwistMotorSettings;
+	EMotorState					mSwingMotorState = EMotorState::Off;
+	EMotorState					mTwistMotorState = EMotorState::Off;
+	Vec3						mTargetAngularVelocity = Vec3::sZero();
+	Quat						mTargetOrientation = Quat::sIdentity();
+
+	// RUN TIME PROPERTIES FOLLOW
+
+	// Rotation axis for motor constraint parts
+	Vec3						mWorldSpaceMotorAxis[3];
+
+	// The constraint parts
+	PointConstraintPart			mPointConstraintPart;
+	SwingTwistConstraintPart	mSwingTwistConstraintPart;
+	AngleConstraintPart			mMotorConstraintPart[3];
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,56 @@
+// 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/TwoBodyConstraint.h>
+#include <Jolt/Physics/IslandBuilder.h>
+#include <Jolt/Physics/LargeIslandSplitter.h>
+#include <Jolt/Physics/Body/BodyManager.h>
+
+#ifdef JPH_DEBUG_RENDERER
+	#include <Jolt/Renderer/DebugRenderer.h>
+#endif // JPH_DEBUG_RENDERER
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT(TwoBodyConstraintSettings)
+{
+	JPH_ADD_BASE_CLASS(TwoBodyConstraintSettings, ConstraintSettings)
+}
+
+void TwoBodyConstraint::BuildIslands(uint32 inConstraintIndex, IslandBuilder &ioBuilder, BodyManager &inBodyManager)
+{
+	// Activate bodies
+	BodyID body_ids[2];
+	int num_bodies = 0;
+	if (mBody1->IsDynamic() && !mBody1->IsActive())
+		body_ids[num_bodies++] = mBody1->GetID();
+	if (mBody2->IsDynamic() && !mBody2->IsActive())
+		body_ids[num_bodies++] = mBody2->GetID();
+	if (num_bodies > 0)
+		inBodyManager.ActivateBodies(body_ids, num_bodies);
+
+	// Link the bodies into the same island
+	ioBuilder.LinkConstraint(inConstraintIndex, mBody1->GetIndexInActiveBodiesInternal(), mBody2->GetIndexInActiveBodiesInternal());
+}
+
+uint TwoBodyConstraint::BuildIslandSplits(LargeIslandSplitter &ioSplitter) const
+{
+	return ioSplitter.AssignSplit(mBody1, mBody2);
+}
+
+#ifdef JPH_DEBUG_RENDERER
+
+void TwoBodyConstraint::DrawConstraintReferenceFrame(DebugRenderer *inRenderer) const
+{
+	RMat44 transform1 = mBody1->GetCenterOfMassTransform() * GetConstraintToBody1Matrix();
+	RMat44 transform2 = mBody2->GetCenterOfMassTransform() * GetConstraintToBody2Matrix();
+	inRenderer->DrawCoordinateSystem(transform1, 1.1f * mDrawConstraintSize);
+	inRenderer->DrawCoordinateSystem(transform2, mDrawConstraintSize);
+}
+
+#endif // JPH_DEBUG_RENDERER
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Constraints/TwoBodyConstraint.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/Constraints/Constraint.h>
+#include <Jolt/Physics/Body/Body.h>
+
+JPH_NAMESPACE_BEGIN
+
+class TwoBodyConstraint;
+
+/// Base class for settings for all constraints that involve 2 bodies
+class JPH_EXPORT TwoBodyConstraintSettings : public ConstraintSettings
+{
+	JPH_DECLARE_SERIALIZABLE_ABSTRACT(JPH_EXPORT, TwoBodyConstraintSettings)
+
+public:
+	/// Create an instance of this constraint
+	/// You can use Body::sFixedToWorld for inBody1 if you want to attach inBody2 to the world
+	virtual TwoBodyConstraint *	Create(Body &inBody1, Body &inBody2) const = 0;
+};
+
+/// Base class for all constraints that involve 2 bodies. Body1 is usually considered the parent, Body2 the child.
+class JPH_EXPORT TwoBodyConstraint : public Constraint
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+								TwoBodyConstraint(Body &inBody1, Body &inBody2, const TwoBodyConstraintSettings &inSettings) : Constraint(inSettings), mBody1(&inBody1), mBody2(&inBody2) { }
+
+	/// Get the type of a constraint
+	virtual EConstraintType		GetType() const override				{ return EConstraintType::TwoBodyConstraint; }
+
+	/// Solver interface
+	virtual bool				IsActive() const override				{ return Constraint::IsActive() && (mBody1->IsActive() || mBody2->IsActive()) && (mBody2->IsDynamic() || mBody1->IsDynamic()); }
+#ifdef JPH_DEBUG_RENDERER
+	virtual void				DrawConstraintReferenceFrame(DebugRenderer *inRenderer) const override;
+#endif // JPH_DEBUG_RENDERER
+
+	/// Access to the connected bodies
+	Body *						GetBody1() const						{ return mBody1; }
+	Body *						GetBody2() const						{ return mBody2; }
+
+	/// Calculates the transform that transforms from constraint space to body 1 space. The first column of the matrix is the primary constraint axis (e.g. the hinge axis / slider direction), second column the secondary etc.
+	virtual Mat44				GetConstraintToBody1Matrix() const = 0;
+
+	/// Calculates the transform that transforms from constraint space to body 2 space. The first column of the matrix is the primary constraint axis (e.g. the hinge axis / slider direction), second column the secondary etc.
+	virtual Mat44				GetConstraintToBody2Matrix() const = 0;
+
+	/// Link bodies that are connected by this constraint in the island builder
+	virtual void				BuildIslands(uint32 inConstraintIndex, IslandBuilder &ioBuilder, BodyManager &inBodyManager) override;
+
+	/// Link bodies that are connected by this constraint in the same split. Returns the split index.
+	virtual uint				BuildIslandSplits(LargeIslandSplitter &ioSplitter) const override;
+
+protected:
+	/// The two bodies involved
+	Body *						mBody1;
+	Body *						mBody2;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/DeterminismLog.cpp

@@ -0,0 +1,17 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/DeterminismLog.h>
+
+#ifdef JPH_ENABLE_DETERMINISM_LOG
+
+JPH_NAMESPACE_BEGIN
+
+DeterminismLog DeterminismLog::sLog;
+
+JPH_NAMESPACE_END
+
+#endif // JPH_ENABLE_DETERMINISM_LOG

package/native/third_party/JoltPhysics/Jolt/Physics/DeterminismLog.h

@@ -0,0 +1,159 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+//#define JPH_ENABLE_DETERMINISM_LOG
+#ifdef JPH_ENABLE_DETERMINISM_LOG
+
+#include <Jolt/Physics/Body/BodyID.h>
+#include <Jolt/Physics/Collision/Shape/SubShapeID.h>
+
+JPH_SUPPRESS_WARNINGS_STD_BEGIN
+#include <iomanip>
+#include <fstream>
+JPH_SUPPRESS_WARNINGS_STD_END
+
+JPH_NAMESPACE_BEGIN
+
+/// A simple class that logs the state of the simulation. The resulting text file can be used to diff between platforms and find issues in determinism.
+class DeterminismLog
+{
+private:
+	JPH_INLINE uint32		Convert(float inValue) const
+	{
+		return *(uint32 *)&inValue;
+	}
+
+	JPH_INLINE uint64		Convert(double inValue) const
+	{
+		return *(uint64 *)&inValue;
+	}
+
+public:
+							DeterminismLog()
+	{
+		mLog.open("detlog.txt", std::ios::out | std::ios::trunc | std::ios::binary); // Binary because we don't want a difference between Unix and Windows line endings.
+		mLog.fill('0');
+	}
+
+	DeterminismLog &		operator << (char inValue)
+	{
+		mLog << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (const char *inValue)
+	{
+		mLog << std::dec << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (const string &inValue)
+	{
+		mLog << std::dec << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (const BodyID &inValue)
+	{
+		mLog << std::hex << std::setw(8) << inValue.GetIndexAndSequenceNumber();
+		return *this;
+	}
+
+	DeterminismLog &		operator << (const SubShapeID &inValue)
+	{
+		mLog << std::hex << std::setw(8) << inValue.GetValue();
+		return *this;
+	}
+
+	DeterminismLog &		operator << (float inValue)
+	{
+		mLog << std::hex << std::setw(8) << Convert(inValue);
+		return *this;
+	}
+
+	DeterminismLog &		operator << (int inValue)
+	{
+		mLog << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (uint32 inValue)
+	{
+		mLog << std::hex << std::setw(8) << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (uint64 inValue)
+	{
+		mLog << std::hex << std::setw(16) << inValue;
+		return *this;
+	}
+
+	DeterminismLog &		operator << (Vec3Arg inValue)
+	{
+		mLog << std::hex << std::setw(8) << Convert(inValue.GetX()) << " " << std::setw(8) << Convert(inValue.GetY()) << " " << std::setw(8) << Convert(inValue.GetZ());
+		return *this;
+	}
+
+	DeterminismLog &		operator << (DVec3Arg inValue)
+	{
+		mLog << std::hex << std::setw(16) << Convert(inValue.GetX()) << " " << std::setw(16) << Convert(inValue.GetY()) << " " << std::setw(16) << Convert(inValue.GetZ());
+		return *this;
+	}
+
+	DeterminismLog &		operator << (Vec4Arg inValue)
+	{
+		mLog << std::hex << std::setw(8) << Convert(inValue.GetX()) << " " << std::setw(8) << Convert(inValue.GetY()) << " " << std::setw(8) << Convert(inValue.GetZ()) << " " << std::setw(8) << Convert(inValue.GetW());
+		return *this;
+	}
+
+	DeterminismLog &		operator << (const Float3 &inValue)
+	{
+		mLog << std::hex << std::setw(8) << Convert(inValue.x) << " " << std::setw(8) << Convert(inValue.y) << " " << std::setw(8) << Convert(inValue.z);
+		return *this;
+	}
+
+	DeterminismLog &		operator << (Mat44Arg inValue)
+	{
+		*this << inValue.GetColumn4(0) << " " << inValue.GetColumn4(1) << " " << inValue.GetColumn4(2) << " " << inValue.GetColumn4(3);
+		return *this;
+	}
+
+	DeterminismLog &		operator << (DMat44Arg inValue)
+	{
+		*this << inValue.GetColumn4(0) << " " << inValue.GetColumn4(1) << " " << inValue.GetColumn4(2) << " " << inValue.GetTranslation();
+		return *this;
+	}
+
+	DeterminismLog &		operator << (QuatArg inValue)
+	{
+		*this << inValue.GetXYZW();
+		return *this;
+	}
+
+	// Singleton instance
+	static DeterminismLog	sLog;
+
+private:
+	std::ofstream			mLog;
+};
+
+/// Will log something to the determinism log, usage: JPH_DET_LOG("label " << value);
+#define JPH_DET_LOG(...)	DeterminismLog::sLog << __VA_ARGS__ << '\n'
+
+JPH_NAMESPACE_END
+
+#else
+
+JPH_SUPPRESS_WARNING_PUSH
+JPH_SUPPRESS_WARNINGS
+
+/// By default we log nothing
+#define JPH_DET_LOG(...)
+
+JPH_SUPPRESS_WARNING_POP
+
+#endif // JPH_ENABLE_DETERMINISM_LOG

package/native/third_party/JoltPhysics/Jolt/Physics/EActivation.h

@@ -0,0 +1,16 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Enum used by AddBody to determine if the body needs to be initially active
+enum class EActivation
+{
+	Activate,				///< Activate the body, making it part of the simulation
+	DontActivate			///< Leave activation state as it is (will not deactivate an active body)
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/EPhysicsUpdateError.h

@@ -0,0 +1,37 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Enum used by PhysicsSystem to report error conditions during the PhysicsSystem::Update call. This is a bit field, multiple errors can trigger in the same update.
+enum class EPhysicsUpdateError : uint32
+{
+	None					= 0,			///< No errors
+	ManifoldCacheFull		= 1 << 0,		///< The manifold cache is full, this means that the total number of contacts between bodies is too high. Some contacts were ignored. Increase inMaxContactConstraints in PhysicsSystem::Init.
+	BodyPairCacheFull		= 1 << 1,		///< The body pair cache is full, this means that too many bodies contacted. Some contacts were ignored. Increase inMaxBodyPairs in PhysicsSystem::Init.
+	ContactConstraintsFull	= 1 << 2,		///< The contact constraints buffer is full. Some contacts were ignored. Increase inMaxContactConstraints in PhysicsSystem::Init.
+};
+
+/// OR operator for EPhysicsUpdateError
+inline EPhysicsUpdateError operator | (EPhysicsUpdateError inA, EPhysicsUpdateError inB)
+{
+	return static_cast<EPhysicsUpdateError>(static_cast<uint32>(inA) | static_cast<uint32>(inB));
+}
+
+/// OR operator for EPhysicsUpdateError
+inline EPhysicsUpdateError operator |= (EPhysicsUpdateError &ioA, EPhysicsUpdateError inB)
+{
+	ioA = ioA | inB;
+	return ioA;
+}
+
+/// AND operator for EPhysicsUpdateError
+inline EPhysicsUpdateError operator & (EPhysicsUpdateError inA, EPhysicsUpdateError inB)
+{
+	return static_cast<EPhysicsUpdateError>(static_cast<uint32>(inA) & static_cast<uint32>(inB));
+}
+
+JPH_NAMESPACE_END