685 lines
22 KiB
Rust
685 lines
22 KiB
Rust
use super::*;
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct Sample {
|
|
time: Duration,
|
|
current: f64,
|
|
velocity: f64,
|
|
target: f64,
|
|
}
|
|
|
|
struct FakeClock {
|
|
now: Duration,
|
|
last: Duration,
|
|
paused: bool,
|
|
trace: Vec<Sample>,
|
|
}
|
|
|
|
impl FakeClock {
|
|
fn new() -> Self {
|
|
Self {
|
|
now: Duration::ZERO,
|
|
last: Duration::ZERO,
|
|
paused: false,
|
|
trace: Vec::new(),
|
|
}
|
|
}
|
|
|
|
fn sample(
|
|
&mut self,
|
|
time: Duration,
|
|
value: &mut AnimatedValue,
|
|
config: SpringConfig,
|
|
) -> Sample {
|
|
assert!(time >= self.now);
|
|
self.now = time;
|
|
let delta = time - self.last;
|
|
self.last = time;
|
|
if !self.paused {
|
|
value.advance(delta, config);
|
|
}
|
|
let sample = Sample {
|
|
time,
|
|
current: value.current,
|
|
velocity: value.velocity,
|
|
target: value.target,
|
|
};
|
|
self.trace.push(sample);
|
|
sample
|
|
}
|
|
|
|
fn pause(&mut self) {
|
|
self.paused = true;
|
|
}
|
|
|
|
fn resume(&mut self, time: Duration) {
|
|
self.now = time;
|
|
self.last = time;
|
|
self.paused = false;
|
|
}
|
|
}
|
|
|
|
// Frozen scalar integrator, including its cap, substeps and crossing snap.
|
|
fn legacy_advance(value: &mut AnimatedValue, delta: Duration, config: SpringConfig) {
|
|
let config = config.normalized();
|
|
let settled = |v: &AnimatedValue| {
|
|
(v.current - v.target).abs() <= config.position_tolerance
|
|
&& v.velocity.abs() <= config.velocity_tolerance
|
|
};
|
|
if settled(value) {
|
|
value.snap();
|
|
return;
|
|
}
|
|
|
|
let seconds = delta.min(Duration::from_millis(100)).as_secs_f64();
|
|
let steps = (seconds / (1.0 / 240.0)).ceil().max(1.0) as usize;
|
|
let dt = seconds / steps as f64;
|
|
for _ in 0..steps {
|
|
let old = value.current - value.target;
|
|
value.velocity +=
|
|
(-config.stiffness * old - config.damping * value.velocity) / config.mass * dt;
|
|
value.current += value.velocity * dt;
|
|
if old != 0.0 && old.signum() != (value.current - value.target).signum() {
|
|
value.snap();
|
|
break;
|
|
}
|
|
}
|
|
if settled(value) {
|
|
value.snap();
|
|
}
|
|
}
|
|
|
|
fn close(a: f64, b: f64, epsilon: f64) {
|
|
assert!((a - b).abs() <= epsilon, "{a} != {b}, tolerance {epsilon}");
|
|
}
|
|
|
|
#[test]
|
|
fn capture_old_golden_trace_and_retarget_policy() {
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(500.0);
|
|
for i in 1..=18 {
|
|
legacy_advance(
|
|
&mut value,
|
|
Duration::from_secs_f64(1.0 / 60.0),
|
|
SpringConfig::default(),
|
|
);
|
|
if [1, 3, 6, 12, 18].contains(&i) {
|
|
println!("old normal {i}: {}, {}", value.current, value.velocity);
|
|
}
|
|
}
|
|
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(1000.0);
|
|
legacy_advance(
|
|
&mut value,
|
|
Duration::from_millis(40),
|
|
SpringConfig::default(),
|
|
);
|
|
println!("old retarget before: {}, {}", value.current, value.velocity);
|
|
let position = value.current;
|
|
let velocity = value.velocity;
|
|
value.retarget_preserving_motion(2000.0);
|
|
assert_eq!(value.current, position);
|
|
assert_eq!(value.velocity, velocity);
|
|
value.retarget_preserving_motion(-500.0);
|
|
println!("old reversal: {}, {}", value.current, value.velocity);
|
|
assert_eq!(value.current, position);
|
|
assert_eq!(value.velocity, velocity);
|
|
}
|
|
|
|
#[test]
|
|
fn long_stall_uses_the_whole_elapsed_duration() {
|
|
let config = SpringConfig {
|
|
mass: 1.0,
|
|
stiffness: 100.0,
|
|
damping: 20.0,
|
|
..SpringConfig::default()
|
|
};
|
|
let mut clock = FakeClock::new();
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(500.0);
|
|
clock.sample(Duration::from_millis(16), &mut value, config);
|
|
let sample = clock.sample(Duration::from_millis(416), &mut value, config);
|
|
let t: f64 = 0.416;
|
|
let decay = (-10.0 * t).exp();
|
|
close(
|
|
sample.current,
|
|
500.0 - 500.0 * (1.0 + 10.0 * t) * decay,
|
|
1e-8,
|
|
);
|
|
close(sample.velocity, 50000.0 * t * decay, 1e-8);
|
|
assert_eq!(sample.time, Duration::from_millis(416));
|
|
assert_eq!(sample.target, 500.0);
|
|
}
|
|
|
|
#[test]
|
|
fn physical_solver_crosses_equilibrium_without_zeroing_velocity() {
|
|
let mut x = 0.0;
|
|
let mut v = 20000.0;
|
|
advance_value(&mut x, 100.0, &mut v, 0.01, SpringConfig::default());
|
|
assert!(x > 100.0, "physical solution was snapped: {x}");
|
|
assert!(v > 0.0, "velocity was erased: {v}");
|
|
}
|
|
|
|
#[test]
|
|
fn fake_clock_pause_excludes_three_hundred_milliseconds() {
|
|
let mut clock = FakeClock::new();
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(500.0);
|
|
clock.sample(
|
|
Duration::from_millis(40),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
let frozen = value;
|
|
clock.pause();
|
|
clock.sample(
|
|
Duration::from_millis(340),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
assert_eq!(value, frozen);
|
|
clock.resume(Duration::from_millis(340));
|
|
clock.sample(
|
|
Duration::from_millis(356),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
let mut expected = frozen;
|
|
expected.advance(Duration::from_millis(16), SpringConfig::default());
|
|
assert_eq!(value, expected);
|
|
}
|
|
|
|
fn physical(x: f64, v: f64, target: f64, dt: f64, config: SpringConfig) -> (f64, f64) {
|
|
let (mut x, mut v) = (x, v);
|
|
advance_value(&mut x, target, &mut v, dt, config);
|
|
(x, v)
|
|
}
|
|
|
|
// Independent characteristic-root reference, used away from ill-conditioned roots.
|
|
fn reference(x: f64, v: f64, target: f64, dt: f64, config: SpringConfig) -> (f64, f64) {
|
|
let a = config.damping / (2.0 * config.mass);
|
|
let omega2 = config.stiffness / config.mass;
|
|
let y = x - target;
|
|
let d = a * a - omega2;
|
|
if d.abs() < 1e-10 {
|
|
let b = v + a * y;
|
|
let e = (-a * dt).exp();
|
|
return (target + e * (y + b * dt), e * (v - a * b * dt));
|
|
}
|
|
|
|
if d < 0.0 {
|
|
let w = (-d).sqrt();
|
|
let b = (v + a * y) / w;
|
|
let (s, c) = (w * dt).sin_cos();
|
|
let e = (-a * dt).exp();
|
|
(
|
|
target + e * (y * c + b * s),
|
|
e * (v * c - (a * v + omega2 * y) / w * s),
|
|
)
|
|
} else {
|
|
let q = d.sqrt();
|
|
let r1 = -a + q;
|
|
let r2 = -a - q;
|
|
let c1 = (v - r2 * y) / (r1 - r2);
|
|
let c2 = y - c1;
|
|
let e1 = (r1 * dt).exp();
|
|
let e2 = (r2 * dt).exp();
|
|
(target + c1 * e1 + c2 * e2, c1 * r1 * e1 + c2 * r2 * e2)
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn solver_reference_regimes_initial_states_and_times() {
|
|
for damping in [
|
|
0.0,
|
|
5.0,
|
|
20.0,
|
|
20.0 * (1.0 - 1e-9),
|
|
20.0 * (1.0 + 1e-9),
|
|
53.0,
|
|
2000.0,
|
|
] {
|
|
let config = SpringConfig {
|
|
stiffness: 100.0,
|
|
damping,
|
|
..SpringConfig::default()
|
|
};
|
|
for (x, v, target) in [
|
|
(0., 0., 0.),
|
|
(0., 100., 0.),
|
|
(500., 0., 0.),
|
|
(-500., 1234., 200.),
|
|
(500., -1234., -200.),
|
|
] {
|
|
for dt in [0.0, 1e-12, 0.0083, 0.05, 0.4, 5.0] {
|
|
let actual = physical(x, v, target, dt, config);
|
|
let expected = reference(x, v, target, dt, config);
|
|
close(actual.0, expected.0, 1e-6);
|
|
close(actual.1, expected.1, 1e-5);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn near_critical_sweep_has_no_regime_jump() {
|
|
let base = SpringConfig {
|
|
stiffness: 100.0,
|
|
damping: 20.0,
|
|
..SpringConfig::default()
|
|
};
|
|
for dt in [1e-12, 0.01, 0.2, 2.0] {
|
|
let critical = physical(-500., 1234., 100., dt, base);
|
|
for offset in [-1e-9, -1e-12, 0., 1e-12, 1e-9] {
|
|
let config = SpringConfig {
|
|
damping: 20.0 * (1.0 + offset),
|
|
..base
|
|
};
|
|
let actual = physical(-500., 1234., 100., dt, config);
|
|
close(actual.0, critical.0, 1e-6);
|
|
close(actual.1, critical.1, 1e-5);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn normal_trace_records_the_old_numerical_error() {
|
|
// Captured BEFORE replacing the integrator. Duration rounds to nanoseconds,
|
|
// giving five old substeps at 60 Hz, not four exact 1/240-second steps.
|
|
let gold = [
|
|
(1, 45.440622413787736, 3968.266514512032),
|
|
(3, 204.05862514520575, 4637.558952650968),
|
|
(6, 375.42995175442246, 2376.3948049425335),
|
|
(12, 482.2490947739653, 366.6034676365624),
|
|
(18, 497.62691927670414, 49.586155106479524),
|
|
];
|
|
let mut old = AnimatedValue::new(0.0);
|
|
old.set_target(500.0);
|
|
let mut max_error: f64 = 0.0;
|
|
for i in 1..=18 {
|
|
legacy_advance(
|
|
&mut old,
|
|
Duration::from_secs_f64(1.0 / 60.0),
|
|
SpringConfig::default(),
|
|
);
|
|
if let Some((_, x, v)) = gold.iter().find(|(n, _, _)| *n == i) {
|
|
close(old.current, *x, 1e-9);
|
|
close(old.velocity, *v, 1e-9);
|
|
}
|
|
let dt = Duration::from_secs_f64(1.0 / 60.0).as_secs_f64() * i as f64;
|
|
let exact = reference(0., 0., 500., dt, SpringConfig::default());
|
|
max_error = max_error.max((old.current - exact.0).abs());
|
|
}
|
|
assert!(
|
|
max_error > 13.0 && max_error < 14.0,
|
|
"old integrator error: {max_error}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn retarget_golden_policy_values() {
|
|
let mut old = AnimatedValue::new(0.0);
|
|
old.set_target(1000.0);
|
|
legacy_advance(&mut old, Duration::from_millis(40), SpringConfig::default());
|
|
close(old.current, 318.94300938241565, 1e-9);
|
|
close(old.velocity, 9837.123292018367, 1e-9);
|
|
old.retarget_preserving_motion(2000.);
|
|
close(old.velocity, 9837.123292018367, 1e-9);
|
|
old.retarget_preserving_motion(-500.);
|
|
close(old.velocity, 9837.123292018367, 1e-9);
|
|
}
|
|
|
|
#[test]
|
|
fn zero_elapsed_time_is_a_strict_noop_even_inside_settling_tolerance() {
|
|
let mut value = AnimatedValue::new(0.05);
|
|
value.set_target(0.0);
|
|
let before = value;
|
|
value.advance(Duration::ZERO, SpringConfig::default());
|
|
assert_eq!(value, before);
|
|
}
|
|
|
|
#[test]
|
|
fn gesture_flick_trace_crosses_once_and_settles_while_clamp_stops_at_crossing() {
|
|
let config = SpringConfig::default();
|
|
let mut free = AnimatedValue::new(0.0);
|
|
free.velocity = 20000.0;
|
|
free.set_target(100.0);
|
|
let mut clamped = free;
|
|
let mut crossings = 0;
|
|
let mut previous_error: f64 = -100.0;
|
|
for ms in 1..=1500 {
|
|
free.advance_with_policy(
|
|
Duration::from_millis(1),
|
|
config,
|
|
CrossingPolicy::AllowOvershoot,
|
|
);
|
|
clamped.advance_with_policy(Duration::from_millis(1), config, CrossingPolicy::NoCrossing);
|
|
let error = free.current - free.target;
|
|
if error != 0.0 && previous_error.signum() != error.signum() {
|
|
crossings += 1;
|
|
}
|
|
if error != 0.0 {
|
|
previous_error = error;
|
|
}
|
|
assert!(clamped.current <= clamped.target);
|
|
if clamped.current == clamped.target {
|
|
assert_eq!(clamped.velocity, 0.0);
|
|
}
|
|
if ms <= 200 {
|
|
let exact = reference(0., 20000., 100., ms as f64 / 1000.0, config);
|
|
close(free.current, exact.0, 1e-7);
|
|
close(free.velocity, exact.1, 1e-6);
|
|
}
|
|
}
|
|
assert_eq!(crossings, 1);
|
|
assert_eq!((free.current, free.velocity), (100., 0.));
|
|
assert_eq!((clamped.current, clamped.velocity), (100., 0.));
|
|
}
|
|
|
|
#[test]
|
|
fn rapid_retarget_trace_preserves_position_and_the_golden_policy() {
|
|
let mut clock = FakeClock::new();
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(1000.0);
|
|
clock.sample(
|
|
Duration::from_millis(40),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
let before = value;
|
|
value.retarget_preserving_motion(2000.0);
|
|
assert_eq!(value.current, before.current);
|
|
assert_eq!(value.velocity, before.velocity);
|
|
clock.sample(
|
|
Duration::from_millis(65),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
let before = value;
|
|
value.retarget_preserving_motion(-500.0);
|
|
assert_eq!(value.current, before.current);
|
|
assert_eq!(value.velocity, before.velocity);
|
|
clock.sample(
|
|
Duration::from_millis(81),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
assert_ne!(value.velocity, 0.0);
|
|
|
|
// Apply the current policy to the exact old in-flight state too.
|
|
value.current = 318.94300938241565;
|
|
value.velocity = 9837.123292018367;
|
|
value.retarget_preserving_motion(-500.0);
|
|
close(value.velocity, 9837.123292018367, 1e-9);
|
|
}
|
|
|
|
#[test]
|
|
fn interrupted_resize_and_zoom_targets_preserve_position_and_velocity() {
|
|
let initial = Rect::new(0., 0., 400., 300.);
|
|
let mut geometry = WindowGeometry::new(initial, None);
|
|
geometry.set_logical_target(Rect::new(100., 50., 900., 600.), Duration::ZERO);
|
|
geometry.advance(Duration::from_millis(40), SpringConfig::default(), true);
|
|
for mode in [
|
|
PresentationMode::Normal,
|
|
PresentationMode::Maximized,
|
|
PresentationMode::Fullscreen,
|
|
PresentationMode::Normal,
|
|
] {
|
|
let before = (geometry.visual.current, geometry.decorations);
|
|
let velocity = geometry.visual.velocity;
|
|
geometry.set_presentation_mode(
|
|
Rect::new(200., 100., 700., 500.),
|
|
mode,
|
|
Duration::from_millis(40),
|
|
);
|
|
assert_eq!((geometry.visual.current, geometry.decorations), before);
|
|
assert_eq!(geometry.visual.velocity, velocity);
|
|
geometry.advance(Duration::ZERO, SpringConfig::default(), true);
|
|
assert_eq!((geometry.visual.current, geometry.decorations), before);
|
|
geometry.advance(Duration::from_millis(16), SpringConfig::default(), true);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn variable_cadence_traces_match_reference_at_every_absolute_timestamp() {
|
|
let config = SpringConfig::default();
|
|
let mut schedules = vec![vec![16600], vec![8300], vec![5000, 22000, 11000, 37000]];
|
|
for mut seed in [1u64, 0x12345678, 0xdeadbeef] {
|
|
let mut seeded = Vec::new();
|
|
for _ in 0..64 {
|
|
seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1);
|
|
seeded.push((1 + (seed >> 32) % 47) * 1000);
|
|
}
|
|
schedules.push(seeded);
|
|
}
|
|
|
|
for schedule in schedules {
|
|
let mut clock = FakeClock::new();
|
|
let mut value = AnimatedValue::new(-100.0);
|
|
value.set_target(500.0);
|
|
let mut elapsed = Duration::ZERO;
|
|
let mut settled_at = None;
|
|
for i in 0..500 {
|
|
elapsed += Duration::from_micros(schedule[i % schedule.len()]);
|
|
let sample = clock.sample(elapsed, &mut value, config);
|
|
let exact = reference(-100., 0., 500., elapsed.as_secs_f64(), config);
|
|
if sample.current == sample.target && sample.velocity == 0.0 {
|
|
assert_eq!((sample.current, sample.velocity), (500., 0.));
|
|
settled_at.get_or_insert(elapsed);
|
|
} else {
|
|
close(sample.current, exact.0, config.position_tolerance);
|
|
close(sample.velocity, exact.1, config.velocity_tolerance);
|
|
}
|
|
if elapsed >= Duration::from_secs(2) {
|
|
break;
|
|
}
|
|
}
|
|
let settled_at = settled_at.unwrap();
|
|
let mut reference_settle_us = 0;
|
|
while {
|
|
let (x, v) = reference(-100., 0., 500., reference_settle_us as f64 / 1e6, config);
|
|
(x - 500.).abs() > config.position_tolerance || v.abs() > config.velocity_tolerance
|
|
} {
|
|
reference_settle_us += 100;
|
|
}
|
|
let exact_settle = Duration::from_micros(reference_settle_us);
|
|
assert!(
|
|
settled_at.abs_diff(exact_settle)
|
|
<= Duration::from_micros(*schedule.iter().max().unwrap() + 100)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn scalar_and_rect_share_math_and_rect_clamps_only_the_crossing_component() {
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(100.0);
|
|
value.velocity = 20000.0;
|
|
let mut rect = AnimatedRect::new(Rect::new(0., 0., 400., 300.));
|
|
rect.set_target(Rect::new(100., 500., 400., 300.));
|
|
rect.velocity.x = value.velocity;
|
|
for policy in [CrossingPolicy::NoCrossing, CrossingPolicy::AllowOvershoot] {
|
|
let mut scalar = value;
|
|
let mut shape = rect;
|
|
scalar.advance_with_policy(Duration::from_millis(10), SpringConfig::default(), policy);
|
|
shape.advance_with_policy(Duration::from_millis(10), SpringConfig::default(), policy);
|
|
assert_eq!(scalar.current, shape.current.x);
|
|
assert_eq!(scalar.velocity, shape.velocity.x);
|
|
assert!(shape.current.y > 0.0 && shape.current.y < 500.0);
|
|
if policy == CrossingPolicy::NoCrossing {
|
|
assert_eq!(shape.current.x, 100.0);
|
|
assert_eq!(shape.velocity.x, 0.0);
|
|
assert_ne!(shape.velocity.y, 0.0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn clamp_detects_crossing_inside_a_stall_even_when_endpoints_have_same_sign() {
|
|
let config = SpringConfig {
|
|
stiffness: 100.0,
|
|
damping: 0.0,
|
|
..SpringConfig::default()
|
|
};
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(100.0);
|
|
value.advance_with_policy(
|
|
Duration::from_secs_f64(std::f64::consts::TAU / 10.0),
|
|
config,
|
|
CrossingPolicy::NoCrossing,
|
|
);
|
|
assert_eq!((value.current, value.velocity), (100., 0.));
|
|
}
|
|
|
|
#[test]
|
|
fn solver_is_finite_for_realistic_ranges_and_invalid_configuration_falls_back() {
|
|
for mass in [0.01, 1.0, 100.0] {
|
|
for stiffness in [0.1, 700.0, 100000.0] {
|
|
for damping in [0.0, 0.01, 53.0, 1000000.0] {
|
|
for dt in [1e-12, 0.008, 0.4, 10.0, 3600.0] {
|
|
let config = SpringConfig {
|
|
mass,
|
|
stiffness,
|
|
damping,
|
|
..SpringConfig::default()
|
|
};
|
|
let (x, v) = physical(-10000., 50000., 10000., dt, config);
|
|
assert!(
|
|
x.is_finite() && v.is_finite(),
|
|
"{config:?} dt {dt}: {x} {v}"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for bad in [0.0, -1.0, f64::NAN, f64::INFINITY] {
|
|
for config in [
|
|
SpringConfig {
|
|
mass: bad,
|
|
..SpringConfig::default()
|
|
},
|
|
SpringConfig {
|
|
stiffness: bad,
|
|
..SpringConfig::default()
|
|
},
|
|
] {
|
|
assert_eq!(
|
|
physical(0., 10., 100., 0.1, config),
|
|
physical(0., 10., 100., 0.1, SpringConfig::default())
|
|
);
|
|
}
|
|
}
|
|
|
|
for bad in [-1.0, f64::NAN, f64::INFINITY] {
|
|
let config = SpringConfig {
|
|
damping: bad,
|
|
..SpringConfig::default()
|
|
};
|
|
assert_eq!(
|
|
physical(0., 10., 100., 0.1, config),
|
|
physical(0., 10., 100., 0.1, SpringConfig::default())
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn physical_zero_and_negative_time_do_not_move_state() {
|
|
for dt in [0.0, -0.01] {
|
|
assert_eq!(
|
|
physical(5.0, 100.0, 10.0, dt, SpringConfig::default()),
|
|
(5.0, 100.0)
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn resize_target_rebases_an_existing_zoom_without_a_zero_time_jump() {
|
|
let mut geometry = WindowGeometry::new(Rect::new(100., 50., 400., 300.), None);
|
|
geometry.set_presentation_mode(
|
|
Rect::new(0., 0., 1920., 1080.),
|
|
PresentationMode::Fullscreen,
|
|
Duration::ZERO,
|
|
);
|
|
geometry.advance(Duration::from_millis(40), SpringConfig::default(), true);
|
|
let before = (geometry.visual.current, geometry.decorations);
|
|
geometry.set_logical_target(Rect::new(0., 0., 1600., 900.), Duration::from_millis(40));
|
|
geometry.advance(Duration::ZERO, SpringConfig::default(), true);
|
|
assert_eq!((geometry.visual.current, geometry.decorations), before);
|
|
geometry.advance(Duration::from_nanos(1), SpringConfig::default(), true);
|
|
close(geometry.visual.current.width, before.0.width, 1e-4);
|
|
}
|
|
|
|
#[test]
|
|
fn small_default_normal_motion_matches_legacy_within_half_a_pixel() {
|
|
let mut old = AnimatedValue::new(0.0);
|
|
old.set_target(10.0);
|
|
let mut clock = FakeClock::new();
|
|
let mut exact = old;
|
|
for i in 1..=120 {
|
|
let step = Duration::from_secs_f64(1.0 / 60.0);
|
|
legacy_advance(&mut old, step, SpringConfig::default());
|
|
let sample = clock.sample(step * i, &mut exact, SpringConfig::default());
|
|
close(sample.current, old.current, 0.5);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn creation_clock_excludes_earlier_idle_time_and_records_all_sample_fields() {
|
|
let mut clock = FakeClock::new();
|
|
let created = Duration::from_secs(10);
|
|
clock.resume(created);
|
|
let mut value = AnimatedValue::new(0.0);
|
|
value.set_target(500.0);
|
|
let first = clock.sample(
|
|
created + Duration::from_millis(16),
|
|
&mut value,
|
|
SpringConfig::default(),
|
|
);
|
|
let exact = reference(0.0, 0.0, 500.0, 0.016, SpringConfig::default());
|
|
close(first.current, exact.0, 1e-8);
|
|
close(first.velocity, exact.1, 1e-8);
|
|
assert_eq!(first.time, created + Duration::from_millis(16));
|
|
assert_eq!(first.target, 500.0);
|
|
assert_eq!(clock.trace.len(), 1);
|
|
value.retarget_preserving_motion(800.0);
|
|
let same_time = clock.sample(first.time, &mut value, SpringConfig::default());
|
|
assert_eq!(same_time.current, first.current);
|
|
assert_eq!(same_time.velocity, first.velocity);
|
|
assert_eq!(same_time.target, 800.0);
|
|
}
|
|
|
|
#[test]
|
|
fn damped_physical_solutions_converge_in_all_three_regimes() {
|
|
for damping in [5.0, 20.0, 53.0, 2000.0] {
|
|
let config = SpringConfig {
|
|
stiffness: 100.0,
|
|
damping,
|
|
..SpringConfig::default()
|
|
};
|
|
let (x, v) = physical(-500.0, 1234.0, 100.0, 2000.0, config);
|
|
close(x, 100.0, 1e-9);
|
|
close(v, 0.0, 1e-9);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn solver_is_continuous_on_both_sides_of_the_flick_crossing() {
|
|
let config = SpringConfig::default();
|
|
let (mut low, mut high) = (0.0, 0.02);
|
|
for _ in 0..60 {
|
|
let middle = (low + high) / 2.0;
|
|
if physical(0.0, 20000.0, 100.0, middle, config).0 < 100.0 {
|
|
low = middle;
|
|
} else {
|
|
high = middle;
|
|
}
|
|
}
|
|
let before = physical(0.0, 20000.0, 100.0, low - 1e-9, config);
|
|
let after = physical(0.0, 20000.0, 100.0, high + 1e-9, config);
|
|
assert!(before.0 < 100.0 && after.0 > 100.0);
|
|
close(before.0, after.0, 1e-4);
|
|
close(before.1, after.1, 0.01);
|
|
assert!(after.1 > 1000.0);
|
|
}
|