Separate library implementations from module declarations
This commit is contained in:
Samuel Onoja committed
1 parent
1b4db0e681
commit
23e280a6b4
19 files changed
+6250
-6213
No files matched your search
@@ -0,0 +1,684 @@
|
||||
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);
|
||||
}
|
||||
Reference in new issue
Block a user