TrackedVehicleController.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/VehicleTrack.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;

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;               
    float                       mLateralFriction = 2.0f;                    
};

class JPH_EXPORT WheelTV : public Wheel
{
public:
    JPH_OVERRIDE_NEW_DELETE

    explicit                    WheelTV(const WheelSettingsTV &inWheel);

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

    void                        CalculateAngularVelocity(const VehicleConstraint &inConstraint);

    void                        Update(uint inWheelIndex, float inDeltaTime, const VehicleConstraint &inConstraint);
 
    int                         mTrackIndex = -1;                           
    float                       mCombinedLongitudinalFriction = 0.0f;       
    float                       mCombinedLateralFriction = 0.0f;            
    float                       mBrakeImpulse = 0.0f;                       
};

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;                                    
    VehicleTransmissionSettings mTransmission;                              
    VehicleTrackSettings        mTracks[(int)ETrackSide::Num];              
};

class JPH_EXPORT TrackedVehicleController : public VehicleController
{
public:
    JPH_OVERRIDE_NEW_DELETE

                                TrackedVehicleController(const TrackedVehicleControllerSettings &inSettings, VehicleConstraint &inConstraint);

    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; }

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

    void                        SetLeftRatio(float inLeftRatio)             { JPH_ASSERT(inLeftRatio != 0.0f); mLeftRatio = inLeftRatio; }
    float                       GetLeftRatio() const                        { return mLeftRatio; }

    void                        SetRightRatio(float inRightRatio)           { JPH_ASSERT(inRightRatio != 0.0f); mRightRatio = inRightRatio; }
    float                       GetRightRatio() const                       { return mRightRatio; }

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

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

    VehicleEngine &             GetEngine()                                 { return mEngine; }

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

    VehicleTransmission &       GetTransmission()                           { return mTransmission; }

    const VehicleTracks &       GetTracks() const                           { return mTracks; }

    VehicleTracks &             GetTracks()                                 { return mTracks; }
 
#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                        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;                       
    float                       mLeftRatio = 1.0f;                          
    float                       mRightRatio = 1.0f;                         
    float                       mBrakeInput = 0.0f;                         
 
    // Simulation information
    VehicleEngine               mEngine;                                    
    VehicleTransmission         mTransmission;                              
    VehicleTracks               mTracks;                                    
 
#ifdef JPH_DEBUG_RENDERER
    // Debug settings
    Vec3                        mRPMMeterPosition { 0, 1, 0 };              
    float                       mRPMMeterSize = 0.5f;                       
#endif // JPH_DEBUG_RENDERER
};
 
JPH_NAMESPACE_END