shifathosn
/
deckcraft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
deckcraft/crates/render/src/transition.rs

518 lines
23 KiB
Rust
Raw Blame History

//! Slide transition frames without a GPU: the layers of [`deckcraft_anim::transition_layers`]
//! composited on the CPU from two rendered slide images. The slide show draws the same layers with
//! the UI toolkit's meshes; this is the headless twin used by the CLI, comparisons and tests.
use deckcraft_anim::{Layer, Source, layer_mesh, transition_frame, uses_slide_parts};
use deckcraft_model::{Presentation, ShapeId};
use crate::{Image, RenderOpts, ShapeState, SlidePart, render_blend, render_slide, render_slide_part};
/// The two slides of a transition rendered as background and content, for the transitions that
/// move contents over the backgrounds ([`deckcraft_anim::uses_slide_parts`]). `None` parts of the
/// old slide (the show's first slide) are black and nothing.
#[derive(Clone, Debug, Default)]
pub struct SlideParts {
pub old_back: Option<Image>,
pub old_content: Option<Image>,
pub new_back: Image,
pub new_content: Image,
}
impl SlideParts {
/// Render the parts of slides `old` and `new`.
pub fn render(pres: &Presentation, old: Option<usize>, new: usize, opts: &RenderOpts) -> SlideParts {
SlideParts {
old_back: old.map(|i| render_slide_part(pres, i, SlidePart::Backdrop, opts)),
old_content: old.map(|i| render_slide_part(pres, i, SlidePart::Content, opts)),
new_back: render_slide_part(pres, new, SlidePart::Backdrop, opts),
new_content: render_slide_part(pres, new, SlidePart::Content, opts),
}
}
}
/// Composite transition `layers` over black into an image the size of `new`. `old` is the outgoing
/// slide (`None`: black, as when the show starts); `parts` the slides' backgrounds and contents
/// (without them, a background draws its whole slide and content draws nothing).
pub fn composite_transition(old: Option<&Image>, new: &Image, parts: Option<&SlideParts>, layers: &[Layer]) -> Image {
let (w, h) = (new.width, new.height);
let n = (w as usize).saturating_mul(h as usize);
let mut out = Image { width: w, height: h, pixels: [0u8, 0, 0, 255].repeat(n) };
for l in layers {
let src = match (l.source.is_part(), parts) {
(true, None) => match l.source.whole() {
Some(s) => s,
None => continue,
},
_ => l.source,
};
let tex = match (src, parts) {
(Source::Old, _) => old.map(Tex::Image).unwrap_or(Tex::Solid([0.0, 0.0, 0.0])),
(Source::New, _) => Tex::Image(new),
(Source::Black, _) => Tex::Solid([0.0, 0.0, 0.0]),
(Source::White, _) => Tex::Solid([255.0, 255.0, 255.0]),
(Source::OldBack, Some(p)) => p.old_back.as_ref().map(Tex::Image).unwrap_or(Tex::Solid([0.0, 0.0, 0.0])),
(Source::NewBack, Some(p)) => Tex::Image(&p.new_back),
(Source::OldContent, Some(p)) => match &p.old_content {
Some(i) => Tex::Image(i),
None => continue,
},
(Source::NewContent, Some(p)) => Tex::Image(&p.new_content),
(_, None) => continue,
};
draw_layer(&mut out, l, &tex);
}
out
}
/// The frame of slide `index`'s transition at progress `t` (0..1): the previous slide (black for
/// the first) going out, slide `index` coming in, at `opts`' scale and size. Morph frames are
/// rendered shape by shape like the show does.
pub fn render_transition(pres: &Presentation, index: usize, t: f64, opts: &RenderOpts) -> Image {
let Some(slide) = pres.slides.get(index) else { return Image::default() };
let (kind, option) = slide.transition.as_ref().map(|tr| (tr.kind.as_str(), tr.option.as_str())).unwrap_or(("none", ""));
let prev = index.checked_sub(1).filter(|i| pres.slides.get(*i).is_some());
if kind == "morph"
&& let Some(from) = prev
&& let Some(a) = pres.slides.get(from)
{
let tt = if t.is_finite() { t.clamp(0.0, 1.0) } else { 0.0 };
if tt < 1.0 {
let m = deckcraft_anim::morph_frame(pres, a, slide, tt, &|_| false);
let f = |id: ShapeId| ShapeState { opacity: m.opacity_of(id), ..Default::default() };
let o = RenderOpts { state: Some(&f), ..copy_opts(opts) };
let text: Vec<crate::TextMorph> =
m.text.iter().map(|x| crate::TextMorph { old: x.old, new: x.new, from: x.from, to: x.to, chars: x.chars, t: m.mix }).collect();
let paths: Vec<crate::PathMorph> = m
.paths
.iter()
.map(|x| crate::PathMorph { id: x.id, from: x.from.clone(), from_box: x.from_box, to_box: x.to_box, t: m.mix })
.collect();
return render_blend(pres, from, index, m.mix, &m.shapes, &text, &paths, &o);
}
}
let new = render_slide(pres, index, opts);
let old = prev.map(|i| render_slide(pres, i, opts));
let parts = uses_slide_parts(kind, option).then(|| SlideParts::render(pres, prev, index, opts));
let aspect = pres.slide_size.width / pres.slide_size.height.max(1.0);
composite_transition(old.as_ref(), &new, parts.as_ref(), &transition_frame(kind, option, t, aspect))
}
fn copy_opts<'a>(o: &RenderOpts<'a>) -> RenderOpts<'a> {
RenderOpts {
scale: o.scale,
edit: o.edit,
show_hidden: o.show_hidden,
state: o.state,
skip: o.skip,
skip_text: o.skip_text,
gif_times: o.gif_times,
threads: o.threads,
offset: o.offset,
size: o.size,
clear: o.clear,
date_text: o.date_text.clone(),
now: o.now,
}
}
enum Tex<'a> {
Image(&'a Image),
/// Straight RGB, opaque.
Solid([f32; 3]),
}
impl Tex<'_> {
/// Premultiplied RGBA (0..255) at texture coordinate (u, v), bilinear, clamped to the edge.
fn sample(&self, u: f64, v: f64) -> [f32; 4] {
match self {
Tex::Solid(c) => [c[0], c[1], c[2], 255.0],
Tex::Image(img) => {
let (w, h) = (img.width as usize, img.height as usize);
if w == 0 || h == 0 {
return [0.0; 4];
}
let x = (u * w as f64 - 0.5).clamp(0.0, (w - 1) as f64);
let y = (v * h as f64 - 0.5).clamp(0.0, (h - 1) as f64);
let (x0, y0) = (x.floor() as usize, y.floor() as usize);
let (x1, y1) = ((x0 + 1).min(w - 1), (y0 + 1).min(h - 1));
let (fx, fy) = ((x - x0 as f64) as f32, (y - y0 as f64) as f32);
let px = |xx: usize, yy: usize| -> [f32; 4] {
let i = (yy * w + xx) * 4;
match img.pixels.get(i..i + 4) {
Some(p) => [p[0] as f32, p[1] as f32, p[2] as f32, p[3] as f32],
None => [0.0; 4],
}
};
let (a, b, c, d) = (px(x0, y0), px(x1, y0), px(x0, y1), px(x1, y1));
let mut o = [0.0f32; 4];
for k in 0..4 {
let top = a[k] + (b[k] - a[k]) * fx;
let bot = c[k] + (d[k] - c[k]) * fx;
o[k] = top + (bot - top) * fy;
}
o
}
}
}
}
fn draw_layer(out: &mut Image, l: &Layer, tex: &Tex) {
if !(l.alpha.is_finite() && l.alpha > 0.0) {
return;
}
let (verts, tris) = layer_mesh(l);
let (w, h) = (out.width as f64, out.height as f64);
for t in tris {
let (Some(a), Some(b), Some(c)) = (verts.get(t[0] as usize), verts.get(t[1] as usize), verts.get(t[2] as usize)) else { continue };
let p = [[a.pos[0] * w, a.pos[1] * h], [b.pos[0] * w, b.pos[1] * h], [c.pos[0] * w, c.pos[1] * h]];
let uv = [a.uv, b.uv, c.uv];
let al = [a.a, b.a, c.a].map(|x| if x.is_finite() { x.clamp(0.0, 1.0) } else { 0.0 });
if al.iter().all(|x| *x <= 0.0) {
continue;
}
fill_triangle(out, p, uv, al, tex);
}
}
/// Rasterise one textured triangle: pixel centres inside it take the texture's colour at the
/// barycentric texture coordinate, at the interpolated opacity, blended source-over.
fn fill_triangle(out: &mut Image, p: [[f64; 2]; 3], uv: [[f64; 2]; 3], al: [f64; 3], tex: &Tex) {
let area = (p[1][0] - p[0][0]) * (p[2][1] - p[0][1]) - (p[2][0] - p[0][0]) * (p[1][1] - p[0][1]);
if !area.is_finite() || area.abs() < 1e-12 {
return;
}
let (w, h) = (out.width as i64, out.height as i64);
let minx = p.iter().map(|q| q[0]).fold(f64::INFINITY, f64::min).floor().max(0.0) as i64;
let maxx = (p.iter().map(|q| q[0]).fold(f64::NEG_INFINITY, f64::max).ceil() as i64).min(w);
let miny = p.iter().map(|q| q[1]).fold(f64::INFINITY, f64::min).floor().max(0.0) as i64;
let maxy = (p.iter().map(|q| q[1]).fold(f64::NEG_INFINITY, f64::max).ceil() as i64).min(h);
if minx >= maxx || miny >= maxy {
return;
}
let edge = |a: [f64; 2], b: [f64; 2], x: f64, y: f64| (b[0] - a[0]) * (y - a[1]) - (b[1] - a[1]) * (x - a[0]);
let width = out.width as usize;
for y in miny..maxy {
// Sample a hair off the pixel centre so a point on an edge shared by two triangles falls
// in exactly one of them (no double-blended seams).
let fy = y as f64 + 0.5 + 2.31e-6;
for x in minx..maxx {
let fx = x as f64 + 0.5 + 1.17e-6;
let w0 = edge(p[1], p[2], fx, fy) / area;
let w1 = edge(p[2], p[0], fx, fy) / area;
let w2 = edge(p[0], p[1], fx, fy) / area;
if w0 < 0.0 || w1 < 0.0 || w2 < 0.0 {
continue;
}
let u = w0 * uv[0][0] + w1 * uv[1][0] + w2 * uv[2][0];
let v = w0 * uv[0][1] + w1 * uv[1][1] + w2 * uv[2][1];
let alpha = (w0 * al[0] + w1 * al[1] + w2 * al[2]) as f32;
if alpha <= 0.0 {
continue;
}
let s = tex.sample(u, v);
let i = (y as usize * width + x as usize) * 4;
let Some(d) = out.pixels.get_mut(i..i + 4) else { continue };
let sa = s[3] * alpha / 255.0;
for k in 0..4 {
let src = s[k] * alpha;
let v = src + d[k] as f32 * (1.0 - sa);
d[k] = v.round().clamp(0.0, 255.0) as u8;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn solid(w: u32, h: u32, c: [u8; 4]) -> Image {
Image { width: w, height: h, pixels: c.repeat((w * h) as usize) }
}
#[test]
fn layers_composite_in_order() {
let old = solid(40, 20, [255, 0, 0, 255]);
let new = solid(40, 20, [0, 0, 255, 255]);
let img = composite_transition(Some(&old), &new, None, &deckcraft_anim::transition_layers("cover", "l", 0.0));
assert_eq!(img.pixel(20, 10), [255, 0, 0, 255]);
let img = composite_transition(Some(&old), &new, None, &deckcraft_anim::transition_layers("cover", "l", 1.0));
assert_eq!(img.pixel(20, 10), [0, 0, 255, 255]);
}
#[test]
fn missing_old_slide_is_black() {
let new = solid(10, 10, [0, 255, 0, 255]);
let img = composite_transition(None, &new, None, &[Layer::full(Source::Old, 1.0)]);
assert_eq!(img.pixel(5, 5), [0, 0, 0, 255]);
}
#[test]
fn half_alpha_blends() {
let old = solid(10, 10, [200, 0, 0, 255]);
let new = solid(10, 10, [0, 0, 200, 255]);
let l = [Layer::full(Source::Old, 1.0), Layer::full(Source::New, 0.5)];
let p = composite_transition(Some(&old), &new, None, &l).pixel(5, 5);
assert!((p[0] as i32 - 100).abs() <= 1 && (p[2] as i32 - 100).abs() <= 1, "{p:?}");
}
// ---------- golden-ish frames on synthetic slides ----------
const W: u32 = 160;
const H: u32 = 90;
const OLD: [u8; 4] = [220, 40, 40, 255];
const NEW: [u8; 4] = [30, 60, 200, 255];
#[derive(Clone, Copy, Debug, PartialEq)]
enum Is {
Old,
New,
Black,
White,
/// Something between (a blend).
Mix,
}
fn classify(p: [u8; 4]) -> Is {
let d = |c: [u8; 4]| (p[0] as i32 - c[0] as i32).abs() + (p[1] as i32 - c[1] as i32).abs() + (p[2] as i32 - c[2] as i32).abs();
let near = 40;
if d(OLD) < near {
Is::Old
} else if d(NEW) < near {
Is::New
} else if d([0, 0, 0, 255]) < near {
Is::Black
} else if d([255, 255, 255, 255]) < near {
Is::White
} else {
// A face shaded in 3-D: a darker copy of one of the slides.
let shaded = |c: [u8; 4]| {
let dot = |a: [u8; 4], b: [u8; 4]| (0..3).map(|i| a[i] as f64 * b[i] as f64).sum::<f64>();
let k = dot(p, c) / dot(c, c);
(0.3..=1.05).contains(&k) && (0..3).all(|i| (p[i] as f64 - k * c[i] as f64).abs() < 14.0)
};
if shaded(OLD) {
Is::Old
} else if shaded(NEW) {
Is::New
} else {
Is::Mix
}
}
}
fn frame(kind: &str, option: &str, t: f64) -> Image {
let old = solid(W, H, OLD);
let new = solid(W, H, NEW);
composite_transition(Some(&old), &new, None, &transition_frame(kind, option, t, 16.0 / 9.0))
}
fn at(img: &Image, x: f64, y: f64) -> Is {
let px = ((x * W as f64) as u32).min(W - 1);
let py = ((y * H as f64) as u32).min(H - 1);
classify(img.pixel(px, py))
}
/// (kind, option, t, x, y, what PowerPoint shows there), read off PowerPoint's own frames.
const PROBES: &[(&str, &str, f64, f64, f64, Is)] = &[
("fade", "smoothly", 0.1, 0.5, 0.5, Is::Old),
("fade", "smoothly", 0.5, 0.5, 0.5, Is::Mix),
("fade", "smoothly", 0.9, 0.5, 0.5, Is::New),
("fade", "throughBlack", 0.5, 0.5, 0.5, Is::Black),
("cut", "throughBlack", 0.3, 0.5, 0.5, Is::Black),
("cut", "", 0.3, 0.5, 0.5, Is::New),
// Push / Cover / Uncover: "l" moves things toward the left; the new slide comes from the right.
("push", "l", 0.25, 0.97, 0.5, Is::New),
("push", "l", 0.25, 0.1, 0.5, Is::Old),
("push", "r", 0.25, 0.03, 0.5, Is::New),
("push", "u", 0.25, 0.5, 0.97, Is::New),
("push", "d", 0.25, 0.5, 0.03, Is::New),
("cover", "l", 0.5, 0.75, 0.5, Is::New),
("cover", "l", 0.5, 0.25, 0.5, Is::Old),
("cover", "rd", 0.5, 0.05, 0.05, Is::New),
("cover", "rd", 0.2, 0.97, 0.97, Is::Old),
("uncover", "l", 0.5, 0.25, 0.5, Is::Old),
("uncover", "l", 0.5, 0.75, 0.5, Is::New),
("uncover", "lu", 0.5, 0.5, 0.5, Is::New),
// Wipe "r" sweeps rightward with a soft edge; "u" upward; diagonals from a corner.
("wipe", "r", 0.5, 0.05, 0.5, Is::New),
("wipe", "r", 0.5, 0.97, 0.5, Is::Old),
("wipe", "l", 0.5, 0.97, 0.5, Is::New),
("wipe", "u", 0.5, 0.5, 0.97, Is::New),
("wipe", "u", 0.5, 0.5, 0.03, Is::Old),
("wipe", "d", 0.5, 0.5, 0.03, Is::New),
("wipe", "ru", 0.5, 0.03, 0.97, Is::New),
("wipe", "ru", 0.5, 0.97, 0.03, Is::Old),
("wipe", "r", 0.5, 0.55, 0.5, Is::Mix),
// Split: Out opens from the middle, In closes from the edges.
("split", "horzOut", 0.5, 0.5, 0.5, Is::New),
("split", "horzOut", 0.5, 0.5, 0.02, Is::Old),
("split", "horzIn", 0.5, 0.5, 0.02, Is::New),
("split", "horzIn", 0.5, 0.5, 0.5, Is::Old),
("split", "vertOut", 0.5, 0.5, 0.5, Is::New),
("split", "vertOut", 0.5, 0.02, 0.5, Is::Old),
("split", "vertIn", 0.5, 0.02, 0.5, Is::New),
// Shape: grows from the centre; In shrinks the old slide over the first half, Out grows
// the new one over the second.
("shape", "circle", 0.5, 0.5, 0.5, Is::New),
("shape", "circle", 0.5, 0.02, 0.03, Is::Old),
("shape", "diamond", 0.5, 0.5, 0.5, Is::New),
("shape", "diamond", 0.5, 0.02, 0.03, Is::Old),
("shape", "plus", 0.5, 0.5, 0.05, Is::New),
("shape", "plus", 0.5, 0.05, 0.05, Is::Old),
("shape", "in", 0.25, 0.5, 0.5, Is::Old),
("shape", "in", 0.25, 0.05, 0.05, Is::New),
("shape", "in", 0.75, 0.5, 0.5, Is::New),
("shape", "out", 0.25, 0.5, 0.5, Is::Old),
("shape", "out", 0.75, 0.5, 0.5, Is::New),
("shape", "out", 0.75, 0.05, 0.05, Is::Old),
// Flash: white in the middle.
("flash", "", 0.3, 0.5, 0.5, Is::White),
// Clock: a hand sweeping from 12 o'clock.
("clock", "clockwise", 0.25, 0.6, 0.15, Is::New),
("clock", "clockwise", 0.25, 0.4, 0.15, Is::Old),
("clock", "counterClockwise", 0.25, 0.4, 0.15, Is::New),
("clock", "counterClockwise", 0.25, 0.6, 0.15, Is::Old),
("clock", "wedge", 0.5, 0.5, 0.05, Is::New),
("clock", "wedge", 0.5, 0.5, 0.95, Is::Old),
// Ripple: from the centre, or from the corner opposite the option.
("ripple", "center", 0.5, 0.5, 0.5, Is::New),
("ripple", "center", 0.5, 0.02, 0.03, Is::Old),
("ripple", "ru", 0.4, 0.03, 0.97, Is::New),
("ripple", "ru", 0.4, 0.97, 0.03, Is::Old),
// Comb: the old slide's bands slide off, the bottom band first.
("comb", "horz", 0.5, 0.5, 0.97, Is::New),
("comb", "horz", 0.5, 0.5, 0.03, Is::Old),
// Glitter "l": the sweep starts on the left.
("glitter", "l", 0.45, 0.03, 0.5, Is::New),
("glitter", "l", 0.45, 0.97, 0.5, Is::Old),
("glitter", "r", 0.45, 0.97, 0.5, Is::New),
// Vortex "l": the old slide whirls off toward the left, its right side first.
("vortex", "l", 0.25, 0.03, 0.5, Is::Old),
("vortex", "l", 0.97, 0.03, 0.5, Is::New),
// Cube / Box "l": the new face comes in from the right.
("cube", "l", 0.5, 0.85, 0.5, Is::New),
("cube", "l", 0.5, 0.15, 0.5, Is::Old),
("cube", "r", 0.5, 0.15, 0.5, Is::New),
("box", "l", 0.25, 0.97, 0.5, Is::New),
("box", "l", 0.25, 0.3, 0.5, Is::Old),
("cube", "u", 0.5, 0.5, 0.9, Is::New),
("cube", "d", 0.5, 0.5, 0.1, Is::New),
// Switch "l": the old card is pulled out to the left, the new one to the right.
("switch", "l", 0.25, 0.97, 0.5, Is::New),
("switch", "l", 0.25, 0.3, 0.5, Is::Old),
("switch", "r", 0.25, 0.03, 0.5, Is::New),
// Gallery "l": the slides travel left along the wall.
("gallery", "l", 0.6, 0.9, 0.5, Is::New),
// Flip: the old face, then the new one.
("flip", "l", 0.2, 0.5, 0.5, Is::Old),
("flip", "l", 0.8, 0.5, 0.5, Is::New),
// Doors open in the middle, the new slide coming forward between them.
("doors", "vert", 0.9, 0.5, 0.5, Is::New),
// Fall Over: the old slide tips backward, uncovering the new one at the top first.
("fallOver", "l", 0.6, 0.5, 0.03, Is::New),
("fallOver", "l", 0.6, 0.5, 0.97, Is::Old),
// Peel Off "l": from the bottom-right corner.
("peelOff", "l", 0.4, 0.98, 0.98, Is::New),
("peelOff", "l", 0.4, 0.03, 0.03, Is::Old),
("peelOff", "r", 0.4, 0.02, 0.98, Is::New),
// Page Curl: the far half rolls up first.
("pageCurlDouble", "l", 0.5, 0.9, 0.5, Is::New),
("pageCurlDouble", "l", 0.5, 0.1, 0.5, Is::Old),
("pageCurlDouble", "r", 0.5, 0.1, 0.5, Is::New),
("pageCurlDouble", "singleL", 0.6, 0.95, 0.5, Is::New),
("pageCurlDouble", "singleL", 0.6, 0.05, 0.5, Is::Old),
// Airplane "l": a dart with its nose to the right, hanging low.
("airplane", "l", 0.5, 0.15, 0.1, Is::New),
("airplane", "l", 0.5, 0.8, 0.68, Is::Old),
("airplane", "r", 0.5, 0.2, 0.68, Is::Old),
// Origami "l": the bird flies off to the left.
("origami", "l", 0.75, 0.97, 0.5, Is::New),
// Fracture: shards fall, the top first.
("fracture", "", 0.6, 0.5, 0.05, Is::New),
// Crush: the old slide crumples toward the centre.
("crush", "", 0.5, 0.03, 0.03, Is::New),
("crush", "", 0.5, 0.45, 0.5, Is::Old),
// Curtains part in the middle.
("curtains", "", 0.4, 0.5, 0.5, Is::New),
("curtains", "", 0.4, 0.02, 0.5, Is::Old),
// Zoom and Rotate: the new slide spins in from the centre over the old one.
("zoom", "rotate", 0.2, 0.03, 0.03, Is::Old),
("zoom", "out", 0.8, 0.5, 0.5, Is::New),
("dissolve", "", 0.02, 0.5, 0.5, Is::Old),
("dissolve", "", 0.99, 0.5, 0.5, Is::New),
];
#[test]
fn frames_match_powerpoint_probes() {
let mut bad = Vec::new();
for (kind, option, t, x, y, want) in PROBES {
let got = at(&frame(kind, option, *t), *x, *y);
if got != *want {
bad.push(format!("{kind}/{option} t={t} ({x},{y}): want {want:?}, got {got:?}"));
}
}
assert!(bad.is_empty(), "{}", bad.join("\n"));
}
#[test]
fn every_transition_starts_old_and_ends_new() {
for (kind, _, _, _, opts) in deckcraft_model::anim::TRANSITIONS {
let mut options: Vec<&str> = opts.to_vec();
options.push("");
for o in options {
assert_eq!(at(&frame(kind, o, 0.0), 0.5, 0.5), Is::Old, "{kind}/{o}");
assert_eq!(at(&frame(kind, o, 1.0), 0.5, 0.5), Is::New, "{kind}/{o}");
for t in [0.25, 0.5, 0.75] {
let img = frame(kind, o, t);
assert_eq!((img.width, img.height), (W, H));
}
}
}
}
#[test]
fn dynamic_content_moves_contents_over_backgrounds() {
// Old: red background with a white content square in the middle; new: blue background
// with a yellow square.
let content = |c: [u8; 4]| {
let mut img = solid(W, H, [0, 0, 0, 0]);
for y in 35..55u32 {
for x in 70..90u32 {
let i = ((y * W + x) * 4) as usize;
if let Some(p) = img.pixels.get_mut(i..i + 4) {
p.copy_from_slice(&c);
}
}
}
img
};
let parts = SlideParts {
old_back: Some(solid(W, H, OLD)),
old_content: Some(content([255, 255, 255, 255])),
new_back: solid(W, H, NEW),
new_content: content([255, 220, 0, 255]),
};
let old = solid(W, H, OLD);
let new = solid(W, H, NEW);
let f = |kind: &str, o: &str, t: f64| composite_transition(Some(&old), &new, Some(&parts), &transition_frame(kind, o, t, 16.0 / 9.0));
// Pan left at the middle: the backgrounds blend, the old square has moved left.
let img = f("pan", "l", 0.5);
let bg = img.pixel(5, 5);
assert!(bg[0] > 60 && bg[2] > 60, "{bg:?}");
assert_eq!(img.pixel(80, 45), bg, "the middle shows background only");
// Pan right: the new square arrives from the left.
let img = f("pan", "r", 0.6);
assert!((0..80).any(|x| {
let p = img.pixel(x, 45);
p[0] > 200 && p[1] > 180 && p[2] < 80
}));
// Reveal: the new content is in place near the end.
let p = f("reveal", "smoothlyLeft", 0.97).pixel(80, 45);
assert!(p[0] > 200 && p[1] > 180, "{p:?}");
// Without parts the dynamic transitions still draw whole slides.
let img = composite_transition(Some(&old), &new, None, &transition_frame("pan", "l", 0.5, 16.0 / 9.0));
assert_ne!(img.pixel(80, 45), [0, 0, 0, 255]);
}
}
Reference in New Issue View Git Blame Copy Permalink