TransmissionSystem.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 "VehicleSystemTemplate.h"
#include "VehicleUtility.h"
 
#if VEHICLE_DEBUGGING_ENABLED
UE_DISABLE_OPTIMIZATION_SHIP
#endif
 
namespace Chaos
{
    enum ETransmissionType : uint8
    {
        Manual,
        Automatic
    };
 
    enum EDifferentialType : uint8
    {
        UndefinedDrive,
        AllWheelDrive,
        FrontWheelDrive,
        RearWheelDrive,
    };
 
    struct CHAOSVEHICLESCORE_API FSimpleDifferentialConfig
    {
        FSimpleDifferentialConfig()
            : DifferentialType(EDifferentialType::RearWheelDrive)
            , FrontRearSplit(0.5f)
        {
        }
 
        EDifferentialType DifferentialType;
        float FrontRearSplit;
    };
 
    class CHAOSVEHICLESCORE_API FSimpleDifferentialSim : public TVehicleSystem<FSimpleDifferentialConfig>
    {
    public:
        FSimpleDifferentialSim(const FSimpleDifferentialConfig* SetupIn) 
            : TVehicleSystem<FSimpleDifferentialConfig>(SetupIn)
            , FrontRearSplit(Setup().FrontRearSplit) {}
 
        float FrontRearSplit;
    };
 
    struct CHAOSVEHICLESCORE_API FSimpleTransmissionConfig
    {
        FSimpleTransmissionConfig()
            : FinalDriveRatio(1.f)
            , ChangeUpRPM(5000)
            , ChangeDownRPM(2500)
            , GearChangeTime(0.2f)
            , TransmissionEfficiency(1.f)
            , TransmissionType(ETransmissionType::Automatic)
            , AutoReverse(true)
        {
        }
 
        TArray<float> ForwardRatios;    // Gear ratios for forward gears
        TArray<float> ReverseRatios;    // Gear ratios for reverse Gear(s)
        float FinalDriveRatio;          // Final drive ratio [~4.0]
 
        uint32 ChangeUpRPM;             // [#todo: RPM or % max RPM?]
        uint32 ChangeDownRPM;           // [#todo: RPM or % max RPM?]
        float GearChangeTime;           // [sec]
 
        float TransmissionEfficiency;   // Loss from friction in the system mean we might run at around 0.94 Efficiency
 
        ETransmissionType TransmissionType; // Specify Automatic or Manual transmission
 
        bool AutoReverse;                   // Arcade handling - holding Brake switches into reverse after vehicle has stopped
    };
 
 
    class CHAOSVEHICLESCORE_API FSimpleTransmissionSim : public TVehicleSystem<FSimpleTransmissionConfig>
    {
    public:
        FSimpleTransmissionSim(const FSimpleTransmissionConfig* SetupIn);
 
        // Input functions
 
        void SetGear(int32 InGear, bool Immediate = false);
 
        void ChangeUp()
        {
            SetGear(TargetGear + 1);        
        }
 
        void ChangeDown()
        {
            SetGear(TargetGear - 1);
        }
 
        void SetEngineRPM(float InRPM)
        {
            EngineRPM = InRPM;
        }
 
        void SetAllowedToChangeGear(bool OkToChangeIn)
        {
            AllowedToChangeGear = OkToChangeIn;
        }
 
        // Output functions
 
        int32 GetCurrentGear() const
        {
            return CurrentGear;
        }
 
        int32 GetTargetGear() const
        {
            return TargetGear;
        }
 
        float GetCurrentGearChangeTime() const
        {
            return CurrentGearChangeTime;
        }
 
        void SetCurrentGear(const int32 InCurrentGear) 
        {
            CurrentGear = InCurrentGear;
        }
 
        void SetTargetGear(const int32 InTargetGear) 
        {
            TargetGear = InTargetGear;
        }
 
        void SetCurrentGearChangeTime(const float InCurrentGearChangeTime) 
        {
            CurrentGearChangeTime = InCurrentGearChangeTime;
        }
 
        bool IsCurrentlyChangingGear() const
        {
            return CurrentGear != TargetGear;
        }
 
        bool IsOutOfGear() const
        {
            return (CurrentGear == 0) || IsCurrentlyChangingGear();
        }
 
        float GetGearRatio(int32 InGear);
 
        float GetTransmissionRPM(float InEngineRPM, int InGear)
        {
            if (InGear == 0) // neutral, don't want to divide by zero
            {
                return 0.0f;
            }
 
            return InEngineRPM / GetGearRatio(InGear);
        }
 
        float GetTransmissionRPM()
        {
            return GetTransmissionRPM(EngineRPM, CurrentGear);
        }
 
        float GetTransmissionTorque(float InEngineTorque)
        {
            return InEngineTorque * GetGearRatio(GetCurrentGear()) * Setup().TransmissionEfficiency;
        }
 
        //float GetEngineTorque(float InTransmissionTorque)
        //{
        //  return InTransmissionTorque / GetGearRatio(GetCurrentGear()); // #todo: what about transmission frictional losses
        //}
 
        float GetEngineRPMFromWheelRPM(float InWheelRPM)
        {
            return InWheelRPM * GetGearRatio(GetCurrentGear());
        }
 
        /*
         * Simulate - update internal state 
         * - changes gear when using automatic transmission
         * - implements gear change time, where gear goes through neutral
         */
        void Simulate(float DeltaTime);
    
        void CorrectGearInputRange(int32& GearIndexInOut)
        {
            GearIndexInOut = FMath::Clamp(GearIndexInOut, -Setup().ReverseRatios.Num(), Setup().ForwardRatios.Num());
        }
 
    private:
 
        int32 CurrentGear; // <0 reverse gear(s), 0 neutral, >0 forward gears
        int32 TargetGear;  // <0 reverse gear(s), 0 neutral, >0 forward gears
        float CurrentGearChangeTime; // Time to change gear, no power transmitted to the wheels during change
 
        float EngineRPM;    // Engine Revs Per Minute
 
        bool AllowedToChangeGear; 
    };
 
} // namespace Chaos
 
#if VEHICLE_DEBUGGING_ENABLED
UE_ENABLE_OPTIMIZATION_SHIP
#endif