e4f86d11fe8a
transition_tests.rs
//! Transition curves and geometry against values measured on PowerPoint's video export
//! (`plan/powerpoint/tools/synth_transitions.ps1`, 2 s transitions, 30 fps).
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use deckcraft_model::anim::TRANSITIONS;
use crate::transition::{Layer, Source, transition_frame, transition_layers, uses_slide_parts};
use crate::transition_geom::{edge, pow_inout, q2, ss};
const A: f64 = 16.0 / 9.0;
fn near(a: f64, b: f64, tol: f64) -> bool {
(a - b).abs() <= tol
}
fn of(ls: &[Layer], src: Source) -> Vec<&Layer> {
ls.iter().filter(|l| l.source == src).collect()
}
fn left(l: &Layer) -> f64 {
l.quad.iter().map(|p| p[0]).fold(f64::INFINITY, f64::min)
}
fn top(l: &Layer) -> f64 {
l.quad.iter().map(|p| p[1]).fold(f64::INFINITY, f64::min)
}
#[test]
fn fade_follows_powerpoints_s_curve() {
// Measured share of the new slide in a 2 s Fade at t = 0.25, 0.5, 0.75: 0.155, 0.49, 0.82.
for (t, want) in [(0.25, 0.155), (0.5, 0.49), (0.75, 0.82)] {
let ls = transition_layers("fade", "smoothly", t);
let new = of(&ls, Source::New);
assert!(near(new[0].alpha, want, 0.04), "t={t}: {}", new[0].alpha);
}
// Through black: the old slide is gone to black at the middle, then the new one fades in.
let mid = transition_layers("fade", "throughBlack", 0.5);
assert!(mid.iter().all(|l| l.source == Source::Black));
let q = transition_layers("fade", "throughBlack", 0.25);
assert!(near(of(&q, Source::Old)[0].alpha, 0.5, 0.01));
}
#[test]
fn push_moves_both_slides_with_an_eased_curve() {
for (o, dx, dy) in [("l", -1.0, 0.0), ("r", 1.0, 0.0), ("u", 0.0, -1.0), ("d", 0.0, 1.0)] {
for t in [0.25, 0.5, 0.75] {
let ls = transition_layers("push", o, t);
let (old, new) = (of(&ls, Source::Old)[0], of(&ls, Source::New)[0]);
let s = q2(t);
assert!(near(old.quad[0][0], dx * s, 1e-9) && near(old.quad[0][1], dy * s, 1e-9), "{o} {t}");
assert!(near(new.quad[0][0], dx * (s - 1.0), 1e-9) && near(new.quad[0][1], dy * (s - 1.0), 1e-9), "{o} {t}");
}
}
// Ease in-out: slow at both ends.
assert!(q2(0.1) < 0.05 && q2(0.9) > 0.95 && near(q2(0.5), 0.5, 1e-9));
}
#[test]
fn cover_and_uncover_match_measured_positions() {
// Offset of the new slide in Cover Left (fraction of the width) at measured times.
for (t, off) in [(0.445, 0.655), (0.495, 0.512), (0.544, 0.359), (0.643, 0.134), (0.742, 0.046)] {
let ls = transition_layers("cover", "l", t);
assert!(near(left(of(&ls, Source::New)[0]), off, 0.05), "cover t={t}");
}
// Offset of the old slide in Uncover Left.
for (t, off) in [(0.244, -0.06), (0.343, -0.14), (0.442, -0.32), (0.508, -0.5), (0.558, -0.63)] {
let ls = transition_layers("uncover", "l", t);
assert!(near(left(of(&ls, Source::Old)[0]), off, 0.05), "uncover t={t}");
}
// Diagonal Cover shoots in and settles slowly.
for (t, off) in [(0.142, 0.728), (0.257, 0.49), (0.356, 0.29), (0.455, 0.146), (0.604, 0.053)] {
let ls = transition_layers("cover", "lu", t);
let n = of(&ls, Source::New)[0];
assert!(near(left(n), off, 0.06) && near(top(n), off, 0.06), "cover lu t={t}");
}
assert!(near(pow_inout(0.25, 3.0), 0.0625, 1e-9));
}
#[test]
fn wipe_has_a_wide_soft_edge() {
// Measured along a row of Wipe Right at t = 0.5: about half-way through at x = 0.6, nearly
// nothing at the right edge, fully new on the left third.
let c = -0.4 + 1.8 * 1.05 * 0.5;
assert!(near(edge(c, 0.6, 0.8), 0.49, 0.1));
assert!(edge(c, 1.0, 0.8) < 0.1);
assert!(edge(c, 0.2, 0.8) > 0.8);
// Directions: "r" starts on the left, "l" on the right, "u" at the bottom, "d" at the top,
// diagonals at the opposite corner.
let first = |o: &str| {
let ls = transition_layers("wipe", o, 0.15);
let n = of(&ls, Source::New);
assert!(!n.is_empty(), "{o}");
let cx = n.iter().map(|l| (l.quad[0][0] + l.quad[2][0]) / 2.0).sum::<f64>() / n.len() as f64;
let cy = n.iter().map(|l| (l.quad[0][1] + l.quad[2][1]) / 2.0).sum::<f64>() / n.len() as f64;
(cx, cy)
};
assert!(first("r").0 < 0.3 && first("l").0 > 0.7);
assert!(first("u").1 > 0.7 && first("d").1 < 0.3);
let ru = first("ru");
assert!(ru.0 < 0.4 && ru.1 > 0.6, "{ru:?}");
}
#[test]
fn split_and_shape_open_from_the_middle() {
for o in ["horzOut", "vertOut"] {
let ls = transition_layers("split", o, 0.2);
let n = of(&ls, Source::New);
assert!(n.iter().all(|l| {
let c = [(l.quad[0][0] + l.quad[2][0]) / 2.0, (l.quad[0][1] + l.quad[2][1]) / 2.0];
if o.starts_with("horz") { (c[1] - 0.5).abs() < 0.4 } else { (c[0] - 0.5).abs() < 0.4 }
}));
}
// Shape In is done with the old slide at half time; Shape Out starts the new one then.
assert!(of(&transition_layers("shape", "in", 0.55), Source::Old).is_empty());
assert!(of(&transition_layers("shape", "out", 0.45), Source::New).is_empty());
}
#[test]
fn dynamic_content_curves() {
// Pan: the new content's offset (fraction of the width) at measured times.
for (t, off) in [(0.6, 0.134), (0.7, 0.086), (0.8, 0.039), (0.9, 0.011)] {
let ls = transition_layers("pan", "l", t);
assert!(near(left(of(&ls, Source::NewContent)[0]), off, 0.07), "pan t={t}");
}
// The backgrounds cross-fade under the moving contents.
let ls = transition_layers("pan", "l", 0.5);
assert_eq!(ls.first().map(|l| l.source), Some(Source::OldBack));
assert!(of(&ls, Source::NewBack)[0].alpha > 0.5);
// Ferris Wheel: the old content drops (top edge, slide heights) as measured.
for (t, dy) in [(0.147, 0.06), (0.246, 0.17), (0.345, 0.36), (0.444, 0.70)] {
let ls = transition_layers("ferris", "l", t);
let q = of(&ls, Source::OldContent)[0].quad;
let cy = q.iter().map(|p| p[1]).sum::<f64>() / 4.0 - 0.5;
assert!(near(cy, dy, 0.08), "ferris t={t}: {cy}");
}
for k in ["pan", "ferris", "conveyor", "rotate", "window", "orbit", "flythrough"] {
assert!(uses_slide_parts(k, ""), "{k}");
}
assert!(uses_slide_parts("reveal", "smoothlyLeft") && !uses_slide_parts("reveal", "blackLeft"));
assert!(!uses_slide_parts("cube", "l") && !uses_slide_parts("push", "l"));
}
#[test]
fn cube_turns_toward_the_option() {
// Cube Left at the middle: the shared edge is near the middle, the old face on the left.
let ls = transition_frame("cube", "l", 0.5, A);
let (o, n) = (of(&ls, Source::Old)[0], of(&ls, Source::New)[0]);
let o_right = o.quad.iter().map(|p| p[0]).fold(f64::NEG_INFINITY, f64::max);
assert!(near(o_right, left(n), 0.02), "shared edge: {o_right} vs {}", left(n));
assert!(o_right > 0.3 && o_right < 0.7);
// Up: the new face comes from below.
let ls = transition_frame("cube", "u", 0.5, A);
assert!(top(of(&ls, Source::New)[0]) > top(of(&ls, Source::Old)[0]));
}
#[test]
fn switch_swaps_the_cards_past_halfway() {
let order = |t: f64| {
let ls = transition_frame("switch", "l", t, A);
let pos = |s: Source| ls.iter().position(|l| l.source == s);
(pos(Source::Old), pos(Source::New))
};
let (o, n) = order(0.3);
assert!(o > n, "old in front early");
let (o, n) = order(0.8);
assert!(n > o, "new in front late");
}
#[test]
fn clock_hand_sweeps_at_constant_speed() {
// The share of the slide covered grows linearly.
let area = |t: f64| {
let ls = transition_layers("clock", "clockwise", t);
of(&ls, Source::New)
.iter()
.map(|l| {
let [a, b, c, _] = l.quad;
((b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1])).abs() / 2.0 * (l.fade[0] + l.fade[1] + l.fade[2]) / 3.0
})
.sum::<f64>()
};
let (a1, a2, a3) = (area(0.25), area(0.5), area(0.75));
assert!(near(a2 - a1, a3 - a2, 0.08), "{a1} {a2} {a3}");
assert!(near(a2, 0.5, 0.08), "{a2}");
}
#[test]
fn options_change_the_frame() {
// Every option of a transition draws something different from its other options midway.
for (id, _, _, _, opts) in TRANSITIONS {
if matches!(*id, "morph" | "none" | "random") || opts.len() < 2 {
continue;
}
for (i, a) in opts.iter().enumerate() {
for b in opts.iter().skip(i + 1) {
let differs = [0.2, 0.35, 0.5, 0.8].iter().any(|t| transition_layers(id, a, *t) != transition_layers(id, b, *t));
assert!(differs, "{id}: {a} vs {b}");
}
}
}
}
#[test]
fn frames_stay_cheap() {
// Per frame, the show draws these meshes from cached slide textures: keep them small.
for (id, _, _, _, opts) in TRANSITIONS {
let mut options: Vec<&str> = opts.to_vec();
options.push("");
for o in options {
for t in [0.1, 0.3, 0.5, 0.7, 0.9] {
let tris: usize = transition_frame(id, o, t, A).iter().map(|l| crate::layer_mesh(l).1.len()).sum();
assert!(tris < 30_000, "{id}/{o} t={t}: {tris} triangles");
}
}
}
}
#[test]
fn hostile_aspects_are_safe() {
for a in [f64::NAN, 0.0, -3.0, 1e9, f64::INFINITY] {
for (id, ..) in TRANSITIONS {
for l in transition_frame(id, "", 0.4, a) {
assert!(l.quad.iter().all(|p| p[0].is_finite() && p[1].is_finite()));
assert!(l.fade.iter().all(|f| (0.0..=1.0).contains(f)));
}
}
}
assert!(near(ss(0.5), 0.5, 1e-12));
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.