MotorcycleController.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Physics/Vehicle/WheeledVehicleController.h>
 
JPH_NAMESPACE_BEGIN

class JPH_EXPORT MotorcycleControllerSettings : public WheeledVehicleControllerSettings
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, MotorcycleControllerSettings)
 
public:
    // See: VehicleControllerSettings
    virtual VehicleController * ConstructController(VehicleConstraint &inConstraint) const override;
    virtual void                SaveBinaryState(StreamOut &inStream) const override;
    virtual void                RestoreBinaryState(StreamIn &inStream) override;

    float                       mMaxLeanAngle = DegreesToRadians(45.0f);

    float                       mLeanSpringConstant = 5000.0f;

    float                       mLeanSpringDamping = 1000.0f;

    float                       mLeanSpringIntegrationCoefficient = 0.0f;

    float                       mLeanSpringIntegrationCoefficientDecay = 4.0f;

    float                       mLeanSmoothingFactor = 0.8f;
};

class JPH_EXPORT MotorcycleController : public WheeledVehicleController
{
public:
    JPH_OVERRIDE_NEW_DELETE

                                MotorcycleController(const MotorcycleControllerSettings &inSettings, VehicleConstraint &inConstraint);

    float                       GetWheelBase() const;

    void                        EnableLeanController(bool inEnable)                 { mEnableLeanController = inEnable; }

    bool                        IsLeanControllerEnabled() const                     { return mEnableLeanController; }

    void                        EnableLeanSteeringLimit(bool inEnable)              { mEnableLeanSteeringLimit = inEnable; }
    bool                        IsLeanSteeringLimitEnabled() const                  { return mEnableLeanSteeringLimit; }

    void                        SetLeanSpringConstant(float inConstant)             { mLeanSpringConstant = inConstant; }
    float                       GetLeanSpringConstant() const                       { return mLeanSpringConstant; }

    void                        SetLeanSpringDamping(float inDamping)               { mLeanSpringDamping = inDamping; }
    float                       GetLeanSpringDamping() const                        { return mLeanSpringDamping; }

    void                        SetLeanSpringIntegrationCoefficient(float inCoefficient) { mLeanSpringIntegrationCoefficient = inCoefficient; }
    float                       GetLeanSpringIntegrationCoefficient() const         { return mLeanSpringIntegrationCoefficient; }

    void                        SetLeanSpringIntegrationCoefficientDecay(float inDecay) { mLeanSpringIntegrationCoefficientDecay = inDecay; }
    float                       GetLeanSpringIntegrationCoefficientDecay() const    { return mLeanSpringIntegrationCoefficientDecay; }

    void                        SetLeanSmoothingFactor(float inFactor)              { mLeanSmoothingFactor = inFactor; }
    float                       GetLeanSmoothingFactor() const                      { return mLeanSmoothingFactor; }
 
    // See: VehicleController
    virtual Ref<VehicleControllerSettings> GetSettings() const override;
 
protected:
    // See: VehicleController
    virtual void                PreCollide(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
 
    // Configuration properties
    bool                        mEnableLeanController = true;
    bool                        mEnableLeanSteeringLimit = true;
    float                       mMaxLeanAngle;
    float                       mLeanSpringConstant;
    float                       mLeanSpringDamping;
    float                       mLeanSpringIntegrationCoefficient;
    float                       mLeanSpringIntegrationCoefficientDecay;
    float                       mLeanSmoothingFactor;
 
    // Run-time calculated target lean vector
    Vec3                        mTargetLean = Vec3::sZero();
 
    // Integrated error for the lean spring
    float                       mLeanSpringIntegratedDeltaAngle = 0.0f;
 
    // Run-time total angular impulse applied to turn the cycle towards the target lean angle
    float                       mAppliedImpulse = 0.0f;
};
 
JPH_NAMESPACE_END