@bloomengine/engine 0.3.1

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

@@ -0,0 +1,31 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Motion quality, or how well it detects collisions when it has a high velocity
+enum class EMotionQuality : uint8
+{
+	/// Update the body in discrete steps. Body will tunnel through thin objects if its velocity is high enough.
+	/// This is the cheapest way of simulating a body.
+	Discrete,
+
+	/// Update the body using linear casting. When stepping the body, its collision shape is cast from
+	/// start to destination using the starting rotation. The body will not be able to tunnel through thin
+	/// objects at high velocity, but tunneling is still possible if the body is long and thin and has high
+	/// angular velocity. Time is stolen from the object (which means it will move up to the first collision
+	/// and will not bounce off the surface until the next integration step). This will make the body appear
+	/// to go slower when it collides with high velocity. In order to not get stuck, the body is always
+	/// allowed to move by a fraction of it's inner radius, which may eventually lead it to pass through geometry.
+	///
+	/// Note that if you're using a collision listener, you can receive contact added/persisted notifications of contacts
+	/// that may in the end not happen. This happens between bodies that are using casting: If bodies A and B collide at t1
+	/// and B and C collide at t2 where t2 < t1 and A and C don't collide. In this case you may receive an incorrect contact
+	/// point added callback between A and B (which will be removed the next frame).
+	LinearCast,
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,17 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+JPH_NAMESPACE_BEGIN
+
+/// Motion type of a physics body
+enum class EMotionType : uint8
+{
+	Static,						///< Non movable
+	Kinematic,					///< Movable using velocities only, does not respond to forces
+	Dynamic,					///< Responds to forces as a normal physics object
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,354 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Character/Character.h>
+#include <Jolt/Physics/Body/BodyCreationSettings.h>
+#include <Jolt/Physics/Body/BodyLock.h>
+#include <Jolt/Physics/Collision/CollideShape.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+static inline const BodyLockInterface &sCharacterGetBodyLockInterface(const PhysicsSystem *inSystem, bool inLockBodies)
+{
+	return inLockBodies? static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterface()) : static_cast<const BodyLockInterface &>(inSystem->GetBodyLockInterfaceNoLock());
+}
+
+static inline BodyInterface &sCharacterGetBodyInterface(PhysicsSystem *inSystem, bool inLockBodies)
+{
+	return inLockBodies? inSystem->GetBodyInterface() : inSystem->GetBodyInterfaceNoLock();
+}
+
+static inline const NarrowPhaseQuery &sCharacterGetNarrowPhaseQuery(const PhysicsSystem *inSystem, bool inLockBodies)
+{
+	return inLockBodies? inSystem->GetNarrowPhaseQuery() : inSystem->GetNarrowPhaseQueryNoLock();
+}
+
+Character::Character(const CharacterSettings *inSettings, RVec3Arg inPosition, QuatArg inRotation, uint64 inUserData, PhysicsSystem *inSystem) :
+	CharacterBase(inSettings, inSystem),
+	mLayer(inSettings->mLayer)
+{
+	// Construct rigid body
+	BodyCreationSettings settings(mShape, inPosition, inRotation, EMotionType::Dynamic, mLayer);
+	settings.mAllowedDOFs = inSettings->mAllowedDOFs;
+	settings.mEnhancedInternalEdgeRemoval = inSettings->mEnhancedInternalEdgeRemoval;
+	settings.mOverrideMassProperties = EOverrideMassProperties::MassAndInertiaProvided;
+	settings.mMassPropertiesOverride.mMass = inSettings->mMass;
+	settings.mFriction = inSettings->mFriction;
+	settings.mGravityFactor = inSettings->mGravityFactor;
+	settings.mUserData = inUserData;
+	const Body *body = mSystem->GetBodyInterface().CreateBody(settings);
+	if (body != nullptr)
+		mBodyID = body->GetID();
+}
+
+Character::~Character()
+{
+	// Destroy the body
+	mSystem->GetBodyInterface().DestroyBody(mBodyID);
+}
+
+void Character::AddToPhysicsSystem(EActivation inActivationMode, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddBody(mBodyID, inActivationMode);
+}
+
+void Character::RemoveFromPhysicsSystem(bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).RemoveBody(mBodyID);
+}
+
+void Character::Activate(bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).ActivateBody(mBodyID);
+}
+
+void Character::CheckCollision(RMat44Arg inCenterOfMassTransform, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const
+{
+	// Create query broadphase layer filter
+	DefaultBroadPhaseLayerFilter broadphase_layer_filter = mSystem->GetDefaultBroadPhaseLayerFilter(mLayer);
+
+	// Create query object layer filter
+	DefaultObjectLayerFilter object_layer_filter = mSystem->GetDefaultLayerFilter(mLayer);
+
+	// Ignore sensors and my own body
+	class CharacterBodyFilter : public IgnoreSingleBodyFilter
+	{
+	public:
+		using			IgnoreSingleBodyFilter::IgnoreSingleBodyFilter;
+
+		virtual bool	ShouldCollideLocked(const Body &inBody) const override
+		{
+			return !inBody.IsSensor();
+		}
+	};
+	CharacterBodyFilter body_filter(mBodyID);
+
+	// Settings for collide shape
+	CollideShapeSettings settings;
+	settings.mMaxSeparationDistance = inMaxSeparationDistance;
+	settings.mActiveEdgeMode = EActiveEdgeMode::CollideOnlyWithActive;
+	settings.mActiveEdgeMovementDirection = inMovementDirection;
+	settings.mBackFaceMode = EBackFaceMode::IgnoreBackFaces;
+
+	sCharacterGetNarrowPhaseQuery(mSystem, inLockBodies).CollideShape(inShape, Vec3::sOne(), inCenterOfMassTransform, settings, inBaseOffset, ioCollector, broadphase_layer_filter, object_layer_filter, body_filter);
+}
+
+void Character::CheckCollision(RVec3Arg inPosition, QuatArg inRotation, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const
+{
+	// Calculate center of mass transform
+	RMat44 center_of_mass = RMat44::sRotationTranslation(inRotation, inPosition).PreTranslated(inShape->GetCenterOfMass());
+
+	CheckCollision(center_of_mass, inMovementDirection, inMaxSeparationDistance, inShape, inBaseOffset, ioCollector, inLockBodies);
+}
+
+void Character::CheckCollision(const Shape *inShape, float inMaxSeparationDistance, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const
+{
+	// Determine position and velocity of body
+	RMat44 query_transform;
+	Vec3 velocity;
+	{
+		BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
+		if (!lock.Succeeded())
+			return;
+
+		const Body &body = lock.GetBody();
+
+		// Correct the center of mass transform for the difference between the old and new center of mass shape
+		query_transform = body.GetCenterOfMassTransform().PreTranslated(inShape->GetCenterOfMass() - mShape->GetCenterOfMass());
+		velocity = body.GetLinearVelocity();
+	}
+
+	CheckCollision(query_transform, velocity, inMaxSeparationDistance, inShape, inBaseOffset, ioCollector, inLockBodies);
+}
+
+void Character::PostSimulation(float inMaxSeparationDistance, bool inLockBodies)
+{
+	// Get character position, rotation and velocity
+	RVec3 char_pos;
+	Quat char_rot;
+	Vec3 char_vel;
+	{
+		BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
+		if (!lock.Succeeded())
+			return;
+		const Body &body = lock.GetBody();
+		char_pos = body.GetPosition();
+		char_rot = body.GetRotation();
+		char_vel = body.GetLinearVelocity();
+	}
+
+	// Collector that finds the hit with the normal that is the most 'up'
+	class MyCollector : public CollideShapeCollector
+	{
+	public:
+		// Constructor
+		explicit			MyCollector(Vec3Arg inUp, RVec3 inBaseOffset) : mBaseOffset(inBaseOffset), mUp(inUp) { }
+
+		// See: CollectorType::AddHit
+		virtual void		AddHit(const CollideShapeResult &inResult) override
+		{
+			Vec3 normal = -inResult.mPenetrationAxis.Normalized();
+			float dot = normal.Dot(mUp);
+			if (dot > mBestDot) // Find the hit that is most aligned with the up vector
+			{
+				mGroundBodyID = inResult.mBodyID2;
+				mGroundBodySubShapeID = inResult.mSubShapeID2;
+				mGroundPosition = mBaseOffset + inResult.mContactPointOn2;
+				mGroundNormal = normal;
+				mBestDot = dot;
+			}
+		}
+
+		BodyID				mGroundBodyID;
+		SubShapeID			mGroundBodySubShapeID;
+		RVec3				mGroundPosition = RVec3::sZero();
+		Vec3				mGroundNormal = Vec3::sZero();
+
+	private:
+		RVec3				mBaseOffset;
+		Vec3				mUp;
+		float				mBestDot = -FLT_MAX;
+	};
+
+	// Collide shape
+	MyCollector collector(mUp, char_pos);
+	CheckCollision(char_pos, char_rot, char_vel, inMaxSeparationDistance, mShape, char_pos, collector, inLockBodies);
+
+	// Copy results
+	mGroundBodyID = collector.mGroundBodyID;
+	mGroundBodySubShapeID = collector.mGroundBodySubShapeID;
+	mGroundPosition = collector.mGroundPosition;
+	mGroundNormal = collector.mGroundNormal;
+
+	// Get additional data from body
+	BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mGroundBodyID);
+	if (lock.Succeeded())
+	{
+		const Body &body = lock.GetBody();
+
+		// Update ground state
+		RMat44 inv_transform = RMat44::sInverseRotationTranslation(char_rot, char_pos);
+		if (mSupportingVolume.SignedDistance(Vec3(inv_transform * mGroundPosition)) > 0.0f)
+			mGroundState = EGroundState::NotSupported;
+		else if (IsSlopeTooSteep(mGroundNormal))
+			mGroundState = EGroundState::OnSteepGround;
+		else
+			mGroundState = EGroundState::OnGround;
+
+		// Copy other body properties
+		mGroundMaterial = body.GetShape()->GetMaterial(mGroundBodySubShapeID);
+		mGroundVelocity = body.GetPointVelocity(mGroundPosition);
+		mGroundUserData = body.GetUserData();
+	}
+	else
+	{
+		mGroundState = EGroundState::InAir;
+		mGroundMaterial = PhysicsMaterial::sDefault;
+		mGroundVelocity = Vec3::sZero();
+		mGroundUserData = 0;
+	}
+}
+
+void Character::SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetLinearAndAngularVelocity(mBodyID, inLinearVelocity, inAngularVelocity);
+}
+
+Vec3 Character::GetLinearVelocity(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetLinearVelocity(mBodyID);
+}
+
+void Character::SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetLinearVelocity(mBodyID, inLinearVelocity);
+}
+
+void Character::AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddLinearVelocity(mBodyID, inLinearVelocity);
+}
+
+void Character::AddImpulse(Vec3Arg inImpulse, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).AddImpulse(mBodyID, inImpulse);
+}
+
+void Character::GetPositionAndRotation(RVec3 &outPosition, Quat &outRotation, bool inLockBodies) const
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).GetPositionAndRotation(mBodyID, outPosition, outRotation);
+}
+
+void Character::SetPositionAndRotation(RVec3Arg inPosition, QuatArg inRotation, EActivation inActivationMode, bool inLockBodies) const
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetPositionAndRotation(mBodyID, inPosition, inRotation, inActivationMode);
+}
+
+RVec3 Character::GetPosition(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetPosition(mBodyID);
+}
+
+void Character::SetPosition(RVec3Arg inPosition, EActivation inActivationMode, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetPosition(mBodyID, inPosition, inActivationMode);
+}
+
+Quat Character::GetRotation(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetRotation(mBodyID);
+}
+
+void Character::SetRotation(QuatArg inRotation, EActivation inActivationMode, bool inLockBodies)
+{
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetRotation(mBodyID, inRotation, inActivationMode);
+}
+
+RVec3 Character::GetCenterOfMassPosition(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetCenterOfMassPosition(mBodyID);
+}
+
+RMat44 Character::GetWorldTransform(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetWorldTransform(mBodyID);
+}
+
+void Character::SetLayer(ObjectLayer inLayer, bool inLockBodies)
+{
+	mLayer = inLayer;
+
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetObjectLayer(mBodyID, inLayer);
+}
+
+bool Character::SetShape(const Shape *inShape, float inMaxPenetrationDepth, bool inLockBodies)
+{
+	if (inMaxPenetrationDepth < FLT_MAX)
+	{
+		// Collector that checks if there is anything in the way while switching to inShape
+		class MyCollector : public CollideShapeCollector
+		{
+		public:
+			// Constructor
+			explicit			MyCollector(float inMaxPenetrationDepth) : mMaxPenetrationDepth(inMaxPenetrationDepth) { }
+
+			// See: CollectorType::AddHit
+			virtual void		AddHit(const CollideShapeResult &inResult) override
+			{
+				if (inResult.mPenetrationDepth > mMaxPenetrationDepth)
+				{
+					mHadCollision = true;
+					ForceEarlyOut();
+				}
+			}
+
+			float				mMaxPenetrationDepth;
+			bool				mHadCollision = false;
+		};
+
+		// Test if anything is in the way of switching
+		RVec3 char_pos = GetPosition(inLockBodies);
+		MyCollector collector(inMaxPenetrationDepth);
+		CheckCollision(inShape, 0.0f, char_pos, collector, inLockBodies);
+		if (collector.mHadCollision)
+			return false;
+	}
+
+	// Switch the shape
+	mShape = inShape;
+	sCharacterGetBodyInterface(mSystem, inLockBodies).SetShape(mBodyID, mShape, false, EActivation::Activate);
+	return true;
+}
+
+TransformedShape Character::GetTransformedShape(bool inLockBodies) const
+{
+	return sCharacterGetBodyInterface(mSystem, inLockBodies).GetTransformedShape(mBodyID);
+}
+
+CharacterSettings Character::GetCharacterSettings(bool inLockBodies) const
+{
+	BodyLockRead lock(sCharacterGetBodyLockInterface(mSystem, inLockBodies), mBodyID);
+	JPH_ASSERT(lock.Succeeded());
+	const Body &body = lock.GetBody();
+
+	CharacterSettings settings;
+	settings.mUp = mUp;
+	settings.mSupportingVolume = mSupportingVolume;
+	settings.mMaxSlopeAngle = ACos(mCosMaxSlopeAngle);
+	settings.mEnhancedInternalEdgeRemoval = body.GetEnhancedInternalEdgeRemoval();
+	settings.mShape = mShape;
+	settings.mLayer = mLayer;
+	const MotionProperties *mp = body.GetMotionProperties();
+	settings.mMass = 1.0f / mp->GetInverseMass();
+	settings.mFriction = body.GetFriction();
+	settings.mGravityFactor = mp->GetGravityFactor();
+	settings.mAllowedDOFs = mp->GetAllowedDOFs();
+	return settings;
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,159 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Character/CharacterBase.h>
+#include <Jolt/Physics/Collision/ObjectLayer.h>
+#include <Jolt/Physics/Collision/TransformedShape.h>
+#include <Jolt/Physics/EActivation.h>
+#include <Jolt/Physics/Body/AllowedDOFs.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Contains the configuration of a character
+class JPH_EXPORT CharacterSettings : public CharacterBaseSettings
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+										CharacterSettings() = default;
+										CharacterSettings(const CharacterSettings &) = default;
+	CharacterSettings &					operator = (const CharacterSettings &) = default;
+
+	/// Layer that this character will be added to
+	ObjectLayer							mLayer = 0;
+
+	/// Mass of the character
+	float								mMass = 80.0f;
+
+	/// Friction for the character
+	float								mFriction = 0.2f;
+
+	/// Value to multiply gravity with for this character
+	float								mGravityFactor = 1.0f;
+
+	/// Allowed degrees of freedom for this character
+	EAllowedDOFs						mAllowedDOFs = EAllowedDOFs::TranslationX | EAllowedDOFs::TranslationY | EAllowedDOFs::TranslationZ;
+};
+
+/// Runtime character object.
+/// This object usually represents the player or a humanoid AI. It uses a single rigid body,
+/// usually with a capsule shape to simulate movement and collision for the character.
+/// The character is a keyframed object, the application controls it by setting the velocity.
+class JPH_EXPORT Character : public CharacterBase
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	/// @param inSettings The settings for the character
+	/// @param inPosition Initial position for the character
+	/// @param inRotation Initial rotation for the character (usually only around Y)
+	/// @param inUserData Application specific value
+	/// @param inSystem Physics system that this character will be added to later
+										Character(const CharacterSettings *inSettings, RVec3Arg inPosition, QuatArg inRotation, uint64 inUserData, PhysicsSystem *inSystem);
+
+	/// Destructor
+	virtual								~Character() override;
+
+	/// Add bodies and constraints to the system and optionally activate the bodies
+	void								AddToPhysicsSystem(EActivation inActivationMode = EActivation::Activate, bool inLockBodies = true);
+
+	/// Remove bodies and constraints from the system
+	void								RemoveFromPhysicsSystem(bool inLockBodies = true);
+
+	/// Wake up the character
+	void								Activate(bool inLockBodies = true);
+
+	/// Needs to be called after every PhysicsSystem::Update
+	/// @param inMaxSeparationDistance Max distance between the floor and the character to still consider the character standing on the floor
+	/// @param inLockBodies If the collision query should use the locking body interface (true) or the non locking body interface (false)
+	void								PostSimulation(float inMaxSeparationDistance, bool inLockBodies = true);
+
+	/// Control the velocity of the character
+	void								SetLinearAndAngularVelocity(Vec3Arg inLinearVelocity, Vec3Arg inAngularVelocity, bool inLockBodies = true);
+
+	/// Get the linear velocity of the character (m / s)
+	Vec3								GetLinearVelocity(bool inLockBodies = true) const;
+
+	/// Set the linear velocity of the character (m / s)
+	void								SetLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
+
+	/// Add world space linear velocity to current velocity (m / s)
+	void								AddLinearVelocity(Vec3Arg inLinearVelocity, bool inLockBodies = true);
+
+	/// Add impulse to the center of mass of the character
+	void								AddImpulse(Vec3Arg inImpulse, bool inLockBodies = true);
+
+	/// Get the body associated with this character
+	BodyID								GetBodyID() const										{ return mBodyID; }
+
+	/// Get position / rotation of the body
+	void								GetPositionAndRotation(RVec3 &outPosition, Quat &outRotation, bool inLockBodies = true) const;
+
+	/// Set the position / rotation of the body, optionally activating it.
+	void								SetPositionAndRotation(RVec3Arg inPosition, QuatArg inRotation, EActivation inActivationMode = EActivation::Activate, bool inLockBodies = true) const;
+
+	/// Get the position of the character
+	RVec3								GetPosition(bool inLockBodies = true) const;
+
+	/// Set the position of the character, optionally activating it.
+	void								SetPosition(RVec3Arg inPosition, EActivation inActivationMode = EActivation::Activate, bool inLockBodies = true);
+
+	/// Get the rotation of the character
+	Quat								GetRotation(bool inLockBodies = true) const;
+
+	/// Set the rotation of the character, optionally activating it.
+	void								SetRotation(QuatArg inRotation, EActivation inActivationMode = EActivation::Activate, bool inLockBodies = true);
+
+	/// Position of the center of mass of the underlying rigid body
+	RVec3								GetCenterOfMassPosition(bool inLockBodies = true) const;
+
+	/// Calculate the world transform of the character
+	RMat44								GetWorldTransform(bool inLockBodies = true) const;
+
+	/// Get the layer of the character
+	ObjectLayer							GetLayer() const										{ return mLayer; }
+
+	/// Update the layer of the character
+	void								SetLayer(ObjectLayer inLayer, bool inLockBodies = true);
+
+	/// Switch the shape of the character (e.g. for stance). When inMaxPenetrationDepth is not FLT_MAX, it checks
+	/// if the new shape collides before switching shape. Returns true if the switch succeeded.
+	bool								SetShape(const Shape *inShape, float inMaxPenetrationDepth, bool inLockBodies = true);
+
+	/// Get the transformed shape that represents the volume of the character, can be used for collision checks.
+	TransformedShape					GetTransformedShape(bool inLockBodies = true) const;
+
+	/// @brief Get all contacts for the character at a particular location
+	/// @param inPosition Position to test.
+	/// @param inRotation Rotation at which to test the shape.
+	/// @param inMovementDirection A hint in which direction the character is moving, will be used to calculate a proper normal.
+	/// @param inMaxSeparationDistance How much distance around the character you want to report contacts in (can be 0 to match the character exactly).
+	/// @param inShape Shape to test collision with.
+	/// @param inBaseOffset All hit results will be returned relative to this offset, can be zero to get results in world position, but when you're testing far from the origin you get better precision by picking a position that's closer e.g. GetPosition() since floats are most accurate near the origin
+	/// @param ioCollector Collision collector that receives the collision results.
+	/// @param inLockBodies If the collision query should use the locking body interface (true) or the non locking body interface (false)
+	void								CheckCollision(RVec3Arg inPosition, QuatArg inRotation, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies = true) const;
+
+	/// Get the character settings that can recreate this character
+	CharacterSettings					GetCharacterSettings(bool inLockBodies = true) const;
+
+private:
+	/// Check collisions between inShape and the world using the center of mass transform
+	void								CheckCollision(RMat44Arg inCenterOfMassTransform, Vec3Arg inMovementDirection, float inMaxSeparationDistance, const Shape *inShape, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const;
+
+	/// Check collisions between inShape and the world using the current position / rotation of the character
+	void								CheckCollision(const Shape *inShape, float inMaxSeparationDistance, RVec3Arg inBaseOffset, CollideShapeCollector &ioCollector, bool inLockBodies) const;
+
+	/// The body of this character
+	BodyID								mBodyID;
+
+	/// The layer the body is in
+	ObjectLayer							mLayer;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Character/CharacterBase.cpp

@@ -0,0 +1,59 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Character/CharacterBase.h>
+#include <Jolt/Physics/StateRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+CharacterBase::CharacterBase(const CharacterBaseSettings *inSettings, PhysicsSystem *inSystem) :
+	mSystem(inSystem),
+	mShape(inSettings->mShape),
+	mUp(inSettings->mUp),
+	mSupportingVolume(inSettings->mSupportingVolume)
+{
+	// Initialize max slope angle
+	SetMaxSlopeAngle(inSettings->mMaxSlopeAngle);
+}
+
+const char *CharacterBase::sToString(EGroundState inState)
+{
+	switch (inState)
+	{
+	case EGroundState::OnGround:		return "OnGround";
+	case EGroundState::OnSteepGround:	return "OnSteepGround";
+	case EGroundState::NotSupported:	return "NotSupported";
+	case EGroundState::InAir:			return "InAir";
+	}
+
+	JPH_ASSERT(false);
+	return "Unknown";
+}
+
+void CharacterBase::SaveState(StateRecorder &inStream) const
+{
+	inStream.Write(mGroundState);
+	inStream.Write(mGroundBodyID);
+	inStream.Write(mGroundBodySubShapeID);
+	inStream.Write(mGroundPosition);
+	inStream.Write(mGroundNormal);
+	inStream.Write(mGroundVelocity);
+	// Can't save user data (may be a pointer) and material
+}
+
+void CharacterBase::RestoreState(StateRecorder &inStream)
+{
+	inStream.Read(mGroundState);
+	inStream.Read(mGroundBodyID);
+	inStream.Read(mGroundBodySubShapeID);
+	inStream.Read(mGroundPosition);
+	inStream.Read(mGroundNormal);
+	inStream.Read(mGroundVelocity);
+	mGroundUserData = 0; // Cannot restore user data
+	mGroundMaterial = PhysicsMaterial::sDefault; // Cannot restore material
+}
+
+JPH_NAMESPACE_END