VehicleBuilder.hpp

Go to the documentation of this file.

#pragma once
 
#include "component/BoxCollider.hpp"
#include "component/ConvexHullMeshCollider.hpp"
#include "component/MeshCollider.hpp"
#include "component/RigidBody.hpp"
#include "component/Vehicle.hpp"
#include "component/VehicleController.hpp"
#include "component/WheelSettings.hpp"
#include "core/Core.hpp"
#include "entity/Entity.hpp"
#include "exception/VehicleBuilderError.hpp"
 
#include "Object.hpp"
 
#include <array>
#include <fmt/format.h>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
 
namespace Physics::Builder {

template <size_t N> class VehicleBuilder {
    static_assert(N == 4, "VehicleBuilder currently only supports 4-wheel vehicles (N=4). "
                          "Support for other wheel counts may be added in future versions.");
};

template <> class VehicleBuilder<4> {
  public:
    VehicleBuilder &SetChassisMesh(const Object::Component::Mesh &chassisMesh,
                                   const glm::vec3 &position = glm::vec3(0.0f),
                                   const glm::quat &rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f),
                                   const glm::vec3 &scale = glm::vec3(1.0f))
    {
        _chassisMesh = chassisMesh;
        _chassisPosition = position;
        _chassisRotation = rotation;
        _chassisScale = scale;
        _hasChassisSet = true;
        return *this;
    }

    VehicleBuilder &SetWheelMesh(Component::WheelIndex index, const Object::Component::Mesh &wheelMesh)
    {
        _wheelMeshes[static_cast<size_t>(index)] = wheelMesh;
        _hasWheelMesh[static_cast<size_t>(index)] = true;
        return *this;
    }

    VehicleBuilder &SetWheelSettings(Component::WheelIndex index, const Component::WheelSettings &settings)
    {
        _vehicle.wheels[static_cast<size_t>(index)] = settings;
        return *this;
    }

    VehicleBuilder &SetMaxBrakeTorque(Component::WheelIndex index, float torque)
    {
        _vehicle.wheels[static_cast<size_t>(index)].maxBrakeTorque = torque;
        return *this;
    }

    VehicleBuilder &SetMaxHandBrakeTorque(Component::WheelIndex index, float torque)
    {
        _vehicle.wheels[static_cast<size_t>(index)].maxHandBrakeTorque = torque;
        return *this;
    }

    VehicleBuilder &SetDrivetrain(Component::DrivetrainType drivetrain)
    {
        _vehicle.drivetrain = drivetrain;
        return *this;
    }

    VehicleBuilder &SetEngine(const Component::EngineSettings &engine)
    {
        _vehicle.engine = engine;
        return *this;
    }

    VehicleBuilder &SetGearbox(const Component::GearboxSettings &gearbox)
    {
        _vehicle.gearbox = gearbox;
        return *this;
    }

    VehicleBuilder &SetRollbar(const Component::RollbarSettings &rollbar)
    {
        _vehicle.rollbar = rollbar;
        return *this;
    }

    VehicleBuilder &SetWheelPositions(const glm::vec3 &frontLeft, const glm::vec3 &frontRight,
                                      const glm::vec3 &rearLeft, const glm::vec3 &rearRight)
    {
        using enum Component::WheelIndex;
 
        _wheelPositions[static_cast<size_t>(FrontLeft)] = frontLeft;
        _wheelPositions[static_cast<size_t>(FrontRight)] = frontRight;
        _wheelPositions[static_cast<size_t>(RearLeft)] = rearLeft;
        _wheelPositions[static_cast<size_t>(RearRight)] = rearRight;
        return *this;
    }

    Engine::Entity Build(Engine::Core &core)
    {
        if (!_hasChassisSet)
        {
            throw Exception::VehicleBuilderError("Chassis mesh not set");
        }
 
        for (size_t i = 0; i < 4; ++i)
        {
            if (!_hasWheelMesh[i])
            {
                throw Exception::VehicleBuilderError(fmt::format("Wheel mesh not set for wheel {}", i));
            }
        }
 
        if (_vehicle.gearbox.forwardGearRatios.empty())
        {
            throw Exception::VehicleBuilderError("Gearbox must have at least one forward gear");
        }
 
        auto chassis = core.CreateEntity();
        chassis.AddComponent<Object::Component::Transform>(
            Object::Component::Transform(_chassisPosition, _chassisScale, _chassisRotation));
        chassis.AddComponent<Object::Component::Mesh>(_chassisMesh);
 
        std::array<Engine::EntityId, 4> wheelEntities;
        for (size_t i = 0; i < 4; ++i)
        {
            wheelEntities[i] = core.CreateEntity();
 
            glm::vec3 worldWheelPos = _chassisPosition + _chassisRotation * _wheelPositions[i];
            glm::quat wheelRotation =
                _chassisRotation * glm::angleAxis(glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));
 
            wheelEntities[i].AddComponent<Object::Component::Transform>(
                core, Object::Component::Transform(worldWheelPos, glm::vec3(1.0f), wheelRotation));
            wheelEntities[i].AddComponent<Object::Component::Mesh>(core, _wheelMeshes[i]);
        }
 
        auto chassisRigidBody = Component::RigidBody::CreateDynamic(_chassisMass);
        chassisRigidBody.friction = 0.5f;
        chassisRigidBody.restitution = 0.1f;
        chassis.AddComponent<Component::ConvexHullMeshCollider>();
        chassis.AddComponent<Component::RigidBody>(chassisRigidBody);
 
        _vehicle.wheelEntities = wheelEntities;
        _vehicle.wheelPositions = _wheelPositions;
 
        chassis.AddComponent<Component::Vehicle>(_vehicle);
 
        chassis.AddComponent<Component::VehicleController>();
 
        return chassis;
    }

    VehicleBuilder &SetChassisMass(float mass)
    {
        _chassisMass = mass;
        return *this;
    }

    VehicleBuilder &SetCollisionTesterType(Component::CollisionTesterType type)
    {
        _vehicle.collisionTesterType = type;
        return *this;
    }

    VehicleBuilder &SetConvexRadiusFraction(float fraction)
    {
        if (fraction < 0.0f || fraction > 1.0f)
        {
            throw Exception::VehicleBuilderError("Convex radius fraction must be between 0.0 and 1.0");
        }
        _vehicle.convexRadiusFraction = fraction;
        return *this;
    }
 
  private:
    Component::Vehicle _vehicle = Component::Vehicle::CreateDefaultCar();
 
    Object::Component::Mesh _chassisMesh;
    glm::vec3 _chassisPosition = glm::vec3(0.0f);
    glm::quat _chassisRotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
    glm::vec3 _chassisScale = glm::vec3(1.0f);
    float _chassisMass = 1500.0f;
 
    std::array<Object::Component::Mesh, 4> _wheelMeshes;
    std::array<glm::vec3, 4> _wheelPositions = Component::Vehicle::GetDefaultWheelPositions();
 
    bool _hasChassisSet = false;
    std::array<bool, 4> _hasWheelMesh = {false, false, false, false};
};
 
} // namespace Physics::Builder