//! Fixed-step physics for the cart shown in the window. mod cart; mod pacing; #[cfg(test)] mod tests; use std::time::Duration; use fabrilis_core::time::SimDelta; use fabrilis_core::vec::{Quat, Vec3}; use fabrilis_physics::{PhysicsBackend, RapierBackend, TrimeshDesc}; use fabrilis_render::Scene; use fabrilis_worldgen::terrain::{Heightmap, TerrainMesh}; use crate::runtime::AppError; use crate::runtime::metrics::Stopwatch; use cart::{Cart, CartInfo, CartPose}; use pacing::{MAX_STEPS, Pacer}; pub(crate) use cart::Drive; /// Physics rate; the step never changes with the frame time. const HZ: u64 = 1_000; /// The Rapier world and the cart it drives. pub(crate) struct Simulation { backend: RapierBackend, cart: Cart, step: SimDelta, pacer: Pacer, total_steps: u64, slowest_step: Duration, } impl Simulation { /// Builds the terrain collider and spawns the cart into the scene. pub(crate) fn new( terrain: &TerrainMesh, heightmap: &Heightmap, scene: &mut Scene, ) -> Result { let step = SimDelta::from_hz(HZ).ok_or_else(|| { AppError::Physics("physics step is not a whole nanosecond".to_owned()) })?; let mut backend = RapierBackend::new(); let collider = TrimeshDesc { vertices: terrain.vertices.clone(), indices: terrain.indices.clone(), position: Vec3::ZERO, rotation: Quat::IDENTITY, }; backend .add_trimesh(collider) .ok_or_else(|| AppError::Physics("terrain collider was rejected".to_owned()))?; let cart = Cart::new(&mut backend, heightmap, scene); Ok(Self { backend, cart, step, pacer: Pacer::new(), total_steps: 0, slowest_step: Duration::ZERO, }) } /// Runs the fixed steps owed for this frame and copies transforms to the scene. /// /// Diagnostics time each step individually, but only observe it: the number /// of steps, their order and the Rapier calls stay exactly the same, so the /// resulting state hash does not depend on logging being enabled. pub(crate) fn advance(&mut self, scene: &mut Scene, drive: Drive) -> pacing::Frame { let frame = self.pacer.advance(self.step.nanos(), MAX_STEPS); self.slowest_step = Duration::ZERO; self.total_steps = self.total_steps.saturating_add(u64::from(frame.steps)); self.cart.drive(&mut self.backend, drive); self.run_steps(frame.steps); self.cart.sync(&self.backend, scene); frame } /// Runs exactly `steps` fixed steps with no wall clock, for golden tests and /// a future headless CLI. The motors are set once, before the batch. #[allow( dead_code, reason = "the headless CLI will step the same world without wall clock" )] pub(crate) fn step_fixed(&mut self, steps: u32, drive: Drive) { self.slowest_step = Duration::ZERO; self.total_steps = self.total_steps.saturating_add(u64::from(steps)); self.cart.drive(&mut self.backend, drive); for _ in 0..steps { self.backend.step(self.step); } } /// Simulated seconds represented by the steps that have actually run. #[must_use] pub(crate) fn sim_seconds(&self) -> f64 { self.total_steps as f64 * self.step.nanos() as f64 / 1_000_000_000.0 } /// The slowest single physics step of the latest frame. #[must_use] pub(crate) fn slowest_step(&self) -> Duration { self.slowest_step } /// The current chassis pose and wheel angles, used by the golden test. #[allow( dead_code, reason = "read by the golden test and by the future headless CLI" )] #[must_use] pub(crate) fn cart_pose(&self) -> Option { self.cart.pose(&self.backend) } /// What the startup banner reports about the cart. #[must_use] pub(crate) fn cart_info(&self) -> CartInfo { self.cart.info() } /// Steps the backend while observing how long each step took. fn run_steps(&mut self, steps: u32) { for _ in 0..steps { let step_start = Stopwatch::start(); self.backend.step(self.step); self.slowest_step = self.slowest_step.max(step_start.elapsed()); } } }