WheelSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "TireSystem.h"
#include "VehicleSystemTemplate.h"
#include "VehicleUtility.h"
 
#if VEHICLE_DEBUGGING_ENABLED
UE_DISABLE_OPTIMIZATION
#endif
 
namespace Chaos
{
 
struct CHAOSVEHICLESCORE_API FSimpleWheelConfig
{
    // #todo: use this
    enum EWheelDamageStatus
    {
        NONE,
        BUCKLED,
        FLAT,
        MISSING
    };
 
    // #todo: use this
    enum EWheelSimulationStatus
    {
        ROLLING,    // wheel speed matches the vehicle ground speed
        SPINNING,   // wheel speed faster than vehicle ground speed
        LOCKED      // wheel is locked and sliding over surface
    };
 
    // #todo: use this
    enum EFrictionCombineMethod
    {
        Multiply, // default - most correct
        Average
    };
 
    enum EAxleType : uint8
    {
        UndefinedAxle = 0,
        Front,
        Rear
    };
    
    enum EExternalTorqueCombineMethod : uint8
    {
        None = 0,
        Override,
        Additive
    };
 
    FSimpleWheelConfig() 
        : Offset(FVector(2.f, 1.f, 0.f))
        , WheelMass(20.f) // [Kg]
        , WheelRadius(30.f) // [cm]
        , WheelWidth(20.f)
        , MaxSteeringAngle(70)
        , MaxBrakeTorque(2000.f)
        , HandbrakeTorque(1000.f)
        , ABSEnabled(false)
        , BrakeEnabled(true)
        , HandbrakeEnabled(true)
        , SteeringEnabled(true)
        , EngineEnabled(false)
        , TractionControlEnabled(false)
        , TorqueRatio(0.f)
        , AxleType(EAxleType::UndefinedAxle)
        , FrictionCombineMethod(EFrictionCombineMethod::Multiply)
        , ExternalTorqueCombineMethod(EExternalTorqueCombineMethod::None)
        , FrictionMultiplier(2.0f)
        , LateralSlipGraphMultiplier(1.0f)
        , CorneringStiffness(1000.0f)
        , SideSlipModifier(1.0f)
        , SlipThreshold(20.0f)
        , SkidThreshold(20.0f)
        , MaxSpinRotation(30.0f)
    {
 
    }
 
    // Basic
    //FSimpleTireConfig Tire;
 
    // wheel tire
    FVector Offset;
    float WheelMass;            // Mass of wheel [Kg]
    float WheelRadius;          // [cm]
    float WheelWidth;           // [cm]
 
    int  MaxSteeringAngle;      // Yaw angle of steering [Degrees]
 
    // brakes
    float MaxBrakeTorque;       // Braking Torque [Nm]
    float HandbrakeTorque;      // Handbrake Torque [Nm]
    bool ABSEnabled;            // Advanced braking system operational
 
    // setup
    bool BrakeEnabled;          // Regular brakes are enabled for this wheel
    bool HandbrakeEnabled;      // Handbrake is operational on this wheel
    bool SteeringEnabled;       // Steering is operational on this wheel
    bool EngineEnabled;         // Wheel is driven by an engine
    bool TractionControlEnabled;// Straight Line Traction Control
    float TorqueRatio;          // Portion of torque going to this wheel (0->1)
 
    EAxleType AxleType;
 
    EFrictionCombineMethod FrictionCombineMethod; //#todo: use this variable
    EExternalTorqueCombineMethod ExternalTorqueCombineMethod;
 
    float FrictionMultiplier;
    float LateralSlipGraphMultiplier;
    float CorneringStiffness;
    float SideSlipModifier;
 
    float SlipThreshold;
    float SkidThreshold;
 
    FGraph LateralSlipGraph;
    float MaxSpinRotation;
 
    // #todo: simulated Damage
    //EWheelDamageStatus DamageStatus;
    //float BuckleAngle;
};
 
 
class CHAOSVEHICLESCORE_API FSimpleWheelSim : public TVehicleSystem<FSimpleWheelConfig>
{
public:
 
    FSimpleWheelSim(const FSimpleWheelConfig* SetupIn);
 
// Inputs
 
    void SetWheelRadius(float NewRadius)
    {
        Re = NewRadius;
    }
 
    void SetAngularPosition(float PositionIn)
    {
        AngularPosition = PositionIn;
    }
 
    void SetAngularVelocity(float AngularVelocityIn)
    {
        Omega = AngularVelocityIn;
    }
 
    void SetMatchingSpeed(float LinearMetersPerSecondIn)
    {
        Omega = LinearMetersPerSecondIn / Re;
    }
 
    void SetBrakeTorque(float BrakeTorqueIn, bool bEngineBrakingIn = false)
    {
        BrakeTorque = BrakeTorqueIn;
        bEngineBraking = bEngineBrakingIn;
    }
 
    void SetDriveTorque(float EngineTorqueIn)
    {
        DriveTorque = EngineTorqueIn;
    }
 
    void SetTorqueCombineMethod(FSimpleWheelConfig::EExternalTorqueCombineMethod InCombineMethod)
    {
        ExternalTorqueCombineMethod = InCombineMethod;
    }
 
    void SetBrakeTorqueOverride(float BrakeTorqueIn, bool bEngineBrakingIn = false)
    {
        ExternalBrakeTorque = BrakeTorqueIn;
        bEngineBraking = bEngineBrakingIn;
    }
 
    void SetDriveTorqueOverride(float EngineTorqueIn)
    {
        ExternalDriveTorque = EngineTorqueIn;
    }
 
    void SetVehicleGroundSpeed(const FVector& VIn)
    {
        GroundVelocityVector = VIn;
    }
 
    void SetWheelLoadForce(float WheelLoadForceIn)
    {
        ForceIntoSurface = WheelLoadForceIn;
        
        if (ForceIntoSurface > SMALL_NUMBER)
        {
            bInContact = true;
        }
        else
        {
            bInContact = false;
        }
    }
 
    void SetSurfaceFriction(float InFriction)
    {
        SurfaceFriction = InFriction;
    }
 
    void SetOnGround(bool OnGround)
    {
        bInContact = OnGround;
    }
 
    void SetSteeringAngle(float InAngle)
    {
        SteeringAngle = InAngle;
    }
 
    void SetMaxOmega(float InMaxOmega)
    {
        MaxOmega = InMaxOmega;
    }
 
    void SetWheelIndex(uint32 InIndex)
    {
        WheelIndex = InIndex;
    }
 
// Outputs
 
    static float GetNormalisedFrictionFromSlipAngle(float SlipIn)
    {
        FVehicleUtility::ClampNormalRange(SlipIn);
 
        // typical slip angle graph; normalized scales
        // Friction between 0 and 1 for values of slip between 0 and 1
        float FunctionResult = 1.125f * (1.0f - exp(-20.0f * SlipIn)) - 0.25f * SlipIn;
        return FMath::Max(0.0f, FMath::Min(1.0f, FunctionResult));
    }
 
    FVector GetForceFromFriction() const
    {
        return ForceFromFriction;
    }
 
    float GetEffectiveRadius() const
    {
        return Re;
    }
 
    float GetAngularPosition() const
    {
        return AngularPosition;
    }
 
    float GetAngularVelocity() const
    {
        return Omega;
    }
 
    float GetWheelRPM()
    {
        return OmegaToRPM(Omega);
    }
 
    bool InContact() const
    {
        return bInContact;
    }
 
    bool IsSlipping() const
    { 
        return (FMath::Abs(GetSlipMagnitude()) > Setup().SlipThreshold);
    }
 
    bool IsSkidding() const
    {
        return (FMath::Abs(GetSkidMagnitude()) > Setup().SkidThreshold);
    }
    bool IsABSActivated() const
    {
        return bABSActivated;
    }
 
    float GetSteeringAngle() const
    {
        return SteeringAngle;
    }
 
    float GetNormalizedLongitudinalSlip() const
    {
        return Sx;
    }
 
    float GetNormalizedLateralSlip() const
    {
        return FMath::Clamp(RadToDeg(SlipAngle) / 30.0f, 0.f, 1.f);
    }
 
    float GetWheelLoadForce() const
    {
        return ForceIntoSurface;
    }
 
    float GetSurfaceFriction() const
    {
        return SurfaceFriction;
    }
 
    float GetSlipAngle() const
    {
        return SlipAngle;
    }
 
    float GetDriveTorque() const
    {
        return DriveTorque;
    }
 
    float GetBrakeTorque() const
    {
        return BrakeTorque;
    }
 
    float GetRoadSpeed() const
    {
        return GroundVelocityVector.X;
    }
 
    float GetWheelGroundSpeed() const
    {
        return Omega * Re;
    }
 
    float GetSlipMagnitude() const
    {
        return GetWheelGroundSpeed() - GetRoadSpeed();
    }
 
    float GetSkidMagnitude() const
    {
        return GroundVelocityVector.Y;
    }
 
 
    void Simulate(float DeltaTime);
 
 
    void SetMassPerWheel(float VehicleMassPerWheel)
    {
        MassPerWheel = VehicleMassPerWheel;
    }
 
public:
    bool BrakeEnabled;          // Regular brakes are enabled for this wheel
    bool HandbrakeEnabled;      // Handbrake is operational on this wheel
    bool SteeringEnabled;       // Steering is operational on this wheel
    bool EngineEnabled;         // Wheel is driven by an engine
    bool TractionControlEnabled;// Straight Line Traction Control
    bool ABSEnabled;            // Advanced braking system operational
    float FrictionMultiplier;
    float LateralSlipGraphMultiplier;
    float CorneringStiffness;
    float MaxSteeringAngle;
    float MaxBrakeTorque;
    float HandbrakeTorque;
    FSimpleWheelConfig::EExternalTorqueCombineMethod ExternalTorqueCombineMethod;
 
    float Re;       // [cm] Effective Wheel Radius could change dynamically if get a flat?, tire shreds
    float Omega;    // [radians/sec] Wheel Rotation Angular Velocity
    float Sx;
    float Inertia;
    // In
    float DriveTorque;              // [N.m]
    float BrakeTorque;              // [N.m]
    float ForceIntoSurface;         // [N]
    FVector GroundVelocityVector;   // [Unreal Units cm.s-1]
    float AngularPosition;          // [radians]
    float SteeringAngle;            // [degrees ATM]
    float SurfaceFriction;
    float MaxOmega;
 
    float ExternalDriveTorque;      // [N.m]
    float ExternalBrakeTorque;      // [N.m]
 
    FVector ForceFromFriction;
    float MassPerWheel;
 
    // Wheel transform
 
    float SlipVelocity;         // Relative velocity between tire patch and ground ?? vector ??
    float SlipAngle;            // Angle between wheel forwards and velocity vector
    bool bInContact;            // Is tire in contact with the ground or free in the air
    uint32 WheelIndex;          // purely for debugging purposes
    bool bEngineBraking;        // Is the braking force coming from the engine
 
    public:
    // debug for now
    float AppliedLinearDriveForce;
    float AppliedLinearBrakeForce;
    float LongitudinalAdhesiveLimit;
    float LateralAdhesiveLimit;
    float SideSlipModifier;
    float Spin;
    float AvailableGrip;
    FVector InputForces;
    bool bClipping;
    bool bABSActivated;
 
};
 
 
struct CHAOSVEHICLESCORE_API FAxleConfig
{
    TArray<uint16> WheelIndex;  // reference to wheels on this axle
    float RollbarScaling;
};
 
class CHAOSVEHICLESCORE_API FAxleSim : public TVehicleSystem<FAxleConfig>
{
public:
 
    FAxleSim();
 
    void Simulate(float DeltaTime) {}
 
    FAxleConfig Setup;
 
};
 
} // namespace Chaos
 
#if VEHICLE_DEBUGGING_ENABLED
UE_ENABLE_OPTIMIZATION
#endif