Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

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.rs
index 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 la
diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rs
index 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.rs
index 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 se
diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rs
index 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<CursorP
center_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<CursorP
center_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<CursorP
cursor_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] } =
placement
else {
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 } = p
else {
unreachable!()
};
diff --git a/crates/compositor/src/sculpt.rs b/crates/compositor/src/sculpt.rs
index 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.hlsl
index 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'ombre
float4 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 projectif
float4 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 sortie
float4 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 u
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 * 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 de
diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metal
index 34f0be51d..6456c3ff7 100644
--- a/crates/compositor/src/shaders.metal
+++ b/crates/compositor/src/shaders.metal
@@ -58,7 +58,7 @@ struct Layer
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'ombre
float4 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 projectif
float4 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 sortie
float4 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, float3
d = 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.wgsl
index 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 projectif
trail_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 sortie
trail_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.md
index 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 shaders
The compositor ray-traces the crystal, its triangles grouped in bounding boxes that
a ray skips when it misses them: refraction per colour
channel, 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 field
like 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.md
index 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 adds
style-specific volume: gloves with separate fingers, beveled voxels, flat
cut-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 apply
one 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.md
index 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 son
seul 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 PNG
du thème reste l'art en 2D. En 3D, la scène nomme le modèle ; `sculpt.rs` en tient la boîte, qui
pose 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 trois
shaders, un cube par pixel plein, tous de même hauteur, colorés comme leur pixel (contour prune,