@bloomengine/engine 0.3.1

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

@@ -0,0 +1,104 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Core/Reference.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/SoftBody/SoftBodyCreationSettings.h>
+#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
+
+JPH_NAMESPACE_BEGIN
+
+class PhysicsSystem;
+
+/// Contains the creation settings of a set of bodies
+class JPH_EXPORT PhysicsScene : public RefTarget<PhysicsScene>
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, PhysicsScene)
+
+public:
+	/// Add a body to the scene
+	void									AddBody(const BodyCreationSettings &inBody);
+
+	/// Body constant to use to indicate that the constraint is attached to the fixed world
+	static constexpr uint32					cFixedToWorld = 0xffffffff;
+
+	/// Add a constraint to the scene
+	/// @param inConstraint Constraint settings
+	/// @param inBody1 Index in the bodies list of first body to attach constraint to
+	/// @param inBody2 Index in the bodies list of the second body to attach constraint to
+	void									AddConstraint(const TwoBodyConstraintSettings *inConstraint, uint32 inBody1, uint32 inBody2);
+
+	/// Add a soft body to the scene
+	void									AddSoftBody(const SoftBodyCreationSettings &inSoftBody);
+
+	/// Get number of bodies in this scene
+	size_t									GetNumBodies() const							{ return mBodies.size(); }
+
+	/// Access to the body settings for this scene
+	const Array<BodyCreationSettings> &		GetBodies() const								{ return mBodies; }
+	Array<BodyCreationSettings> &			GetBodies()										{ return mBodies; }
+
+	/// A constraint and how it is connected to the bodies in the scene
+	class ConnectedConstraint
+	{
+		JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, ConnectedConstraint)
+
+	public:
+											ConnectedConstraint() = default;
+											ConnectedConstraint(const TwoBodyConstraintSettings *inSettings, uint inBody1, uint inBody2) : mSettings(inSettings), mBody1(inBody1), mBody2(inBody2) { }
+
+		RefConst<TwoBodyConstraintSettings>	mSettings;										///< Constraint settings
+		uint32								mBody1;											///< Index of first body (in mBodies)
+		uint32								mBody2;											///< Index of second body (in mBodies)
+	};
+
+	/// Get number of constraints in this scene
+	size_t									GetNumConstraints() const						{ return mConstraints.size(); }
+
+	/// Access to the constraints for this scene
+	const Array<ConnectedConstraint> &		GetConstraints() const							{ return mConstraints; }
+	Array<ConnectedConstraint> &			GetConstraints()								{ return mConstraints; }
+
+	/// Get number of bodies in this scene
+	size_t									GetNumSoftBodies() const						{ return mSoftBodies.size(); }
+
+	/// Access to the soft body settings for this scene
+	const Array<SoftBodyCreationSettings> &	GetSoftBodies() const							{ return mSoftBodies; }
+	Array<SoftBodyCreationSettings> &		GetSoftBodies()									{ return mSoftBodies; }
+
+	/// Instantiate all bodies, returns false if not all bodies could be created
+	bool									CreateBodies(PhysicsSystem *inSystem) const;
+
+	/// Go through all body creation settings and fix shapes that are scaled incorrectly (note this will change the scene a bit).
+	/// @return False when not all scales could be fixed.
+	bool									FixInvalidScales();
+
+	/// Saves the state of this object in binary form to inStream.
+	/// @param inStream The stream to save the state to
+	/// @param inSaveShapes If the shapes should be saved as well (these could be shared between physics scenes, in which case the calling application may want to write custom code to restore them)
+	/// @param inSaveGroupFilter If the group filter should be saved as well (these could be shared)
+	void									SaveBinaryState(StreamOut &inStream, bool inSaveShapes, bool inSaveGroupFilter) const;
+
+	using PhysicsSceneResult = Result<Ref<PhysicsScene>>;
+
+	/// Restore a saved scene from inStream
+	static PhysicsSceneResult				sRestoreFromBinaryState(StreamIn &inStream);
+
+	/// For debugging purposes: Construct a scene from the current state of the physics system
+	void									FromPhysicsSystem(const PhysicsSystem *inSystem);
+
+private:
+	/// The bodies that are part of this scene
+	Array<BodyCreationSettings>				mBodies;
+
+	/// Constraints that are part of this scene
+	Array<ConnectedConstraint>				mConstraints;
+
+	/// Soft bodies that are part of this scene
+	Array<SoftBodyCreationSettings>			mSoftBodies;
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,125 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// If objects are closer than this distance, they are considered to be colliding (used for GJK) (unit: meter)
+constexpr float cDefaultCollisionTolerance = 1.0e-4f;
+
+/// A factor that determines the accuracy of the penetration depth calculation. If the change of the squared distance is less than tolerance * current_penetration_depth^2 the algorithm will terminate. (unit: dimensionless)
+constexpr float cDefaultPenetrationTolerance = 1.0e-4f; ///< Stop when there's less than 1% change
+
+/// How much padding to add around objects
+constexpr float cDefaultConvexRadius = 0.05f;
+
+/// Used by (Tapered)CapsuleShape to determine when supporting face is an edge rather than a point (unit: meter)
+static constexpr float cCapsuleProjectionSlop = 0.02f;
+
+/// Maximum amount of jobs to allow
+constexpr int cMaxPhysicsJobs = 2048;
+
+/// Maximum amount of barriers to allow
+constexpr int cMaxPhysicsBarriers = 8;
+
+struct PhysicsSettings
+{
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Size of body pairs array, corresponds to the maximum amount of potential body pairs that can be in flight at any time.
+	/// Setting this to a low value will use less memory but slow down simulation as threads may run out of narrow phase work.
+	int			mMaxInFlightBodyPairs = 16384;
+
+	/// How many PhysicsStepListeners to notify in 1 batch
+	int			mStepListenersBatchSize = 8;
+
+	/// How many step listener batches are needed before spawning another job (set to INT_MAX if no parallelism is desired)
+	int			mStepListenerBatchesPerJob = 1;
+
+	/// Baumgarte stabilization factor (how much of the position error to 'fix' in 1 update) (unit: dimensionless, 0 = nothing, 1 = 100%)
+	float		mBaumgarte = 0.2f;
+
+	/// Radius around objects inside which speculative contact points will be detected. Note that if this is too big
+	/// you will get ghost collisions as speculative contacts are based on the closest points during the collision detection
+	/// step which may not be the actual closest points by the time the two objects hit (unit: meters)
+	float		mSpeculativeContactDistance = 0.02f;
+
+	/// How much bodies are allowed to sink into each other (unit: meters)
+	float		mPenetrationSlop = 0.02f;
+
+	/// Fraction of its inner radius a body must move per step to enable casting for the LinearCast motion quality
+	float		mLinearCastThreshold = 0.75f;
+
+	/// Fraction of its inner radius a body may penetrate another body for the LinearCast motion quality
+	float		mLinearCastMaxPenetration = 0.25f;
+
+	/// Max distance to use to determine if two points are on the same plane for determining the contact manifold between two shape faces (unit: meter)
+	float		mManifoldTolerance = 1.0e-3f;
+
+	/// Maximum distance to correct in a single iteration when solving position constraints (unit: meters)
+	float		mMaxPenetrationDistance = 0.2f;
+
+	/// Maximum relative delta position for body pairs to be able to reuse collision results from last frame (units: meter^2)
+	float		mBodyPairCacheMaxDeltaPositionSq = Square(0.001f); ///< 1 mm
+
+	/// Maximum relative delta orientation for body pairs to be able to reuse collision results from last frame, stored as cos(max angle / 2)
+	float		mBodyPairCacheCosMaxDeltaRotationDiv2 = 0.99984769515639123915701155881391f; ///< cos(2 degrees / 2)
+
+	/// Maximum angle between normals that allows manifolds between different sub shapes of the same body pair to be combined
+	float		mContactNormalCosMaxDeltaRotation = 0.99619469809174553229501040247389f; ///< cos(5 degree)
+
+	/// Maximum allowed distance between old and new contact point to preserve contact forces for warm start (units: meter^2)
+	float		mContactPointPreserveLambdaMaxDistSq = Square(0.01f); ///< 1 cm
+
+	/// Number of solver velocity iterations to run
+	/// Note that this needs to be >= 2 in order for friction to work (friction is applied using the non-penetration impulse from the previous iteration)
+	uint		mNumVelocitySteps = 10;
+
+	/// Number of solver position iterations to run
+	uint		mNumPositionSteps = 2;
+
+	/// Minimal velocity needed before a collision can be elastic. If the relative velocity between colliding objects
+	/// in the direction of the contact normal is lower than this, the restitution will be zero regardless of the configured
+	/// value. This lets an object settle sooner. Must be a positive number. (unit: m)
+	float		mMinVelocityForRestitution = 1.0f;
+
+	/// Time before object is allowed to go to sleep (unit: seconds)
+	float		mTimeBeforeSleep = 0.5f;
+
+	/// To detect if an object is sleeping, we use 3 points:
+	/// - The center of mass.
+	/// - The centers of the faces of the bounding box that are furthest away from the center.
+	/// The movement of these points is tracked and if the velocity of all 3 points is lower than this value,
+	/// the object is allowed to go to sleep. Must be a positive number. (unit: m/s)
+	float		mPointVelocitySleepThreshold = 0.03f;
+
+	/// By default the simulation is deterministic, it is possible to turn this off by setting this setting to false. This will make the simulation run faster but it will no longer be deterministic.
+	bool		mDeterministicSimulation = true;
+
+	///@name These variables are mainly for debugging purposes, they allow turning on/off certain subsystems. You probably want to leave them alone.
+	///@{
+
+	/// Whether or not to use warm starting for constraints (initially applying previous frames impulses)
+	bool		mConstraintWarmStart = true;
+
+	/// Whether or not to use the body pair cache, which removes the need for narrow phase collision detection when orientation between two bodies didn't change
+	bool		mUseBodyPairContactCache = true;
+
+	/// Whether or not to reduce manifolds with similar contact normals into one contact manifold (see description at Body::SetUseManifoldReduction)
+	bool		mUseManifoldReduction = true;
+
+	/// If we split up large islands into smaller parallel batches of work (to improve performance)
+	bool		mUseLargeIslandSplitter = true;
+
+	/// If objects can go to sleep or not
+	bool		mAllowSleeping = true;
+
+	/// When false, we prevent collision against non-active (shared) edges. Mainly for debugging the algorithm.
+	bool		mCheckActiveEdges = true;
+
+	///@}
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,37 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+class PhysicsSystem;
+
+/// Context information for the step listener
+class JPH_EXPORT PhysicsStepListenerContext
+{
+public:
+	float					mDeltaTime;								///< Delta time of the current step
+	bool					mIsFirstStep;							///< True if this is the first step
+	bool					mIsLastStep;							///< True if this is the last step
+	PhysicsSystem *			mPhysicsSystem;							///< The physics system that is being stepped
+};
+
+/// A listener class that receives a callback before every physics simulation step
+class JPH_EXPORT PhysicsStepListener
+{
+public:
+	/// Ensure virtual destructor
+	virtual					~PhysicsStepListener() = default;
+
+	/// Called before every simulation step (received inCollisionSteps times for every PhysicsSystem::Update(...) call)
+	/// This is called while all body and constraint mutexes are locked. You can read/write bodies and constraints but not add/remove them.
+	/// Multiple listeners can be executed in parallel and it is the responsibility of the listener to avoid race conditions.
+	/// The best way to do this is to have each step listener operate on a subset of the bodies and constraints
+	/// and making sure that these bodies and constraints are not touched by any other step listener.
+	/// Note that this function is not called if there aren't any active bodies or when the physics system is updated with 0 delta time.
+	virtual void			OnStep(const PhysicsStepListenerContext &inContext) = 0;
+};
+
+JPH_NAMESPACE_END