Struct Velocity 

pub struct Velocity(/* private fields */);

Validated bounded velocity component; no fluid/rigid-body solver is implied.

Implementations

impl Velocity

pub fn new(value: [f32; 3]) -> Result<Self, RenderError>

Reject non-finite or excessively large local velocities before storing them.

Examples found in repository

examples/scene.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Opaque asset identities only; this example qualifies CPU scene ownership, not drawing.
    let mut assets = ResourceArena::new(RenderLimits::default())?;
    let binding = RenderBinding {
        mesh: assets.insert((), 1)?,
        material: assets.insert((), 1)?,
        tint: [1.0; 4],
        animation: 0,
        morph: 0,
    };
    let mut world = SceneWorld::new(SceneLimits {
        max_entities: 64,
        max_snapshot_instances: 64,
        ..Default::default()
    })?;
    let mut first = None;
    for i in 0..64 {
        let id = world.spawn(
            Transform::default().with_position([i as f32, 0.0, 0.0])?,
            binding,
            Some(Velocity::new([1.0, 0.0, 0.0])?),
        )?;
        first = first.or(Some(id));
    }
    let before = world.snapshot()?;
    world.step_velocity(0.016)?;
    let after = world.snapshot()?;
    assert_eq!(before.instances()[0].transform.position()[0], 0.0);
    assert_eq!(after.instances()[0].transform.position()[0], 0.016);
    let mut commands = SceneCommands::new(8)?;
    if let Some(first) = first {
        commands.push(SceneCommand::SetVelocity(first, None))?;
    }
    for outcome in commands.apply(&mut world)? {
        outcome?;
    }
    println!(
        "entities={} owned_snapshots=2 moving_rows={}",
        world.len(),
        world.moving_columns().entities.len()
    );
    Ok(())
}

pub fn value(self) -> [f32; 3]

Local units per second.

Trait Implementations

impl Clone for Velocity

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 Velocity

impl Debug for Velocity

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

Formats the value using the given formatter.

impl PartialEq for Velocity

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Velocity