Struct Wheel3D 

#[repr(C, align(16))]
pub struct Wheel3D {

    pub position: Vec3,
    pub radius: f32,
    pub mass: f32,
    pub suspension_distance: f32,
    pub spring: f32,
    pub damper: f32,
    pub target_position: f32,
    pub force_app_point_distance: f32,
    pub damping_rate: f32,
    pub forward_friction: FrictionCurve,
    pub sideways_friction: FrictionCurve,
    pub motor_torque: f32,
    pub brake_torque: f32,
    pub steer_angle: f32,
    pub local_rotation: Quat,
    pub grounded: bool,
    pub contact_point: Vec3,
    pub contact_normal: Vec3,
    pub compression: f32,
    pub suspension_force: f32,
    pub sprung_mass: f32,
    pub angular_velocity: f32,
    pub forward_slip: f32,
    pub sideways_slip: f32,
    pub spin: f32,
    pub local_position: Vec3,
}

One wheel of a Vehicle3D: where it’s mounted, its suspension and tyres (set these up once), what drives it this tick (yours to set), and what happened to it in the last physics step (read after the step).

The suspension hangs straight down from position along the chassis’s -Y: at full compression the wheel’s center is at position, fully extended it’s suspension_distance lower. Under the car’s weight it rests at target_position of that travel.

use ponko::*;
// Front left wheel of a car whose chassis faces -Z.
let mut wheel = Wheel3D::new(vec3(-0.8, -0.2, -1.3), 0.35);
wheel.spring = 40_000.0;
wheel.sideways_friction.stiffness = 1.2;
// Each tick:
wheel.motor_torque = 300.0;
wheel.steer_angle = 0.3; // right
assert!(!wheel.grounded);

Fields

position: Vec3

Where the wheel’s center is at full compression, in the chassis’s frame (relative to its Transform3D position).

radius: f32

The wheel’s radius in meters. Default 0.5.

mass: f32

The wheel’s mass in kg, which sets how fast torque spins it up. Default 20.

suspension_distance: f32

How far the suspension travels, meters. Default 0.3.

spring: f32

The suspension’s spring rate, N/m. Default 35 000.

damper: f32

The suspension’s damper rate, N·s/m. Default 4 500.

target_position: f32

Where the suspension rests under the car’s weight: 0 fully compressed, 1 fully extended. Default 0.5.

force_app_point_distance: f32

Where the suspension and tyre forces act: this far up the suspension from the bottom of the resting wheel. 0 (the default) at the tyre’s contact; near the center of mass rolls less.

damping_rate: f32

Slows the wheel’s spin by this many N·m per rad/s (rolling resistance, bearings). Default 0.25.

forward_friction: FrictionCurve

Grip along the wheel’s rolling direction.

sideways_friction: FrictionCurve

Grip across it.

motor_torque: f32

Drive torque, N·m: positive rolls forward (the chassis’s -Z).

brake_torque: f32

Brake torque, N·m (positive): slows the wheel’s spin to a stop.

steer_angle: f32

Steering, radians around the chassis’s up axis: positive steers right (clockwise seen from above).

local_rotation: Quat

The wheel’s turn relative to the chassis (steer, then spin): for drawing it, with local_position or pose.

grounded: bool

Touches the ground.

contact_point: Vec3

Where the tyre touches the ground (when grounded).

contact_normal: Vec3

The ground’s outward direction there (when grounded).

compression: f32

How far the suspension is pushed in from full extension, meters (0 in the air, suspension_distance bottomed out).

suspension_force: f32

The suspension’s push, newtons: the load on the tyre.

sprung_mass: f32

The share of the chassis’s mass this wheel carries, kg.

angular_velocity: f32

How fast the wheel spins, rad/s: positive rolls forward. See rpm.

forward_slip: f32

Forward slip (see FrictionCurve).

sideways_slip: f32

Sideways slip, radians: positive slides to the wheel’s right.

spin: f32

How far the wheel has turned, radians (0..2π), for drawing.

local_position: Vec3

The wheel’s center in the chassis’s frame, suspension travel included: for drawing it.

Implementations

impl Wheel3D

pub fn new(position: Vec3, radius: f32) -> Self

A wheel of radius mounted at position (its center at full compression, in the chassis’s frame), with the usual suspension and tyres.

Examples found in repository

examples/vehicle.rs (line 44)

fn spawn_car(ctx: &mut Ctx, at: Vec3) -> Entity {
    let mut car = Vehicle3D::new();
    for (x, z) in [(-0.8, -1.3), (0.8, -1.3), (-0.8, 1.3), (0.8, 1.3)] {
        let mut wheel = Wheel3D::new(vec3(x, -0.3, z), 0.35);
        wheel.sideways_friction.stiffness = 1.3;
        car = car.with_wheel(wheel);
    }
    ctx.world.spawn((
        Transform3D::at(at),
        RigidBody3D::dynamic()
            .mass(1200.0)
            .center_of_mass(vec3(0.0, -0.35, 0.0)),
        Collider3D::cuboid(vec3(1.8, 0.6, 4.2)),
        Velocity3D::default(),
        car,
    ))
}

pub fn rpm(&self) -> f32

How fast the wheel spins, in revolutions per minute.

use ponko::*;
let mut wheel = Wheel3D::new(Vec3::ZERO, 0.3);
wheel.angular_velocity = std::f32::consts::TAU; // one turn a second
assert!((wheel.rpm() - 60.0).abs() < 1e-3);

pub fn pose(&self, chassis: &Transform3D) -> Transform3D

Where to draw the wheel for a chassis at chassis: its center, with steer, spin and suspension travel. Pass the chassis’s Transform3D in a frame system and the wheel moves as smoothly as the chassis does.

use ponko::*;
let wheel = Wheel3D::new(vec3(1.0, 0.0, 0.0), 0.4);
let pose = wheel.pose(&Transform3D::at(vec3(0.0, 2.0, 0.0)));
// Hanging fully extended: 0.3 m below its mount.
assert!((pose.position - vec3(1.0, 1.7, 0.0)).length() < 1e-5);

Examples found in repository

examples/vehicle.rs (line 138)

fn place_wheels(ctx: &mut Ctx) {
    let player = ctx.world.resource::<Player>();
    let car = player.car;
    let (Some(&vehicle), Some(&chassis)) = (ctx.world.get::<Vehicle3D>(car), ctx.world.get::<Transform3D>(car)) else {
        return;
    };
    for i in 0..player.wheels.len() {
        let e = ctx.world.resource::<Player>().wheels[i];
        let pose = vehicle.wheels()[i].pose(&chassis);
        if let Some(t) = ctx.world.get_mut::<Transform3D>(e) {
            *t = Transform3D { scale: t.scale, ..pose };
        }
    }
}

Trait Implementations

impl Clone for Wheel3D

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Wheel3D

impl Debug for Wheel3D

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Wheel3D

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Wheel3D

where Wheel3D: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Wheel3D

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Wheel3D

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Wheel3D