Struct SnapshotBuffer 

pub struct SnapshotBuffer<T: Interpolate> { /* private fields */ }

Timestamped states of one entity, in time order, read back at any time: interpolated between two snapshots, predicted for a bounded time past the newest, then held. Times are the sender’s, in seconds on any timeline you like (for a remote entity use SnapshotStream, which also converts your local clock).

Snapshots may arrive in any order and more than once.

use ponko::*;
let mut buffer = SnapshotBuffer::new();
buffer.push(1.0, vec3(10.0, 0.0, 0.0));
buffer.push(0.0, vec3(0.0, 0.0, 0.0)); // arrived late: still placed first
assert_eq!(buffer.push(1.0, vec3(99.0, 0.0, 0.0)), SnapshotPush::Duplicate);

let s = buffer.sample_at(0.25).unwrap();
assert_eq!(s.value, vec3(2.5, 0.0, 0.0));
assert_eq!(s.state, SnapshotState::Interpolated);
// Packets stop: predict for up to 0.25 s, then hold.
assert_eq!(buffer.sample_at(1.1).unwrap().state, SnapshotState::Extrapolated);
let held = buffer.sample_at(5.0).unwrap();
assert_eq!(held.state, SnapshotState::Held);
assert_eq!(held.value, vec3(12.5, 0.0, 0.0));

Implementations

impl<T: Interpolate> SnapshotBuffer<T>

pub fn new() -> Self

An empty buffer with the default SnapshotConfig.

let b = ponko::SnapshotBuffer::<f32>::new();
assert!(b.is_empty());

pub fn with_config(config: SnapshotConfig) -> Self

An empty buffer. Panics if capacity is below 2 or a time setting is negative or not finite.

use ponko::*;
let b = SnapshotBuffer::<f32>::with_config(SnapshotConfig { delay: 0.2, ..Default::default() });
assert_eq!(b.config().delay, 0.2);

pub fn config(&self) -> SnapshotConfig

The settings it was made with.

assert_eq!(ponko::SnapshotBuffer::<f32>::new().config().delay, 0.1);

pub fn push(&mut self, time: f64, value: T) -> SnapshotPush

Stores value, stamped time. Late snapshots go in at their place in time; one with the same timestamp as a stored snapshot is ignored. When the buffer is full the oldest snapshot is dropped.

use ponko::*;
let mut b = SnapshotBuffer::new();
assert_eq!(b.push(1.0, 1.0f32), SnapshotPush::Added);
assert_eq!(b.push(1.0, 1.0f32), SnapshotPush::Duplicate);
assert_eq!(b.push(f64::NAN, 1.0f32), SnapshotPush::Invalid);

pub fn sample_at(&self, time: f64) -> Option<SnapshotSample<T>>

The state at time (the sender’s timeline): interpolated between the snapshots around it; past the newest, predicted up to max_extrapolation and then held where the prediction ended; before the oldest, the oldest. None while the buffer is empty. Allocation free.

use ponko::*;
let mut b = SnapshotBuffer::new();
assert!(b.sample_at(0.0).is_none());
b.push(0.0, 0.0f32);
b.push(1.0, 4.0);
assert_eq!(b.sample_at(0.5).unwrap().value, 2.0);

pub fn sample(&self, now: f64) -> Option<SnapshotSample<T>>

The state to show at now, delay seconds in the past; for buffers filled with times from the clock now is on.

use ponko::*;
let mut b = SnapshotBuffer::new();
b.push(0.0, 0.0f32);
b.push(1.0, 10.0);
assert_eq!(b.sample(0.6).unwrap().value, 5.0); // 0.6 - 0.1 s delay

pub fn latest_time(&self) -> Option<f64>

Timestamp of the newest snapshot.

let mut b = ponko::SnapshotBuffer::new();
b.push(2.0, 0.0f32);
assert_eq!(b.latest_time(), Some(2.0));

pub fn oldest_time(&self) -> Option<f64>

Timestamp of the oldest snapshot kept.

let mut b = ponko::SnapshotBuffer::new();
b.push(2.0, 0.0f32);
assert_eq!(b.oldest_time(), Some(2.0));

pub fn len(&self) -> usize

Number of snapshots kept.

assert_eq!(ponko::SnapshotBuffer::<f32>::new().len(), 0);

pub fn is_empty(&self) -> bool

Whether no snapshot is kept.

assert!(ponko::SnapshotBuffer::<f32>::new().is_empty());

pub fn clear(&mut self)

Drops every snapshot. Do this on a teleport, a respawn or a restart of the sender’s clock, so the entity jumps instead of sliding across.

let mut b = ponko::SnapshotBuffer::new();
b.push(0.0, 0.0f32);
b.clear();
assert!(b.is_empty());

pub fn trim_before(&mut self, time: f64)

Drops snapshots that can no longer be shown at time or later: all but the newest one at or before it.

let mut b = ponko::SnapshotBuffer::new();
for i in 0..5 { b.push(i as f64, 0.0f32); }
b.trim_before(3.5);
assert_eq!(b.oldest_time(), Some(3.0));

Trait Implementations

impl<T: Clone + Interpolate> Clone for SnapshotBuffer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Interpolate> Debug for SnapshotBuffer<T>

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

Formats the value using the given formatter.

impl<T: Interpolate> Default for SnapshotBuffer<T>

fn default() -> Self

Returns the “default value” for a type.