@bloomengine/engine 0.3.1

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

@@ -0,0 +1,245 @@
+// 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/Core/Result.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/Constraints/TwoBodyConstraint.h>
+#include <Jolt/Skeleton/Skeleton.h>
+#include <Jolt/Skeleton/SkeletonPose.h>
+#include <Jolt/Physics/EActivation.h>
+
+JPH_NAMESPACE_BEGIN
+
+class Ragdoll;
+class PhysicsSystem;
+
+/// Contains the structure of a ragdoll
+class JPH_EXPORT RagdollSettings : public RefTarget<RagdollSettings>
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, RagdollSettings)
+
+public:
+	/// Stabilize the constraints of the ragdoll
+	/// @return True on success, false on failure.
+	bool								Stabilize();
+
+	/// Initializes the constraint priorities so that constraints near the leaves of the ragdoll have a lower priority
+	/// than constraints near the root of the ragdoll.
+	/// @param inBasePriority The lowest priority that will be used in the ragdoll.
+	void								CalculateConstraintPriorities(uint32 inBasePriority = 0);
+
+	/// After the ragdoll has been fully configured, call this function to automatically create and add a GroupFilterTable collision filter to all bodies
+	/// and configure them so that parent and children don't collide.
+	///
+	/// This will:
+	/// - Create a GroupFilterTable and assign it to all of the bodies in a ragdoll.
+	/// - Each body in your ragdoll will get a SubGroupID that is equal to the joint index in the Skeleton that it is attached to.
+	/// - Loop over all joints in the Skeleton and call GroupFilterTable::DisableCollision(joint index, parent joint index).
+	/// - When a pose is provided through inJointMatrices the function will detect collisions between joints
+	/// (they must be separated by more than inMinSeparationDistance to be treated as not colliding) and automatically disable collisions.
+	///
+	/// When you create an instance using Ragdoll::CreateRagdoll pass in a unique GroupID for each ragdoll (e.g. a simple counter), note that this number
+	/// should be unique throughout the PhysicsSystem, so if you have different types of ragdolls they should not share the same GroupID.
+	void								DisableParentChildCollisions(const Mat44 *inJointMatrices = nullptr, float inMinSeparationDistance = 0.0f);
+
+	/// 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 ragdolls, 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 RagdollResult = Result<Ref<RagdollSettings>>;
+
+	/// Restore a saved ragdoll from inStream
+	static RagdollResult				sRestoreFromBinaryState(StreamIn &inStream);
+
+	/// Create ragdoll instance from these settings
+	/// @return Newly created ragdoll or null when out of bodies
+	Ragdoll *							CreateRagdoll(CollisionGroup::GroupID inCollisionGroup, uint64 inUserData, PhysicsSystem *inSystem) const;
+
+	/// Access to the skeleton of this ragdoll
+	const Skeleton *					GetSkeleton() const												{ return mSkeleton; }
+	Skeleton *							GetSkeleton()													{ return mSkeleton; }
+
+	/// Calculate the map needed for GetBodyIndexToConstraintIndex()
+	void								CalculateBodyIndexToConstraintIndex();
+
+	/// Get table that maps a body index to the constraint index with which it is connected to its parent. -1 if there is no constraint associated with the body.
+	/// Note that this will only tell you which constraint connects the body to its parent, it will not look in the additional constraint list.
+	const Array<int> &					GetBodyIndexToConstraintIndex() const							{ return mBodyIndexToConstraintIndex; }
+
+	/// Map a single body index to a constraint index
+	int									GetConstraintIndexForBodyIndex(int inBodyIndex) const			{ return mBodyIndexToConstraintIndex[inBodyIndex]; }
+
+	/// Calculate the map needed for GetConstraintIndexToBodyIdxPair()
+	void								CalculateConstraintIndexToBodyIdxPair();
+
+	using BodyIdxPair = std::pair<int, int>;
+
+	/// Table that maps a constraint index (index in mConstraints) to the indices of the bodies that the constraint is connected to (index in mBodyIDs)
+	const Array<BodyIdxPair> &			GetConstraintIndexToBodyIdxPair() const							{ return mConstraintIndexToBodyIdxPair; }
+
+	/// Map a single constraint index (index in mConstraints) to the indices of the bodies that the constraint is connected to (index in mBodyIDs)
+	BodyIdxPair							GetBodyIndicesForConstraintIndex(int inConstraintIndex) const	{ return mConstraintIndexToBodyIdxPair[inConstraintIndex]; }
+
+	/// A single rigid body sub part of the ragdoll
+	class Part : public BodyCreationSettings
+	{
+		JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Part)
+
+	public:
+		Ref<TwoBodyConstraintSettings>	mToParent;
+	};
+
+	/// List of ragdoll parts
+	using PartVector = Array<Part>;																	///< The constraint that connects this part to its parent part (should be null for the root)
+
+	/// A constraint that connects two bodies in a ragdoll (for non parent child related constraints)
+	class AdditionalConstraint
+	{
+		JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, AdditionalConstraint)
+
+	public:
+		/// Constructors
+										AdditionalConstraint() = default;
+										AdditionalConstraint(int inBodyIdx1, int inBodyIdx2, TwoBodyConstraintSettings *inConstraint) : mBodyIdx { inBodyIdx1, inBodyIdx2 }, mConstraint(inConstraint) { }
+
+		int								mBodyIdx[2];												///< Indices of the bodies that this constraint connects
+		Ref<TwoBodyConstraintSettings>	mConstraint;												///< The constraint that connects these bodies
+	};
+
+	/// List of additional constraints
+	using AdditionalConstraintVector = Array<AdditionalConstraint>;
+
+	/// The skeleton for this ragdoll
+	Ref<Skeleton>						mSkeleton;
+
+	/// For each of the joints, the body and constraint attaching it to its parent body (1-on-1 with mSkeleton.GetJoints())
+	PartVector							mParts;
+
+	/// A list of constraints that connects two bodies in a ragdoll (for non parent child related constraints)
+	AdditionalConstraintVector			mAdditionalConstraints;
+
+private:
+	/// Table that maps a body index (index in mBodyIDs) to the constraint index with which it is connected to its parent. -1 if there is no constraint associated with the body.
+	Array<int>							mBodyIndexToConstraintIndex;
+
+	/// Table that maps a constraint index (index in mConstraints) to the indices of the bodies that the constraint is connected to (index in mBodyIDs)
+	Array<BodyIdxPair>					mConstraintIndexToBodyIdxPair;
+};
+
+/// Runtime ragdoll information
+class JPH_EXPORT Ragdoll : public RefTarget<Ragdoll>, public NonCopyable
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	explicit							Ragdoll(PhysicsSystem *inSystem) : mSystem(inSystem) { }
+
+	/// Destructor
+										~Ragdoll();
+
+	/// Add bodies and constraints to the system and optionally activate the bodies
+	void								AddToPhysicsSystem(EActivation inActivationMode, bool inLockBodies = true);
+
+	/// Remove bodies and constraints from the system
+	void								RemoveFromPhysicsSystem(bool inLockBodies = true);
+
+	/// Wake up all bodies in the ragdoll
+	void								Activate(bool inLockBodies = true);
+
+	/// Check if one or more of the bodies in the ragdoll are active.
+	/// Note that this involves locking the bodies (if inLockBodies is true) and looping over them. An alternative and possibly faster
+	/// way could be to install a BodyActivationListener and count the number of active bodies of a ragdoll as they're activated / deactivated
+	/// (basically check if the body that activates / deactivates is in GetBodyIDs() and increment / decrement a counter).
+	bool								IsActive(bool inLockBodies = true) const;
+
+	/// Set the group ID on all bodies in the ragdoll
+	void								SetGroupID(CollisionGroup::GroupID inGroupID, bool inLockBodies = true);
+
+	/// Set the ragdoll to a pose (calls BodyInterface::SetPositionAndRotation to instantly move the ragdoll)
+	void								SetPose(const SkeletonPose &inPose, bool inLockBodies = true);
+
+	/// Lower level version of SetPose that directly takes the world space joint matrices
+	void								SetPose(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, bool inLockBodies = true);
+
+	/// Get the ragdoll pose (uses the world transform of the bodies to calculate the pose)
+	void								GetPose(SkeletonPose &outPose, bool inLockBodies = true);
+
+	/// Lower level version of GetPose that directly returns the world space joint matrices
+	void								GetPose(RVec3 &outRootOffset, Mat44 *outJointMatrices, bool inLockBodies = true);
+
+	/// This function calls ResetWarmStart on all constraints. It can be used after calling SetPose to reset previous frames impulses. See: Constraint::ResetWarmStart.
+	void								ResetWarmStart();
+
+	/// Drive the ragdoll to a specific pose by setting velocities on each of the bodies so that it will reach inPose in inDeltaTime
+	void								DriveToPoseUsingKinematics(const SkeletonPose &inPose, float inDeltaTime, bool inLockBodies = true);
+
+	/// Lower level version of DriveToPoseUsingKinematics that directly takes the world space joint matrices
+	void								DriveToPoseUsingKinematics(RVec3Arg inRootOffset, const Mat44 *inJointMatrices, float inDeltaTime, bool inLockBodies = true);
+
+	/// Drive the ragdoll to a specific pose by activating the motors on each constraint
+	void								DriveToPoseUsingMotors(const SkeletonPose &inPose);
+
+	/// Control the linear and velocity of all bodies in the ragdoll
+	void								SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies = true);
+
+	/// Set the world space linear velocity of all bodies in the ragdoll.
+	void								SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
+
+	/// Add a world space velocity (in m/s) to all bodies in the ragdoll.
+	void								AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
+
+	/// Add impulse to all bodies of the ragdoll (center of mass of each of them)
+	void								AddImpulse(Vec3Arg inImpulse, bool inLockBodies = true);
+
+	/// Get the position and orientation of the root of the ragdoll
+	void								GetRootTransform(RVec3 &outPosition, Quat &outRotation, bool inLockBodies = true) const;
+
+	/// Get number of bodies in the ragdoll
+	size_t								GetBodyCount() const									{ return mBodyIDs.size(); }
+
+	/// Access a body ID
+	BodyID								GetBodyID(int inBodyIndex) const						{ return mBodyIDs[inBodyIndex]; }
+
+	/// Access to the array of body IDs
+	const Array<BodyID> &				GetBodyIDs() const										{ return mBodyIDs; }
+
+	/// Get number of constraints in the ragdoll
+	size_t								GetConstraintCount() const								{ return mConstraints.size(); }
+
+	/// Access a constraint by index
+	TwoBodyConstraint *					GetConstraint(int inConstraintIndex)					{ return mConstraints[inConstraintIndex]; }
+
+	/// Access a constraint by index
+	const TwoBodyConstraint *			GetConstraint(int inConstraintIndex) const				{ return mConstraints[inConstraintIndex]; }
+
+	/// Get world space bounding box for all bodies of the ragdoll
+	AABox								GetWorldSpaceBounds(bool inLockBodies = true) const;
+
+	/// Get the settings object that created this ragdoll
+	const RagdollSettings *				GetRagdollSettings() const								{ return mRagdollSettings; }
+
+private:
+	/// For RagdollSettings::CreateRagdoll function
+	friend class RagdollSettings;
+
+	/// The settings that created this ragdoll
+	RefConst<RagdollSettings>			mRagdollSettings;
+
+	/// The bodies and constraints that this ragdoll consists of (1-on-1 with mRagdollSettings->mParts)
+	Array<BodyID>						mBodyIDs;
+
+	/// Array of constraints that connect the bodies together
+	Array<Ref<TwoBodyConstraint>>		mConstraints;
+
+	/// Cached physics system
+	PhysicsSystem *						mSystem;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/SoftBody/SoftBodyContactListener.h

@@ -0,0 +1,55 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+class Body;
+class SoftBodyManifold;
+
+/// Return value for the OnSoftBodyContactValidate callback. Determines if the contact will be processed or not.
+enum class SoftBodyValidateResult
+{
+	AcceptContact,														///< Accept this contact
+	RejectContact,														///< Reject this contact
+};
+
+/// Contact settings for a soft body contact.
+/// The values are filled in with their defaults by the system so the callback doesn't need to modify anything, but it can if it wants to.
+class SoftBodyContactSettings
+{
+public:
+	float							mInvMassScale1 = 1.0f;				///< Scale factor for the inverse mass of the soft body (0 = infinite mass, 1 = use original mass, 2 = body has half the mass). For the same contact pair, you should strive to keep the value the same over time.
+	float							mInvMassScale2 = 1.0f;				///< Scale factor for the inverse mass of the other body (0 = infinite mass, 1 = use original mass, 2 = body has half the mass). For the same contact pair, you should strive to keep the value the same over time.
+	float							mInvInertiaScale2 = 1.0f;			///< Scale factor for the inverse inertia of the other body (usually same as mInvMassScale2)
+	bool							mIsSensor;							///< If the contact should be treated as a sensor vs body contact (no collision response)
+};
+
+/// A listener class that receives collision contact events for soft bodies against rigid bodies.
+/// It can be registered with the PhysicsSystem.
+class SoftBodyContactListener
+{
+public:
+	/// Ensure virtual destructor
+	virtual							~SoftBodyContactListener() = default;
+
+	/// Called whenever the soft body's aabox overlaps with another body's aabox (so receiving this callback doesn't tell if any of the vertices will collide).
+	/// This callback can be used to change the behavior of the collision response for all vertices in the soft body or to completely reject the contact.
+	/// Note that this callback is called when all bodies are locked, so don't use any locking functions!
+	/// @param inSoftBody The soft body that collided. It is safe to access this as the soft body is only updated on the current thread.
+	/// @param inOtherBody The other body that collided. Note that accessing the position/orientation/velocity of inOtherBody may result in a race condition as other threads may be modifying the body at the same time.
+	/// @param ioSettings The settings for all contact points that are generated by this collision.
+	/// @return Whether the contact should be processed or not.
+	virtual SoftBodyValidateResult	OnSoftBodyContactValidate([[maybe_unused]] const Body &inSoftBody, [[maybe_unused]] const Body &inOtherBody, [[maybe_unused]] SoftBodyContactSettings &ioSettings) { return SoftBodyValidateResult::AcceptContact; }
+
+	/// Called after all contact points for a soft body have been handled.
+	/// Note that this callback is called when all bodies are locked, so don't use any locking functions!
+	/// You will receive a single callback for a soft body per simulation step for performance reasons, this callback will apply to all vertices in the soft body.
+	/// @param inSoftBody The soft body that collided. It is safe to access this as the soft body is only updated on the current thread.
+	/// @param inManifold The manifold that describes which vertices collide and with what body they collide. Other bodies may be modified by other threads during this callback.
+	virtual void					OnSoftBodyContactAdded([[maybe_unused]] const Body &inSoftBody, const SoftBodyManifold &inManifold) { /* Do nothing */ }
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/SoftBody/SoftBodyCreationSettings.cpp

@@ -0,0 +1,128 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/SoftBody/SoftBodyCreationSettings.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(SoftBodyCreationSettings)
+{
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mSettings)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mPosition)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mRotation)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mUserData)
+	JPH_ADD_ENUM_ATTRIBUTE(SoftBodyCreationSettings, mObjectLayer)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mCollisionGroup)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mNumIterations)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mLinearDamping)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mMaxLinearVelocity)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mRestitution)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mFriction)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mPressure)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mGravityFactor)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mVertexRadius)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mUpdatePosition)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mMakeRotationIdentity)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mAllowSleeping)
+	JPH_ADD_ATTRIBUTE(SoftBodyCreationSettings, mFacesDoubleSided)
+}
+
+void SoftBodyCreationSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mPosition);
+	inStream.Write(mRotation);
+	inStream.Write(mUserData);
+	inStream.Write(mObjectLayer);
+	mCollisionGroup.SaveBinaryState(inStream);
+	inStream.Write(mNumIterations);
+	inStream.Write(mLinearDamping);
+	inStream.Write(mMaxLinearVelocity);
+	inStream.Write(mRestitution);
+	inStream.Write(mFriction);
+	inStream.Write(mPressure);
+	inStream.Write(mGravityFactor);
+	inStream.Write(mVertexRadius);
+	inStream.Write(mUpdatePosition);
+	inStream.Write(mMakeRotationIdentity);
+	inStream.Write(mAllowSleeping);
+	inStream.Write(mFacesDoubleSided);
+}
+
+void SoftBodyCreationSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mPosition);
+	inStream.Read(mRotation);
+	inStream.Read(mUserData);
+	inStream.Read(mObjectLayer);
+	mCollisionGroup.RestoreBinaryState(inStream);
+	inStream.Read(mNumIterations);
+	inStream.Read(mLinearDamping);
+	inStream.Read(mMaxLinearVelocity);
+	inStream.Read(mRestitution);
+	inStream.Read(mFriction);
+	inStream.Read(mPressure);
+	inStream.Read(mGravityFactor);
+	inStream.Read(mVertexRadius);
+	inStream.Read(mUpdatePosition);
+	inStream.Read(mMakeRotationIdentity);
+	inStream.Read(mAllowSleeping);
+	inStream.Read(mFacesDoubleSided);
+}
+
+void SoftBodyCreationSettings::SaveWithChildren(StreamOut &inStream, SharedSettingsToIDMap *ioSharedSettingsMap, MaterialToIDMap *ioMaterialMap, GroupFilterToIDMap *ioGroupFilterMap) const
+{
+	// Save creation settings
+	SaveBinaryState(inStream);
+
+	// Save shared settings
+	if (ioSharedSettingsMap != nullptr && ioMaterialMap != nullptr)
+		mSettings->SaveWithMaterials(inStream, *ioSharedSettingsMap, *ioMaterialMap);
+	else
+		inStream.Write(~uint32(0));
+
+	// Save group filter
+	StreamUtils::SaveObjectReference(inStream, mCollisionGroup.GetGroupFilter(), ioGroupFilterMap);
+}
+
+SoftBodyCreationSettings::SBCSResult SoftBodyCreationSettings::sRestoreWithChildren(StreamIn &inStream, IDToSharedSettingsMap &ioSharedSettingsMap, IDToMaterialMap &ioMaterialMap, IDToGroupFilterMap &ioGroupFilterMap)
+{
+	SBCSResult result;
+
+	// Read creation settings
+	SoftBodyCreationSettings settings;
+	settings.RestoreBinaryState(inStream);
+	if (inStream.IsEOF() || inStream.IsFailed())
+	{
+		result.SetError("Error reading body creation settings");
+		return result;
+	}
+
+	// Read shared settings
+	SoftBodySharedSettings::SettingsResult settings_result = SoftBodySharedSettings::sRestoreWithMaterials(inStream, ioSharedSettingsMap, ioMaterialMap);
+	if (settings_result.HasError())
+	{
+		result.SetError(settings_result.GetError());
+		return result;
+	}
+	settings.mSettings = settings_result.Get();
+
+	// Read group filter
+	Result gfresult = StreamUtils::RestoreObjectReference(inStream, ioGroupFilterMap);
+	if (gfresult.HasError())
+	{
+		result.SetError(gfresult.GetError());
+		return result;
+	}
+	settings.mCollisionGroup.SetGroupFilter(gfresult.Get());
+
+	result.Set(settings);
+	return result;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/SoftBody/SoftBodyCreationSettings.h

@@ -0,0 +1,75 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/SoftBody/SoftBodySharedSettings.h>
+#include <Jolt/Physics/Collision/ObjectLayer.h>
+#include <Jolt/Physics/Collision/CollisionGroup.h>
+#include <Jolt/ObjectStream/SerializableObject.h>
+#include <Jolt/Core/StreamUtils.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// This class contains the information needed to create a soft body object
+/// Note: Soft bodies are still in development and come with several caveats. Read the Architecture and API documentation for more information!
+class JPH_EXPORT SoftBodyCreationSettings
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, SoftBodyCreationSettings)
+
+public:
+	/// Constructor
+						SoftBodyCreationSettings() = default;
+						SoftBodyCreationSettings(const SoftBodySharedSettings *inSettings, RVec3Arg inPosition, QuatArg inRotation, ObjectLayer inObjectLayer) : mSettings(inSettings), mPosition(inPosition), mRotation(inRotation), mObjectLayer(inObjectLayer) { }
+
+	/// Saves the state of this object in binary form to inStream. Doesn't store the shared settings nor the group filter.
+	void				SaveBinaryState(StreamOut &inStream) const;
+
+	/// Restore the state of this object from inStream. Doesn't restore the shared settings nor the group filter.
+	void				RestoreBinaryState(StreamIn &inStream);
+
+	using GroupFilterToIDMap = StreamUtils::ObjectToIDMap<GroupFilter>;
+	using IDToGroupFilterMap = StreamUtils::IDToObjectMap<GroupFilter>;
+	using SharedSettingsToIDMap = SoftBodySharedSettings::SharedSettingsToIDMap;
+	using IDToSharedSettingsMap = SoftBodySharedSettings::IDToSharedSettingsMap;
+	using MaterialToIDMap = StreamUtils::ObjectToIDMap<PhysicsMaterial>;
+	using IDToMaterialMap = StreamUtils::IDToObjectMap<PhysicsMaterial>;
+
+	/// Save this body creation settings, its shared settings and group filter. Pass in an empty map in ioSharedSettingsMap / ioMaterialMap / ioGroupFilterMap or reuse the same map while saving multiple shapes to the same stream in order to avoid writing duplicates.
+	/// Pass nullptr to ioSharedSettingsMap and ioMaterial map to skip saving shared settings and materials
+	/// Pass nullptr to ioGroupFilterMap to skip saving group filters
+	void				SaveWithChildren(StreamOut &inStream, SharedSettingsToIDMap *ioSharedSettingsMap, MaterialToIDMap *ioMaterialMap, GroupFilterToIDMap *ioGroupFilterMap) const;
+
+	using SBCSResult = Result<SoftBodyCreationSettings>;
+
+	/// Restore a shape, all its children and materials. Pass in an empty map in ioSharedSettingsMap / ioMaterialMap / ioGroupFilterMap or reuse the same map while reading multiple shapes from the same stream in order to restore duplicates.
+	static SBCSResult	sRestoreWithChildren(StreamIn &inStream, IDToSharedSettingsMap &ioSharedSettingsMap, IDToMaterialMap &ioMaterialMap, IDToGroupFilterMap &ioGroupFilterMap);
+
+	RefConst<SoftBodySharedSettings> mSettings;				///< Defines the configuration of this soft body
+
+	RVec3				mPosition { RVec3::sZero() };		///< Initial position of the soft body
+	Quat				mRotation { Quat::sIdentity() };	///< Initial rotation of the soft body
+
+	/// User data value (can be used by application)
+	uint64				mUserData = 0;
+
+	///@name Collision settings
+	ObjectLayer			mObjectLayer = 0;					///< The collision layer this body belongs to (determines if two objects can collide)
+	CollisionGroup		mCollisionGroup;					///< The collision group this body belongs to (determines if two objects can collide)
+
+	uint32				mNumIterations = 5;					///< Number of solver iterations
+	float				mLinearDamping = 0.1f;				///< Linear damping: dv/dt = -mLinearDamping * v. Value should be zero or positive and is usually close to 0.
+	float				mMaxLinearVelocity = 500.0f;		///< Maximum linear velocity that a vertex can reach (m/s)
+	float				mRestitution = 0.0f;				///< Restitution when colliding
+	float				mFriction = 0.2f;					///< Friction coefficient when colliding
+	float				mPressure = 0.0f;					///< n * R * T, amount of substance * ideal gas constant * absolute temperature, see https://en.wikipedia.org/wiki/Pressure
+	float				mGravityFactor = 1.0f;				///< Value to multiply gravity with for this body
+	float				mVertexRadius = 0.0f;				///< How big the particles are, can be used to push the vertices a little bit away from the surface of other bodies to prevent z-fighting
+	bool				mUpdatePosition = true;				///< Update the position of the body while simulating (set to false for something that is attached to the static world)
+	bool				mMakeRotationIdentity = true;		///< Bake specified mRotation in the vertices and set the body rotation to identity (simulation is slightly more accurate if the rotation of a soft body is kept to identity)
+	bool				mAllowSleeping = true;				///< If this body can go to sleep or not
+	bool				mFacesDoubleSided = false;			///< If the faces in this soft body should be treated as double sided for the purpose of collision detection (ray cast / collide shape / cast shape)
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/SoftBody/SoftBodyManifold.h

@@ -0,0 +1,74 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2024 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/SoftBody/SoftBodyMotionProperties.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// An interface to query which vertices of a soft body are colliding with other bodies
+class SoftBodyManifold
+{
+public:
+	/// Get the vertices of the soft body for iterating
+	const Array<SoftBodyVertex> &	GetVertices() const							{ return mVertices; }
+
+	/// Check if a vertex has collided with something in this update
+	JPH_INLINE bool					HasContact(const SoftBodyVertex &inVertex) const
+	{
+		return inVertex.mHasContact;
+	}
+
+	/// Get the local space contact point (multiply by GetCenterOfMassTransform() of the soft body to get world space)
+	JPH_INLINE Vec3					GetLocalContactPoint(const SoftBodyVertex &inVertex) const
+	{
+		return inVertex.mPosition - inVertex.mCollisionPlane.SignedDistance(inVertex.mPosition) * inVertex.mCollisionPlane.GetNormal();
+	}
+
+	/// Get the contact normal for the vertex (assumes there is a contact).
+	JPH_INLINE Vec3					GetContactNormal(const SoftBodyVertex &inVertex) const
+	{
+		return -inVertex.mCollisionPlane.GetNormal();
+	}
+
+	/// Get the body with which the vertex has collided in this update
+	JPH_INLINE BodyID				GetContactBodyID(const SoftBodyVertex &inVertex) const
+	{
+		return inVertex.mHasContact? mCollidingShapes[inVertex.mCollidingShapeIndex].mBodyID : BodyID();
+	}
+
+	/// Get the number of sensors that are in contact with the soft body
+	JPH_INLINE uint					GetNumSensorContacts() const
+	{
+		return (uint)mCollidingSensors.size();
+	}
+
+	/// Get the i-th sensor that is in contact with the soft body
+	JPH_INLINE BodyID				GetSensorContactBodyID(uint inIndex) const
+	{
+		return mCollidingSensors[inIndex].mBodyID;
+	}
+
+private:
+	/// Allow SoftBodyMotionProperties to construct us
+	friend class SoftBodyMotionProperties;
+
+	/// Constructor
+	explicit						SoftBodyManifold(const SoftBodyMotionProperties *inMotionProperties) :
+										mVertices(inMotionProperties->mVertices),
+										mCollidingShapes(inMotionProperties->mCollidingShapes),
+										mCollidingSensors(inMotionProperties->mCollidingSensors)
+	{
+	}
+
+	using CollidingShape = SoftBodyMotionProperties::CollidingShape;
+	using CollidingSensor = SoftBodyMotionProperties::CollidingSensor;
+
+	const Array<SoftBodyVertex> &	mVertices;
+	const Array<CollidingShape>	&	mCollidingShapes;
+	const Array<CollidingSensor> &	mCollidingSensors;
+};
+
+JPH_NAMESPACE_END