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
fix(compositor): keep the 3D models out of the Linux layer pipeline
Etienne Lescotacfc10fb5616
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex f49974d47..4874e26b0 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -52,6 +52,12 @@ use crate::scene::{Scene, SceneBackground, WallpaperMotion};const LAYER_WGSL: &str = include_str!("vk_shaders/layer.wgsl");const BLUR_WGSL: &str = include_str!("vk_shaders/blur.wgsl");+/// `layer.wgsl` avec ou sans ses modeles 3D (modes 15 a 17) : la constante que le shader teste+/// pour les compiler, prefixee au source (pourquoi deux pipelines : le haut de `layer.wgsl`).+fn layer_source(models: bool) -> String {+ format!("const LAYER_MODELS: bool = {models};\n{LAYER_WGSL}")+}+/// Budget du cache de textures image (`img_cache`), en octets.////// Doit tenir le JEU ACTIF d'une frame -- au pire un wallpaper d'ecran ET un@@ -270,11 +276,16 @@ pub struct Compositor {// Pipeline de calque (VS + FS `layer.wgsl`), sampler lineaire, bind group// layout (uniform + 2 textures + sampler). Immuables apres `new_sized`.+ // `pipeline` n'a pas les modeles 3D (modes 15 a 17) : ils passent par `pipeline_models`.pipeline: wgpu::RenderPipeline,/// Meme shader et meme layout que `pipeline`, blend ADDITIF pondere par la/// constante de blend. Sert a sommer les copies de la trainee du curseur/// dans `accum` ; cf. `blend_add` cote Windows.pipeline_add: wgpu::RenderPipeline,+ /// `pipeline` et `pipeline_add` avec les modeles 3D : le curseur modelise, l'impact de son+ /// clic et le cadre d'appareil, et rien d'autre (cf. `layer_source`).+ pipeline_models: wgpu::RenderPipeline,+ pipeline_add_models: wgpu::RenderPipeline,/// Copie plein ecran d'`accum` vers le RT en « over » premultiplie/// (`blur.wgsl` : `vs_fullscreen` + `fs_copy`). Utilise le layout du blur.pipeline_copy: wgpu::RenderPipeline,@@ -422,10 +433,14 @@ impl Compositor {feature_level: gpu.feature_level,};- let module = gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {- label: Some("layer.wgsl"),- source: wgpu::ShaderSource::Wgsl(LAYER_WGSL.into()),- });+ let mk_module = |label: &str, models: bool| {+ gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {+ label: Some(label),+ source: wgpu::ShaderSource::Wgsl(layer_source(models).into()),+ })+ };+ let module = mk_module("layer.wgsl", false);+ let module_models = mk_module("layer.wgsl (modeles)", true);let sampler = gpu.device.create_sampler(&wgpu::SamplerDescriptor {label: Some("layer"),address_mode_u: wgpu::AddressMode::ClampToEdge,@@ -511,19 +526,19 @@ impl Compositor {bind_group_layouts: &[&bind_group_layout],push_constant_ranges: &[],});- // Deux pipelines pour le MEME shader de calque : seul le blend change.- let mk_layer = |label: &str, blend: wgpu::BlendState| {+ // Deux pipelines par source de calque : seul le blend change.+ let mk_layer = |label: &str, module: &wgpu::ShaderModule, blend: wgpu::BlendState| {gpu.device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {label: Some(label),layout: Some(&pipeline_layout),vertex: wgpu::VertexState {- module: &module,+ module,entry_point: Some("vs_main"),compilation_options: wgpu::PipelineCompilationOptions::default(),buffers: &[],},fragment: Some(wgpu::FragmentState {- module: &module,+ module,entry_point: Some("fs_main"),compilation_options: wgpu::PipelineCompilationOptions::default(),targets: &[Some(wgpu::ColorTargetState {@@ -542,22 +557,23 @@ impl Compositor {cache: None,})};- let pipeline = mk_layer("layer", wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING);+ let over = wgpu::BlendState::PREMULTIPLIED_ALPHA_BLENDING;+ let pipeline = mk_layer("layer", &module, over);+ let pipeline_models = mk_layer("layer-models", &module_models, over);// SOMME pondere : `src * constante + dst`. La constante (posee par pass// via `set_blend_constant`) vaut 1/taps, donc N copies d'un curseur// parfaitement immobile redonnent exactement ce curseur. Transcription// du `blend_add` D3D11 (BLEND_FACTOR / ONE / OP_ADD sur couleur ET// alpha) ; l'alpha doit suivre la couleur, sinon la somme n'est plus// premultipliee et la composition finale delave la trainee.- let add = wgpu::BlendComponent {+ let sum = wgpu::BlendComponent {src_factor: wgpu::BlendFactor::Constant,dst_factor: wgpu::BlendFactor::One,operation: wgpu::BlendOperation::Add,};- let pipeline_add = mk_layer(- "layer-add",- wgpu::BlendState { color: add, alpha: add },- );+ let add = wgpu::BlendState { color: sum, alpha: sum };+ let pipeline_add = mk_layer("layer-add", &module, add);+ let pipeline_add_models = mk_layer("layer-add-models", &module_models, add);// --- Chaine de blur Kawase du fond (`blur.wgsl`) ---let blur_module = gpu.device.create_shader_module(wgpu::ShaderModuleDescriptor {@@ -690,6 +706,8 @@ impl Compositor {render_h: h,pipeline,pipeline_add,+ pipeline_models,+ pipeline_add_models,pipeline_copy,bind_group_layout,sampler,@@ -1299,8 +1317,12 @@ impl Compositor {rpass.set_bind_group(0, screen, &[]);rpass.draw(0..4, 0..1);if let Some((_buf, bind)) = device_frame {+ // Mode 17, que `pipeline` ne compile pas ; on lui rend la main ensuite, comme l'a+ // laisse l'appelant.+ rpass.set_pipeline(&self.pipeline_models);rpass.set_bind_group(0, bind, &[]);rpass.draw(0..4, 0..1);+ rpass.set_pipeline(&self.pipeline);}}@@ -2868,7 +2890,11 @@ impl Compositor {/// Le sprite, et pour le curseur modelise son champ de distance._tex: Vec<(wgpu::Texture, wgpu::TextureView)>,binds: Vec<wgpu::BindGroup>,- /// L'impact des clics (mode 16), dessine SOUS le curseur, sur le RT.+ /// `binds` est le curseur modelise (mode 15), a dessiner par `pipeline_models` ;+ /// sinon le sprite (modes 7 et 13).+ modelled: bool,+ /// L'impact des clics (mode 16, donc `pipeline_models` lui aussi), dessine SOUS le+ /// curseur, sur le RT.impacts: Vec<wgpu::BindGroup>,/// Le cristal de Prism Glow : il lit la copie de l'image composee (`CursorPlan::glass`).glass: bool,@@ -2983,6 +3009,7 @@ impl Compositor {_bufs: bufs,_tex: vec![(tex, view), (sdf, sdf_view)],binds,+ modelled: true,impacts,glass: plan.glass,});@@ -3008,7 +3035,14 @@ impl Compositor {bufs.push(buf);binds.push(bind);}- Some(CursorDraw { _bufs: bufs, _tex: vec![(tex, view)], binds, impacts, glass: false })+ Some(CursorDraw {+ _bufs: bufs,+ _tex: vec![(tex, view)],+ binds,+ modelled: false,+ impacts,+ glass: false,+ })})();// Bind group de la passe de composition d'`accum` (layout du blur :// uniform + texture + sampler). Construit hors de la pass, comme les@@ -3216,13 +3250,14 @@ impl Compositor {timestamp_writes: None,occlusion_query_set: None,});- rpass.set_pipeline(&self.pipeline);- // L'impact des clics, sous le curseur et sa trainee (dessinee plus bas).+ // L'impact des clics (mode 16), sous le curseur et sa trainee (dessinee plus bas).+ rpass.set_pipeline(&self.pipeline_models);for bind in cursor_draw.iter().flat_map(|c| &c.impacts) {rpass.set_bind_group(0, bind, &[]);rpass.draw(0..4, 0..1);}if let Some(c) = cursor_draw.as_ref().filter(|c| c.binds.len() == 1) {+ rpass.set_pipeline(if c.modelled { &self.pipeline_models } else { &self.pipeline });rpass.set_bind_group(0, &c.binds[0], &[]);rpass.draw(0..4, 0..1);}@@ -3259,7 +3294,11 @@ impl Compositor {timestamp_writes: None,occlusion_query_set: None,});- rpass.set_pipeline(&self.pipeline_add);+ rpass.set_pipeline(if c.modelled {+ &self.pipeline_add_models+ } else {+ &self.pipeline_add+ });for (k, bind) in c.binds.iter().enumerate() {let w = crate::frame_geometry::cursor_tap_weight(k as u32, c.binds.len() as u32) as f64;rpass.set_blend_constant(wgpu::Color { r: w, g: w, b: w, a: w });@@ -5728,6 +5767,34 @@ mod tests {}}+ /// La trainee du curseur modelise s'accumule par `pipeline_add_models` : le pipeline plat ne+ /// compile pas le mode 15 et n'en peindrait rien. En mouvement, flou du curseur au maximum,+ /// le modele doit donc bien apparaitre.+ #[test]+ fn the_modelled_cursor_draws_its_trail() {+ let Some(gpu) = gpu() else { return };+ let comp = Compositor::new_sized(&gpu, 1280, 720).expect("Compositor::new_sized");+ let (y, uv) = model_screen_planes(false);+ let screen = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);+ // Traverse 60 % de la largeur en une seconde autour de t = 2 s : ~13 px par frame, donc+ // plusieurs copies dans `accum`.+ let moving = crate::cursor::CursorTrack::new(+ vec![(1.5, 0.2, 0.45), (2.5, 0.8, 0.45)],+ vec![],+ vec![(0.0, "arrow".to_string())],+ );+ let json = |show: bool| {+ model_scene_json("null", Some(true), "default", show, 3.0)+ .replace(r#""motionBlur":0,"clickBounce""#, r#""motionBlur":1,"clickBounce""#)+ };+ assert!(json(true).contains(r#""motionBlur":1,"clickBounce""#), "garde : le flou du curseur");+ let bare = compose_model(&comp, &screen, &json(false), &moving);+ let trail = compose_model(&comp, &screen, &json(true), &moving);+ let drawn = bare.chunks_exact(4).zip(trail.chunks_exact(4)).filter(|(a, b)| a != b).count();+ // Taille 3 : ~1000 px de silhouette a l'arret, etales ici par la trainee.+ assert!(drawn > 1000, "trainee du curseur modelise : {drawn} px dessines");+ }+/// Chaque état garde son art et sa silhouette : posé au centre de l'écran (vu de face), le/// modèle couvre ce que couvre le sprite plat, avec ses couleurs ; il porte une ombre en/// l'air et suit l'inclinaison du plan. Le réglage éteint garde le sprite plat.diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex 96532b6ba..8f3bf4174 100644--- a/crates/compositor/src/vk_shaders/layer.wgsl+++ b/crates/compositor/src/vk_shaders/layer.wgsl@@ -16,6 +16,14 @@//// Le rendu est en alpha PRÉMULTIPLIÉ (cf. commentaire HLSL), convention qu'on// retrouve dans tous les autres modes du compositeur (texte, curseur, ombre).+//+// `LAYER_MODELS` n'est PAS declare ici : `compositor_linux.rs` (`layer_source`) le prefixe et+// compile ce source deux fois. Un shader unique alloue a CHAQUE calque les registres de sa+// branche la plus lourde, et ce sont les modeles 3D ray-traces (modes 15 a 17) : 168 VGPR sous+// ACO (Radeon 610M), donc 6 vagues par SIMD au lieu de 32 pour le fond, l'ombre et la video, qui+// couvrent toute la sortie : l'export Linux du banc etait passe de 31 a 57 s. Sans ces trois modes,+// 48 VGPR et 20 vagues. Le pipeline plat (`false`) dessine donc tout le reste, et seuls le+// curseur modelise, l'impact de son clic et le cadre d'appareil passent par l'autre.struct Layer {dst: vec4<f32>, // x,y,w,h sortie 0..1 (origine haut-gauche)@@ -2626,18 +2634,26 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {frame_rgb = mix(frame_rgb, vec3<f32>(0.157, 0.784, 0.251), disc_cov(q, vec2<f32>(x0 + 2.0 * dx, bar * 0.5), dr));let fa = cov * layer.color.a;return vec4<f32>(frame_rgb * fa, fa); // premultiplie- } else if layer.mode > 14.5 && layer.mode < 15.5 {- // Mode 15 -- curseur modelise (`cursor_model`). Clip « Clip to canvas » dans- // `dst_prev`, comme au mode 13.- if i.pout.x < layer.dst_prev.x || i.pout.x > layer.dst_prev.x + layer.dst_prev.z- || i.pout.y < layer.dst_prev.y || i.pout.y > layer.dst_prev.y + layer.dst_prev.w {+ } else if layer.mode > 14.5 && layer.mode < 17.5 {+ // Modes 15 a 17 -- les modeles 3D, que seul le pipeline `LAYER_MODELS` compile (cf. le+ // haut du fichier). Le pipeline plat ne les recoit jamais ; s'il en recevait un, il ne+ // dessinerait rien plutot qu'une ombre faite de leurs emplacements.+ if !LAYER_MODELS {return vec4<f32>(0.0, 0.0, 0.0, 0.0);}- return cursor_model(i.local);- } else if layer.mode > 15.5 && layer.mode < 16.5 {- // Mode 16 -- impact du clic sous le curseur modelise (`cursor_impact`).- return cursor_impact(i.local);- } else if layer.mode > 16.5 && layer.mode < 17.5 {+ if layer.mode < 15.5 {+ // Mode 15 -- curseur modelise (`cursor_model`). Clip « Clip to canvas » dans+ // `dst_prev`, comme au mode 13.+ if i.pout.x < layer.dst_prev.x || i.pout.x > layer.dst_prev.x + layer.dst_prev.z+ || i.pout.y < layer.dst_prev.y || i.pout.y > layer.dst_prev.y + layer.dst_prev.w {+ return vec4<f32>(0.0, 0.0, 0.0, 0.0);+ }+ return cursor_model(i.local);+ }+ if layer.mode < 16.5 {+ // Mode 16 -- impact du clic sous le curseur modelise (`cursor_impact`).+ return cursor_impact(i.local);+ }// Mode 17 -- cadre d'appareil modelise (`device_frame`).return device_frame(i.local);} else if layer.mode > 17.5 {