@bloomengine/engine 0.4.0 → 0.4.2

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/ContactListener.h

@@ -1,143 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/Shape/SubShapeIDPair.h>
-#include <Jolt/Core/StaticArray.h>
-
-JPH_NAMESPACE_BEGIN
-
-class Body;
-class CollideShapeResult;
-
-/// Array of contact points
-using ContactPoints = StaticArray<Vec3, 64>;
-
-/// Manifold class, describes the contact surface between two bodies
-class ContactManifold
-{
-public:
-	/// Swaps shape 1 and 2
-	ContactManifold			SwapShapes() const					{ return { mBaseOffset, -mWorldSpaceNormal, mPenetrationDepth, mSubShapeID2, mSubShapeID1, mRelativeContactPointsOn2, mRelativeContactPointsOn1 }; }
-
-	/// Access to the world space contact positions
-	inline RVec3			GetWorldSpaceContactPointOn1(uint inIndex) const { return mBaseOffset + mRelativeContactPointsOn1[inIndex]; }
-	inline RVec3			GetWorldSpaceContactPointOn2(uint inIndex) const { return mBaseOffset + mRelativeContactPointsOn2[inIndex]; }
-
-	RVec3					mBaseOffset;						///< Offset to which all the contact points are relative
-	Vec3					mWorldSpaceNormal;					///< Normal for this manifold, direction along which to move body 2 out of collision along the shortest path
-	float					mPenetrationDepth;					///< Penetration depth (move shape 2 by this distance to resolve the collision). If this value is negative, this is a speculative contact point and may not actually result in a velocity change as during solving the bodies may not actually collide.
-	SubShapeID				mSubShapeID1;						///< Sub shapes that formed this manifold (note that when multiple manifolds are combined because they're coplanar, we lose some information here because we only keep track of one sub shape pair that we encounter, see description at Body::SetUseManifoldReduction)
-	SubShapeID				mSubShapeID2;
-	ContactPoints			mRelativeContactPointsOn1;			///< Contact points on the surface of shape 1 relative to mBaseOffset.
-	ContactPoints			mRelativeContactPointsOn2;			///< Contact points on the surface of shape 2 relative to mBaseOffset. If there's no penetration, this will be the same as mRelativeContactPointsOn1. If there is penetration they will be different.
-};
-
-/// When a contact point is added or persisted, the callback gets a chance to override certain properties of the contact constraint.
-/// 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 ContactSettings
-{
-public:
-	float					mCombinedFriction;					///< Combined friction for the body pair (see: PhysicsSystem::SetCombineFriction)
-	float					mCombinedRestitution;				///< Combined restitution for the body pair (see: PhysicsSystem::SetCombineRestitution)
-	float					mInvMassScale1 = 1.0f;				///< Scale factor for the inverse mass of body 1 (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					mInvInertiaScale1 = 1.0f;			///< Scale factor for the inverse inertia of body 1 (usually same as mInvMassScale1)
-	float					mInvMassScale2 = 1.0f;				///< Scale factor for the inverse mass of body 2 (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 body 2 (usually same as mInvMassScale2)
-	bool					mIsSensor;							///< If the contact should be treated as a sensor vs body contact (no collision response)
-	Vec3					mRelativeLinearSurfaceVelocity = Vec3::sZero(); ///< Relative linear surface velocity between the bodies (world space surface velocity of body 2 - world space surface velocity of body 1), can be used to create a conveyor belt effect
-	Vec3					mRelativeAngularSurfaceVelocity = Vec3::sZero(); ///< Relative angular surface velocity between the bodies (world space angular surface velocity of body 2 - world space angular surface velocity of body 1). Note that this angular velocity is relative to the center of mass of body 1, so if you want it relative to body 2's center of mass you need to add body 2 angular velocity x (body 1 world space center of mass - body 2 world space center of mass) to mRelativeLinearSurfaceVelocity.
-};
-
-/// Return value for the OnContactValidate callback. Determines if the contact is being processed or not.
-/// Results are ordered so that the strongest accept has the lowest number and the strongest reject the highest number (which allows for easy combining of results)
-enum class ValidateResult
-{
-	AcceptAllContactsForThisBodyPair,							///< Accept this and any further contact points for this body pair
-	AcceptContact,												///< Accept this contact only (and continue calling this callback for every contact manifold for the same body pair)
-	RejectContact,												///< Reject this contact only (but process any other contact manifolds for the same body pair)
-	RejectAllContactsForThisBodyPair							///< Rejects this and any further contact points for this body pair
-};
-
-/// A listener class that receives collision contact events. It can be registered through PhysicsSystem::SetContactListener.
-/// Only a single contact listener can be registered. A common pattern is to create a contact listener that casts Body::GetUserData
-/// to a game object and then forwards the call to a handler specific for that game object.
-/// Typically this is done on both objects involved in a collision event.
-///
-/// Note that contact listener callbacks are called from multiple threads at the same time when all bodies are locked, this means you cannot
-/// use PhysicsSystem::GetBodyInterface / PhysicsSystem::GetBodyLockInterface but must use PhysicsSystem::GetBodyInterfaceNoLock / PhysicsSystem::GetBodyLockInterfaceNoLock instead.
-/// If you use a locking interface, the simulation will deadlock. You're only allowed to read from the bodies and you can't change physics state.
-/// During OnContactRemoved you cannot access the bodies at all, see the comments at that function.
-///
-/// While a callback can come from multiple threads, all callbacks relating to a single body pair are serialized.
-/// For EMotionQuality::Discrete bodies, during every 'collision step' in a PhysicsSystem::Update, you will receive at most one OnContactAdded/Persisted/Removed call per body/sub shape pair.
-/// For EMotionQuality::LinearCast bodies, you may get an OnContactAdded followed by an OnContactPersisted for the same body/sub shape pair.
-/// This happens when a body collides both in the discrete and the continuous collision detection stage.
-class ContactListener
-{
-public:
-	/// Ensure virtual destructor
-	virtual					~ContactListener() = default;
-
-	/// Called after detecting a collision between a body pair, but before calling OnContactAdded and before adding the contact constraint.
-	/// If the function rejects the contact, the contact will not be processed by the simulation.
-	/// This is a rather expensive time to reject a contact point since a lot of the collision detection has happened already, make sure you
-	/// filter out the majority of undesired body pairs through the ObjectLayerPairFilter that is registered on the PhysicsSystem.
-	///
-	/// This function may not be called again the next update if a contact persists and no new contact pairs between sub shapes are found.
-	///
-	/// Note that this callback is called when all bodies are locked, so don't use any locking functions! See detailed class description of ContactListener.
-	///
-	/// Body 1 will have a motion type that is larger or equal than body 2's motion type (order from large to small: dynamic -> kinematic -> static). When motion types are equal, they are ordered by BodyID.
-	///
-	/// The collision result (inCollisionResult) is reported relative to inBaseOffset.
-	virtual ValidateResult	OnContactValidate([[maybe_unused]] const Body &inBody1, [[maybe_unused]] const Body &inBody2, [[maybe_unused]] RVec3Arg inBaseOffset, [[maybe_unused]] const CollideShapeResult &inCollisionResult) { return ValidateResult::AcceptAllContactsForThisBodyPair; }
-
-	/// Called whenever a new contact point is detected.
-	///
-	/// Note that this callback is called when all bodies are locked, so don't use any locking functions! See detailed class description of ContactListener.
-	///
-	/// Body 1 and 2 will be sorted such that body 1 ID < body 2 ID, so body 1 may not be dynamic.
-	///
-	/// Note that only active bodies will report contacts, as soon as a body goes to sleep the contacts between that body and all other
-	/// bodies will receive an OnContactRemoved callback, if this is the case then Body::IsActive() will return false during the callback.
-	///
-	/// When contacts are added, the constraint solver has not run yet, so the collision impulse is unknown at that point.
-	/// The velocities of inBody1 and inBody2 are the velocities before the contact has been resolved, so you can use this to
-	/// estimate the collision impulse to e.g. determine the volume of the impact sound to play (see: EstimateCollisionResponse).
-	virtual void			OnContactAdded([[maybe_unused]] const Body &inBody1, [[maybe_unused]] const Body &inBody2, [[maybe_unused]] const ContactManifold &inManifold, [[maybe_unused]] ContactSettings &ioSettings) { /* Do nothing */ }
-
-	/// Called whenever a contact is detected that was also detected last update.
-	///
-	/// Note that this callback is called when all bodies are locked, so don't use any locking functions! See detailed class description of ContactListener.
-	///
-	/// Body 1 and 2 will be sorted such that body 1 ID < body 2 ID, so body 1 may not be dynamic.
-	///
-	/// If the structure of the shape of a body changes between simulation steps (e.g. by adding/removing a child shape of a compound shape),
-	/// it is possible that the same sub shape ID used to identify the removed child shape is now reused for a different child shape. The physics
-	/// system cannot detect this, so may send a 'contact persisted' callback even though the contact is now on a different child shape. You can
-	/// detect this by keeping the old shape (before adding/removing a part) around until the next PhysicsSystem::Update (when the OnContactPersisted
-	/// callbacks are triggered) and resolving the sub shape ID against both the old and new shape to see if they still refer to the same child shape.
-	virtual void			OnContactPersisted([[maybe_unused]] const Body &inBody1, [[maybe_unused]] const Body &inBody2, [[maybe_unused]] const ContactManifold &inManifold, [[maybe_unused]] ContactSettings &ioSettings) { /* Do nothing */ }
-
-	/// Called whenever a contact was detected last update but is not detected anymore.
-	///
-	/// You cannot access the bodies at the time of this callback because:
-	/// - All bodies are locked at the time of this callback.
-	/// - Some properties of the bodies are being modified from another thread at the same time.
-	/// - The body may have been removed and destroyed (you'll receive an OnContactRemoved callback in the PhysicsSystem::Update after the body has been removed).
-	///
-	/// Cache what you need in the OnContactAdded and OnContactPersisted callbacks and store it in a separate structure to use during this callback.
-	/// Alternatively, you could just record that the contact was removed and process it after PhysicsSystem::Update.
-	///
-	/// Body 1 and 2 will be sorted such that body 1 ID < body 2 ID, so body 1 may not be dynamic.
-	///
-	/// The sub shape IDs were created in the previous simulation step, so if the structure of a shape changes (e.g. by adding/removing a child shape of a compound shape),
-	/// the sub shape ID may not be valid / may not point to the same sub shape anymore.
-	/// If you want to know if this is the last contact between the two bodies, use PhysicsSystem::WereBodiesInContact.
-	virtual void			OnContactRemoved([[maybe_unused]] const SubShapeIDPair &inSubShapePair) { /* Do nothing */ }
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/EstimateCollisionResponse.cpp

@@ -1,213 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Physics/Collision/EstimateCollisionResponse.h>
-#include <Jolt/Physics/Body/Body.h>
-
-JPH_NAMESPACE_BEGIN
-
-void EstimateCollisionResponse(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, CollisionEstimationResult &outResult, float inCombinedFriction, float inCombinedRestitution, float inMinVelocityForRestitution, uint inNumIterations)
-{
-	// Note this code is based on AxisConstraintPart, see that class for more comments on the math
-
-	ContactPoints::size_type num_points = inManifold.mRelativeContactPointsOn1.size();
-	JPH_ASSERT(num_points == inManifold.mRelativeContactPointsOn2.size());
-
-	// Start with zero impulses
-	outResult.mImpulses.resize(num_points);
-	memset(outResult.mImpulses.data(), 0, num_points * sizeof(CollisionEstimationResult::Impulse));
-
-	// Calculate friction directions
-	outResult.mTangent1 = inManifold.mWorldSpaceNormal.GetNormalizedPerpendicular();
-	outResult.mTangent2 = inManifold.mWorldSpaceNormal.Cross(outResult.mTangent1);
-
-	// Get body velocities
-	EMotionType motion_type1 = inBody1.GetMotionType();
-	const MotionProperties *motion_properties1 = inBody1.GetMotionPropertiesUnchecked();
-	if (motion_type1 != EMotionType::Static)
-	{
-		outResult.mLinearVelocity1 = motion_properties1->GetLinearVelocity();
-		outResult.mAngularVelocity1 = motion_properties1->GetAngularVelocity();
-	}
-	else
-		outResult.mLinearVelocity1 = outResult.mAngularVelocity1 = Vec3::sZero();
-
-	EMotionType motion_type2 = inBody2.GetMotionType();
-	const MotionProperties *motion_properties2 = inBody2.GetMotionPropertiesUnchecked();
-	if (motion_type2 != EMotionType::Static)
-	{
-		outResult.mLinearVelocity2 = motion_properties2->GetLinearVelocity();
-		outResult.mAngularVelocity2 = motion_properties2->GetAngularVelocity();
-	}
-	else
-		outResult.mLinearVelocity2 = outResult.mAngularVelocity2 = Vec3::sZero();
-
-	// Get inverse mass and inertia
-	float inv_m1, inv_m2;
-	Mat44 inv_i1, inv_i2;
-	if (motion_type1 == EMotionType::Dynamic)
-	{
-		inv_m1 = motion_properties1->GetInverseMass();
-		inv_i1 = inBody1.GetInverseInertia();
-	}
-	else
-	{
-		inv_m1 = 0.0f;
-		inv_i1 = Mat44::sZero();
-	}
-
-	if (motion_type2 == EMotionType::Dynamic)
-	{
-		inv_m2 = motion_properties2->GetInverseMass();
-		inv_i2 = inBody2.GetInverseInertia();
-	}
-	else
-	{
-		inv_m2 = 0.0f;
-		inv_i2 = Mat44::sZero();
-	}
-
-	// Get center of masses relative to the base offset
-	Vec3 com1 = Vec3(inBody1.GetCenterOfMassPosition() - inManifold.mBaseOffset);
-	Vec3 com2 = Vec3(inBody2.GetCenterOfMassPosition() - inManifold.mBaseOffset);
-
-	struct AxisConstraint
-	{
-		inline void		Initialize(Vec3Arg inR1, Vec3Arg inR2, Vec3Arg inWorldSpaceNormal, float inInvM1, float inInvM2, Mat44Arg inInvI1, Mat44Arg inInvI2)
-		{
-			// Calculate effective mass: K^-1 = (J M^-1 J^T)^-1
-			mR1PlusUxAxis = inR1.Cross(inWorldSpaceNormal);
-			mR2xAxis = inR2.Cross(inWorldSpaceNormal);
-			mInvI1_R1PlusUxAxis = inInvI1.Multiply3x3(mR1PlusUxAxis);
-			mInvI2_R2xAxis = inInvI2.Multiply3x3(mR2xAxis);
-			mEffectiveMass = 1.0f / (inInvM1 + mInvI1_R1PlusUxAxis.Dot(mR1PlusUxAxis) + inInvM2 + mInvI2_R2xAxis.Dot(mR2xAxis));
-			mBias = 0.0f;
-		}
-
-		inline float	SolveGetLambda(Vec3Arg inWorldSpaceNormal, const CollisionEstimationResult &inResult) const
-		{
-			// Calculate jacobian multiplied by linear/angular velocity
-			float jv = inWorldSpaceNormal.Dot(inResult.mLinearVelocity1 - inResult.mLinearVelocity2) + mR1PlusUxAxis.Dot(inResult.mAngularVelocity1) - mR2xAxis.Dot(inResult.mAngularVelocity2);
-
-			// Lagrange multiplier is:
-			//
-			// lambda = -K^-1 (J v + b)
-			return mEffectiveMass * (jv - mBias);
-		}
-
-		inline void		SolveApplyLambda(Vec3Arg inWorldSpaceNormal, float inInvM1, float inInvM2, float inLambda, CollisionEstimationResult &ioResult) const
-		{
-			// Apply impulse to body velocities
-			ioResult.mLinearVelocity1 -= (inLambda * inInvM1) * inWorldSpaceNormal;
-			ioResult.mAngularVelocity1 -= inLambda * mInvI1_R1PlusUxAxis;
-			ioResult.mLinearVelocity2 += (inLambda * inInvM2) * inWorldSpaceNormal;
-			ioResult.mAngularVelocity2 += inLambda * mInvI2_R2xAxis;
-		}
-
-		inline void		Solve(Vec3Arg inWorldSpaceNormal, float inInvM1, float inInvM2, float inMinLambda, float inMaxLambda, float &ioTotalLambda, CollisionEstimationResult &ioResult) const
-		{
-			// Calculate new total lambda
-			float total_lambda = ioTotalLambda + SolveGetLambda(inWorldSpaceNormal, ioResult);
-
-			// Clamp impulse
-			total_lambda = Clamp(total_lambda, inMinLambda, inMaxLambda);
-
-			SolveApplyLambda(inWorldSpaceNormal, inInvM1, inInvM2, total_lambda - ioTotalLambda, ioResult);
-
-			ioTotalLambda = total_lambda;
-		}
-
-		Vec3			mR1PlusUxAxis;
-		Vec3			mR2xAxis;
-		Vec3			mInvI1_R1PlusUxAxis;
-		Vec3			mInvI2_R2xAxis;
-		float			mEffectiveMass;
-		float			mBias;
-	};
-
-	struct Constraint
-	{
-		AxisConstraint	mContact;
-		AxisConstraint	mFriction1;
-		AxisConstraint	mFriction2;
-	};
-
-	// Initialize the constraint properties
-	Constraint constraints[ContactPoints::Capacity];
-	for (uint c = 0; c < num_points; ++c)
-	{
-		Constraint &constraint = constraints[c];
-
-		// Calculate contact points relative to body 1 and 2
-		Vec3 p = 0.5f * (inManifold.mRelativeContactPointsOn1[c] + inManifold.mRelativeContactPointsOn2[c]);
-		Vec3 r1 = p - com1;
-		Vec3 r2 = p - com2;
-
-		// Initialize contact constraint
-		constraint.mContact.Initialize(r1, r2, inManifold.mWorldSpaceNormal, inv_m1, inv_m2, inv_i1, inv_i2);
-
-		// Handle elastic collisions
-		if (inCombinedRestitution > 0.0f)
-		{
-			// Calculate velocity of contact point
-			Vec3 relative_velocity = outResult.mLinearVelocity2 + outResult.mAngularVelocity2.Cross(r2) - outResult.mLinearVelocity1 - outResult.mAngularVelocity1.Cross(r1);
-			float normal_velocity = relative_velocity.Dot(inManifold.mWorldSpaceNormal);
-
-			// If it is big enough, apply restitution
-			if (normal_velocity < -inMinVelocityForRestitution)
-				constraint.mContact.mBias = inCombinedRestitution * normal_velocity;
-		}
-
-		if (inCombinedFriction > 0.0f)
-		{
-			// Initialize friction constraints
-			constraint.mFriction1.Initialize(r1, r2, outResult.mTangent1, inv_m1, inv_m2, inv_i1, inv_i2);
-			constraint.mFriction2.Initialize(r1, r2, outResult.mTangent2, inv_m1, inv_m2, inv_i1, inv_i2);
-		}
-	}
-
-	// If there's only 1 contact point, we only need 1 iteration
-	int num_iterations = inCombinedFriction <= 0.0f && num_points == 1? 1 : inNumIterations;
-
-	// Solve iteratively
-	for (int iteration = 0; iteration < num_iterations; ++iteration)
-	{
-		// Solve friction constraints first
-		if (inCombinedFriction > 0.0f && iteration > 0) // For first iteration the contact impulse is zero so there's no point in applying friction
-			for (uint c = 0; c < num_points; ++c)
-			{
-				const Constraint &constraint = constraints[c];
-				CollisionEstimationResult::Impulse &impulse = outResult.mImpulses[c];
-
-				float lambda1 = impulse.mFrictionImpulse1 + constraint.mFriction1.SolveGetLambda(outResult.mTangent1, outResult);
-				float lambda2 = impulse.mFrictionImpulse2 + constraint.mFriction2.SolveGetLambda(outResult.mTangent2, outResult);
-
-				// Calculate max impulse based on contact impulse
-				float max_impulse = inCombinedFriction * impulse.mContactImpulse;
-
-				// If the total lambda that we will apply is too large, scale it back
-				float total_lambda_sq = Square(lambda1) + Square(lambda2);
-				if (total_lambda_sq > Square(max_impulse))
-				{
-					float scale = max_impulse / sqrt(total_lambda_sq);
-					lambda1 *= scale;
-					lambda2 *= scale;
-				}
-
-				constraint.mFriction1.SolveApplyLambda(outResult.mTangent1, inv_m1, inv_m2, lambda1 - impulse.mFrictionImpulse1, outResult);
-				constraint.mFriction2.SolveApplyLambda(outResult.mTangent2, inv_m1, inv_m2, lambda2 - impulse.mFrictionImpulse2, outResult);
-
-				impulse.mFrictionImpulse1 = lambda1;
-				impulse.mFrictionImpulse2 = lambda2;
-			}
-
-		// Solve contact constraints last
-		for (uint c = 0; c < num_points; ++c)
-			constraints[c].mContact.Solve(inManifold.mWorldSpaceNormal, inv_m1, inv_m2, 0.0f, FLT_MAX, outResult.mImpulses[c].mContactImpulse, outResult);
-	}
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/EstimateCollisionResponse.h

@@ -1,48 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/ContactListener.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// A structure that contains the estimated contact and friction impulses and the resulting body velocities
-struct CollisionEstimationResult
-{
-	Vec3			mLinearVelocity1;				///< The estimated linear velocity of body 1 after collision
-	Vec3			mAngularVelocity1;				///< The estimated angular velocity of body 1 after collision
-	Vec3			mLinearVelocity2;				///< The estimated linear velocity of body 2 after collision
-	Vec3			mAngularVelocity2;				///< The estimated angular velocity of body 2 after collision
-
-	Vec3			mTangent1;						///< Normalized tangent of contact normal
-	Vec3			mTangent2;						///< Second normalized tangent of contact normal (forms a basis with mTangent1 and mWorldSpaceNormal)
-
-	struct Impulse
-	{
-		float		mContactImpulse;				///< Estimated contact impulses (kg m / s)
-		float		mFrictionImpulse1;				///< Estimated friction impulses in the direction of tangent 1 (kg m / s)
-		float		mFrictionImpulse2;				///< Estimated friction impulses in the direction of tangent 2 (kg m / s)
-	};
-
-	using Impulses = StaticArray<Impulse, ContactPoints::Capacity>;
-
-	Impulses		mImpulses;
-};
-
-/// This function estimates the contact impulses and body velocity changes as a result of a collision.
-/// It can be used in the ContactListener::OnContactAdded to determine the strength of the collision to e.g. play a sound or trigger a particle system.
-/// This function is accurate when two bodies collide but will not be accurate when more than 2 bodies collide at the same time as it does not know about these other collisions.
-///
-/// @param inBody1 Colliding body 1
-/// @param inBody2 Colliding body 2
-/// @param inManifold The collision manifold
-/// @param outResult A structure that contains the estimated contact and friction impulses and the resulting body velocities
-/// @param inCombinedFriction The combined friction of body 1 and body 2 (see ContactSettings::mCombinedFriction)
-/// @param inCombinedRestitution The combined restitution of body 1 and body 2 (see ContactSettings::mCombinedRestitution)
-/// @param inMinVelocityForRestitution Minimal velocity required for restitution to be applied (see PhysicsSettings::mMinVelocityForRestitution)
-/// @param inNumIterations Number of iterations to use for the impulse estimation (see PhysicsSettings::mNumVelocitySteps, note you can probably use a lower number for a decent estimate). If you set the number of iterations to 1 then no friction will be calculated.
-JPH_EXPORT void EstimateCollisionResponse(const Body &inBody1, const Body &inBody2, const ContactManifold &inManifold, CollisionEstimationResult &outResult, float inCombinedFriction, float inCombinedRestitution, float inMinVelocityForRestitution = 1.0f, uint inNumIterations = 10);
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/GroupFilter.cpp

@@ -1,32 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Physics/Collision/GroupFilter.h>
-#include <Jolt/Core/StreamUtils.h>
-
-JPH_NAMESPACE_BEGIN
-
-JPH_IMPLEMENT_SERIALIZABLE_ABSTRACT_BASE(GroupFilter)
-{
-	JPH_ADD_BASE_CLASS(GroupFilter, SerializableObject)
-}
-
-void GroupFilter::SaveBinaryState(StreamOut &inStream) const
-{
-	inStream.Write(GetRTTI()->GetHash());
-}
-
-void GroupFilter::RestoreBinaryState(StreamIn &inStream)
-{
-	// RTTI hash is read in sRestoreFromBinaryState
-}
-
-GroupFilter::GroupFilterResult GroupFilter::sRestoreFromBinaryState(StreamIn &inStream)
-{
-	return StreamUtils::RestoreObject<GroupFilter>(inStream, &GroupFilter::RestoreBinaryState);
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/GroupFilter.h

@@ -1,46 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Core/Result.h>
-#include <Jolt/ObjectStream/SerializableObject.h>
-
-JPH_NAMESPACE_BEGIN
-
-class CollisionGroup;
-class StreamIn;
-class StreamOut;
-
-/// Abstract class that checks if two CollisionGroups collide
-class JPH_EXPORT GroupFilter : public SerializableObject, public RefTarget<GroupFilter>
-{
-	JPH_DECLARE_SERIALIZABLE_ABSTRACT(JPH_EXPORT, GroupFilter)
-
-public:
-	/// Virtual destructor
-	virtual						~GroupFilter() override = default;
-
-	/// Check if two groups collide
-	virtual bool				CanCollide(const CollisionGroup &inGroup1, const CollisionGroup &inGroup2) const = 0;
-
-	/// Saves the contents of the group filter in binary form to inStream.
-	virtual void				SaveBinaryState(StreamOut &inStream) const;
-
-	using GroupFilterResult = Result<Ref<GroupFilter>>;
-
-	/// Creates a GroupFilter of the correct type and restores its contents from the binary stream inStream.
-	static GroupFilterResult	sRestoreFromBinaryState(StreamIn &inStream);
-
-protected:
-	/// Don't allow (copy) constructing this base class, but allow derived classes to (copy) construct themselves
-								GroupFilter() = default;
-								GroupFilter(const GroupFilter &) = default;
-	GroupFilter &				operator = (const GroupFilter &) = default;
-
-	/// This function should not be called directly, it is used by sRestoreFromBinaryState.
-	virtual void				RestoreBinaryState(StreamIn &inStream);
-};
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/GroupFilterTable.cpp

@@ -1,38 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#include <Jolt/Jolt.h>
-
-#include <Jolt/Physics/Collision/GroupFilterTable.h>
-#include <Jolt/ObjectStream/TypeDeclarations.h>
-#include <Jolt/Core/StreamIn.h>
-#include <Jolt/Core/StreamOut.h>
-
-JPH_NAMESPACE_BEGIN
-
-JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(GroupFilterTable)
-{
-	JPH_ADD_BASE_CLASS(GroupFilterTable, GroupFilter)
-
-	JPH_ADD_ATTRIBUTE(GroupFilterTable, mNumSubGroups)
-	JPH_ADD_ATTRIBUTE(GroupFilterTable, mTable)
-}
-
-void GroupFilterTable::SaveBinaryState(StreamOut &inStream) const
-{
-	GroupFilter::SaveBinaryState(inStream);
-
-	inStream.Write(mNumSubGroups);
-	inStream.Write(mTable);
-}
-
-void GroupFilterTable::RestoreBinaryState(StreamIn &inStream)
-{
-	GroupFilter::RestoreBinaryState(inStream);
-
-	inStream.Read(mNumSubGroups);
-	inStream.Read(mTable);
-}
-
-JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Collision/GroupFilterTable.h

@@ -1,130 +0,0 @@
-// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
-// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
-// SPDX-License-Identifier: MIT
-
-#pragma once
-
-#include <Jolt/Physics/Collision/GroupFilter.h>
-#include <Jolt/Physics/Collision/CollisionGroup.h>
-
-JPH_NAMESPACE_BEGIN
-
-/// Implementation of GroupFilter that stores a bit table with one bit per sub shape ID pair to determine if they collide or not
-///
-/// The collision rules:
-/// - If one of the objects is in the cInvalidGroup the objects will collide.
-/// - If the objects are in different groups they will collide.
-/// - If they're in the same group but their collision filter is different they will not collide.
-/// - If they're in the same group and their collision filters match, we'll use the SubGroupID and the table below.
-///
-/// For N = 6 sub groups the table will look like:
-///
-///		            sub group 1 --->
-///		sub group 2 x.....
-///		     |      ox....
-///		     |      oox...
-///		     V      ooox..
-///		            oooox.
-///		            ooooox
-///
-/// * 'x' means sub group 1 == sub group 2 and we define this to never collide.
-/// * 'o' is a bit that we have to store that defines if the sub groups collide or not.
-/// * '.' is a bit we don't need to store because the table is symmetric, we take care that group 2 > group 1 by swapping sub group 1 and sub group 2 if needed.
-///
-/// The total number of bits we need to store is (N * (N - 1)) / 2
-class JPH_EXPORT GroupFilterTable final : public GroupFilter
-{
-	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, GroupFilterTable)
-
-private:
-	using GroupID = CollisionGroup::GroupID;
-	using SubGroupID = CollisionGroup::SubGroupID;
-
-	/// Get which bit corresponds to the pair (inSubGroup1, inSubGroup2)
-	int						GetBit(SubGroupID inSubGroup1, SubGroupID inSubGroup2) const
-	{
-		JPH_ASSERT(inSubGroup1 != inSubGroup2);
-
-		// We store the lower left half only, so swap the inputs when trying to access the top right half
-		if (inSubGroup1 > inSubGroup2)
-			std::swap(inSubGroup1, inSubGroup2);
-
-		JPH_ASSERT(inSubGroup2 < mNumSubGroups);
-
-		// Calculate at which bit the entry for this pair resides
-		// We use the fact that a row always starts at inSubGroup2 * (inSubGroup2 - 1) / 2
-		// (this is the amount of bits needed to store a table of inSubGroup2 entries)
-		return (inSubGroup2 * (inSubGroup2 - 1)) / 2 + inSubGroup1;
-	}
-
-public:
-	/// Constructs the table with inNumSubGroups subgroups, initially all collision pairs are enabled except when the sub group ID is the same
-	explicit				GroupFilterTable(uint inNumSubGroups = 0) :
-		mNumSubGroups(inNumSubGroups)
-	{
-		// By default everything collides
-		int table_size = ((inNumSubGroups * (inNumSubGroups - 1)) / 2 + 7) / 8;
-		mTable.resize(table_size, 0xff);
-	}
-
-	/// Copy constructor
-							GroupFilterTable(const GroupFilterTable &inRHS) : mNumSubGroups(inRHS.mNumSubGroups), mTable(inRHS.mTable) { }
-
-	/// Disable collision between two sub groups
-	void					DisableCollision(SubGroupID inSubGroup1, SubGroupID inSubGroup2)
-	{
-		int bit = GetBit(inSubGroup1, inSubGroup2);
-		mTable[bit >> 3] &= (0xff ^ (1 << (bit & 0b111)));
-	}
-
-	/// Enable collision between two sub groups
-	void					EnableCollision(SubGroupID inSubGroup1, SubGroupID inSubGroup2)
-	{
-		int bit = GetBit(inSubGroup1, inSubGroup2);
-		mTable[bit >> 3] |= 1 << (bit & 0b111);
-	}
-
-	/// Check if the collision between two subgroups is enabled
-	inline bool				IsCollisionEnabled(SubGroupID inSubGroup1, SubGroupID inSubGroup2) const
-	{
-		// Test if the bit is set for this group pair
-		int bit = GetBit(inSubGroup1, inSubGroup2);
-		return (mTable[bit >> 3] & (1 << (bit & 0b111))) != 0;
-	}
-
-	/// Checks if two CollisionGroups collide
-	virtual bool			CanCollide(const CollisionGroup &inGroup1, const CollisionGroup &inGroup2) const override
-	{
-		// If one of the groups is cInvalidGroup the objects will collide (note that the if following this if will ensure that group2 is not cInvalidGroup)
-		if (inGroup1.GetGroupID() == CollisionGroup::cInvalidGroup)
-			return true;
-
-		// If the objects are in different groups, they collide
-		if (inGroup1.GetGroupID() != inGroup2.GetGroupID())
-			return true;
-
-		// If the collision filters do not match, but they're in the same group we ignore the collision
-		if (inGroup1.GetGroupFilter() != inGroup2.GetGroupFilter())
-			return false;
-
-		// If they are in the same sub group, they don't collide
-		if (inGroup1.GetSubGroupID() == inGroup2.GetSubGroupID())
-			return false;
-
-		// Check the bit table
-		return IsCollisionEnabled(inGroup1.GetSubGroupID(), inGroup2.GetSubGroupID());
-	}
-
-	// See: GroupFilter::SaveBinaryState
-	virtual void			SaveBinaryState(StreamOut &inStream) const override;
-
-protected:
-	// See: GroupFilter::RestoreBinaryState
-	virtual void			RestoreBinaryState(StreamIn &inStream) override;
-
-private:
-	uint					mNumSubGroups;									///< The number of subgroups that this group filter supports
-	Array<uint8>			mTable;											///< The table of bits that indicates which pairs collide
-};
-
-JPH_NAMESPACE_END