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): refract the blurred picture, the cursor sharp on top
EtienneLescot1d463c7caa82
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex 74538623b..3b9a97a31 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -2533,6 +2533,8 @@ impl Compositor {.as_ref().is_some_and(|s| s.annotations.iter().any(|a| a.kind == "blur" && visible(a)));let mut ann_draws: Vec<AnnDraw> = Vec::new();+ // Les flous de confidentialite, dessines sur le metrage avant le curseur.+ let mut privacy_draws: Vec<AnnDraw> = Vec::new();if let Some(scene) = scene_ref.as_ref() {// La liste arrive deja triee par zIndex cote app : l'ordre d'iteration// EST l'ordre de peinture.@@ -2623,7 +2625,7 @@ impl Compositor {Some((&self.ann_copy_view, &self.ann_copy_view, &self.ann_copy_view)),&dummy,);- ann_draws.push(AnnDraw::plain(buf, bind));+ privacy_draws.push(AnnDraw::plain(buf, bind));}"image" => {let Some(src) = a.image_path.as_ref().filter(|s| !s.is_empty()) else {@@ -2859,6 +2861,8 @@ impl Compositor {binds: Vec<wgpu::BindGroup>,/// L'impact des clics (mode 16), 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,}let cursor_draw: Option<CursorDraw> = (|| {let track = cursor_ref.as_ref()?;@@ -2937,8 +2941,8 @@ impl Compositor {let view = tex.create_view(&wgpu::TextureViewDescriptor::default());// Curseur modelise (mode 15) : ce meme sprite extrude, `plan_cursor` en a tire la- // pose. L'enregistrement reste aux bindings 1, 2 et 5 (le cristal de Prism Glow le- // refracte), le champ au binding 4 (texMask), le sprite au binding 6 (texDof).+ // pose. La copie de l'image composee au binding 1 (texY), que refracte le cristal de+ // Prism Glow, le champ au binding 4 (texMask), le sprite au binding 6 (texDof).// Parite Windows/macOS.if let Some(pose) = plan.model {match self.cursor_sdf(&sprite.path) {@@ -2958,7 +2962,7 @@ impl Compositor {};let (buf, bind) = self.make_bind_b4(&cb,- Some((&sy, &su, &sv)),+ Some((&self.ann_copy_view, &dummy, &dummy)),&dummy,Some(&sdf_view),Some(&view),@@ -2971,6 +2975,7 @@ impl Compositor {_tex: vec![(tex, view), (sdf, sdf_view)],binds,impacts,+ glass: plan.glass,});}Err(e) => eprintln!("[curseur] champ de \"{}\" : {e:#}", sprite.path),@@ -2994,7 +2999,7 @@ impl Compositor {bufs.push(buf);binds.push(bind);}- Some(CursorDraw { _bufs: bufs, _tex: vec![(tex, view)], binds, impacts })+ Some(CursorDraw { _bufs: bufs, _tex: vec![(tex, view)], binds, 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@@ -3107,8 +3112,8 @@ impl Compositor {// Blur du fond (avant l'ecran), si active par la scene/l'inspector.self.blur_bg(&mut encoder, cfg.bg_blur);// Passe 2 : l'ecran, compose par-dessus le fond (eventuellement floute) avec- // `LoadOp::Load`. Puis le curseur, la camera et les annotations, dans cet ordre :- // celui de Windows et macOS.+ // `LoadOp::Load`. Puis les flous de confidentialite, le curseur, la camera et les autres+ // annotations, dans cet ordre : celui de Windows et macOS.{let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {label: Some("fg-pass"),@@ -3142,6 +3147,49 @@ impl Compositor {),}}+ // Fige la frame composee pour les annotations « flou ». ICI et nulle part+ // ailleurs : apres l'ecran (sinon un flou masquerait du vide)+ // et avant le premier flou (sinon deux flous qui se recouvrent+ // s'echantillonnent l'un l'autre). Une passe de rendu ne peut pas lire sa+ // propre cible, d'ou la copie -- et d'ou le fait que les annotations+ // doivent avoir leur propre passe.+ if needs_ann_copy {+ self.generate_ann_mips(&mut encoder);+ }+ // Passe 2 bis : les flous de confidentialite, sur le metrage, AVANT le curseur (parite+ // Windows et macOS). Le curseur reste net par-dessus, et le cristal de Prism Glow, qui+ // refracte l'image composee, n'y voit que des pixels deja floutes.+ if !privacy_draws.is_empty() {+ let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("privacy-pass"),+ 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);+ for a in &privacy_draws {+ rpass.set_bind_group(0, &a.bind, &[]);+ rpass.draw(0..4, 0..1);+ }+ }+ // Le cristal de Prism Glow refracte l'image telle qu'elle est composee a cet instant,+ // flous compris : sa copie dans `ann_copy` (libre, les flous l'ont deja lue ; le mip 0+ // suffit), une fois pour toutes les copies de la trainee.+ if cursor_draw.as_ref().is_some_and(|c| c.glass) {+ encoder.copy_texture_to_texture(+ self.rt.as_image_copy(),+ self.ann_copy.as_image_copy(),+ wgpu::Extent3d { width: self.render_w, height: self.render_h, depth_or_array_layers: 1 },+ );+ }// Le curseur net, et l'impact des clics sous lui. La trainee, elle, a besoin de sa// propre cible : elle suit.{@@ -3262,21 +3310,11 @@ impl Compositor {rpass.draw(0..4, 0..1);}}- // Fige la frame composee pour les annotations « flou ». ICI et nulle part- // ailleurs : apres l'ecran, le curseur et la camera (sinon un flou masquerait du vide)- // et avant la premiere annotation (sinon deux flous qui se recouvrent- // s'echantillonnent l'un l'autre). Une passe de rendu ne peut pas lire sa- // propre cible, d'ou la copie -- et d'ou le fait que les annotations- // doivent avoir leur propre passe.- if needs_ann_copy {- self.generate_ann_mips(&mut encoder);- }- // Passe 3 : les annotations, par-dessus tout le reste, curseur compris : un flou de- // confidentialite doit le couvrir, sans quoi le cristal de Prism Glow, qui refracte- // l'enregistrement brut, montrerait ce que le flou cache. Elle existe meme sans flou :- // 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.+ // 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 mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {label: Some("ann-pass"),@@ -5843,37 +5881,52 @@ mod tests {assert!(failures.is_empty(), "{failures:#?}");}- /// Un flou de confidentialité couvre le curseur, comme sous Windows et macOS. Le cristal de- /// Prism Glow réfracte l'enregistrement brut : dessiné par-dessus le flou, il montrerait ce- /// que le flou cache. Sous le flou, ce que change le curseur reste flou : aucun bord franc, là- /// où le serti du cristal, dessiné par-dessus, en ferait des centaines.+ /// Le métrage, puis ses flous de confidentialité, puis le curseur, net par-dessus (parité+ /// Windows et macOS) : le cristal de Prism Glow réfracte l'image déjà floutée. Sous le flou,+ /// des rayures fines décalées d'une colonne donnent la même image floutée ; si le verre lisait+ /// la vidéo brute, il montrerait les rayures, et les deux rendus différeraient à travers lui.#[test]- fn a_privacy_blur_covers_the_crystal_cursor() {+ fn the_crystal_refracts_the_blurred_picture() {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 blue = FakeFrame::from_planes(&gpu, 640, 360, &y, &uv);- let blur = r#""annotations":[{"id":"b","startSec":0,"endSec":10,"kind":"blur","x":0.3,"y":0.3,"w":0.6,"h":0.7,"blur":{"style":"blur","shape":"rectangle","color":"white","intensity":24,"blockSize":16}}]"#;- let scene = |show: bool| {+ // Moitié gauche grise, moitié droite (la zone floutée) rayée une colonne sur deux.+ let (w, h) = (640u32, 360u32);+ let stripes = |phase: u32| {+ let y: Vec<u8> = (0..w * h)+ .map(|i| if i % w < w / 2 { 150 } else if (i % w + phase) % 2 == 0 { 40 } else { 220 })+ .collect();+ FakeFrame::from_planes(&gpu, w, h, &y, &vec![128; (w * (h / 2)) as usize])+ };+ let (a, b) = (stripes(0), stripes(1));+ let blur = r#""annotations":[{"id":"b","startSec":0,"endSec":10,"kind":"blur","x":0.5,"y":0.0,"w":0.5,"h":1.0,"blur":{"style":"blur","shape":"rectangle","color":"white","intensity":24,"blockSize":16}}]"#;+ let json = |show: bool| {model_scene_json("null", Some(true), "default", show, 5.0).replace(r#"/arrow.png","#, r#"/arrow.png","sculpt":"prism-glow/arrow","#).replace(r#""annotations":[]"#, blur)};- let still = model_track("arrow", false, 0.5);- let with = compose_model(&comp, &blue, &scene(true), &still);- let without = compose_model(&comp, &blue, &scene(false), &still);- model_save("privacy-blur-over-crystal", &with);- // Ce que change le curseur, pixel par pixel ; un bord franc y est un saut de plus de 40- // entre deux voisins.- let diff = |i: usize, c: usize| with[i * 4 + c] as i32 - without[i * 4 + c] as i32;- let changed = (0..1280 * 720).filter(|&i| (0..3).any(|c| diff(i, c) != 0)).count();- let sharp = (0..1280 * 719)- .filter(|&i| i % 1280 < 1279)- .filter(|&i| (0..3).any(|c| (diff(i, c) - diff(i + 1, c)).abs() > 40 || (diff(i, c) - diff(i + 1280, c)).abs() > 40))- .count();- println!("sous le flou : {changed} px changés par le curseur, {sharp} bords francs");- assert!(changed > 0, "le curseur ne change rien : il manque, ou le flou l'a effacé");- assert_eq!(sharp, 0, "{sharp} bords francs sous le flou : le curseur est dessiné par-dessus");+ let mut failures = Vec::new();+ // Tout entier dans la zone, puis à cheval sur son bord.+ for x in [0.7f32, 0.48] {+ let track = crate::cursor::CursorTrack::new(vec![(0.0, x, 0.45), (9.0, x, 0.45)], vec![], vec![(0.0, "arrow".to_string())]);+ let (ra, rb) = (compose_model(&comp, &a, &json(true), &track), compose_model(&comp, &b, &json(true), &track));+ let bare = compose_model(&comp, &a, &json(false), &track);+ model_save(&format!("glass-over-blur-{x}"), &ra);+ let px = |img: &[u8], i: usize, c: usize| img[i * 4 + c] as i32;+ let hidden = (0..1280 * 720).filter(|&i| (0..3).any(|c| (px(&ra, i, c) - px(&rb, i, c)).abs() > 24)).count();+ // Le serti net du curseur : des sauts francs, entre voisins, de ce qu'il change.+ let d = |i: usize, c: usize| px(&ra, i, c) - px(&bare, i, c);+ let sharp = (0..1280 * 720 - 1)+ .filter(|&i| i % 1280 < 1279 && (0..3).any(|c| (d(i, c) - d(i + 1, c)).abs() > 60))+ .count();+ println!("cristal en x = {x} : {sharp} bords francs, {hidden} px qui suivent les rayures cachées");+ if sharp < 50 {+ failures.push(format!("x = {x} : {sharp} bords francs, le curseur n'est pas net par-dessus le flou"));+ }+ if hidden > 0 {+ failures.push(format!("x = {x} : {hidden} px montrent les rayures cachées sous le flou"));+ }+ }+ assert!(failures.is_empty(), "{failures:#?}");}/// Les thèmes cerclés gardent le trait de leur dessin (`design/cursors/<thème>`) : sur ladiff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex 1e59f2de1..ad4bbf28e 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -1417,6 +1417,23 @@ impl Compositor {}+ /// Fige l'image composée dans `ann_copy` (mip 0), qu'y lisent les flous (mips dérivés,+ /// `mips`) et le cristal de Prism Glow.+ unsafe fn snapshot_rt(&self, cmd: &metal::CommandBufferRef, mips: bool) {+ let blit = cmd.new_blit_command_encoder();+ blit.copy_from_texture(+ &self.rt, 0, 0,+ metal::MTLOrigin { x: 0, y: 0, z: 0 },+ metal::MTLSize { width: self.render_w as u64, height: self.render_h as u64, depth: 1 },+ &self.ann_copy, 0, 0,+ metal::MTLOrigin { x: 0, y: 0, z: 0 },+ );+ if mips {+ blit.generate_mipmaps(&self.ann_copy);+ }+ blit.end_encoding();+ }+/// Annotations : calque le plus haut, ancré sur `s_ann` — le rect écran SANS ZOOM, le/// conteneur que reçoit l'overlay web. Port de `compositor_windows::draw_annotations`.///@@ -1425,6 +1442,9 @@ impl Compositor {/// grossir les sous-titres sous un zoom (issue #179, puis #397 sur Linux). L'arithmétique/// elle-même vit dans `frame_geometry::annotation_dst_in`, partagée par les trois backends./// Le flou, lui, se place par `g.privacy_mask` : un masque doit rester sur ce qu'il cache.+ ///+ /// `privacy` : les flous de confidentialité seuls, dessinés sur le métrage avant le curseur ;+ /// sinon toutes les autres annotations, le calque le plus haut.unsafe fn draw_annotations(&self,cmd: &metal::CommandBufferRef,@@ -1432,30 +1452,21 @@ impl Compositor {t: f32,s_ann: [f32; 4],g: &crate::frame_geometry::FrameGeometry,+ privacy: bool,) -> Result<()> {let Some(scene) = scene else { return Ok(()) };- if scene.annotations.is_empty() {- return Ok(());- }let (rw, rh) = (self.render_w as f32, self.render_h as f32);let visible = |a: &crate::scene::SceneAnnotation| {- t >= a.start_sec as f32 && t < a.end_sec as f32+ t >= a.start_sec as f32 && t < a.end_sec as f32 && (a.kind == "blur") == privacy};+ if !scene.annotations.iter().any(visible) {+ return Ok(());+ }// UNE seule recopie pour toutes les annotations flou de la frame : leur lecture doit// voir l'image composée SANS les flous eux-mêmes, sinon deux zones qui se recouvrent// s'échantillonneraient l'une l'autre selon l'ordre de dessin.- if scene.annotations.iter().any(|a| a.kind == "blur" && visible(a)) {- let blit = cmd.new_blit_command_encoder();- blit.copy_from_texture(- &self.rt, 0, 0,- metal::MTLOrigin { x: 0, y: 0, z: 0 },- metal::MTLSize { width: rw as u64, height: rh as u64, depth: 1 },- &self.ann_copy, 0, 0,- metal::MTLOrigin { x: 0, y: 0, z: 0 },- );- // Seul le mip 0 est rempli ; le GPU dérive le reste.- blit.generate_mipmaps(&self.ann_copy);- blit.end_encoding();+ if privacy {+ self.snapshot_rt(cmd, true);}let enc = self.begin_pass(cmd, &self.rt, None, &self.pipeline_main)?;@@ -2401,6 +2412,11 @@ impl Compositor {enc.end_encoding();+ // --- flous de confidentialité : sur le métrage, AVANT le curseur (parité Windows). Le+ // curseur reste net par-dessus, et le cristal de Prism Glow, qui réfracte l'image+ // composée, n'y voit que des pixels déjà floutés.+ self.draw_annotations(cmd_buf, scene_ref.as_ref(), g.source_t, g.s_ann, &g, true)?;+// --- curseur --- (parité `compositor_windows.rs`, section « curseur custom »)if let Some(track) = cursor_ref.as_ref() {let plan = crate::frame_geometry::plan_cursor(@@ -2423,6 +2439,12 @@ impl Compositor {.map(|s| s.cursor.cursor_sprites.clone()).unwrap_or_default();let kind = plan.cursor_type.as_deref();+ // Le cristal de Prism Glow réfracte l'image telle qu'elle est composée à cet+ // instant, flous compris : sa copie en texture(5), une fois pour toutes les copies+ // de la traînée (`ann_copy` est libre, les flous l'ont déjà lue).+ if plan.glass {+ self.snapshot_rt(cmd_buf, false);+ }// L'impact des clics (mode 16, sans texture), posé sur l'écran SOUS le curseur.if !plan.impacts.is_empty() {let e = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;@@ -2433,9 +2455,9 @@ impl Compositor {}if plan.taps <= 1 {let e = self.begin_pass(cmd_buf, &self.rt, None, &self.pipeline_main)?;- // Le cristal de Prism Glow (mode 15) réfracte l'enregistrement : texture(0) et (1).- e.set_fragment_texture(0, Some(&sy));- e.set_fragment_texture(1, Some(&suv));+ if plan.glass {+ e.set_fragment_texture(5, Some(&self.ann_copy));+ }self.draw_cur_themed(e,&sprites,@@ -2458,8 +2480,9 @@ impl Compositor {Some(metal::MTLClearColor::new(0.0, 0.0, 0.0, 0.0)),&self.pipeline_add,)?;- e.set_fragment_texture(0, Some(&sy));- e.set_fragment_texture(1, Some(&suv));+ if plan.glass {+ e.set_fragment_texture(5, Some(&self.ann_copy));+ }for k in 0..plan.taps {let f = k as f32 / (plan.taps - 1) as f32;let w = crate::frame_geometry::cursor_tap_weight(k, plan.taps);@@ -2584,8 +2607,9 @@ impl Compositor {// --- annotations : calque le plus haut, ancré sur le rect ÉCRAN SANS ZOOM ---// `s_ann`, pas `s_dst` : le zoom vit dans la boîte depuis l'issue #179, donc `s_dst`// grandit avec lui et emmenait annotations et sous-titres dans le mouvement. Le flou de- // confidentialité est l'exception : il suit le contenu, d'où `&g`.- self.draw_annotations(cmd_buf, scene_ref.as_ref(), g.source_t, g.s_ann, &g)?;+ // confidentialité est l'exception : il suit le contenu, d'où `&g` ; il est passé avant le+ // curseur (plus haut).+ self.draw_annotations(cmd_buf, scene_ref.as_ref(), g.source_t, g.s_ann, &g, false)?;// Ni miroir RGBA ni attente ici : le miroir ne sert qu'à `readback_direct` (la// preview), et l'export ne lit jamais le RGBA — le blit pleine résolution était payédiff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex 41e9f148e..72ce180de 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -2200,6 +2200,11 @@ impl Compositor {self.ctx.PSSetShaderResources(5, Some(&[None]));}+ // --- flous de confidentialité : sur le métrage, AVANT le curseur. Le curseur reste net+ // par-dessus, et le cristal de Prism Glow, qui réfracte l'image composée, n'y voit que des+ // pixels déjà floutés. Les autres annotations restent le calque le plus haut (plus bas).+ self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, true);+// --- curseur custom : suit le mapping src/dst (zoom+layout), click bounce,// et flou de mouvement (parité `compositor_macos.rs` et `compositor_linux.rs`) ---if let Some(track) = cursor_ref.as_ref() {@@ -2223,10 +2228,13 @@ impl Compositor {.map(|s| s.cursor.cursor_sprites.clone()).unwrap_or_default();let cursor_type = plan.cursor_type.as_deref();- // L'enregistrement en t0/t1 : le cristal de Prism Glow (mode 15) le lit sous le- // curseur pour le réfracter. Les plans y sont déjà depuis le dessin de l'écran ; on- // ne compte pas là-dessus.- self.ctx.PSSetShaderResources(0, Some(&[Some(sy.clone()), Some(suv.clone())]));+ // Le cristal de Prism Glow réfracte l'image telle qu'elle est composée à cet+ // instant, flous compris : sa copie en t5, une fois pour toutes les copies de la+ // traînée (`ann_copy` est libre, les flous l'ont déjà lue).+ if plan.glass {+ self.ctx.CopySubresourceRegion(&self.ann_copy, 0, 0, 0, 0, &self.rt, 0, None);+ self.ctx.PSSetShaderResources(5, Some(&[Some(self.ann_copy_srv.clone())]));+ }// L'impact des clics (mode 16, sans texture), posé sur l'écran SOUS le curseur.for cb in &plan.impacts {self.draw_solid(cb);@@ -2282,6 +2290,9 @@ impl Compositor {// le dessin de la webcam qui suit juste après.self.bind_compose_state();}+ if plan.glass {+ self.ctx.PSSetShaderResources(5, Some(&[None]));+ }}}@@ -2400,12 +2411,13 @@ impl Compositor {// la transform, donc les annotations restent en place pendant que le contenu zoome dessous.// Ce fut `s_dst` tant que le zoom vivait dans la coupe source ; depuis l'issue #179 il vit// dans la BOÎTE, et `s_dst` emmenait annotations et sous-titres avec lui.- // Exception : le flou de confidentialité suit le contenu (`FrameGeometry::privacy_mask`),- // d'où la géométrie entière passée en plus de `s_ann`.+ // Les flous de confidentialité, eux, sont passés avant le curseur (plus haut) : ils suivent+ // le contenu (`FrameGeometry::privacy_mask`), d'où la géométrie entière passée en plus de+ // `s_ann`.// `source_t`, la même base de temps que les zoom/speed regions : le temps SOURCE du clip,// pas le compteur de frames. C'est ce qui garde une annotation alignée sur l'image quand// une speed region répète ou saute des frames.- self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g);+ self.draw_annotations(scene_ref.as_ref(), source_t, s_ann, &g, false);Ok(())}@@ -2417,19 +2429,23 @@ impl Compositor {/// sous-titres sous un zoom (issue #179, puis #397 sur Linux). L'arithmétique elle-même vit/// dans `frame_geometry::annotation_dst_in`, partagée par les trois backends. Le flou, lui,/// se place par `g.privacy_mask` : un masque doit rester sur ce qu'il cache.+ ///+ /// `privacy` : les flous de confidentialité seuls, dessinés sur le métrage avant le curseur ;+ /// sinon toutes les autres annotations, le calque le plus haut.unsafe fn draw_annotations(&self,scene: Option<&Scene>,t: f32,s_ann: [f32; 4],g: &crate::frame_geometry::FrameGeometry,+ privacy: bool,) {let Some(scene) = scene else { return };if scene.annotations.is_empty() {return;}let visible = |a: &crate::scene::SceneAnnotation| {- t >= a.start_sec as f32 && t < a.end_sec as f32+ t >= a.start_sec as f32 && t < a.end_sec as f32 && (a.kind == "blur") == privacy};// Une seule recopie du render target pour TOUTES les annotations flou de la frame — leur// lecture doit voir l'image composée sans les flous eux-mêmes, sinon deux zones qui sediff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex 4b872ce12..4aee32a9d 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -1066,9 +1066,6 @@ pub enum CursorPlacement {screen_px: [f32; 2],/// Taille de la cible de rendu en px, pour repasser des px aux 0..1 de la sortie.render_px: [f32; 2],- /// La coupe que montre le plan, en uv de la TEXTURE écran (`FrameGeometry::cut`) : de- /// quoi lire l'enregistrement sous le curseur (le cristal de Prism Glow le réfracte).- screen_uv: [f32; 4],},}impl CursorPlacement {@@ -1083,13 +1080,12 @@ impl CursorPlacement {pub(crate) fn lerp(self, other: CursorPlacement, f: f32) -> CursorPlacement {match (self, other) {(- CursorPlacement::Tilted { plane_pt: a, quad, center_px, screen_px, render_px, screen_uv },+ CursorPlacement::Tilted { plane_pt: a, quad, center_px, screen_px, render_px },CursorPlacement::Tilted {plane_pt: b,quad: quad_b,center_px: center_b,screen_px: screen_b,- screen_uv: uv_b,..},) => CursorPlacement::Tilted {@@ -1115,7 +1111,6 @@ impl CursorPlacement {center_px: [lerp(center_px[0], center_b[0], f), lerp(center_px[1], center_b[1], f)],screen_px: [lerp(screen_px[0], screen_b[0], f), lerp(screen_px[1], screen_b[1], f)],render_px,- screen_uv: lerp4(screen_uv, uv_b, f),},(a, b) => {let (p, q) = (a.upright_center(), b.upright_center());@@ -3431,6 +3426,10 @@ pub struct CursorPlan {/// L'impact des clics récents sur l'écran (mode 16), à dessiner SOUS le curseur. Vide sans/// curseur modélisé, sans clic récent ou à `clickBounce` nul.pub impacts: Vec<LayerCB>,+ /// Le curseur modélisé est le cristal de Prism Glow : il réfracte l'image déjà composée, le+ /// métrage et ses flous de confidentialité, que le backend lui copie juste avant de le+ /// dessiner. Seuls des pixels floutés passent ainsi à travers le verre.+ pub glass: bool,}impl CursorPlan {@@ -3575,7 +3574,6 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorPcenter_px: quad_center_px,screen_px: s_px,render_px: [rw, rh],- screen_uv: g.cut,},// Le curseur modélisé a toujours besoin d'un plan : sur écran droit, un plan// IDENTITÉ taillé dans `dst`. À rotation nulle `rotated_quad_corners_px` rend les@@ -3593,7 +3591,6 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorPcenter_px: [(dst[0] + dst[2] * 0.5) * rw, (dst[1] + dst[3] * 0.5) * rh],screen_px,render_px: [rw, rh],- screen_uv: g.cut,}}None => CursorPlacement::Upright {@@ -3734,6 +3731,7 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorPcursor_pose(input.track, input.t, lp.cursor_bounce_scale, pointing)}),impacts,+ glass: model_sprite.and_then(|s| s.sculpt.as_deref()).is_some_and(crate::sculpt::refracts),})}@@ -3770,14 +3768,13 @@ pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorP// radius_px rapport w/h du sprite : sa taille (unités) en découle, plus grand côté = 1// trail_a le curseur sculpté (0 = le sprite extrudé), l'épaisseur sous z = 0 avant// écrasement, la hauteur au-dessus de z = 0 (`SpriteShape`), 0-// trail_b la coupe que montre le plan, en uv de la texture écran (`FrameGeometry::cut`) :-// le cristal de Prism Glow y lit l'enregistrement qu'il réfracte// Textures : le sprite RGBA (alpha droit) et son champ R16F (`cursor_sdf`), sur le même rect ;-// l'enregistrement, que le cristal de Prism Glow réfracte.+// pour le cristal de Prism Glow (`CursorPlan::glass`), une copie de l'image composée, flous de+// confidentialité compris, qu'il réfracte.// Windows et macOS : sprite en t2/texture(2) (`texImg`), champ en t4/texture(4) (`texSdf`),-// enregistrement en t0/t1.-// Linux : sprite au binding 6 (`texDof`), champ au binding 4 (`texMask`), enregistrement aux-// bindings 1, 2 et 5.+// copie en t5/texture(5) (`texDof`).+// Linux : sprite au binding 6 (`texDof`), champ au binding 4 (`texMask`), copie au binding 1+// (`texY`)./// Épaisseur du sprite extrudé : son dessus est en z = 0, son dessous en z = -épaisseur.pub const MODEL_THICK: f32 = 0.19;@@ -4178,7 +4175,7 @@ pub fn cursor_model_cb(clip: [f32; 4],) -> Option<LayerCB> {let view = ModelView::new(placement, size_px, pose, shape)?;- let CursorPlacement::Tilted { render_px: [rw, rh], screen_uv, .. } = placement else { return None };+ let CursorPlacement::Tilted { render_px: [rw, rh], .. } = placement else { return None };let [x0, y0, x1, y1] = view.footprint()?;// Bords entiers : `local` vaut alors k + 0,5 au centre des pixels, comme le rastériseur.let (x0, y0, x1, y1) = (x0.floor(), y0.floor(), x1.ceil(), y1.ceil());@@ -4202,7 +4199,6 @@ pub fn cursor_model_cb(mb: [view.half[0], view.half[1], view.offset[0], view.offset[1]],radius_px: shape.size[0] / shape.size[1],trail_a: [shape.sculpt as f32, shape.thick, shape.max_height, 0.0],- trail_b: screen_uv,..Default::default()})}@@ -4278,7 +4274,7 @@ fn cursor_impact_cb(impact: Impact,alpha: f32,) -> Option<LayerCB> {- let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px: [rw, rh], .. } =+ let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px: [rw, rh] } =placementelse {return None;@@ -7651,7 +7647,7 @@ mod tests {a: f32,clip: [f32; 4],) -> LayerCB {- let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px, .. } = p+ let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px } = pelse {unreachable!()};diff --git a/crates/compositor/src/sculpt.rs b/crates/compositor/src/sculpt.rsindex 5d3cdba2f..89fa9a277 100644--- a/crates/compositor/src/sculpt.rs+++ b/crates/compositor/src/sculpt.rs@@ -62,6 +62,11 @@ fn model_box(theme: usize, arrow: bool) -> [f32; 3] {}}+/// Le curseur sculpté que nomme la scène est de verre (Prism Glow) : il réfracte ce qui est dessous.+pub fn refracts(name: &str) -> bool {+ sculpted_shape(name).is_some_and(|s| THEMES[((s.sculpt - 1) / 2) as usize] == "prism-glow")+}+/// Le curseur sculpté que nomme la scène (`"<thème>/<état>"`, cf. `resolveCursorSprites`), sous/// la forme que le mode 15 attend. `None` pour un nom inconnu : l'appelant extrude le sprite.pub fn sculpted_shape(name: &str) -> Option<SpriteShape> {@@ -225,6 +230,15 @@ mod tests {}}+ /// Seul Prism Glow est de verre, flèche et main.+ #[test]+ fn only_prism_glow_refracts() {+ for name in NAMES {+ assert_eq!(refracts(name), name.starts_with("prism-glow/"), "{name}");+ }+ assert!(!refracts("prism-glow/text"));+ }+/// Le maillage de Prism Glow tient dans sa boîte (le shader n'y lance de rayons que là), son/// dessous est à l'épaisseur annoncée (la garde au sol en dépend) et son sommet à la hauteur.#[test]diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlslindex 96c9a4971..37614e23d 100644--- a/crates/compositor/src/shaders.hlsl+++ b/crates/compositor/src/shaders.hlsl@@ -14,7 +14,7 @@ cbuffer Layer : register(b0)float4 dst_prev; // dst à la frame précédente ; modes 13 et 15 : rect de clip ; mode 17 : angle du socle, rayon et recouvrement de l'ouverture, pénombre de l'ombrefloat4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation ; mode 18 : .z = 1 si le plan est incliné, .w = 1 si son warp est projectiffloat4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie- float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie ; mode 15 : la coupe du plan en uv de l'écran (u0, v0, u1, v1), que réfracte le cristal de Prism Glow+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortiefloat4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incliné : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs};// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête@@ -82,11 +82,6 @@ float3 sample_yuv(float2 uv)}// La même, au niveau 0 : lisible dans une boucle ou une branche (le cristal du mode 15).-float3 sample_yuv_level(float2 uv)-{- return yuv709_limited(texY.SampleLevel(samp, uv, 0.0), texUV.SampleLevel(samp, uv, 0.0));-}-// SDF segment à bouts ronds — la primitive des flèches d'annotation, dont les tracés SVG sont// trois segments `stroke-linecap="round"` (cf. ArrowSvgs.tsx).float sd_segment(float2 p, float2 a, float2 b)@@ -1054,8 +1049,9 @@ float s_pixel_outline(float2 p, int shape)// dessus du serti en z = 0). Le serti marine est la silhouette de l'art extrudée sous z = 0, un// champ de distance comme les autres sculptés : il donne la couverture, l'ombre portée et l'ombre// de contact. Le cristal est lancé de rayons, triangles rangés par boîtes : réfraction par canal-// (dispersion), réflexions totales internes, sortie par son fond plat vers l'enregistrement, lu-// sous le curseur (t0/t1, `trail_b`). Tables : miroir de `prism_mesh.rs` ; un triangle = quatre+// (dispersion), réflexions totales internes, sortie par son fond plat vers l'image composée sous+// le curseur, flous de confidentialité compris (sa copie en t5). Tables : miroir de `prism_mesh.rs` ;+// un triangle = quatre// float4 (v0, drapeaux), (e1, r), (e2, g), (normale sortante, b) ; drapeaux = paroi (1) + 2 ×// arêtes réelles (bit k : l'arête opposée au sommet k) ; une boîte = deux float4 (coin bas,// premier triangle), (coin haut, nombre de triangles).@@ -2349,8 +2345,21 @@ float prism_edge_px(float3 p, int h, float px)return d / px;}-// L'enregistrement là où le rayon (q, d) du modèle retombe sur le plan : la vidéo, lue par la coupe-// du plan (`trail_b`, uv de la texture), en linéaire. Hors du plan, l'écran sombre du studio.+// La rotation inverse de `world_to_plane` : du repère du plan à celui de la caméra.+float3 plane_to_world(float3 v, ModelFrame f)+{+ float x = v.x * f.c.z - v.y * f.s.z;+ float y = v.x * f.s.z + v.y * f.c.z;+ float z = -x * f.s.y + v.z * f.c.y;+ return float3(x * f.c.y + v.z * f.s.y, y * f.c.x - z * f.s.x, y * f.s.x + z * f.c.x);+}++// Ce que montre l'image là où le rayon (q, d) du modèle retombe sur le plan : la copie de l'image+// composée faite juste avant le curseur (t5), flous de confidentialité compris, lue au pixel de+// sortie de ce point, en linéaire. Seuls des pixels déjà floutés passent donc à travers le verre.+// L'œil est en (-mb.zw, persp) du repère caméra, le rayon du pixel `local` y va vers+// (local + src.xy, -persp) : on remonte de ce point du plan à son `local`, puis à son uv de sortie.+// Hors de l'image, l'écran sombre du studio.float3 prism_screen(float3 q, float3 d, float3 nz, float hz, float3 tip, float unit, ModelFrame f){float denom = dot(d, nz);@@ -2359,12 +2368,18 @@ float3 prism_screen(float3 q, float3 d, float3 nz, float hz, float3 tip, float ureturn SCULPT_SCREEN * 0.2;}float3 g = q + d * ((hz - dot(q, nz)) / denom);- float2 fp = (tip + unit * model_to_plane(g, f)).xy / (2.0 * mb.xy) + 0.5;- if (any(fp < 0.0) || any(fp > 1.0))+ float3 w = plane_to_world(tip + unit * model_to_plane(g, f), f);+ float k = 1.0 - w.z / src.z;+ if (k < 1e-3)+ {+ return SCULPT_SCREEN * 0.2;+ }+ float2 uv = dst.xy + ((w.xy + mb.zw) / k - src.xy) / quad_px * dst.zw;+ if (any(uv < 0.0) || any(uv > 1.0)){return SCULPT_SCREEN * 0.2;}- return pow(sample_yuv_level(lerp(trail_b.xy, trail_b.zw, fp)), 2.2);+ return pow(texDof.SampleLevel(samp, uv, 0.0).rgb, 2.2);}// La couleur (sRGB, comme `model_shade`) du cristal au point `p` de la facette `h`, vu le long dediff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 34f0be51d..6456c3ff7 100644--- a/crates/compositor/src/shaders.metal+++ b/crates/compositor/src/shaders.metal@@ -58,7 +58,7 @@ struct Layerfloat4 dst_prev; // dst à la frame précédente ; modes 13 et 15 : rect de clip ; mode 17 : angle du socle, rayon et recouvrement de l'ouverture, pénombre de l'ombrefloat4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation ; mode 18 : .z = 1 si le plan est incliné, .w = 1 si son warp est projectiffloat4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie- float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie ; mode 15 : la coupe du plan en uv de l'écran (u0, v0, u1, v1), que réfracte le cristal de Prism Glow+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortiefloat4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs};// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête@@ -147,14 +147,6 @@ inline float3 sample_yuv(float2 uv,return yuv709_limited(y, cbcr);}-// `sample_yuv` au niveau 0, pour les boucles à sortie anticipée (pas de dérivées).-inline float3 sample_yuv_level(float2 uv,- texture2d<float, access::sample> texY,- texture2d<float, access::sample> texUV)-{- return yuv709_limited(texY.sample(samp, uv, level(0.0)).r, texUV.sample(samp, uv, level(0.0)).rg);-}-// SDF segment à bouts ronds — la primitive des flèches d'annotation.inline float sd_segment(float2 p, float2 a, float2 b){@@ -553,7 +545,8 @@ inline float3 image_motion(float2 q, float time, float motion, float aspect)// ============ Curseur MODÉLISÉ (mode 15) ============// Port ligne pour ligne de `cursor_model` (HLSL), dont les commentaires font foi ; seules// différences : `layer` et les textures arrivent en paramètres (le sprite en texture(2), son-// champ R16F en texture(4), l'enregistrement en texture(0) et (1) pour le cristal de Prism Glow),+// champ R16F en texture(4), la copie de l'image composée en texture(5) pour le cristal de Prism+// Glow),// `lerp` s'écrit `mix`, `SampleLevel` s'écrit `sample(…, level(0.0))`, un `out` s'écrit `thread &`,// et `pow` veut un exposant du type de sa base.// Constantes : miroir exact de `frame_geometry.rs` (MODEL_*) et de `sculpt.rs` (SCULPT_*).@@ -2200,9 +2193,16 @@ static float prism_edge_px(float3 p, int h, float px)return d / px;}+static float3 plane_to_world(float3 v, ModelFrame f)+{+ float x = v.x * f.c.z - v.y * f.s.z;+ float y = v.x * f.s.z + v.y * f.c.z;+ float z = -x * f.s.y + v.z * f.c.y;+ return float3(x * f.c.y + v.z * f.s.y, y * f.c.x - z * f.s.x, y * f.s.x + z * f.c.x);+}+static float3 prism_screen(float3 q, float3 d, float3 nz, float hz, float3 tip, float unit, ModelFrame f,- constant Layer &layer, texture2d<float, access::sample> texY,- texture2d<float, access::sample> texUV)+ constant Layer &layer, texture2d<float, access::sample> texFrame){float denom = dot(d, nz);if (denom > -1e-4)@@ -2210,17 +2210,23 @@ static float3 prism_screen(float3 q, float3 d, float3 nz, float hz, float3 tip,return SCULPT_SCREEN * 0.2;}float3 g = q + d * ((hz - dot(q, nz)) / denom);- float2 fp = (tip + unit * model_to_plane(g, f)).xy / (2.0 * layer.mb.xy) + 0.5;- if (any(fp < 0.0) || any(fp > 1.0))+ float3 w = plane_to_world(tip + unit * model_to_plane(g, f), f);+ float k = 1.0 - w.z / layer.src.z;+ if (k < 1e-3)+ {+ return SCULPT_SCREEN * 0.2;+ }+ float2 uv = layer.dst.xy + ((w.xy + layer.mb.zw) / k - layer.src.xy) / layer.quad_px * layer.dst.zw;+ if (any(uv < 0.0) || any(uv > 1.0)){return SCULPT_SCREEN * 0.2;}- return pow(sample_yuv_level(mix(layer.trail_b.xy, layer.trail_b.zw, fp), texY, texUV), float3(2.2));+ return pow(texFrame.sample(samp, uv, level(0.0)).rgb, float3(2.2));}static float3 prism_shade(float3 p, float3 n, float3 rd, int h, float px, float3 l, float3 fill, float3 nz,float hz, float3 tip, float unit, ModelFrame f, constant Layer &layer,- texture2d<float, access::sample> texY, texture2d<float, access::sample> texUV)+ texture2d<float, access::sample> texFrame){int shape = prism_shape(layer);float4 r3 = PRISM_TRIS[4 * h + 3];@@ -2251,7 +2257,7 @@ static float3 prism_shade(float3 p, float3 n, float3 rd, int h, float px, float3d = reflect(d, float3(0.0, 0.0, 1.0));continue;}- acc += thr * dot(prism_screen(qb, d2, nz, hz, tip, unit, f, layer, texY, texUV), mask);+ acc += thr * dot(prism_screen(qb, d2, nz, hz, tip, unit, f, layer, texFrame), mask);thr = 0.0;break;}@@ -2306,8 +2312,7 @@ inline float3 model_tetra(int k)static float4 cursor_model(float2 local, constant Layer &layer,texture2d<float, access::sample> texSdf,texture2d<float, access::sample> texImg,- texture2d<float, access::sample> texY,- texture2d<float, access::sample> texUV)+ texture2d<float, access::sample> texFrame){ModelFrame f;f.c = cos(layer.fx.xyz);@@ -2395,7 +2400,7 @@ static float4 cursor_model(float2 local, constant Layer &layer,float3 c;if (mat > PRISM_MAT - 0.5){- c = prism_shade(q, n, ray, hc, t_best / dlen, l, fill, nz, hz, tip, unit, f, layer, texY, texUV);+ c = prism_shade(q, n, ray, hc, t_best / dlen, l, fill, nz, hz, tip, unit, f, layer, texFrame);}else{@@ -3305,7 +3310,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],{return float4(0.0, 0.0, 0.0, 0.0);}- return cursor_model(i.local, layer, texSdf, texImg, texY, texUV);+ return cursor_model(i.local, layer, texSdf, texImg, texDof);}// mode 14 : CADRE DE FENÊTRE autour de l'écran, dessiné SOUS lui. Cf. commentaires HLSL.diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex 0f4d4e452..96532b6ba 100644--- a/crates/compositor/src/vk_shaders/layer.wgsl+++ b/crates/compositor/src/vk_shaders/layer.wgsl@@ -29,12 +29,12 @@ struct Layer {dst_prev: vec4<f32>, // mode 8 : .xy = taille du plan en px AVANT projection (le rayon y vit), .z = 1 si coins hauts carres (sous un cadre), .w = 1 si warp projectif ; mode 14 : .xy = taille du plan du cadre, .z = hauteur de la barre, .w = epaisseur du filet (px du plan) ; modes 13 et 15 : rect de clip ; mode 9 : barbe 2 ; mode 10 incliné : coins TL,TR du masque ; mode 17 : (angle du socle depuis le plan en rad, rayon de l'ouverture et recouvrement de la lunette en unites du modele, penombre de l'ombre ou 0)mb: vec4<f32>, // mode 8 : [gx, gy, z_focus, k], profondeur du plan et flou (texels source) par px d'ecart, k = 0 coupe ; mode 0 : .x taps, .y force du flou, .w = 1 si coins hauts carres (sous un cadre) ; mode 5 : mb.x = aspect w/h de la sortie (fond anime) ; mode 12 : mb.y = spread de la pénombre en px ; mode 9 : mb.y = demi-épaisseur du trait en px ; mode 10 : mb.z = 1 si masque incliné, mb.w = 1 si son warp est projectif ; mode 13 : mb.x = 1 si warp projectif ; mode 14 : couleur du filet (alpha droit) ; modes 15 et 17 : .xy = demi-taille du plan dans son repere (px pour le 15, unites pour le 17), .zw = translation du plan (repere camera, px) ; mode 18 : .z = 1 si le plan est incline, .w = 1 si son warp est projectiftrail_a: vec4<f32>, // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx) ; mode 18 incline : en fractions de sortie- trail_b: vec4<f32>, // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortie ; mode 15 : la coupe du plan en uv de l'ecran (u0, v0, u1, v1), que refracte le cristal de Prism Glow+ trail_b: vec4<f32>, // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortietrail_mb: vec4<f32>, // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incline : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs}@group(0) @binding(0) var<uniform> layer: Layer;-@group(0) @binding(1) var texY: texture_2d<f32>; // R8Unorm, sample .r ; modes 7 et 13 : le sprite RGBA+@group(0) @binding(1) var texY: texture_2d<f32>; // R8Unorm, sample .r ; modes 7 et 13 : le sprite RGBA ; mode 15 : la copie de l'image composee@group(0) @binding(2) var texU: texture_2d<f32>; // R8Unorm, sample .r@group(0) @binding(3) var samp: sampler;// Masque de segmentation du sujet webcam, R8. Une vue 1x1 est liee quand aucun masque@@ -573,8 +573,8 @@ fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<// propres et occlusion, et qui porte une ombre douce et une ombre de contact sur le plan de// l'ecran. Constantes : miroir exact de `frame_geometry.rs` (MODEL_*) et de `sculpt.rs`// (SCULPT_*), emplacements du cbuffer : `cursor_model_cb`.-// Textures : l'enregistrement reste aux bindings 1, 2 et 5 (le cristal de Prism Glow le lit sous-// le curseur) ; le sprite RGBA (alpha droit) est au binding 6 (`texDof`), son champ R16F au+// Textures : la copie de l'image composee au binding 1 (`texY`), que refracte le cristal de Prism+// Glow ; le sprite RGBA (alpha droit) est au binding 6 (`texDof`), son champ R16F au// binding 4 (`texMask`), sur le meme rect ; `color.rg` = coin du sprite dans le repere du modele,// `sprite_size()` = sa taille (w/h dans `radius_px`), `color.b` = l'ecrasement au clic.const MODEL_BEVEL: f32 = 0.045;@@ -1363,17 +1363,31 @@ fn prism_edge_px(p: vec3<f32>, h: i32, px: f32) -> f32 {return d / px;}+// La rotation inverse de `world_to_plane` : du repere du plan a celui de la camera.+fn plane_to_world(v: vec3<f32>, f: ModelFrame) -> vec3<f32> {+ let x = v.x * f.c.z - v.y * f.s.z;+ let y = v.x * f.s.z + v.y * f.c.z;+ let z = -x * f.s.y + v.z * f.c.y;+ return vec3<f32>(x * f.c.y + v.z * f.s.y, y * f.c.x - z * f.s.x, y * f.s.x + z * f.c.x);+}++// L'image composee la ou le rayon retombe sur le plan (cf. HLSL) : sa copie au binding 1.fn prism_screen(q: vec3<f32>, d: vec3<f32>, nz: vec3<f32>, hz: f32, tip: vec3<f32>, unit: f32, f: ModelFrame) -> vec3<f32> {let denom = dot(d, nz);if denom > -1e-4 {return SCULPT_SCREEN * 0.2;}let g = q + d * ((hz - dot(q, nz)) / denom);- let fp = (tip + unit * model_to_plane(g, f)).xy / (2.0 * layer.mb.xy) + vec2<f32>(0.5);- if any(fp < vec2<f32>(0.0)) || any(fp > vec2<f32>(1.0)) {+ let w = plane_to_world(tip + unit * model_to_plane(g, f), f);+ let k = 1.0 - w.z / layer.src.z;+ if k < 1e-3 {+ return SCULPT_SCREEN * 0.2;+ }+ let uv = layer.dst.xy + ((w.xy + layer.mb.zw) / k - layer.src.xy) / layer.quad_px * layer.dst.zw;+ if any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0)) {return SCULPT_SCREEN * 0.2;}- return pow(sample_yuv_level(mix(layer.trail_b.xy, layer.trail_b.zw, fp)), vec3<f32>(2.2));+ return pow(textureSampleLevel(texY, samp, uv, 0.0).rgb, vec3<f32>(2.2));}fn prism_shade(p: vec3<f32>, n: vec3<f32>, rd: vec3<f32>, h: i32, px: f32, l: vec3<f32>, fill: vec3<f32>,diff --git a/design/cursors/3d-direction.md b/design/cursors/3d-direction.mdindex a18cb1ee6..1205d3174 100644--- a/design/cursors/3d-direction.md+++ b/design/cursors/3d-direction.md@@ -14,7 +14,7 @@ their built-in art and the compositor's beveled extrusion.| Theme | Arrow model | Hand model || --- | --- | --- || Studio Ink | Black rim, a raised ivory band, a recessed satin black field. | Ivory glove cushion in a black rim, black ridges between the fingers. |-| Prism Glow | A glass crystal cut along the facets of its drawing, set in a thin navy rim. The recording shows through it, refracted with a slight dispersion; each facet glows faintly in its drawn colour, and a light line marks its folds. | The same crystal: a facet for each plane of the drawn hand, the fingers and thumb included. |+| Prism Glow | A glass crystal cut along the facets of its drawing, set in a thin navy rim. The picture under it shows through, refracted with a slight dispersion; each facet glows faintly in its drawn colour, and a light line marks its folds. | The same crystal: a facet for each plane of the drawn hand, the fingers and thumb included. || Pop Coral | Cut paper: flat-topped sheets, no rounded bead or gloss. A coral sheet on a navy sheet, a yellow sheet behind them offset down-left, two yellow click dashes. | A yellow sheet on a navy sheet, the navy showing between the fingers, a coral sheet behind offset down-left, two coral click dashes. || Pixel Candy | Simplified pixel art, one cube per pixel: a plum outline, a pink body with a pale highlight down the lit edge and a darker shade along the outline. The 3D model and the 2D sprite come from the same grid. | The same, a pixel hand: the index up, three knuckles apart, the thumb. || Star Sprout | Glossy mint cushion framed by the navy outline of its drawing, carrying a star with a face and two leaves. | Ivory glove cushion in the same navy frame, navy ridges between the fingers, a mint cuff and the same star. |@@ -38,7 +38,10 @@ writes the mesh into `crates/compositor/src/prism_mesh.rs` and the three shadersThe compositor ray-traces the crystal, its triangles grouped in bounding boxes thata ray skips when it misses them: refraction per colourchannel, total internal reflection, and an exit through its flat base onto the-recording under the cursor. The rim is its silhouette extruded, a distance field+picture under the cursor. That picture is a copy of the composed frame taken just+before the cursor is drawn: the recording, then its privacy blurs, then the cursor,+sharp on top, so only blurred pixels show through the glass. The rim is its+silhouette extruded, a distance fieldlike the other models: it gives the coverage and the shadows.All models share one close lamp: a gradient and a highlight even on flat faces,diff --git a/design/cursors/requirements.md b/design/cursors/requirements.mdindex 1d191897b..1cf03d987 100644--- a/design/cursors/requirements.md+++ b/design/cursors/requirements.md@@ -29,7 +29,7 @@ their 3D models.states that do not have a dedicated theme model. Each pack addsstyle-specific volume: gloves with separate fingers, beveled voxels, flatcut-paper sheets, cushions set in the rim of their drawn outline, and a- faceted glass crystal that refracts the recording.+ faceted glass crystal that refracts the picture under it.- Model the arrow and hand separately for every sculpted theme. Do not applyone contour, material, or roundness rule to all designs.- Preserve the cursor hotspot through hover, tilt, yaw, click, and size changes.@@ -42,7 +42,7 @@ their 3D models.| Theme | Arrow | Hand || --- | --- | --- || Studio Ink | Black rim, raised ivory band, recessed satin black field. | Ivory glove cushion; the black outline stays as a physical rim, with black ridges between the fingers. |-| Prism Glow | A glass crystal cut along the drawing's facets, in a thin navy rim; the recording shows through, refracted with a slight dispersion; the facets glow faintly in their drawn colours. Modelled from the 2D drawing alone, keeping its polygonal simplicity. | The same, a crystal hand. |+| Prism Glow | A glass crystal cut along the drawing's facets, in a thin navy rim; the picture under it shows through, refracted with a slight dispersion, privacy blurs included; the facets glow faintly in their drawn colours. Modelled from the 2D drawing alone, keeping its polygonal simplicity. | The same, a crystal hand. || Pop Coral | Cut paper: a coral sheet on a navy sheet, flat tops, matte; the yellow offset becomes a flat sheet behind; the click dashes become flat pieces. | A yellow sheet on a navy sheet, flat tops, matte; the coral offset becomes a flat sheet behind; the coral click dashes become flat pieces. || Pixel Candy | Simplified pixel art that reads at 20 px as at full size; the 3D model is one cube per pixel of the same grid as the sprite. | A pixel hand from the same kind of grid: index, three knuckles, thumb. || Star Sprout | Puffy mint cushion; the navy outline stays as a physical rim (a navy tray and a rounded bead) around it, the star and its leaves in front, each in its own navy rim. | Puffy ivory glove in the same navy rim, with navy ridges between the fingers; separate mint cuff framed in navy; the star and leaves in front, as in `star-sprout/3d-reference.png`. |diff --git a/docs/3d-effects-v2.md b/docs/3d-effects-v2.mdindex 6308bed84..0f7faf447 100644--- a/docs/3d-effects-v2.md+++ b/docs/3d-effects-v2.md@@ -294,15 +294,16 @@ leur dessin : un plateau et un jonc de la couleur du trait, un coussin de couleu(`s_paper`). Prism Glow est à part : un **cristal en maillage**, ses facettes tracées sur sonseul dessin 2D (`design/cursors/prism-glow/model/`), serti dans sa silhouette extrudée, marine.Le shader le lance de rayons, triangles rangés par boîtes englobantes (un rayon saute les-boîtes qu'il rate) : réfraction par canal (une légère-dispersion), réflexions totales internes, et sortie par son fond plat sur l'enregistrement sous-le curseur ; chaque facette luit un peu de sa couleur du dessin, ses plis d'un liseré clair.+boîtes qu'il rate) : réfraction par canal (une légère dispersion), réflexions totales internes,+et sortie par son fond plat sur l'image sous le curseur ; chaque facette luit un peu de sa+couleur du dessin, ses plis d'un liseré clair. Cette image est une copie de la frame composée+prise juste avant le curseur : le métrage, puis ses flous de confidentialité, puis le curseur,+net par-dessus. Seuls des pixels déjà floutés passent donc à travers le verre.`export_compositor.py` écrit le maillage dans `prism_mesh.rs` et dans les trois shaders. Le PNGdu thème reste l'art en 2D. En 3D, la scène nomme le modèle ; `sculpt.rs` en tient la boîte, quipose le hotspot (pointe de la flèche, bout de l'index), règle la garde au sol et borne la boîte-de dessin. Emplacements du cbuffer : `trail_a` = [modèle, épaisseur sous z = 0, hauteur-au-dessus, 0], `trail_b` = la coupe du plan en uv de l'écran, que le cristal réfracte-(`cursor_model_cb`).+de dessin. Emplacement du cbuffer : `trail_a` = [modèle, épaisseur sous z = 0, hauteur+au-dessus, 0] (`cursor_model_cb`).Pixel Candy est un pixel art dessiné une fois, en grille, dans`scripts/generate-pixel-candy-voxels.mjs` : le script en tire ses PNG 2D et les tables des troisshaders, un cube par pixel plein, tous de même hauteur, colorés comme leur pixel (contour prune,