@bloomengine/engine 0.3.1

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

@@ -0,0 +1,169 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/Physics/Vehicle/VehicleConstraint.h>
+#include <Jolt/Physics/Vehicle/VehicleController.h>
+#include <Jolt/Physics/Vehicle/VehicleEngine.h>
+#include <Jolt/Physics/Vehicle/VehicleTransmission.h>
+#include <Jolt/Physics/Vehicle/VehicleTrack.h>
+
+JPH_NAMESPACE_BEGIN
+
+class PhysicsSystem;
+
+/// WheelSettings object specifically for TrackedVehicleController
+class JPH_EXPORT WheelSettingsTV : public WheelSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, WheelSettingsTV)
+
+public:
+	// See: WheelSettings
+	virtual void				SaveBinaryState(StreamOut &inStream) const override;
+	virtual void				RestoreBinaryState(StreamIn &inStream) override;
+
+	float						mLongitudinalFriction = 4.0f;				///< Friction in forward direction of tire
+	float						mLateralFriction = 2.0f;					///< Friction in sideways direction of tire
+};
+
+/// Wheel object specifically for TrackedVehicleController
+class JPH_EXPORT WheelTV : public Wheel
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+	explicit					WheelTV(const WheelSettingsTV &inWheel);
+
+	/// Override GetSettings and cast to the correct class
+	const WheelSettingsTV *		GetSettings() const							{ return StaticCast<WheelSettingsTV>(mSettings); }
+
+	/// Update the angular velocity of the wheel based on the angular velocity of the track
+	void						CalculateAngularVelocity(const VehicleConstraint &inConstraint);
+
+	/// Update the wheel rotation based on the current angular velocity
+	void						Update(uint inWheelIndex, float inDeltaTime, const VehicleConstraint &inConstraint);
+
+	int							mTrackIndex = -1;							///< Index in mTracks to which this wheel is attached (calculated on initialization)
+	float						mCombinedLongitudinalFriction = 0.0f;		///< Combined friction coefficient in longitudinal direction (combines terrain and track)
+	float						mCombinedLateralFriction = 0.0f;			///< Combined friction coefficient in lateral direction (combines terrain and track)
+	float						mBrakeImpulse = 0.0f;						///< Amount of impulse that the brakes can apply to the floor (excluding friction), spread out from brake impulse applied on track
+};
+
+/// Settings of a vehicle with tank tracks
+///
+/// Default settings are based around what I could find about the M1 Abrams tank.
+/// Note to avoid issues with very heavy objects vs very light objects the mass of the tank should be a lot lower (say 10x) than that of a real tank. That means that the engine/brake torque is also 10x less.
+class JPH_EXPORT TrackedVehicleControllerSettings : public VehicleControllerSettings
+{
+	JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, TrackedVehicleControllerSettings)
+
+public:
+	// Constructor
+								TrackedVehicleControllerSettings();
+
+	// See: VehicleControllerSettings
+	virtual VehicleController *	ConstructController(VehicleConstraint &inConstraint) const override;
+	virtual void				SaveBinaryState(StreamOut &inStream) const override;
+	virtual void				RestoreBinaryState(StreamIn &inStream) override;
+
+	VehicleEngineSettings		mEngine;									///< The properties of the engine
+	VehicleTransmissionSettings	mTransmission;								///< The properties of the transmission (aka gear box)
+	VehicleTrackSettings		mTracks[(int)ETrackSide::Num];				///< List of tracks and their properties
+};
+
+/// Runtime controller class for vehicle with tank tracks
+class JPH_EXPORT TrackedVehicleController : public VehicleController
+{
+public:
+	JPH_OVERRIDE_NEW_DELETE
+
+	/// Constructor
+								TrackedVehicleController(const TrackedVehicleControllerSettings &inSettings, VehicleConstraint &inConstraint);
+
+	/// Set input from driver
+	/// @param inForward Value between -1 and 1 for auto transmission and value between 0 and 1 indicating desired driving direction and amount the gas pedal is pressed
+	/// @param inLeftRatio Value between -1 and 1 indicating an extra multiplier to the rotation rate of the left track (used for steering)
+	/// @param inRightRatio Value between -1 and 1 indicating an extra multiplier to the rotation rate of the right track (used for steering)
+	/// @param inBrake Value between 0 and 1 indicating how strong the brake pedal is pressed
+	void						SetDriverInput(float inForward, float inLeftRatio, float inRightRatio, float inBrake) { JPH_ASSERT(inLeftRatio != 0.0f && inRightRatio != 0.0f); mForwardInput = inForward; mLeftRatio = inLeftRatio; mRightRatio = inRightRatio; mBrakeInput = inBrake; }
+
+	/// Value between -1 and 1 for auto transmission and value between 0 and 1 indicating desired driving direction and amount the gas pedal is pressed
+	void						SetForwardInput(float inForward)			{ mForwardInput = inForward; }
+	float						GetForwardInput() const						{ return mForwardInput; }
+
+	/// Value between -1 and 1 indicating an extra multiplier to the rotation rate of the left track (used for steering)
+	void						SetLeftRatio(float inLeftRatio)				{ JPH_ASSERT(inLeftRatio != 0.0f); mLeftRatio = inLeftRatio; }
+	float						GetLeftRatio() const						{ return mLeftRatio; }
+
+	/// Value between -1 and 1 indicating an extra multiplier to the rotation rate of the right track (used for steering)
+	void						SetRightRatio(float inRightRatio)			{ JPH_ASSERT(inRightRatio != 0.0f); mRightRatio = inRightRatio; }
+	float						GetRightRatio() const						{ return mRightRatio; }
+
+	/// Value between 0 and 1 indicating how strong the brake pedal is pressed
+	void						SetBrakeInput(float inBrake)				{ mBrakeInput = inBrake; }
+	float						GetBrakeInput() const						{ return mBrakeInput; }
+
+	/// Get current engine state
+	const VehicleEngine &		GetEngine() const							{ return mEngine; }
+
+	/// Get current engine state (writable interface, allows you to make changes to the configuration which will take effect the next time step)
+	VehicleEngine &				GetEngine()									{ return mEngine; }
+
+	/// Get current transmission state
+	const VehicleTransmission &	GetTransmission() const						{ return mTransmission; }
+
+	/// Get current transmission state (writable interface, allows you to make changes to the configuration which will take effect the next time step)
+	VehicleTransmission &		GetTransmission()							{ return mTransmission; }
+
+	/// Get the tracks this vehicle has
+	const VehicleTracks	&		GetTracks() const							{ return mTracks; }
+
+	/// Get the tracks this vehicle has (writable interface, allows you to make changes to the configuration which will take effect the next time step)
+	VehicleTracks &				GetTracks()									{ return mTracks; }
+
+#ifdef JPH_DEBUG_RENDERER
+	/// Debug drawing of RPM meter
+	void						SetRPMMeter(Vec3Arg inPosition, float inSize) { mRPMMeterPosition = inPosition; mRPMMeterSize = inSize; }
+#endif // JPH_DEBUG_RENDERER
+
+	// See: VehicleController
+	virtual Ref<VehicleControllerSettings> GetSettings() const override;
+
+protected:
+	/// Synchronize angular velocities of left and right tracks according to their ratios
+	void						SyncLeftRightTracks();
+
+	// See: VehicleController
+	virtual Wheel *				ConstructWheel(const WheelSettings &inWheel) const override { JPH_ASSERT(IsKindOf(&inWheel, JPH_RTTI(WheelSettingsTV))); return new WheelTV(static_cast<const WheelSettingsTV &>(inWheel)); }
+	virtual bool				AllowSleep() const override;
+	virtual void				PreCollide(float inDeltaTime, PhysicsSystem &inPhysicsSystem) override;
+	virtual void				PostCollide(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
+
+	// Control information
+	float						mForwardInput = 0.0f;						///< Value between -1 and 1 for auto transmission and value between 0 and 1 indicating desired driving direction and amount the gas pedal is pressed
+	float						mLeftRatio = 1.0f;							///< Value between -1 and 1 indicating an extra multiplier to the rotation rate of the left track (used for steering)
+	float						mRightRatio = 1.0f;							///< Value between -1 and 1 indicating an extra multiplier to the rotation rate of the right track (used for steering)
+	float						mBrakeInput = 0.0f;							///< Value between 0 and 1 indicating how strong the brake pedal is pressed
+
+	// Simulation information
+	VehicleEngine				mEngine;									///< Engine state of the vehicle
+	VehicleTransmission			mTransmission;								///< Transmission state of the vehicle
+	VehicleTracks				mTracks;									///< Tracks of the vehicle
+
+#ifdef JPH_DEBUG_RENDERER
+	// Debug settings
+	Vec3						mRPMMeterPosition { 0, 1, 0 };				///< Position (in local space of the body) of the RPM meter when drawing the constraint
+	float						mRPMMeterSize = 0.5f;						///< Size of the RPM meter when drawing the constraint
+#endif // JPH_DEBUG_RENDERER
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,33 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Vehicle/VehicleAntiRollBar.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(VehicleAntiRollBar)
+{
+	JPH_ADD_ATTRIBUTE(VehicleAntiRollBar, mLeftWheel)
+	JPH_ADD_ATTRIBUTE(VehicleAntiRollBar, mRightWheel)
+	JPH_ADD_ATTRIBUTE(VehicleAntiRollBar, mStiffness)
+}
+
+void VehicleAntiRollBar::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mLeftWheel);
+	inStream.Write(mRightWheel);
+	inStream.Write(mStiffness);
+}
+
+void VehicleAntiRollBar::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mLeftWheel);
+	inStream.Read(mRightWheel);
+	inStream.Read(mStiffness);
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,33 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <Jolt/ObjectStream/SerializableObject.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// An anti rollbar is a stiff spring that connects two wheels to reduce the amount of roll the vehicle makes in sharp corners
+/// See: https://en.wikipedia.org/wiki/Anti-roll_bar
+class JPH_EXPORT VehicleAntiRollBar
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, VehicleAntiRollBar)
+
+public:
+	/// Saves the contents in binary form to inStream.
+	void					SaveBinaryState(StreamOut &inStream) const;
+
+	/// Restores the contents in binary form to inStream.
+	void					RestoreBinaryState(StreamIn &inStream);
+
+	int						mLeftWheel = 0;								///< Index (in mWheels) that represents the left wheel of this anti-rollbar
+	int						mRightWheel = 1;							///< Index (in mWheels) that represents the right wheel of this anti-rollbar
+	float					mStiffness = 1000.0f;						///< Stiffness (spring constant in N/m) of anti rollbar, can be 0 to disable the anti-rollbar
+};
+
+using VehicleAntiRollBars = Array<VehicleAntiRollBar>;
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,376 @@
+// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
+// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
+// SPDX-License-Identifier: MIT
+
+#include <Jolt/Jolt.h>
+
+#include <Jolt/Physics/Vehicle/VehicleCollisionTester.h>
+#include <Jolt/Physics/Vehicle/VehicleConstraint.h>
+#include <Jolt/Physics/Collision/RayCast.h>
+#include <Jolt/Physics/Collision/ShapeCast.h>
+#include <Jolt/Physics/Collision/CastResult.h>
+#include <Jolt/Physics/Collision/Shape/SphereShape.h>
+#include <Jolt/Physics/Collision/Shape/CylinderShape.h>
+#include <Jolt/Physics/Collision/CollisionCollectorImpl.h>
+#include <Jolt/Physics/PhysicsSystem.h>
+
+JPH_NAMESPACE_BEGIN
+
+bool VehicleCollisionTesterRay::Collide(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&outBody, SubShapeID &outSubShapeID, RVec3 &outContactPosition, Vec3 &outContactNormal, float &outSuspensionLength) const
+{
+	const DefaultBroadPhaseLayerFilter default_broadphase_layer_filter = inPhysicsSystem.GetDefaultBroadPhaseLayerFilter(mObjectLayer);
+	const BroadPhaseLayerFilter &broadphase_layer_filter = mBroadPhaseLayerFilter != nullptr? *mBroadPhaseLayerFilter : default_broadphase_layer_filter;
+
+	const DefaultObjectLayerFilter default_object_layer_filter = inPhysicsSystem.GetDefaultLayerFilter(mObjectLayer);
+	const ObjectLayerFilter &object_layer_filter = mObjectLayerFilter != nullptr? *mObjectLayerFilter : default_object_layer_filter;
+
+	const IgnoreSingleBodyFilter default_body_filter(inVehicleBodyID);
+	const BodyFilter &body_filter = mBodyFilter != nullptr? *mBodyFilter : default_body_filter;
+
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float wheel_radius = wheel_settings->mRadius;
+	float ray_length = wheel_settings->mSuspensionMaxLength + wheel_radius;
+	RRayCast ray { inOrigin, ray_length * inDirection };
+
+	class MyCollector : public CastRayCollector
+	{
+	public:
+							MyCollector(PhysicsSystem &inPhysicsSystem, const RRayCast &inRay, Vec3Arg inUpDirection, float inCosMaxSlopeAngle) :
+			mPhysicsSystem(inPhysicsSystem),
+			mRay(inRay),
+			mUpDirection(inUpDirection),
+			mCosMaxSlopeAngle(inCosMaxSlopeAngle)
+		{
+		}
+
+		virtual void		AddHit(const RayCastResult &inResult) override
+		{
+			// Test if this collision is closer than the previous one
+			if (inResult.mFraction < GetEarlyOutFraction())
+			{
+				// Lock the body
+				BodyLockRead lock(mPhysicsSystem.GetBodyLockInterfaceNoLock(), inResult.mBodyID);
+				JPH_ASSERT(lock.Succeeded()); // When this runs all bodies are locked so this should not fail
+				const Body *body = &lock.GetBody();
+
+				if (body->IsSensor())
+					return;
+
+				// Test that we're not hitting a vertical wall
+				RVec3 contact_pos = mRay.GetPointOnRay(inResult.mFraction);
+				Vec3 normal = body->GetWorldSpaceSurfaceNormal(inResult.mSubShapeID2, contact_pos);
+				if (normal.Dot(mUpDirection) > mCosMaxSlopeAngle)
+				{
+					// Update early out fraction to this hit
+					UpdateEarlyOutFraction(inResult.mFraction);
+
+					// Get the contact properties
+					mBody = body;
+					mSubShapeID2 = inResult.mSubShapeID2;
+					mContactPosition = contact_pos;
+					mContactNormal = normal;
+				}
+			}
+		}
+
+		// Configuration
+		PhysicsSystem &		mPhysicsSystem;
+		RRayCast			mRay;
+		Vec3				mUpDirection;
+		float				mCosMaxSlopeAngle;
+
+		// Resulting closest collision
+		const Body *		mBody = nullptr;
+		SubShapeID			mSubShapeID2;
+		RVec3				mContactPosition;
+		Vec3				mContactNormal;
+	};
+
+	RayCastSettings settings;
+
+	MyCollector collector(inPhysicsSystem, ray, mUp, mCosMaxSlopeAngle);
+	inPhysicsSystem.GetNarrowPhaseQueryNoLock().CastRay(ray, settings, collector, broadphase_layer_filter, object_layer_filter, body_filter);
+	if (collector.mBody == nullptr)
+		return false;
+
+	outBody = const_cast<Body *>(collector.mBody);
+	outSubShapeID = collector.mSubShapeID2;
+	outContactPosition = collector.mContactPosition;
+	outContactNormal = collector.mContactNormal;
+	outSuspensionLength = max(0.0f, ray_length * collector.GetEarlyOutFraction() - wheel_radius);
+
+	return true;
+}
+
+void VehicleCollisionTesterRay::PredictContactProperties(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&ioBody, SubShapeID &ioSubShapeID, RVec3 &ioContactPosition, Vec3 &ioContactNormal, float &ioSuspensionLength) const
+{
+	// Recalculate the contact points assuming the contact point is on an infinite plane
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float d_dot_n = inDirection.Dot(ioContactNormal);
+	if (d_dot_n < -1.0e-6f)
+	{
+		// Reproject the contact position using the suspension ray and the plane formed by the contact position and normal
+		ioContactPosition = inOrigin + Vec3(ioContactPosition - inOrigin).Dot(ioContactNormal) / d_dot_n * inDirection;
+
+		// The suspension length is simply the distance between the contact position and the suspension origin excluding the wheel radius
+		ioSuspensionLength = Clamp(Vec3(ioContactPosition - inOrigin).Dot(inDirection) - wheel_settings->mRadius, 0.0f, wheel_settings->mSuspensionMaxLength);
+	}
+	else
+	{
+		// If the normal is pointing away we assume there's no collision anymore
+		ioSuspensionLength = wheel_settings->mSuspensionMaxLength;
+	}
+}
+
+bool VehicleCollisionTesterCastSphere::Collide(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&outBody, SubShapeID &outSubShapeID, RVec3 &outContactPosition, Vec3 &outContactNormal, float &outSuspensionLength) const
+{
+	const DefaultBroadPhaseLayerFilter default_broadphase_layer_filter = inPhysicsSystem.GetDefaultBroadPhaseLayerFilter(mObjectLayer);
+	const BroadPhaseLayerFilter &broadphase_layer_filter = mBroadPhaseLayerFilter != nullptr? *mBroadPhaseLayerFilter : default_broadphase_layer_filter;
+
+	const DefaultObjectLayerFilter default_object_layer_filter = inPhysicsSystem.GetDefaultLayerFilter(mObjectLayer);
+	const ObjectLayerFilter &object_layer_filter = mObjectLayerFilter != nullptr? *mObjectLayerFilter : default_object_layer_filter;
+
+	const IgnoreSingleBodyFilter default_body_filter(inVehicleBodyID);
+	const BodyFilter &body_filter = mBodyFilter != nullptr? *mBodyFilter : default_body_filter;
+
+	SphereShape sphere(mRadius);
+	sphere.SetEmbedded();
+
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float wheel_radius = wheel_settings->mRadius;
+	float shape_cast_length = wheel_settings->mSuspensionMaxLength + wheel_radius - mRadius;
+	RShapeCast shape_cast(&sphere, Vec3::sOne(), RMat44::sTranslation(inOrigin), inDirection * shape_cast_length);
+
+	ShapeCastSettings settings;
+	settings.mUseShrunkenShapeAndConvexRadius = true;
+	settings.mReturnDeepestPoint = true;
+
+	class MyCollector : public CastShapeCollector
+	{
+	public:
+							MyCollector(PhysicsSystem &inPhysicsSystem, const RShapeCast &inShapeCast, Vec3Arg inUpDirection, float inCosMaxSlopeAngle) :
+			mPhysicsSystem(inPhysicsSystem),
+			mShapeCast(inShapeCast),
+			mUpDirection(inUpDirection),
+			mCosMaxSlopeAngle(inCosMaxSlopeAngle)
+		{
+		}
+
+		virtual void		AddHit(const ShapeCastResult &inResult) override
+		{
+			// Test if this collision is closer/deeper than the previous one
+			float early_out = inResult.GetEarlyOutFraction();
+			if (early_out < GetEarlyOutFraction())
+			{
+				// Lock the body
+				BodyLockRead lock(mPhysicsSystem.GetBodyLockInterfaceNoLock(), inResult.mBodyID2);
+				JPH_ASSERT(lock.Succeeded()); // When this runs all bodies are locked so this should not fail
+				const Body *body = &lock.GetBody();
+
+				if (body->IsSensor())
+					return;
+
+				// Test that we're not hitting a vertical wall
+				Vec3 normal = -inResult.mPenetrationAxis.Normalized();
+				if (normal.Dot(mUpDirection) > mCosMaxSlopeAngle)
+				{
+					// Update early out fraction to this hit
+					UpdateEarlyOutFraction(early_out);
+
+					// Get the contact properties
+					mBody = body;
+					mSubShapeID2 = inResult.mSubShapeID2;
+					mContactPosition = mShapeCast.mCenterOfMassStart.GetTranslation() + inResult.mContactPointOn2;
+					mContactNormal = normal;
+					mFraction = inResult.mFraction;
+				}
+			}
+		}
+
+		// Configuration
+		PhysicsSystem &		mPhysicsSystem;
+		const RShapeCast &	mShapeCast;
+		Vec3				mUpDirection;
+		float				mCosMaxSlopeAngle;
+
+		// Resulting closest collision
+		const Body *		mBody = nullptr;
+		SubShapeID			mSubShapeID2;
+		RVec3				mContactPosition;
+		Vec3				mContactNormal;
+		float				mFraction;
+	};
+
+	MyCollector collector(inPhysicsSystem, shape_cast, mUp, mCosMaxSlopeAngle);
+	inPhysicsSystem.GetNarrowPhaseQueryNoLock().CastShape(shape_cast, settings, shape_cast.mCenterOfMassStart.GetTranslation(), collector, broadphase_layer_filter, object_layer_filter, body_filter);
+	if (collector.mBody == nullptr)
+		return false;
+
+	outBody = const_cast<Body *>(collector.mBody);
+	outSubShapeID = collector.mSubShapeID2;
+	outContactPosition = collector.mContactPosition;
+	outContactNormal = collector.mContactNormal;
+	outSuspensionLength = max(0.0f, shape_cast_length * collector.mFraction + mRadius - wheel_radius);
+
+	return true;
+}
+
+void VehicleCollisionTesterCastSphere::PredictContactProperties(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&ioBody, SubShapeID &ioSubShapeID, RVec3 &ioContactPosition, Vec3 &ioContactNormal, float &ioSuspensionLength) const
+{
+	// Recalculate the contact points assuming the contact point is on an infinite plane
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float d_dot_n = inDirection.Dot(ioContactNormal);
+	if (d_dot_n < -1.0e-6f)
+	{
+		// Reproject the contact position using the suspension cast sphere and the plane formed by the contact position and normal
+		// This solves x = inOrigin + fraction * inDirection and (x - ioContactPosition) . ioContactNormal = mRadius for fraction
+		float oc_dot_n = Vec3(ioContactPosition - inOrigin).Dot(ioContactNormal);
+		float fraction = (mRadius + oc_dot_n) / d_dot_n;
+		ioContactPosition = inOrigin + fraction * inDirection - mRadius * ioContactNormal;
+
+		// Calculate the new suspension length in the same way as the cast sphere normally does
+		ioSuspensionLength = Clamp(fraction + mRadius - wheel_settings->mRadius, 0.0f, wheel_settings->mSuspensionMaxLength);
+	}
+	else
+	{
+		// If the normal is pointing away we assume there's no collision anymore
+		ioSuspensionLength = wheel_settings->mSuspensionMaxLength;
+	}
+}
+
+bool VehicleCollisionTesterCastCylinder::Collide(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&outBody, SubShapeID &outSubShapeID, RVec3 &outContactPosition, Vec3 &outContactNormal, float &outSuspensionLength) const
+{
+	const DefaultBroadPhaseLayerFilter default_broadphase_layer_filter = inPhysicsSystem.GetDefaultBroadPhaseLayerFilter(mObjectLayer);
+	const BroadPhaseLayerFilter &broadphase_layer_filter = mBroadPhaseLayerFilter != nullptr? *mBroadPhaseLayerFilter : default_broadphase_layer_filter;
+
+	const DefaultObjectLayerFilter default_object_layer_filter = inPhysicsSystem.GetDefaultLayerFilter(mObjectLayer);
+	const ObjectLayerFilter &object_layer_filter = mObjectLayerFilter != nullptr? *mObjectLayerFilter : default_object_layer_filter;
+
+	const IgnoreSingleBodyFilter default_body_filter(inVehicleBodyID);
+	const BodyFilter &body_filter = mBodyFilter != nullptr? *mBodyFilter : default_body_filter;
+
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float max_suspension_length = wheel_settings->mSuspensionMaxLength;
+
+	// Get the wheel transform given that the cylinder rotates around the Y axis
+	RMat44 shape_cast_start = inVehicleConstraint.GetWheelWorldTransform(inWheelIndex, Vec3::sAxisY(), Vec3::sAxisX());
+	shape_cast_start.SetTranslation(inOrigin);
+
+	// Construct a cylinder with the dimensions of the wheel
+	float wheel_half_width = 0.5f * wheel_settings->mWidth;
+	CylinderShape cylinder(wheel_half_width, wheel_settings->mRadius, min(wheel_half_width, wheel_settings->mRadius) * mConvexRadiusFraction);
+	cylinder.SetEmbedded();
+
+	RShapeCast shape_cast(&cylinder, Vec3::sOne(), shape_cast_start, inDirection * max_suspension_length);
+
+	ShapeCastSettings settings;
+	settings.mUseShrunkenShapeAndConvexRadius = true;
+	settings.mReturnDeepestPoint = true;
+
+	class MyCollector : public CastShapeCollector
+	{
+	public:
+							MyCollector(PhysicsSystem &inPhysicsSystem, const RShapeCast &inShapeCast) :
+			mPhysicsSystem(inPhysicsSystem),
+			mShapeCast(inShapeCast)
+		{
+		}
+
+		virtual void		AddHit(const ShapeCastResult &inResult) override
+		{
+			// Test if this collision is closer/deeper than the previous one
+			float early_out = inResult.GetEarlyOutFraction();
+			if (early_out < GetEarlyOutFraction())
+			{
+				// Lock the body
+				BodyLockRead lock(mPhysicsSystem.GetBodyLockInterfaceNoLock(), inResult.mBodyID2);
+				JPH_ASSERT(lock.Succeeded()); // When this runs all bodies are locked so this should not fail
+				const Body *body = &lock.GetBody();
+
+				if (body->IsSensor())
+					return;
+
+				// Update early out fraction to this hit
+				UpdateEarlyOutFraction(early_out);
+
+				// Get the contact properties
+				mBody = body;
+				mSubShapeID2 = inResult.mSubShapeID2;
+				mContactPosition = mShapeCast.mCenterOfMassStart.GetTranslation() + inResult.mContactPointOn2;
+				mContactNormal = -inResult.mPenetrationAxis.Normalized();
+				mFraction = inResult.mFraction;
+			}
+		}
+
+		// Configuration
+		PhysicsSystem &		mPhysicsSystem;
+		const RShapeCast &	mShapeCast;
+
+		// Resulting closest collision
+		const Body *		mBody = nullptr;
+		SubShapeID			mSubShapeID2;
+		RVec3				mContactPosition;
+		Vec3				mContactNormal;
+		float				mFraction;
+	};
+
+	MyCollector collector(inPhysicsSystem, shape_cast);
+	inPhysicsSystem.GetNarrowPhaseQueryNoLock().CastShape(shape_cast, settings, shape_cast.mCenterOfMassStart.GetTranslation(), collector, broadphase_layer_filter, object_layer_filter, body_filter);
+	if (collector.mBody == nullptr)
+		return false;
+
+	outBody = const_cast<Body *>(collector.mBody);
+	outSubShapeID = collector.mSubShapeID2;
+	outContactPosition = collector.mContactPosition;
+	outContactNormal = collector.mContactNormal;
+	outSuspensionLength = max_suspension_length * collector.mFraction;
+
+	return true;
+}
+
+void VehicleCollisionTesterCastCylinder::PredictContactProperties(PhysicsSystem &inPhysicsSystem, const VehicleConstraint &inVehicleConstraint, uint inWheelIndex, RVec3Arg inOrigin, Vec3Arg inDirection, const BodyID &inVehicleBodyID, Body *&ioBody, SubShapeID &ioSubShapeID, RVec3 &ioContactPosition, Vec3 &ioContactNormal, float &ioSuspensionLength) const
+{
+	// Recalculate the contact points assuming the contact point is on an infinite plane
+	const WheelSettings *wheel_settings = inVehicleConstraint.GetWheel(inWheelIndex)->GetSettings();
+	float d_dot_n = inDirection.Dot(ioContactNormal);
+	if (d_dot_n < -1.0e-6f)
+	{
+		// Wheel size
+		float half_width = 0.5f * wheel_settings->mWidth;
+		float radius = wheel_settings->mRadius;
+
+		// Get the inverse local space contact normal for a cylinder pointing along Y
+		RMat44 wheel_transform = inVehicleConstraint.GetWheelWorldTransform(inWheelIndex, Vec3::sAxisY(), Vec3::sAxisX());
+		Vec3 inverse_local_normal = -wheel_transform.Multiply3x3Transposed(ioContactNormal);
+
+		// Get the support point of this normal in local space of the cylinder
+		// See CylinderShape::Cylinder::GetSupport
+		float x = inverse_local_normal.GetX(), y = inverse_local_normal.GetY(), z = inverse_local_normal.GetZ();
+		float o = sqrt(Square(x) + Square(z));
+		Vec3 support_point;
+		if (o > 0.0f)
+			support_point = Vec3((radius * x) / o, Sign(y) * half_width, (radius * z) / o);
+		else
+			support_point = Vec3(0, Sign(y) * half_width, 0);
+
+		// Rotate back to world space
+		support_point = wheel_transform.Multiply3x3(support_point);
+
+		// Now we can use inOrigin + support_point as the start of a ray of our suspension to the contact plane
+		// as know that it is the first point on the wheel that will hit the plane
+		RVec3 origin = inOrigin + support_point;
+
+		// Calculate contact position and suspension length, the is the same as VehicleCollisionTesterRay
+		// but we don't need to take the radius into account anymore
+		Vec3 oc(ioContactPosition - origin);
+		ioContactPosition = origin + oc.Dot(ioContactNormal) / d_dot_n * inDirection;
+		ioSuspensionLength = Clamp(oc.Dot(inDirection), 0.0f, wheel_settings->mSuspensionMaxLength);
+	}
+	else
+	{
+		// If the normal is pointing away we assume there's no collision anymore
+		ioSuspensionLength = wheel_settings->mSuspensionMaxLength;
+	}
+}
+
+JPH_NAMESPACE_END