WheeledVehicleController.h

Go to the documentation of this file.

// 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/VehicleDifferential.h>
#include <Jolt/Core/LinearCurve.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;

class JPH_EXPORT WheelSettingsWV : public WheelSettings
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, WheelSettingsWV)
 
public:
                                WheelSettingsWV();
 
    // See: WheelSettings
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
    virtual void                RestoreBinaryState(StreamIn &inStream) override;
 
    float                       mInertia = 0.9f;                            
    float                       mAngularDamping = 0.2f;                     
    float                       mMaxSteerAngle = DegreesToRadians(70.0f);   
    LinearCurve                 mLongitudinalFriction;                      
    LinearCurve                 mLateralFriction;                           
    float                       mMaxBrakeTorque = 1500.0f;                  
    float                       mMaxHandBrakeTorque = 4000.0f;              
};

class JPH_EXPORT WheelWV : public Wheel
{
public:
    JPH_OVERRIDE_NEW_DELETE

    explicit                    WheelWV(const WheelSettingsWV &inWheel);

    const WheelSettingsWV *     GetSettings() const                         { return StaticCast<WheelSettingsWV>(mSettings); }

    void                        ApplyTorque(float inTorque, float inDeltaTime)
    {
        mAngularVelocity += inTorque * inDeltaTime / GetSettings()->mInertia;
    }

    void                        Update(uint inWheelIndex, float inDeltaTime, const VehicleConstraint &inConstraint);
 
    float                       mLongitudinalSlip = 0.0f;                   
    float                       mLateralSlip = 0.0f;                        
    float                       mCombinedLongitudinalFriction = 0.0f;       
    float                       mCombinedLateralFriction = 0.0f;            
    float                       mBrakeImpulse = 0.0f;                       
};

class JPH_EXPORT WheeledVehicleControllerSettings : public VehicleControllerSettings
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, WheeledVehicleControllerSettings)
 
public:
    // See: VehicleControllerSettings
    virtual VehicleController * ConstructController(VehicleConstraint &inConstraint) const override;
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
    virtual void                RestoreBinaryState(StreamIn &inStream) override;
 
    VehicleEngineSettings       mEngine;                                    
    VehicleTransmissionSettings mTransmission;                              
    Array<VehicleDifferentialSettings> mDifferentials;                      
    float                       mDifferentialLimitedSlipRatio = 1.4f;       
};

class JPH_EXPORT WheeledVehicleController : public VehicleController
{
public:
    JPH_OVERRIDE_NEW_DELETE

                                WheeledVehicleController(const WheeledVehicleControllerSettings &inSettings, VehicleConstraint &inConstraint);

    using Differentials = Array<VehicleDifferentialSettings>;

    void                        SetDriverInput(float inForward, float inRight, float inBrake, float inHandBrake) { mForwardInput = inForward; mRightInput = inRight; mBrakeInput = inBrake; mHandBrakeInput = inHandBrake; }

    void                        SetForwardInput(float inForward)            { mForwardInput = inForward; }
    float                       GetForwardInput() const                     { return mForwardInput; }

    void                        SetRightInput(float inRight)                { mRightInput = inRight; }
    float                       GetRightInput() const                       { return mRightInput; }

    void                        SetBrakeInput(float inBrake)                { mBrakeInput = inBrake; }
    float                       GetBrakeInput() const                       { return mBrakeInput; }

    void                        SetHandBrakeInput(float inHandBrake)        { mHandBrakeInput = inHandBrake; }
    float                       GetHandBrakeInput() const                   { return mHandBrakeInput; }

    const VehicleEngine &       GetEngine() const                           { return mEngine; }

    VehicleEngine &             GetEngine()                                 { return mEngine; }

    const VehicleTransmission & GetTransmission() const                     { return mTransmission; }

    VehicleTransmission &       GetTransmission()                           { return mTransmission; }

    const Differentials &       GetDifferentials() const                    { return mDifferentials; }

    Differentials &             GetDifferentials()                          { return mDifferentials; }

    float                       GetDifferentialLimitedSlipRatio() const     { return mDifferentialLimitedSlipRatio; }
    void                        SetDifferentialLimitedSlipRatio(float inV)  { mDifferentialLimitedSlipRatio = inV; }

    float                       GetWheelSpeedAtClutch() const;

    using TireMaxImpulseCallback = function<void(uint inWheelIndex, float &outLongitudinalImpulse, float &outLateralImpulse, float inSuspensionImpulse, float inLongitudinalFriction, float inLateralFriction, float inLongitudinalSlip, float inLateralSlip, float inDeltaTime)>;
    const TireMaxImpulseCallback&GetTireMaxImpulseCallback() const          { return mTireMaxImpulseCallback; }
    void                        SetTireMaxImpulseCallback(const TireMaxImpulseCallback &inTireMaxImpulseCallback)   { mTireMaxImpulseCallback = inTireMaxImpulseCallback; }
 
#ifdef JPH_DEBUG_RENDERER
    void                        SetRPMMeter(Vec3Arg inPosition, float inSize) { mRPMMeterPosition = inPosition; mRPMMeterSize = inSize; }
#endif // JPH_DEBUG_RENDERER
 
    // See: VehicleController
    virtual Ref<VehicleControllerSettings> GetSettings() const override;
 
protected:
    void                        ToSettings(WheeledVehicleControllerSettings &outSettings) const;
 
    // See: VehicleController
    virtual Wheel *             ConstructWheel(const WheelSettings &inWheel) const override { JPH_ASSERT(IsKindOf(&inWheel, JPH_RTTI(WheelSettingsWV))); return new WheelWV(static_cast<const WheelSettingsWV &>(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;                       
    float                       mRightInput = 0.0f;                         
    float                       mBrakeInput = 0.0f;                         
    float                       mHandBrakeInput = 0.0f;                     
 
    // Simulation information
    VehicleEngine               mEngine;                                    
    VehicleTransmission         mTransmission;                              
    Differentials               mDifferentials;                             
    float                       mDifferentialLimitedSlipRatio;              
    float                       mPreviousDeltaTime = 0.0f;                  
 
    // Callback that calculates the max impulse that the tire can apply to the ground
    TireMaxImpulseCallback      mTireMaxImpulseCallback =
        [](uint, float &outLongitudinalImpulse, float &outLateralImpulse, float inSuspensionImpulse, float inLongitudinalFriction, float inLateralFriction, float, float, float)
        {
            outLongitudinalImpulse = inLongitudinalFriction * inSuspensionImpulse;
            outLateralImpulse = inLateralFriction * inSuspensionImpulse;
        };
 
#ifdef JPH_DEBUG_RENDERER
    // Debug settings
    Vec3                        mRPMMeterPosition { 0, 1, 0 };              
    float                       mRPMMeterSize = 0.5f;                       
#endif // JPH_DEBUG_RENDERER
};
 
JPH_NAMESPACE_END