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): 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.hlsl
index 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'ombre
float4 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, flo
return 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, fl
return 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.metal
index 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 Layer
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'ombre
float4 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 c
return 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, float2
return 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.wgsl
index 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: ve
return 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>, c0
return 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.rs
index 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.md
index 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 P
Un zoom porte **une attitude figée** (`rotationPreset` : `iso`, `left`, `right`), animée par
deux 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.ts
index 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 },
};