Vehicle.hpp

Go to the documentation of this file.

#pragma once
 
#include "component/WheelSettings.hpp"
#include "entity/EntityId.hpp"
#include <Jolt/Physics/Vehicle/VehicleAntiRollBar.h>
#include <Jolt/Physics/Vehicle/VehicleConstraint.h>
#include <array>
#include <memory>
 
namespace Physics::Component {

enum class DrivetrainType : uint8_t {
    AWD,
    FWD,
    RWD
};

enum class CollisionTesterType : uint8_t {
    Ray,
    CastSphere,
    CastCylinder
};

enum class TransmissionMode : uint8_t {
    Auto,
    Manual
};

struct TorqueCurvePoint {
    float rpm;    
    float torque; 
};

struct GearboxSettings {
    TransmissionMode mode = TransmissionMode::Auto;

    std::vector<float> forwardGearRatios = {2.66f, 1.78f, 1.3f, 1.0f, 0.74f};

    std::vector<float> reverseGearRatios = {-2.90f};

    int currentGear = 1;

    float switchTime = 0.5f;

    float clutchReleaseTime = 0.3f;

    float switchLatency = 0.5f;

    float shiftUpRPM = 4000.0f;

    float shiftDownRPM = 2000.0f;

    float clutchStrength = 10.0f;

    float clutchFriction = 1.0f;
};

struct EngineSettings {
    float maxTorque = 500.0f;

    float minRPM = 1000.0f;

    float maxRPM = 6000.0f;

    std::vector<TorqueCurvePoint> normalizedTorque = {
        {0.0f,  0.8f}, // 80% torque at minRPM
        {0.66f, 1.0f}, // 100% torque at 66% of RPM range (peak)
        {1.0f,  0.8f}  // 80% torque at maxRPM
    };

    float inertia = 0.5f;

    float angularDamping = 0.2f;
};

struct RollbarSettings {
    float frontStiffness = 5000.0f;

    float rearStiffness = 5000.0f;
};

struct Vehicle {
    std::array<WheelSettings, static_cast<size_t>(WheelIndex::Count)> wheels;

    DrivetrainType drivetrain = DrivetrainType::RWD;

    EngineSettings engine;

    GearboxSettings gearbox;

    RollbarSettings rollbar;

    std::array<Engine::EntityId, 4> wheelEntities;

    std::array<glm::vec3, 4> wheelPositions = GetDefaultWheelPositions();

    CollisionTesterType collisionTesterType = CollisionTesterType::CastCylinder;

    float convexRadiusFraction = 0.5f;

    static std::array<glm::vec3, 4> GetDefaultWheelPositions()
    {
        return {
            glm::vec3(-0.9f, -0.3f, 1.2f),  // Front-left
            glm::vec3(0.9f, -0.3f, 1.2f),   // Front-right
            glm::vec3(-0.9f, -0.3f, -1.2f), // Rear-left
            glm::vec3(0.9f, -0.3f, -1.2f)   // Rear-right
        };
    }

    static Vehicle CreateDefaultCar()
    {
        using enum WheelIndex;
 
        Vehicle vehicle;
        vehicle.drivetrain = DrivetrainType::RWD;
        vehicle.engine.maxTorque = 600.0f;
        vehicle.engine.maxRPM = 7000.0f;
        vehicle.rollbar.rearStiffness = 8000.0f;
 
        // Front wheels with steering
        vehicle.wheels[static_cast<size_t>(FrontLeft)] = WheelSettings::CreateFrontWheel();
        vehicle.wheels[static_cast<size_t>(FrontRight)] = WheelSettings::CreateFrontWheel();
 
        // Rear wheels without steering
        vehicle.wheels[static_cast<size_t>(RearLeft)] = WheelSettings::CreateRearWheel();
        vehicle.wheels[static_cast<size_t>(RearRight)] = WheelSettings::CreateRearWheel();
        return vehicle;
    }
};
 
} // namespace Physics::Component