f67d38b35cc5
graphic_clip.rs
//! Graphic clips: text and shape layers drawn as vectors straight into the output (no resampling),
//! with fill, up to two strokes (outer / centre / inner), a background box and a drop shadow.
//! Each layer is rasterised into a tight premultiplied linear-light image that is cached while
//! the layer and its transform stay the same.
//!
//! [`item_layer_specs`] evaluates a graphic clip's layers the way they are shown: keyframes read
//! through Responsive Design – Time, per-character style runs, responsive pins resolved (pinned
//! layers move, pinned shapes resize), and the roll / crawl offset applied to every layer.
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::sync::{Arc, Mutex, OnceLock};
use filmcraft_geom::{Affine, Vec2};
use filmcraft_project::graphic::{LayerContent, LayerSpec, LinearGradient, ShapeProps, Stroke, StrokeStyle, TextProps, eval_layer};
use filmcraft_project::graphic_design::{GraphicMeta, PinNode, remap_time, resolve_pins, roll_offset};
use filmcraft_project::{EffectInstance, TrackItem};
use filmcraft_text::raster::{Xform, apply, fill_into, xform_scale};
use filmcraft_text::{Align, Caps, Layout, Mask, ParagraphStyle, StrokeKind, StyleRun, TextStyle, layout_rich, mask, render};
use filmcraft_time::Tick;
use rayon::prelude::*;
use crate::graphics::{premul_linear, premul_linear_lerp};
use crate::image::Image;
/// f64 affine → the text crate's f32 transform.
pub fn xform(a: &Affine) -> Xform {
[a.a as f32, a.b as f32, a.c as f32, a.d as f32, a.e as f32, a.f as f32]
}
/// Layer pixels → graphic canvas pixels (position / anchor / scale / rotation).
pub fn layer_matrix(spec: &LayerSpec) -> Affine {
let t = &spec.transform;
Affine::motion(t.position, t.scale, t.rotation, t.anchor)
}
/// Text style + paragraph style of a text layer.
pub fn text_styles(t: &TextProps) -> (TextStyle, ParagraphStyle) {
(
TextStyle {
family: if t.font.is_empty() { filmcraft_text::fonts::DEFAULT_FAMILY.into() } else { t.font.clone() },
style: if t.style.is_empty() { "Regular".into() } else { t.style.clone() },
size: t.size,
tracking: t.tracking,
kerning: t.kerning,
ligatures: t.ligatures,
baseline_shift: t.baseline_shift,
faux_bold: t.faux_bold,
faux_italic: t.faux_italic,
caps: caps_of(t.caps),
underline: t.underline,
strikethrough: t.strikethrough,
},
ParagraphStyle {
align: match t.align {
1 => Align::Center,
2 => Align::Right,
3 => Align::Justify,
_ => Align::Left,
},
leading: t.leading,
width: (t.box_width > 0.0 && !t.vertical).then_some(t.box_width),
height: (t.box_width > 0.0 && t.box_height > 0.0 && !t.vertical).then_some(t.box_height),
rtl: None,
vertical: t.vertical,
},
)
}
fn caps_of(c: u32) -> Caps {
match c {
1 => Caps::All,
2 => Caps::Small,
_ => Caps::Normal,
}
}
/// The per-character style runs of a text layer as text-engine runs (overrides applied to the
/// layer's style).
pub fn text_runs(t: &TextProps, base: &TextStyle) -> Vec<StyleRun> {
t.runs
.iter()
.map(|(r, c)| StyleRun {
range: r.clone(),
style: TextStyle {
family: c.font.clone().filter(|f| !f.is_empty()).unwrap_or_else(|| base.family.clone()),
style: c.font_style.clone().filter(|f| !f.is_empty()).unwrap_or_else(|| base.style.clone()),
size: c.size.map_or(base.size, |s| s.max(0.1)),
tracking: c.tracking.unwrap_or(base.tracking),
baseline_shift: c.baseline_shift.unwrap_or(base.baseline_shift),
faux_bold: c.faux_bold.unwrap_or(base.faux_bold),
faux_italic: c.faux_italic.unwrap_or(base.faux_italic),
caps: c.caps.map_or(base.caps, caps_of),
underline: c.underline.unwrap_or(base.underline),
strikethrough: c.strikethrough.unwrap_or(base.strikethrough),
..base.clone()
},
})
.collect()
}
/// The laid-out text of a text layer (cached by the text engine).
pub fn text_layout(t: &TextProps) -> Arc<Layout> {
let (st, ps) = text_styles(t);
let runs = text_runs(t, &st);
layout_rich(&t.text, &st, &runs, &ps)
}
/// A shape layer's outline in layer pixels (centred on the layer origin).
pub fn shape_path(s: &ShapeProps) -> filmcraft_text::Path {
let (w, h) = (s.size.0 / 2.0, s.size.1 / 2.0);
match s.shape {
1 => filmcraft_text::Path::ellipse(0.0, 0.0, w, h),
2 => {
let n = s.sides.max(3);
let pts: Vec<(f32, f32)> = (0..n)
.map(|i| {
let a = std::f32::consts::TAU * i as f32 / n as f32 - std::f32::consts::FRAC_PI_2;
(a.cos() * w, a.sin() * h)
})
.collect();
filmcraft_text::Path::polygon(&pts)
}
3 if s.points.len() >= 3 => filmcraft_text::Path::polygon(&s.points.iter().map(|p| (p[0], p[1])).collect::<Vec<_>>()),
_ => filmcraft_text::Path::round_rect(-w, -h, w, h, s.corner_radius),
}
}
/// Content bounds `[x0, y0, x1, y1]` of a layer in layer pixels (text box or shape box).
pub fn layer_local_bounds(spec: &LayerSpec) -> [f32; 4] {
match &spec.content {
LayerContent::Text(t) => text_layout(t).bounds,
LayerContent::Shape(s) => match shape_path(s).bounds() {
Some(b) => [b.0, b.1, b.2, b.3],
None => [0.0; 4],
},
}
}
/// The four corners of a layer's content box in graphic canvas pixels (selection boxes, hit
/// testing, alignment), clockwise from the top-left.
pub fn layer_quad(spec: &LayerSpec) -> [Vec2; 4] {
let b = layer_local_bounds(spec);
let m = layer_matrix(spec);
[Vec2::new(b[0] as f64, b[1] as f64), Vec2::new(b[2] as f64, b[1] as f64), Vec2::new(b[2] as f64, b[3] as f64), Vec2::new(b[0] as f64, b[3] as f64)]
.map(|p| m.apply(p))
}
/// A rendered layer: premultiplied linear RGBA at device position (`x`, `y`).
#[derive(Debug)]
pub struct LayerRaster {
pub x: i32,
pub y: i32,
pub img: Image,
}
fn stroke_kind(k: u32) -> StrokeKind {
match k {
1 => StrokeKind::Center,
2 => StrokeKind::Inner,
_ => StrokeKind::Outer,
}
}
fn bbox_of(m: &Xform, b: [f32; 4], pad: f32) -> [f32; 4] {
let pts = [(b[0] - pad, b[1] - pad), (b[2] + pad, b[1] - pad), (b[0] - pad, b[3] + pad), (b[2] + pad, b[3] + pad)];
let mut o = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
for (x, y) in pts {
let (a, c) = apply(m, x, y);
o = [o[0].min(a), o[1].min(c), o[2].max(a), o[3].max(c)];
}
o
}
fn union(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
[a[0].min(b[0]), a[1].min(b[1]), a[2].max(b[2]), a[3].max(b[3])]
}
/// Over-composite `c` (premultiplied) through `m` into `px` (premultiplied RGBA, same size).
fn over_mask(px: &mut [f32], m: &Mask, c: [f32; 4]) {
if c[3] <= 0.0 || m.w == 0 {
return;
}
px.par_chunks_mut(4 * m.w).zip(m.a.par_chunks(m.w)).for_each(|(row, mrow)| {
for (p, &a) in row.as_chunks_mut::<4>().0.iter_mut().zip(mrow) {
if a > 0.0 {
let k = 1.0 - c[3] * a;
for i in 0..4 {
p[i] = c[i] * a + p[i] * k;
}
}
}
});
}
fn invert_xform(m: &Xform) -> Option<Xform> {
let det = m[0] * m[3] - m[1] * m[2];
if det.abs() < 1e-8 {
return None;
}
let inv = 1.0 / det;
let a = m[3] * inv;
let b = -m[1] * inv;
let c = -m[2] * inv;
let d = m[0] * inv;
Some([a, b, c, d, -(a * m[4] + c * m[5]), -(b * m[4] + d * m[5])])
}
/// Paint `grad` through `msk`. 0° runs left to right across `lb` in layer space; the angle is
/// clockwise on screen and turns with `inv` (the device→layer transform).
fn over_linear_gradient(px: &mut [f32], msk: &Mask, grad: &LinearGradient, lb: [f32; 4], inv: &Xform, origin: (i32, i32)) {
if msk.w == 0 {
return;
}
let (cx, cy) = ((lb[0] + lb[2]) * 0.5, (lb[1] + lb[3]) * 0.5);
let (sin, cos) = grad.angle.to_radians().sin_cos();
let (ax, ay) = (cos, sin);
let corners = [(lb[0], lb[1]), (lb[2], lb[1]), (lb[0], lb[3]), (lb[2], lb[3])];
let half = corners.iter().map(|(x, y)| ((x - cx) * ax + (y - cy) * ay).abs()).fold(1e-3_f32, f32::max);
let w = msk.w;
let (start, end) = (grad.start, grad.end);
px.par_chunks_mut(4 * w).enumerate().for_each(|(row, dest)| {
let py = origin.1 as f32 + row as f32 + 0.5;
let mrow = &msk.a[row * w..(row + 1) * w];
for (col, (p, &cov)) in dest.as_chunks_mut::<4>().0.iter_mut().zip(mrow).enumerate() {
if cov <= 0.0 {
continue;
}
let (lx, ly) = apply(inv, origin.0 as f32 + col as f32 + 0.5, py);
let t = (((((lx - cx) * ax + (ly - cy) * ay) / half) + 1.0) * 0.5).clamp(0.0, 1.0);
let c = premul_linear_lerp(start, end, t);
let k = 1.0 - c[3] * cov;
for i in 0..4 {
p[i] = c[i] * cov + p[i] * k;
}
}
});
}
/// The style runs that own at least one glyph or decoration (run 0, the base style, always counts).
/// Runs without any cannot paint, so they must not cost a colour group and its full-size mask.
fn used_runs(layout: &Layout) -> Vec<bool> {
let mut used = vec![false; layout.glyphs.iter().map(|g| g.run).chain(layout.underline_runs.iter().copied()).max().map_or(1, |m| m as usize + 1)];
used[0] = true;
for r in layout.glyphs.iter().map(|g| g.run).chain(layout.underline_runs.iter().copied()) {
used[r as usize] = true;
}
used
}
/// Most colour groups (each a full-size mask and a pass over it) painted for one layer: about a
/// billion pixel visits. Groups past it are not painted.
fn max_groups(cover: &Mask) -> usize {
((1usize << 30) / cover.w.saturating_mul(cover.h).max(1)).max(1)
}
/// Group text runs by their effective colour, including unstyled text (run 0). Only `used` runs
/// are grouped, at most `max` groups.
fn color_groups(color: [f32; 4], overrides: &[Option<[f32; 4]>], used: &[bool], max: usize) -> Vec<([f32; 4], Vec<u16>)> {
let mut groups: Vec<([f32; 4], Vec<u16>)> = Vec::new();
let mut index: HashMap<[u32; 4], usize> = HashMap::new();
for (r, col) in std::iter::once(color).chain(overrides.iter().map(|c| c.unwrap_or(color))).enumerate() {
let Ok(run) = u16::try_from(r) else { break };
if !used.get(r).copied().unwrap_or(false) {
continue;
}
match index.get(&col.map(f32::to_bits)) {
Some(&g) => groups[g].1.push(run),
None if groups.len() < max => {
index.insert(col.map(f32::to_bits), groups.len());
groups.push((col, vec![run]));
}
None => {}
}
}
groups
}
/// Solid fill, one mask per distinct colour when text runs carry their own.
fn paint_solid(px: &mut [f32], cover: &Mask, color: [f32; 4], text: Option<&Layout>, m: &Xform, run_fills: &[Option<[f32; 4]>], origin: (i32, i32)) {
let Some(layout) = text.filter(|_| run_fills.iter().any(Option::is_some)) else {
over_mask(px, cover, premul_linear(color));
return;
};
for (col, runs) in color_groups(color, run_fills, &used_runs(layout), max_groups(cover)) {
let mut m_run = Mask::new(cover.w, cover.h);
for r in runs {
render::draw_run(layout, m, &mut m_run, origin, Some(r));
}
over_mask(px, &m_run, premul_linear(col));
}
}
/// Shared coverage and coordinates for both strokes. Colour groups are rasterised one at a time,
/// keeping memory bounded even when every character has a distinct stroke colour.
struct StrokeCoverage<'a> {
cover: &'a Mask,
text: Option<&'a Layout>,
transform: &'a Xform,
origin: (i32, i32),
scale: f32,
filled: bool,
}
struct StrokeGroup {
style: StrokeStyle,
runs: Vec<u16>,
}
struct StrokePlan {
groups: Vec<StrokeGroup>,
/// A uniform layer keeps the existing one-mask fast path.
whole: Option<Mask>,
}
impl StrokeCoverage<'_> {
fn mask(&self, source: &Mask, stroke: &StrokeStyle) -> Mask {
let mut sm = mask::stroke(source, stroke.width * self.scale, stroke_kind(stroke.kind));
// Outer coverage includes the glyph for a seamless fill. With Fill off, retain only
// the ring outside all glyphs, including neighbours with another stroke colour.
if !self.filled && stroke.kind != 1 && stroke.kind != 2 {
sm.a.iter_mut().zip(&self.cover.a).for_each(|(v, c)| *v = v.min(1.0 - c));
}
sm
}
fn prepare(&self, stroke: &Stroke) -> StrokePlan {
if self.text.is_none() || stroke.runs.iter().all(|s| *s == stroke.style) {
return StrokePlan { groups: vec![StrokeGroup { style: stroke.style, runs: Vec::new() }], whole: Some(self.mask(self.cover, &stroke.style)) };
}
let mut groups: Vec<StrokeGroup> = Vec::new();
let used = self.text.map(used_runs).unwrap_or_default();
let max = max_groups(self.cover);
for (r, style) in std::iter::once(stroke.style).chain(stroke.runs.iter().copied()).enumerate() {
let Ok(run) = u16::try_from(r) else { break };
if !style.active() || !used.get(r).copied().unwrap_or(false) {
continue;
}
match groups.iter().position(|g| g.style == style) {
Some(g) => groups[g].runs.push(run),
None if groups.len() < max => groups.push(StrokeGroup { style, runs: vec![run] }),
None => {}
}
}
StrokePlan { groups, whole: None }
}
/// Visit one coverage mask at a time, grouping independently of unrelated fill/font runs.
fn visit(&self, plan: &StrokePlan, keep: impl Fn(u32) -> bool, mut paint: impl FnMut(&Mask, StrokeStyle)) {
for group in &plan.groups {
if !group.style.active() || !keep(group.style.kind) {
continue;
}
if let Some(whole) = &plan.whole {
paint(whole, group.style);
continue;
}
let Some(layout) = self.text else { continue };
let mut coverage = Mask::new(self.cover.w, self.cover.h);
for &run in &group.runs {
render::draw_run(layout, self.transform, &mut coverage, self.origin, Some(run));
}
paint(&self.mask(&coverage, &group.style), group.style);
}
}
}
/// Gradient for runs that have no fill of their own; runs with a fill stay that solid colour.
struct MixedGradient<'a> {
px: &'a mut [f32],
cover: &'a Mask,
grad: &'a LinearGradient,
bounds: [f32; 4],
inverse: &'a Xform,
origin: (i32, i32),
layout: &'a Layout,
transform: &'a Xform,
run_fills: &'a [Option<[f32; 4]>],
}
fn paint_mixed_gradient(input: MixedGradient<'_>) {
let MixedGradient { px, cover, grad, bounds, inverse, origin, layout, transform, run_fills } = input;
let mut grad_mask = Mask::new(cover.w, cover.h);
render::draw_run(layout, transform, &mut grad_mask, origin, Some(0));
let mut solids: Vec<([f32; 4], Vec<u16>)> = Vec::new();
let used = used_runs(layout);
let max = max_groups(cover);
for (i, fill) in run_fills.iter().enumerate() {
let Ok(run) = u16::try_from(i + 1) else { break };
if !used.get(i + 1).copied().unwrap_or(false) {
continue; // owns no glyph: nothing to paint
}
if let Some(col) = fill {
match solids.iter().position(|g| g.0 == *col) {
Some(g) => solids[g].1.push(run),
None if solids.len() < max => solids.push((*col, vec![run])),
None => {}
}
} else {
render::draw_run(layout, transform, &mut grad_mask, origin, Some(run));
}
}
over_linear_gradient(px, &grad_mask, grad, bounds, inverse, origin);
for (col, runs) in solids {
let mut m_run = Mask::new(cover.w, cover.h);
for r in runs {
render::draw_run(layout, transform, &mut m_run, origin, Some(r));
}
over_mask(px, &m_run, premul_linear(col));
}
}
/// Rasterise one layer with layer→device transform `m`, clipped to a `cw`×`ch` canvas.
pub fn raster_layer(spec: &LayerSpec, m: &Xform, cw: usize, ch: usize) -> Option<LayerRaster> {
if !spec.enabled || spec.transform.opacity <= 0.0 {
return None;
}
let s = xform_scale(m).max(1e-6);
let ap = &spec.appearance;
let text = match &spec.content {
LayerContent::Text(t) => {
let l = text_layout(t);
if l.glyphs.is_empty() && l.underlines.is_empty() && ap.background.is_none() {
return None;
}
Some(l)
}
LayerContent::Shape(_) => None,
};
let lb = match &text {
Some(l) => l.bounds,
None => layer_local_bounds(spec),
};
let shape = match &spec.content {
LayerContent::Shape(sh) => Some(shape_path(sh).transformed(m)),
_ => None,
};
let stroke_out = ap
.strokes
.iter()
.flat_map(|stroke| std::iter::once(stroke.style).chain(stroke.runs.iter().copied()))
.filter(StrokeStyle::active)
.map(|stroke| {
if stroke.kind == 2 {
0.0
} else if stroke.kind == 1 {
stroke.width / 2.0
} else {
stroke.width
}
})
.fold(0.0f32, f32::max);
let overhang = text.as_ref().map_or(0.0, |l| l.glyphs.iter().map(|g| g.size).fold(0.0f32, f32::max) * 0.35);
let mut bb = bbox_of(m, lb, overhang + stroke_out + 2.0 / s);
if let Some((_, pad, _)) = ap.background {
bb = union(bb, bbox_of(m, lb, pad + 1.0 / s));
}
let mut shadow_dev = (0.0f32, 0.0f32);
if let Some(sh) = &ap.shadow {
// the offset is in layer space, so it turns and scales with the layer
shadow_dev = (m[0] * sh.offset.0 + m[2] * sh.offset.1, m[1] * sh.offset.0 + m[3] * sh.offset.1);
let grow = (sh.size + sh.blur) * s + 2.0;
bb = union(bb, [bb[0] + shadow_dev.0 - grow, bb[1] + shadow_dev.1 - grow, bb[2] + shadow_dev.0 + grow, bb[3] + shadow_dev.1 + grow]);
}
// clip to the canvas, keeping enough margin for blur to read content just outside it
let margin = ap.shadow.as_ref().map_or(2.0, |sh| (sh.blur + sh.size) * s + shadow_dev.0.abs().max(shadow_dev.1.abs()) + 2.0);
let x0 = bb[0].floor().max(-margin) as i32;
let y0 = bb[1].floor().max(-margin) as i32;
let x1 = bb[2].ceil().min(cw as f32 + margin) as i32;
let y1 = bb[3].ceil().min(ch as f32 + margin) as i32;
if x1 <= x0 || y1 <= y0 || x1 <= 0 || y1 <= 0 || x0 >= cw as i32 || y0 >= ch as i32 {
return None;
}
let (w, h) = ((x1 - x0) as usize, (y1 - y0) as usize);
if w * h > 64 << 20 {
return None;
}
let mut cover = Mask::new(w, h);
if let Some(l) = &text {
render::draw(l, m, &mut cover, (x0, y0));
}
if let Some(p) = &shape {
fill_into(p, &mut cover, -x0 as f32, -y0 as f32);
}
let stroke_cover = StrokeCoverage { cover: &cover, text: text.as_deref(), transform: m, origin: (x0, y0), scale: s, filled: ap.fill.is_some() };
let strokes: Vec<_> = ap.strokes.iter().map(|stroke| stroke_cover.prepare(stroke)).collect();
let outer = |k: u32| k != 1 && k != 2;
let bg = ap.background.map(|(c, pad, r)| {
let p = filmcraft_text::Path::round_rect(lb[0] - pad, lb[1] - pad, lb[2] + pad, lb[3] + pad, r).transformed(m);
let mut bm = Mask::new(w, h);
fill_into(&p, &mut bm, -x0 as f32, -y0 as f32);
(bm, c)
});
let mut px = vec![0.0f32; w * h * 4];
if let Some(sh) = &ap.shadow {
let mut u = if ap.fill.is_some() { cover.clone() } else { Mask::new(w, h) };
for stroke in &strokes {
stroke_cover.visit(stroke, |_| true, |sm, _| u.max_with(sm));
}
if let Some((bm, _)) = &bg {
u.max_with(bm);
}
if sh.size > 0.0 {
u = mask::stroke(&u, sh.size * s, StrokeKind::Outer);
}
let u = mask::offset(&u, shadow_dev.0.round() as i32, shadow_dev.1.round() as i32);
let u = mask::blur(&u, sh.blur * s / 3.0);
over_mask(&mut px, &u, premul_linear(sh.color));
}
if let Some((bm, c)) = &bg {
over_mask(&mut px, bm, premul_linear(*c));
}
// outer strokes sit under the fill; centre and inner strokes are drawn over it
for stroke in strokes.iter().rev() {
stroke_cover.visit(stroke, outer, |sm, style| over_mask(&mut px, sm, premul_linear(style.color)));
}
let run_fills: Vec<Option<[f32; 4]>> = match &spec.content {
LayerContent::Text(t) => t.runs.iter().map(|(_, s)| s.fill).collect(),
_ => Vec::new(),
};
if let Some(grad) = &ap.gradient
&& let Some(inv) = invert_xform(m)
{
if run_fills.iter().any(Option::is_some)
&& let Some(layout) = &text
{
paint_mixed_gradient(MixedGradient {
px: &mut px,
cover: &cover,
grad,
bounds: lb,
inverse: &inv,
origin: (x0, y0),
layout,
transform: m,
run_fills: &run_fills,
});
} else {
over_linear_gradient(&mut px, &cover, grad, lb, &inv, (x0, y0));
}
} else if let Some(c) = ap.fill {
paint_solid(&mut px, &cover, c, text.as_deref(), m, &run_fills, (x0, y0));
}
for stroke in strokes.iter().rev() {
stroke_cover.visit(stroke, |k| !outer(k), |sm, style| over_mask(&mut px, sm, premul_linear(style.color)));
}
let op = spec.transform.opacity;
if op < 1.0 {
px.iter_mut().for_each(|v| *v *= op);
}
Some(LayerRaster { x: x0, y: y0, img: Image { w, h, px } })
}
type Cache = Mutex<HashMap<u64, (u64, Option<Arc<LayerRaster>>)>>;
fn raster_cache() -> &'static Cache {
static C: OnceLock<Cache> = OnceLock::new();
C.get_or_init(Default::default)
}
/// [`raster_layer`] through a small cache (static titles re-composite without re-rasterising).
pub fn raster_layer_cached(spec: &LayerSpec, m: &Xform, cw: usize, ch: usize) -> Option<Arc<LayerRaster>> {
let mut hs = std::collections::hash_map::DefaultHasher::new();
format!("{spec:?}").hash(&mut hs);
m.iter().for_each(|v| v.to_bits().hash(&mut hs));
(cw, ch).hash(&mut hs);
let key = hs.finish();
static CLOCK: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
let now = CLOCK.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
if let Some(e) = raster_cache().lock().unwrap_or_else(|e| e.into_inner()).get_mut(&key) {
e.0 = now;
return e.1.clone();
}
let r = raster_layer(spec, m, cw, ch).map(Arc::new);
let mut c = raster_cache().lock().unwrap_or_else(|e| e.into_inner());
if c.len() >= 96
&& let Some(k) = c.iter().min_by_key(|(_, v)| v.0).map(|(k, _)| *k)
{
c.remove(&k);
}
c.insert(key, (now, r.clone()));
r
}
/// Over-composite a raster at (`r.x` + `dx`, `r.y` + `dy`) onto `img`.
pub fn composite_raster(img: &mut Image, r: &LayerRaster, dx: i32, dy: i32) {
let (rx, ry) = (r.x + dx, r.y + dy);
let (w, h) = (img.w as i32, img.h as i32);
let ys = ry.max(0)..(ry + r.img.h as i32).min(h);
let xs = rx.max(0)..(rx + r.img.w as i32).min(w);
if ys.is_empty() || xs.is_empty() {
return;
}
let iw = img.w;
img.px[ys.start as usize * iw * 4..ys.end as usize * iw * 4].par_chunks_mut(iw * 4).enumerate().for_each(|(row_i, row)| {
let sy = (ys.start + row_i as i32 - ry) as usize;
for x in xs.clone() {
let si = (sy * r.img.w + (x - rx) as usize) * 4;
let s = &r.img.px[si..si + 4];
if s[3] <= 0.0 {
continue;
}
let d = &mut row[x as usize * 4..x as usize * 4 + 4];
let k = 1.0 - s[3];
for c in 0..4 {
d[c] = s[c] + d[c] * k;
}
}
});
}
/// Axis-aligned bounds `[x0, y0, x1, y1]` of a layer's content box in canvas pixels.
pub fn layer_bounds(spec: &LayerSpec) -> [f64; 4] {
let q = layer_quad(spec);
let mut b = [f64::MAX, f64::MAX, f64::MIN, f64::MIN];
for p in q {
b = [b[0].min(p.x), b[1].min(p.y), b[2].max(p.x), b[3].max(p.y)];
}
b
}
/// Resolve responsive pins of evaluated layers in place: pinned layers move, shapes pinned on
/// opposite edges resize.
pub fn apply_pins(specs: &mut [LayerSpec], canvas: (u32, u32)) {
if !specs.iter().any(|s| s.pin.is_some()) {
return;
}
let nodes: Vec<PinNode> = specs
.iter()
.map(|s| PinNode { uid: s.uid, pin: s.pin.clone(), bounds: layer_bounds(s), resizable: matches!(s.content, LayerContent::Shape(_)) })
.collect();
let out = resolve_pins(&nodes, [0.0, 0.0, canvas.0 as f64, canvas.1 as f64]);
for ((s, n), b) in specs.iter_mut().zip(&nodes).zip(out) {
if b == n.bounds {
continue;
}
let (ow, oh) = (n.bounds[2] - n.bounds[0], n.bounds[3] - n.bounds[1]);
let (nw, nh) = (b[2] - b[0], b[3] - b[1]);
if let LayerContent::Shape(sh) = &mut s.content {
let kx = if ow > 1e-9 { nw / ow } else { 1.0 };
let ky = if oh > 1e-9 { nh / oh } else { 1.0 };
if (kx - 1.0).abs() > 1e-12 || (ky - 1.0).abs() > 1e-12 {
sh.size = ((sh.size.0 as f64 * kx) as f32, (sh.size.1 as f64 * ky) as f32);
sh.points.iter_mut().for_each(|p| *p = [(p[0] as f64 * kx) as f32, (p[1] as f64 * ky) as f32]);
}
}
let now = layer_bounds(s);
s.transform.position = Vec2::new(s.transform.position.x + b[0] - now[0], s.transform.position.y + b[1] - now[1]);
}
}
/// Evaluated layers of a graphic clip's effect list at clip time `t`, in paint order, with pins
/// resolved.
pub fn graphic_specs(effects: &[EffectInstance], t: Tick, canvas: (u32, u32)) -> Vec<LayerSpec> {
let mut v: Vec<LayerSpec> = effects.iter().filter(|e| filmcraft_project::graphic::is_layer(e)).filter_map(|e| eval_layer(e, t, canvas)).collect();
apply_pins(&mut v, canvas);
v
}
/// The media time at which a graphic clip's layers are read at media time `mt` (Responsive Design
/// – Time), and the clip-relative time and clip length (media time) for rolls.
pub fn graphic_time(item: &TrackItem, mt: Tick) -> (Tick, Tick, Tick) {
let u = mt - item.source_in;
let d = Tick((item.duration.0 as f64 * item.speed.abs().max(1e-9)).round() as i64);
let t = match item.graphic.as_deref() {
Some(m) if m.has_responsive_time() => remap_time(m, u, d),
_ => mt,
};
(t, u, d)
}
/// Union of the layers' bounds (with background padding) for rolls and crawls.
fn content_bounds(specs: &[LayerSpec]) -> Option<[f64; 4]> {
let mut b: Option<[f64; 4]> = None;
for s in specs.iter().filter(|s| s.enabled) {
let mut lb = layer_bounds(s);
if let Some((_, pad, _)) = s.appearance.background {
let k = s.transform.scale.x.abs().max(s.transform.scale.y.abs());
let p = pad as f64 * k;
lb = [lb[0] - p, lb[1] - p, lb[2] + p, lb[3] + p];
}
b = Some(match b {
Some(a) => [a[0].min(lb[0]), a[1].min(lb[1]), a[2].max(lb[2]), a[3].max(lb[3])],
None => lb,
});
}
b
}
/// A graphic clip's layers at media time `mt` as shown: `(effect index, layer)` in paint order,
/// with Responsive Design – Time, pins and the roll / crawl offset applied. Includes hidden
/// layers (their `enabled` is false).
pub fn item_layer_specs(item: &TrackItem, mt: Tick, canvas: (u32, u32)) -> Vec<(usize, LayerSpec)> {
let (t, u, d) = graphic_time(item, mt);
let mut idx = Vec::new();
let mut specs = Vec::new();
for (i, e) in item.effects.iter().enumerate() {
if filmcraft_project::graphic::is_layer(e)
&& let Some(s) = eval_layer(e, t, canvas)
{
idx.push(i);
specs.push(s);
}
}
apply_pins(&mut specs, canvas);
if let Some(meta) = item.graphic.as_deref() {
apply_roll(meta, &mut specs, u, d, canvas);
}
idx.into_iter().zip(specs).collect()
}
/// Move every layer by the roll / crawl offset at clip time `u` of a clip `d` long.
pub fn apply_roll(meta: &GraphicMeta, specs: &mut [LayerSpec], u: Tick, d: Tick, canvas: (u32, u32)) {
if meta.roll.mode == filmcraft_project::RollMode::Off {
return;
}
let Some(cb) = content_bounds(specs) else { return };
let (dx, dy) = roll_offset(&meta.roll, u, d, canvas, cb);
for s in specs.iter_mut() {
s.transform.position = Vec2::new(s.transform.position.x + dx, s.transform.position.y + dy);
}
}
/// Draw all layers of a graphic clip at media time `mt` onto `out`; `m` maps graphic canvas
/// pixels to `out` pixels.
pub fn render_graphic(item: &TrackItem, mt: Tick, canvas: (u32, u32), m: &Affine, out: &mut Image) {
let specs: Vec<LayerSpec> = item_layer_specs(item, mt, canvas).into_iter().map(|(_, s)| s).collect();
draw_specs(&specs, m, out);
}
/// Draw a graphic's layers (an effect list, without clip settings) at time `t` onto `out`.
pub fn render_graphic_layers(effects: &[EffectInstance], t: Tick, canvas: (u32, u32), m: &Affine, out: &mut Image) {
draw_specs(&graphic_specs(effects, t, canvas), m, out);
}
fn draw_specs(specs: &[LayerSpec], m: &Affine, out: &mut Image) {
for spec in specs {
let lm = xform(&m.then_apply(&layer_matrix(spec)));
if let Some(r) = raster_layer_cached(spec, &lm, out.w, out.h) {
composite_raster(out, &r, 0, 0);
}
}
}
/// All layers composed into one tight image (for the GPU plan): `(image, x, y)` in output pixels.
pub fn render_graphic_tight(item: &TrackItem, mt: Tick, canvas: (u32, u32), m: &Affine, w: usize, h: usize) -> Option<(Image, i32, i32)> {
let rasters: Vec<Arc<LayerRaster>> =
item_layer_specs(item, mt, canvas).iter().filter_map(|(_, spec)| raster_layer_cached(spec, &xform(&m.then_apply(&layer_matrix(spec))), w, h)).collect();
let x0 = rasters.iter().map(|r| r.x).min()?.max(0);
let y0 = rasters.iter().map(|r| r.y).min()?.max(0);
let x1 = rasters.iter().map(|r| r.x + r.img.w as i32).max()?.min(w as i32);
let y1 = rasters.iter().map(|r| r.y + r.img.h as i32).max()?.min(h as i32);
if x1 <= x0 || y1 <= y0 {
return None;
}
let mut img = Image::new((x1 - x0) as usize, (y1 - y0) as usize);
for r in &rasters {
composite_raster(&mut img, r, -x0, -y0);
}
Some((img, x0, y0))
}
#[cfg(test)]
mod tests;
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.