Struct PhysicsLitePlugin 

pub struct PhysicsLitePlugin {
    pub bodies: Vec<PhysicsBody>,
    pub gravity: Vec3,
}

A plugin that integrates velocity, applies gravity, and reflects bodies off bounding box walls.

Runs in the [RuntimePhase::Simulate] phase. Pairs well with crate::FixedTimestep for stable integration.

World-bounds collisions produce ContactEvents in crate::RuntimeOutput with node_b set to NodeId::MAX (a sentinel for world geometry).

Example

use viewport_lib::{Aabb, FixedTimestep, PhysicsBody, PhysicsLitePlugin, ViewportRuntime};

let bounds = Aabb { min: glam::Vec3::splat(-5.0), max: glam::Vec3::splat(5.0) };
let mut physics = PhysicsLitePlugin::new()
    .with_gravity(glam::Vec3::new(0.0, 0.0, -9.81));
physics.add_body(
    PhysicsBody::new(node_id)
        .with_velocity(glam::Vec3::new(2.0, 1.0, 4.0))
        .with_bounds(bounds),
);

let runtime = ViewportRuntime::new()
    .with_fixed_timestep(FixedTimestep::new(60.0))
    .with_plugin(physics);

Fields

bodies: Vec<PhysicsBody>

All bodies managed by this plugin.

gravity: Vec3

Global gravity acceleration vector (world space).

Implementations

impl PhysicsLitePlugin

pub fn new() -> Self

Create with default downward gravity (-Z) and no bodies.

pub fn with_gravity(self, gravity: Vec3) -> Self

Set the gravity vector.

pub fn add_body(&mut self, body: PhysicsBody)

Add a body.

pub fn body_mut(&mut self, node_id: NodeId) -> Option<&mut PhysicsBody>

Get a mutable reference to the body for node_id, if it exists.

Trait Implementations

impl Default for PhysicsLitePlugin

fn default() -> Self

Returns the “default value” for a type.

impl RuntimePlugin for PhysicsLitePlugin

fn priority(&self) -> i32

Numeric execution priority. Lower values run first. Use the constants in phase as base values and offset within a band if needed.

fn step(&mut self, ctx: &mut RuntimeStepContext<'_>)

Called once per phase execution.

fn submit(&mut self, _ctx: &RuntimeStepContext<'_>)

Called once per frame before the step loop, in priority order.

fn collect(&mut self, _ctx: &mut RuntimeStepContext<'_>)

Called once per frame after the step loop, in priority order.

fn on_event(&mut self, _event: &RuntimeEvent, _ctx: &mut RuntimeStepContext<'_>)

Called for each lifecycle event before the step loop.