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 WheelSettingsWV : public WheelSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(WheelSettingsWV)
 
    
                                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 WheelWV : public Wheel
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                    WheelWV(const WheelSettingsWV &inWheel);
 
    const WheelSettingsWV *     GetSettings() const                         { return static_cast<const WheelSettingsWV *>(mSettings.GetPtr()); }
 
    void                        ApplyTorque(float inTorque, float inDeltaTime)
    {
        mAngularVelocity += inTorque * inDeltaTime / GetSettings()->mInertia;
    }
 
    void                        Update(float inDeltaTime, const VehicleConstraint &inConstraint);
 
    float                       mLongitudinalSlip = 0.0f;                   
    float                       mCombinedLongitudinalFriction = 0.0f;       
    float                       mCombinedLateralFriction = 0.0f;            
    float                       mBrakeImpulse = 0.0f;                       
};
 
class WheeledVehicleControllerSettings : public VehicleControllerSettings
{
public:
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(WheeledVehicleControllerSettings)
 
    // 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 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; }
 
    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; }
 
#ifdef JPH_DEBUG_RENDERER
    void                        SetRPMMeter(Vec3Arg inPosition, float inSize) { mRPMMeterPosition = inPosition; mRPMMeterSize = inSize; }
#endif // JPH_DEBUG_RENDERER
 
protected:
    // 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                 { return mForwardInput == 0.0f; }
    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;                     
 
    // Simluation information
    VehicleEngine               mEngine;                                    
    VehicleTransmission         mTransmission;                              
    Differentials               mDifferentials;                             
    float                       mDifferentialLimitedSlipRatio;              
 
#ifdef JPH_DEBUG_RENDERER
    // Debug settings
    Vec3                        mRPMMeterPosition { 0, 1, 0 };              
    float                       mRPMMeterSize = 0.5f;                       
#endif // JPH_DEBUG_RENDERER
};
 
JPH_NAMESPACE_END