use lgwks_std::id::Uuid;
use std::collections::BTreeMap;
use super::super::error::{MotionError, MotionErrorCode};
use super::spring::SpringConfig;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum AccumulatorKind {
Spring,
Drag,
Scrub,
}
#[derive(Clone, Debug, PartialEq)]
pub struct AccumulatorComponent {
kind: AccumulatorKind,
spring_config: Option<SpringConfig>,
scrub_source_id: Option<String>,
preserve_velocity: bool,
}
impl AccumulatorComponent {
#[must_use]
pub const fn new_spring(config: SpringConfig) -> Self {
Self {
kind: AccumulatorKind::Spring,
spring_config: Some(config),
scrub_source_id: None,
preserve_velocity: true,
}
}
pub fn new_scrub(source_id: String) -> Result<Self, MotionError> {
MotionError::require(
!source_id.is_empty(),
MotionErrorCode::PatchInvalid,
"scrub_source_id must not be empty",
)?;
Ok(Self {
kind: AccumulatorKind::Scrub,
spring_config: None,
scrub_source_id: Some(source_id),
preserve_velocity: false,
})
}
#[must_use]
pub const fn new_drag() -> Self {
Self {
kind: AccumulatorKind::Drag,
spring_config: None,
scrub_source_id: None,
preserve_velocity: true,
}
}
#[must_use]
pub const fn kind(&self) -> AccumulatorKind {
self.kind
}
#[must_use]
pub const fn spring_config(&self) -> Option<&SpringConfig> {
self.spring_config.as_ref()
}
#[must_use]
pub fn scrub_source_id(&self) -> Option<&str> {
self.scrub_source_id.as_deref()
}
#[must_use]
pub const fn preserve_velocity(&self) -> bool {
self.preserve_velocity
}
#[must_use]
pub fn with_preserve_velocity(mut self, preserve: bool) -> Self {
self.preserve_velocity = preserve;
self
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[non_exhaustive]
pub struct AccumulatorState {
node_id: Uuid,
position: f32,
velocity: f32,
last_scrub_value: Option<f32>,
last_t_wall_ms: Option<f64>,
lease_generation: u32,
}
impl AccumulatorState {
#[must_use]
pub const fn zero(node_id: Uuid) -> Self {
Self {
node_id,
position: 0.0,
velocity: 0.0,
last_scrub_value: None,
last_t_wall_ms: None,
lease_generation: 0,
}
}
#[must_use]
pub const fn node_id(&self) -> Uuid {
self.node_id
}
#[must_use]
pub const fn position(&self) -> f32 {
self.position
}
pub const fn set_position(&mut self, position: f32) {
self.position = position;
}
#[must_use]
pub const fn velocity(&self) -> f32 {
self.velocity
}
pub const fn set_velocity(&mut self, velocity: f32) {
self.velocity = velocity;
}
#[must_use]
pub const fn last_scrub_value(&self) -> Option<f32> {
self.last_scrub_value
}
pub const fn set_last_scrub_value(&mut self, value: f32) {
self.last_scrub_value = Some(value);
}
#[must_use]
pub const fn last_t_wall_ms(&self) -> Option<f64> {
self.last_t_wall_ms
}
pub const fn set_last_t_wall_ms(&mut self, wall_ms: f64) {
self.last_t_wall_ms = Some(wall_ms);
}
#[must_use]
pub const fn lease_generation(&self) -> u32 {
self.lease_generation
}
}
pub struct AccumulatorStore {
states: BTreeMap<Uuid, AccumulatorState>,
current_generation: u32,
}
impl AccumulatorStore {
#[must_use]
pub fn new() -> Self {
Self {
states: BTreeMap::new(),
current_generation: 1,
}
}
pub fn rotate_and_reap(&mut self) {
let dead_generation = self.current_generation;
self.current_generation = self.current_generation.saturating_add(1);
self.states
.retain(|_, state| state.lease_generation >= dead_generation);
}
#[must_use]
pub fn get(&self, node_id: &Uuid) -> Option<&AccumulatorState> {
self.states.get(node_id)
}
pub fn get_or_default(&mut self, node_id: Uuid) -> &mut AccumulatorState {
let generation = self.current_generation;
let state = self
.states
.entry(node_id)
.or_insert_with(|| AccumulatorState::zero(node_id));
state.lease_generation = generation;
state
}
pub fn set(&mut self, node_id: Uuid, mut state: AccumulatorState) {
state.lease_generation = self.current_generation;
state.node_id = node_id;
self.states.insert(node_id, state);
}
pub fn remove(&mut self, node_id: &Uuid) {
self.states.remove(node_id);
}
}
impl Default for AccumulatorStore {
fn default() -> Self {
Self::new()
}
}