@bloomengine/engine 0.3.1

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

@@ -0,0 +1,90 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/StateRecorderImpl.h>
+
+JPH_NAMESPACE_BEGIN
+
+void StateRecorderImpl::WriteBytes(const void *inData, size_t inNumBytes)
+{
+	mStream.write((const char *)inData, inNumBytes);
+}
+
+void StateRecorderImpl::Rewind()
+{
+	mStream.seekg(0, std::stringstream::beg);
+}
+
+void StateRecorderImpl::Clear()
+{
+	mStream.clear();
+	mStream.str({});
+}
+
+void StateRecorderImpl::ReadBytes(void *outData, size_t inNumBytes)
+{
+	if (IsValidating())
+	{
+		// Read data in temporary buffer to compare with current value
+		void *data = JPH_STACK_ALLOC(inNumBytes);
+		mStream.read((char *)data, inNumBytes);
+		if (memcmp(data, outData, inNumBytes) != 0)
+		{
+			// Mismatch, print error
+			Trace("Mismatch reading %u bytes", (uint)inNumBytes);
+			for (size_t i = 0; i < inNumBytes; ++i)
+			{
+				int b1 = reinterpret_cast<uint8 *>(outData)[i];
+				int b2 = reinterpret_cast<uint8 *>(data)[i];
+				if (b1 != b2)
+					Trace("Offset %d: %02X -> %02X", i, b1, b2);
+			}
+			JPH_BREAKPOINT;
+		}
+
+		// Copy the temporary data to the final destination
+		memcpy(outData, data, inNumBytes);
+		return;
+	}
+
+	mStream.read((char *)outData, inNumBytes);
+}
+
+bool StateRecorderImpl::IsEqual(StateRecorderImpl &inReference)
+{
+	// Get length of new state
+	mStream.seekg(0, std::stringstream::end);
+	std::streamoff this_len = mStream.tellg();
+	mStream.seekg(0, std::stringstream::beg);
+
+	// Get length of old state
+	inReference.mStream.seekg(0, std::stringstream::end);
+	std::streamoff reference_len = inReference.mStream.tellg();
+	inReference.mStream.seekg(0, std::stringstream::beg);
+
+	// Compare size
+	bool fail = reference_len != this_len;
+	if (fail)
+	{
+		Trace("Failed to properly recover state, different stream length!");
+		return false;
+	}
+
+	// Compare byte by byte
+	for (std::streamoff i = 0, l = this_len; !fail && i < l; ++i)
+	{
+		fail = inReference.mStream.get() != mStream.get();
+		if (fail)
+		{
+			Trace("Failed to properly recover state, different at offset %d!", (int)i);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,50 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/StateRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Implementation of the StateRecorder class that uses a stringstream as underlying store and that implements checking if the state doesn't change upon reading
+class JPH_EXPORT StateRecorderImpl final : public StateRecorder
+{
+public:
+	/// Constructor
+						StateRecorderImpl() = default;
+						StateRecorderImpl(StateRecorderImpl &&inRHS)				: StateRecorder(inRHS), mStream(std::move(inRHS.mStream)) { }
+
+	/// Write a string of bytes to the binary stream
+	virtual void		WriteBytes(const void *inData, size_t inNumBytes) override;
+
+	/// Rewind the stream for reading
+	void				Rewind();
+
+	/// Clear the stream for reuse
+	void				Clear();
+
+	/// Read a string of bytes from the binary stream
+	virtual void		ReadBytes(void *outData, size_t inNumBytes) override;
+
+	// See StreamIn
+	virtual bool		IsEOF() const override										{ return mStream.eof(); }
+
+	// See StreamIn / StreamOut
+	virtual bool		IsFailed() const override									{ return mStream.fail(); }
+
+	/// Compare this state with a reference state and ensure they are the same
+	bool				IsEqual(StateRecorderImpl &inReference);
+
+	/// Convert the binary data to a string
+	std::string			GetData() const												{ return mStream.str(); }
+
+	/// Get size of the binary data in bytes
+	size_t				GetDataSize()												{ return size_t(mStream.tellp()); }
+
+private:
+	std::stringstream	mStream;
+};
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Vehicle/MotorcycleController.cpp

@@ -0,0 +1,306 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Vehicle/MotorcycleController.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+#ifdef JPH_DEBUG_RENDERER
+	#include <Jolt/Renderer/DebugRenderer.h>
+#endif // JPH_DEBUG_RENDERER
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(MotorcycleControllerSettings)
+{
+	JPH_ADD_BASE_CLASS(MotorcycleControllerSettings, WheeledVehicleControllerSettings)
+
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mMaxLeanAngle)
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mLeanSpringConstant)
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mLeanSpringDamping)
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mLeanSpringIntegrationCoefficient)
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mLeanSpringIntegrationCoefficientDecay)
+	JPH_ADD_ATTRIBUTE(MotorcycleControllerSettings, mLeanSmoothingFactor)
+}
+
+VehicleController *MotorcycleControllerSettings::ConstructController(VehicleConstraint &inConstraint) const
+{
+	return new MotorcycleController(*this, inConstraint);
+}
+
+void MotorcycleControllerSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	WheeledVehicleControllerSettings::SaveBinaryState(inStream);
+
+	inStream.Write(mMaxLeanAngle);
+	inStream.Write(mLeanSpringConstant);
+	inStream.Write(mLeanSpringDamping);
+	inStream.Write(mLeanSpringIntegrationCoefficient);
+	inStream.Write(mLeanSpringIntegrationCoefficientDecay);
+	inStream.Write(mLeanSmoothingFactor);
+}
+
+void MotorcycleControllerSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	WheeledVehicleControllerSettings::RestoreBinaryState(inStream);
+
+	inStream.Read(mMaxLeanAngle);
+	inStream.Read(mLeanSpringConstant);
+	inStream.Read(mLeanSpringDamping);
+	inStream.Read(mLeanSpringIntegrationCoefficient);
+	inStream.Read(mLeanSpringIntegrationCoefficientDecay);
+	inStream.Read(mLeanSmoothingFactor);
+}
+
+MotorcycleController::MotorcycleController(const MotorcycleControllerSettings &inSettings, VehicleConstraint &inConstraint) :
+	WheeledVehicleController(inSettings, inConstraint),
+	mMaxLeanAngle(inSettings.mMaxLeanAngle),
+	mLeanSpringConstant(inSettings.mLeanSpringConstant),
+	mLeanSpringDamping(inSettings.mLeanSpringDamping),
+	mLeanSpringIntegrationCoefficient(inSettings.mLeanSpringIntegrationCoefficient),
+	mLeanSpringIntegrationCoefficientDecay(inSettings.mLeanSpringIntegrationCoefficientDecay),
+	mLeanSmoothingFactor(inSettings.mLeanSmoothingFactor)
+{
+}
+
+float MotorcycleController::GetWheelBase() const
+{
+	float low = FLT_MAX, high = -FLT_MAX;
+
+	for (const Wheel *w : mConstraint.GetWheels())
+	{
+		const WheelSettings *s = w->GetSettings();
+
+		// Measure distance along the forward axis by looking at the fully extended suspension.
+		// If the suspension force point is active, use that instead.
+		Vec3 force_point = s->mEnableSuspensionForcePoint? s->mSuspensionForcePoint : s->mPosition + s->mSuspensionDirection * s->mSuspensionMaxLength;
+		float value = force_point.Dot(mConstraint.GetLocalForward());
+
+		// Update min and max
+		low = min(low, value);
+		high = max(high, value);
+	}
+
+	return high - low;
+}
+
+void MotorcycleController::PreCollide(float inDeltaTime, PhysicsSystem &inPhysicsSystem)
+{
+	WheeledVehicleController::PreCollide(inDeltaTime, inPhysicsSystem);
+
+	const Body *body = mConstraint.GetVehicleBody();
+	Vec3 forward = body->GetRotation() * mConstraint.GetLocalForward();
+	float wheel_base = GetWheelBase();
+	Vec3 world_up = mConstraint.GetWorldUp();
+
+	if (mEnableLeanController)
+	{
+		// Calculate the target lean vector, this is in the direction of the total applied impulse by the ground on the wheels
+		Vec3 target_lean = Vec3::sZero();
+		for (const Wheel *w : mConstraint.GetWheels())
+			if (w->HasContact())
+				target_lean += w->GetContactNormal() * w->GetSuspensionLambda() + w->GetContactLateral() * w->GetLateralLambda();
+
+		// Normalize the impulse
+		target_lean = target_lean.NormalizedOr(world_up);
+
+		// Smooth the impulse to avoid jittery behavior
+		mTargetLean = mLeanSmoothingFactor * mTargetLean + (1.0f - mLeanSmoothingFactor) * target_lean;
+
+		// Remove forward component, we can only lean sideways
+		mTargetLean -= forward * mTargetLean.Dot(forward);
+		mTargetLean = mTargetLean.NormalizedOr(world_up);
+
+		// Clamp the target lean against the max lean angle
+		Vec3 adjusted_world_up = world_up - forward * world_up.Dot(forward);
+		adjusted_world_up = adjusted_world_up.NormalizedOr(world_up);
+		float w_angle = -Sign(mTargetLean.Cross(adjusted_world_up).Dot(forward)) * ACos(mTargetLean.Dot(adjusted_world_up));
+		if (abs(w_angle) > mMaxLeanAngle)
+			mTargetLean = Quat::sRotation(forward, Sign(w_angle) * mMaxLeanAngle) * adjusted_world_up;
+
+		// Integrate the delta angle
+		Vec3 up = body->GetRotation() * mConstraint.GetLocalUp();
+		float d_angle = -Sign(mTargetLean.Cross(up).Dot(forward)) * ACos(mTargetLean.Dot(up));
+		mLeanSpringIntegratedDeltaAngle += d_angle * inDeltaTime;
+	}
+	else
+	{
+		// Controller not enabled, reset target lean
+		mTargetLean = world_up;
+
+		// Reset integrated delta angle
+		mLeanSpringIntegratedDeltaAngle = 0;
+	}
+
+	JPH_DET_LOG("WheeledVehicleController::PreCollide: mTargetLean: " << mTargetLean);
+
+	// Calculate max steering angle based on the max lean angle we're willing to take
+	// See: https://en.wikipedia.org/wiki/Bicycle_and_motorcycle_dynamics#Leaning
+	// LeanAngle = Atan(Velocity^2 / (Gravity * TurnRadius))
+	// And: https://en.wikipedia.org/wiki/Turning_radius (we're ignoring the tire width)
+	// The CasterAngle is the added according to https://en.wikipedia.org/wiki/Bicycle_and_motorcycle_dynamics#Turning (this is the same formula but without small angle approximation)
+	// TurnRadius = WheelBase / (Sin(SteerAngle) * Cos(CasterAngle))
+	// => SteerAngle = ASin(WheelBase * Tan(LeanAngle) * Gravity / (Velocity^2 * Cos(CasterAngle))
+	// The caster angle is different for each wheel so we can only calculate part of the equation here
+	float max_steer_angle_factor = wheel_base * Tan(mMaxLeanAngle) * (mConstraint.IsGravityOverridden()? mConstraint.GetGravityOverride() : inPhysicsSystem.GetGravity()).Length();
+
+	// Calculate forward velocity
+	float velocity = body->GetLinearVelocity().Dot(forward);
+	float velocity_sq = Square(velocity);
+
+	// Decompose steering into sign and direction
+	float steer_strength = abs(mRightInput);
+	float steer_sign = -Sign(mRightInput);
+
+	for (Wheel *w_base : mConstraint.GetWheels())
+	{
+		WheelWV *w = static_cast<WheelWV *>(w_base);
+		const WheelSettingsWV *s = w->GetSettings();
+
+		// Check if this wheel can steer
+		if (s->mMaxSteerAngle != 0.0f)
+		{
+			// Calculate cos(caster angle), the angle between the steering axis and the up vector
+			float cos_caster_angle = s->mSteeringAxis.Dot(mConstraint.GetLocalUp());
+
+			// Calculate steer angle
+			float steer_angle = steer_strength * w->GetSettings()->mMaxSteerAngle;
+
+			// Clamp to max steering angle
+			if (mEnableLeanSteeringLimit
+				&& velocity_sq > 1.0e-6f && cos_caster_angle > 1.0e-6f)
+			{
+				float max_steer_angle = ASin(max_steer_angle_factor / (velocity_sq * cos_caster_angle));
+				steer_angle = min(steer_angle, max_steer_angle);
+			}
+
+			// Set steering angle
+			w->SetSteerAngle(steer_sign * steer_angle);
+		}
+	}
+
+	// Reset applied impulse
+	mAppliedImpulse = 0;
+}
+
+bool MotorcycleController::SolveLongitudinalAndLateralConstraints(float inDeltaTime)
+{
+	bool impulse = WheeledVehicleController::SolveLongitudinalAndLateralConstraints(inDeltaTime);
+
+	if (mEnableLeanController)
+	{
+		// Only apply a lean impulse if all wheels are in contact, otherwise we can easily spin out
+		bool all_in_contact = true;
+		for (const Wheel *w : mConstraint.GetWheels())
+			if (!w->HasContact() || w->GetSuspensionLambda() <= 0.0f)
+			{
+				all_in_contact = false;
+				break;
+			}
+
+		if (all_in_contact)
+		{
+			Body *body = mConstraint.GetVehicleBody();
+			const MotionProperties *mp = body->GetMotionProperties();
+
+			Vec3 forward = body->GetRotation() * mConstraint.GetLocalForward();
+			Vec3 up = body->GetRotation() * mConstraint.GetLocalUp();
+
+			// Calculate delta to target angle and derivative
+			float d_angle = -Sign(mTargetLean.Cross(up).Dot(forward)) * ACos(mTargetLean.Dot(up));
+			float ddt_angle = body->GetAngularVelocity().Dot(forward);
+
+			// Calculate impulse to apply to get to target lean angle
+			float total_impulse = (mLeanSpringConstant * d_angle - mLeanSpringDamping * ddt_angle + mLeanSpringIntegrationCoefficient * mLeanSpringIntegratedDeltaAngle) * inDeltaTime;
+
+			// Remember angular velocity pre angular impulse
+			Vec3 old_w = mp->GetAngularVelocity();
+
+			// Apply impulse taking into account the impulse we've applied earlier
+			float delta_impulse = total_impulse - mAppliedImpulse;
+			body->AddAngularImpulse(delta_impulse * forward);
+			mAppliedImpulse = total_impulse;
+
+			// Calculate delta angular velocity due to angular impulse
+			Vec3 dw = mp->GetAngularVelocity() - old_w;
+			Vec3 linear_acceleration = Vec3::sZero();
+			float total_lambda = 0.0f;
+			for (Wheel *w_base : mConstraint.GetWheels())
+			{
+				const WheelWV *w = static_cast<WheelWV *>(w_base);
+
+				// We weigh the importance of each contact point according to the contact force
+				float lambda = w->GetSuspensionLambda();
+				total_lambda += lambda;
+
+				// Linear acceleration of contact point is dw x com_to_contact
+				Vec3 r = Vec3(w->GetContactPosition() - body->GetCenterOfMassPosition());
+				linear_acceleration += lambda * dw.Cross(r);
+			}
+
+			// Apply linear impulse to COM to cancel the average velocity change on the wheels due to the angular impulse
+			Vec3 linear_impulse = -linear_acceleration / (total_lambda * mp->GetInverseMass());
+			body->AddImpulse(linear_impulse);
+
+			// Return true if we applied an impulse
+			impulse |= delta_impulse != 0.0f;
+		}
+		else
+		{
+			// Decay the integrated angle because we won't be applying a torque this frame
+			// Uses 1st order Taylor approximation of e^(-decay * dt) = 1 - decay * dt
+			mLeanSpringIntegratedDeltaAngle *= max(0.0f, 1.0f - mLeanSpringIntegrationCoefficientDecay * inDeltaTime);
+		}
+	}
+
+	return impulse;
+}
+
+void MotorcycleController::SaveState(StateRecorder &inStream) const
+{
+	WheeledVehicleController::SaveState(inStream);
+
+	inStream.Write(mTargetLean);
+}
+
+void MotorcycleController::RestoreState(StateRecorder &inStream)
+{
+	WheeledVehicleController::RestoreState(inStream);
+
+	inStream.Read(mTargetLean);
+}
+
+#ifdef JPH_DEBUG_RENDERER
+
+void MotorcycleController::Draw(DebugRenderer *inRenderer) const
+{
+	WheeledVehicleController::Draw(inRenderer);
+
+	// Draw current and desired lean angle
+	Body *body = mConstraint.GetVehicleBody();
+	RVec3 center_of_mass = body->GetCenterOfMassPosition();
+	Vec3 up = body->GetRotation() * mConstraint.GetLocalUp();
+	inRenderer->DrawArrow(center_of_mass, center_of_mass + up, Color::sYellow, 0.1f);
+	inRenderer->DrawArrow(center_of_mass, center_of_mass + mTargetLean, Color::sRed, 0.1f);
+}
+
+#endif // JPH_DEBUG_RENDERER
+
+Ref<VehicleControllerSettings> MotorcycleController::GetSettings() const
+{
+	MotorcycleControllerSettings *settings = new MotorcycleControllerSettings;
+	ToSettings(*settings);
+	settings->mMaxLeanAngle = mMaxLeanAngle;
+	settings->mLeanSpringConstant = mLeanSpringConstant;
+	settings->mLeanSpringDamping = settings->mLeanSpringDamping;
+	settings->mLeanSpringIntegrationCoefficient = mLeanSpringIntegrationCoefficient;
+	settings->mLeanSpringIntegrationCoefficientDecay = mLeanSpringIntegrationCoefficientDecay;
+	settings->mLeanSmoothingFactor = mLeanSmoothingFactor;
+	return settings;
+}
+
+JPH_NAMESPACE_END

package/native/third_party/JoltPhysics/Jolt/Physics/Vehicle/MotorcycleController.h

@@ -0,0 +1,119 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Vehicle/WheeledVehicleController.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// Settings of a two wheeled motorcycle (adds a spring to balance the motorcycle)
+/// Note: The motor cycle controller is still in development and may need a lot of tweaks/hacks to work properly!
+class JPH_EXPORT MotorcycleControllerSettings : public WheeledVehicleControllerSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, MotorcycleControllerSettings)
+
+public:
+	// See: VehicleControllerSettings
+	virtual VehicleController *	ConstructController(VehicleConstraint &inConstraint) const override;
+	virtual void				SaveBinaryState(StreamOut &inStream) const override;
+	virtual void				RestoreBinaryState(StreamIn &inStream) override;
+
+	/// How far we're willing to make the bike lean over in turns (in radians)
+	float						mMaxLeanAngle = DegreesToRadians(45.0f);
+
+	/// Spring constant for the lean spring
+	float						mLeanSpringConstant = 5000.0f;
+
+	/// Spring damping constant for the lean spring
+	float						mLeanSpringDamping = 1000.0f;
+
+	/// The lean spring applies an additional force equal to this coefficient * Integral(delta angle, 0, t), this effectively makes the lean spring a PID controller
+	float						mLeanSpringIntegrationCoefficient = 0.0f;
+
+	/// How much to decay the angle integral when the wheels are not touching the floor: new_value = e^(-decay * t) * initial_value
+	float						mLeanSpringIntegrationCoefficientDecay = 4.0f;
+
+	/// How much to smooth the lean angle (0 = no smoothing, 1 = lean angle never changes)
+	/// Note that this is frame rate dependent because the formula is: smoothing_factor * previous + (1 - smoothing_factor) * current
+	float						mLeanSmoothingFactor = 0.8f;
+};
+
+/// Runtime controller class
+class JPH_EXPORT MotorcycleController : public WheeledVehicleController
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+								MotorcycleController(const MotorcycleControllerSettings &inSettings, VehicleConstraint &inConstraint);
+
+	/// Get the distance between the front and back wheels
+	float						GetWheelBase() const;
+
+	/// Enable or disable the lean spring. This allows you to temporarily disable the lean spring to allow the motorcycle to fall over.
+	void						EnableLeanController(bool inEnable)					{ mEnableLeanController = inEnable; }
+
+	/// Check if the lean spring is enabled.
+	bool						IsLeanControllerEnabled() const						{ return mEnableLeanController; }
+
+	/// Enable or disable the lean steering limit. When enabled (default) the steering angle is limited based on the vehicle speed to prevent steering that would cause an inertial force that causes the motorcycle to topple over.
+	void						EnableLeanSteeringLimit(bool inEnable)				{ mEnableLeanSteeringLimit = inEnable; }
+	bool						IsLeanSteeringLimitEnabled() const					{ return mEnableLeanSteeringLimit; }
+
+	/// Spring constant for the lean spring
+	void						SetLeanSpringConstant(float inConstant)				{ mLeanSpringConstant = inConstant; }
+	float						GetLeanSpringConstant() const						{ return mLeanSpringConstant; }
+
+	/// Spring damping constant for the lean spring
+	void						SetLeanSpringDamping(float inDamping)				{ mLeanSpringDamping = inDamping; }
+	float						GetLeanSpringDamping() const						{ return mLeanSpringDamping; }
+
+	/// The lean spring applies an additional force equal to this coefficient * Integral(delta angle, 0, t), this effectively makes the lean spring a PID controller
+	void						SetLeanSpringIntegrationCoefficient(float inCoefficient) { mLeanSpringIntegrationCoefficient = inCoefficient; }
+	float						GetLeanSpringIntegrationCoefficient() const			{ return mLeanSpringIntegrationCoefficient; }
+
+	/// How much to decay the angle integral when the wheels are not touching the floor: new_value = e^(-decay * t) * initial_value
+	void						SetLeanSpringIntegrationCoefficientDecay(float inDecay) { mLeanSpringIntegrationCoefficientDecay = inDecay; }
+	float						GetLeanSpringIntegrationCoefficientDecay() const	{ return mLeanSpringIntegrationCoefficientDecay; }
+
+	/// How much to smooth the lean angle (0 = no smoothing, 1 = lean angle never changes)
+	/// Note that this is frame rate dependent because the formula is: smoothing_factor * previous + (1 - smoothing_factor) * current
+	void						SetLeanSmoothingFactor(float inFactor)				{ mLeanSmoothingFactor = inFactor; }
+	float						GetLeanSmoothingFactor() const						{ return mLeanSmoothingFactor; }
+
+	// See: VehicleController
+	virtual Ref<VehicleControllerSettings> GetSettings() const override;
+
+protected:
+	// See: VehicleController
+	virtual void				PreCollide(float inDeltaTime, PhysicsSystem &inPhysicsSystem) override;
+	virtual bool				SolveLongitudinalAndLateralConstraints(float inDeltaTime) override;
+	virtual void				SaveState(StateRecorder &inStream) const override;
+	virtual void				RestoreState(StateRecorder &inStream) override;
+#ifdef JPH_DEBUG_RENDERER
+	virtual void				Draw(DebugRenderer *inRenderer) const override;
+#endif // JPH_DEBUG_RENDERER
+
+	// Configuration properties
+	bool						mEnableLeanController = true;
+	bool						mEnableLeanSteeringLimit = true;
+	float						mMaxLeanAngle;
+	float						mLeanSpringConstant;
+	float						mLeanSpringDamping;
+	float						mLeanSpringIntegrationCoefficient;
+	float						mLeanSpringIntegrationCoefficientDecay;
+	float						mLeanSmoothingFactor;
+
+	// Run-time calculated target lean vector
+	Vec3						mTargetLean = Vec3::sZero();
+
+	// Integrated error for the lean spring
+	float						mLeanSpringIntegratedDeltaAngle = 0.0f;
+
+	// Run-time total angular impulse applied to turn the cycle towards the target lean angle
+	float						mAppliedImpulse = 0.0f;
+};
+
+JPH_NAMESPACE_END