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): tilted zooms that never roll and carry motion blur
EtienneLescotdbd82e78221c
diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rsindex 94c768c9d..fc0ed6c27 100644--- a/crates/compositor/src/compositor_linux.rs+++ b/crates/compositor/src/compositor_linux.rs@@ -61,10 +61,14 @@ const BLUR_WGSL: &str = include_str!("vk_shaders/blur.wgsl");/// en parcourant les 18 wallpapers livres) en laissant le jeu actif resident.const IMG_CACHE_BUDGET_BYTES: u64 = 512 * 1024 * 1024;-/// `&LayerCB` -> `&[u8; 128]`. `LayerCB` est `#[repr(C, align(16))]`, son layout-/// EST le buffer uniforme WGSL (16 vec4 + 1 vec2 + 2 f32 = 128 octets).+/// Taille du buffer uniforme d'un calque : `LayerCB` entier (176 octets), le `struct Layer` de+/// `layer.wgsl`. `blur.wgsl` n'en lit que les 128 premiers.+const LAYER_BYTES: u64 = std::mem::size_of::<LayerCB>() as u64;++/// `&LayerCB` -> ses octets. `LayerCB` est `#[repr(C, align(16))]`, son layout EST le buffer+/// uniforme WGSL (dix vec4 et un vec2 + 2 f32 = 176 octets).fn layer_bytes(cb: &LayerCB) -> &[u8] {- unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, 128) }+ unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, LAYER_BYTES as usize) }}/// Un calque de fond deja lie, en attente de son `draw`. `_buf`/`_tex`/`_view`@@ -444,7 +448,7 @@ impl Compositor {ty: wgpu::BindingType::Buffer {ty: wgpu::BufferBindingType::Uniform,has_dynamic_offset: false,- min_binding_size: wgpu::BufferSize::new(128),+ min_binding_size: wgpu::BufferSize::new(LAYER_BYTES),},count: None,},@@ -2093,20 +2097,18 @@ impl Compositor {// sinon. Place par plan_frame (cover-fit + coins arrondis) ;// `src = g.cut` (crop utilisateur + zoom en UV texture) dans les deux cas.//- // FLOU DE VELOCITE, ET POURQUOI SEULEMENT SUR LE MODE 0. `src_prev`/- // `dst_prev` decrivent le MEME calque a la frame precedente ; le shader- // remappe chaque pixel de sortie par ce couple pour retrouver l'UV qu'il- // occupait alors, et floute le long du segment. `src_prev = g.cut` et non- // un `cut` d'avant : la coupe est identique aux deux frames (`plan_frame`- // ne fait varier que le rect de DESTINATION entre `s_dst` et- // `s_dst_prev`), ce que Windows documente aussi. Le mouvement vient donc- // entierement de `dst_prev`.+ // FLOU DE VELOCITE. Au mode 0, `src_prev`/`dst_prev` decrivent le MEME+ // calque a la frame precedente ; le shader remappe chaque pixel de sortie+ // par ce couple pour retrouver l'UV qu'il occupait alors, et floute le long+ // du segment. `src_prev = g.cut` et non un `cut` d'avant : la coupe est+ // identique aux deux frames (`plan_frame` ne fait varier que le rect de+ // DESTINATION entre `s_dst` et `s_dst_prev`), ce que Windows documente+ // aussi. Le mouvement vient donc entierement de `dst_prev`.//- // Le mode 8 n'en recoit PAS, et ce n'est pas un oubli : ces deux champs y- // portent deja les coins projetes du quad (BR/BL dans `src_prev`,- // `plane_px` dans `dst_prev`). Les deux sens ne peuvent pas cohabiter dans- // un meme draw. macOS et Windows sautent egalement le flou sur le chemin- // incline, pour la meme raison.+ // Au mode 8, ces deux champs portent deja les coins projetes du quad+ // (BR/BL dans `src_prev`, `plane_px` dans `dst_prev`) : le plan d'avant+ // arrive dans ses propres champs (`trail_a`/`trail_b`/`trail_mb`,+ // `FrameGeometry::tilt_trail`), meme flou borne a une frame.// Sous un cadre de fenetre, l'ecran garde ses coins HAUTS carres (`mb.w` au mode 0,// `dst_prev.z` au mode 8) ; 0 sans cadre, soit le rendu d'avant.let square_top = g.screen_square_top();@@ -2143,6 +2145,7 @@ impl Compositor {dof,[rw, rh],g.screen_mask,+ g.tilt_trail([rw, rh]),),};// Bind group construit AVANT le pass (doit vivre pendant tout le pass) ;diff --git a/crates/compositor/src/compositor_macos.rs b/crates/compositor/src/compositor_macos.rsindex 4b08767ef..48c17e34b 100644--- a/crates/compositor/src/compositor_macos.rs+++ b/crates/compositor/src/compositor_macos.rs@@ -1290,6 +1290,8 @@ impl Compositor {top_lift: f32,// Le slot d'un layout en bloc, qui rogne le plan (`FrameGeometry::screen_mask`).mask: Option<crate::frame_geometry::ScreenMask>,+ // Le plan à la frame d'avant, pour son flou de mouvement (`FrameGeometry::tilt_trail`).+ trail: Option<crate::frame_geometry::TiltTrail>,y: &metal::Texture,uv: &metal::Texture,dof_pyramid: Option<&metal::Texture>,@@ -1310,6 +1312,7 @@ impl Compositor {dof_pyramid.is_some(),render_px,mask,+ trail,);self.draw_video(enc, &cb, y, uv);}@@ -2282,6 +2285,7 @@ impl Compositor {g.s_radius,top_lift,g.screen_mask,+ g.tilt_trail([rw, rh]),&sy,&suv,dof_pyramid.as_ref(),diff --git a/crates/compositor/src/compositor_windows.rs b/crates/compositor/src/compositor_windows.rsindex 6a0e22374..26882df3a 100644--- a/crates/compositor/src/compositor_windows.rs+++ b/crates/compositor/src/compositor_windows.rs@@ -1945,6 +1945,7 @@ impl Compositor {dof,render_px,g.screen_mask,+ g.tilt_trail(render_px),),&sy,&suv,diff --git a/crates/compositor/src/frame_geometry.rs b/crates/compositor/src/frame_geometry.rsindex ccaae5761..4c070aa39 100644--- a/crates/compositor/src/frame_geometry.rs+++ b/crates/compositor/src/frame_geometry.rs@@ -27,21 +27,21 @@use crate::config::Cfg;use crate::scene::{Scene, SceneCrop};-/// Constant buffer d'un calque : **128 octets**, un par draw.+/// Constant buffer d'un calque : **176 octets**, un par draw.////// C'est le contrat partagé par les trois côtés — `cbuffer Layer` dans `shaders.hlsl`,-/// `struct Layer` dans `shaders.metal`, et ce struct. Les trois doivent s'accorder champ-/// pour champ ET octet pour octet : un décalage ne produit pas d'erreur, il produit un-/// shader qui lit `color` là où on a écrit `fx`.+/// `struct Layer` dans `shaders.metal` et `vk_shaders/layer.wgsl`, et ce struct. Ils doivent+/// s'accorder champ pour champ ET octet pour octet : un décalage ne produit pas d'erreur, il+/// produit un shader qui lit `color` là où on a écrit `fx`.////// `align(16)` vient de la version macOS ; sous `repr(C)` seul, les offsets sont déjà-/// 0/16/32/40/44/48/64/80/96/112 des deux côtés — l'alignement Rust ne change que+/// 0/16/32/40/44/48/64/80/96/112/128/144/160 des deux côtés — l'alignement Rust ne change que/// l'adresse du struct, pas son contenu, et Windows le `copy_nonoverlapping` dans un/// constant buffer mappé où l'alignement source est sans effet. Les deux formes étaient/// donc compatibles ; les unifier évite qu'elles cessent de l'être.////// (Le commentaire d'origine annonçait « 64 octets ». Il n'a jamais été juste : dix champs,-/// trente-deux `f32`.)+/// trente-deux `f32`. Les trois derniers, le flou de mouvement de l'écran incliné, en font 176.)#[repr(C, align(16))]#[derive(Clone, Copy, Default)]pub struct LayerCB {@@ -55,6 +55,12 @@ pub struct LayerCB {pub src_prev: [f32; 4],pub dst_prev: [f32; 4],pub mb: [f32; 4], // mb[0] = nombre de taps de motion blur+ /// Mode 8 : le plan à la frame PRÉCÉDENTE, coins TL, TR (`trail_a`) puis BR, BL (`trail_b`)+ /// en px locaux comme `fx`/`src_prev`, et `trail_mb` = `[taps, force, 0, 0]` de son flou de+ /// mouvement, ceux du mode 0 (`mb.xy`). `trail_mb` nul ailleurs : aucun tap, rien n'est lu.+ pub trail_a: [f32; 4],+ pub trail_b: [f32; 4],+ pub trail_mb: [f32; 4],}pub const OUT_W: u32 = 1920;@@ -1135,7 +1141,7 @@ pub fn cursor_sprite_cb(src_prev: [br0, br1, bl0, bl1],// Le clip vit ici et NON dans `fx` (mode 7) : `fx` porte les coins.dst_prev: clip,- // `mb.x` : 1 = warp projectif (caméra réelle).+ // `mb.x` : 1 = warp projectif (tout écran incliné, cf. `screen_tilt`).mb: [quad.warp_flag(), 0.0, 0.0, 0.0],..Default::default()}@@ -1149,9 +1155,19 @@ pub fn cursor_sprite_cb(/// à l'autre vaut `0,42·gain` en 16:9, soit ±4 % ici.pub const CAMERA_LIGHT_GAIN: f32 = 0.2;+/// Le plan incliné une frame plus tôt, et le réglage du flou : ce que le mode 8 floute+/// (`FrameGeometry::tilt_trail`, `tilted_screen_cb`).+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct TiltTrail {+ /// Coins TL, TR, BR, BL du quad à la frame précédente, en px relatifs au centre de la boîte+ /// COURANTE — le repère de `TiltedQuad::corners`.+ pub corners: [(f32, f32); 4],+ /// `[taps, force]` : ceux du mode 0 (`FrameGeometry::mb_taps`, `mb_amount`).+ pub mb: [f32; 2],+}+/// `LayerCB` de l'écran incliné (mode 8), pour les trois backends : le quad projeté est dessiné-/// dans sa BBOX et le fragment remonte au (s, t) du plan par le warp inverse. Pas de flou de-/// mouvement sur ce chemin : `src_prev`/`dst_prev` y portent déjà les coins et le plan.+/// dans sa BBOX et le fragment remonte au (s, t) du plan par le warp inverse.////// - `src` : la coupe source en UV texture ; `center_px` : le centre du rect `s_px` à l'écran ;/// - `radius` : le rayon de l'écran droit, que le plan réduit de `quad.scale` ;@@ -1161,14 +1177,18 @@ pub const CAMERA_LIGHT_GAIN: f32 = 0.2;/// du cadre quand le rayon dépasse la barre (`color.z` = la même hauteur, px du plan) ;/// - `dof` : la profondeur de champ tourne (`FrameGeometry::depth_of_field_on`).///-/// Sous la caméra réelle (`quad.projective`) : `dst_prev.w` = 1 (warp projectif), et `color.xy`-/// porte l'éclairage, `1 + color.x·(s − 0,5) + color.y·(t − 0,5)` : la lampe de la caméra, fixe-/// dans le monde comme l'œil, éclaire un peu plus le côté proche. Nuls sous un angle fixe, dont le-/// rendu reste celui d'avant à l'octet.+/// `quad.projective` : `dst_prev.w` = 1 (warp projectif). Sous la caméra réelle (`quad.lamp`),+/// `color.xy` porte l'éclairage, `1 + color.x·(s − 0,5) + color.y·(t − 0,5)` : la lampe de la+/// caméra, fixe dans le monde comme l'œil, éclaire un peu plus le côté proche. Nuls sous un angle+/// fixe, dont l'exposition reste celle d'avant.////// Sous le masque d'un layout en bloc (`mask`) : le plan penche DANS le slot, qui le rogne. Il est/// dessiné dans le rect du slot au lieu de sa bbox, et `color.w` porte le rayon des coins du slot,/// que le shader applique à ce rect. Nul sans masque, comme avant.+///+/// `trail` : le plan à la frame précédente. Le shader floute le contenu le long du chemin qu'a+/// parcouru chaque pixel depuis, borné à une frame et réglé comme le mode 0 (`trail_a`, `trail_b`,+/// `trail_mb`). `None`, ou un seul tap : l'échantillon net, le rendu d'avant à l'octet.#[allow(clippy::too_many_arguments)]pub fn tilted_screen_cb(quad: &crate::regions::TiltedQuad,@@ -1181,6 +1201,7 @@ pub fn tilted_screen_cb(dof: bool,render_px: [f32; 2],mask: Option<ScreenMask>,+ trail: Option<TiltTrail>,) -> LayerCB {let [rw, rh] = render_px;let corners = quad.corners;@@ -1231,6 +1252,17 @@ pub fn tilted_screen_cb(mb: quad.depth_mb(s_px, focus_plane, dof),..Default::default()};+ if let Some(trail) = trail {+ // Même repère local que les coins courants : sans mouvement, les deux quads coïncident+ // au bit près et le shader garde son échantillon net.+ let [a0, a1] = local(trail.corners[0]);+ let [b0, b1] = local(trail.corners[1]);+ let [c0, c1] = local(trail.corners[2]);+ let [d0, d1] = local(trail.corners[3]);+ cb.trail_a = [a0, a1, b0, b1];+ cb.trail_b = [c0, c1, d0, d1];+ cb.trail_mb = [trail.mb[0], trail.mb[1], 0.0, 0.0];+ }if let Some(mask) = mask {reframe_warped(&mut cb, mask.rect, render_px);cb.color[3] = mask.radius_px;@@ -1656,6 +1688,11 @@ pub struct FrameGeometry {/// Caméra réelle de `follow-cursor` (`camera.rs`), `None` sans elle. Jamais en même temps/// qu'une `zoom_rotation` non nulle.pub camera: Option<crate::camera::CameraPose>,+ /// La rotation de base une frame d'écran plus tôt : avec `s_dst_prev` et `camera_prev`, le+ /// zoom d'AVANT, que le mode 8 floute (`tilt_trail`).+ pub zoom_rotation_prev: [f32; 3],+ /// La caméra réelle une frame plus tôt : son poids et son zoom d'avant, sa visée d'à présent.+ pub camera_prev: Option<crate::camera::CameraPose>,pub padding_scale: f32,/// Coupe source de l'écran en UV texture (crop utilisateur + zoom).pub cut: [f32; 4],@@ -1729,12 +1766,20 @@ impl ScreenMask {}/// Redessine un calque WARPÉ (modes 8 et 16 : coins TL/TR dans `fx`, BR/BL dans `src_prev`, en px-/// locaux à `dst`) dans une autre boîte `dst`. Le warp ne dépend pas de la boîte de dessin, qui ne-/// fait que borner les pixels rastérisés : il suffit de reporter les coins dans son repère.+/// locaux à `dst` ; au mode 8, ceux de la frame d'avant dans `trail_a`/`trail_b`) dans une autre+/// boîte `dst`. Le warp ne dépend pas de la boîte de dessin, qui ne fait que borner les pixels+/// rastérisés : il suffit de reporter les coins dans son repère.fn reframe_warped(cb: &mut LayerCB, dst: [f32; 4], render_px: [f32; 2]) {let shift = [(dst[0] - cb.dst[0]) * render_px[0], (dst[1] - cb.dst[1]) * render_px[1]];- for c in [&mut cb.fx, &mut cb.src_prev] {+ let reframe = |c: &mut [f32; 4]| {*c = [c[0] - shift[0], c[1] - shift[1], c[2] - shift[0], c[3] - shift[1]];+ };+ reframe(&mut cb.fx);+ reframe(&mut cb.src_prev);+ // La traînée, seulement s'il y en a une : sans elle, ses champs restent nuls.+ if cb.trail_mb[0] > 0.0 {+ reframe(&mut cb.trail_a);+ reframe(&mut cb.trail_b);}cb.dst = dst;cb.quad_px = [dst[2] * render_px[0], dst[3] * render_px[1]];@@ -1780,21 +1825,54 @@ impl FrameGeometry {self.zoom_rotation,self.zoom_rotation_dyn,);- // Sous un cadre d'APPAREIL, l'écran passe au warp PROJECTIF même sous un angle fixe.- // Le mode 17 lance ses rayons dans la perspective exacte ; le warp bilinéaire s'en- // écarte de ~8 % de la largeur au milieu des bords (mesuré par- // `the_device_screen_face_lands_on_the_footage_plane`), soit une lunette à cent- // pixels du bord de l'image. Les quatre coins sont les mêmes des deux côtés, donc- // l'homographie qu'ils définissent EST cette projection exacte : passer le drapeau- // recolle l'image sur le modèle, partout et pas seulement aux coins. Sans appareil —- // sans cadre ou sous le chrome plat — rien ne change, à l'octet.- if self.window_frame.as_ref().is_some_and(|f| f.kind.is_device()) {- quad.projective = true;- }+ // Un angle fixe se dessine au warp PROJECTIF, comme la caméra réelle. Les quatre coins+ // sont ceux de la projection exacte, donc l'homographie qu'ils définissent EST cette+ // projection, partout et pas seulement aux coins. Le warp bilinéaire s'en écartait de+ // ~8 % de la largeur au milieu des bords (mesuré par+ // `the_device_screen_face_lands_on_the_footage_plane`), et surtout il PENCHAIT le+ // contenu : la verticale du milieu de l'écran, droite sous une caméra sans roulis,+ // tombait de 2,9° sous `iso` et de 0,8° sous `left`/`right`, et ce roulis-là entrait+ // avec le zoom. Le mode 17 (appareil) en dépend aussi : il lance ses rayons dans la+ // perspective exacte.+ quad.projective = true;quad})}+ /// Le plan incliné une frame d'écran plus tôt, avec le réglage du flou : ce que le mode 8+ /// floute (`tilted_screen_cb`). `None` quand l'écran est droit ou le flou coupé.+ ///+ /// La frame d'avant est celle du mode 0 : la boîte au zoom d'avant (`s_dst_prev`), et ici la+ /// rotation de base d'avant (un angle fixe entre avec le zoom) ou le poids de la caméra réelle.+ /// Parallaxe, impact et visée restent ceux de la frame, comme le focus du mode 0 : le flou suit+ /// le zoom, borné à une frame.+ pub fn tilt_trail(&self, render_px: [f32; 2]) -> Option<TiltTrail> {+ if !self.tilted() || self.mb_taps < 2.0 || self.mb_amount <= 0.001 {+ return None;+ }+ let d = self.s_dst_prev;+ let px = [d[2] * render_px[0], d[3] * render_px[1]];+ let quad = match self.camera_prev {+ Some(pose) => crate::camera::View::new(px, pose).quad(px),+ None => crate::regions::rotated_quad_corners_px(+ px[0],+ px[1],+ self.zoom_rotation_prev,+ self.zoom_rotation_dyn,+ ),+ };+ // Les coins d'avant, reportés au centre de la boîte COURANTE (le repère des siens).+ let now = self.screen_center_px(render_px);+ let shift = [+ (d[0] + d[2] * 0.5) * render_px[0] - now[0],+ (d[1] + d[3] * 0.5) * render_px[1] - now[1],+ ];+ Some(TiltTrail {+ corners: quad.corners.map(|(x, y)| (x + shift[0], y + shift[1])),+ mb: [self.mb_taps, self.mb_amount],+ })+ }+/// L'écran passe-t-il par le plan projeté (modes 8, 12, 13, 14) plutôt que par le rect droit ?pub fn tilted(&self) -> bool {self.camera.is_some() || !crate::regions::is_identity_rotation(self.zoom_rotation)@@ -2532,13 +2610,14 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {let source_t_prev = clock.source_at(clock.at(source_t) - 1.0 / FPS);// le focus "auto" (suivi curseur) réutilise la même piste que le rendu du curseur.let cursor_for_zoom = cursor;- // La rotation 3D (mode 8, pas de motion blur dans ce chemin — cf. le commentaire au- // point d'appel) n'est calculée QUE pour la frame courante ; `pp` ne sert qu'au zoom- // écran normal (vélocité pour le motion blur du chemin non-tilté).+ // `pp` porte le zoom de la frame précédente, pour le flou de mouvement ; celui du plan+ // incliné y ajoute sa rotation de base et le poids de la caméra réelle (`tilt_trail`).let mut zoom_rotation = [0.0f32; 3];+ let mut zoom_rotation_prev = [0.0f32; 3];let mut zoom_tilt = 0.0f32;let mut zoom_click_impact = 0.0f32;let mut zoom_camera = 0.0f32;+ let mut zoom_camera_prev = 0.0f32;let mut zoom_aim = [0.5f32; 2];let mut zoom_orbit = [0.5f32; 2];// Curseur masqué → pas de piste pour ce qui anime le plan (parallaxe, impact, caméra@@ -2579,6 +2658,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {);pp.zoom = zs_p.scale;pp.focus = zs_p.focus;+ zoom_rotation_prev = zs_p.rotation;+ zoom_camera_prev = zs_p.camera;}// Full Camera ignore le rétrécissement réactif de la webcam (design web : mélanger// "rétrécit pour le zoom" et "grandit en plein cadre" dans la même frame n'a pas de sens).@@ -2791,6 +2872,11 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {zoom: p.zoom,press,});+ let camera_prev = camera.map(|pose| crate::camera::CameraPose {+ weight: zoom_camera_prev,+ zoom: pp.zoom,+ ..pose+ });let focus_plane = match camera {Some(pose) => pose.orbit,None => focus_in_cut(u_max, v_max, active_crop, p.focus, cut),@@ -2981,6 +3067,8 @@ pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {zoom_rotation,zoom_rotation_dyn,camera,+ zoom_rotation_prev,+ camera_prev,padding_scale,cut,focus_plane,@@ -3804,6 +3892,7 @@ fn cursor_impact_cb(src_prev: [br0, br1, bl0, bl1],dst_prev: [x0, y0, 2.0 * hx, 2.0 * hy],mb: [quad.warp_flag(), impact.spot_r, impact.spot_a, 0.0],+ ..Default::default()})}@@ -4425,6 +4514,7 @@ mod tests {false,RENDER,g.screen_mask,+ None,)};for (name, _) in DEVICES {@@ -4432,10 +4522,10 @@ mod tests {assert_eq!(cb.dst_prev[3], 1.0, "{name}: l'écran est resté au warp bilinéaire");assert_eq!(cb.color, [0.0; 4], "{name}: la lampe de la caméra s'est allumée");}- // Sans appareil, l'angle fixe garde son warp bilinéaire ET son absence de lampe ; la- // caméra réelle, elle, garde les deux.+ // Sans appareil, l'angle fixe a le même warp exact (`screen_tilt`) et toujours pas de+ // lampe ; la caméra réelle, elle, a les deux.let plain = flat_cb(&framed_plan(&framed_scene("", r#""iso""#, 1.0, false)));- assert_eq!((plain.dst_prev[3], plain.color), (0.0, [0.0; 4]));+ assert_eq!((plain.dst_prev[3], plain.color), (1.0, [0.0; 4]));let orbit = flat_cb(&framed_plan(&framed_scene("", r#""follow-cursor""#, 1.0, false)));assert_eq!(orbit.dst_prev[3], 1.0);assert!(orbit.color[0] != 0.0 || orbit.color[1] != 0.0, "la caméra réelle n'éclaire plus");@@ -5423,7 +5513,7 @@ mod tests {assert!(hx > slot_px[0] * 0.5 && hy > slot_px[1] * 0.5, "{rotation} : garde, le plan zoomé déborde du slot");let centre = g.screen_center_px(RENDER);- let draw = |m| tilted_screen_cb(&quad, s_px, centre, g.cut, g.focus_plane, g.s_radius, 0.0, false, RENDER, m);+ let draw = |m| tilted_screen_cb(&quad, s_px, centre, g.cut, g.focus_plane, g.s_radius, 0.0, false, RENDER, m, None);let (cb, bare) = (draw(g.screen_mask), draw(None));assert_eq!(cb.dst, SLOT, "{rotation} : dessiné dans le slot");assert_eq!(cb.color[3], mask.radius_px);@@ -5583,6 +5673,77 @@ mod tests {assert_eq!(flat.zoom_rotation_dyn, [0.0; 3], "sans préset");}+ /// Le plan incliné a son flou de mouvement, borné à une frame comme celui du mode 0 : sa+ /// traînée est le plan une frame d'écran plus tôt, boîte ET rotation de base — un angle fixe+ /// entre avec le zoom.+ #[test]+ fn the_tilted_screen_trails_its_previous_frame() {+ let cfg = crate::config::all().pop().expect("au moins une config");+ let render = [1170.0, 658.0];+ // La région démarre à 2 s : à 1,6 s, sa rampe d'entrée est en cours.+ let ramp = |json: &str| json.replace(r#""startSec":0.0"#, r#""startSec":2.0"#);+ let tilted = ramp(zoomed_golden_scene_json()).replace(r#""rotation":"none""#, r#""rotation":"iso""#);+ let at = |json: &str, t: f32| {+ let scene = Scene::from_json(json).expect("scène");+ plan_frame(&FrameGeometryInput { timeline_t_override: Some(t), ..golden_input(&scene, &cfg) })+ };+ let quad_of = |g: &FrameGeometry| {+ g.screen_tilt([g.s_dst[2] * render[0], g.s_dst[3] * render[1]]).expect("incliné")+ };+ let width = |c: &[(f32, f32); 4]| {+ c.iter().map(|p| p.0).fold(f32::MIN, f32::max) - c.iter().map(|p| p.0).fold(f32::MAX, f32::min)+ };++ let g = at(&tilted, 1.6);+ let trail = g.tilt_trail(render).expect("flou sur le plan incliné");+ assert_eq!(trail.mb, [g.mb_taps, g.mb_amount]);+ assert_ne!(g.zoom_rotation_prev, g.zoom_rotation, "le préset entre avec le zoom");+ let (now, before) = (width(&quad_of(&g).corners), width(&trail.corners));+ // Zoom avant : le plan d'une frame plus tôt est plus petit, de quelques pour cent.+ assert!(before < now && before > now * 0.9, "traînée {before} px, plan {now} px");++ // Au palier, rien ne bouge : la traînée EST le plan, au bit près, et le shader garde son+ // échantillon net.+ let hold = at(&tilted, 3.0);+ assert_eq!(hold.tilt_trail(render).expect("incliné").corners, quad_of(&hold).corners);++ // Flou coupé, ou écran droit (le mode 0 a le sien) : pas de traînée.+ let off = tilted.replace(r#""roundnessFrac":0.0255,"motionBlur":0.35"#, r#""roundnessFrac":0.0255,"motionBlur":0"#);+ assert_ne!(off, tilted, "la substitution doit couper le flou");+ assert_eq!(at(&off, 1.6).tilt_trail(render), None);+ assert_eq!(at(&ramp(zoomed_golden_scene_json()), 1.6).tilt_trail(render), None);+ }++ /// Le calque du mode 8 porte la traînée dans le repère de ses propres coins, y compris+ /// reporté dans le slot d'un layout en bloc ; sans elle, rien de ce qu'il portait ne change.+ #[test]+ fn the_tilted_screen_cb_carries_its_trail_in_its_own_frame() {+ let quad = crate::regions::rotated_quad_corners_px(800.0, 450.0, [-23.0, -25.0, 0.0], [0.0; 3]);+ let moved = TiltTrail { corners: quad.corners.map(|(x, y)| (x * 0.9 + 3.0, y * 0.9 - 2.0)), mb: [6.0, 0.35] };+ let mask = ScreenMask { rect: [0.1, 0.1, 0.6, 0.6], radius_px: 8.0 };+ let cb = |mask, trail| {+ tilted_screen_cb(&quad, [800.0, 450.0], [600.0, 400.0], [0.0, 0.0, 1.0, 1.0], [0.5, 0.5], 12.0, 0.0, false, [1200.0, 800.0], mask, trail)+ };+ let corner = |c: [f32; 4], i: usize| [c[2 * i], c[2 * i + 1]];+ for m in [None, Some(mask)] {+ let (bare, with) = (cb(m, None), cb(m, Some(moved)));+ assert_eq!((bare.trail_a, bare.trail_b, bare.trail_mb), ([0.0; 4], [0.0; 4], [0.0; 4]), "{m:?}");+ assert_eq!((with.dst, with.fx, with.src_prev, with.dst_prev, with.mb), (bare.dst, bare.fx, bare.src_prev, bare.dst_prev, bare.mb));+ assert_eq!(with.trail_mb, [6.0, 0.35, 0.0, 0.0]);+ // Chaque coin de la traînée garde son écart au coin courant : même repère local.+ let now = [corner(with.fx, 0), corner(with.fx, 1), corner(with.src_prev, 0), corner(with.src_prev, 1)];+ let then = [corner(with.trail_a, 0), corner(with.trail_a, 1), corner(with.trail_b, 0), corner(with.trail_b, 1)];+ for i in 0..4 {+ let want = [moved.corners[i].0 - quad.corners[i].0, moved.corners[i].1 - quad.corners[i].1];+ let got = [then[i][0] - now[i][0], then[i][1] - now[i][1]];+ assert!((got[0] - want[0]).abs() < 1e-3 && (got[1] - want[1]).abs() < 1e-3, "{m:?} coin {i} : {got:?} != {want:?}");+ }+ }+ // Sans mouvement, les deux quads coïncident au bit près.+ let still = cb(None, Some(TiltTrail { corners: quad.corners, mb: [6.0, 0.35] }));+ assert_eq!((still.trail_a, still.trail_b), (still.fx, still.src_prev));+ }+/// La vitesse se mesure dans la coupe VISIBLE, zoom compris : sous un x2, le même geste/// traverse deux fois plus d'écran et penche donc plus le plan (hors saturation).#[test]@@ -5634,7 +5795,7 @@ mod tests {};let same = |s: String| s;let on = dyn_of(&same, on_edge);- assert!(on[1] > 1.5, "clic à droite → +Y : {on:?}");+ assert!(on[1] > 0.75 * crate::regions::CLICK_IMPACT_DEG, "clic à droite → +Y : {on:?}");let insert = |field: &'static str| {move |s: String| s.replace(r#""cursor":"#, &format!(r#"{field},"cursor":"#))@@ -5942,7 +6103,7 @@ mod tests {#[test]fn layer_cb_matches_the_shader_constant_buffer() {use std::mem::{align_of, offset_of, size_of};- assert_eq!(size_of::<LayerCB>(), 128);+ assert_eq!(size_of::<LayerCB>(), 176);assert_eq!(align_of::<LayerCB>(), 16);for (name, got, want) in [("dst", offset_of!(LayerCB, dst), 0),@@ -5955,6 +6116,9 @@ mod tests {("src_prev", offset_of!(LayerCB, src_prev), 80),("dst_prev", offset_of!(LayerCB, dst_prev), 96),("mb", offset_of!(LayerCB, mb), 112),+ ("trail_a", offset_of!(LayerCB, trail_a), 128),+ ("trail_b", offset_of!(LayerCB, trail_b), 144),+ ("trail_mb", offset_of!(LayerCB, trail_mb), 160),] {assert_eq!(got, want, "offset de `{name}`");}@@ -6350,6 +6514,8 @@ mod tests {zoom_rotation: [0.0, 0.0, 0.0],zoom_rotation_dyn: [0.0, 0.0, 0.0],camera: None,+ zoom_rotation_prev: [0.0, 0.0, 0.0],+ camera_prev: None,padding_scale: 1.0,cut: [0.0, 0.0, 1.0, 1.0],focus_plane: [0.5, 0.5],@@ -6500,8 +6666,8 @@ mod tests {.expect("plan cursor")}- const ISO: [f32; 3] = [-12.0, -18.0, -2.0];- const LEFT: [f32; 3] = [-8.0, -16.0, -1.0];+ const ISO: [f32; 3] = [-23.0, -25.0, 0.0];+ const LEFT: [f32; 3] = [-6.5, -17.0, 0.0];/// Le `LayerCB` du sprite incliné est, octet pour octet, celui que chaque backend construisait/// avant de le partager. La référence est le corps d'origine de `draw_cursor_sprite`.@@ -6548,14 +6714,18 @@ mod tests {fx: [tl0, tl1, tr0, tr1],src_prev: [br0, br1, bl0, bl1],dst_prev: clip,+ // Le drapeau du warp : un angle fixe est maintenant projectif (`screen_tilt`),+ // comme la caméra réelle l'était déjà.+ mb: [quad.warp_flag(), 0.0, 0.0, 0.0],..Default::default()}}let bytes = |cb: &LayerCB| -> Vec<u8> {- // SAFETY: `LayerCB` est `repr(C)`, 128 octets de f32 sans padding (test d'offsets).- unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, 128) }.to_vec()+ // SAFETY: `LayerCB` est `repr(C)`, des f32 sans padding (test d'offsets).+ let len = std::mem::size_of::<LayerCB>();+ unsafe { std::slice::from_raw_parts(cb as *const LayerCB as *const u8, len) }.to_vec()};- for rot in [ISO, LEFT, [-8.0, 16.0, 1.0]] {+ for rot in [ISO, LEFT, [-6.5, 17.0, 0.0]] {let plan = plan_with(rot);let clip = [0.1, 0.2, 0.7, 0.6];let got = cursor_sprite_cb(@@ -6812,7 +6982,7 @@ mod tests {let scene = model_scene();for key in MODEL_STATES {let (sdf, shape) = sprite_model(key);- for rot in [[0.0; 3], [-12.0, -18.0, -2.0]] {+ for rot in [[0.0; 3], [-23.0, -25.0, 0.0]] {let track = still_track_as(Some(key), vec![0.5]);for (t, want) in [(0.3, MODEL_HOVER), (0.5 + CONTACT_S, 0.0)] {let plan = model_plan(rot, &scene, &track, t, true).expect("plan");@@ -6936,8 +7106,8 @@ mod tests {assert!(model_plan([0.0; 3], &bare, &track, 0.3, true).expect("plan").model.is_none());}- const LEFT_ROT: [f32; 3] = [-8.0, -16.0, -1.0];- const ISO_ROT: [f32; 3] = [-12.0, -18.0, -2.0];+ const LEFT_ROT: [f32; 3] = [-6.5, -17.0, 0.0];+ const ISO_ROT: [f32; 3] = [-23.0, -25.0, 0.0];/// Les poses d'essai, pour chaque état de `MODEL_STATES` : au repos, posé, tourné.fn model_cases() -> Vec<(String, CursorPlan, SpriteShape, crate::cursor_sdf::CursorSdf)> {@@ -6950,7 +7120,7 @@ mod tests {vec![],vec![(0.0, key.to_string())],);- for (name, rot) in [("flat", [0.0; 3]), ("iso", ISO_ROT), ("left", LEFT_ROT), ("right", [-8.0, 16.0, 1.0])] {+ for (name, rot) in [("flat", [0.0; 3]), ("iso", ISO_ROT), ("left", LEFT_ROT), ("right", [-6.5, 17.0, 0.0])] {for (pose, track, t) in [("hover", &clicked, 0.3), ("touch", &clicked, 0.5 + CONTACT_S), ("yaw", &moving, 1.0)] {let plan = model_plan(rot, &scene, track, t, true).expect("plan");let (sdf, shape) = sprite_model(key);diff --git a/crates/compositor/src/regions.rs b/crates/compositor/src/regions.rsindex 471235127..13bd99fba 100644--- a/crates/compositor/src/regions.rs+++ b/crates/compositor/src/regions.rs@@ -572,14 +572,23 @@ fn ease_connected_pan(t: f32) -> f32 {/// alors que le plan était rendu en entier — mesuré au pixel sur un export 1920×1080 : bord droit/// à 1539, coin calculé à 1540, arrondis présents aux quatre coins.///-/// Chaque préset a donc maintenant ses trois composantes, choisies pour qu'aucune arête ne-/// s'approche d'un axe à moins de 2° (cf. `no_preset_has_an_axis_aligned_edge`) tout en gardant-/// l'identité du préset : left penche vers la gauche, right vers la droite, iso est le plus incliné.+/// Aucune arête ne s'approche donc d'un axe à moins de 2° (cf.+/// `no_preset_has_an_axis_aligned_edge`), et AUCUN préset ne roule : Z vaut 0. Le tilt entre avec+/// le zoom, et une caméra qui bouge ne roule jamais le métrage — le roulis de −2°/±1° qui tenait+/// la règle jusqu'ici penchait l'image pendant chaque zoom, et balayait 2° entre left et right.+///+/// Sans roulis, la règle ne laisse que deux bandes de tangage (X). Une rotation Y pure garde les+/// verticales verticales, donc chaque préset tangue ; et entre 10° et 14° de tangage, le bord haut+/// d'un écran tourné ressort à plat (la remontée du rotateX annulée par la perspective), à tout+/// lacet. D'où left/right à 6,5° (un écran tourné, à peine vu d'en haut, arêtes à 2,5° au plus+/// près) et iso à 23° (vu d'en haut franchement, le plus incliné, arêtes à 4,8°). Iso sort de la+/// bande des 2° pendant son ease-in à 0,82 de force, avant que la parallaxe ne s'ouvre+/// (`PARALLAX_GATE_START`). Le budget dynamique suit left/right (`DYNAMIC_TILT_BUDGET`).fn rotation3d_for(rotation: &Option<String>) -> [f32; 3] {match rotation.as_deref() {- Some("iso") => [-12.0, -18.0, -2.0],- Some("left") => [-8.0, -16.0, -1.0],- Some("right") => [-8.0, 16.0, 1.0],+ Some("iso") => [-23.0, -25.0, 0.0],+ Some("left") => [-6.5, -17.0, 0.0],+ Some("right") => [-6.5, 17.0, 0.0],_ => [0.0, 0.0, 0.0],}}@@ -992,10 +1001,10 @@ pub(crate) const PERSPECTIVE_FACTOR: f32 = 1.6;////// Réglé une fois, en unités de P : cet écart ne dépend ni de la résolution ni du zoom (la/// perspective se déduit de la taille du plan lui-même). Sur iso en 16:9, focus au centre, le-/// coin lointain est à ~0.19 P, soit un flou de ~4.6 texels ; focus sur le coin proche, l'écart-/// double et le shader plafonne (`DOF_MAX_LOD`, niveau 1.5 de la pyramide demi-résolution, soit-/// ~5.7 texels). Un flou exprimé en texels suit le CONTENU : la même zone est aussi floue quel-/// que soit le zoom qui l'affiche.+/// coin lointain est à ~0.25 P, soit un flou de ~5.9 texels, au plafond du shader+/// (`DOF_MAX_LOD`, niveau 1.5 de la pyramide demi-résolution, soit ~5.7 texels) ; focus sur le+/// coin proche, l'écart double. Un flou exprimé en texels suit le CONTENU : la même zone est aussi+/// floue quel que soit le zoom qui l'affiche.pub const DOF_COC_PER_DEPTH: f32 = 24.0;/// Les 4 coins d'un quad `width`×`height` réduit de `scale`, projetés. `None` si un coin part@@ -1048,8 +1057,10 @@ pub struct TiltedQuad {/// Où tombe le centre du plan à l'image, en px relatifs au centre du rect d'origine.pub offset: [f32; 2],/// `true` : le plan se dessine par l'homographie EXACTE de ses coins ; `false` : par le warp- /// bilinéaire des angles fixes, inchangé à l'octet. La caméra réelle l'exige, et un cadre- /// d'appareil aussi (le mode 17 lance ses rayons dans la perspective exacte).+ /// bilinéaire, qui penche le contenu d'un plan tourné ET tangué (sa verticale du milieu+ /// suit les milieux des bords, pas la projection). Tout écran incliné passe au projectif+ /// (`FrameGeometry::screen_tilt`) ; `rotated_quad_corners_px` rend `false`, la géométrie+ /// seule.pub projective: bool,/// `true` : une lampe posée sur la caméra éclaire un peu plus le côté proche du plan/// (`CAMERA_LIGHT_GAIN`, cf. `tilted_screen_cb`). Elle appartient à la caméra RÉELLE, pas au@@ -1160,14 +1171,18 @@ fn contain_scale(/// anime le plan (la parallaxe ici ; l'impact du clic ensuite) : les contributions s'ADDITIONNENT/// puis la somme est bornée par `clamp_dynamic_tilt`.///-/// - Z : 0. L'axe le plus étroit, à ~1° de casser la règle des 2°.-/// - X : ±1,9°. La limite de `left`/`right`, les plus serrés sur cet axe.-/// - Y : ±3°. Au-delà, `left` déborde sa boîte même à échelle gelée.+/// - Z : 0. Jamais de roulis ; c'est aussi l'axe le plus étroit (0,6° en fait sortir `left`).+/// - X : ±1,2°. La limite de `left`/`right` : leur tangage de 6,5° vit dans une bande étroite, sous+/// laquelle les verticales se redressent et au-dessus de laquelle le bord haut s'aplatit.+/// - Y : ±1,8°. Vers 2,1°, `left` rapproche une arête de son axe ou déborde sa boîte ; à ±1,9°,+/// la fin d'une transition chaînée depuis `iso` en approche une à 0,002° de la règle.///-/// Reproduits par `the_budget_sweep_keeps_every_edge_off_axis` et-/// `the_budget_sweep_stays_inside_the_original_rect` sur tout le balayage, pas seulement aux-/// présets.-pub const DYNAMIC_TILT_BUDGET: [f32; 3] = [1.9, 3.0, 0.0];+/// C'était ±1,9° / ±3° tant que les présets roulaient : sans roulis, `left` n'en laisse que ça.+/// Reproduits par `the_budget_sweep_keeps_every_edge_off_axis`,+/// `the_budget_sweep_stays_inside_the_original_rect` et+/// `the_chained_sweep_keeps_every_edge_off_axis_and_inside` sur tout le balayage, pas seulement+/// aux présets.+pub const DYNAMIC_TILT_BUDGET: [f32; 3] = [1.2, 1.8, 0.0];/// Borne une part dynamique au budget, axe par axe.pub fn clamp_dynamic_tilt(rot: [f32; 3]) -> [f32; 3] {@@ -1177,10 +1192,10 @@ pub fn clamp_dynamic_tilt(rot: [f32; 3]) -> [f32; 3] {/// Force du préset sous laquelle la part dynamique est nulle ; elle s'installe en smoothstep/// jusqu'à 1. La spec disait 0,5 ; les maths de ce crate disent autrement : `left`/`right` ne-/// sortent de la bande des 2° qu'à 0,635 de force, et le budget plein ne leur laisse que-/// 0,034° de marge à force 1. Juste sous 1, la base perd plus d'angle que la porte n'en retire-/// — il faut une porte raide. 0,78 passe encore sous 2° (de 0,001°), 0,8 tient ; 0,85 garde-/// du jeu. Cf. `the_budget_sweep_keeps_every_edge_off_axis`.+/// sortent de la bande des 2° qu'à 0,71 de force, et le budget plein ne leur laisse que 0,02° de+/// marge à force 1. Juste sous 1, la base perd plus d'angle que la porte n'en retire — il faut une+/// porte raide. `iso`, lui, traverse en montant le tangage où le bord haut ressort à plat, et n'en+/// sort qu'à 0,82 : la porte doit s'ouvrir après. Cf. `the_budget_sweep_keeps_every_edge_off_axis`.const PARALLAX_GATE_START: f32 = 0.85;/// Degrés de parallaxe par unité de vitesse (largeurs — ou hauteurs — de coupe par seconde),/// avant saturation. Un balayage d'une demi-largeur par seconde penche d'environ 2° en Y, une@@ -1250,7 +1265,7 @@ pub const CLICK_IMPACT_WINDOW_S: f32 = 0.26;/// autant sur les deux axes sans que X sature seul et ne tourne l'axe du pivot. Ce n'est PAS/// le réglage `clickBounce` du curseur (brut sur [0, 5], 2,5 par défaut) : il rendrait le plan/// 2,5 fois trop fort. Cf. `a_corner_click_moves_the_plane_visibly_at_a_frozen_scale`.-pub const CLICK_IMPACT_DEG: f32 = 1.9;+pub const CLICK_IMPACT_DEG: f32 = 1.2;/// Valeur du pic de `sin(2πe)·(1−e)²` (en e ≈ 0,1904), pour que le creux de `tap` vaille −1.const TAP_NORM: f32 = 0.610;@@ -2002,7 +2017,7 @@ mod tilt_tests {};let centre = [0.5, 0.5];assert!(coc(1920.0, 1080.0, centre, 0.5, 0.5) < 1e-4);- // Coin lointain (BL) : ~0.19 P, donc ~4.6 texels, bien au-dessus du seuil net (0.5).+ // Coin lointain (BL) : ~0.25 P, donc ~5.9 texels, bien au-dessus du seuil net (0.5).let far = coc(1920.0, 1080.0, centre, 0.0, 1.0);assert!((3.5..6.0).contains(&far), "coin lointain {far}");// Focus posé sur le coin proche (TR) : le lointain s'en éloigne encore.@@ -2059,9 +2074,10 @@ mod tilt_tests {/// La règle des 2° tient sur TOUT le balayage du budget, et pas qu'aux présets : à force 1/// sur la boîte entière, et pendant l'ease-in, où la part dynamique ne doit jamais faire- /// passer une arête sous min(2°, ce que la base seule donne). Sous ~0,64 de force, `left`- /// et `right` sont DÉJÀ dans la bande (l'ease-in traverse 0°) ; on ne leur demande alors que- /// de ne pas empirer.+ /// passer une arête sous min(2°, ce que la base seule donne). Sous ~0,71 de force, `left`+ /// et `right` sont DÉJÀ dans la bande (l'ease-in traverse 0°), `iso` jusqu'à ~0,82 (il+ /// traverse le tangage où son bord haut ressort à plat) ; on ne leur demande alors que de ne+ /// pas empirer.#[test]fn the_budget_sweep_keeps_every_edge_off_axis() {let (w, h) = (1920.0f32, 1080.0f32);@@ -2281,7 +2297,7 @@ mod tilt_tests {}}let fast = dynamic_tilt(1.0, Some(&swipe(1000.0, 9.0)), FULL_CUT, 1.0, [0.0; 3]);- assert!(fast[1] > 2.9, "saturation au budget : {fast:?}");+ assert!(fast[1] > b[1] - 0.1, "saturation au budget : {fast:?}");}/// Pure fonction de `t` : l'ordre des appels (lecture, seek arrière) ne change rien.@@ -2451,8 +2467,9 @@ mod tilt_tests {worst = worst.max((a.0 - b.0).hypot(a.1 - b.1));}}- // Mesuré : 24 px (iso), 25 (left), 27 (right) à 1080p pour un clic dans un coin.- assert!(worst > 15.0, "{name} : {worst:.1} px, invisible");+ // Mesuré : 13 px (iso), 16 (left), 17 (right) à 1080p pour un clic dans un coin. C'était+ // 24 à 27 px au budget de ±1,9° que le roulis des présets permettait.+ assert!(worst > 12.0, "{name} : {worst:.1} px, invisible");}}@@ -2832,7 +2849,7 @@ mod follow_camera_tests {assert_eq!((blind.aim, blind.orbit), ([0.5, 0.5], [0.5, 0.5]));// Un angle fixe garde exactement son état.let iso = zoom_state_in(&[region("iso", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());- assert_eq!((iso.rotation, iso.camera, iso.click_impact), ([-12.0, -18.0, -2.0], 0.0, 1.0));+ assert_eq!((iso.rotation, iso.camera, iso.click_impact), ([-23.0, -25.0, 0.0], 0.0, 1.0));let unknown = zoom_state_in(&[region("orbit", 2.0, 8.0)], 5.0, Some(&tr), &f, &ScreenClock::default());assert_eq!((unknown.rotation, unknown.tilt, unknown.camera), ([0.0; 3], 0.0, 0.0));}diff --git a/crates/compositor/src/shaders.hlsl b/crates/compositor/src/shaders.hlslindex ef0062c78..052acbfc5 100644--- a/crates/compositor/src/shaders.hlsl+++ b/crates/compositor/src/shaders.hlsl@@ -13,6 +13,9 @@ cbuffer Layer : register(b0)float4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)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+ float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx)+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev)+ 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// de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de@@ -250,8 +253,8 @@ float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 c11, floreturn float3(s, t, ok);}-// Le warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle (`projective` =-// 1, cf. `TiltedQuad::warp_flag`), bilinéaire sous un angle fixe, inchangé.+// Le warp inverse d'un calque posé sur le plan : projectif (`projective` = 1, cf.+// `TiltedQuad::warp_flag`, que tout écran incliné porte), bilinéaire sinon.float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective){if (projective > 0.5)@@ -261,6 +264,21 @@ float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, flreturn quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Un échantillon de l'écran incliné (mode 8) : la vidéo nette, fondue vers la pyramide de+// profondeur de champ (t2) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce seuil,+// l'échantillon net d'avant, à l'octet.+float3 tilted_sample(float2 uv, float coc)+{+ float3 rgb = sample_yuv(uv);+ if (coc > 0.5)+ {+ float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);+ float3 far_rgb = texImg.SampleLevel(samp, uv, lod).rgb;+ rgb = lerp(rgb, far_rgb, saturate((coc - 0.5) / 1.5));+ }+ return rgb;+}+// Hash 2D -> [0,1) sans sin() : le hash `frac(sin(x) * 43758)` dépend de la précision du GPU,// celui-ci (Hoskins, « hash12 ») ne fait que des produits de petites valeurs.float hash12(float2 p)@@ -1424,8 +1442,8 @@ float4 ps_main(VSOut i) : SV_Target// mode 8 : écran tilté en 3D (zoom regions "rotation" : iso/left/right) ou vu par la caméra// réelle (`follow-cursor`). `dst`/`quad_px` couvrent la BOUNDING BOX des 4 coins projetés// (`frame_geometry::tilted_screen_cb`) ; ce shader retrouve où tombe chaque pixel DANS le quad- // (warp inverse : bilinéaire sous un angle fixe, projectif exact sous la caméra réelle,- // dst_prev.w = 1) et échantillonne la vidéo à l'UV correspondant, sinon transparent.+ // (warp inverse : projectif exact quand dst_prev.w = 1, ce que porte tout écran incliné,+ // bilinéaire sinon) et échantillonne la vidéo à l'UV correspondant, sinon transparent.// fx.xy/fx.zw = coins TL/TR (px locaux, 0..quad_px) ; src_prev.xy/.zw = coins BR/BL.// color.xy (caméra réelle) : éclairage 1 + color.x·(s − 0.5) + color.y·(t − 0.5).// mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy@@ -1433,6 +1451,8 @@ float4 ps_main(VSOut i) : SV_Target// k = texels source de flou par px d'écart de profondeur (0 = profondeur de champ coupée).// t2 (texImg) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que t0/t1 ; liée// explicitement à chaque draw du mode 8 (`draw_video` ne lie que t0/t1).+ // trail_a/trail_b = coins du plan à la frame précédente, trail_mb = [taps, force] : son flou+ // de mouvement (`FrameGeometry::tilt_trail`).// mode 11 : texte d'annotation, rastérisé par Direct2D (voir text.rs). D2D écrit sur une// surface DXGI en alpha PRÉMULTIPLIÉ, donc contrairement au mode 7 (sprite curseur, alpha// droit) il ne faut SURTOUT pas re-multiplier ici : les bords adoucis des glyphes@@ -1613,16 +1633,32 @@ float4 ps_main(VSOut i) : SV_Target// jamais par le RGBA de la pyramide, et `k = 0` (réglage coupé) ne quitte jamais cette// voie. Au-delà, fondu vers la pyramide demi-résolution (t2) au niveau `log2(coc) - 1`// (son niveau 0 est déjà une moyenne 2x2), plafonné à DOF_MAX_LOD : au niveau 2, un- // bloc 4x4 soude les jambages d'un « m » en 1080p.- float3 rgb = sample_yuv(uv);+ // bloc 4x4 soude les jambages d'un « m » en 1080p (`tilted_sample`).float2 rs = saturate(float2(r.x, r.y));float z = (rs.x - 0.5) * mb.x + (rs.y - 0.5) * mb.y;float coc = mb.w * abs(z - mb.z);- if (coc > 0.5)+ float3 rgb = tilted_sample(uv, coc);+ // Flou de mouvement, celui du mode 0 : l'UV que CE pixel montrait à la frame précédente,+ // par le même warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis `taps`+ // échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame. Hors du+ // plan d'avant, le warp prolongé donne encore le bon point (sa racine proche).+ int taps = (int) trail_mb.x;+ if (taps > 1 && trail_mb.y > 0.001){- float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);- float3 far_rgb = texImg.SampleLevel(samp, uv, lod).rgb;- rgb = lerp(rgb, far_rgb, saturate((coc - 0.5) / 1.5));+ float3 rp = quad_inverse(i.local, trail_a.xy, trail_a.zw, trail_b.xy, trail_b.zw, dst_prev.w);+ float2 uv_prev = float2(lerp(src.x, src.z, rp.x), lerp(src.y, src.w, rp.y));+ float2 duv = (uv - uv_prev) * saturate(trail_mb.y);+ if (dot(duv, duv) >= 1e-9)+ {+ float3 acc = 0.0;+ [loop] for (int k = 0; k < 16; k++)+ {+ if (k >= taps) break;+ float t = (float) k / (float) (taps - 1);+ acc += tilted_sample(uv - duv * (1.0 - t), coc);+ }+ rgb = acc / (float) taps;+ }}if (dst_prev.w > 0.5){diff --git a/crates/compositor/src/shaders.metal b/crates/compositor/src/shaders.metalindex 07b885425..fb53b114a 100644--- a/crates/compositor/src/shaders.metal+++ b/crates/compositor/src/shaders.metal@@ -42,7 +42,7 @@ using namespace metal;// =================================================================================//// Le moteur côté CPU upload ce buffer via `setVertexBytes` (vertex stage) et-// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 128 octets,+// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 176 octets,// ce qui est sous le seuil d'alignement 4K de Metal pour le mode « immediate ».struct Layer@@ -57,6 +57,9 @@ struct Layerfloat4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)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+ float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx)+ float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev)+ 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// de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de@@ -298,8 +301,8 @@ inline float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 creturn float3(s, t, ok);}-// Warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle (`projective` = 1),-// bilinéaire sous un angle fixe, inchangé.+// Warp inverse d'un calque posé sur le plan : projectif (`projective` = 1, que tout écran incliné+// porte), bilinéaire sinon.inline float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective){if (projective > 0.5)@@ -309,6 +312,24 @@ inline float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2return quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Un échantillon de l'écran incliné (mode 8) : la vidéo nette, fondue vers la pyramide de+// profondeur de champ (texture(2)) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce+// seuil, l'échantillon net d'avant, à l'octet. Miroir de `tilted_sample` (HLSL).+inline float3 tilted_sample(float2 uv, float coc,+ texture2d<float, access::sample> texY,+ texture2d<float, access::sample> texUV,+ texture2d<float, access::sample> texImg)+{+ float3 rgb = sample_yuv(uv, texY, texUV);+ if (coc > 0.5)+ {+ float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);+ float3 far_rgb = texImg.sample(samp, uv, level(lod)).rgb;+ rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));+ }+ return rgb;+}+// Couverture d'une pastille (disque) adoucie sur ~1.5 px, pour la barre de titre du mode 14.inline float disc_cov(float2 p, float2 c, float r){@@ -1435,7 +1456,7 @@ fragment float4 ps_main(VSOut i [[stage_in]],}// mode 8 : écran tilté (zoom regions "rotation") ou vu par la caméra réelle. Warp inverse :- // bilinéaire sous un angle fixe, projectif exact sous la caméra réelle (dst_prev.w = 1), qui+ // projectif exact (dst_prev.w = 1, tout écran incliné), bilinéaire sinon ; la caméra réelle// éclaire aussi le plan (color.xy : 1 + color.x·(s − 0.5) + color.y·(t − 0.5)).// mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy// en px, positive vers la caméra ; z_focus = celle du focus du zoom (`TiltedQuad::depth_mb`) ;@@ -1478,15 +1499,31 @@ fragment float4 ps_main(VSOut i [[stage_in]],// Profondeur de champ : net sous un demi-texel de flou (l'échantillon d'avant, à// l'octet), fondu au-delà vers la pyramide au niveau `log2(coc) - 1`, plafonné.// `level(lod)` exige `mip_filter::linear` sur `samp` : sans lui, niveau 0 partout.- float3 rgb = sample_yuv(uv, texY, texUV);float2 rs = clamp(float2(r.x, r.y), 0.0, 1.0);float z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;float coc = layer.mb.w * abs(z - layer.mb.z);- if (coc > 0.5)+ float3 rgb = tilted_sample(uv, coc, texY, texUV, texImg);+ // Flou de mouvement, celui du mode 0 : l'UV que CE pixel montrait à la frame précédente,+ // par le même warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis `taps`+ // échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame.+ int taps = int(layer.trail_mb.x);+ if (taps > 1 && layer.trail_mb.y > 0.001){- float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);- float3 far_rgb = texImg.sample(samp, uv, level(lod)).rgb;- rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));+ float3 rp = quad_inverse(i.local, layer.trail_a.xy, layer.trail_a.zw,+ layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w);+ float2 uv_prev = float2(mix(layer.src.x, layer.src.z, rp.x), mix(layer.src.y, layer.src.w, rp.y));+ float2 duv = (uv - uv_prev) * clamp(layer.trail_mb.y, 0.0, 1.0);+ if (dot(duv, duv) >= 1e-9)+ {+ float3 acc = float3(0.0);+ for (int k = 0; k < 16; k++)+ {+ if (k >= taps) break;+ float t = float(k) / float(taps - 1);+ acc += tilted_sample(uv - duv * (1.0 - t), coc, texY, texUV, texImg);+ }+ rgb = acc / float(taps);+ }}if (layer.dst_prev.w > 0.5){diff --git a/crates/compositor/src/vk_shaders/layer.wgsl b/crates/compositor/src/vk_shaders/layer.wgslindex ed67dc147..cdf12c322 100644--- a/crates/compositor/src/vk_shaders/layer.wgsl+++ b/crates/compositor/src/vk_shaders/layer.wgsl@@ -28,6 +28,9 @@ struct Layer {src_prev: vec4<f32>, // modes 8/12/13/14 : coins BR,BL du quad projeté ; mode 9 : barbe 1 ; mode 10 incliné : coins BR,BL du masque ; mode 15 : (hotspot du dessus, repere du plan en px ; lacet) ; mode 17 : marges du corps (gauche, haut, droite, bas ; unites du modele)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)+ trail_a: vec4<f32>, // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx)+ trail_b: vec4<f32>, // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev)+ trail_mb: vec4<f32>, // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs}@group(0) @binding(0) var<uniform> layer: Layer;@@ -330,8 +333,8 @@ fn quad_inverse_projective(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vereturn vec3<f32>(s, t, ok);}-// Warp inverse d'un calque pose sur le plan : projectif sous la camera reelle (`projective` = 1),-// bilineaire sous un angle fixe, inchange.+// Warp inverse d'un calque pose sur le plan : projectif (`projective` = 1, que tout ecran incline+// porte), bilineaire sinon.fn quad_inverse(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>, projective: f32) -> vec3<f32> {if projective > 0.5 {return quad_inverse_projective(P, c00, c10, c11, c01);@@ -339,6 +342,20 @@ fn quad_inverse(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c0return quad_inverse_bilinear(P, c00, c10, c11, c01);}+// Un echantillon de l'ecran incline (mode 8) : la video nette, fondue vers la pyramide de+// profondeur de champ (binding 4, a la place du masque webcam) au-dela d'un demi-texel de cercle+// de confusion `coc`. Sous ce seuil, l'echantillon net d'avant, a l'octet. Miroir de+// `tilted_sample` (HLSL). LOD explicite : pas de derivees dans cette branche.+fn tilted_sample(uv: vec2<f32>, coc: f32) -> vec3<f32> {+ var rgb = sample_yuv(uv);+ if coc > 0.5 {+ let lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);+ let far_rgb = textureSampleLevel(texMask, samp, uv, lod).rgb;+ rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));+ }+ return rgb;+}+// Hash 2D -> [0,1) sans sin(). Miroir de `hash12` cote HLSL.fn hash12(p: vec2<f32>) -> f32 {var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);@@ -1376,8 +1393,8 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {} else if layer.mode > 7.5 && layer.mode < 8.5 {// Mode 8 -- ecran tilte (rotation 3D des zoom regions). Le quad projete est// dessine dans sa BBOX (le VS ne sait tracer qu'un rect) et chaque fragment- // remonte au (s,t) du plan par warp inverse : bilineaire sous un angle fixe, projectif exact- // sous la camera reelle (dst_prev.w = 1), qui eclaire aussi le plan (color.xy).+ // remonte au (s,t) du plan par warp inverse : projectif exact (dst_prev.w = 1, tout ecran+ // incline), bilineaire sinon ; la camera reelle eclaire aussi le plan (color.xy).//// PAS de test de clip sur `dst_prev` : en mode 8 `dst_prev.xy` porte// `plane_px`, la taille du plan en PIXELS (~1600), la ou `i.pout` vit dans@@ -1415,15 +1432,33 @@ fn fs_main(i: VsOut) -> @location(0) vec4<f32> {// Profondeur de champ (cf. HLSL) : net sous un demi-texel de flou, l'echantillon// d'avant a l'octet ; au-dela, fondu vers la pyramide demi-resolution liee en binding 4// (a la place du masque webcam, que ce mode ne lit pas), au niveau `log2(coc) - 1`,- // plafonne. LOD explicite : pas de derivees dans cette branche.- var tilt_rgb = sample_yuv(uv);+ // plafonne. LOD explicite : pas de derivees dans cette branche (`tilted_sample`).let rs = clamp(vec2<f32>(r.x, r.y), vec2<f32>(0.0), vec2<f32>(1.0));let z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;let coc = layer.mb.w * abs(z - layer.mb.z);- if coc > 0.5 {- let lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);- let far_rgb = textureSampleLevel(texMask, samp, uv, lod).rgb;- tilt_rgb = mix(tilt_rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));+ var tilt_rgb = tilted_sample(uv, coc);+ // Flou de mouvement, celui du mode 0 (cf. HLSL) : l'UV que CE pixel montrait a la frame+ // precedente, par le meme warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis+ // `taps` echantillons de celui-la a celui-ci, raccourcis de la force. Borne a une frame.+ let trail_taps = i32(layer.trail_mb.x);+ if trail_taps > 1 && layer.trail_mb.y > 0.001 {+ let rp = quad_inverse(+ i.local, layer.trail_a.xy, layer.trail_a.zw, layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w,+ );+ let uv_prev = vec2<f32>(+ mix(layer.src.x, layer.src.z, rp.x),+ mix(layer.src.y, layer.src.w, rp.y),+ );+ let duv = (uv - uv_prev) * clamp(layer.trail_mb.y, 0.0, 1.0);+ if dot(duv, duv) >= 1e-9 {+ var acc = vec3<f32>(0.0);+ let step = 1.0 / f32(trail_taps - 1);+ for (var k: i32 = 0; k < 16; k = k + 1) {+ if k >= trail_taps { break; }+ acc = acc + tilted_sample(uv - duv * (1.0 - f32(k) * step), coc);+ }+ tilt_rgb = acc / f32(trail_taps);+ }}if layer.dst_prev.w > 0.5 {// La lampe de la camera reelle : le cote proche un peu plus clair.diff --git a/crates/compositor/tests/click_impact_render.rs b/crates/compositor/tests/click_impact_render.rsindex 751e9b005..44aa73ffe 100644--- a/crates/compositor/tests/click_impact_render.rs+++ b/crates/compositor/tests/click_impact_render.rs@@ -135,9 +135,9 @@ fn a_click_presses_the_clicked_side_of_the_tilted_plane() {];let probe = |rgba: &[u8]| {let (l, r) = left_and_right_edges(rgba);- // Colonnes fixes, à l'intérieur du plan à tous les instants (bords mesurés : ~430 et- // ~1660) : on compare la même tranche du plan d'une frame à l'autre.- (l, r, plane_height_at(rgba, 1600), plane_height_at(rgba, 480))+ // Colonnes fixes, à l'intérieur du plan à tous les instants (bords mesurés à mi-hauteur :+ // ~525 et ~1590) : on compare la même tranche du plan d'une frame à l'autre.+ (l, r, plane_height_at(rgba, 1400), plane_height_at(rgba, 560))};let mut frames = Vec::new();for (name, t) in instants {@@ -166,9 +166,10 @@ fn a_click_presses_the_clicked_side_of_the_tilted_plane() {assert_eq!(unchanged, 0, "sans l'option, le clic ne doit rien changer");assert_eq!(settled, 0, "le plan n'est pas revenu à sa pose");assert!(pressed > 1_000, "{pressed} px : le contact ne se voit pas");- // Au contact, le bord droit (cliqué) recule : il se rapproche du centre et rétrécit, le- // bord gauche avance et grandit.- assert!(contact.1 < rest.1, "bord droit {} au repos {}", contact.1, rest.1);+ // Au contact, le côté droit (cliqué) recule et rétrécit, le côté gauche avance : il grandit+ // et son bord s'écarte du centre. Sous `iso` (tourné ET vu d'en haut), le bord droit ne bouge+ // presque pas à mi-hauteur : le pivot de l'impact passe près de lui.+ assert!(contact.0 < rest.0, "bord gauche {} au repos {}", contact.0, rest.0);assert!(contact.2 < rest.2, "hauteur droite {} au repos {}", contact.2, rest.2);assert!(contact.3 > rest.3, "hauteur gauche {} au repos {}", contact.3, rest.3);}diff --git a/docs/3d-effects-v2.md b/docs/3d-effects-v2.mdindex 5e68938fd..a7ba274d0 100644--- a/docs/3d-effects-v2.md+++ b/docs/3d-effects-v2.md@@ -17,7 +17,8 @@ Ce document tranche les décisions que la v1 laissait ouvertes et découpe les PUn zoom porte **une attitude figée** (`rotationPreset` : `iso`, `left`, `right`), animée pardeux effets qui partagent un unique budget d'angle dynamique (`DYNAMIC_TILT_BUDGET`-= ±1,9° X, ±3,0° Y, 0° Z, `clamp_dynamic_tilt`) :+= ±1,2° X, ±1,8° Y, 0° Z, `clamp_dynamic_tilt` ; ±1,9° X et ±3° Y tant que les angles fixes+roulaient) :- **la parallaxe** (`dynamic_tilt`, PR 1) : pilotée par la **vitesse** lissée du curseur ;- **l'impact du clic** (PR 2b) : piloté par la **position** du clic, `regions::tap`.diff --git a/src/components/video-editor/types.ts b/src/components/video-editor/types.tsindex 93d9f763b..6aee9d5f9 100644--- a/src/components/video-editor/types.ts+++ b/src/components/video-editor/types.ts@@ -101,12 +101,13 @@ export function isRotation3DPreset(value: unknown): value is Rotation3DPreset {return typeof value === "string" && (ROTATION_3D_PRESET_ORDER as string[]).includes(value);}-// Every preset carries all three components on purpose. With a single-axis rotation the projected-// quad keeps an edge exactly parallel to the frame — both vertical edges for a pure Y rotation,-// which is geometry rather than a setting — and a perfectly vertical edge cutting through text is-// indistinguishable from `overflow: hidden`. That is what got reported three times as "the-// recording is truncated" while the plane was in fact drawn whole. `regions.rs` holds the same-// numbers and a test asserting no edge comes within 2° of an axis.+// No preset rolls (Z is 0): the tilt enters with the zoom, and a camera that moves never rolls the+// footage. X and Y are chosen so that no edge of the projected quad comes within 2° of an axis — a+// perfectly vertical edge cutting through text is indistinguishable from `overflow: hidden`, which+// got reported three times as "the recording is truncated". A pure Y rotation keeps both vertical+// edges vertical, so every preset also pitches; and between 10° and 14° of pitch the top edge of a+// turned screen reads level, so a preset pitches either less or more than that. `regions.rs` holds+// the same numbers and the tests.//// A moving camera has no single pose. Its entry is its resting angle (`ELEVATION_DEG` in// `camera.rs`: cursor centred, the camera 4° above the screen, facing it), what a renderer without@@ -114,9 +115,9 @@ export function isRotation3DPreset(value: unknown): value is Rotation3DPreset {// rotation of the screen. It is a camera angle, not a screen rotation, so this is the nearest// equivalent rather than the same picture.export const ROTATION_3D_PRESETS: Record<Rotation3DPreset, Rotation3D> = {- iso: { rotationX: -12, rotationY: -18, rotationZ: -2 },- left: { rotationX: -8, rotationY: -16, rotationZ: -1 },- right: { rotationX: -8, rotationY: 16, rotationZ: 1 },+ iso: { rotationX: -23, rotationY: -25, rotationZ: 0 },+ left: { rotationX: -6.5, rotationY: -17, rotationZ: 0 },+ right: { rotationX: -6.5, rotationY: 17, rotationZ: 0 },"follow-cursor": { rotationX: -4, rotationY: 0, rotationZ: 0 },};