@bloomengine/engine 0.3.1

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

@@ -0,0 +1,93 @@
+// 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/LinearCurve.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+#include <Jolt/Physics/StateRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+#ifdef JPH_DEBUG_RENDERER
+	class DebugRenderer;
+#endif // JPH_DEBUG_RENDERER
+
+/// Generic properties for a vehicle engine
+class JPH_EXPORT VehicleEngineSettings
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, VehicleEngineSettings)
+
+public:
+	/// Constructor
+							VehicleEngineSettings();
+
+	/// 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);
+
+	float					mMaxTorque = 500.0f;						///< Max amount of torque (Nm) that the engine can deliver
+	float					mMinRPM = 1000.0f;							///< Min amount of revolutions per minute (rpm) the engine can produce without stalling
+	float					mMaxRPM = 6000.0f;							///< Max amount of revolutions per minute (rpm) the engine can generate
+	LinearCurve				mNormalizedTorque;							///< Y-axis: Curve that describes a ratio of the max torque the engine can produce (0 = 0, 1 = mMaxTorque). X-axis: the fraction of the RPM of the engine (0 = mMinRPM, 1 = mMaxRPM)
+	float					mInertia = 0.5f;							///< Moment of inertia (kg m^2) of the engine
+	float					mAngularDamping = 0.2f;						///< Angular damping factor of the wheel: dw/dt = -c * w. Value should be zero or positive and is usually close to 0.
+};
+
+/// Runtime data for engine
+class JPH_EXPORT VehicleEngine : public VehicleEngineSettings
+{
+public:
+	/// Multiply an angular velocity (rad/s) with this value to get rounds per minute (RPM)
+	static constexpr float	cAngularVelocityToRPM = 60.0f / (2.0f * JPH_PI);
+
+	/// Clamp the RPM between min and max RPM
+	inline void				ClampRPM()									{ mCurrentRPM = Clamp(mCurrentRPM, mMinRPM, mMaxRPM); }
+
+	/// Current rotation speed of engine in rounds per minute
+	float					GetCurrentRPM() const						{ return mCurrentRPM; }
+
+	/// Update rotation speed of engine in rounds per minute
+	void					SetCurrentRPM(float inRPM)					{ mCurrentRPM = inRPM; ClampRPM(); }
+
+	/// Get current angular velocity of the engine in radians / second
+	inline float			GetAngularVelocity() const					{ return mCurrentRPM / cAngularVelocityToRPM; }
+
+	/// Get the amount of torque (N m) that the engine can supply
+	/// @param inAcceleration How much the gas pedal is pressed [0, 1]
+	float					GetTorque(float inAcceleration) const		{ return inAcceleration * mMaxTorque * mNormalizedTorque.GetValue(mCurrentRPM / mMaxRPM); }
+
+	/// Apply a torque to the engine rotation speed
+	/// @param inTorque Torque in N m
+	/// @param inDeltaTime Delta time in seconds
+	void					ApplyTorque(float inTorque, float inDeltaTime);
+
+	/// Update the engine RPM for damping
+	/// @param inDeltaTime Delta time in seconds
+	void					ApplyDamping(float inDeltaTime);
+
+#ifdef JPH_DEBUG_RENDERER
+	// Function that converts RPM to an angle in radians for debugging purposes
+	float					ConvertRPMToAngle(float inRPM) const		{ return (-0.75f + 1.5f * inRPM / mMaxRPM) * JPH_PI; }
+
+	/// Debug draw a RPM meter
+	void					DrawRPM(DebugRenderer *inRenderer, RVec3Arg inPosition, Vec3Arg inForward, Vec3Arg inUp, float inSize, float inShiftDownRPM, float inShiftUpRPM) const;
+#endif // JPH_DEBUG_RENDERER
+
+	/// If the engine is idle we allow the vehicle to sleep
+	bool					AllowSleep() const							{ return mCurrentRPM <= 1.01f * mMinRPM; }
+
+	/// Saving state for replay
+	void					SaveState(StateRecorder &inStream) const;
+	void					RestoreState(StateRecorder &inStream);
+
+private:
+	float					mCurrentRPM = mMinRPM;						///< Current rotation speed of engine in rounds per minute
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,52 @@
+// 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/VehicleTrack.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(VehicleTrackSettings)
+{
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mDrivenWheel)
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mWheels)
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mInertia)
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mAngularDamping)
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mMaxBrakeTorque)
+	JPH_ADD_ATTRIBUTE(VehicleTrackSettings, mDifferentialRatio)
+}
+
+void VehicleTrackSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mDrivenWheel);
+	inStream.Write(mWheels);
+	inStream.Write(mInertia);
+	inStream.Write(mAngularDamping);
+	inStream.Write(mMaxBrakeTorque);
+	inStream.Write(mDifferentialRatio);
+}
+
+void VehicleTrackSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mDrivenWheel);
+	inStream.Read(mWheels);
+	inStream.Read(mInertia);
+	inStream.Read(mAngularDamping);
+	inStream.Read(mMaxBrakeTorque);
+	inStream.Read(mDifferentialRatio);
+}
+
+void VehicleTrack::SaveState(StateRecorder &inStream) const
+{
+	inStream.Write(mAngularVelocity);
+}
+
+void VehicleTrack::RestoreState(StateRecorder &inStream)
+{
+	inStream.Read(mAngularVelocity);
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,56 @@
+// 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/LinearCurve.h>
+#include <Jolt/Core/StreamIn.h>
+#include <Jolt/Core/StreamOut.h>
+#include <Jolt/Physics/StateRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// On which side of the vehicle the track is located (for steering)
+enum class ETrackSide : uint
+{
+	Left = 0,
+	Right = 1,
+	Num = 2
+};
+
+/// Generic properties for tank tracks
+class JPH_EXPORT VehicleTrackSettings
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, VehicleTrackSettings)
+
+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);
+
+	uint					mDrivenWheel;								///< Which wheel on the track is connected to the engine
+	Array<uint>				mWheels;									///< Indices of wheels that are inside this track, should include the driven wheel too
+	float					mInertia = 10.0f;							///< Moment of inertia (kg m^2) of the track and its wheels as seen on the driven wheel
+	float					mAngularDamping = 0.5f;						///< Damping factor of track and its wheels: dw/dt = -c * w as seen on the driven wheel
+	float					mMaxBrakeTorque = 15000.0f;					///< How much torque (Nm) the brakes can apply on the driven wheel
+	float					mDifferentialRatio = 6.0f;					///< Ratio between rotation speed of gear box and driven wheel of track
+};
+
+/// Runtime data for tank tracks
+class JPH_EXPORT VehicleTrack : public VehicleTrackSettings
+{
+public:
+	/// Saving state for replay
+	void					SaveState(StateRecorder &inStream) const;
+	void					RestoreState(StateRecorder &inStream);
+
+	float					mAngularVelocity = 0.0f;					///< Angular velocity of the driven wheel, will determine the speed of the entire track
+};
+
+using VehicleTracks = VehicleTrack[(int)ETrackSide::Num];
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,159 @@
+// 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/VehicleTransmission.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_NON_VIRTUAL(VehicleTransmissionSettings)
+{
+	JPH_ADD_ENUM_ATTRIBUTE(VehicleTransmissionSettings, mMode)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mGearRatios)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mReverseGearRatios)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mSwitchTime)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mClutchReleaseTime)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mSwitchLatency)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mShiftUpRPM)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mShiftDownRPM)
+	JPH_ADD_ATTRIBUTE(VehicleTransmissionSettings, mClutchStrength)
+}
+
+void VehicleTransmissionSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mMode);
+	inStream.Write(mGearRatios);
+	inStream.Write(mReverseGearRatios);
+	inStream.Write(mSwitchTime);
+	inStream.Write(mClutchReleaseTime);
+	inStream.Write(mSwitchLatency);
+	inStream.Write(mShiftUpRPM);
+	inStream.Write(mShiftDownRPM);
+	inStream.Write(mClutchStrength);
+}
+
+void VehicleTransmissionSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mMode);
+	inStream.Read(mGearRatios);
+	inStream.Read(mReverseGearRatios);
+	inStream.Read(mSwitchTime);
+	inStream.Read(mClutchReleaseTime);
+	inStream.Read(mSwitchLatency);
+	inStream.Read(mShiftUpRPM);
+	inStream.Read(mShiftDownRPM);
+	inStream.Read(mClutchStrength);
+}
+
+void VehicleTransmission::Update(float inDeltaTime, float inCurrentRPM, float inForwardInput, bool inCanShiftUp)
+{
+	// Update current gear and calculate clutch friction
+	if (mMode == ETransmissionMode::Auto)
+	{
+		// Switch gears based on rpm
+		int old_gear = mCurrentGear;
+		if (mCurrentGear == 0 // In neutral
+			|| inForwardInput * float(mCurrentGear) < 0.0f) // Changing between forward / reverse
+		{
+			// Switch to first gear or reverse depending on input
+			mCurrentGear = inForwardInput > 0.0f? 1 : (inForwardInput < 0.0f? -1 : 0);
+		}
+		else if (mGearSwitchLatencyTimeLeft == 0.0f) // If not in the timout after switching gears
+		{
+			if (inCanShiftUp && inCurrentRPM > mShiftUpRPM)
+			{
+				if (mCurrentGear < 0)
+				{
+					// Shift up, reverse
+					if (mCurrentGear > -(int)mReverseGearRatios.size())
+						mCurrentGear--;
+				}
+				else
+				{
+					// Shift up, forward
+					if (mCurrentGear < (int)mGearRatios.size())
+						mCurrentGear++;
+				}
+			}
+			else if (inCurrentRPM < mShiftDownRPM)
+			{
+				if (mCurrentGear < 0)
+				{
+					// Shift down, reverse
+					int max_gear = inForwardInput != 0.0f? -1 : 0;
+					if (mCurrentGear < max_gear)
+						mCurrentGear++;
+				}
+				else
+				{
+					// Shift down, forward
+					int min_gear = inForwardInput != 0.0f? 1 : 0;
+					if (mCurrentGear > min_gear)
+						mCurrentGear--;
+				}
+			}
+		}
+
+		if (old_gear != mCurrentGear)
+		{
+			// We've shifted gear, start switch countdown
+			mGearSwitchTimeLeft = old_gear != 0? mSwitchTime : 0.0f;
+			mClutchReleaseTimeLeft = mClutchReleaseTime;
+			mGearSwitchLatencyTimeLeft = mSwitchLatency;
+			mClutchFriction = 0.0f;
+		}
+		else if (mGearSwitchTimeLeft > 0.0f)
+		{
+			// If still switching gears, count down
+			mGearSwitchTimeLeft = max(0.0f, mGearSwitchTimeLeft - inDeltaTime);
+			mClutchFriction = 0.0f;
+		}
+		else if (mClutchReleaseTimeLeft > 0.0f)
+		{
+			// After switching the gears we slowly release the clutch
+			mClutchReleaseTimeLeft = max(0.0f, mClutchReleaseTimeLeft - inDeltaTime);
+			mClutchFriction = 1.0f - mClutchReleaseTimeLeft / mClutchReleaseTime;
+		}
+		else
+		{
+			// Clutch has full friction
+			mClutchFriction = 1.0f;
+
+			// Count down switch latency
+			mGearSwitchLatencyTimeLeft = max(0.0f, mGearSwitchLatencyTimeLeft - inDeltaTime);
+		}
+	}
+}
+
+float VehicleTransmission::GetCurrentRatio() const
+{
+	if (mCurrentGear < 0)
+		return mReverseGearRatios[-mCurrentGear - 1];
+	else if (mCurrentGear == 0)
+		return 0.0f;
+	else
+		return mGearRatios[mCurrentGear - 1];
+}
+
+void VehicleTransmission::SaveState(StateRecorder &inStream) const
+{
+	inStream.Write(mCurrentGear);
+	inStream.Write(mClutchFriction);
+	inStream.Write(mGearSwitchTimeLeft);
+	inStream.Write(mClutchReleaseTimeLeft);
+	inStream.Write(mGearSwitchLatencyTimeLeft);
+}
+
+void VehicleTransmission::RestoreState(StateRecorder &inStream)
+{
+	inStream.Read(mCurrentGear);
+	inStream.Read(mClutchFriction);
+	inStream.Read(mGearSwitchTimeLeft);
+	inStream.Read(mClutchReleaseTimeLeft);
+	inStream.Read(mGearSwitchLatencyTimeLeft);
+}
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,87 @@
+// 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>
+#include <Jolt/Physics/StateRecorder.h>
+
+JPH_NAMESPACE_BEGIN
+
+/// How gears are shifted
+enum class ETransmissionMode : uint8
+{
+	Auto,																///< Automatically shift gear up and down
+	Manual,																///< Manual gear shift (call SetTransmissionInput)
+};
+
+/// Configuration for the transmission of a vehicle (gear box)
+class JPH_EXPORT VehicleTransmissionSettings
+{
+	JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, VehicleTransmissionSettings)
+
+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);
+
+	ETransmissionMode		mMode = ETransmissionMode::Auto;			///< How to switch gears
+	Array<float>			mGearRatios { 2.66f, 1.78f, 1.3f, 1.0f, 0.74f }; ///< Ratio in rotation rate between engine and gear box, first element is 1st gear, 2nd element 2nd gear etc.
+	Array<float>			mReverseGearRatios { -2.90f };				///< Ratio in rotation rate between engine and gear box when driving in reverse
+	float					mSwitchTime = 0.5f;							///< How long it takes to switch gears (s), only used in auto mode
+	float					mClutchReleaseTime = 0.3f;					///< How long it takes to release the clutch (go to full friction), only used in auto mode
+	float					mSwitchLatency = 0.5f;						///< How long to wait after releasing the clutch before another switch is attempted (s), only used in auto mode
+	float					mShiftUpRPM = 4000.0f;						///< If RPM of engine is bigger then this we will shift a gear up, only used in auto mode
+	float					mShiftDownRPM = 2000.0f;					///< If RPM of engine is smaller then this we will shift a gear down, only used in auto mode
+	float					mClutchStrength = 10.0f;					///< Strength of the clutch when fully engaged. Total torque a clutch applies is Torque = ClutchStrength * (Velocity Engine - Avg Velocity Wheels At Clutch) (units: k m^2 s^-1)
+};
+
+/// Runtime data for transmission
+class JPH_EXPORT VehicleTransmission : public VehicleTransmissionSettings
+{
+public:
+	/// Set input from driver regarding the transmission (only relevant when transmission is set to manual mode)
+	/// @param inCurrentGear Current gear, -1 = reverse, 0 = neutral, 1 = 1st gear etc.
+	/// @param inClutchFriction Value between 0 and 1 indicating how much friction the clutch gives (0 = no friction, 1 = full friction)
+	void					Set(int inCurrentGear, float inClutchFriction) { mCurrentGear = inCurrentGear; mClutchFriction = inClutchFriction; }
+
+	/// Update the current gear and clutch friction if the transmission is in auto mode
+	/// @param inDeltaTime Time step delta time in s
+	/// @param inCurrentRPM Current RPM for engine
+	/// @param inForwardInput Hint if the user wants to drive forward (> 0) or backwards (< 0)
+	/// @param inCanShiftUp Indicates if we want to allow the transmission to shift up (e.g. pass false if wheels are slipping)
+	void					Update(float inDeltaTime, float inCurrentRPM, float inForwardInput, bool inCanShiftUp);
+
+	/// Current gear, -1 = reverse, 0 = neutral, 1 = 1st gear etc.
+	int						GetCurrentGear() const						{ return mCurrentGear; }
+
+	/// Value between 0 and 1 indicating how much friction the clutch gives (0 = no friction, 1 = full friction)
+	float					GetClutchFriction() const					{ return mClutchFriction; }
+
+	/// If the auto box is currently switching gears
+	bool					IsSwitchingGear() const						{ return mGearSwitchTimeLeft > 0.0f; }
+
+	/// Return the transmission ratio based on the current gear (ratio between engine and differential)
+	float					GetCurrentRatio() const;
+
+	/// Only allow sleeping when the transmission is idle
+	bool					AllowSleep() const							{ return mGearSwitchTimeLeft <= 0.0f && mClutchReleaseTimeLeft <= 0.0f && mGearSwitchLatencyTimeLeft <= 0.0f; }
+
+	/// Saving state for replay
+	void					SaveState(StateRecorder &inStream) const;
+	void					RestoreState(StateRecorder &inStream);
+
+private:
+	int						mCurrentGear = 0;							///< Current gear, -1 = reverse, 0 = neutral, 1 = 1st gear etc.
+	float					mClutchFriction = 1.0f;						///< Value between 0 and 1 indicating how much friction the clutch gives (0 = no friction, 1 = full friction)
+	float					mGearSwitchTimeLeft = 0.0f;					///< When switching gears this will be > 0 and will cause the engine to not provide any torque to the wheels for a short time (used for automatic gear switching only)
+	float					mClutchReleaseTimeLeft = 0.0f;				///< After switching gears this will be > 0 and will cause the clutch friction to go from 0 to 1 (used for automatic gear switching only)
+	float					mGearSwitchLatencyTimeLeft = 0.0f;			///< After releasing the clutch this will be > 0 and will prevent another gear switch (used for automatic gear switching only)
+};
+
+JPH_NAMESPACE_END

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

@@ -0,0 +1,93 @@
+// 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/Wheel.h>
+#include <Jolt/Physics/Vehicle/VehicleConstraint.h>
+#include <Jolt/ObjectStream/TypeDeclarations.h>
+
+JPH_NAMESPACE_BEGIN
+
+JPH_IMPLEMENT_SERIALIZABLE_VIRTUAL(WheelSettings)
+{
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSuspensionForcePoint)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mPosition)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSuspensionDirection)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSteeringAxis)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mWheelForward)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mWheelUp)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSuspensionMinLength)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSuspensionMaxLength)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mSuspensionPreloadLength)
+	JPH_ADD_ENUM_ATTRIBUTE_WITH_ALIAS(WheelSettings, mSuspensionSpring.mMode, "mSuspensionSpringMode")
+	JPH_ADD_ATTRIBUTE_WITH_ALIAS(WheelSettings, mSuspensionSpring.mFrequency, "mSuspensionFrequency") // Renaming attributes to stay compatible with old versions of the library
+	JPH_ADD_ATTRIBUTE_WITH_ALIAS(WheelSettings, mSuspensionSpring.mDamping, "mSuspensionDamping")
+	JPH_ADD_ATTRIBUTE(WheelSettings, mRadius)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mWidth)
+	JPH_ADD_ATTRIBUTE(WheelSettings, mEnableSuspensionForcePoint)
+}
+
+void WheelSettings::SaveBinaryState(StreamOut &inStream) const
+{
+	inStream.Write(mSuspensionForcePoint);
+	inStream.Write(mPosition);
+	inStream.Write(mSuspensionDirection);
+	inStream.Write(mSteeringAxis);
+	inStream.Write(mWheelForward);
+	inStream.Write(mWheelUp);
+	inStream.Write(mSuspensionMinLength);
+	inStream.Write(mSuspensionMaxLength);
+	inStream.Write(mSuspensionPreloadLength);
+	mSuspensionSpring.SaveBinaryState(inStream);
+	inStream.Write(mRadius);
+	inStream.Write(mWidth);
+	inStream.Write(mEnableSuspensionForcePoint);
+}
+
+void WheelSettings::RestoreBinaryState(StreamIn &inStream)
+{
+	inStream.Read(mSuspensionForcePoint);
+	inStream.Read(mPosition);
+	inStream.Read(mSuspensionDirection);
+	inStream.Read(mSteeringAxis);
+	inStream.Read(mWheelForward);
+	inStream.Read(mWheelUp);
+	inStream.Read(mSuspensionMinLength);
+	inStream.Read(mSuspensionMaxLength);
+	inStream.Read(mSuspensionPreloadLength);
+	mSuspensionSpring.RestoreBinaryState(inStream);
+	inStream.Read(mRadius);
+	inStream.Read(mWidth);
+	inStream.Read(mEnableSuspensionForcePoint);
+}
+
+Wheel::Wheel(const WheelSettings &inSettings) :
+	mSettings(&inSettings),
+	mSuspensionLength(inSettings.mSuspensionMaxLength)
+{
+	JPH_ASSERT(inSettings.mSuspensionDirection.IsNormalized());
+	JPH_ASSERT(inSettings.mSteeringAxis.IsNormalized());
+	JPH_ASSERT(inSettings.mWheelForward.IsNormalized());
+	JPH_ASSERT(inSettings.mWheelUp.IsNormalized());
+	JPH_ASSERT(inSettings.mSuspensionMinLength >= 0.0f);
+	JPH_ASSERT(inSettings.mSuspensionMaxLength >= inSettings.mSuspensionMinLength);
+	JPH_ASSERT(inSettings.mSuspensionPreloadLength >= 0.0f);
+	JPH_ASSERT(inSettings.mSuspensionSpring.mFrequency > 0.0f);
+	JPH_ASSERT(inSettings.mSuspensionSpring.mDamping >= 0.0f);
+	JPH_ASSERT(inSettings.mRadius > 0.0f);
+	JPH_ASSERT(inSettings.mWidth >= 0.0f);
+}
+
+bool Wheel::SolveLongitudinalConstraintPart(const VehicleConstraint &inConstraint, float inMinImpulse, float inMaxImpulse)
+{
+	return mLongitudinalPart.SolveVelocityConstraint(*inConstraint.GetVehicleBody(), *mContactBody, -mContactLongitudinal, inMinImpulse, inMaxImpulse);
+}
+
+bool Wheel::SolveLateralConstraintPart(const VehicleConstraint &inConstraint, float inMinImpulse, float inMaxImpulse)
+{
+	return mLateralPart.SolveVelocityConstraint(*inConstraint.GetVehicleBody(), *mContactBody, -mContactLateral, inMinImpulse, inMaxImpulse);
+}
+
+JPH_NAMESPACE_END