@bloomengine/engine 0.3.1

package/native/third_party/JoltPhysics/Jolt/Physics/Body/Body.inl

@@ -0,0 +1,197 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+RMat44 Body::GetWorldTransform() const
+{
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read));
+
+	return RMat44::sRotationTranslation(mRotation, mPosition).PreTranslated(-mShape->GetCenterOfMass());
+}
+
+RMat44 Body::GetCenterOfMassTransform() const
+{
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read));
+
+	return RMat44::sRotationTranslation(mRotation, mPosition);
+}
+
+RMat44 Body::GetInverseCenterOfMassTransform() const
+{
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read));
+
+	return RMat44::sInverseRotationTranslation(mRotation, mPosition);
+}
+
+inline bool Body::sFindCollidingPairsCanCollide(const Body &inBody1, const Body &inBody2)
+{
+	// First body should never be a soft body
+	JPH_ASSERT(!inBody1.IsSoftBody());
+
+	// One of these conditions must be true
+	// - We always allow detecting collisions between kinematic and non-dynamic bodies
+	// - One of the bodies must be dynamic to collide
+	// - A kinematic object can collide with a sensor
+	if (!inBody1.GetCollideKinematicVsNonDynamic()
+		&& !inBody2.GetCollideKinematicVsNonDynamic()
+		&& (!inBody1.IsDynamic() && !inBody2.IsDynamic())
+		&& !(inBody1.IsKinematic() && inBody2.IsSensor())
+		&& !(inBody2.IsKinematic() && inBody1.IsSensor()))
+		return false;
+
+	// Check that body 1 is active
+	uint32 body1_index_in_active_bodies = inBody1.GetIndexInActiveBodiesInternal();
+	JPH_ASSERT(!inBody1.IsStatic() && body1_index_in_active_bodies != Body::cInactiveIndex, "This function assumes that Body 1 is active");
+
+	// If the pair A, B collides we need to ensure that the pair B, A does not collide or else we will handle the collision twice.
+	// If A is the same body as B we don't want to collide (1)
+	// If A is dynamic / kinematic and B is static we should collide (2)
+	// If A is dynamic / kinematic and B is dynamic / kinematic we should only collide if
+	//	- A is active and B is not active (3)
+	//	- A is active and B will become active during this simulation step (4)
+	//	- A is active and B is active, we require a condition that makes A, B collide and B, A not (5)
+	//
+	// In order to implement this we use the index in the active body list and make use of the fact that
+	// a body not in the active list has Body.Index = 0xffffffff which is the highest possible value for an uint32.
+	//
+	// Because we know that A is active we know that A.Index != 0xffffffff:
+	// (1) Because A.Index != 0xffffffff, if A.Index = B.Index then A = B, so to collide A.Index != B.Index
+	// (2) A.Index != 0xffffffff, B.Index = 0xffffffff (because it's static and cannot be in the active list), so to collide A.Index != B.Index
+	// (3) A.Index != 0xffffffff, B.Index = 0xffffffff (because it's not yet active), so to collide A.Index != B.Index
+	// (4) A.Index != 0xffffffff, B.Index = 0xffffffff currently. But it can activate during the Broad/NarrowPhase step at which point it
+	//     will be added to the end of the active list which will make B.Index > A.Index (this holds only true when we don't deactivate
+	//     bodies during the Broad/NarrowPhase step), so to collide A.Index < B.Index.
+	// (5) As tie breaker we can use the same condition A.Index < B.Index to collide, this means that if A, B collides then B, A won't
+	static_assert(Body::cInactiveIndex == 0xffffffff, "The algorithm below uses this value");
+	if (!inBody2.IsSoftBody() && body1_index_in_active_bodies >= inBody2.GetIndexInActiveBodiesInternal())
+		return false;
+	JPH_ASSERT(inBody1.GetID() != inBody2.GetID(), "Read the comment above, A and B are the same body which should not be possible!");
+
+	// Check collision group filter
+	if (!inBody1.GetCollisionGroup().CanCollide(inBody2.GetCollisionGroup()))
+		return false;
+
+	return true;
+}
+
+void Body::AddRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime)
+{
+	JPH_ASSERT(IsRigidBody());
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::ReadWrite));
+
+	// This used to use the equation: d/dt R(t) = 1/2 * w(t) * R(t) so that R(t + dt) = R(t) + 1/2 * w(t) * R(t) * dt
+	// See: Appendix B of An Introduction to Physically Based Modeling: Rigid Body Simulation II-Nonpenetration Constraints
+	// URL: https://www.cs.cmu.edu/~baraff/sigcourse/notesd2.pdf
+	// But this is a first order approximation and does not work well for kinematic ragdolls that are driven to a new
+	// pose if the poses differ enough. So now we split w(t) * dt into an axis and angle part and create a quaternion with it.
+	// Note that the resulting quaternion is normalized since otherwise numerical drift will eventually make the rotation non-normalized.
+	float len = inAngularVelocityTimesDeltaTime.Length();
+	if (len > 1.0e-6f)
+	{
+		mRotation = (Quat::sRotation(inAngularVelocityTimesDeltaTime / len, len) * mRotation).Normalized();
+		JPH_ASSERT(!mRotation.IsNaN());
+	}
+}
+
+void Body::SubRotationStep(Vec3Arg inAngularVelocityTimesDeltaTime)
+{
+	JPH_ASSERT(IsRigidBody());
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::ReadWrite));
+
+	// See comment at Body::AddRotationStep
+	float len = inAngularVelocityTimesDeltaTime.Length();
+	if (len > 1.0e-6f)
+	{
+		mRotation = (Quat::sRotation(inAngularVelocityTimesDeltaTime / len, -len) * mRotation).Normalized();
+		JPH_ASSERT(!mRotation.IsNaN());
+	}
+}
+
+Vec3 Body::GetWorldSpaceSurfaceNormal(const SubShapeID &inSubShapeID, RVec3Arg inPosition) const
+{
+	RMat44 inv_com = GetInverseCenterOfMassTransform();
+	return inv_com.Multiply3x3Transposed(mShape->GetSurfaceNormal(inSubShapeID, Vec3(inv_com * inPosition))).Normalized();
+}
+
+Mat44 Body::GetInverseInertia() const
+{
+	JPH_ASSERT(IsDynamic());
+
+	return GetMotionProperties()->GetInverseInertiaForRotation(Mat44::sRotation(mRotation));
+}
+
+void Body::AddForce(Vec3Arg inForce, RVec3Arg inPosition)
+{
+	AddForce(inForce);
+	AddTorque(Vec3(inPosition - mPosition).Cross(inForce));
+}
+
+void Body::AddImpulse(Vec3Arg inImpulse)
+{
+	JPH_ASSERT(IsDynamic());
+
+	SetLinearVelocityClamped(mMotionProperties->GetLinearVelocity() + inImpulse * mMotionProperties->GetInverseMass());
+}
+
+void Body::AddImpulse(Vec3Arg inImpulse, RVec3Arg inPosition)
+{
+	JPH_ASSERT(IsDynamic());
+
+	SetLinearVelocityClamped(mMotionProperties->GetLinearVelocity() + inImpulse * mMotionProperties->GetInverseMass());
+
+	SetAngularVelocityClamped(mMotionProperties->GetAngularVelocity() + mMotionProperties->MultiplyWorldSpaceInverseInertiaByVector(mRotation, Vec3(inPosition - mPosition).Cross(inImpulse)));
+}
+
+void Body::AddAngularImpulse(Vec3Arg inAngularImpulse)
+{
+	JPH_ASSERT(IsDynamic());
+
+	SetAngularVelocityClamped(mMotionProperties->GetAngularVelocity() + mMotionProperties->MultiplyWorldSpaceInverseInertiaByVector(mRotation, inAngularImpulse));
+}
+
+void Body::GetSleepTestPoints(RVec3 *outPoints) const
+{
+	JPH_ASSERT(BodyAccess::sCheckRights(BodyAccess::sPositionAccess(), BodyAccess::EAccess::Read));
+
+	// Center of mass is the first position
+	outPoints[0] = mPosition;
+
+	// The second and third position are on the largest axis of the bounding box
+	Vec3 extent = mShape->GetLocalBounds().GetExtent();
+	int lowest_component = extent.GetLowestComponentIndex();
+	Mat44 rotation = Mat44::sRotation(mRotation);
+	switch (lowest_component)
+	{
+	case 0:
+		outPoints[1] = mPosition + extent.GetY() * rotation.GetColumn3(1);
+		outPoints[2] = mPosition + extent.GetZ() * rotation.GetColumn3(2);
+		break;
+
+	case 1:
+		outPoints[1] = mPosition + extent.GetX() * rotation.GetColumn3(0);
+		outPoints[2] = mPosition + extent.GetZ() * rotation.GetColumn3(2);
+		break;
+
+	case 2:
+		outPoints[1] = mPosition + extent.GetX() * rotation.GetColumn3(0);
+		outPoints[2] = mPosition + extent.GetY() * rotation.GetColumn3(1);
+		break;
+
+	default:
+		JPH_ASSERT(false);
+		break;
+	}
+}
+
+void Body::ResetSleepTimer()
+{
+	RVec3 points[3];
+	GetSleepTestPoints(points);
+	mMotionProperties->ResetSleepTestSpheres(points);
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Body/BodyAccess.h

@@ -0,0 +1,68 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#ifdef JPH_ENABLE_ASSERTS
+
+JPH_NAMESPACE_BEGIN
+
+class JPH_EXPORT BodyAccess
+{
+public:
+	/// Access rules, used to detect race conditions during simulation
+	enum class EAccess : uint8
+	{
+		None		= 0,
+		Read		= 1,
+		ReadWrite	= 3,
+	};
+
+	/// Grant a scope specific access rights on the current thread
+	class Grant
+	{
+	public:
+		inline							Grant(EAccess inVelocity, EAccess inPosition)
+		{
+			EAccess &velocity = sVelocityAccess();
+			EAccess &position = sPositionAccess();
+
+			JPH_ASSERT(velocity == EAccess::ReadWrite);
+			JPH_ASSERT(position == EAccess::ReadWrite);
+
+			velocity = inVelocity;
+			position = inPosition;
+		}
+
+		inline							~Grant()
+		{
+			sVelocityAccess() = EAccess::ReadWrite;
+			sPositionAccess() = EAccess::ReadWrite;
+		}
+	};
+
+	/// Check if we have permission
+	static inline bool					sCheckRights(EAccess inRights, EAccess inDesiredRights)
+	{
+		return (uint8(inRights) & uint8(inDesiredRights)) == uint8(inDesiredRights);
+	}
+
+	/// Access to read/write velocities
+	static inline EAccess &				sVelocityAccess()
+	{
+		static thread_local EAccess sAccess = BodyAccess::EAccess::ReadWrite;
+		return sAccess;
+	}
+
+	/// Access to read/write positions
+	static inline EAccess &				sPositionAccess()
+	{
+		static thread_local EAccess sAccess = BodyAccess::EAccess::ReadWrite;
+		return sAccess;
+	}
+};
+
+JPH_NAMESPACE_END
+
+#endif // JPH_ENABLE_ASSERTS

package/native/third_party/JoltPhysics/Jolt/Physics/Body/BodyActivationListener.h

@@ -0,0 +1,28 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+class BodyID;
+
+/// A listener class that receives events when a body activates or deactivates.
+/// It can be registered with the BodyManager (or PhysicsSystem).
+class BodyActivationListener
+{
+public:
+	/// Ensure virtual destructor
+	virtual					~BodyActivationListener() = default;
+
+	/// Called whenever a body activates, note this can be called from any thread so make sure your code is thread safe.
+	/// At the time of the callback the body inBodyID will be locked and no bodies can be written/activated/deactivated from the callback.
+	virtual void			OnBodyActivated(const BodyID &inBodyID, uint64 inBodyUserData) = 0;
+
+	/// Called whenever a body deactivates, note this can be called from any thread so make sure your code is thread safe.
+	/// At the time of the callback the body inBodyID will be locked and no bodies can be written/activated/deactivated from the callback.
+	virtual void			OnBodyDeactivated(const BodyID &inBodyID, uint64 inBodyUserData) = 0;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Body/BodyCreationSettings.cpp

@@ -0,0 +1,234 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(BodyCreationSettings)
+{
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mPosition)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mRotation)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mLinearVelocity)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mAngularVelocity)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mUserData)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mShape)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mCollisionGroup)
+	JPH_ADD_ENUM_ATTRIBUTE(BodyCreationSettings, mObjectLayer)
+	JPH_ADD_ENUM_ATTRIBUTE(BodyCreationSettings, mMotionType)
+	JPH_ADD_ENUM_ATTRIBUTE(BodyCreationSettings, mAllowedDOFs)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mAllowDynamicOrKinematic)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mIsSensor)
+	JPH_ADD_ATTRIBUTE_WITH_ALIAS(BodyCreationSettings, mCollideKinematicVsNonDynamic, "mSensorDetectsStatic") // This is the old name to keep backwards compatibility
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mUseManifoldReduction)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mApplyGyroscopicForce)
+	JPH_ADD_ENUM_ATTRIBUTE(BodyCreationSettings, mMotionQuality)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mEnhancedInternalEdgeRemoval)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mAllowSleeping)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mFriction)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mRestitution)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mLinearDamping)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mAngularDamping)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mMaxLinearVelocity)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mMaxAngularVelocity)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mGravityFactor)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mNumVelocityStepsOverride)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mNumPositionStepsOverride)
+	JPH_ADD_ENUM_ATTRIBUTE(BodyCreationSettings, mOverrideMassProperties)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mInertiaMultiplier)
+	JPH_ADD_ATTRIBUTE(BodyCreationSettings, mMassPropertiesOverride)
+}
+
+void BodyCreationSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mPosition);
+	inStream.Write(mRotation);
+	inStream.Write(mLinearVelocity);
+	inStream.Write(mAngularVelocity);
+	mCollisionGroup.SaveBinaryState(inStream);
+	inStream.Write(mObjectLayer);
+	inStream.Write(mMotionType);
+	inStream.Write(mAllowedDOFs);
+	inStream.Write(mAllowDynamicOrKinematic);
+	inStream.Write(mIsSensor);
+	inStream.Write(mCollideKinematicVsNonDynamic);
+	inStream.Write(mUseManifoldReduction);
+	inStream.Write(mApplyGyroscopicForce);
+	inStream.Write(mMotionQuality);
+	inStream.Write(mEnhancedInternalEdgeRemoval);
+	inStream.Write(mAllowSleeping);
+	inStream.Write(mFriction);
+	inStream.Write(mRestitution);
+	inStream.Write(mLinearDamping);
+	inStream.Write(mAngularDamping);
+	inStream.Write(mMaxLinearVelocity);
+	inStream.Write(mMaxAngularVelocity);
+	inStream.Write(mGravityFactor);
+	inStream.Write(mNumVelocityStepsOverride);
+	inStream.Write(mNumPositionStepsOverride);
+	inStream.Write(mOverrideMassProperties);
+	inStream.Write(mInertiaMultiplier);
+	mMassPropertiesOverride.SaveBinaryState(inStream);
+}
+
+void BodyCreationSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mPosition);
+	inStream.Read(mRotation);
+	inStream.Read(mLinearVelocity);
+	inStream.Read(mAngularVelocity);
+	mCollisionGroup.RestoreBinaryState(inStream);
+	inStream.Read(mObjectLayer);
+	inStream.Read(mMotionType);
+	inStream.Read(mAllowedDOFs);
+	inStream.Read(mAllowDynamicOrKinematic);
+	inStream.Read(mIsSensor);
+	inStream.Read(mCollideKinematicVsNonDynamic);
+	inStream.Read(mUseManifoldReduction);
+	inStream.Read(mApplyGyroscopicForce);
+	inStream.Read(mMotionQuality);
+	inStream.Read(mEnhancedInternalEdgeRemoval);
+	inStream.Read(mAllowSleeping);
+	inStream.Read(mFriction);
+	inStream.Read(mRestitution);
+	inStream.Read(mLinearDamping);
+	inStream.Read(mAngularDamping);
+	inStream.Read(mMaxLinearVelocity);
+	inStream.Read(mMaxAngularVelocity);
+	inStream.Read(mGravityFactor);
+	inStream.Read(mNumVelocityStepsOverride);
+	inStream.Read(mNumPositionStepsOverride);
+	inStream.Read(mOverrideMassProperties);
+	inStream.Read(mInertiaMultiplier);
+	mMassPropertiesOverride.RestoreBinaryState(inStream);
+}
+
+Shape::ShapeResult BodyCreationSettings::ConvertShapeSettings()
+{
+	// If we already have a shape, return it
+	if (mShapePtr != nullptr)
+	{
+		mShape = nullptr;
+
+		Shape::ShapeResult result;
+		result.Set(const_cast<Shape *>(mShapePtr.GetPtr()));
+		return result;
+	}
+
+	// Check if we have shape settings
+	if (mShape == nullptr)
+	{
+		Shape::ShapeResult result;
+		result.SetError("No shape present!");
+		return result;
+	}
+
+	// Create the shape
+	Shape::ShapeResult result = mShape->Create();
+	if (result.IsValid())
+		mShapePtr = result.Get();
+	mShape = nullptr;
+	return result;
+}
+
+const Shape *BodyCreationSettings::GetShape() const
+{
+	// If we already have a shape, return it
+	if (mShapePtr != nullptr)
+		return mShapePtr;
+
+	// Check if we have shape settings
+	if (mShape == nullptr)
+		return nullptr;
+
+	// Create the shape
+	Shape::ShapeResult result = mShape->Create();
+	if (result.IsValid())
+		return result.Get();
+
+	Trace("Error: %s", result.GetError().c_str());
+	JPH_ASSERT(false, "An error occurred during shape creation. Use ConvertShapeSettings() to convert the shape and get the error!");
+	return nullptr;
+}
+
+MassProperties BodyCreationSettings::GetMassProperties() const
+{
+	// Calculate mass properties
+	MassProperties mass_properties;
+	switch (mOverrideMassProperties)
+	{
+	case EOverrideMassProperties::CalculateMassAndInertia:
+		mass_properties = GetShape()->GetMassProperties();
+		mass_properties.mInertia *= mInertiaMultiplier;
+		mass_properties.mInertia(3, 3) = 1.0f;
+		break;
+	case EOverrideMassProperties::CalculateInertia:
+		mass_properties = GetShape()->GetMassProperties();
+		mass_properties.ScaleToMass(mMassPropertiesOverride.mMass);
+		mass_properties.mInertia *= mInertiaMultiplier;
+		mass_properties.mInertia(3, 3) = 1.0f;
+		break;
+	case EOverrideMassProperties::MassAndInertiaProvided:
+		mass_properties = mMassPropertiesOverride;
+		break;
+	}
+	return mass_properties;
+}
+
+void BodyCreationSettings::SaveWithChildren(StreamOut &inStream, ShapeToIDMap *ioShapeMap, MaterialToIDMap *ioMaterialMap, GroupFilterToIDMap *ioGroupFilterMap) const
+{
+	// Save creation settings
+	SaveBinaryState(inStream);
+
+	// Save shape
+	if (ioShapeMap != nullptr && ioMaterialMap != nullptr)
+		GetShape()->SaveWithChildren(inStream, *ioShapeMap, *ioMaterialMap);
+	else
+		inStream.Write(~uint32(0));
+
+	// Save group filter
+	StreamUtils::SaveObjectReference(inStream, mCollisionGroup.GetGroupFilter(), ioGroupFilterMap);
+}
+
+BodyCreationSettings::BCSResult BodyCreationSettings::sRestoreWithChildren(StreamIn &inStream, IDToShapeMap &ioShapeMap, IDToMaterialMap &ioMaterialMap, IDToGroupFilterMap &ioGroupFilterMap)
+{
+	BCSResult result;
+
+	// Read creation settings
+	BodyCreationSettings settings;
+	settings.RestoreBinaryState(inStream);
+	if (inStream.IsEOF() || inStream.IsFailed())
+	{
+		result.SetError("Error reading body creation settings");
+		return result;
+	}
+
+	// Read shape
+	Shape::ShapeResult shape_result = Shape::sRestoreWithChildren(inStream, ioShapeMap, ioMaterialMap);
+	if (shape_result.HasError())
+	{
+		result.SetError(shape_result.GetError());
+		return result;
+	}
+	settings.SetShape(shape_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/Body/BodyCreationSettings.h

@@ -0,0 +1,124 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Collision/Shape/Shape.h>
+#include <Jolt/Physics/Collision/ObjectLayer.h>
+#include <Jolt/Physics/Collision/CollisionGroup.h>
+#include <Jolt/Physics/Body/MotionType.h>
+#include <Jolt/Physics/Body/MotionQuality.h>
+#include <Jolt/Physics/Body/AllowedDOFs.h>
+#include <Jolt/ObjectStream/SerializableObject.h>
+#include <Jolt/Core/StreamUtils.h>
+
+JPH_NAMESPACE_BEGIN
+
+class StreamIn;
+class StreamOut;
+
+/// Enum used in BodyCreationSettings to indicate how mass and inertia should be calculated
+enum class EOverrideMassProperties : uint8
+{
+	CalculateMassAndInertia,			///< Tells the system to calculate the mass and inertia based on density
+	CalculateInertia,					///< Tells the system to take the mass from mMassPropertiesOverride and to calculate the inertia based on density of the shapes and to scale it to the provided mass
+	MassAndInertiaProvided				///< Tells the system to take the mass and inertia from mMassPropertiesOverride
+};
+
+/// Settings for constructing a rigid body
+class JPH_EXPORT BodyCreationSettings
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, BodyCreationSettings)
+
+public:
+	/// Constructor
+							BodyCreationSettings() = default;
+							BodyCreationSettings(const ShapeSettings *inShape, RVec3Arg inPosition, QuatArg inRotation, EMotionType inMotionType, ObjectLayer inObjectLayer) : mPosition(inPosition), mRotation(inRotation), mObjectLayer(inObjectLayer), mMotionType(inMotionType), mShape(inShape) { }
+							BodyCreationSettings(const Shape *inShape, RVec3Arg inPosition, QuatArg inRotation, EMotionType inMotionType, ObjectLayer inObjectLayer) : mPosition(inPosition), mRotation(inRotation), mObjectLayer(inObjectLayer), mMotionType(inMotionType), mShapePtr(inShape) { }
+
+	/// Access to the shape settings object. This contains serializable (non-runtime optimized) information about the Shape.
+	const ShapeSettings *	GetShapeSettings() const										{ return mShape; }
+	void					SetShapeSettings(const ShapeSettings *inShape)					{ mShape = inShape; mShapePtr = nullptr; }
+
+	/// Convert ShapeSettings object into a Shape object. This will free the ShapeSettings object and make the object ready for runtime. Serialization is no longer possible after this.
+	Shape::ShapeResult		ConvertShapeSettings();
+
+	/// Access to the run-time shape object. Will convert from ShapeSettings object if needed.
+	const Shape *			GetShape() const;
+	void					SetShape(const Shape *inShape)									{ mShapePtr = inShape; mShape = nullptr; }
+
+	/// Check if the mass properties of this body will be calculated (only relevant for kinematic or dynamic objects that need a MotionProperties object)
+	bool					HasMassProperties() const										{ return mAllowDynamicOrKinematic || mMotionType != EMotionType::Static; }
+
+	/// Calculate (or return when overridden) the mass and inertia for this body
+	MassProperties			GetMassProperties() const;
+
+	/// Saves the state of this object in binary form to inStream. Doesn't store the shape nor the group filter.
+	void					SaveBinaryState(StreamOut &inStream) const;
+
+	/// Restore the state of this object from inStream. Doesn't restore the shape nor the group filter.
+	void					RestoreBinaryState(StreamIn &inStream);
+
+	using GroupFilterToIDMap = StreamUtils::ObjectToIDMap<GroupFilter>;
+	using IDToGroupFilterMap = StreamUtils::IDToObjectMap<GroupFilter>;
+	using ShapeToIDMap = Shape::ShapeToIDMap;
+	using IDToShapeMap = Shape::IDToShapeMap;
+	using MaterialToIDMap = StreamUtils::ObjectToIDMap<PhysicsMaterial>;
+	using IDToMaterialMap = StreamUtils::IDToObjectMap<PhysicsMaterial>;
+
+	/// Save body creation settings, its shape, materials and group filter. Pass in an empty map in ioShapeMap / ioMaterialMap / ioGroupFilterMap or reuse the same map while saving multiple shapes to the same stream in order to avoid writing duplicates.
+	/// Pass nullptr to ioShapeMap and ioMaterial map to skip saving shapes
+	/// Pass nullptr to ioGroupFilterMap to skip saving group filters
+	void					SaveWithChildren(StreamOut &inStream, ShapeToIDMap *ioShapeMap, MaterialToIDMap *ioMaterialMap, GroupFilterToIDMap *ioGroupFilterMap) const;
+
+	using BCSResult = Result<BodyCreationSettings>;
+
+	/// Restore body creation settings, its shape, materials and group filter. Pass in an empty map in ioShapeMap / ioMaterialMap / ioGroupFilterMap or reuse the same map while reading multiple shapes from the same stream in order to restore duplicates.
+	static BCSResult		sRestoreWithChildren(StreamIn &inStream, IDToShapeMap &ioShapeMap, IDToMaterialMap &ioMaterialMap, IDToGroupFilterMap &ioGroupFilterMap);
+
+	RVec3					mPosition = RVec3::sZero();										///< Position of the body (not of the center of mass)
+	Quat					mRotation = Quat::sIdentity();									///< Rotation of the body
+	Vec3					mLinearVelocity = Vec3::sZero();								///< World space linear velocity of the center of mass (m/s)
+	Vec3					mAngularVelocity = Vec3::sZero();								///< World space angular velocity (rad/s)
+
+	/// 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)
+
+	///@name Simulation properties
+	EMotionType				mMotionType = EMotionType::Dynamic;								///< Motion type, determines if the object is static, dynamic or kinematic
+	EAllowedDOFs			mAllowedDOFs = EAllowedDOFs::All;								///< Which degrees of freedom this body has (can be used to limit simulation to 2D)
+	bool					mAllowDynamicOrKinematic = false;								///< When this body is created as static, this setting tells the system to create a MotionProperties object so that the object can be switched to kinematic or dynamic
+	bool					mIsSensor = false;												///< If this body is a sensor. A sensor will receive collision callbacks, but will not cause any collision responses and can be used as a trigger volume. See description at Body::SetIsSensor.
+	bool					mCollideKinematicVsNonDynamic = false;							///< If kinematic objects can generate contact points against other kinematic or static objects. See description at Body::SetCollideKinematicVsNonDynamic.
+	bool					mUseManifoldReduction = true;									///< If this body should use manifold reduction (see description at Body::SetUseManifoldReduction)
+	bool					mApplyGyroscopicForce = false;									///< Set to indicate that the gyroscopic force should be applied to this body (aka Dzhanibekov effect, see https://en.wikipedia.org/wiki/Tennis_racket_theorem)
+	EMotionQuality			mMotionQuality = EMotionQuality::Discrete;						///< Motion quality, or how well it detects collisions when it has a high velocity
+	bool					mEnhancedInternalEdgeRemoval = false;							///< Set to indicate that extra effort should be made to try to remove ghost contacts (collisions with internal edges of a mesh). This is more expensive but makes bodies move smoother over a mesh with convex edges.
+	bool					mAllowSleeping = true;											///< If this body can go to sleep or not
+	float					mFriction = 0.2f;												///< Friction of the body (dimensionless number, usually between 0 and 1, 0 = no friction, 1 = friction force equals force that presses the two bodies together). Note that bodies can have negative friction but the combined friction (see PhysicsSystem::SetCombineFriction) should never go below zero.
+	float					mRestitution = 0.0f;											///< Restitution of body (dimensionless number, usually between 0 and 1, 0 = completely inelastic collision response, 1 = completely elastic collision response). Note that bodies can have negative restitution but the combined restitution (see PhysicsSystem::SetCombineRestitution) should never go below zero.
+	float					mLinearDamping = 0.05f;											///< Linear damping: dv/dt = -c * v. c. Value should be zero or positive and is usually close to 0.
+	float					mAngularDamping = 0.05f;										///< Angular damping: dw/dt = -c * w. c. Value should be zero or positive and is usually close to 0.
+	float					mMaxLinearVelocity = 500.0f;									///< Maximum linear velocity that this body can reach (m/s)
+	float					mMaxAngularVelocity = 0.25f * JPH_PI * 60.0f;					///< Maximum angular velocity that this body can reach (rad/s)
+	float					mGravityFactor = 1.0f;											///< Value to multiply gravity with for this body
+	uint					mNumVelocityStepsOverride = 0;									///< Used only when this body is dynamic and colliding. Override for the number of solver velocity iterations to run, 0 means use the default in PhysicsSettings::mNumVelocitySteps. The number of iterations to use is the max of all contacts and constraints in the island.
+	uint					mNumPositionStepsOverride = 0;									///< Used only when this body is dynamic and colliding. Override for the number of solver position iterations to run, 0 means use the default in PhysicsSettings::mNumPositionSteps. The number of iterations to use is the max of all contacts and constraints in the island.
+
+	///@name Mass properties of the body (by default calculated by the shape)
+	EOverrideMassProperties	mOverrideMassProperties = EOverrideMassProperties::CalculateMassAndInertia; ///< Determines how mMassPropertiesOverride will be used
+	float					mInertiaMultiplier = 1.0f;										///< When calculating the inertia (not when it is provided) the calculated inertia will be multiplied by this value
+	MassProperties			mMassPropertiesOverride;										///< Contains replacement mass settings which override the automatically calculated values
+
+private:
+	/// Collision volume for the body
+	RefConst<ShapeSettings>	mShape;															///< Shape settings, can be serialized. Mutually exclusive with mShapePtr
+	RefConst<Shape>			mShapePtr;														///< Actual shape, cannot be serialized. Mutually exclusive with mShape
+};
+
+JPH_NAMESPACE_END