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