Task: Design and implement a high-performance 3D Vehicle Physics Sandbox using a Data-Oriented Design (DOD) approach within the Magnum ecosystem.

Core Technology Stack:
Language: C++20.
Engine Core: Magnum (latest on Github).
Window/Context: Magnum::Platform::Sdl2Application (or GlfwApplication).
Graphics: Magnum::GL (No GLAD/GLEW). Use latest commits of all projects from 'mosra' user on Github
Asset loading: none, procedural assets. see below
Physics: Bullet Physics 3.25.
Integration: Magnum::BulletIntegration.

Architectural Requirements:
Magnum-Centric ECS:
Use EnTT for entity management.
        Use Magnum::SceneGraph for the hierarchical representation of visual objects, but decouple the physics transform updates. The Physics System should drive the SceneGraph object transformations (Object3D::setTransformation), not the other way around.


        Convex Hull Generation: Implement a robust utility to convert Magnum::Trade::MeshData into btConvexHullShape.
        Simplification Constraint: Use Magnum::MeshTools or Bullet’s internal simplification utilities to optimize the collision mesh, but explicitly preserve the critical geometry volume to ensure the chassis collides accurately. Do not over-simplify to the point of losing wheel wells or bumpers.
        
    Physics Implementation:

        Implement btRaycastVehicle logic.
        Debug Visualization: Implement a DebugDraw class inheriting from btIDebugDraw (or use Magnum::BulletIntegration::DebugDraw if applicable).
        Runtime Toggle: Map a key (e.g., 'F1') to toggle the rendering of the physics wireframe overlay on top of the PBR render. This must show the actual simplified collision hulls, not the visual meshes.
    Rendering Pipeline:
        Implement a PBR Shader pipeline using Magnum::Shaders::Phong (or a custom PBR shader) with the Magnum::GL::Renderer.
        Ensure the visual mesh and the physics hull are aligned in the viewport.        
        

use best practices to ensure a functional result.  Prefer simple approaches that produce results rather than complexity

gameplay:
W A S D for vehicle movement
procedural generated smooth terrain - use standard techniques with bezier curves or similar
objects in the environment should be collidable and movable when that happens. 
third person perspective to vehicle
use a fixed timestep for simulation as described at the end of this blog post: https://gafferongames.com/post/fix_your_timestep/

assets:

Do not rely on loading assets from file.
Generate assets procedurally for the different items we need
Use a composition approach, composing different element's from Magnum's Primitives library
Use simplified geometry when generating an asset, the shape can be low poly and simply approximate the shape of the items
For the textures use a simple approach with distinguishing colors and a checkerboard pattern to ensure contrast
Assets we need: vehicle with body and tires. Rocks to collide with in the environment.
        
restrictions:

no use of obsolete or deprecated APIs
do not generate a build system

Deliverables:

    Single file C++ code demonstrating the Asset Import -> Mesh Processing -> btCollisionShape conversion pipeline using Magnum types.   
     The video game should be complete, functional & ready to play after being compiled. No skeletons or pseudo code.
    The drawEvent loop showing the PBR render pass followed by the conditional world->debugDrawWorld() pass.
    Configuration for the btRaycastVehicle tuning to work with Magnum's unit scale.