Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
feat(compositor): the Linux pass of shader effects
EtienneLescot4f13ce85325b
diff --git a/crates/compositor/Cargo.toml b/crates/compositor/Cargo.tomlindex 8f84f117b..246f914e2 100644--- a/crates/compositor/Cargo.toml+++ b/crates/compositor/Cargo.toml@@ -53,6 +53,8 @@ naga = { version = "24", features = ["wgsl-in", "hlsl-out"] }[target.'cfg(target_os = "linux")'.dependencies]ash = "0.38"wgpu-hal = { version = "24", features = ["vulkan"] }+# `shader_fx::check_for_agent` traduit l'effet en SPIR-V, comme wgpu le fera pour Vulkan.+naga = { version = "24", features = ["spv-out"] }# Windows : D3D11 + D3D11VA + Direct2D/DirectWrite + HLSL à l'exécution.[target.'cfg(windows)'.dependencies]diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex e3176ad8c..541840ae2 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -47,7 +47,7 @@ use crate::frame_geometry::{plan_frame, tilted_screen_cb, CursorPlacement, CursorPlanInput, FrameGeometryInput,ShadowCaster, SpriteShape,};-use crate::scene::{Scene, SceneBackground, WallpaperMotion};+use crate::scene::{Scene, SceneBackground, SceneShaderEffect, ShaderEffectTarget, WallpaperMotion};const LAYER_WGSL: &str = include_str!("vk_shaders/layer.wgsl");const BLUR_WGSL: &str = include_str!("vk_shaders/blur.wgsl");@@ -116,6 +116,24 @@ struct BgCache {tex: wgpu::Texture,}+/// Un effet shader de la scène (`shader_fx`), par hash de sa source.+enum ShaderFx {+ /// Module et pipeline se construisent sur un thread de fond (`spawn_shader_fx`).+ Pending(std::sync::mpsc::Receiver<Result<wgpu::RenderPipeline, String>>),+ Ready(wgpu::RenderPipeline),+ /// Erreur déjà écrite ; l'effet ne se dessine pas.+ Failed,+}++struct ShaderFxEntry {+ state: ShaderFx,+ /// Dernier usage, pour l'éviction (`SHADER_FX_CACHE`).+ used: u64,+}++/// Combien d'effets compilés le compositeur garde. Un agent qui itère en crée un par version.+const SHADER_FX_CACHE: usize = 64;+/// Une copie RT -> staging DEJA SOUMISE, dont le mapping est arme mais pas/// encore recolte. On garde `idx` (l'index de soumission rendu par/// `Queue::submit`) pour n'attendre QUE cette soumission-la, et les dimensions@@ -435,6 +453,20 @@ pub struct Compositor {seg_scratch: RefCell<Vec<u8>>,/// Le chargement du modele a echoue : ne pas reessayer a chaque frame.seg_failed: RefCell<bool>,++ /// Layout des effets shader : les quatre bindings du prélude (`shader_fx::PRELUDE_V1`).+ shader_fx_bgl: wgpu::BindGroupLayout,+ shader_fx_layout: wgpu::PipelineLayout,+ /// Effets shader de la scène, compilés une fois par source, les moins récents évincés au-delà+ /// de `SHADER_FX_CACHE`.+ shader_fx: RefCell<std::collections::HashMap<u64, ShaderFxEntry>>,+ shader_fx_tick: std::cell::Cell<u64>,+ /// Vrai par défaut : une frame dont l'effet compile encore attend son pipeline, parce qu'un+ /// export ne doit jamais rendre de frame sans l'effet. La preview le passe à faux et saute+ /// l'effet le temps de la compilation, puis recompose (`shader_fx_landed`).+ shader_fx_blocking: std::cell::Cell<bool>,+ /// Le calque transparent des textes, alloué à la première frame qui porte un effet `text`.+ text_layer: RefCell<Option<(wgpu::Texture, wgpu::TextureView)>>,}impl Compositor {@@ -699,6 +731,40 @@ impl Compositor {multiview: None,cache: None,});+ // Effets shader (`shader_fx`) : un layout explicite, celui du prélude. Avec `layout: None`,+ // un effet qui ne lit pas `ctx` perdrait ce binding, et son bind group ne validerait plus.+ let fx_entry = |binding: u32, ty: wgpu::BindingType| wgpu::BindGroupLayoutEntry {+ binding,+ visibility: wgpu::ShaderStages::FRAGMENT,+ ty,+ count: None,+ };+ let fx_uniform = wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Uniform,+ has_dynamic_offset: false,+ min_binding_size: None,+ };+ let shader_fx_bgl = gpu.device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: Some("shader-fx"),+ entries: &[+ fx_entry(+ 0,+ wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Float { filterable: true },+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,+ },+ ),+ fx_entry(1, wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering)),+ fx_entry(2, fx_uniform),+ fx_entry(3, fx_uniform),+ ],+ });+ let shader_fx_layout = gpu.device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {+ label: Some("shader-fx"),+ bind_group_layouts: &[&shader_fx_bgl],+ push_constant_ranges: &[],+ });let (blur_half, blur_qtr, blur_oct, trail_view) = Self::make_blur_targets(&gpu, w, h);let (rt, rt_view, accum, accum_view, readback_bpr) = Self::make_targets(&gpu, w, h);let (ann_copy, ann_copy_view, ann_copy_mips) = Self::make_ann_copy(&gpu, w, h);@@ -772,6 +838,12 @@ impl Compositor {seg_rate: RefCell::new(crate::segmentation::RateLimiter::new(SEGMENTATION_HZ)),seg_scratch: RefCell::new(Vec::new()),seg_failed: RefCell::new(false),+ shader_fx_bgl,+ shader_fx_layout,+ shader_fx: RefCell::new(std::collections::HashMap::new()),+ shader_fx_tick: std::cell::Cell::new(0),+ shader_fx_blocking: std::cell::Cell::new(true),+ text_layer: RefCell::new(None),})}@@ -819,6 +891,7 @@ impl Compositor {ann_copy_view,ann_copy_mips,bg_cache: RefCell::new(None),+ text_layer: RefCell::new(None),..self})}@@ -1165,9 +1238,243 @@ impl Compositor {}pub fn set_scene(&self, s: Option<Scene>) {+ // Les effets nouveaux partent compiler tout de suite, hors du thread de rendu : à la+ // première frame qui les montre, ils sont en général déjà prêts.+ if let Some(scene) = &s {+ for effect in &scene.shader_effects {+ self.shader_fx_entry(effect);+ }+ }*self.scene.borrow_mut() = s;}+ /// Faux pour la preview : voir `shader_fx_blocking`.+ pub fn set_shader_fx_blocking(&self, on: bool) {+ self.shader_fx_blocking.set(on);+ }++ /// Fait aboutir les compilations terminées. Vrai si un effet vient d'être prêt : la preview+ /// en pause doit alors recomposer, sinon elle resterait sur la frame sans l'effet.+ pub fn shader_fx_landed(&self) -> bool {+ let mut landed = false;+ for entry in self.shader_fx.borrow_mut().values_mut() {+ let got = match &entry.state {+ ShaderFx::Pending(rx) => rx.try_recv(),+ _ => continue,+ };+ match got {+ Ok(result) => {+ entry.state = Self::finish_shader_fx(result);+ landed = true;+ }+ Err(std::sync::mpsc::TryRecvError::Empty) => {}+ Err(std::sync::mpsc::TryRecvError::Disconnected) => entry.state = ShaderFx::Failed,+ }+ }+ landed+ }++ /// La clé de cache d'`effect`, sa compilation lancée s'il est neuf, et son dernier usage noté.+ /// `None` pour un contrat que ce compositeur ne connaît pas : la région ne se dessine pas.+ fn shader_fx_entry(&self, effect: &SceneShaderEffect) -> Option<u64> {+ if effect.contract != crate::shader_fx::CONTRACT {+ return None;+ }+ let key = crate::shader_fx::source_hash(effect);+ let tick = self.shader_fx_tick.get() + 1;+ self.shader_fx_tick.set(tick);+ let mut fx = self.shader_fx.borrow_mut();+ fx.entry(key)+ .or_insert_with(|| ShaderFxEntry {+ state: ShaderFx::Pending(self.spawn_shader_fx(effect)),+ used: tick,+ })+ .used = tick;+ // Un agent qui itère crée une entrée par version : on garde les plus récentes.+ if fx.len() > SHADER_FX_CACHE {+ if let Some(oldest) = fx.iter().min_by_key(|(_, e)| e.used).map(|(k, _)| *k) {+ fx.remove(&oldest);+ }+ }+ Some(key)+ }++ /// Construit le pipeline d'`effect` sur un thread de fond : `Device` est `Send + Sync`, et le+ /// pilote compile le SPIR-V dans `create_render_pipeline`. naga valide le code avant wgpu :+ /// aucun `on_uncaptured_error` n'est posé, et une erreur de validation wgpu fait paniquer. Si+ /// wgpu panique malgré tout, seul ce thread meurt, et le canal fermé vaut un échec.+ fn spawn_shader_fx(+ &self,+ effect: &SceneShaderEffect,+ ) -> std::sync::mpsc::Receiver<Result<wgpu::RenderPipeline, String>> {+ let (tx, rx) = std::sync::mpsc::channel();+ let (device, layout) = (self.gpu.device.clone(), self.shader_fx_layout.clone());+ let (code, params) = (effect.code.clone(), effect.params.clone());+ std::thread::Builder::new()+ .name("shader-fx".into())+ .spawn(move || {+ let built = crate::shader_fx::analyze(&code, ¶ms).map(|_| {+ let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some("shader-fx"),+ source: wgpu::ShaderSource::Wgsl(+ crate::shader_fx::module_source(&code, ¶ms).into(),+ ),+ });+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some("shader-fx"),+ layout: Some(&layout),+ vertex: wgpu::VertexState {+ module: &module,+ entry_point: Some("fx_vs"),+ compilation_options: wgpu::PipelineCompilationOptions::default(),+ buffers: &[],+ },+ fragment: Some(wgpu::FragmentState {+ module: &module,+ entry_point: Some("fx_fs"),+ compilation_options: wgpu::PipelineCompilationOptions::default(),+ targets: &[Some(wgpu::ColorTargetState {+ format: wgpu::TextureFormat::Rgba8Unorm,+ blend: None,+ write_mask: wgpu::ColorWrites::ALL,+ })],+ }),+ primitive: wgpu::PrimitiveState::default(),+ depth_stencil: None,+ multisample: wgpu::MultisampleState::default(),+ multiview: None,+ cache: None,+ })+ });+ let _ = tx.send(built);+ })+ .expect("thread shader-fx");+ rx+ }++ fn finish_shader_fx(result: Result<wgpu::RenderPipeline, String>) -> ShaderFx {+ match result {+ Ok(pipeline) => ShaderFx::Ready(pipeline),+ Err(e) => {+ eprintln!("[shader-fx] {e}");+ ShaderFx::Failed+ }+ }+ }++ /// Le pipeline d'`effect`. Le compositeur d'export attend sa compilation ; la preview+ /// (`shader_fx_blocking` faux) rend `None` tant qu'il compile. `None` aussi s'il a échoué.+ fn shader_fx_ready(&self, effect: &SceneShaderEffect) -> Option<wgpu::RenderPipeline> {+ let key = self.shader_fx_entry(effect)?;+ let mut fx = self.shader_fx.borrow_mut();+ let entry = fx.get_mut(&key)?;+ if let ShaderFx::Pending(rx) = &entry.state {+ let got = if self.shader_fx_blocking.get() {+ rx.recv().map_err(|e| e.to_string())+ } else {+ match rx.try_recv() {+ Ok(result) => Ok(result),+ Err(std::sync::mpsc::TryRecvError::Empty) => return None,+ Err(e) => Err(e.to_string()),+ }+ };+ entry.state = Self::finish_shader_fx(got.and_then(|result| result));+ }+ match &entry.state {+ ShaderFx::Ready(pipeline) => Some(pipeline.clone()),+ _ => None,+ }+ }++ /// Une passe d'effet sur `dst` (le RT, ou le calque des textes) : `dst` est copié dans le+ /// niveau 0 d'`ann_copy`, libre à ce stade (les flous et le cristal de Prism Glow l'ont déjà+ /// lu, plus tôt dans l'encodeur), puis l'effet le repeint en entier.+ fn encode_shader_effect(+ &self,+ encoder: &mut wgpu::CommandEncoder,+ effect: &SceneShaderEffect,+ dst: (&wgpu::Texture, &wgpu::TextureView),+ ctx: &crate::shader_fx::FxContext,+ ) {+ let Some(pipeline) = self.shader_fx_ready(effect) else { return };+ let ctx_bytes = unsafe {+ std::slice::from_raw_parts(+ ctx as *const crate::shader_fx::FxContext as *const u8,+ std::mem::size_of::<crate::shader_fx::FxContext>(),+ )+ };+ let params: Vec<u8> =+ crate::shader_fx::pack_params(effect).iter().flat_map(|v| v.to_ne_bytes()).collect();+ let uniform = |label: &str, contents: &[u8]| {+ self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some(label),+ contents,+ usage: wgpu::BufferUsages::UNIFORM,+ })+ };+ let (ctx_buf, params_buf) = (uniform("shader-fx-ctx", ctx_bytes), uniform("shader-fx-params", ¶ms));+ // Les bindings du prélude : la frame (0), le sampler (1), `ctx` (2), `params` (3).+ let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("shader-fx"),+ layout: &self.shader_fx_bgl,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: wgpu::BindingResource::TextureView(&self.ann_copy_view),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: wgpu::BindingResource::Sampler(&self.sampler),+ },+ wgpu::BindGroupEntry { binding: 2, resource: ctx_buf.as_entire_binding() },+ wgpu::BindGroupEntry { binding: 3, resource: params_buf.as_entire_binding() },+ ],+ });+ encoder.copy_texture_to_texture(+ dst.0.as_image_copy(),+ self.ann_copy.as_image_copy(),+ wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },+ );+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("shader-fx-pass"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: dst.1,+ resolve_target: None,+ ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ });+ rpass.set_pipeline(&pipeline);+ rpass.set_bind_group(0, &bind, &[]);+ rpass.draw(0..3, 0..1);+ }++ /// Le calque transparent des textes, à la taille de rendu, alloué à la première frame qui en a+ /// besoin (un effet `ShaderEffectTarget::Text`).+ fn text_layer(&self) -> (wgpu::Texture, wgpu::TextureView) {+ if let Some(layer) = self.text_layer.borrow().as_ref() {+ return layer.clone();+ }+ let tex = self.gpu.device.create_texture(&wgpu::TextureDescriptor {+ label: Some("text-layer"),+ size: wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba8Unorm,+ // COPY_SRC : un effet `text` le copie dans `ann_copy` avant de le repeindre.+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT+ | wgpu::TextureUsages::TEXTURE_BINDING+ | wgpu::TextureUsages::COPY_SRC,+ view_formats: &[],+ });+ let view = tex.create_view(&wgpu::TextureViewDescriptor::default());+ *self.text_layer.borrow_mut() = Some((tex.clone(), view.clone()));+ (tex, view)+ }+pub fn set_cursor(&self, track: crate::cursor::CursorTrack) {*self.cursor.borrow_mut() = Some(track);}@@ -2919,6 +3226,9 @@ impl Compositor {/// Le cristal de Prism Glow : il lit la copie de l'image composee (`CursorPlan::glass`).glass: bool,}+ // La pointe et les clics récents, tels que les effets shader les lisent.+ let mut fx_cursor = None;+ let mut fx_clicks = Vec::new();let cursor_draw: Option<CursorDraw> = (|| {let track = cursor_ref.as_ref()?;let plan = plan_cursor(@@ -2938,6 +3248,8 @@ impl Compositor {},)?.for_backend(self.gpu.backend == crate::d3d::Backend::Cpu);+ fx_cursor = Some(plan.pointer);+ fx_clicks = plan.clicks.clone();// `taps == 1` : un seul placement, celui de l'instant rendu -- le// chemin net d'avant, inchange. Au-dela, on echelonne les copies@@ -3431,21 +3743,48 @@ impl Compositor {self.draw_layer(&mut rpass, layer, false);}}+ // Effets shader de l'agent, autour des textes selon leur cible (`docs/shader-effects.md`,+ // D.1) : `image` avant les annotations, `text` sur un calque des textes a part, `both` sur+ // l'image finale. Meme ordre que `compositor_windows.rs`.+ let fx_inputs = crate::shader_fx::FxFrameInputs {+ cursor: fx_cursor,+ clicks: fx_clicks,+ footage: crate::shader_fx::bounds(&g.footage_quad([rw, rh]).corners),+ camera: lp.has_webcam.then_some(g.w_dst),+ };+ let effects = scene_ref+ .as_ref()+ .map(|s| crate::shader_fx::active_effects(&s.shader_effects, g.source_t))+ .unwrap_or_default();+ let fx_context = |e: &SceneShaderEffect| {+ crate::shader_fx::context(e, g.source_t, g.programme_t, [rw, rh], &fx_inputs)+ };+ let with_target = |target: ShaderEffectTarget| -> Vec<&SceneShaderEffect> {+ effects.iter().copied().filter(|e| e.target == target).collect()+ };+ for e in with_target(ShaderEffectTarget::Image) {+ self.encode_shader_effect(&mut encoder, e, (&self.rt, &self.rt_view), &fx_context(e));+ }+ // Un effet `text` : les textes sur un calque transparent, l'effet sur ce calque seul, puis+ // le calque pose sur l'image (« over » premultiplie). L'image dessous reste intacte.+ let text_effects = with_target(ShaderEffectTarget::Text);+ let text_layer = (!text_effects.is_empty()).then(|| self.text_layer());// Passe 3 : les autres annotations, par-dessus tout le reste (les flous sont passes avant// le curseur). Elle existe meme sans annotation : deux passes consecutives sur la MEME// cible avec `LoadOp::Load` ne coutent rien de plus qu'une seule sur un GPU desktop, et un// seul chemin de code vaut mieux qu'un branchement qui ne serait exerce que dans un projet// sur dix.{+ let (view, load) = match &text_layer {+ Some((_, view)) => (view, wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT)),+ None => (&self.rt_view, wgpu::LoadOp::Load),+ };let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {label: Some("ann-pass"),color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: &self.rt_view,+ view,resolve_target: None,- ops: wgpu::Operations {- load: wgpu::LoadOp::Load,- store: wgpu::StoreOp::Store,- },+ ops: wgpu::Operations { load, store: wgpu::StoreOp::Store },})],depth_stencil_attachment: None,timestamp_writes: None,@@ -3456,6 +3795,47 @@ impl Compositor {self.draw_layer(&mut rpass, &a.layer, false);}}+ if let Some((tex, view)) = &text_layer {+ for e in text_effects {+ self.encode_shader_effect(&mut encoder, e, (tex, view), &fx_context(e));+ }+ // Le calque pose sur le RT par la passe qui recopie `accum` : layout du blur, et un+ // uniforme que `fs_copy` ne lit pas.+ let uniform = self.gpu.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {+ label: Some("text-layer-uniform"),+ contents: layer_bytes(&LayerCB::default()),+ usage: wgpu::BufferUsages::UNIFORM,+ });+ let bind = self.gpu.device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("text-layer"),+ layout: &self.blur_bgl,+ entries: &[+ wgpu::BindGroupEntry { binding: 0, resource: uniform.as_entire_binding() },+ wgpu::BindGroupEntry { binding: 1, resource: wgpu::BindingResource::TextureView(view) },+ wgpu::BindGroupEntry {+ binding: 2,+ resource: wgpu::BindingResource::Sampler(&self.sampler),+ },+ ],+ });+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("text-layer-composite"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: &self.rt_view,+ resolve_target: None,+ ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store },+ })],+ depth_stencil_attachment: None,+ timestamp_writes: None,+ occlusion_query_set: None,+ });+ rpass.set_pipeline(&self.pipeline_copy);+ rpass.set_bind_group(0, &bind, &[]);+ rpass.draw(0..3, 0..1);+ }+ for e in with_target(ShaderEffectTarget::Both) {+ self.encode_shader_effect(&mut encoder, e, (&self.rt, &self.rt_view), &fx_context(e));+ }self.gpu.context.submit(std::iter::once(encoder.finish()));Ok(())}@@ -6543,6 +6923,215 @@ mod tests {assert!(n > 50, "trop peu de points visibles : {n}");assert!(worst <= 0.25, "le rendu s'ecarte de la projection de {worst:.2} px");}++ // -----------------------------------------------------------------------+ // Effets shader (`shader_fx`) : les tests de `compositor_windows.rs`, sur lavapipe.+ // -----------------------------------------------------------------------++ /// Une scène à fond rouge plein, l'écran rétréci par le padding : les coins sont du fond.+ fn shader_fx_scene(effects: serde_json::Value) -> Scene {+ let json = serde_json::json!({+ "clips": [],+ "layout": {"preset":"no-webcam","webcamSize":1,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,"webcamReactiveZoom":false},+ "effects": {"padding":0.5,"blur":false,"shadow":0,"roundnessFrac":0,"motionBlur":0},+ "background": {"kind":"color","color":"#ff0000"},+ "zoomRegions": [],+ "cursor": {"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"},+ "cropByClip": [],+ "output": {"width":320,"height":180,"fps":null},+ "shaderEffects": effects,+ });+ Scene::from_json(&json.to_string()).expect("scène")+ }++ /// Un fragment d'effet de 1 s à 3 s, tel que l'app l'envoie.+ fn fx(code: &str, target: &str, lane: u32) -> serde_json::Value {+ serde_json::json!({+ "clipIndex": 0, "startSec": 1.0, "endSec": 3.0, "target": target, "lane": lane,+ "contract": 1, "code": code,+ "params": [{"name": "level", "type": "number"}, {"name": "tint", "type": "color"}],+ "values": {"level": 1.0, "tint": [0.0, 1.0, 0.0, 1.0]},+ })+ }++ const INVERT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> {\n let c = frame(uv);\n return vec4<f32>(vec3<f32>(params.level) - c.rgb, 1.0);\n}\n";+ const BLUE: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return vec4<f32>(0.0, 0.0, 1.0, 1.0); }";+ const TINT: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return params.tint; }";+ const SAME: &str = "fn effect(uv: vec2<f32>) -> vec4<f32> { return frame(uv); }";++ fn fx_cfg() -> Cfg {+ let mut cfg = Cfg::c8();+ cfg.bg_blur = 0.0;+ cfg.mblur_n = 1;+ cfg+ }++ fn fx_compositor(gpu: &Gpu, w: u32, h: u32, effects: serde_json::Value) -> Compositor {+ let comp = Compositor::new_sized(gpu, w, h).expect("compositeur");+ let scene = shader_fx_scene(effects);+ comp.set_live_params(live_params_from_scene(&scene));+ comp.set_scene(Some(scene));+ comp+ }++ /// Le pixel du coin haut-gauche (du fond) après une frame composée au temps source `t`.+ fn corner_at(comp: &Compositor, gpu: &Gpu, t: f32) -> [u8; 3] {+ let screen = FakeFrame::new(gpu, 64, 64, |_, _| 126);+ comp.set_timeline_time(Some(t));+ comp.set_programme_time(Some(t));+ unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), 0.0, &fx_cfg()) }.expect("compose");+ let (_, _, rgba) = unsafe { comp.readback_direct() }.expect("readback");+ [rgba[0], rgba[1], rgba[2]]+ }++ /// Le coin à 2 s, dans la région, sous les effets donnés.+ fn corner_under(effects: serde_json::Value) -> Option<[u8; 3]> {+ let gpu = gpu()?;+ Some(corner_at(&fx_compositor(&gpu, 320, 180, effects), &gpu, 2.0))+ }++ /// La passe de l'agent repeint l'image composée, dans sa région et nulle part ailleurs. Le+ /// compositeur par défaut est celui de l'export : il attend le pipeline, jamais de frame sans.+ #[test]+ fn a_shader_effect_repaints_the_composed_frame_inside_its_region() {+ let Some(gpu) = gpu() else { return };+ let comp = fx_compositor(&gpu, 320, 180, serde_json::json!([fx(INVERT, "image", 0)]));+ assert_eq!(corner_at(&comp, &gpu, 0.5), [255, 0, 0], "avant la région : le fond rouge");+ assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255], "dans la région : rouge inversé");+ assert_eq!(corner_at(&comp, &gpu, 3.5), [255, 0, 0], "après la région : le fond rouge");+ }++ /// La preview ne bloque pas : elle saute l'effet tant qu'il compile, et `shader_fx_landed`+ /// lui dit quand recomposer. Ensuite la frame est celle de l'export, au pixel.+ #[test]+ fn the_preview_shows_the_effect_once_it_landed() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, 320, 180).expect("compositeur");+ comp.set_shader_fx_blocking(false);+ let scene = shader_fx_scene(serde_json::json!([fx(INVERT, "image", 0)]));+ comp.set_live_params(live_params_from_scene(&scene));+ let start = std::time::Instant::now();+ comp.set_scene(Some(scene));+ while !comp.shader_fx_landed() {+ assert!(start.elapsed().as_secs() < 30, "la compilation n'a jamais abouti");+ std::thread::sleep(std::time::Duration::from_millis(1));+ }+ eprintln!("effet prêt en {:.1} ms", start.elapsed().as_secs_f64() * 1000.0);+ assert_eq!(corner_at(&comp, &gpu, 2.0), [0, 255, 255]);+ }++ /// Un WGSL invalide, une binding de plus ou un contrat inconnu ne cassent pas le rendu :+ /// l'effet ne se dessine pas, la frame reste celle de la composition. Aucun n'atteint wgpu,+ /// qui paniquerait sur une erreur de validation.+ #[test]+ fn a_broken_or_unknown_effect_leaves_the_frame_untouched() {+ let broken = fx("fn effect(uv: vec2<f32>) -> vec4<f32> { nope }", "image", 0);+ let extra = fx(+ "@group(0) @binding(4) var<uniform> extra: vec4<f32>;\nfn effect(uv: vec2<f32>) -> vec4<f32> { return extra; }",+ "image",+ 0,+ );+ let mut future = fx(BLUE, "image", 0);+ future["contract"] = serde_json::json!(2);+ for effect in [broken, extra, future] {+ let Some(corner) = corner_under(serde_json::json!([effect])) else { return };+ assert_eq!(corner, [255, 0, 0]);+ }+ }++ /// Les paramètres arrivent dans `params` au layout de la struct générée : la couleur `tint`+ /// suit le nombre `level` dans le buffer, et se lit telle que l'app l'a écrite.+ #[test]+ fn a_color_parameter_reaches_the_shader() {+ let Some(corner) = corner_under(serde_json::json!([fx(TINT, "image", 0)])) else { return };+ assert_eq!(corner, [0, 255, 0]);+ }++ /// Les lanes s'appliquent dans l'ordre : bleu puis inversion donne jaune, l'inverse donne bleu.+ #[test]+ fn lanes_apply_in_order() {+ let Some(blue_then_invert) =+ corner_under(serde_json::json!([fx(INVERT, "image", 1), fx(BLUE, "image", 0)]))+ else {+ return;+ };+ assert_eq!(blue_then_invert, [255, 255, 0]);+ let invert_then_blue =+ corner_under(serde_json::json!([fx(INVERT, "image", 0), fx(BLUE, "image", 1)])).unwrap();+ assert_eq!(invert_then_blue, [0, 0, 255]);+ }++ /// `text` ne touche que le calque des textes, posé ensuite sur l'image ; `both` voit tout.+ /// Sans annotation, le calque est transparent : un effet `text` qui le rend tel quel laisse+ /// l'image intacte, un effet `text` opaque la recouvre.+ #[test]+ fn the_three_targets_keep_to_their_layer() {+ let Some(image_only) = corner_under(serde_json::json!([fx(BLUE, "image", 0)])) else { return };+ assert_eq!(image_only, [0, 0, 255]);+ let text_untouched =+ corner_under(serde_json::json!([fx(BLUE, "image", 0), fx(SAME, "text", 0)])).unwrap();+ assert_eq!(text_untouched, [0, 0, 255], "un calque transparent ne change pas l'image");+ let text_opaque =+ corner_under(serde_json::json!([fx(BLUE, "image", 0), fx(TINT, "text", 0)])).unwrap();+ assert_eq!(text_opaque, [0, 255, 0], "le calque des textes, opaque, posé sur l'image");+ let both = corner_under(serde_json::json!([fx(BLUE, "image", 0), fx(INVERT, "both", 0)])).unwrap();+ assert_eq!(both, [255, 255, 0], "`both` voit l'image finale");+ }++ /// Calibre les paliers de coût : le surcoût par frame d'un effet qui lit `frame()` N fois,+ /// à 1080p et en 4K, sur le GPU de la machine. Opt-in, comme les autres mesures :+ ///+ /// OPENSCREEN_FX_BENCH=1 cargo test -p openscreen-compositor --release --lib+ /// shader_fx_tier_calibration -- --nocapture+ ///+ /// 200 frames par mesure ; `OPENSCREEN_FX_BENCH_FRAMES=5` sur lavapipe, où 512 lectures en 4K+ /// prennent 5 s par frame.+ #[test]+ fn shader_fx_tier_calibration() {+ if std::env::var_os("OPENSCREEN_FX_BENCH").is_none() {+ eprintln!("OPENSCREEN_FX_BENCH absent — saute");+ return;+ }+ let gpu = Gpu::create_auto(false).expect("device Vulkan");+ eprintln!("backend : {:?}", gpu.backend);+ let screen = FakeFrame::new(&gpu, 1920, 1080, |x, y| ((x ^ y) & 0xff) as u8);+ let cfg = fx_cfg();+ let reads_effect = |n: u32| {+ format!(+ "fn effect(uv: vec2<f32>) -> vec4<f32> {{\n var acc = vec4<f32>(0.0);\n for (var i = 0; i < {n}; i++) {{\n let a = f32(i) * 2.399;\n acc += frame(uv + vec2<f32>(cos(a), sin(a)) * fx_px(f32(i)));\n }}\n return acc / {n}.0;\n}}\n"+ )+ };+ let frames: u32 = std::env::var("OPENSCREEN_FX_BENCH_FRAMES").ok().and_then(|v| v.parse().ok()).unwrap_or(200);+ let per_frame = |w: u32, h: u32, effects: serde_json::Value| -> f64 {+ let comp = fx_compositor(&gpu, w, h, effects);+ comp.set_timeline_time(Some(2.0));+ comp.set_programme_time(Some(2.0));+ unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), 0.0, &cfg) }.unwrap();+ unsafe { comp.readback_direct() }.unwrap();+ let t0 = std::time::Instant::now();+ for f in 0..frames {+ unsafe { comp.compose_frame(screen.as_ptr(), std::ptr::null(), f as f32, &cfg) }.unwrap();+ }+ unsafe { comp.readback_direct() }.unwrap();+ t0.elapsed().as_secs_f64() * 1000.0 / frames as f64+ };+ for (w, h) in [(1920u32, 1080u32), (3840, 2160)] {+ let base = (0..3).map(|_| per_frame(w, h, serde_json::json!([]))).fold(f64::MAX, f64::min);+ eprintln!("{w}x{h} : sans effet {base:.3} ms/frame");+ for reads in [1u32, 8, 32, 128, 512] {+ let code = reads_effect(reads);+ let report = crate::shader_fx::analyze(&code, &[]).expect("analyse").report;+ let with = (0..3)+ .map(|_| per_frame(w, h, serde_json::json!([fx(&code, "image", 0)])))+ .fold(f64::MAX, f64::min);+ eprintln!(+ "{w}x{h} : {reads:>3} lectures ({:>10}) : +{:.3} ms/frame",+ report.tier.name(),+ with - base+ );+ }+ }+ }}// ---------------------------------------------------------------------------diff --git a/crates/compositor/src/live.rs b/crates/compositor/src/live.rsindex 2af211e20..74cb71959 100644--- a/crates/compositor/src/live.rs+++ b/crates/compositor/src/live.rs@@ -1493,7 +1493,7 @@ unsafe fn render_thread(let mut comp = Compositor::new(&gpu)?;// La preview ne bloque jamais sur la compilation d'un effet shader : elle le saute le temps// qu'il compile (voir `shader_fx_landed` plus bas). L'export, lui, attend.- #[cfg(windows)]+ #[cfg(any(windows, target_os = "linux"))]comp.set_shader_fx_blocking(false);// Vue live = le VRAI enregistrement, pas la fenêtre fixture (100s@6s, taillée pour l'ancien// fixture POC). On charge toute la piste depuis t=0 ; 24h couvre large toute recording réelle.@@ -1786,9 +1786,9 @@ unsafe fn render_thread(}// Un effet shader vient de finir de compiler : la frame en pause doit le montrer.- #[cfg(windows)]+ #[cfg(any(windows, target_os = "linux"))]let fx_landed = comp.shader_fx_landed();- #[cfg(not(windows))]+ #[cfg(not(any(windows, target_os = "linux")))]let fx_landed = false;// avance : seek app-piloté (presentTime) prioritaire, sinon lecture libre (60 fps)diff --git a/crates/compositor/src/shader_fx.rs b/crates/compositor/src/shader_fx.rsindex 50da290a7..87e4ad54e 100644--- a/crates/compositor/src/shader_fx.rs+++ b/crates/compositor/src/shader_fx.rs@@ -226,6 +226,17 @@ pub fn analyze(user: &str, params: &[ShaderParamDecl]) -> Result<Parsed, String>).validate(&module).map_err(|e| e.emit_to_string(&src))?;+ // Les bindings sont ceux du prélude, et eux seuls : chaque backend lie ces quatre-là. Linux+ // valide le pipeline contre ce layout, et une erreur de validation wgpu y fait paniquer.+ for (handle, var) in module.global_variables.iter() {+ let name = var.name.as_deref().unwrap_or("?");+ if var.binding.is_some() && !["fx_frame", "fx_sampler", "ctx", "params"].contains(&name) {+ let line = module.global_variables.get_span(handle).location(&src).line_number;+ return Err(format!(+ "`{name}` at line {line}: an effect declares no binding of its own, it reads frame(), ctx and params"+ ));+ }+ }let entry = module.entry_points.iter()@@ -657,13 +668,23 @@ pub fn spawn_compile(effect: &SceneShaderEffect) -> std::sync::mpsc::Receiver<Rerx}+/// Le SPIR-V que wgpu tirera du même module pour Vulkan. Le compositeur Linux passe le WGSL à+/// wgpu, qui refait cette traduction lui-même : celle-ci ne sert qu'à la vérifier d'avance.+#[cfg(target_os = "linux")]+fn to_spirv(parsed: &Parsed) -> Result<Vec<u32>, String> {+ naga::back::spv::write_vec(&parsed.module, &parsed.info, &naga::back::spv::Options::default(), None)+ .map_err(|e| e.to_string())+}+/// Ce que l'outil de l'agent demande avant d'accepter un code : la validation, la compilation/// réelle pour le backend de la machine quand elle existe, et le palier.pub fn check_for_agent(code: &str, params: &[ShaderParamDecl]) -> Result<EffectReport, String> {- let report = analyze(code, params)?.report;+ let parsed = analyze(code, params)?;#[cfg(windows)]compile_dxbc(code, params)?;- Ok(report)+ #[cfg(target_os = "linux")]+ to_spirv(&parsed)?;+ Ok(parsed.report)}/// `check_for_agent`, les paramètres reçus en JSON (`[{ "name", "type" }, …]`) depuis l'addon.@@ -725,6 +746,21 @@ mod tests {assert!(analyze("fn other() {}", &[]).is_err());}+ #[test]+ fn an_effect_declares_no_binding_of_its_own() {+ let code = "@group(0) @binding(4) var extra: texture_2d<f32>;\n\+ fn effect(uv: vec2<f32>) -> vec4<f32> { return textureLoad(extra, vec2<i32>(0), 0); }\n";+ let err = analyze(code, &[]).err().expect("refusé");+ assert!(err.contains("`extra` at line 1"), "{err}");+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn a_valid_effect_becomes_spirv() {+ let parsed = analyze(VIGNETTE, &[decl("strength", ShaderParamType::Number)]).expect("analyze");+ assert!(!to_spirv(&parsed).expect("spirv").is_empty());+ }+#[test]fn parameter_names_are_checked() {for bad in ["Strength", "2x", "unused", "a-b"] {diff --git a/docs/shader-effects.md b/docs/shader-effects.mdindex a26594596..b4d1a6ed2 100644--- a/docs/shader-effects.md+++ b/docs/shader-effects.md@@ -230,6 +230,8 @@ libre, et les erreurs pointent ainsi les lignes que l'agent a écrites.la souris arrive pile au moment du clic. Ce cas est rare sur une vraie prise.- **Le spike exposait un seul clic** (`ctx.click`). Avec quatre, deux clics rapprochés gardentchacun leur onde.+- **Rien d'autre n'est lié.** Une variable `@group`/`@binding` dans le code de l'agent est+ refusée, avec sa ligne : aucun backend ne la lierait.### C.3 Les paramètres sont nommés et typés@@ -338,6 +340,10 @@ refusé parce que la machine qui l'écrit est modeste.1080p et 17 µs en 4K, au-dessus d'un fixe de 0,03 ms. Un effet léger coûte au plus 0,06 ms parframe en 1080p, un moyen 0,14 ms, un lourd 0,54 ms, 512 lectures 2,1 ms. Le détail est dans[rendering-performance.md](../technical-documentation/engineering/rendering-performance.md).+- **Mesuré sur lavapipe** (le repli CPU de Linux, 16 threads) : environ 1,4 ms par lecture en+ 1080p, 350 fois la RTX. Un effet léger y ajoute jusqu'à 11 ms à une frame qui en coûte 7,5 ;+ un lourd, 234 ms. L'ordre des paliers tient, mais sans GPU même un effet léger double le+ temps d'export.- **Le GPU intégré de référence** (le Radeon 610M des mesures Linux) reste à mesurer : on y attendplusieurs fois ces coûts. La description de l'outil donnera les paliers en ms sur les deuxmachines, pour que l'agent raisonne en temps et non en lectures.@@ -424,10 +430,10 @@ Une seule source WGSL, traduite par naga au moment de compiler.|---|---|---|---|| Traduction | naga vers HLSL SM 5.0 | naga vers MSL | aucune : WGSL tel quel || Compilation | `D3DCompile` (FXC) vers DXBC, puis `CreateVertexShader`/`CreatePixelShader` | `new_library_with_source`, puis `make_pipeline(…, Blend::Replace)` | `create_shader_module`, puis `create_render_pipeline` |-| Thread de fond | naga et FXC (fait) | bibliothèque et pipeline, sous `autoreleasepool` | module et pipeline |-| Copie du RT | `CopySubresourceRegion` vers `ann_copy` (fait) | `snapshot_rt(cmd_buf, false)` | `copy_texture_to_texture` vers `ann_copy` (comme le verre) |-| Insertion | fin de `compose_frame` (fait) | entre `draw_annotations(…, false)` et `submit` | entre l'ann-pass et `submit` |-| Uniforms | `Map(WRITE_DISCARD)` (fait) | `set_fragment_bytes` | `create_buffer_init(UNIFORM)` par draw |+| Thread de fond | naga et FXC (fait) | bibliothèque et pipeline, sous `autoreleasepool` | module et pipeline (fait) |+| Copie du RT | `CopySubresourceRegion` vers `ann_copy` (fait) | `snapshot_rt(cmd_buf, false)` | `copy_texture_to_texture` vers le niveau 0 d'`ann_copy` (fait) |+| Insertion | fin de `compose_frame` (fait) | entre `draw_annotations(…, false)` et `submit` | `image` entre la passe caméra et l'ann-pass, `text` et `both` après (fait) |+| Uniforms | `Map(WRITE_DISCARD)` (fait) | `set_fragment_bytes` | `create_buffer_init(UNIFORM)` par passe (fait) |**macOS en détail**- **Activer `msl-out`.** Le dépôt l'obtient aujourd'hui par unification des features de wgpu ; le@@ -447,7 +453,14 @@ Une seule source WGSL, traduite par naga au moment de compiler.- **Le thread de fond.** `wgpu::Device` est `Send`, `Sync` et `Clone` : le pipeline peut seconstruire hors du thread de rendu.- **Valider avant wgpu.** Aucun `on_uncaptured_error` n'est posé, donc une erreur de validation- wgpu fait paniquer. La pré-validation par naga (`shader_fx::validate`) en protège.+ wgpu fait paniquer. La pré-validation (`shader_fx::analyze`) en protège : naga 24, celui de+ wgpu 24, et le refus de tout binding que le prélude ne déclare pas. Si wgpu panique malgré tout,+ seul le thread de compilation meurt, et l'effet ne se dessine pas (D.6).+- **« Accepté » sous Linux.** `check_for_agent` traduit l'effet en SPIR-V par naga, comme wgpu le+ fera. La compilation par le pilote Vulkan n'a lieu qu'à `set_scene`, faute de device dans+ l'outil.+- **Le calque des textes** est une texture RGBA8 transparente, posée sur le RT par la passe qui+ recopie déjà `accum` (`pipeline_copy`, « over » prémultiplié).**naga reste en 24.** À partir de la 25, sa sortie HLSL déclare les samplers dans un tas D3D12(`register(s0, space0)`), que FXC refuse en `ps_5_0` (erreur X3721). Le test@@ -692,10 +705,12 @@ qu'on n'a pas écrit.| Export de 180 frames en 1752×1080 : sans effet, avec effet, avec effet lourd | 520, 523 et 521 ms || Preview en lecture, source à 30 i/s | 30 i/s avec et sans effet |+Mesuré à la passe Linux (lavapipe sous WSL, 16 threads) : effet prêt en 18 ms après `set_scene`,+module et pipeline compris ; les paliers en C.7.+À mesurer à l'implémentation :- un GPU intégré (le Radeon 610M des mesures Linux) ;-- le compilateur Metal ;-- lavapipe en CI.+- le compilateur Metal.Les résultats iront dans[rendering-performance.md](../technical-documentation/engineering/rendering-performance.md).diff --git a/technical-documentation/architecture/native-compositor.md b/technical-documentation/architecture/native-compositor.mdindex 1b8a7e6c2..c80cd8e83 100644--- a/technical-documentation/architecture/native-compositor.md+++ b/technical-documentation/architecture/native-compositor.md@@ -29,7 +29,7 @@ and without that flag the runtime corruption is silent.| [`crates/compositor/src/ffi.rs`](../../crates/compositor/src/ffi.rs) | bindgen-generated `libav*` bindings (ffmpeg 8.x headers) || [`crates/compositor/src/compositor.rs`](../../crates/compositor/src/compositor_windows.rs) | HLSL compositor — every per-frame pass (`compose_frame`, background, screen, webcam, cursor, annotations, shadows, blur) || [`crates/compositor/src/scene.rs`](../../crates/compositor/src/scene.rs) | the `Scene` struct parsed from the app's `SceneDescription` JSON |-| [`crates/compositor/src/shader_fx.rs`](../../crates/compositor/src/shader_fx.rs) | agent-written shader effects: the WGSL contract, validation and loop rule, cost tiers, parameter packing, background compilation (FXC on Windows) |+| [`crates/compositor/src/shader_fx.rs`](../../crates/compositor/src/shader_fx.rs) | agent-written shader effects: the WGSL contract, validation and loop rule, cost tiers, parameter packing, background compilation (FXC on Windows; on Linux, `compositor_linux.rs` builds wgpu pipelines) || [`crates/compositor/src/regions.rs`](../../crates/compositor/src/regions.rs) | zoom / speed / Full Camera regions — envelope shapes and per-frame state sampling || [`crates/compositor/src/pipeline.rs`](../../crates/compositor/src/pipeline_windows.rs) | demux + `D3D11VA` decode + composite + AMF encode + mux (`run_c0` for decode/encode only, `run_composited` for the full path) || [`crates/compositor/src/audio.rs`](../../crates/compositor/src/audio.rs) | per-clip audio decode, swresample → f32 planar 48 kHz stereo, libavfilter `atempo` speed stretch (WSOLA fallback), multi-track mix, AAC encoder |@@ -186,11 +186,17 @@ backend-specific.parameters, bound at `b3`), then the contract-v1 prelude: `frame()`, `ctx` (`b2`), `fx_px`,`fx_hash` and the `fx_vs`/`fx_fs` entry points. Errors therefore point at the agent's lines.- **Validation** (`analyze`) is naga's, plus the loop rule: every loop is a `for` with literal- bounds, at most 4 096 iterations per pixel. It also estimates the cost, in `frame()` reads per- pixel, as an indicative tier (light, medium, heavy, very heavy). Nothing is refused on cost.+ bounds, at most 4 096 iterations per pixel. An effect declares no binding beyond the prelude's+ four. It also estimates the cost, in `frame()` reads per pixel, as an indicative tier (light,+ medium, heavy, very heavy). Nothing is refused on cost.- **Compilation never happens on the render thread.** `set_scene` starts one background compile per- new source (naga to HLSL SM 5.0, then FXC). The cache is keyed by contract, code and parameter- layout, and keeps the 64 most recently used.+ new source. The cache is keyed by contract, code and parameter layout, and keeps the 64 most+ recently used.+ - **Windows:** naga to HLSL SM 5.0, then FXC.+ - **Linux:** the WGSL goes to wgpu as it is. The thread builds the shader module and the+ pipeline, against an explicit layout of the prelude's four bindings. wgpu panics on a+ validation error, since no `on_uncaptured_error` is set: `analyze` runs first so that none+ can happen, and a panic would only kill that thread, leaving the effect undrawn.- **Blocking.** The export compositor waits for a pending compile and never draws a frame withoutits effect. The live view (`set_shader_fx_blocking(false)`) skips the effect until it lands, thenrecomposes the paused frame (`shader_fx_landed`).@@ -436,10 +442,11 @@ licence. D3D11VA + AMF survive the LGPL-shared build (verified:rasteriser: one that needs no D3D device at all. Giving the helper a WARPdevice would add a slow path nobody needs alongside a working one.-### Known gap: shader effects draw on Windows only+### Known gap: shader effects do not draw on macOS-The Metal and wgpu compositors parse `shader_effects` but do not draw them: an effect is visible on-Windows only. [docs/shader-effects.md](../../docs/shader-effects.md) (D.5) specifies both passes.+The Metal compositor parses `shader_effects` but does not draw them: an effect is visible on+Windows and Linux only. [docs/shader-effects.md](../../docs/shader-effects.md) (D.5) specifies the+Metal pass.### Known gap: the capture fallback is unreachable on a host that fails D3Ddiff --git a/technical-documentation/engineering/rendering-performance.md b/technical-documentation/engineering/rendering-performance.mdindex 20702e5c4..f8bb47187 100644--- a/technical-documentation/engineering/rendering-performance.md+++ b/technical-documentation/engineering/rendering-performance.md@@ -448,7 +448,19 @@ An agent-written effect (`crates/compositor/src/shader_fx.rs`, [docs/shader-effe- **The cost is linear in the reads,** about 4 µs per read at 1080p and 17 µs at 4K, over a fixed 0.03 ms (1080p) for the copy and the pass. It is the texture bandwidth that pays, which is why the tiers count reads.- **The export does not notice a light effect:** 180 frames at 1752×1080 took 520 ms without, 523 ms with the spike's effect, and 521 ms with a heavier one. The preview held the source's 30 fps either way.-- **Not measured yet:** an integrated GPU, where the same reads cost several times more, and the Metal and wgpu passes.+- **On lavapipe, the Linux CPU fallback,** the same bench (`compositor_linux::tests::shader_fx_tier_calibration`, release, best of three runs of 5 frames, WSL on 16 threads) gives about 1.4 ms per read at 1080p, 350 times the RTX:++| `frame()` reads | Tier | 1080p | 4K |+|---:|---|---:|---:|+| none (the frame alone) | | 7.5 ms | 29.5 ms |+| 1 | light | +3.2 ms | +13.4 ms |+| 8 | light | +11.2 ms | +44.4 ms |+| 32 | medium | +42.1 ms | +159 ms |+| 128 | heavy | +234 ms | +958 ms |+| 512 | very heavy | +1 035 ms | +5 068 ms |++- **The tiers keep their order on lavapipe,** but without a GPU a light effect already doubles the frame. The pipeline is ready 18 ms after `set_scene` there, module and driver compile included.+- **Not measured yet:** an integrated GPU, where the same reads cost several times more, and the Metal pass.## How we got here — the WebCodecs trail