dynamis_world/world/

step.rs

use super::World;
use crate::dynamics::FrameParams;
use crate::world::commands::{CompiledBodyCommands, CompiledConstraintCommands};

use dynamis_layout::{COUNTER_ACTIVE, QueryResultRecord, RowStreams, StepParamsRecord};
use std::mem::size_of;

impl World {
    pub fn set_time_scale(&mut self, time_scale: f32) {
        assert!(time_scale > 0.0, "time scale must be strictly positive");
        self.clock.time_scale = time_scale;
    }

    pub fn update(&mut self, real_dt: f32, sub_dt: f32, max_substeps: u32) {
        assert!(real_dt >= 0.0, "real dt must be non-negative");
        assert!(sub_dt > 0.0, "sub dt must be strictly positive");
        assert!(max_substeps > 0, "max substeps must be positive");
        self.clock.sub_dt = sub_dt;
        self.clock.accumulator += real_dt * self.clock.time_scale;
        let mut steps = 0;
        while self.clock.accumulator >= sub_dt && steps < max_substeps {
            self.step(sub_dt);
            self.clock.accumulator -= sub_dt;
            steps += 1;
        }
        if steps == max_substeps {
            self.clock.accumulator %= sub_dt;
        }
    }

    pub fn interpolation_alpha(&self) -> f32 {
        (self.clock.accumulator / self.clock.sub_dt).clamp(0.0, 1.0)
    }

    pub fn step(&mut self, dt: f32) {
        assert!(dt > 0.0, "timestep must be strictly positive");
        self.backend.gpu.assert_alive();
        let step = self.clock.step;
        self.collect_readbacks();
        self.apply_plan();
        self.flush_rows();
        self.apply_pending_commands();
        self.write_step_records(dt);
        let query_count = self.queries.pending.len() as u32;
        let batch = self.submit_queries(step, query_count);
        let quiet = self.backend.measured_step.is_some_and(|measured| {
            self.backend.measured[COUNTER_ACTIVE] == 0
                && self
                    .backend
                    .commanded_step
                    .is_none_or(|commanded| commanded <= measured)
        });
        let idle = quiet && self.constraints.alive.is_empty();
        let frame = FrameParams {
            dynamic_count: self.bodies.dynamic_count as u32,
            body_count: self.bodies.alive.len() as u32,
            solve_iterations: self.config.solve_iterations,
            island_rounds: self.island_rounds(),
            query_count,
            constraint_count: self.constraints.alive.len() as u32,
            edit_run_count: self.bodies.last_edits,
            body_move_count: self.bodies.last_moves,
            constraint_move_count: self.constraints.last_moves,
        };
        self.encode_step(&frame, batch, step, idle);
        self.bodies.device_count = frame.body_count;
        self.queries.pending.clear();
        self.clock.step += 1;
        self.bodies.states_ready = false;
    }

    pub(crate) fn apply_pending_commands(&mut self) {
        if self.bodies.commands.is_empty() && self.constraints.commands.is_empty() {
            self.bodies.last_edits = 0;
            self.bodies.last_moves = 0;
            self.constraints.last_commands = 0;
            self.constraints.last_moves = 0;
            return;
        }
        self.backend.commanded_step = Some(self.clock.step);
        let body_commands = self.compile_body_commands();
        let constraint_commands = self.compile_constraint_commands();
        self.upload_body_commands(&body_commands);
        self.upload_constraint_commands(&constraint_commands);
        self.bodies.last_edits = body_commands.runs.len() as u32;
        self.constraints.last_commands = self.constraints.commands.len() as u32;
        self.bodies.commands.clear();
        self.constraints.commands.clear();
    }

    fn write_step_records(&self, dt: f32) {
        let queue = self.backend.gpu.queue();
        self.write_declared_counters();
        let params = StepParamsRecord::new(
            &self.config,
            dt,
            self.bodies.dynamic_count as u32,
            self.bodies.alive.len() as u32,
            self.constraints.alive.len() as u32,
            RowStreams {
                edit_runs: self.bodies.last_edits,
                body_moves: self.bodies.last_moves,
                constraint_moves: self.constraints.last_moves,
            },
            self.event_slot_of(self.clock.step),
        );
        self.backend
            .buffers
            .params
            .write(queue, bytemuck::cast_slice(&[params]));
    }

    fn upload_body_commands(&mut self, compiled: &CompiledBodyCommands) {
        let queue = self.backend.gpu.queue();
        self.backend
            .buffers
            .bodies
            .row_moves
            .write(queue, bytemuck::cast_slice(&compiled.moves));
        self.backend
            .buffers
            .bodies
            .fresh_rows
            .write(queue, bytemuck::cast_slice(&compiled.fresh));
        self.backend
            .buffers
            .bodies
            .edits
            .write(queue, bytemuck::cast_slice(&compiled.edits));
        self.backend
            .buffers
            .bodies
            .edit_runs
            .write(queue, bytemuck::cast_slice(&compiled.runs));
        self.bodies.last_moves = compiled.moves.len() as u32;
    }

    fn upload_constraint_commands(&mut self, compiled: &CompiledConstraintCommands) {
        let queue = self.backend.gpu.queue();
        self.backend
            .buffers
            .constraints
            .row_moves
            .write(queue, bytemuck::cast_slice(&compiled.moves));
        self.backend
            .buffers
            .constraints
            .fresh_rows
            .write(queue, bytemuck::cast_slice(&compiled.fresh));
        self.constraints.last_moves = compiled.moves.len() as u32;
    }

    fn submit_queries(&mut self, step: u64, query_count: u32) -> Option<u64> {
        if query_count == 0 {
            return None;
        }
        self.backend.buffers.queries.records.write(
            self.backend.gpu.queue(),
            bytemuck::cast_slice(&self.queries.pending),
        );
        let batch = self.queries.next_batch;
        self.queries.pool.submit(batch, step, query_count as usize);
        self.queries.next_batch += 1;
        Some(batch)
    }

    fn encode_step(&mut self, frame: &FrameParams, batch: Option<u64>, step: u64, idle: bool) {
        let device = self.backend.gpu.device().clone();
        let queue = self.backend.gpu.queue().clone();
        let mut encoder = dynamis_gpu::SubmissionEncoder::new(&device, "dynamis step");

        self.copy_events(&mut encoder);
        self.backend
            .pipeline
            .encode(&mut encoder, &self.backend.buffers, frame, idle);
        #[cfg(feature = "profile")]
        let timings = self.backend.pipeline.capture_timings(&mut encoder, step);
        let pack_bytes = self.pack_step(&mut encoder);
        let pack = self.backend.buffers.readback.step.enqueue(
            &mut encoder,
            self.backend.buffers.readback.pack.buffer(),
            0,
            pack_bytes,
            step,
        );
        let queries = match batch {
            Some(batch) => self.backend.buffers.readback.queries.enqueue(
                &mut encoder,
                self.backend.buffers.queries.results.buffer(),
                0,
                self.queries.pending.len() as u64 * size_of::<QueryResultRecord>() as u64,
                batch,
            ),
            None => None,
        };
        encoder.submit(&queue);
        #[cfg(feature = "profile")]
        if let Some((_step, timings)) = timings {
            self.backend.pass_timings = timings;
        }
        if let Some((step, bytes)) = pack {
            self.consume_pack(step, &bytes);
        }
        if let Some((batch, bytes)) = queries {
            self.queries.pool.collect(batch, &bytes);
        }
    }

    #[cfg(feature = "profile")]
    pub fn gpu_pass_timings(&self) -> &[dynamis_gpu::GpuPassTiming] {
        &self.backend.pass_timings
    }

    #[cfg(feature = "profile")]
    pub fn gpu_timing_supported(&self) -> bool {
        self.backend.gpu.supports_pass_timing()
    }
}