Skip to content

EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust

GPU: precomp layers render their nested comp resident on the GPU instead of on the CPU and uploading it every frame (#640)

Matej Kozlovský8321d099d25f
diff --git a/crates/gpu/src/tests.rs b/crates/gpu/src/tests.rs
index 39be29a97..0234f7934 100644
--- a/crates/gpu/src/tests.rs
+++ b/crates/gpu/src/tests.rs
@@ -745,3 +745,43 @@ fn within_memory_returns_the_work_when_there_is_room() {
let img = g.within_memory(|| g.ctx.image(64, 32)).expect("room for a 64×32 texture");
assert_eq!((img.width, img.height), (64, 32));
}
+
+/// Precomp layers (not collapsed) render their nested comp resident on the GPU
+/// (`walk::draw_precomp`): match the CPU (nested blend modes, effects inside and outside,
+/// transforms, opacity, a blend mode on the precomp layer, half resolution,
+/// two instances at different times of the same nested comp).
+#[test]
+fn nested_precomps_render_resident() {
+ for depth in [BitDepth::Bpc8, BitDepth::Bpc32] {
+ let mut s = Scene::new(depth);
+ let inner = Comp::new(60, 40, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
+ let inner_id = s.p.add_item("Inner", Label::Sandstone, None, ItemKind::Comp(inner.clone().into()));
+ {
+ let mut ins = Scene { p: std::mem::take(&mut s.p), cid: inner_id, comp: inner };
+ let mut a = ins.footage(50, 30);
+ ins.effect(&mut a, "ec.blur.gaussian", &[("blurriness", n(3.0))]);
+ ins.push(a);
+ let mut b = ins.solid([0.2, 0.7, 0.4], 30, 20);
+ b.blend_mode = BlendMode::Difference;
+ set(&mut b, "transform/rotation", Value::Scalar(15.0));
+ ins.push(b);
+ s.p = ins.p;
+ }
+ let bg = s.footage(97, 61);
+ s.push(bg);
+ let mut pre = build::layer(&mut s.p, &s.comp, "Inner", LayerSource::Comp { item: inner_id }, (60, 40), None);
+ set(&mut pre, "transform/rotation", Value::Scalar(25.0));
+ set(&mut pre, "transform/opacity", Value::Scalar(80.0));
+ s.effect(&mut pre, "ec.color.levels", &[("gamma", n(1.3))]);
+ pre.blend_mode = BlendMode::Screen;
+ s.push(pre);
+ // A second instance, later in the nested comp's time.
+ let mut pre2 = build::layer(&mut s.p, &s.comp, "Inner 2", LayerSource::Comp { item: inner_id }, (60, 40), None);
+ set(&mut pre2, "transform/position", v3(70.0, 40.0));
+ pre2.start_time = Tick::from_seconds_f64(-0.5);
+ s.push(pre2);
+ check(&format!("nested precomps {depth:?}"), compare_at(&s, opts(), Tick::from_seconds_f64(0.2)), 0.0);
+ let half = RenderOpts { scale: 0.5, ..opts() };
+ check(&format!("nested precomps half {depth:?}"), compare_at(&s, half, Tick::from_seconds_f64(0.2)), 0.0);
+ }
+}
diff --git a/crates/gpu/src/walk.rs b/crates/gpu/src/walk.rs
index b5bd166c8..e2b2910f8 100644
--- a/crates/gpu/src/walk.rs
+++ b/crates/gpu/src/walk.rs
@@ -214,6 +214,9 @@ fn draw_layer(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canvas: &
if opacity <= 0.0 {
return Some(());
}
+ if let Some(done) = draw_precomp(e, r, ctx, layer, canvas, opacity) {
+ return done;
+ }
let Some(st) = r.styled_layer(ctx, layer) else { return Some(()) };
if st.plain {
return composite_layer(e, r, ctx, layer, &st.body, canvas, opacity);
@@ -243,6 +246,50 @@ fn draw_layer(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canvas: &
Some(())
}
+/// A 2D precomp layer, its nested comp rendered resident on the GPU (`walk::render` one level
+/// down) instead of by the CPU compositor and uploaded every frame (`Renderer::layer_source`
+/// renders nested comps on the CPU: depth > 0). Then the layer's effects (resident), its
+/// placement, track matte / Preserve Transparency and blend, as for any layer. `None`: not this
+/// kind of layer, or the nested comp needs the CPU path (masks, layer styles, proxies,
+/// overrides, frame blending, nested motion-blur sampling; see `Renderer::precomp_source`);
+/// `Some(None)`: the GPU failed.
+fn draw_precomp(e: &mut Enc, r: &Renderer, ctx: &EvalCtx, layer: &Layer, canvas: &mut GpuImage, opacity: f32) -> Option<Option<()>> {
+ if layer.masks().is_some_and(|m| !m.children.is_empty()) || styles::active(ctx, layer) {
+ return None;
+ }
+ let (sub, item, lt, bs) = r.precomp_source(ctx, layer)?;
+ let Some(mut src) = render(e, &sub, item, lt) else { return Some(None) };
+ let pipe = r.pipe();
+ // `masked_source` quantises a non-solid source to the project's depth.
+ if let Some(l) = pipe.levels {
+ src = ops::quantize(e, &src, l);
+ }
+ let (mut img, offset, scale) = if layer.switches.effects && layer.effects().is_some_and(|f| !f.children.is_empty()) {
+ // Effects run in effect space (0.7.0): from the layer bounds' corner.
+ let o = ctx.effect_bounds(layer).1;
+ let mut fx = crate::effects::GpuFx::new(e, src, [o[0] * bs, o[1] * bs], bs, pipe.levels);
+ r.run_layer_effects_on(ctx, layer, &mut fx);
+ let Some((img, off, sc)) = fx.finish() else { return Some(None) };
+ (img, [off[0] - o[0] * sc, off[1] - o[1] * sc], sc)
+ } else {
+ (src, [0.0; 2], bs)
+ };
+ if img.width == 0 || img.height == 0 {
+ return Some(Some(()));
+ }
+ if let Some(c) = pipe.to_blend() {
+ img = ops::convert(e, &img, &c);
+ }
+ let shape = Buf { img: Image { width: img.width, height: img.height, data: Vec::new() }, offset, scale };
+ if r.track_matte(ctx, layer).is_some() || layer.preserve_transparency {
+ let Some(iso) = place_src(e, r, ctx, layer, &shape, img, &e.zeros(canvas.width, canvas.height), BlendMode::Normal, 1.0, None) else {
+ return Some(None);
+ };
+ return Some(composite_iso(e, r, ctx, layer, iso, canvas, opacity));
+ }
+ Some(place_src(e, r, ctx, layer, &shape, img, canvas, layer.blend_mode, opacity, pipe.levels).map(|c| *canvas = c))
+}
+
/// Adjustment layer (`Renderer::draw_adjustment`): the effect stack runs on the comp below,
/// resident on the GPU (non-GPU effects read back, run on the CPU and upload), and the result
/// replaces the canvas inside the layer's footprint × opacity. `None` = draw it on the CPU.
@@ -342,6 +389,23 @@ fn place(
return Some(target.clone());
}
let src = e.g.upload_buf(buf)?;
+ place_src(e, r, ctx, layer, buf, src, target, mode, opacity, levels)
+}
+
+/// [`place`] of a GPU image `src` shaped like `buf`.
+#[allow(clippy::too_many_arguments)]
+fn place_src(
+ e: &mut Enc,
+ r: &Renderer,
+ ctx: &EvalCtx,
+ layer: &Layer,
+ buf: &Buf,
+ src: GpuImage,
+ target: &GpuImage,
+ mode: BlendMode,
+ opacity: f32,
+ levels: Option<f32>,
+) -> Option<GpuImage> {
let pl = r.placement(ctx, layer, buf);
if let [m] = pl.matrices.as_slice() {
return Some(ops::warp_q(e, target, &src, m, pl.sampling, mode, opacity, pl.seed, None, levels));