EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Render: Renderer::precomp_source and run_layer_effects_on, so an accelerator can render a precomp layer's nested comp itself (#640)
Matej Kozlovský21b732875fb5
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rsindex 46e108661..d2ed0f4b1 100644--- a/crates/render/src/lib.rs+++ b/crates/render/src/lib.rs@@ -623,6 +623,30 @@ impl<'a> Renderer<'a> {}}+ /// A precomp layer's nested comp for an accelerator to render resident (no CPU render and+ /// upload of the nested frame): the renderer one level down, the comp, its time and the+ /// buffer scale, exactly as [`Self::layer_source`]'s comp branch would render it. `None`+ /// when that branch does more (composition proxy, Essential Properties overrides, frame+ /// blending, recursion) or draws nothing (outside the nested comp's span): use the CPU path.+ pub fn precomp_source(&self, ctx: &EvalCtx, layer: &Layer) -> Option<(Renderer<'a>, ItemId, Tick, f64)> {+ let LayerSource::Comp { item } = layer.source else { return None };+ if layer.switches.adjustment || self.project.comp_contains(item, ctx.comp_id) {+ return None;+ }+ let nc = self.project.comp(item)?;+ let lt = ctx.nested_time(layer);+ if self.content_times(ctx, layer).is_some() {+ return None;+ }+ if !nc.covers(lt) || self.proxy_for(item).is_some() || !essential_overrides(ctx, layer).is_empty() || frame_blend_mode(ctx, layer) != FrameBlend::Off {+ return None;+ }+ let s = self.opts.scale;+ let bs = if s < 1.0 && nc.preserve_resolution { 1.0 } else { s };+ let base = self.nested_through(layer);+ Some((Renderer { opts: RenderOpts { scale: bs, ..base.opts }, ..base }, item, lt, bs))+ }+/// The nested comp of a precomp layer whose transformations collapse into this comp: the/// Collapse Transformations switch is on and the layer has no masks, effects or layer/// styles (those force a flattened render of the precomp, as in After Effects).@@ -1988,6 +2012,15 @@ impl<'a> Renderer<'a> {self.run_effect_stack(ctx, layer, adjustment, usize::MAX, None, [0.0; 2], target);}+ /// [`Renderer::run_effects_on`] for a (non-adjustment) layer's own pixels: `target` holds+ /// them in effect space (as [`Renderer::layer_input`] hands them out) and the result stays+ /// there. Returns the effect-space origin in layer coordinates (rebase by its negation).+ pub fn run_layer_effects_on(&self, ctx: &EvalCtx, layer: &Layer, target: &mut dyn FxTarget) -> [f64; 2] {+ let origin = ctx.effect_bounds(layer).1;+ self.run_effect_stack(ctx, layer, false, usize::MAX, None, origin, target);+ origin+ }+/// An adjustment layer's footprint (its source with masks applied, layer space): where/// its effects show. `None` = the layer changes nothing.pub fn adjustment_footprint(&self, ctx: &EvalCtx, layer: &Layer) -> Option<Arc<Buf>> {