Vehicle.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/ecs/Entity.h"
#include "ncengine/physics/SpringSettings.h"
 
#include <initializer_list>
#include <span>
#include <vector>
 
namespace nc
{
using VehicleId = uint32_t;
using VehicleHandle = void*;
 
struct VehicleOrientation
{
    Vector3 up = Vector3::Up();                     
    Vector3 forward = Vector3::Front();             
    float maxRollAngle = std::numbers::pi_v<float>; 
};
 
struct VehicleEngine
{
    float maxTorque = 500.0f; 
    float minRPM = 1000.0f;   
    float maxRPM = 6000.0f;   
    float inertia = 0.5f;     
    float damping = 0.2f;     
};
 
struct VehicleTransmission
{
    std::vector<float> gears{defaultGears};  
    std::vector<float> reverseGears{-2.90f}; 
    float shiftTime = 0.5f;                  
    float shiftLatency = 0.5f;               
    float shiftUpRPM = 4000.0f;              
    float shiftDownRPM = 2000.0f;            
    float clutchRelease = 0.3f;              
    float clutchStrength = 10.0f;            
 
    static constexpr auto defaultGears = std::initializer_list<float>{ 2.66f, 1.78f, 1.3f, 1.0f, 0.74f };
};
 
struct WheelSpec
{
    float radius = 0.3f;                
    float width = 0.1f;                 
    float inertia = 0.9f;               
    float damping = 0.2f;               
    float maxSteerAngle = 0.523599f;    
    float maxBrakeTorque = 1500.0f;     
    float maxHandBrakeTorque = 4000.0f; 
};
 
struct WheelMount
{
    int id = 0;                               
    Vector3 position = Vector3::Zero();       
    Vector3 up = Vector3::Up();               
    Vector3 forward = Vector3::Front();       
    Vector3 steeringAxis = Vector3::Up();     
    Vector3 suspensionAxis = Vector3::Down(); 
    Entity target = Entity::Null();           
 
    static auto MakeDisabled()       -> WheelMount { return WheelMount{.id = -1}; }
    auto IsEnabled()           const -> bool       { return id != -1; }
};
 
struct Suspension
{
    float minLength = 0.01f;           
    float maxLength = 0.7f;            
    SpringSettings spring{1.5f, 0.5f}; 
    float antiRollBarStiffness = 0.0f; 
 
    static auto MakeDisabled() -> Suspension
    {
        return Suspension{0.0f, 0.0001f, SpringSettings{0.0f, 0.0f}, 0.0f};
    }
 
    auto HasRollBar() const -> bool { return antiRollBarStiffness > 0.0f; }
};
 
struct Differential
{
    float ratio = 3.42f;           
    float limitedSlipRatio = 1.4f; 
 
    static auto MakeDisabled()       -> Differential { return Differential{.ratio = 0.0f}; }
    auto IsEnabled()           const -> bool         { return ratio != 0.0f; }
};
 
struct WheelAssembly
{
    WheelMount leftWheel{};      
    WheelMount rightWheel{};     
    WheelSpec wheelSpec{};       
    Suspension suspension{};     
    Differential differential{}; 
 
    auto WheelCount() const -> size_t
    {
        return static_cast<size_t>(leftWheel.IsEnabled()) +
               static_cast<size_t>(rightWheel.IsEnabled());
    }
 
    auto IsPowered() const -> bool
    {
        return differential.IsEnabled();
    }
};
 
struct VehicleInfo
{
    VehicleOrientation orientation{};                            
    VehicleEngine engine{};                                      
    VehicleTransmission transmission{};                          
    std::vector<WheelAssembly> wheelAssemblies{WheelAssembly{}}; 
};
 
class Vehicle
{
    public:
        explicit Vehicle(VehicleInfo&& info,
                         VehicleHandle handle,
                         VehicleId id)
            : m_info{std::move(info)},
              m_handle{handle},
              m_id{id}
        {
        }
 
        auto GetThrottle()  const -> float;
        auto GetSteering()  const -> float;
        auto GetBrake()     const -> float;
        auto GetHandBrake() const -> float;
        void SetThrottle(float throttle);
        void SetSteering(float steering);
        void SetBrake(float brake);
        void SetHandBrake(float brake);
        void SetInput(float throttle, float steering, float brake, float handBrake);
        void HardStopEngine(); // zero out input, engine, and transmission state.
 
        auto GetVehicleInfo()       const -> const VehicleInfo&             { return m_info;                        }
        auto GetOrientation()       const -> const VehicleOrientation&      { return m_info.orientation;            }
        auto GetEngine()                  ->       VehicleEngine&           { return m_info.engine;                 }
        auto GetEngine()            const -> const VehicleEngine&           { return m_info.engine;                 }
        auto GetTransmission()            ->       VehicleTransmission&     { return m_info.transmission;           }
        auto GetTransmission()      const -> const VehicleTransmission&     { return m_info.transmission;           }
        auto GetWheelAssemblies()         -> std::span<WheelAssembly>       { return m_info.wheelAssemblies;        }
        auto GetWheelAssemblies()   const -> std::span<const WheelAssembly> { return m_info.wheelAssemblies;        }
        auto GetAssemblyCount()     const -> size_t                         { return m_info.wheelAssemblies.size(); }
        auto GetWheelCount()        const -> size_t;
        auto GetDifferentialCount() const -> size_t;
 
        void SetMaxRollAngle(float angle);
        void NotifyModifyEngine();
        void NotifyModifyTransmission();
        void NotifyModifyWheelAssembly(size_t assemblyIndex);
        void AddWheelAssembly(const WheelAssembly& info);
        void RemoveWheelAssembly(size_t assemblyIndex);
 
        void Enable(bool enabled);
        auto IsEnabled() const -> bool;
 
        auto GetId()     const -> VehicleId     { return m_id;     }
        auto GetHandle() const -> VehicleHandle { return m_handle; }
 
    private:
        VehicleInfo m_info;
        VehicleHandle m_handle;
        VehicleId m_id;
};
} // namespace nc