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
//! La géométrie de composition, sans backend.
//!
//! Tout ce qui décide OÙ va un calque et de quoi il a l'air — placements de preset,
//! coupe source, cover-fit, rayons, ombres, timeline de la fixture, parsing des
//! couleurs CSS — par opposition à ce qui l'envoie au GPU. Rien ici ne connaît
//! D3D11 ni Metal, et le module est donc compilé sur les deux plateformes
//! (`pub mod frame_geometry;` sans `cfg`, comme `regions.rs` juste à côté).
//!
//! # Pourquoi ce module existe
//!
//! Ce code vivait dans `compositor_windows.rs`. Le port macOS a besoin des mêmes
//! placements au pixel près — c'est la propriété « iso-render » que le projet
//! mesure — et la seule façon de garantir que deux backends s'accordent est qu'ils
//! lisent la même fonction, pas qu'ils entretiennent deux copies qui doivent rester
//! d'accord. C'est le même raisonnement que `timeline_walk.rs`.
//!
//! Effet de bord immédiat : cette géométrie et ses tests, qui n'avaient jamais été
//! exécutés ailleurs que sur Windows, tournent maintenant aussi dans le job macOS.
// Sur macOS, la moitié de ce module est encore sans consommateur : le moteur Metal
// n'a pas de `compose_frame` en couches, donc rien n'appelle encore `screen_source_rect`,
// `cover_uv_rect`, les fractions d'ombre ou `CursorPlacement`. Ce n'est PAS du code mort —
// c'est du code que le port n'a pas encore atteint, et il est exercé par ses tests sur les
// deux plateformes. Le `allow` saute quand le pilotage des couches arrive côté Metal.
#![allow(dead_code)]
use crate::config::Cfg;
use crate::scene::{Scene, SceneCrop};
/// 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 `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/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`. 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 {
pub dst: [f32; 4],
pub src: [f32; 4],
pub quad_px: [f32; 2],
pub radius_px: f32,
pub mode: f32,
pub color: [f32; 4],
pub fx: [f32; 4],
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.
/// Mode 18 incliné : les mêmes coins d'avant, en fractions de la sortie (`screen_trail_cb`).
pub trail_a: [f32; 4],
pub trail_b: [f32; 4],
pub trail_mb: [f32; 4],
}
impl LayerCB {
/// Le calque est l'un des modèles 3D — le curseur modelé (mode 15), l'impact de son clic
/// (16), l'appareil et son ombre (17) — ou le verre à plat de Glass Lens (19), qui en reprend
/// les formes : seule la variante « modèles » du shader de calque les compile. Dans le même
/// shader que les autres, leurs branches fixaient l'occupation de TOUS les calques (168 VGPR
/// sur RADV) ; les trois backends décident donc du shader d'un calque par ce test, au moment de
/// le dessiner (cf. le haut de `vk_shaders/layer.wgsl`).
pub fn needs_models(&self) -> bool {
(self.mode > 14.5 && self.mode < 17.5) || self.mode > 18.5
}
}
pub const OUT_W: u32 = 1920;
pub const OUT_H: u32 = 1080;
/// Parse une couleur "#rgb" / "#rrggbb" (sRGB, comme les wallpapers web) → [r,g,b,a] 0..1.
/// Les couleurs plates suivent le même chemin que `bg_color` (pas de linéarisation).
/// Décode une data URL base64 (`data:image/png;base64,AAAA…`) en octets. `None` si ce n'en est
/// pas une — l'appelant retombe alors sur une lecture disque.
///
/// Écrit à la main plutôt qu'avec une dépendance : c'est le seul usage de base64 du projet, et le
/// décodeur tient en quinze lignes vérifiables. Les caractères hors alphabet (retours à la ligne
/// d'un URI replié, `=` de padding) sont ignorés, ce qui rend la fonction tolérante sans être
/// laxiste : un caractère invalide ne peut pas décaler le flux, il est simplement absent.
pub(crate) fn decode_data_uri(uri: &str) -> Option<Vec<u8>> {
let rest = uri.strip_prefix("data:")?;
let comma = rest.find(',')?;
if !rest[..comma].contains("base64") {
return None;
}
let payload = &rest[comma + 1..];
let sextet = |c: u8| -> Option<u32> {
match c {
b'A'..=b'Z' => Some((c - b'A') as u32),
b'a'..=b'z' => Some((c - b'a') as u32 + 26),
b'0'..=b'9' => Some((c - b'0') as u32 + 52),
b'+' => Some(62),
b'/' => Some(63),
_ => None,
}
};
let mut out = Vec::with_capacity(payload.len() / 4 * 3);
let (mut acc, mut bits) = (0u32, 0u32);
for byte in payload.bytes() {
let Some(v) = sextet(byte) else { continue };
acc = (acc << 6) | v;
bits += 6;
if bits >= 8 {
bits -= 8;
out.push((acc >> bits) as u8);
}
}
Some(out)
}
pub(crate) fn parse_hex(s: &str) -> Option<[f32; 4]> {
// Le contrat accepte du CSS, pas seulement de l'hex : la bridge des captions produit du
// `rgba(r, g, b, a)` (l'inspector stocke couleur + opacité séparément, et `captionBackgroundCss`
// les recombine en rgba pour la preview) et les stops de gradient arrivent aussi sous cette
// forme. `transparent` est un cas particulier documenté : alpha 0, pas de plaque. Tout le
// reste tombe sur None → l'appelant applique son fallback (alpha 0 pour un fond, alpha 1
// pour un texte, etc.) — la même sémantique qu'avant l'ajout du parseur rgba.
let trimmed = s.trim();
if trimmed.eq_ignore_ascii_case("transparent") {
return Some([0.0, 0.0, 0.0, 0.0]);
}
// CSS Color 4 fait de `rgb()` et `rgba()` des synonymes : les deux acceptent 3 ou 4
// composantes. On les traite donc par le même chemin plutôt que d'imposer une arité par
// nom — refuser `rgba(0, 0, 0)` ne « signalerait » rien d'utile, ça retomberait sur le
// fallback de l'appelant, c'est-à-dire une plaque invisible : exactement le bug #178.
if let Some(inner) =
strip_color_fn(trimmed, "rgba").or_else(|| strip_color_fn(trimmed, "rgb"))
{
return parse_rgb_components(inner);
}
let h = trimmed.trim_start_matches('#');
// Un corps hex est ASCII par définition, et les découpes par octet ci-dessous (`h[i..=i]`,
// `h[0..2]`…) paniqueraient au milieu d'un caractère multi-octets qui ferait pile 3 ou 6
// octets (`éa`, `€€`). On refuse avant de découper.
if !h.is_ascii() {
return None;
}
let (r, g, b) = match h.len() {
3 => {
let d = |i: usize| u8::from_str_radix(&h[i..=i], 16).ok().map(|v| v * 17);
(d(0)?, d(1)?, d(2)?)
}
6 => (
u8::from_str_radix(&h[0..2], 16).ok()?,
u8::from_str_radix(&h[2..4], 16).ok()?,
u8::from_str_radix(&h[4..6], 16).ok()?,
),
_ => return None,
};
Some([r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0, 1.0])
}
/// `rgba(0, 0, 0, 0.55)` → `"0, 0, 0, 0.55"` (le contenu entre les parenthèses), None si
/// l'enveloppe n'est pas de la forme `fn(...)`. Tolère les espaces et les tabs, refuse les
/// virgules finales et les arguments vides — le gradient parser a déjà démontré que la couche
/// application produit des chaînes propres, donc rester strict ici évite d'avaler des CSS
/// tordus qu'on ne maîtrise pas. La casse du préfixe est libre (`RGBA(...)` est valide) parce
/// que CSS le permet.
pub(crate) fn strip_color_fn<'a>(s: &'a str, name: &str) -> Option<&'a str> {
// `get` rend None si `name.len()` n'est pas une frontière de caractère : c'est ce qui rend
// le slice `s[..name.len()]` juste en dessous sûr par construction. Un `&s[..n]` direct
// paniquerait au milieu d'un caractère multi-octets (`#ab€cd` coupe dans le `€`), et une
// panique traverserait le pont N-API au lieu de retomber sur le fallback de l'appelant —
// le contraire de ce que ce parseur promet.
let after_name = s.get(name.len()..)?;
if !s[..name.len()].eq_ignore_ascii_case(name) {
return None;
}
let inner = after_name.strip_prefix('(')?.strip_suffix(')')?.trim();
if inner.is_empty() {
return None;
}
Some(inner)
}
/// `"r, g, b"` ou `"r, g, b, a"` (floats 0..255 pour r/g/b, 0..1 pour a) → `[r, g, b, a]` en
/// 0..1, l'alpha valant 1 (opaque) quand elle est absente. Toute autre arité → None. Tolère
/// les espaces autour des virgules, pas les pourcentages : le gradient parser n'envoie pas de
/// `rgb(50%, …)` et les couches UI qui le font n'arrivent pas ici (les couleurs wallpaper
/// passent par une autre route, cf. `parseWallpaper`).
pub(crate) fn parse_rgb_components(s: &str) -> Option<[f32; 4]> {
let parts: Vec<&str> = s.split(',').map(str::trim).collect();
let (rgb, alpha) = match parts.as_slice() {
[r, g, b] => ([r, g, b], 1.0),
// L'alpha est déjà sur [0..1] par convention (`rgba(...,0.55)`, pas `rgba(...,55)`).
[r, g, b, a] => ([r, g, b], parse_color_channel(a, 1.0)?),
_ => return None,
};
Some([
parse_color_channel(rgb[0], 255.0)?,
parse_color_channel(rgb[1], 255.0)?,
parse_color_channel(rgb[2], 255.0)?,
alpha,
])
}
pub(crate) fn parse_color_channel(raw: &str, max: f32) -> Option<f32> {
let n: f32 = raw.parse().ok()?;
if !n.is_finite() || n < 0.0 || n > max {
return None;
}
Some(n / max)
}
/// Le recadrage `[x0, y0, x1, y1]` en fractions de la source (repère normalisé du curseur),
/// l'image entière quand il est absent ou invalide.
fn normalized_crop(crop: Option<SceneCrop>) -> [f32; 4] {
crop.and_then(|crop| {
if !crop.x.is_finite() || !crop.y.is_finite()
|| !crop.width.is_finite() || !crop.height.is_finite()
{
return None;
}
let x0 = crop.x.clamp(0.0, 1.0);
let y0 = crop.y.clamp(0.0, 1.0);
let x1 = (crop.x + crop.width).clamp(x0, 1.0);
let y1 = (crop.y + crop.height).clamp(y0, 1.0);
(x1 > x0 && y1 > y0).then_some([x0, y0, x1, y1])
})
.unwrap_or([0.0, 0.0, 1.0, 1.0])
}
/// Rect source après crop puis zoom, dans les UV de la texture D3D. `u_max`/`v_max`
/// excluent le padding NV12 ; le crop reste donc exprimé dans le frame visible (0..1),
/// comme `VirtualPreview.cropVideoStyle`, puis le focus du zoom est remappé dans ce crop.
pub(crate) fn screen_source_rect(
u_max: f32,
v_max: f32,
crop: Option<SceneCrop>,
zoom: f32,
focus: [f32; 2],
) -> [f32; 4] {
let [x0, y0, x1, y1] = normalized_crop(crop);
let (cu0, cv0, cu1, cv1) = (x0 * u_max, y0 * v_max, x1 * u_max, y1 * v_max);
let (cw, ch) = (cu1 - cu0, cv1 - cv0);
let zoom = if zoom.is_finite() && zoom >= 1.0 { zoom } else { 1.0 };
let fx = if focus[0].is_finite() { focus[0].clamp(0.0, 1.0) } else { 0.5 };
let fy = if focus[1].is_finite() { focus[1].clamp(0.0, 1.0) } else { 0.5 };
let (hu, hv) = (cw / (2.0 * zoom), ch / (2.0 * zoom));
// `.max(cu0/cv0)` absorbs the tiny float inversion possible at zoom=1.
let su0 = (cu0 + fx * cw - hu).clamp(cu0, (cu1 - 2.0 * hu).max(cu0));
let sv0 = (cv0 + fy * ch - hv).clamp(cv0, (cv1 - 2.0 * hv).max(cv0));
[su0, sv0, su0 + 2.0 * hu, sv0 + 2.0 * hv]
}
/// Rect DESTINATION de l'écran quand on dessine une coupe source PLUS LARGE que celle qui
/// remplissait la boîte — le cœur du correctif #179.
///
/// Le zoom natif se jouait entièrement dans la coupe source (`screen_source_rect` rétrécit
/// la coupe autour du focus) pendant que la boîte, elle, ne bougeait pas : le zoom
/// s'arrêtait donc à la frontière paddée au lieu d'atteindre les bords du cadre. La
/// référence fait l'inverse — `applyZoomTransform` (TS) met à l'échelle et translate le
/// CONTENEUR CAMÉRA, masque compris, donc la boîte paddée grandit avec le zoom, sort de
/// l'étage, et le padding s'efface.
///
/// On rend donc le zoom à la boîte : la coupe dessinée redevient le simple crop
/// (`cut`, zoom 1) et c'est la boîte qui porte le grossissement. `cut_ref` est la coupe
/// d'AVANT (zoom entier, celle qui remplissait `base`) et sert de référence : on reporte
/// `cut` à travers le mapping `cut_ref → base`.
///
/// C'est ce report qui fait toute la sûreté du correctif. Le mapping image→écran est
/// conservé PAR CONSTRUCTION — même grossissement, même cadrage, même point de focus au
/// même pixel — quel que soit le crop, le clamp de bord ou le `cover`, puisque tout cela
/// est déjà cuit dans les deux coupes. Seule l'ÉTENDUE dessinée grandit, et c'est
/// exactement elle qui déborde le padding. Tout ce qui roule sur ce mapping (curseur,
/// tilt 3D, motion blur) est donc inchangé.
///
/// Pas de clamp dans le cadre : la boîte doit pouvoir en sortir (« No stage clamping »,
/// `frameRenderer.cameraAwareMaskRect`) — le rasterizer coupe ce qui dépasse, comme il le
/// fait déjà pour le fond flouté.
pub(crate) fn remap_box(base: [f32; 4], cut_ref: [f32; 4], cut: [f32; 4]) -> [f32; 4] {
let (rw, rh) = ((cut_ref[2] - cut_ref[0]), (cut_ref[3] - cut_ref[1]));
if !(rw > 1e-6 && rh > 1e-6) {
return base;
}
[
base[0] + base[2] * (cut[0] - cut_ref[0]) / rw,
base[1] + base[3] * (cut[1] - cut_ref[1]) / rh,
base[2] * (cut[2] - cut[0]) / rw,
base[3] * (cut[3] - cut[1]) / rh,
]
}
/// Où tombe le point de focus du zoom dans la coupe DESSINÉE `cut`, en 0..1 de cette coupe.
///
/// `focus` est exprimé dans le crop utilisateur (la convention de `screen_source_rect`), pas
/// dans `cut` : les deux diffèrent dès qu'un crop ou un cover s'en mêle. Le zoom, lui, ne compte
/// pas : la coupe dessinée est prise à zoom 1 (issue #179). Et le centre de la coupe zoomée
/// n'est pas le focus dès qu'elle bute sur un bord, d'où le report du point lui-même, sans
/// jamais supposer (0.5, 0.5).
pub(crate) fn focus_in_cut(
u_max: f32,
v_max: f32,
crop: Option<SceneCrop>,
focus: [f32; 2],
cut: [f32; 4],
) -> [f32; 2] {
// Zoom 1 : la coupe est le crop entier, quel que soit le focus.
let [cu0, cv0, cu1, cv1] = screen_source_rect(u_max, v_max, crop, 1.0, [0.5, 0.5]);
let f = |v: f32| if v.is_finite() { v.clamp(0.0, 1.0) } else { 0.5 };
let (u, v) = (cu0 + f(focus[0]) * (cu1 - cu0), cv0 + f(focus[1]) * (cv1 - cv0));
let local = |x: f32, a: f32, b: f32| if b - a > 1e-6 { ((x - a) / (b - a)).clamp(0.0, 1.0) } else { 0.5 };
[local(u, cut[0], cut[2]), local(v, cut[1], cut[3])]
}
/// Sous-rect SOURCE (en UV de texture) qui remplit une boîte de ratio `box_ar` **sans
/// déformer** l'image : le plus grand rect centré ayant ce ratio, tiré de la frame
/// visible — l'équivalent de `object-fit: cover` côté web.
///
/// C'est LA primitive qui garantit qu'une couche vidéo n'est jamais étirée. Le
/// contrat est déplacé de l'appelant (« donne-moi un dst au ratio de la source »,
/// hypothèse qu'un preset pouvait violer en silence) vers le calcul lui-même
/// (« quel que soit le dst, je choisis la coupe qui l'habille »).
///
/// * `visible` : dimensions RÉELLES de l'image dans la texture (`AVFrame::width/height`) ;
/// elles peuvent être plus petites que la texture, qui est allouée avec du padding
/// décodeur — d'où la division finale par `tex`.
/// * `tex` : dimensions de la texture, pour normaliser en UV.
/// * `box_ar` : ratio largeur/hauteur de la boîte de destination, en pixels de rendu.
///
/// Retourne `(u0, v0, u1, v1)`. Quand la boîte a déjà le ratio de la source, la coupe
/// est la frame entière — donc aucun changement de pixel sur les placements qui étaient
/// déjà corrects.
pub(crate) fn cover_crop_uv(visible: [f32; 2], tex: [f32; 2], box_ar: f32) -> (f32, f32, f32, f32) {
let (cam_w, cam_h) = (visible[0].max(1.0), visible[1].max(1.0));
let (tex_w, tex_h) = (tex[0].max(1.0), tex[1].max(1.0));
let full = [0.0, 0.0, cam_w / tex_w, cam_h / tex_h];
let [u0, v0, u1, v1] = cover_uv_rect(full, tex, box_ar);
(u0, v0, u1, v1)
}
/// Camera equivalent of the screen crop pipeline: apply the user crop first, then a centred
/// cover-crop inside that authored window so arbitrary layout slots never stretch the image.
pub(crate) fn webcam_source_rect(
visible: [f32; 2],
tex: [f32; 2],
crop: Option<SceneCrop>,
box_ar: f32,
) -> [f32; 4] {
let u_max = visible[0].max(1.0) / tex[0].max(1.0);
let v_max = visible[1].max(1.0) / tex[1].max(1.0);
cover_uv_rect(
screen_source_rect(u_max, v_max, crop, 1.0, [0.5, 0.5]),
tex,
box_ar,
)
}
/// Rétrécit un rect SOURCE déjà exprimé en UV (`[u0, v0, u1, v1]`) autour de son
/// centre pour qu'il porte le ratio `box_ar` une fois rapporté aux pixels de la
/// texture. C'est la forme générale de `object-fit: cover`, et LA primitive qui
/// garantit qu'une couche vidéo n'est jamais étirée.
///
/// Deux appelants, deux points d'entrée dans le rect :
/// - la **webcam** part de la frame visible entière (`cover_crop_uv`) ;
/// - l'**écran** part du rect déjà réduit par le crop utilisateur ET le zoom,
/// et n'applique ce cover que dans les layouts qui le demandent
/// (`Scene.layout.screen_cover` — les blocs side-by-side / top-bottom, où le
/// web fait exactement la même chose via `screenCover`).
///
/// Rogner APRÈS le crop et le zoom est ce qui rend l'opération composable : le
/// crop décide quoi montrer, le zoom où regarder, le cover comment habiller la
/// boîte. Chacun réduit le rect précédent, jamais ne le déforme.
///
/// Quand le rect a déjà le ratio de la boîte, il est renvoyé inchangé — donc
/// aucun placement déjà correct ne bouge.
pub(crate) fn cover_uv_rect(uv: [f32; 4], tex: [f32; 2], box_ar: f32) -> [f32; 4] {
let (tex_w, tex_h) = (tex[0].max(1.0), tex[1].max(1.0));
let (w_uv, h_uv) = ((uv[2] - uv[0]).max(1e-6), (uv[3] - uv[1]).max(1e-6));
// ratio du rect courant, en PIXELS (les UV sont anisotropes dès que la
// texture n'est pas carrée — d'où le passage par `tex`).
let (w_px, h_px) = (w_uv * tex_w, h_uv * tex_h);
let cur_ar = w_px / h_px;
let box_ar = if box_ar.is_finite() && box_ar > 0.0 { box_ar } else { cur_ar };
let (new_w_px, new_h_px) = if box_ar >= cur_ar {
(w_px, w_px / box_ar) // boîte plus large → pleine largeur, on rogne en hauteur
} else {
(h_px * box_ar, h_px) // boîte plus haute → pleine hauteur, on rogne en largeur
};
let (new_w, new_h) = (new_w_px / tex_w, new_h_px / tex_h);
let (cx, cy) = (uv[0] + w_uv * 0.5, uv[1] + h_uv * 0.5);
[cx - new_w * 0.5, cy - new_h * 0.5, cx + new_w * 0.5, cy + new_h * 0.5]
}
/// `cover_uv_rect`, la fenêtre centrée sur `at` (UV) au lieu du centre de `uv`, et bornée à `uv` :
/// le remplissage du format, qui suit le curseur lissé dans l'enregistrement. Même taille que la
/// fenêtre centrée, donc même grossissement ; seule sa position change.
pub(crate) fn follow_cover_uv_rect(
uv: [f32; 4],
tex: [f32; 2],
box_ar: f32,
at: [f32; 2],
) -> [f32; 4] {
let c = cover_uv_rect(uv, tex, box_ar);
let (hw, hh) = (0.5 * (c[2] - c[0]), 0.5 * (c[3] - c[1]));
// `max` puis `min`, pas `clamp` : à la précision flottante près la fenêtre peut dépasser `uv`
// d'un epsilon, et `clamp` panique quand sa borne basse passe la haute.
let cx = at[0].max(uv[0] + hw).min(uv[2] - hw);
let cy = at[1].max(uv[1] + hh).min(uv[3] - hh);
[cx - hw, cy - hh, cx + hw, cy + hh]
}
pub const HALF_W: u32 = OUT_W / 2;
pub const HALF_H: u32 = OUT_H / 2;
pub const FIXTURE_FRAMES: u32 = 360;
pub(crate) const FPS: f32 = 60.0;
/// La profondeur de champ tourne-t-elle sur le backend CPU (WARP, lavapipe) ? Le seul drapeau
/// partagé qui la coupe là-bas si son coût y devient prohibitif (seuil fixé par la spec :
/// 10 ms/frame). Mesuré (`tests/tilted_depth_of_field.rs`, 1080p iso, trois passes) : WARP
/// +3.8 / +6.3 / +12.2 ms/frame, soit +35 à +45 % ; le matériel +0.04 à +0.08 ms/frame. Médiane
/// sous le seuil : l'effet reste allumé partout, ce drapeau est le levier si ça change.
pub const DOF_ON_CPU_BACKEND: bool = true;
/// Niveaux de la pyramide de profondeur de champ (demi-résolution de la texture décodeur, donc
/// son niveau 0 est le niveau 1 d'une pyramide pleine résolution). Le shader plafonne sa lecture
/// à `DOF_MAX_LOD` (1.5) ; les niveaux au-delà laissent la marge de relever ce plafond sans
/// toucher aux trois backends. Jamais plus que la chaîne complète d'une très petite source.
pub fn dof_pyramid_levels(w: u32, h: u32) -> u32 {
const DOF_PYRAMID_LEVELS: u32 = 5;
DOF_PYRAMID_LEVELS.min(32 - w.max(h).max(1).leading_zeros())
}
/// Flou du fond : force 0..1 → (niveaux de la pyramide dual-Kawase, écart par passe), `None`
/// à 0. Le rayon d'un dual-Kawase croît comme `2^niveaux × écart` : on vise un rayon
/// proportionnel à la force et on prend le moins de niveaux qui l'atteint sans écarter les taps
/// au point de dédoubler l'image. 0,5 retombe exactement sur l'ancien interrupteur « Blur BG »
/// (3 niveaux, écart 2,2). Les trois backends lisent ceci, ils floutent donc pareil.
pub fn background_blur_steps(amount: f32) -> Option<(usize, f32)> {
const RADIUS_AT_FULL: f32 = 2.0 * 8.0 * 2.2;
if !(amount > 0.001) {
return None;
}
let radius = amount.min(1.0) * RADIUS_AT_FULL;
let levels: usize = if radius <= 4.0 {
1
} else if radius <= 12.0 {
2
} else {
3
};
Some((levels, radius / (1 << levels) as f32))
}
/// Longueurs de style exprimées en FRACTION du petit côté du cadre, et non en pixels.
///
/// Elles étaient écrites en px bruts au point d'appel, ce qui voulait dire « px du render
/// target » — donc une proportion DIFFÉRENTE selon la taille de rendu : 40 px, c'est 3,7 % d'un
/// cadre 1080 mais 1,9 % d'un 2160. L'ombre était donc deux fois plus douce en preview qu'à
/// l'export, et un export 4K la recevait deux fois plus faible qu'un 1080p — même famille de bug
/// que les rayons venus de l'app, mais née à l'intérieur du natif. Les valeurs ci-dessous sont
/// les anciennes constantes rapportées au cadre 1080 contre lequel elles avaient été réglées :
/// le rendu à cette résolution est donc inchangé, et devient enfin identique partout ailleurs.
pub(crate) const SHADOW_TUNING_REF_PX: f32 = 1080.0;
pub(crate) const SCREEN_SHADOW_SPREAD_FRAC: f32 = 40.0 / SHADOW_TUNING_REF_PX;
pub(crate) const SCREEN_SHADOW_OFFSET_FRAC: f32 = 16.0 / SHADOW_TUNING_REF_PX;
pub(crate) const WEBCAM_SHADOW_SPREAD_FRAC: f32 = 32.0 / SHADOW_TUNING_REF_PX;
pub(crate) const WEBCAM_SHADOW_OFFSET_FRAC: f32 = 12.0 / SHADOW_TUNING_REF_PX;
/// Opacité FIXE de l'ombre portée de la caméra (layout PiP uniquement). Contrairement à
/// l'ombre de l'écran — dont l'opacité est pilotée par le slider Shadow (`shadow_scale`) —
/// l'ombre de la caméra est une ombre légère NON paramétrable : même valeur quelle que soit
/// la position du slider. Parité avec le preset PiP côté web (`compositeLayout.ts`,
/// `rgba(0,0,0,0.35)`), dont l'ombre est elle aussi un forfait fixe et PiP-only.
pub(crate) const WEBCAM_SHADOW_OPACITY: f32 = 0.35;
/// Taille de base du curseur, même convention (34 px réglés contre un cadre 1080).
pub(crate) const CURSOR_BASE_SIZE_FRAC: f32 = 34.0 / SHADOW_TUNING_REF_PX;
// ============ L'unité du cadre ============
//
// UNE longueur par boîte, la même sur x, y et z : tout ce qu'un cadre dessine s'y mesure — barre et
// filet de la fenêtre, lunettes, liseré, épaisseurs, rayons, socle et pied des appareils. Elle
// était autrefois la LARGEUR de la boîte écran pour les appareils et son PETIT CÔTÉ pour la fenêtre :
// autour d'un clip portrait, la largeur tombe au tiers de celle d'un clip paysage dans la même
// sortie, et la lunette avec elle. Le même cadre changeait d'épaisseur avec le ratio du clip.
/// L'UNITÉ DU CADRE `u`, en px de la boîte droite `s_px` (zoom compris) rendue dans `render_px`.
///
/// Le petit côté de la sortie, mis à l'échelle de la part de la sortie que la boîte occupe dans
/// sa dimension la plus remplie : `max(s_w / r_w, s_h / r_h) · min(r_w, r_h)`. Un clip est
/// contenu dans la zone paddée et la touche dans une dimension, quel que soit son ratio : `u`
/// vaut donc le petit côté de cette zone pour un clip 16:9, 9:16, 1:1, 4:3 ou 21:9, et le cadre
/// a la même épaisseur autour de chacun — seule l'ouverture change de forme. Elle suit le padding
/// et grandit avec le zoom comme la boîte ; et, quand la sortie a le ratio du clip, elle vaut le
/// petit côté de la boîte, la référence contre laquelle les proportions ci-dessous ont été réglées.
pub(crate) fn frame_unit_px(s_px: [f32; 2], render_px: [f32; 2]) -> f32 {
let [rw, rh] = render_px.map(|v| v.max(1.0));
(s_px[0] / rw).max(s_px[1] / rh) * rw.min(rh)
}
/// Hauteur de la barre de titre du cadre de fenêtre, en unités du cadre (`frame_unit_px`) :
/// environ 35 px sur une boîte de 864 px (1080p, padding 50 %), la proportion d'une barre de
/// titre de bureau à cette échelle.
pub(crate) const WINDOW_FRAME_BAR_FRAC: f32 = 0.04;
/// Épaisseur du filet qui borde le cadre, même unité : environ un pixel sur la même boîte.
/// Pas de plancher en px — il rendrait le filet plus épais, en proportion, dans la petite
/// preview qu'à l'export ; le shader l'estompe plutôt que de le faire disparaître.
pub(crate) const WINDOW_FRAME_LINE_FRAC: f32 = 0.0012;
/// Le cadre posé autour de l'écran (`effects.frame`) : chrome de fenêtre plat (mode 14) ou
/// appareil modelé en 3D (mode 17).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct WindowFrame {
/// Lequel des cadres. `SceneFrame::None` n'arrive jamais ici (pas de cadre = pas de
/// `WindowFrame`).
pub kind: crate::scene::SceneFrame,
pub dark: bool,
/// Marges du CORPS du cadre autour de `s_dst`, en FRACTION de cette boîte : gauche, haut,
/// droite, bas (pour le chrome de fenêtre, le haut est la barre de titre et les trois autres
/// le filet ; pour un appareil, sa lunette). Des fractions et non des px :
/// `remap_box` agrandit la boîte sous un zoom (#179) et le cadre doit grandir avec elle. Ce
/// sont aussi, prises en négatif ou au-delà de 1, les coordonnées du plan où
/// `TiltedQuad::point_px` extrapole les coins du cadre sous un préset 3D. En px, ce sont des
/// multiples de l'unité du cadre : la même bordure sur x et sur y.
pub margins: [f32; 4],
/// Rayons extérieurs du CORPS, coins HAUTS puis coins BAS, en px de la boîte droite :
/// `concentric_radius` du rayon du métrage et des deux bordures qui s'y rejoignent. Les deux
/// sont égaux pour la fenêtre (son mode 14 n'a qu'un rayon), le téléphone et le moniteur.
pub radius: [f32; 2],
}
/// Le rayon extérieur d'un coin de corps CONCENTRIQUE à un coin intérieur de rayon `r`, sous les
/// bordures `bx` (le côté) et `by` (le haut ou le bas) qui s'y rejoignent, px.
///
/// LA fonction qui relie le contour intérieur (le métrage, l'ouverture) au contour extérieur (le
/// corps) : les deux arcs ont le même centre, et la bordure garde son épaisseur tout autour du
/// coin. `r + b` quand les deux bordures sont égales — le seul cas où deux arcs de cercle peuvent
/// être exactement concentriques. Quand elles diffèrent (le bas du portable, 0,0409 contre
/// 0,0356 + liseré), leur moyenne : le décalage des deux centres est alors perpendiculaire à la
/// diagonale du coin, et l'épaisseur y vaut la moyenne des deux bordures à 0,15 px près.
///
/// Elle vaut pour la fenêtre et le téléphone, dont le corps suit le slider. Le portable et le
/// moniteur n'y passent pas : leur coque garde ses rayons industriels (`device_shell_radius`) et
/// seul l'intérieur de la lunette s'arrondit — la lunette s'y épaissit donc au coin quand le
/// slider monte, comme sur les produits dont ils s'inspirent.
pub(crate) fn concentric_radius(r: f32, bx: f32, by: f32) -> f32 {
r.max(0.0) + 0.5 * (bx + by)
}
/// Position du slider Roundness sur sa course, 0..1, lue dans la scène : `roundnessFrac` est la
/// valeur du slider (px) sur la référence FIXE de 1080 px (`sceneDescription.ts`), et non plus
/// sur le petit côté de la sortie — qui suit la source, si bien qu'une prise 4K recevait des
/// coins deux fois moins ronds qu'une prise 1080p. `ROUNDNESS_SLIDER_MAX_PX` est le miroir du
/// maximum du slider (`paramUnits.ts`).
pub(crate) const ROUNDNESS_SLIDER_MAX_PX: f32 = 64.0;
pub(crate) fn roundness_slider_position(scene: &crate::scene::Scene) -> f32 {
(scene.effects.roundness_frac * SHADOW_TUNING_REF_PX / ROUNDNESS_SLIDER_MAX_PX).clamp(0.0, 1.0)
}
/// L'UNITÉ DE L'ÉCRAN, px : le petit côté du cadre qu'aurait cet écran dans une sortie à SON ratio.
///
/// `content_px` est l'enregistrement affiché au repos (crop compris, zoom exclu, en entier même
/// quand un slot en `cover` en rogne une partie). Divisé par `padding_scale`, il vaut exactement le
/// petit côté du cadre (`frame_min_px`) quand la sortie a le ratio de l'enregistrement — Auto, ou
/// un format fixe qui lui correspond : le rendu y est inchangé. Quand le format diffère (un clip
/// 16:9 dans une sortie 9:16), l'écran n'occupe plus qu'une bande du cadre et l'unité rétrécit
/// avec lui : le curseur, l'ombre et les coins gardent leur proportion À L'ÉCRAN au lieu de
/// grossir de 1,8× à côté de lui.
///
/// Ce n'est pas `frame_unit_px` : celle-ci est faite pour qu'un cadre d'appareil ait la même
/// épaisseur autour de n'importe quel clip d'une sortie, donc elle vaut `frame_min_px ×
/// padding_scale` pour tout clip contenu dans la zone paddée — y compris la bande 16:9 d'une
/// sortie 9:16, où elle ne corrigerait rien.
pub(crate) fn screen_unit_px(content_px: [f32; 2], padding_scale: f32) -> f32 {
content_px[0].min(content_px[1]) / padding_scale.max(1e-3)
}
/// Le rayon des coins du métrage au BOUT de la course de Roundness sous chaque cadre, en unités
/// du cadre. Sous un cadre, le slider parcourt 0 → ce plafond : chaque position est belle pour
/// chaque cadre et chaque ratio, et un rendu laid n'est plus atteignable. Sans cadre, rien ne
/// change (`plan_frame`).
///
/// Réglés sur des objets réels :
/// - **fenêtre** : 0,035 u de métrage (+ le filet) garde le contour SOUS la hauteur de la barre
/// (0,04 u) : l'arc reste dans le chrome, les pastilles s'en écartent (leur premier centre est repoussé au-delà de l'arc, mode 14), et
/// les coins HAUTS du métrage restent carrés sous la barre — rien de ce qu'ils montrent (le
/// logo d'une app, ses menus) n'est rogné. En deçà, la course était invisible ;
/// - **portable, moniteur** : seule l'OUVERTURE suit le slider, la coque garde son rayon
/// industriel (`device_shell_radius`). 0,04 u : une course qui se voit, du coin vif à un coin
/// d'écran franchement arrondi, sans jamais atteindre celui d'un téléphone ;
/// - **téléphone** : de grands coins, ceux d'un téléphone moderne (14 % de sa largeur, debout
/// dans une sortie 16:9), concentriques au corps.
pub(crate) fn frame_roundness_cap(kind: crate::scene::SceneFrame) -> f32 {
use crate::scene::SceneFrame as F;
match kind {
F::Window | F::WindowLight | F::WindowDark => 0.035,
F::Laptop | F::Monitor => 0.04,
F::Phone => 0.08,
F::None => 0.0,
}
}
/// Rayons FIXES de la coque du portable et du moniteur, coins HAUTS puis coins BAS, en unités du
/// cadre ; `None` pour les cadres dont le corps suit le slider (fenêtre, téléphone), concentrique
/// au métrage (`concentric_radius`).
///
/// Sur ces deux appareils, seul l'intérieur de la lunette s'arrondit avec le slider : la coque
/// d'un produit ne change pas de forme parce que son écran arrondit ses coins. Rayons des
/// produits de référence vus de face : portable, 2,5 % de la largeur du capot en haut et 0,4 %
/// en bas, là où il rejoint la charnière ; moniteur, 0,6 %. Rapportés au petit côté d'un écran
/// 16:9 (le capot y fait ~1,85 u de large, le moniteur ~1,81 u).
pub(crate) fn device_shell_radius(kind: crate::scene::SceneFrame) -> Option<[f32; 2]> {
use crate::scene::SceneFrame as F;
match kind {
F::Laptop => Some([0.046, 0.0074]),
F::Monitor => Some([0.0109, 0.0109]),
_ => None,
}
}
// ============ Appareils modelés (mode 17) : proportions ============
//
// Toutes les longueurs sont en UNITÉS DU CADRE (`frame_unit_px`), et sont le miroir exact des
// constantes `DEV_*` des trois shaders : le repère du modèle a cette unité. Les maquettes de
// référence (`design-pr0/Frame*.dc.html`) donnent le style ; les proportions, elles, viennent des
// appareils réels, rapportées au petit côté d'un écran 16:9 (portable, moniteur) — qui vaut
// alors 1 — ou à la largeur d'un téléphone debout (1,78 fois moins : ses lunettes sont fines).
// Aucune ne dépend du ratio du clip : un portable autour d'un clip portrait a les lunettes, le
// liseré, l'épaisseur et le socle du portable autour d'un clip paysage.
/// Marges du CORPS de chaque appareil : gauche, haut, droite, bas, en unités du cadre.
/// Chacune est une lunette de verre NOIR, plus le liseré d'aluminium qui la borde (`DEV_RIM`).
///
/// Fines et uniformes, d'après les produits de référence vus de face : le portable a 3,6 % de
/// verre noir sur les côtés et en haut, un rien de plus en bas, là où l'écran rejoint la
/// charnière (2 % et 2,3 % de la largeur d'un écran 16:9) ; le moniteur moitié moins ; le
/// téléphone un anneau de 1,4 %. Une lunette grasse, et plus encore un menton, est ce qui date un
/// appareil et le fait lire comme un jouet.
pub(crate) fn device_body_margins(kind: crate::scene::SceneFrame) -> [f32; 4] {
use crate::scene::SceneFrame as F;
let [s, b] = match kind {
// Lunette de l'écran du portable seule : le socle sort du plan.
F::Laptop => [DEV_BEZEL_LAPTOP, DEV_BEZEL_LAPTOP_BOTTOM],
F::Phone => [DEV_BEZEL_PHONE; 2],
F::Monitor => [DEV_BEZEL_MONITOR; 2],
_ => return [0.0; 4],
};
[s + DEV_RIM, s + DEV_RIM, s + DEV_RIM, b + DEV_RIM]
}
/// Verre noir de la lunette du portable, en unités du cadre : côtés et haut, puis bas.
pub(crate) const DEV_BEZEL_LAPTOP: f32 = 0.0356;
pub(crate) const DEV_BEZEL_LAPTOP_BOTTOM: f32 = 0.0409;
/// Verre noir de la lunette du moniteur, le même sur les quatre côtés.
pub(crate) const DEV_BEZEL_MONITOR: f32 = 0.0178;
/// Verre noir de l'anneau du téléphone, le même sur les quatre côtés.
pub(crate) const DEV_BEZEL_PHONE: f32 = 0.014;
/// Le liseré d'aluminium qui borde la face avant, en unités du cadre : quelques pixels, qui
/// suivent le contour du corps. Mêmes valeurs dans les shaders (`DEV_RIM`).
pub(crate) const DEV_RIM: f32 = 0.0053;
/// Angle du socle du portable DEPUIS LE PLAN DE L'ÉCRAN, en radians, pour un écran de
/// demi-taille `half` (unités du cadre) sous une lunette `chin` et un corps d'épaisseur `thick`.
///
/// **On résout par l'ORIENTATION, pas par la taille.** Le socle a sa profondeur réelle
/// (`DEV_DECK_LEN`) ; ce qui le rend discret à plat, c'est son angle. On choisit la charnière pour
/// que le PLAN du socle passe à `DEV_DECK_EYE_CLEARANCE` sous l'œil de la caméra droite : le socle
/// est vu presque par la tranche, et se projette en un fil sous l'écran qui laisse juste deviner le
/// clavier. Le modèle est RIGIDE : le même angle montre le clavier naturellement dès que la caméra
/// tourne (angles fixes, orbite).
///
/// La dérivation : l'œil du MODÈLE est en (0, 0, P) dans le repère du plan, P = max(petit côté ×
/// 1,6, `DEV_EYE_MIN`) (cf. `DeviceView::project`) ; la charnière en (0, h, −thick/2),
/// h = half.y + chin. Le plan du socle, qui contient l'axe x et la charnière, passe par
/// (0, clearance, P) quand l'ouverture écran–socle vaut `atan((P + thick/2) / (h − clearance))` ;
/// l'angle depuis le plan de l'écran en est le supplément.
///
/// **Bornée à [60°, 135°] d'ouverture.** Un œil à hauteur du CENTRE de l'écran ne voit un socle par
/// la tranche que si celui-ci remonte vers lui, donc sous 90° à toute distance finie. Un plancher
/// à 90° montrerait le clavier sur ~13 % de la hauteur de l'écran au lieu d'un fil ; la borne
/// basse retenue laisse passer la tranche pour tous les ratios.
pub(crate) fn device_deck_angle(half: [f32; 2], chin: f32, thick: f32) -> f32 {
let p = (2.0 * half[0].min(half[1]) * crate::regions::PERSPECTIVE_FACTOR).max(DEV_EYE_MIN);
let h = half[1] + chin;
let opening = ((p + thick * 0.5) / (h - DEV_DECK_EYE_CLEARANCE).max(1e-3))
.atan()
.clamp(DEV_HINGE_MIN_RAD, DEV_HINGE_MAX_RAD);
std::f32::consts::PI - opening
}
/// Épaisseur du corps, en unités du cadre.
///
/// La même quel que soit le ratio du clip : un téléphone qui encadre une vidéo paysage est un
/// téléphone COUCHÉ, pas un téléphone plus gros. Des corps MINCES : le rapport épaisseur/petit
/// côté est ce qui sépare un produit d'un coussin. Un portable et un moniteur sont des dalles ; un
/// téléphone est épais pour sa largeur (un dixième, debout dans une sortie 16:9), et c'est ce qui
/// le fait reconnaître.
pub(crate) fn device_thickness(kind: crate::scene::SceneFrame) -> f32 {
use crate::scene::SceneFrame as F;
match kind {
F::Laptop => 0.0284,
F::Phone => 0.05,
F::Monitor => 0.0284,
_ => 0.0,
}
}
// Le micro-chanfrein des arêtes vit dans les shaders seuls (`DEV_CHAMFER`) : il ne change que la
// matière et le filet de lumière, jamais l'encombrement, donc la boîte calculée ici le majore
// sans avoir à le connaître.
/// Profondeur du socle : celle d'un socle RÉEL (portable 14 pouces, 221 mm pour 312 mm de large,
/// autour d'un écran 16:9), en unités du cadre. Elle n'est pas réduite pour tenir : c'est l'angle
/// (`device_deck_angle`) qui la rend discrète vue de face, et le métrage ne rétrécit pas pour lui
/// faire place. Le socle a la LARGEUR de la coque, qui suit l'ouverture ; tout le reste est fixe.
pub(crate) const DEV_DECK_LEN: f32 = 1.30;
/// De combien le plan du socle passe sous l'œil de la caméra droite, en unités du cadre. Vu de
/// face, le socle d'un portable n'est qu'une barre d'argent sous l'écran — sa tranche avant — et
/// aucun clavier : le dessus reste à un pixel ou deux, tout juste un filet de lumière.
pub(crate) const DEV_DECK_EYE_CLEARANCE: f32 = 0.0178;
/// Bornes de l'ouverture écran–socle (cf. `device_deck_angle`) : 60° et 135°.
pub(crate) const DEV_HINGE_MIN_RAD: f32 = 1.047_198;
pub(crate) const DEV_HINGE_MAX_RAD: f32 = 2.356_194;
/// Épaisseur à la charnière puis au bord avant. Presque une dalle : c'est la tranche avant, vue de
/// face et grossie de ~15 % par la perspective, qui fait la barre d'argent sous l'écran.
pub(crate) const DEV_DECK_THICK: f32 = 0.0446;
pub(crate) const DEV_DECK_THICK_FRONT: f32 = 0.0391;
/// Jeu entre le bas de l'écran et le socle : le trait sombre qui sépare les deux pièces.
pub(crate) const DEV_DECK_GAP: f32 = 0.0093;
/// Pied du moniteur : une colonne LARGE et plate (`DEV_NECK_W` en est la demi-largeur) qui descend
/// de derrière l'écran, à flancs droits, puis une semelle mince et plate aux coins avant arrondis.
/// En unités du cadre : le même pied sous un écran paysage ou pivoté.
pub(crate) const DEV_NECK_W: f32 = 0.255;
pub(crate) const DEV_NECK_LEN: f32 = 0.177;
pub(crate) const DEV_FOOT_W: f32 = 0.456;
pub(crate) const DEV_FOOT_H: f32 = 0.0456;
pub(crate) const DEV_STAND_Z: f32 = 0.0219;
pub(crate) const DEV_FOOT_Z: f32 = 0.195;
/// De combien la lunette MORD sur le métrage, en PIXELS de sortie (le calque le convertit en unités
/// du modèle, `dst_prev.z`).
///
/// Le métrage est opaque jusqu'à son bord et s'estompe AU-DELÀ sur 1,5 px ; la lunette est opaque
/// jusqu'au bord de l'ouverture et s'estompe EN DEÇÀ, sur le métrage. Si les deux bords
/// coïncidaient, les deux fondus se superposeraient sur un anneau à demi transparent, et le fond
/// d'écran y passerait — le liseré clair constaté autour du téléphone. En rentrant l'ouverture
/// d'un pixel et quart dans le métrage, la lunette couvre la frange de celui-ci et fait son propre
/// fondu sur de l'image opaque : aucun pixel de la couture ne voit le fond. Un pixel et quart de
/// métrage est caché, pas plus. En pixels et non en unités : exprimé en unités, le recouvrement
/// fondait à 1,2 px sur un petit écran, sous la somme des deux fondus.
pub(crate) const DEV_OVERLAP_PX: f32 = 1.25;
/// Distance MINIMALE, en unités du cadre, de l'œil qui voit le RELIEF du modèle (`DeviceView::
/// project`, `device_frame` dans les shaders).
///
/// Réglée sur le portable de référence vu de face : la tranche avant du socle, à 1,30 u devant
/// l'écran, y paraît ~15 % plus large que le couvercle — 9,6 / (9,6 − 1,3) ≈ 1,16.
///
/// L'objectif des présets met l'œil à 1,6 petit côté du plan. C'est ce qui fait lire
/// l'inclinaison du métrage, et le plan le garde. Mais un socle de profondeur réelle vient alors à
/// quelques dixièmes de l'œil : sa tranche avant se projette sur toute la largeur de l'image, et
/// sous `iso` le clavier devient plus grand que l'écran. Le relief est donc vu d'un œil reculé ;
/// chaque rayon passe par le même point du plan que celui de l'objectif, si bien que la face écran
/// reste au pixel près sur le métrage.
pub(crate) const DEV_EYE_MIN: f32 = 9.6;
/// Le PLAN PROCHE du modèle, en fraction de la distance de l'œil du modèle (`DEV_EYE_MIN`) :
/// ce qui se tient plus loin que `DEV_NEAR · DEV_EYE_MIN · g` devant l'écran s'efface, `g` étant
/// le travelling de la caméra RÉELLE (sa distance au plan sur celle du repos, cf.
/// `device_near_plane`). Au repos, 1,54 u : au-delà du bord avant du socle (1,30 u), rien ne
/// change. Quand la caméra en orbite avance pour zoomer, le plan proche avance avec elle et le
/// socle s'efface par son bord avant, doucement, sur `DEV_NEAR_BAND` de la distance — jamais
/// une coupe franche qui montrerait sa section.
pub(crate) const DEV_NEAR: f32 = 0.16;
pub(crate) const DEV_NEAR_BAND: f32 = 0.1;
/// La hauteur du plan proche devant l'écran, en unités du cadre, pour une caméra RÉELLE à
/// `camera_dist` (unités du cadre) du point qu'elle vise sur le plan, et un écran de demi-taille
/// `half`. Miroir de `dev_near_plane` dans les trois shaders.
///
/// `g` rapporte cette distance à celle de l'objectif des présets pour la même boîte (1,6 petit
/// côté) : 1 à plat, ≥ 1 sous un angle fixe (le plan y est réduit par son containment), et sous la
/// caméra en orbite `zoom^−0,5` — elle zoome à moitié en avançant —, où qu'elle vise. La caméra
/// réelle elle-même ne peut pas porter le plan proche : au repos, son œil est déjà DANS la
/// profondeur du socle sur un clip large (1,22 u devant un 21:9, le socle en fait 1,30). C'est
/// donc l'œil du modèle qui avance du même travelling qu'elle.
pub(crate) fn device_near_plane(camera_dist: f32, half: [f32; 2]) -> f32 {
let rest = crate::regions::PERSPECTIVE_FACTOR * 2.0 * half[0].min(half[1]);
DEV_NEAR * DEV_EYE_MIN * camera_dist / rest.max(1e-4)
}
/// L'identifiant que le shader lit dans `color.r` (mode 17).
pub(crate) fn device_kind_id(kind: crate::scene::SceneFrame) -> f32 {
use crate::scene::SceneFrame as F;
match kind {
F::Laptop => 1.0,
F::Phone => 2.0,
F::Monitor => 3.0,
_ => 0.0,
}
}
/// Le verre noir de la face avant, tel que le mode 17 le rend de face : l'albédo `DEV_GLASS_*`
/// des shaders sous leur lampe (`MODEL_AMBIENT + MODEL_DIFFUSE · n·l`, n = +z au repos). Le verre
/// posé sous le métrage d'un bloc (`FrameGeometry::window_frame_cb`) prolonge ainsi la lunette
/// sans couture. Miroir des trois shaders : teintes et coefficients.
pub(crate) fn device_glass_rgba(dark: bool) -> [f32; 4] {
const GLASS_LIGHT: [f32; 3] = [0.031, 0.034, 0.040];
const GLASS_GRAPHITE: [f32; 3] = [0.043, 0.047, 0.055];
const MODEL_AMBIENT: f32 = 0.36;
const MODEL_DIFFUSE: f32 = 0.75;
let lit = MODEL_AMBIENT + MODEL_DIFFUSE * MODEL_LIGHT[2];
let [r, g, b] = if dark { GLASS_GRAPHITE } else { GLASS_LIGHT };
[r * lit, g * lit, b * lit, 1.0]
}
/// Les huit coins d'une boîte alignée.
fn box_corners(lo: [f32; 3], hi: [f32; 3]) -> [[f32; 3]; 8] {
std::array::from_fn(|i| {
[
if i & 1 == 0 { lo[0] } else { hi[0] },
if i & 2 == 0 { lo[1] } else { hi[1] },
if i & 4 == 0 { lo[2] } else { hi[2] },
]
})
}
/// La caméra qui voit le plan de l'écran, du point de vue d'un calque lancé de rayons : de quoi
/// projeter n'importe quel point du modèle exactement comme le mode 17 le rend.
///
/// Pendant de `ModelView` (mode 15), en plus simple : l'origine du modèle est le CENTRE du plan,
/// pas un hotspot flottant, donc rien à ancrer. Les quatre coins du plan se projettent ici au bit
/// près là où `rotated_quad_corners_px` les a mis (même rotation, même perspective, même
/// échelle), et sous un appareil le mode 8 passe au warp projectif (`TiltedQuad::projective`) :
/// l'intérieur du plan tombe lui aussi au même pixel que l'ouverture.
#[derive(Clone, Copy, Debug)]
pub(crate) struct DeviceView {
/// Rotation dessinée du plan, degrés (`TiltedQuad::rot`).
pub rot: [f32; 3],
pub perspective: f32,
/// Translation du plan dans le repère caméra (`TiltedQuad::offset`).
pub offset: [f32; 2],
/// L'unité du modèle (l'unité du cadre, `frame_unit_px`) en px du plan.
pub unit: f32,
/// Centre du plan en px de sortie.
pub center: [f32; 2],
/// Demi-taille de l'écran en unités du modèle : `[s_w, s_h] / 2u`.
pub half: [f32; 2],
}
impl DeviceView {
/// Marges du corps en unités du modèle. Celles de `WindowFrame` sont des fractions de la
/// boîte écran : de sa largeur à gauche et à droite, de sa hauteur en haut et en bas.
pub(crate) fn body_margins(&self, m: [f32; 4]) -> [f32; 4] {
let [w, h] = self.half.map(|v| 2.0 * v);
[m[0] * w, m[1] * h, m[2] * w, m[3] * h]
}
/// Centre et demi-taille du corps, en unités du modèle.
pub(crate) fn body_rect(&self, m: [f32; 4]) -> ([f32; 2], [f32; 2]) {
let [l, t, r, b] = self.body_margins(m);
(
[(r - l) * 0.5, (b - t) * 0.5],
[self.half[0] + (l + r) * 0.5, self.half[1] + (t + b) * 0.5],
)
}
/// L'œil de l'objectif du PLAN, dans le repère du plan (unités) : `(−offset, P)` du repère
/// caméra, ramené par la rotation inverse. Le mode 17 le reconstruit de la même façon.
fn plane_eye(&self) -> [f32; 3] {
let e = crate::regions::rotate_point_inv(
[-self.offset[0], -self.offset[1], self.perspective],
self.rot,
);
e.map(|v| v / self.unit)
}
/// L'ŒIL DU MODÈLE, dans le repère du plan (unités) : celui du plan, jamais plus bas que la
/// ligne du centre de l'écran (`y ≤ 0`, y vers le bas), reculé sur sa droite à au moins
/// `DEV_EYE_MIN`. Miroir de `device_frame` dans les trois shaders.
///
/// Pas plus bas : le socle d'un portable est réglé pour être vu par la TRANCHE depuis la
/// caméra droite (`device_deck_angle`), son plan passe juste sous cet œil. Un œil plus bas le
/// voyait par-dessous, et sa face inférieure remontait sur le bas de l'écran — au zoom sur le
/// bas de l'image, la caméra en orbite vise sous le centre, l'œil du relief plongeait de 35°
/// sous l'écran et le socle couvrait tout le métrage. Borné ainsi, aucun point du socle ne se
/// projette sur l'écran, sous aucun angle ni aucun zoom. Au repos et sous les angles fixes,
/// qui regardent tous d'en haut, rien ne change.
pub(crate) fn model_eye(&self) -> [f32; 3] {
let mut e = self.plane_eye();
e[1] = e[1].min(0.0);
let len = (e[0] * e[0] + e[1] * e[1] + e[2] * e[2]).sqrt().max(1e-3);
e.map(|v| v * (DEV_EYE_MIN / len).max(1.0))
}
/// La hauteur du plan proche devant l'écran (unités), cf. `device_near_plane` : la distance de
/// la caméra réelle au point qu'elle vise, le long de son axe.
pub(crate) fn near_plane(&self) -> f32 {
let e = self.plane_eye();
let axis = crate::regions::rotate_point_inv([0.0, 0.0, -1.0], self.rot);
device_near_plane(e[2] / (-axis[2]).max(1e-3), self.half)
}
/// Point du modèle (unités) → px de sortie, exactement comme le mode 17 le rend.
///
/// Le relief est vu de l'ŒIL DU MODÈLE (`model_eye`). Le point est d'abord ramené sur le plan
/// le long de la droite qui le joint à cet œil, puis projeté par l'objectif du plan — celui qui
/// dessine le métrage. Sur le plan, les deux coïncident : la face écran reste au pixel près sur
/// l'image.
pub(crate) fn project(&self, p: [f32; 3]) -> Option<[f32; 2]> {
let eye = self.model_eye();
let dz = eye[2] - p[2];
if !(dz > 1e-4) {
return None;
}
let k = eye[2] / dz;
let q = [eye[0] + (p[0] - eye[0]) * k, eye[1] + (p[1] - eye[1]) * k];
let w = crate::regions::rotate_point([q[0] * self.unit, q[1] * self.unit, 0.0], self.rot);
let d = self.perspective - w[2];
if !(d > 1e-3) {
return None;
}
let f = self.perspective / d;
Some([
self.center[0] + (w[0] + self.offset[0]) * f,
self.center[1] + (w[1] + self.offset[1]) * f,
])
}
/// Les boîtes alignées qui contiennent le modèle, en unités du modèle : le corps, plus le
/// socle du portable (dans SON repère, charnière comprise) ou le pied du moniteur. Miroir
/// exact de `sd_device` dans les trois shaders — ce qui n'est pas ici sort de la boîte de
/// dessin et se fait couper.
///
/// `deck_angle` est l'angle du socle du portable depuis le plan (`device_deck_angle`), tiré de
/// la caméra droite ; ignoré par les deux autres appareils.
pub(crate) fn model_points(
&self,
kind: crate::scene::SceneFrame,
c: [f32; 2],
h: [f32; 2],
t: f32,
deck_angle: f32,
) -> Vec<[f32; 3]> {
use crate::scene::SceneFrame as F;
let mut pts =
box_corners([c[0] - h[0], c[1] - h[1], -t], [c[0] + h[0], c[1] + h[1], 0.0]).to_vec();
match kind {
F::Laptop => {
// Le socle a exactement la largeur de la coque, et commence après le jeu de
// charnière. Le coin le plus épais est celui de la charnière ; la boîte le prend.
let hinge = [0.0, c[1] + h[1], -t * 0.5];
let (ca, sa) = (deck_angle.cos(), deck_angle.sin());
pts.extend(
box_corners(
[-h[0], DEV_DECK_GAP, -DEV_DECK_THICK],
[h[0], DEV_DECK_GAP + DEV_DECK_LEN, 0.0],
)
.map(|q| {
[
hinge[0] + q[0],
hinge[1] + q[1] * ca - q[2] * sa,
hinge[2] + q[1] * sa + q[2] * ca,
]
}),
);
}
F::Monitor => {
let y0 = c[1] + h[1];
let z0 = -t * 0.5;
pts.extend(box_corners(
[-DEV_NECK_W, y0 - 0.01, z0 - DEV_STAND_Z],
[DEV_NECK_W, y0 + DEV_NECK_LEN, z0],
));
pts.extend(box_corners(
[-DEV_FOOT_W, y0 + DEV_NECK_LEN - 0.01, z0 - DEV_FOOT_Z],
[DEV_FOOT_W, y0 + DEV_NECK_LEN + DEV_FOOT_H, z0],
));
}
_ => {}
}
pts
}
/// Boîte de dessin (px de sortie, `[x0, y0, x1, y1]`) qui contient tout le modèle. L'ombre
/// n'y entre pas : `device_shadow_cb` l'élargit de la pénombre et la décale.
pub(crate) fn footprint(
&self,
kind: crate::scene::SceneFrame,
c: [f32; 2],
h: [f32; 2],
t: f32,
deck_angle: f32,
) -> Option<[f32; 4]> {
let mut b = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
for p in self.model_points(kind, c, h, t, deck_angle) {
let q = self.project(p)?;
b = [b[0].min(q[0]), b[1].min(q[1]), b[2].max(q[0]), b[3].max(q[1])];
}
const PAD_PX: f32 = 2.0;
Some([b[0] - PAD_PX, b[1] - PAD_PX, b[2] + PAD_PX, b[3] + PAD_PX])
}
}
/// LE rayon des coins du métrage, en px, pour un rayon demandé `r` (le slider) et un écran
/// `s_px`. Une seule fonction, et tout ce qui trace ce coin la lit : le métrage (modes 0 et 8),
/// l'ouverture des appareils (mode 17, `dst_prev.y`), les coins bas de la fenêtre.
///
/// Bornée à la moitié du petit côté : au-delà, `sd_round_rect` dégénère, et le métrage (qui ne
/// bornait pas) et l'ouverture (qui bornait) traçaient deux coins différents — le coin carré du
/// contenu dépassait de l'arc de la lunette à Roundness élevé. Sans effet en deçà : le rendu
/// d'avant, à l'octet, pour tout rayon réaliste.
pub(crate) fn screen_corner_radius_px(r: f32, s_px: [f32; 2]) -> f32 {
r.min(0.5 * s_px[0].min(s_px[1])).max(0.0)
}
/// Marges du chrome de fenêtre autour de l'écran `s_px` (px), en fractions de CELUI-CI, pour une
/// unité du cadre `u` (px) : le filet à gauche, à droite et en bas, la barre de titre en haut (cf.
/// `WindowFrame::margins`).
///
/// Le compositeur ne rétrécit jamais la boîte écran qu'il reçoit pour loger le cadre : le cadre
/// pousse vers l'extérieur. C'est le layout de l'app qui lui fait place : le padding se mesure
/// depuis le bord extérieur de tout ce que le cadre dessine (`computeCompositeLayout`), si bien
/// qu'au repos il ne sort jamais du canvas, et c'est l'ensemble qui est centré.
pub(crate) fn window_frame_margins(s_px: [f32; 2], u: f32) -> [f32; 4] {
let (bar, line) = (WINDOW_FRAME_BAR_FRAC * u, WINDOW_FRAME_LINE_FRAC * u);
let (sw, sh) = (s_px[0].max(1.0), s_px[1].max(1.0));
[line / sw, bar / sh, line / sw, line / sh]
}
/// Marges du CORPS d'un appareil autour de l'écran `s_px` (px), en fractions de celui-ci, pour une
/// unité du cadre `u` (px) (cf. `WindowFrame::margins`). Même principe que `window_frame_margins` :
/// l'écran garde sa taille, l'appareil déborde. Le socle et le pied n'y entrent pas : ils sortent
/// du plan, et le calque du mode 17 les cadre lui-même (`DeviceView::footprint`), ombre comprise
/// (`device_shadow_cb`).
pub(crate) fn device_frame_margins(kind: crate::scene::SceneFrame, s_px: [f32; 2], u: f32) -> [f32; 4] {
let (sw, sh) = (s_px[0].max(1.0), s_px[1].max(1.0));
let [l, t, r, b] = device_body_margins(kind).map(|m| m * u);
[l / sw, t / sh, r / sw, b / sh]
}
/// Qui porte l'ombre portée de l'écran, et avec quelle silhouette.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ShadowCaster {
/// Rect droit (mode 2) : `dst` en fractions de sortie, `size_px` sa taille, `radius` en px.
Upright { dst: [f32; 4], size_px: [f32; 2], radius: f32 },
/// Quad incliné (mode 12) : coins TL, TR, BR, BL relatifs à `center_px`, rayon du plan.
/// `mask` : le slot d'un layout en bloc, qui rogne le plan — l'ombre est alors celle de
/// leur intersection, ce qu'on voit (`shadow_mask_fields`).
Tilted { corners: [(f32, f32); 4], center_px: [f32; 2], radius: f32, mask: Option<ScreenMask> },
}
/// Les champs du mode 12 qui rognent l'ombre d'un plan incliné au slot qui le masque : `dst_prev`
/// = le slot en px LOCAUX à la boîte de l'ombre (x0, y0, x1, y1), `mb.w` = le rayon de ses coins.
/// `origin_px` : l'origine de ce repère local, en px de sortie, décalage de l'ombre NON compris —
/// le slot et le plan portent le même. Des zéros sans masque : le shader n'en fait rien.
pub fn shadow_mask_fields(
mask: Option<ScreenMask>,
origin_px: [f32; 2],
render_px: [f32; 2],
) -> ([f32; 4], f32) {
let Some(m) = mask else { return ([0.0; 4], 0.0) };
let [x, y, w, h] = m.rect;
let (x0, y0) = (x * render_px[0] - origin_px[0], y * render_px[1] - origin_px[1]);
([x0, y0, x0 + w * render_px[0], y0 + h * render_px[1]], m.radius_px)
}
/// Rect [x,y,w,h] normalisé d'un sprite de curseur de taille `w`×`h` dont le pivot `hotspot`
/// (fraction 0..1 de l'image) doit tomber exactement sur `center`.
///
/// L'invariant est que `center` reste sur le pixel désigné QUELLE QUE SOIT la taille : le
/// décalage grandit avec le sprite, donc il doit être une fraction de `w`/`h` et pas une
/// constante. Un pivot centré en dur (0.5) laissait la pointe dériver de plus en plus loin de
/// la zone visée à mesure qu'on agrandissait le curseur.
pub(crate) fn cursor_sprite_dst(center: [f32; 2], w: f32, h: f32, hotspot: [f32; 2]) -> [f32; 4] {
[center[0] - w * hotspot[0], center[1] - h * hotspot[1], w, h]
}
/// Où poser le curseur, et dans quel repère.
///
/// Le curseur remplace un pointeur qui faisait partie de l'image capturée, donc il vit SUR la
/// surface de l'écran, pas dans un calque au-dessus. Quand cet écran est incliné en 3D, ce n'est
/// donc pas seulement sa position qu'il faut projeter mais son sprite entier : autrement il se
/// lit comme un autocollant plat posé sur une scène en perspective.
#[derive(Clone, Copy)]
pub enum CursorPlacement {
/// Écran droit : centre en coordonnées sortie 0..1.
Upright { center: [f32; 2] },
/// Écran incliné : position 0..1 DANS le plan, plus de quoi projeter les coins du sprite.
Tilted {
/// Position du pivot dans le plan (0..1 depuis son coin haut-gauche).
plane_pt: [f32; 2],
quad: crate::regions::TiltedQuad,
/// Centre du plan en px sortie — `quad.corners` y est relatif.
center_px: [f32; 2],
/// Taille du rect d'écran NON incliné en px : l'unité dans laquelle la taille du
/// curseur est exprimée, et donc ce qui la convertit en fraction du plan.
screen_px: [f32; 2],
/// Taille de la cible de rendu en px, pour repasser des px aux 0..1 de la sortie.
render_px: [f32; 2],
},
}
impl CursorPlacement {
/// Interpolation entre deux placements, pour les copies de la traînée de flou. Sur un plan
/// incliné on interpole DANS le plan : la traînée suit alors la surface au lieu de couper
/// droit à travers la perspective.
///
/// Le plan lui-même est interpolé aussi. Sous un vrai tilt les deux bornes partagent le même
/// quad (`a + (a - a) * f` rend `a` au bit près, rien ne bouge) ; mais le curseur modélisé
/// sur écran droit porte un quad identité taillé dans `s_dst` d'un côté et `s_dst_prev` de
/// l'autre, et garder celui de la queue décalerait la tête quand le zoom bouge.
pub(crate) fn lerp(self, other: CursorPlacement, f: f32) -> CursorPlacement {
match (self, other) {
(
CursorPlacement::Tilted { plane_pt: a, quad, center_px, screen_px, render_px },
CursorPlacement::Tilted {
plane_pt: b,
quad: quad_b,
center_px: center_b,
screen_px: screen_b,
..
},
) => CursorPlacement::Tilted {
plane_pt: [lerp(a[0], b[0], f), lerp(a[1], b[1], f)],
quad: crate::regions::TiltedQuad {
corners: std::array::from_fn(|i| {
(
lerp(quad.corners[i].0, quad_b.corners[i].0, f),
lerp(quad.corners[i].1, quad_b.corners[i].1, f),
)
}),
scale: lerp(quad.scale, quad_b.scale, f),
depth_k: (
lerp(quad.depth_k.0, quad_b.depth_k.0, f),
lerp(quad.depth_k.1, quad_b.depth_k.1, f),
),
rot: std::array::from_fn(|i| lerp(quad.rot[i], quad_b.rot[i], f)),
perspective: lerp(quad.perspective, quad_b.perspective, f),
offset: std::array::from_fn(|i| lerp(quad.offset[i], quad_b.offset[i], f)),
projective: quad.projective,
lamp: quad.lamp,
},
center_px: [lerp(center_px[0], center_b[0], f), lerp(center_px[1], center_b[1], f)],
screen_px: [lerp(screen_px[0], screen_b[0], f), lerp(screen_px[1], screen_b[1], f)],
render_px,
},
(a, b) => {
let (p, q) = (a.upright_center(), b.upright_center());
CursorPlacement::Upright {
center: [p[0] + (q[0] - p[0]) * f, p[1] + (q[1] - p[1]) * f],
}
}
}
}
/// Le centre en coordonnées sortie, quel que soit le repère — ce dont ont besoin le curseur
/// math de secours et le calcul de vélocité.
pub(crate) fn upright_center(self) -> [f32; 2] {
match self {
CursorPlacement::Upright { center } => center,
CursorPlacement::Tilted { plane_pt, quad, center_px, render_px, .. } => {
let (px, py) = quad.point_px(plane_pt[0], plane_pt[1]);
[(center_px[0] + px) / render_px[0], (center_px[1] + py) / render_px[1]]
}
}
}
}
/// `LayerCB` du sprite de curseur, pour les trois backends : mode 7 sur écran droit, mode 13
/// posé sur le plan incliné.
///
/// `sprite_px` = taille du sprite en px de sortie (ratio de l'image déjà appliqué).
pub fn cursor_sprite_cb(
placement: CursorPlacement,
sprite_px: [f32; 2],
hotspot: [f32; 2],
alpha: f32,
clip: [f32; 4],
render_px: [f32; 2],
) -> LayerCB {
let [pw, ph] = sprite_px;
let [rw, rh] = render_px;
match placement {
CursorPlacement::Upright { center } => LayerCB {
dst: cursor_sprite_dst(center, pw / rw, ph / rh, hotspot),
src: [0.0, 0.0, 1.0, 1.0],
mode: 7.0,
color: [1.0, 1.0, 1.0, alpha],
fx: clip,
..Default::default()
},
CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, .. } => {
// Le sprite est posé DANS le plan : sa taille devient une fraction du plan
// (l'unité de `size_px` est le rect d'écran non incliné), et ses 4 coins
// traversent la même projection que la vidéo. La réduction due au tilt vient
// donc de la projection elle-même — rien à multiplier à la main.
let (wf, hf) = (pw / screen_px[0], ph / screen_px[1]);
let x0 = plane_pt[0] - hotspot[0] * wf;
let y0 = plane_pt[1] - hotspot[1] * hf;
let corners =
[(x0, y0), (x0 + wf, y0), (x0 + wf, y0 + hf), (x0, y0 + hf)].map(|(fx, fy)| {
let (px, py) = quad.point_px(fx, fy);
(center_px[0] + px, center_px[1] + py)
});
let (min_x, max_x) = corners
.iter()
.fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) = corners
.iter()
.fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
// Le quad projeté d'un sprite peut être très fin de biais : une bbox d'un pixel
// de large ferait diverger le warp inverse, donc plancher à 1 px.
let (bw, bh) = ((max_x - min_x).max(1.0), (max_y - min_y).max(1.0));
let local = |(x, y): (f32, f32)| [x - min_x, y - min_y];
let [tl0, tl1] = local(corners[0]);
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
LayerCB {
dst: [min_x / rw, min_y / rh, bw / rw, bh / rh],
quad_px: [bw, bh],
mode: 13.0,
color: [1.0, 1.0, 1.0, alpha],
fx: [tl0, tl1, tr0, tr1],
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 ou appareil, cf. `screen_tilt`).
mb: [quad.warp_flag(), 0.0, 0.0, 0.0],
..Default::default()
}
}
}
}
// ============ Verre à plat (mode 19) ============
//
// Glass Lens, 3D éteinte : la lentille de son modèle (`sculpt.rs`, `s_glass` dans les shaders)
// vue de face, posée sur l'image comme le sprite plat (le quad projeté et le warp inverse du
// mode 13), mais dessinée par le shader, qui réfracte la copie de l'image composée
// (`CursorPlan::glass`) au travers d'un relief tiré des mêmes formes. Le PNG du thème ne sert plus
// qu'au sélecteur.
//
// Emplacements du `LayerCB` au mode 19 :
// dst, quad_px bbox du rect du modèle projeté (sortie 0..1, px)
// fx, src_prev coins TL, TR puis BR, BL, en px locaux à la bbox (comme au mode 13)
// dst_prev rect de clip « Clip to canvas » (sortie 0..1)
// mb.x 1 = warp projectif (caméra réelle)
// src.xy l'unité du modèle en fractions de la sortie (x, y) : le décalage de la réfraction
// color.rg coin haut-gauche du rect, repère du modèle (unités), comme au mode 15
// color.b l'unité du modèle en px de sortie : l'antialiasing
// color.a opacité
// radius_px rapport w/h du rect (`sprite_size` des shaders)
// trail_a.x le curseur sculpté (`SpriteShape::sculpt`)
// Texture : la copie de l'image composée, t5/texture(5) (`texDof`) sous Windows et macOS, au
// binding 1 (`texY`) sous Linux, comme pour le cristal du mode 15.
/// Le verre à plat du curseur sculpté `name` posé en `placement` : la boîte du modèle a pour plus
/// grand côté `size_px`, comme au mode 15. `None` pour un nom qui n'est pas un modèle.
pub fn cursor_glass_cb(
placement: CursorPlacement,
size_px: f32,
name: &str,
alpha: f32,
clip: [f32; 4],
render_px: [f32; 2],
) -> Option<LayerCB> {
let shape = crate::sculpt::sculpted_shape(name)?;
let [rw, rh] = render_px;
let sprite_px = [shape.size[0] * size_px, shape.size[1] * size_px];
let mut cb = cursor_sprite_cb(placement, sprite_px, shape.hotspot, alpha, clip, render_px);
if cb.mode < 12.5 {
// Écran droit (mode 7) : son rect, sous la forme du mode 13. Le warp bilinéaire d'un
// rect est exact.
let [w, h] = [cb.dst[2] * rw, cb.dst[3] * rh];
cb.quad_px = [w, h];
cb.fx = [0.0, 0.0, w, 0.0];
cb.src_prev = [w, h, 0.0, h];
cb.dst_prev = clip;
}
// L'unité telle que le plan la montre : le bord gauche du rect projeté (TL -> BL).
let unit_px = (cb.src_prev[2] - cb.fx[0]).hypot(cb.src_prev[3] - cb.fx[1]) / shape.size[1];
cb.mode = 19.0;
cb.src = [unit_px / rw, unit_px / rh, 0.0, 0.0];
cb.color = [shape.origin()[0], shape.origin()[1], unit_px, alpha];
cb.radius_px = shape.size[0] / shape.size[1];
cb.trail_a = [shape.sculpt as f32, 0.0, 0.0, 0.0];
Some(cb)
}
/// Gain de l'éclairage de la caméra réelle : une lampe posée sur la caméra, dont la lumière
/// décroît avec le carré de la distance. 1 = la décroissance physique ; moins, pour que le
/// contenu reste lisible. L'œil en orbite passe loin de l'axe : à 22° d'azimut, l'écart d'un bord
/// à 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.
///
/// - `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` ;
/// - `top_lift_px` : sous le chrome de fenêtre, de combien son contour intérieur remonte au-dessus
/// du haut de l'écran (px de l'écran droit, `FrameGeometry::screen_top_lift_px`) ; 0 ailleurs.
/// Non nul, il carre les coins HAUTS de l'écran (`dst_prev.z` = 1) et rogne ceux-ci par l'arc
/// 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`).
///
/// `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 (`FrameGeometry::tilt_pixel_trail`). 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,
s_px: [f32; 2],
center_px: [f32; 2],
src: [f32; 4],
focus_plane: [f32; 2],
radius: f32,
top_lift_px: f32,
dof: bool,
render_px: [f32; 2],
mask: Option<ScreenMask>,
trail: Option<TiltTrail>,
) -> LayerCB {
let [rw, rh] = render_px;
let corners = quad.corners;
// Taille du plan dans son propre repère, avant projection : c'est là que vit le rayon, pour
// qu'il reste constant le long du bord au lieu de s'étirer avec la perspective.
let plane_px = [s_px[0] * quad.scale, s_px[1] * quad.scale];
let (min_x, max_x) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
let bbox_w = (max_x - min_x).max(1.0);
let bbox_h = (max_y - min_y).max(1.0);
// Coins en px LOCAUX à la bbox, pour matcher `i.local` du shader.
let local = |(x, y): (f32, f32)| -> [f32; 2] { [x - min_x, y - min_y] };
let [tl0, tl1] = local(corners[0]);
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
// `lamp` et non `projective` : sous un cadre d'appareil, un angle fixe passe au warp exact
// (le mode 17 en a besoin) mais garde son exposition. La lampe vient avec la caméra réelle.
let light = if quad.lamp {
// Œil dans le repère du plan, et la dérivée de (d_centre / d)² au centre du plan.
let eye = crate::regions::rotate_point_inv(
[-quad.offset[0], -quad.offset[1], quad.perspective],
quad.rot,
);
let e2 = eye[0] * eye[0] + eye[1] * eye[1] + eye[2] * eye[2];
let k = 2.0 * CAMERA_LIGHT_GAIN / e2.max(1e-6);
[k * plane_px[0] * eye[0], k * plane_px[1] * eye[1], 0.0, 0.0]
} else {
[0.0; 4]
};
let mut cb = LayerCB {
dst: [(center_px[0] + min_x) / rw, (center_px[1] + min_y) / rh, bbox_w / rw, bbox_h / rh],
src,
quad_px: [bbox_w, bbox_h],
// Le rayon suit la réduction du plan : l'écran incliné est plus petit, ses coins le sont
// d'autant, exactement comme s'il s'éloignait.
radius_px: radius * quad.scale,
mode: 8.0,
// `color.z` : la remontée du contour intérieur du chrome de fenêtre, dans le repère du
// plan comme le rayon. Nulle sans fenêtre, comme avant.
color: [light[0], light[1], top_lift_px * quad.scale, light[3]],
fx: [tl0, tl1, tr0, tr1],
src_prev: [br0, br1, bl0, bl1],
dst_prev: [plane_px[0], plane_px[1], (top_lift_px > 0.0) as u8 as f32, quad.warp_flag()],
// Gradient de profondeur du plan, profondeur du focus et `k` (`depth_mb`).
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);
// Négatif : coins hauts carrés, sous la barre de la fenêtre (`slot_alpha`, shaders).
cb.color[3] = if mask.square_top { -mask.radius_px } else { mask.radius_px };
}
cb
}
/// `LayerCB` d'une ombre portée par un quadrilatère (mode 12). `corners` (TL, TR, BR, BL) en px
/// de sortie ABSOLUS. Même boîte que `draw_quad_shadow` des backends : le quad élargi du
/// `spread`, pour que la pénombre ne se coupe pas net.
pub(crate) fn quad_shadow_cb(
corners: &[(f32, f32); 4],
radius: f32,
spread: f32,
opacity: f32,
render_px: [f32; 2],
) -> LayerCB {
let (min_x, max_x) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
let box_w = (max_x - min_x) + 2.0 * spread;
let box_h = (max_y - min_y) + 2.0 * spread;
let local = |(x, y): (f32, f32)| -> [f32; 2] { [x - min_x + spread, y - min_y + spread] };
let [tl0, tl1] = local(corners[0]);
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
LayerCB {
dst: [
(min_x - spread) / render_px[0],
(min_y - spread) / render_px[1],
box_w / render_px[0],
box_h / render_px[1],
],
quad_px: [box_w, box_h],
radius_px: radius,
mode: 12.0,
color: [0.0, 0.0, 0.0, opacity],
fx: [tl0, tl1, tr0, tr1],
src_prev: [br0, br1, bl0, bl1],
mb: [0.0, spread, 1.0, 0.0],
..Default::default()
}
}
/// Le plus grand rayon que le mode 12 accepte sur ce quad sans se retourner.
///
/// Le shader rentre chaque arête de `r` (`line_cross`) : dès que `r` dépasse la demi-distance
/// entre deux arêtes opposées, les arêtes rentrées se croisent et le quad « rentré » est retourné
/// — la pénombre sort alors n'importe où. La demi-distance se mesure du milieu d'une arête à la
/// droite de l'arête opposée (exact pour des arêtes parallèles, proche sous nos petits angles),
/// et `0.8×` garde une marge pour l'écart au parallélisme.
pub(crate) fn quad_shadow_max_radius(c: &[(f32, f32); 4]) -> f32 {
let dist_to_line = |p: (f32, f32), a: (f32, f32), b: (f32, f32)| {
let (ex, ey) = (b.0 - a.0, b.1 - a.1);
((p.0 - a.0) * ey - (p.1 - a.1) * ex).abs() / ex.hypot(ey).max(1e-6)
};
let mid = |a: (f32, f32), b: (f32, f32)| ((a.0 + b.0) * 0.5, (a.1 + b.1) * 0.5);
let half_min = (0..4)
.map(|k| {
let (a, b) = (c[k], c[(k + 1) % 4]);
let (o0, o1) = (c[(k + 2) % 4], c[(k + 3) % 4]);
dist_to_line(mid(o0, o1), a, b) * 0.5
})
.fold(f32::MAX, f32::min);
0.8 * half_min
}
pub(crate) fn ease_in_out_cubic(x: f32) -> f32 {
let x = x.clamp(0.0, 1.0);
if x < 0.5 {
4.0 * x * x * x
} else {
1.0 - (-2.0 * x + 2.0).powi(3) / 2.0
}
}
pub(crate) fn lerp(a: f32, b: f32, t: f32) -> f32 {
a + (b - a) * t
}
pub(crate) fn lerp4(a: [f32; 4], b: [f32; 4], t: f32) -> [f32; 4] {
[lerp(a[0], b[0], t), lerp(a[1], b[1], t), lerp(a[2], b[2], t), lerp(a[3], b[3], t)]
}
/// Un calque vidéo animé (rect sortie, taille px, rayon) — screen ou webcam.
#[derive(Clone, Copy)]
pub(crate) struct Placement {
pub(crate) dst: [f32; 4],
pub(crate) radius: f32,
}
/// Paramètres d'une frame : dérivés du temps par la timeline (§8).
#[derive(Clone, Copy)]
pub(crate) struct FrameParams {
pub(crate) zoom: f32,
pub(crate) focus: [f32; 2],
pub(crate) screen: Placement,
pub(crate) webcam: Placement, // dst carré (w en px via OUT_W)
}
/// Timeline figée de la fixture (6 s) : zoom 1.0→1.8→1.0, layout A(PIP)↔B(côte à côte).
/// `frame` fractionnaire pour permettre le supersampling temporel (flou de mouvement).
/// Gaté par `cfg` : zoom et layout ne bougent que si activés.
pub(crate) fn timeline(frame: f32, cfg: &Cfg) -> FrameParams {
let t = frame / FPS; // secondes
// zoom : montée [0,3s] puis descente [3s,6s], easeInOutCubic
let zoom = if cfg.zoom {
let zt = if t < 3.0 { ease_in_out_cubic(t / 3.0) } else { ease_in_out_cubic((6.0 - t) / 3.0) };
1.0 + 0.8 * zt
} else {
1.0
};
// layout A = PIP bas-droite ; B = côte à côte. Transitions A→B [2,2.5]s, B→A [4,4.5]s.
let lf = if !cfg.layout_anim {
0.0
} else if t < 2.0 {
0.0
} else if t < 2.5 {
ease_in_out_cubic((t - 2.0) / 0.5)
} else if t < 4.0 {
1.0
} else if t < 4.5 {
1.0 - ease_in_out_cubic((t - 4.0) / 0.5)
} else {
0.0
};
// Layout A (PIP)
let a_screen = Placement { dst: [0.05, 0.05, 0.90, 0.90], radius: 24.0 };
let a_side = 320.0_f32;
let a_webcam = Placement {
dst: [
(OUT_W as f32 - 40.0 - a_side) / OUT_W as f32,
(OUT_H as f32 - 40.0 - a_side) / OUT_H as f32,
a_side / OUT_W as f32,
a_side / OUT_H as f32,
],
radius: 40.0,
};
// Layout B (côte à côte) : screen à gauche (16:9), webcam carré à droite
let b_screen = Placement { dst: [0.035, 0.22, 0.60, 0.5625], radius: 20.0 };
let b_side = 520.0_f32;
let b_webcam = Placement {
dst: [
0.70,
(OUT_H as f32 - b_side) * 0.5 / OUT_H as f32,
b_side / OUT_W as f32,
b_side / OUT_H as f32,
],
radius: 40.0,
};
FrameParams {
zoom,
focus: [0.5, 0.32],
screen: Placement { dst: lerp4(a_screen.dst, b_screen.dst, lf), radius: lerp(a_screen.radius, b_screen.radius, lf) },
webcam: Placement { dst: lerp4(a_webcam.dst, b_webcam.dst, lf), radius: lerp(a_webcam.radius, b_webcam.radius, lf) },
}
}
/// Placements statiques screen+webcam pour un preset de layout de l'app (contrat de scène) —
/// remplace le planning A↔B fixture de `timeline()`. Zoom = 1 (les zoom regions viennent ensuite).
/// La taille/forme/miroir webcam restent appliqués par-dessus via `LiveParams`.
pub(crate) fn preset_placements(preset: &str) -> FrameParams {
// plein cadre : le padding l'insère ensuite (padding 0 → bord à bord).
let full_screen = Placement { dst: [0.0, 0.0, 1.0, 1.0], radius: 24.0 };
// PiP bas-droite (≈ layout A fixture).
let a_side = 320.0_f32;
let pip_webcam = Placement {
dst: [
(OUT_W as f32 - 40.0 - a_side) / OUT_W as f32,
(OUT_H as f32 - 40.0 - a_side) / OUT_H as f32,
a_side / OUT_W as f32,
a_side / OUT_H as f32,
],
radius: 40.0,
};
// webcam hors écran (no-webcam) : quad de taille nulle, jamais visible.
let off_webcam = Placement { dst: [2.0, 2.0, 0.0, 0.0], radius: 0.0 };
let (screen, webcam) = match preset {
"dual-frame" => {
// côte à côte : screen 16:9 à gauche, webcam carré à droite (≈ layout B fixture).
let b_side = 520.0_f32;
(
Placement { dst: [0.035, 0.22, 0.60, 0.5625], radius: 20.0 },
Placement {
dst: [
0.70,
(OUT_H as f32 - b_side) * 0.5 / OUT_H as f32,
b_side / OUT_W as f32,
b_side / OUT_H as f32,
],
radius: 40.0,
},
)
}
"vertical-stack" => {
// haut/bas : screen en haut, webcam carré centré en bas.
let w_side = 360.0_f32;
(
Placement { dst: [0.13, 0.04, 0.74, 0.52], radius: 20.0 },
Placement {
dst: [
0.5 - (w_side * 0.5) / OUT_W as f32,
0.60,
w_side / OUT_W as f32,
w_side / OUT_H as f32,
],
radius: 40.0,
},
)
}
"no-webcam" => (full_screen, off_webcam),
_ => (full_screen, pip_webcam), // "picture-in-picture" (défaut)
};
FrameParams { zoom: 1.0, focus: [0.5, 0.5], screen, webcam }
}
// Les quatre items qui suivent existaient en DOUBLE, un exemplaire par backend, et les
// commentaires macOS affirmaient « mêmes champs et même layout » puis « mêmes formules ».
// Les deux affirmations étaient fausses sur trois valeurs :
//
// bg_color défaut windows [0.10, 0.11, 0.14, 1.0] macos [0, 0, 0, 0]
// has_webcam défaut windows true macos false
// webcam_shape_code(_) windows 3 ("rounded") macos 0 ("rectangle")
//
// La troisième est celle qui mord : `live_params_from_scene` l'appelle, et `webcam_shape`
// vaut "rounded" par défaut côté app — donc la même scène décrivait une caméra arrondie
// sur Windows et rectangulaire sur macOS. Les valeurs Windows font foi : c'est le backend
// qui rend en production aujourd'hui.
/// Valeurs continues pilotées par l'inspector (celles qui étaient codées en dur dans
/// `compose_frame`). Le défaut reproduit le rendu actuel → bench/export inchangés.
/// Les booléens/taps (fond flouté, ombre on/off, coins on/off, motion blur) restent
/// portés par le `Cfg` que le thread live reconstruit depuis les switches.
#[derive(Clone, Copy)]
pub struct LiveParams {
pub bg_color: [f32; 4], // fond plat (mode couleur) quand non flouté
pub shadow_scale: f32, // multiplie l'opacité des ombres (1 = défaut, 0 = off)
pub radius_scale: f32, // multiplie le rayon des coins (1 = défaut, 0 = carré)
pub padding: f32, // 0..1 : inset supplémentaire du screen (0 = défaut fixture)
pub webcam_size_scale: f32, // multiplie la taille de la webcam (1 = défaut)
pub webcam_mirror: bool, // miroir horizontal de la webcam
pub webcam_shape: u32, // 0=rect, 1=circle, 2=square, 3=rounded (défaut)
pub cursor_size_scale: f32, // multiplie la taille du curseur (1 = défaut)
pub cursor_bounce_scale: f32, // multiplie l'amplitude du click-bounce (1 = défaut, 0 = off)
/// 0..1 : flou de mouvement DU CURSEUR (indépendant du motion blur écran/`cfg.mblur_n`).
/// Approximé par le même mécanisme de traînée fantôme (taps décalés le long de la
/// vélocité), pas par un flou gaussien variable comme le canvas web — plus simple à
/// réutiliser côté GPU, effet de streak équivalent.
pub cursor_motion_blur: f32,
/// Flèche modélisée en 3D (mode 15, cf. `plan_cursor`). `false` = le sprite plat d'avant.
pub cursor_model3d: bool,
/// Masquage auto du curseur en cas d'inactivité.
pub cursor_auto_hide: bool,
/// False when the "webcam" decoder is actually just the screen video again (the TS side
/// falls `webcamPath` back to the screen asset's own path when a clip has no real camera,
/// purely so the decoder pipeline has something valid to open) — drawing the PiP box in
/// that case duplicates the screen video into its own corner. Derived per clip from the
/// screen/webcam paths via `webcam_is_real`: in `live.rs` for the preview, in
/// `timeline_walk.rs` for every export. Defaults `true` (draw) so fixture/bench renders
/// and any caller that never sets it keep their old behavior.
pub has_webcam: bool,
}
fn same_source_path(a: &str, b: &str) -> bool {
a.eq_ignore_ascii_case(b)
}
/// Période commune des mouvements de fond (s). Chaque période du shader (6, 10, 12, 15, 20,
/// 30 s) la divise, donc replier le temps dessus ne crée aucun raccord visible — et garde au
/// shader un temps borné, là où un `f32` de plusieurs heures perdrait la finesse du bruit.
pub const WALLPAPER_MOTION_PERIOD_S: f32 = 120.0;
/// Ce qui décide à lui seul du fond composé — sa description, la force de son flou, la couleur
/// de repli, la taille de rendu —, gardé avec sa copie (`bg_cache`) : tant que le fond demandé
/// lui est égal, le backend recopie le fond de la frame d'avant au lieu de le redessiner, ce qui
/// coûtait plus que l'écran lui-même (1,65 ms par frame 1080p sur une Radeon 610M, un wallpaper
/// 4K échantillonné sans mips).
///
/// La comparaison de chaque frame (`matches`) ne construit ni ne copie rien : une image en data
/// URI pèse plusieurs Mo. Seul `of`, au moment de garder un nouveau fond, la clone.
#[derive(Clone, PartialEq)]
pub struct BackgroundKey {
background: Option<crate::scene::SceneBackground>,
blur: f32,
fallback: [f32; 4],
render_px: [f32; 2],
}
impl BackgroundKey {
/// La clé d'un fond fixe ; `None` pour un fond animé, qui change à chaque frame.
pub fn of(
background: Option<&crate::scene::SceneBackground>,
blur: f32,
fallback: [f32; 4],
render_px: [f32; 2],
) -> Option<BackgroundKey> {
use crate::scene::{SceneBackground as B, WallpaperMotion};
if let Some(B::Gradient { motion, .. } | B::Image { motion, .. }) = background {
if *motion != WallpaperMotion::None {
return None;
}
}
Some(BackgroundKey { background: background.cloned(), blur, fallback, render_px })
}
/// Le fond demandé est celui-ci.
pub fn matches(
&self,
background: Option<&crate::scene::SceneBackground>,
blur: f32,
fallback: [f32; 4],
render_px: [f32; 2],
) -> bool {
self.background.as_ref() == background
&& self.blur == blur
&& self.fallback == fallback
&& self.render_px == render_px
}
}
/// Emplacements libres des modes 5 (dégradé) et 6 (image) pour le fond animé : `fx.zw` = (temps
/// programme replié, indice du mouvement), `mb.x` = aspect w/h du rect rempli (les nappes de
/// l'aurore restent rondes).
///
/// `WallpaperMotion::None` rend les zéros d'avant l'animation, emplacement pour emplacement : le
/// fond immobile reste celui d'aujourd'hui, octet pour octet. Fonction pure du temps
/// programme, jamais d'un état porté de frame en frame — preview et export, lecture et seek
/// tombent sur la même image.
pub fn wallpaper_motion_slots(
motion: crate::scene::WallpaperMotion,
programme_t: f32,
aspect: f32,
) -> ([f32; 2], [f32; 4]) {
use crate::scene::WallpaperMotion as M;
let index = match motion {
M::None => return ([0.0, 0.0], [0.0; 4]),
M::Drift => 1.0,
M::Aurora => 2.0,
M::Waves => 3.0,
};
(
[programme_t.rem_euclid(WALLPAPER_MOTION_PERIOD_S), index],
[aspect, 0.0, 0.0, 0.0],
)
}
/// Un dégradé linéaire en calque du mode 5, stops compris : quatre nœuds `[r, g, b, position]`
/// dans `color`, `src_prev`, `dst_prev` puis `src`, dans l'ordre du dégradé. Le shader va de nœud
/// en nœud comme CSS, donc un stop du milieu est peint là où la vignette le montre. Avant, seuls
/// le premier et le dernier stop arrivaient au shader, et le milieu d'un dégradé à trois stops
/// (celui de l'ancien éditeur) disparaissait du rendu.
///
/// Positions : celles de l'app quand il y en a une par stop, sinon réparties à égale distance
/// (scène plus ancienne). Bornées à 0..1 et jamais en recul sur la précédente, comme en CSS. Un
/// stop illisible est sauté ; sans aucun stop lisible, `fallback` remplit tout. Moins de quatre
/// stops : le dernier se répète, en segments de longueur nulle qui ne peignent rien. Deux stops
/// à 0 et 1 rendent donc exactement l'ancien `lerp(c0, c1, t)`.
pub fn gradient_layer(stops: &[String], offsets: &[f32], fallback: [f32; 4]) -> LayerCB {
let mut knots: Vec<[f32; 4]> = Vec::with_capacity(stops.len().max(4));
let mut floor = 0.0f32;
for (i, stop) in stops.iter().enumerate() {
let Some(c) = parse_hex(stop) else { continue };
let raw = if offsets.len() == stops.len() {
offsets[i]
} else if stops.len() > 1 {
i as f32 / (stops.len() - 1) as f32
} else {
0.0
};
let at = if raw.is_finite() { raw.clamp(0.0, 1.0) } else { floor }.max(floor);
floor = at;
// Un stop translucide (le preset v1.5 `rgba(235,230,44,0.55)` vit dans des projets
// enregistrés) est prémultiplié : le fond est la couche du dessous, posée sur le clear
// noir, donc honorer son alpha revient exactement à `rgb · a`. CSS interpole aussi en
// prémultiplié, d'où la rampe juste entre deux stops d'alphas différents. Le nœud n'a
// pas de place pour l'alpha (w = position), et le shader rend le mode 5 opaque.
knots.push([c[0] * c[3], c[1] * c[3], c[2] * c[3], at]);
}
if knots.is_empty() {
knots.push([fallback[0], fallback[1], fallback[2], 0.0]);
}
// ponytail: quatre nœuds, les emplacements libres du mode 5. Au-delà (les presets v1.5 en
// avaient jusqu'à sept), on retire tour à tour le stop intérieur que ses voisins reproduisent
// le mieux. Une rampe en texture lèverait la limite si un dégradé plus riche devenait courant.
while knots.len() > 4 {
let miss = |i: usize| {
let (p, k, n) = (knots[i - 1], knots[i], knots[i + 1]);
let span = n[3] - p[3];
if span <= 1e-6 {
return 0.0; // stop de largeur nulle : il ne peint rien
}
let f = (k[3] - p[3]) / span;
(0..3).map(|c| (k[c] - (p[c] + (n[c] - p[c]) * f)).abs()).sum::<f32>()
};
let drop = (1..knots.len() - 1).min_by(|&a, &b| miss(a).total_cmp(&miss(b))).unwrap_or(1);
knots.remove(drop);
}
while knots.len() < 4 {
let last = knots[knots.len() - 1];
knots.push(last);
}
LayerCB {
mode: 5.0,
color: knots[0],
src_prev: knots[1],
dst_prev: knots[2],
src: knots[3],
..Default::default()
}
}
/// True when this clip really has a camera to draw.
///
/// TWO ways the app says "no camera", and both must be caught here, because the
/// webcam decoder is opened either way — the live path falls back to the SCREEN
/// file when the webcam path won't open, and `ExportDialog` sends the screen path
/// outright, so the decoder always yields frames. Whether those frames are the
/// camera or a second copy of the screen is decided HERE and nowhere else.
///
/// - the empty string, which is what `sceneDescription.ts` and
/// `NativeCompositorOverlay` send for an asset with no `cameraTrack`;
/// - the screen's own path, which `ExportDialog.tsx` sends and which older
/// scenes still use.
///
/// Missing the empty-string case is what put the screen recording inside the PiP
/// box: `"" != "/…/recording.mp4"`, so the box was drawn, and the decoder behind
/// it was the screen fallback.
pub fn webcam_is_real(webcam_path: &str, screen_path: &str) -> bool {
!webcam_path.trim().is_empty() && !same_source_path(webcam_path, screen_path)
}
impl Default for LiveParams {
fn default() -> Self {
Self {
bg_color: [0.10, 0.11, 0.14, 1.0],
shadow_scale: 1.0,
radius_scale: 1.0,
padding: 0.0,
webcam_size_scale: 1.0,
webcam_mirror: false,
webcam_shape: 3,
cursor_size_scale: 1.0,
cursor_bounce_scale: 1.0,
cursor_motion_blur: 0.0,
cursor_model3d: false,
cursor_auto_hide: false,
has_webcam: true,
}
}
}
/// "rectangle"|"circle"|"square"|"rounded" -> code webcam_shape (0/1/2/3). Partagé entre le
/// live (`live.rs::set_param_str`) et l'export (construit `LiveParams` depuis la scène) — une
/// seule table de vérité pour ce mapping.
pub fn webcam_shape_code(shape: &str) -> u32 {
match shape {
"rectangle" => 0,
"circle" => 1,
"square" => 2,
_ => 3, // "rounded" (défaut)
}
}
/// Construit les `LiveParams` équivalents à ce que l'inspector pousse en live, mais depuis la
/// scène de l'app — l'export est un rendu one-shot sans historique de sliders, donc il doit lire
/// directement la config déjà posée dans la scène plutôt que dupliquer un mécanisme d'inspector.
/// Unités identiques à `RightPanes.tsx` (mêmes conversions, pas de re-normalisation) : voir
/// `sceneDescription.ts` pour la correspondance settings -> champs de scène.
pub fn live_params_from_scene(s: &crate::scene::Scene) -> LiveParams {
LiveParams {
shadow_scale: s.effects.shadow,
// `radius_scale` reste le multiplicateur du chemin INSPECTOR (bench/GUI standalone) ; le
// rayon écran d'une scène vient désormais de `effects.roundness_frac`, lu directement
// dans `compose_frame`. Le faire transiter ici obligeait à le normaliser par un rayon de
// fixture (`p.screen.radius`, 24 px) pour ressortir la valeur de départ — un aller-retour
// qui ne servait qu'à faire passer des pixels pour un ratio.
padding: s.effects.padding,
webcam_size_scale: s.layout.webcam_size,
webcam_mirror: s.layout.webcam_mirror,
webcam_shape: webcam_shape_code(&s.layout.webcam_shape),
cursor_size_scale: s.cursor.size,
cursor_bounce_scale: s.cursor.click_bounce,
cursor_motion_blur: s.cursor.motion_blur,
cursor_model3d: s.cursor.model3d,
cursor_auto_hide: s.cursor.auto_hide,
..LiveParams::default()
}
}
/// Ce que `plan_frame` a besoin de savoir. Rien ici n'est un objet backend : ce sont des
/// dimensions, la scène, et les réglages live. C'est ce qui rend la fonction partageable.
pub struct FrameGeometryInput<'a> {
/// Taille de la cible de rendu en px (`Compositor::rw()`/`rh()` côté Windows,
/// `render_w`/`render_h` côté macOS).
pub render_px: [f32; 2],
/// Dimensions de la TEXTURE écran. Sur D3D11VA elles sont alignées macrobloc
/// (1080 → 1088) ; sur CoreVideo elles sont nominales. L'écart est voulu et c'est
/// exactement pourquoi `u_max`/`v_max` existent — ne jamais supposer texture == visible.
pub screen_tex_px: [f32; 2],
pub screen_visible_px: [f32; 2],
pub webcam_visible_px: [f32; 2],
/// Fraction utile de la texture écran : `visible / texture`.
pub u_max: f32,
pub v_max: f32,
pub frame: f32,
pub cfg: &'a Cfg,
pub live: LiveParams,
pub scene: Option<&'a Scene>,
pub cursor: Option<&'a crate::cursor::CursorTrack>,
pub timeline_t_override: Option<f32>,
/// Temps PROGRAMME (secondes de sortie), continu à travers les coupes et les clips :
/// `frames / out_fps` à l'export, `regions::ProgrammeClock` en preview. `None` = fixture
/// (`frame / FPS`). Voir `FrameGeometry::programme_t`.
pub programme_time: Option<f32>,
}
/// Les 15 valeurs que la moitié « dessin » consomme. Sur les 75 locaux que le calcul
/// produit, 60 meurent avant le premier draw — ce sont ceux-là, et seulement ceux-là,
/// qui traversent.
pub struct FrameGeometry {
pub scene_preset: Option<String>,
/// Continuous PiP shadow weight through a layout change.
pub webcam_shadow: f32,
pub mb_taps: f32,
pub mb_amount: f32,
pub source_t: f32,
/// Horloge des effets qui vivent sur la SORTIE et non sur la source (fond animé) :
/// `source_t` saute à chaque coupe et à chaque clip, pas elle. Recopiée telle quelle de
/// l'entrée, jamais déduite de `frame` — en preview ce compteur n'est qu'un tick, qui
/// diffère entre lecture et seek pour la même image.
pub programme_t: f32,
/// Rotation 3D de BASE (préset × force) : elle seule fixe l'échelle de containment et le
/// choix mode 0 / mode 8.
pub zoom_rotation: [f32; 3],
/// Part dynamique du tilt (parallaxe, `regions::dynamic_tilt`), ajoutée à la base à la
/// projection. Nulle quand la base est neutre.
pub zoom_rotation_dyn: [f32; 3],
/// Caméra réelle de `orbit` (`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 (poids, visée, orbite, zoom), `None` si elle n'y était
/// pas active — même quand elle l'est à cette frame-ci, ou l'inverse.
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],
/// La coupe que montrerait le même écran à plat : le repère du métrage (annotations, effets,
/// gimbal de l'éditeur). Égale à `cut`, sauf sous le remplissage incliné, où `cut` n'est plus
/// que la fenêtre zoomée qu'en montre la carte (`content_to_plane`).
pub content_cut: [f32; 4],
/// Remplissage du format sous un plan incliné : la carte penche dans son slot, fixe, et seul
/// le métrage bouge dedans. Son flou de mouvement reste donc par pixel (`screen_trail`).
pub fill_tilt: bool,
/// Point de focus du zoom (résolu : suivi curseur et rampe compris) en 0..1 DANS la coupe
/// dessinée `cut`, c'est-à-dire dans le plan que le mode 8 incline. Borné au plan : un focus
/// que le cover a rogné retombe sur le bord. C'est lui qui fixe `z_focus` (`depth_mb`).
pub focus_plane: [f32; 2],
/// Réglage « Depth of field » du projet. Ne décide rien seul : voir `depth_of_field_on`.
pub depth_of_field: bool,
pub s_dst: [f32; 4],
pub s_dst_prev: [f32; 4],
/// Boîte écran **sans le zoom** : le conteneur auquel les annotations et les
/// sous-titres sont ancrés — sauf le flou de confidentialité, qui suit le contenu
/// (`privacy_mask`).
///
/// C'est `s_dst` avant le `remap_box` du zoom, donc le rect que l'app a résolu
/// (`layout.screenRect`, que le cadre ne touche pas) et que l'overlay web reçoit comme
/// conteneur. Le contrat de
/// `SceneAnnotation` est explicite : « deliberately NOT affected by the zoom crop — the
/// overlay is a sibling of the element carrying the zoom transform, so annotations hold
/// still while the content zooms underneath them ». Tant que le zoom vivait dans la
/// coupe source, `s_dst` tenait ce rôle ; depuis l'issue #179 il vit dans la BOÎTE, donc
/// `s_dst` grandit et se déplace avec lui — et les annotations le suivaient, sous-titres
/// compris, qui se mettaient à zoomer avec l'écran.
pub s_ann: [f32; 4],
pub s_radius: f32,
pub frame_min_px: f32,
/// L'unité de l'ÉCRAN (`screen_unit_px`) : ce que mesurent le curseur, l'ombre de l'écran et
/// ses coins sans cadre.
pub screen_unit_px: f32,
pub w_dst: [f32; 4],
pub w_dst_prev: [f32; 4],
pub w_px: [f32; 2],
pub w_radius: f32,
pub shape_fade: f32,
/// Cadre autour de l'écran : chrome de fenêtre plat (mode 14) ou appareil modelé (mode 17).
/// `None` : aucun, et le rendu est celui d'avant le cadre, à l'octet. `Some` : `s_dst` est
/// déjà la boîte rétrécie, et `s_radius` le rayon des coins de l'écran — des seuls coins BAS
/// sous une barre de titre (fenêtre, navigateur), des quatre pour les autres appareils.
pub window_frame: Option<WindowFrame>,
/// Layouts en bloc : le slot de l'écran, un conteneur qui le MASQUE (cf. `ScreenMask`).
/// `None` ailleurs, et le rendu est celui d'avant, à l'octet.
pub screen_mask: Option<ScreenMask>,
}
/// Le conteneur d'un layout en bloc (côte à côte, haut/bas) : un masque fixe, overflow hidden.
///
/// L'écran y garde la géométrie de tous les layouts — le zoom dans la boîte (#179), la 3D sur le
/// métrage — et seul son DESSIN est rogné au slot. Sans lui, la boîte zoomée débordait sur la
/// caméra et dans l'espace qui les sépare, et le bloc ne tenait plus. Le masque, lui, ne zoome
/// ni ne penche jamais : le layout garde son rect et ses coins, et son ombre est la sienne.
///
/// Sous un cadre, le cadre EST ce conteneur : fenêtre ou appareil, il reste au repos autour du
/// slot, à plat, et le slot est son ouverture. Le métrage zoome et penche dedans. C'est l'inverse
/// des autres layouts, où l'appareil zoome et penche avec l'écran (`FrameGeometry::frame_box`).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ScreenMask {
/// Le slot, en fractions de la sortie : `layout.screenRect`, que le zoom ne touche pas.
pub rect: [f32; 4],
/// Le rayon de ses coins, en px du render target : celui de l'écran au repos.
pub radius_px: f32,
/// Coins HAUTS carrés : le slot est sous la barre de la fenêtre qui le contient. À plat, le
/// mode 0 le sait déjà (`screen_square_top`) ; incliné, le mode 8 le lit dans le signe de son
/// rayon (`tilted_screen_cb`).
pub square_top: bool,
}
impl ScreenMask {
/// `dst` rogné au slot, en fractions de la sortie. `None` s'il n'en reste rien ; `dst` tel
/// quel, à l'octet, s'il y tient déjà (une intersection recalculée en différerait d'un ulp).
fn clip(&self, dst: [f32; 4]) -> Option<[f32; 4]> {
let [x, y, w, h] = self.rect;
if dst[0] >= x && dst[1] >= y && dst[0] + dst[2] <= x + w && dst[1] + dst[3] <= y + h {
return Some(dst);
}
let r = intersect_rect(dst, self.rect);
(r[2] > 0.0 && r[3] > 0.0).then_some(r)
}
}
/// Redessine un calque WARPÉ (modes 8 et 16 : coins TL/TR dans `fx`, BR/BL dans `src_prev`, en px
/// 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]];
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]];
}
/// Rect de destination d'une annotation dans un rect d'ancrage, en fractions de la sortie.
///
/// Pour le texte, les flèches, les images et les sous-titres, `anchor` est TOUJOURS `s_ann`,
/// le rect écran sans le zoom — jamais `s_dst`. (Le flou passe par
/// `FrameGeometry::privacy_mask`, qui fait l'inverse exprès.) Les deux
/// coïncident sans zoom, ce qui rend l'erreur invisible sur la moitié des scènes ; sous
/// zoom, `s_dst` grandit et emmène annotations et sous-titres avec lui, alors que le
/// contrat de `SceneAnnotation` les veut « deliberately NOT affected by the zoom crop ».
///
/// Version libre plutôt que méthode : Windows déstructure `FrameGeometry` dès l'entrée de
/// `compose_frame`, donc il n'a plus de `&self` à offrir quand il dessine les annotations.
/// Les trois backends partagent malgré tout CETTE arithmétique-ci — le bug est reparu sur
/// Linux après avoir été corrigé sur Windows et macOS (issue #179) parce que chacun en
/// gardait sa copie.
///
/// Attention : le choix du rect passé en `anchor` reste, lui, au call site des backends
/// Metal et D3D (leur `draw_annotations` prend le rect en paramètre). Seul Linux part
/// directement de `FrameGeometry`. Passer `s_dst` ici reste donc possible sur deux
/// backends sur trois — d'où le nom du paramètre côté appelants, et les tests.
pub fn annotation_dst_in(anchor: [f32; 4], x: f32, y: f32, w: f32, h: f32) -> [f32; 4] {
[anchor[0] + x * anchor[2], anchor[1] + y * anchor[3], w * anchor[2], h * anchor[3]]
}
impl FrameGeometry {
/// Le quad de l'écran incliné pour une boîte de `s_px` px, `None` quand l'écran est droit.
/// LE point de passage de l'écran, de son ombre, du curseur et du masque de flou : tous
/// doivent porter la même séparation base / dynamique, sinon ils se décollent.
///
/// Sous la caméra réelle, c'est l'écran vu par elle (`camera::View::quad`), même boîte.
pub fn screen_tilt(&self, s_px: [f32; 2]) -> Option<crate::regions::TiltedQuad> {
if let Some(pose) = self.camera {
return Some(crate::camera::View::new(s_px, pose).quad(s_px));
}
self.tilted().then(|| {
let mut quad = crate::regions::rotated_quad_corners_px(
s_px[0],
s_px[1],
self.zoom_rotation,
self.zoom_rotation_dyn,
);
// Un angle fixe se dessine au warp BILINÉAIRE de ses coins : le rendu des angles fixes
// de la v1.13.0, à l'octet. Sous un cadre d'APPAREIL seulement, l'écran passe au warp
// PROJECTIF : le mode 17 lance ses rayons dans la perspective exacte, et 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. Pas sous le masque d'un
// bloc : l'appareil y reste au repos, le métrage penche seul dans son ouverture, au
// warp de l'écran sans cadre.
if self.window_frame.as_ref().is_some_and(|f| f.kind.is_device())
&& self.screen_mask.is_none()
{
quad.projective = true;
}
quad
})
}
/// Le plan incliné une frame d'écran plus tôt, avec le réglage du flou : d'où part la
/// traînée de l'écran cadré (`screen_trail_cb`), ou celle du seul métrage sous un masque de
/// bloc (`tilt_pixel_trail`). `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 la caméra réelle d'avant
/// (`camera_prev`). Parallaxe et impact restent ceux de la frame, comme le focus du mode 0 : le
/// flou suit le zoom et la caméra, 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)
}
/// La profondeur de champ tourne-t-elle sur CETTE frame ? Réglage allumé, écran réellement
/// incliné (à plat le mode 8 n'est pas dessiné), et backend qui en a les moyens (cf.
/// `DOF_ON_CPU_BACKEND`). Une seule réponse pour les trois backends : elle décide à la fois
/// du remplissage de la pyramide et du `k` du mode 8, qui ne doivent jamais diverger.
pub fn depth_of_field_on(&self, cpu_backend: bool) -> bool {
self.depth_of_field && self.tilted() && (DOF_ON_CPU_BACKEND || !cpu_backend)
}
/// `annotation_dst_in` appliqué à `s_ann`, pour les backends qui tiennent la géométrie
/// entière — c'est-à-dire ceux qui n'ont aucune raison de choisir un rect.
pub fn annotation_dst(&self, x: f32, y: f32, w: f32, h: f32) -> [f32; 4] {
annotation_dst_in(self.s_ann, x, y, w, h)
}
/// Hauteur en px du rect d'ancrage des annotations, pour `rh` px de sortie.
///
/// `font_size_rel` est une fraction de cette hauteur (cf. `annotationScale.ts`) :
/// la prendre sur `s_dst` ferait grossir le texte avec le zoom, exactement comme
/// `annotation_dst` le déplacerait.
pub fn annotation_anchor_h_px(&self, rh: f32) -> f32 {
self.s_ann[3] * rh
}
/// 1 quand l'écran garde ses coins HAUTS carrés : sous le chrome de FENÊTRE, et là seulement.
/// Le mode 0 le lit dans `mb.w`, le mode 8 dans `dst_prev.z` — deux emplacements que ces
/// modes laissaient à zéro, d'où un rendu inchangé sans fenêtre.
///
/// Sous une barre de titre, l'arrondi du haut se fait UNE fois, par le cadre : l'écran est à
/// ras de la barre, sans encoche. L'arrondir lui aussi ouvrait une encoche couleur de barre
/// dans chaque coin haut (constaté en produit). Le téléphone, lui, n'a pas de barre : son
/// écran est arrondi aux quatre coins, concentrique au corps (« Le rayon des coins »).
pub fn screen_square_top(&self) -> f32 {
match self.window_frame.as_ref().map(|f| f.kind) {
Some(crate::scene::SceneFrame::Window) => 1.0,
_ => 0.0,
}
}
/// L'écran cadré se déplace-t-il EN BLOC sous le flou de mouvement sur cette frame ?
///
/// La coupe est la même aux deux frames : tout le mouvement de l'écran vient de sa boîte,
/// `s_dst_prev` → `s_dst`, et incliné, du plan qui la montre (`tilt_trail`). L'ombre, le cadre
/// et l'appareil sont taillés dans cette boîte et posés sur ce plan. C'est donc un objet
/// rigide, et on le floute comme tel (mode 18, `screen_trail_cb`) : flouter le seul métrage
/// laissait un contenu qui file dans un cadre aux bords nets, et sous une caméra 3D, c'était
/// le cas de tout zoom.
///
/// Incliné, le plan a bougé quand ses coins ont bougé : sans mouvement, ceux de `tilt_trail`
/// sont les siens au bit près, et le rendu reste celui d'avant, à l'octet.
///
/// Pas sous un masque de bloc ni sous le remplissage incliné : la case ou la carte ne bouge
/// pas, seul le métrage bouge dedans, et le flou par pixel (modes 0 et 8) reste le bon.
pub fn screen_trail(&self, render_px: [f32; 2]) -> bool {
if self.mb_taps < 2.0 || self.mb_amount <= 0.001 || self.screen_mask.is_some() || self.fill_tilt
{
return false;
}
match self.screen_tilt_in(render_px) {
None => self.s_dst != self.s_dst_prev,
Some(quad) => self.tilt_trail(render_px).is_some_and(|t| t.corners != quad.corners),
}
}
/// Taps du flou PAR PIXEL du mode 0 de l'écran : un seul quand `screen_trail` floute déjà
/// l'objet entier, sinon le métrage serait flouté deux fois.
pub fn screen_pixel_taps(&self, render_px: [f32; 2]) -> f32 {
if self.screen_trail(render_px) { 1.0 } else { self.mb_taps }
}
/// La traînée PAR PIXEL du mode 8 : `tilt_trail`, sauf quand `screen_trail` floute déjà
/// l'objet entier. Le masque de confidentialité, lui, lit toujours `tilt_trail` : les deux
/// flous étalent le secret sur le même chemin.
pub fn tilt_pixel_trail(&self, render_px: [f32; 2]) -> Option<TiltTrail> {
self.tilt_trail(render_px).filter(|_| !self.screen_trail(render_px))
}
/// Le calque du mode 18 : le rendu isolé de l'écran cadré (t2), recomposé le long de sa
/// trajectoire. `src` = la coupe (le métrage relu directement là où le rendu isolé s'arrête
/// au bord de la sortie), `quad_px` et `radius_px` = l'écran et ses coins : ce repli ne lit le
/// métrage que dans l'ouverture arrondie, jamais sous la lunette d'un appareil.
///
/// À plat, la trajectoire est celle de la boîte : `fx` = la courante, `dst_prev` = la
/// précédente. Incliné (`mb.z` = 1), celle du plan : ses coins TL, TR, BR, BL courants dans
/// `fx`/`src_prev` et ceux de `tilt_trail` dans `trail_a`/`trail_b`, en fractions de la
/// sortie comme la boîte ; `quad_px` et `radius_px` sont alors pris dans le plan, comme au
/// mode 8. `mb.w` = le warp du plan (`TiltedQuad::warp_flag`, bilinéaire sous un angle fixe,
/// projectif sous la caméra réelle ou un appareil) : le shader passe par lui dans les deux
/// sens, comme le mode 8 qui a dessiné le métrage.
///
/// Le métrage relu hors de la sortie l'est comme le mode 8 l'a dessiné : incliné, `trail_mb`
/// porte SA profondeur de champ (son `mb` ; `dof` = `depth_of_field_on`, vrai quand la
/// pyramide est liée) et `color.xy` sa lampe. Nuls à plat : le repli relit le métrage net.
pub fn screen_trail_cb(&self, render_px: [f32; 2], dof: bool) -> LayerCB {
let s_px = [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]];
let flat = LayerCB {
dst: [0.0, 0.0, 1.0, 1.0],
src: self.cut,
quad_px: s_px,
radius_px: self.s_radius,
mode: 18.0,
fx: self.s_dst,
dst_prev: self.s_dst_prev,
mb: [self.mb_taps, self.mb_amount, 0.0, 0.0],
..Default::default()
};
let (Some(quad), Some(trail)) = (self.screen_tilt_in(render_px), self.tilt_trail(render_px))
else {
return flat;
};
let c = self.screen_center_px(render_px);
let out = |(x, y): (f32, f32)| [(c[0] + x) / render_px[0], (c[1] + y) / render_px[1]];
let [tl, tr, br, bl] = quad.corners.map(out);
let [ptl, ptr, pbr, pbl] = trail.corners.map(out);
// Le calque que le mode 8 dessine pour ce plan : sa profondeur de champ et sa lampe ne
// dépendent ni du rayon, ni du chrome, ni d'un masque.
let plane = tilted_screen_cb(&quad, s_px, c, self.cut, self.focus_plane, 0.0, 0.0, dof, render_px, None, None);
LayerCB {
quad_px: s_px.map(|v| v * quad.scale),
radius_px: self.s_radius * quad.scale,
color: [plane.color[0], plane.color[1], 0.0, 0.0],
fx: [tl[0], tl[1], tr[0], tr[1]],
src_prev: [br[0], br[1], bl[0], bl[1]],
trail_a: [ptl[0], ptl[1], ptr[0], ptr[1]],
trail_b: [pbr[0], pbr[1], pbl[0], pbl[1]],
mb: [self.mb_taps, self.mb_amount, 1.0, quad.warp_flag()],
trail_mb: plane.mb,
..flat
}
}
/// Sous le chrome de fenêtre, de combien son contour INTÉRIEUR remonte au-dessus du bord haut
/// de l'écran, en px de l'écran droit : la barre de titre moins le filet. 0 ailleurs.
///
/// C'est ce qui garde l'arrondi « une seule fois, par le cadre » vrai à TOUT rayon. Tant que
/// le rayon tient dans la barre, l'arc du cadre reste au-dessus de l'écran et ses coins hauts
/// carrés sont entièrement dedans. Au-delà, l'arc descend sous la barre : un écran carré en
/// sortirait. Le shader rogne alors ses coins hauts par ce même arc, pris au contour
/// intérieur du filet (`sd_screen_under_bar`) — l'écran suit le cadre, il ne s'arrondit pas
/// de son côté. Le mode 0 le lit dans `mb.z`, le mode 8 dans `color.z` (px du plan).
///
/// Sous le masque d'un bloc, la fenêtre reste au repos autour du slot : la remontée est la
/// sienne, et le métrage droit, rogné au slot, épouse son contour. Incliné, il penche DANS la
/// fenêtre, arrondi de partout comme sans cadre : 0.
pub fn screen_top_lift_px(&self, render_px: [f32; 2]) -> f32 {
match self.window_frame.as_ref() {
Some(_) if self.screen_mask.is_some() && self.tilted() => 0.0,
Some(f) if f.kind == crate::scene::SceneFrame::Window => {
let b = self.frame_box();
let (s_w, s_h) = (b[2] * render_px[0], b[3] * render_px[1]);
(f.margins[1] * s_h - f.margins[0] * s_w).max(0.0)
}
_ => 0.0,
}
}
/// La boîte autour de laquelle le cadre se construit. Sous le masque d'un bloc, le cadre EST
/// le conteneur (`ScreenMask`) : le slot au repos, ni zoomé ni incliné. Ailleurs, la boîte
/// écran : le cadre zoome avec elle (#179).
fn frame_box(&self) -> [f32; 4] {
self.screen_mask.map_or(self.s_dst, |m| m.rect)
}
/// Le plan du cadre : celui de l'écran, sauf sous le masque d'un bloc, où le cadre reste à
/// plat pendant que le métrage penche dedans.
fn frame_tilt(&self, render_px: [f32; 2]) -> Option<crate::regions::TiltedQuad> {
if self.screen_mask.is_some() {
return None;
}
self.screen_tilt_in(render_px)
}
/// Le rayon des coins du métrage autour duquel le cadre s'arrondit : celui du slot au repos
/// sous le masque d'un bloc, celui de la boîte écran ailleurs.
fn frame_screen_radius(&self) -> f32 {
self.screen_mask.map_or(self.s_radius, |m| m.radius_px)
}
fn frame_center_px(&self, render_px: [f32; 2]) -> [f32; 2] {
let b = self.frame_box();
[(b[0] + b[2] * 0.5) * render_px[0], (b[1] + b[3] * 0.5) * render_px[1]]
}
/// Le plan incliné de l'écran, `None` quand il est droit. Même appel que les backends : un
/// calcul déterministe, donc le même quadrilatère au bit près.
fn screen_tilt_in(&self, render_px: [f32; 2]) -> Option<crate::regions::TiltedQuad> {
self.screen_tilt([self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]])
}
fn screen_center_px(&self, render_px: [f32; 2]) -> [f32; 2] {
[
(self.s_dst[0] + self.s_dst[2] * 0.5) * render_px[0],
(self.s_dst[1] + self.s_dst[3] * 0.5) * render_px[1],
]
}
/// Les coins TL, TR, BR, BL du cadre, en px relatifs au centre de l'écran, plus l'échelle du
/// plan (1 à plat). Incliné, c'est le MÊME `TiltedQuad` que l'écran, prolongé au-delà de
/// 0..1 : un warp bilinéaire est entièrement fixé par ses quatre coins, donc le prolonger
/// donne exactement le plan que le mode 8 dessine, et le cadre penche avec l'écran sans
/// aucune trigonométrie de plus. Sous la caméra réelle, le prolongement est celui de
/// l'homographie, et le drapeau rendu (`TiltedQuad::warp_flag`) le dit au mode 14. Sous le
/// masque d'un bloc, le cadre est droit autour du slot (`frame_box`), coins relatifs au centre
/// de celui-ci.
fn window_frame_corners(
&self,
margins: [f32; 4],
render_px: [f32; 2],
) -> ([(f32, f32); 4], f32, f32) {
let [ml, mt, mr, mb] = margins;
let quad = self.frame_tilt(render_px).unwrap_or_else(|| {
let b = self.frame_box();
let (hw, hh) = (b[2] * render_px[0] * 0.5, b[3] * render_px[1] * 0.5);
crate::regions::TiltedQuad {
corners: [(-hw, -hh), (hw, -hh), (hw, hh), (-hw, hh)],
scale: 1.0,
depth_k: (0.0, 0.0),
rot: [0.0; 3],
perspective: 0.0,
offset: [0.0; 2],
projective: false,
lamp: false,
}
});
let corners = [
quad.point_px(-ml, -mt),
quad.point_px(1.0 + mr, -mt),
quad.point_px(1.0 + mr, 1.0 + mb),
quad.point_px(-ml, 1.0 + mb),
];
(corners, quad.scale, quad.warp_flag())
}
/// Ce qui porte l'ombre portée : le chrome de fenêtre quand il y en a un — sinon l'ombre
/// tomberait sous l'écran seul et la barre de titre flotterait au-dessus d'elle —, l'écran
/// sinon, avec exactement l'arithmétique que les backends faisaient avant le cadre. Un
/// APPAREIL ne passe pas par ici : son ombre suit la silhouette du modèle (`device_shadow_cb`),
/// qu'un quad plat ne sait pas porter.
pub fn shadow_caster(&self, render_px: [f32; 2]) -> ShadowCaster {
// Le cadre porte l'ombre, là où il est : au repos autour du slot sous le masque d'un bloc.
if let Some(frame) = &self.window_frame {
return match self.frame_tilt(render_px) {
None => {
let [ml, mt, mr, mb] = frame.margins;
let d = self.frame_box();
let dst = [
d[0] - ml * d[2],
d[1] - mt * d[3],
d[2] * (1.0 + ml + mr),
d[3] * (1.0 + mt + mb),
];
ShadowCaster::Upright {
dst,
size_px: [dst[2] * render_px[0], dst[3] * render_px[1]],
radius: frame.radius[0],
}
}
Some(_) => {
let (corners, scale, _) = self.window_frame_corners(frame.margins, render_px);
ShadowCaster::Tilted {
corners,
center_px: self.frame_center_px(render_px),
radius: frame.radius[0] * scale,
mask: None,
}
}
};
}
// Sous le masque d'un layout en bloc, l'ombre est celle de ce qu'on voit. Droite, la boîte
// zoomée couvre tout le slot : c'est le slot, qui ne zoome pas. Inclinée, le plan rogné
// par le slot (`mask` du quad).
match (self.screen_mask, self.screen_tilt_in(render_px)) {
(Some(mask), None) => ShadowCaster::Upright {
dst: mask.rect,
size_px: [mask.rect[2] * render_px[0], mask.rect[3] * render_px[1]],
radius: mask.radius_px,
},
(None, None) => ShadowCaster::Upright {
dst: self.s_dst,
size_px: [self.s_dst[2] * render_px[0], self.s_dst[3] * render_px[1]],
radius: self.s_radius,
},
(mask, Some(quad)) => ShadowCaster::Tilted {
corners: quad.corners,
center_px: self.screen_center_px(render_px),
radius: self.s_radius * quad.scale,
mask,
},
}
}
/// L'écran droit (mode 0) sous le masque d'un layout en bloc : `dst` rogné au slot, `src`
/// d'autant (même mapping image→écran), et les coins du slot. Sans masque, les valeurs du
/// backend repartent telles quelles, à l'octet. Le flou de mouvement n'a rien à suivre : il
/// lit la frame précédente par `dst_prev`/`src_prev`, que le masque ne touche pas.
pub fn mask_flat_screen(
&self,
dst: [f32; 4],
src: [f32; 4],
quad_px: [f32; 2],
radius_px: f32,
render_px: [f32; 2],
) -> ([f32; 4], [f32; 4], [f32; 2], f32) {
let Some(mask) = self.screen_mask else { return (dst, src, quad_px, radius_px) };
let clipped = intersect_rect(dst, mask.rect);
let u = |x: f32| src[0] + (x - dst[0]) / dst[2] * (src[2] - src[0]);
let v = |y: f32| src[1] + (y - dst[1]) / dst[3] * (src[3] - src[1]);
let [x0, y0, w, h] = clipped;
(
clipped,
[u(x0), v(y0), u(x0 + w), v(y0 + h)],
[w * render_px[0], h * render_px[1]],
mask.radius_px,
)
}
/// Décalage de l'ombre portée de l'écran, en px de sortie : vers le bas sous un écran droit
/// ou un angle fixe (inchangé) ; sous la caméra réelle, le long de la lumière qui éclaire aussi
/// la flèche modélisée (`MODEL_LIGHT`), pour que les deux ombres tombent du même côté. La
/// direction glisse avec le poids de la caméra : aucun saut à l'entrée du zoom. Sous le masque
/// d'un layout en bloc, l'ombre est celle du slot, que la caméra ne fait pas tourner.
pub fn screen_shadow_offset(&self) -> [f32; 2] {
let off = SCREEN_SHADOW_OFFSET_FRAC * self.screen_unit_px;
if self.screen_mask.is_some() {
return [0.0, off];
}
let Some(pose) = self.camera else { return [0.0, off] };
let (lx, ly) = (-MODEL_LIGHT[0], -MODEL_LIGHT[1]);
let n = lx.hypot(ly);
let w = pose.weight.clamp(0.0, 1.0);
let dir = [lx / n * w, ly / n * w + (1.0 - w)];
let len = dir[0].hypot(dir[1]).max(1e-6);
[off * dir[0] / len, off * dir[1] / len]
}
/// Le calque du cadre qui passe SOUS l'écran, à dessiner après l'ombre et AVANT lui : le
/// chrome de fenêtre (mode 14). `None` sans cadre.
///
/// Une seule forme pour le cas droit et le cas incliné : le mode 14 fait toujours le warp
/// inverse du mode 8, et sur un rect ce warp est l'identité exacte (le terme quadratique est
/// nul). Le calque se construit donc ici, une fois, pour les trois backends.
///
/// Sous le masque d'un bloc, un APPAREIL y pose le verre de son écran (mode 1, le slot et ses
/// coins) : là où le métrage incliné ne couvre plus l'ouverture, on voit l'écran éteint, pas
/// un trou vers le fond d'écran. Ailleurs, l'appareil n'a rien sous l'écran.
pub fn window_frame_cb(&self, render_px: [f32; 2]) -> Option<LayerCB> {
let frame = self.window_frame.as_ref()?;
let [rw, rh] = render_px;
if frame.kind.is_device() {
let mask = self.screen_mask?;
return Some(LayerCB {
dst: mask.rect,
quad_px: [mask.rect[2] * rw, mask.rect[3] * rh],
radius_px: mask.radius_px,
mode: 1.0,
color: device_glass_rgba(frame.dark),
..Default::default()
});
}
let (corners, scale, warp) = self.window_frame_corners(frame.margins, render_px);
let center = self.frame_center_px(render_px);
let (min_x, max_x) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
let bbox = [(max_x - min_x).max(1.0), (max_y - min_y).max(1.0)];
let local = |(x, y): (f32, f32)| [x - min_x, y - min_y];
let [tl, tr, br, bl] = corners.map(local);
let [ml, mt, mr, mb] = frame.margins;
let b = self.frame_box();
let (s_w, s_h) = (b[2] * rw, b[3] * rh);
// Dimensions dans le repère du plan, avant projection, comme `plane_px` au mode 8.
let plane_px = [s_w * (1.0 + ml + mr) * scale, s_h * (1.0 + mt + mb) * scale];
let (bar_px, line_px) = (mt * s_h * scale, ml * s_w * scale);
let (fill, line) = if frame.dark {
([0.165, 0.165, 0.180, 1.0], [1.0, 1.0, 1.0, 0.14])
} else {
([0.925, 0.925, 0.935, 1.0], [0.0, 0.0, 0.0, 0.16])
};
Some(LayerCB {
dst: [(center[0] + min_x) / rw, (center[1] + min_y) / rh, bbox[0] / rw, bbox[1] / rh],
// `src.x` : 1 = warp projectif (caméra réelle). Le mode 14 ne lit pas d'UV.
src: [warp, 0.0, 0.0, 0.0],
quad_px: bbox,
radius_px: frame.radius[0] * scale,
mode: 14.0,
color: fill,
fx: [tl[0], tl[1], tr[0], tr[1]],
src_prev: [br[0], br[1], bl[0], bl[1]],
dst_prev: [plane_px[0], plane_px[1], bar_px, line_px],
mb: line,
..Default::default()
})
}
/// La caméra qui voit le plan de l'écran, reconstruite pour les calques lancés de rayons
/// (mode 17). Sous un angle fixe ou la caméra réelle c'est celle du plan ; à plat, l'identité
/// avec la MÊME distance de fuite que les présets. Le relief du modèle, lui, est vu d'un œil
/// reculé sur la même droite (`DEV_EYE_MIN`, `DeviceView::project`). Sous le masque d'un bloc,
/// l'appareil au repos autour du slot (`frame_box`).
fn device_view(&self, render_px: [f32; 2]) -> Option<DeviceView> {
let [rw, rh] = render_px;
let b = self.frame_box();
let (s_w, s_h) = (b[2] * rw, b[3] * rh);
if !(s_w > 1.0) || !(s_h > 1.0) {
return None;
}
let quad = self.frame_tilt(render_px);
let perspective = quad
.as_ref()
.map(|q| q.perspective)
.filter(|p| *p > 1.0)
.unwrap_or_else(|| s_w.min(s_h) * crate::regions::PERSPECTIVE_FACTOR);
let scale = quad.as_ref().map(|q| q.scale).unwrap_or(1.0);
let u = self.frame_unit_px(render_px);
let unit = u * scale;
if !(unit > 1.0) {
return None;
}
Some(DeviceView {
rot: quad.as_ref().map(|q| q.rot).unwrap_or([0.0; 3]),
perspective,
offset: quad.as_ref().map(|q| q.offset).unwrap_or([0.0; 2]),
unit,
center: self.frame_center_px(render_px),
half: [0.5 * s_w / u, 0.5 * s_h / u],
})
}
/// L'unité du cadre (`frame_unit_px`) de la boîte autour de laquelle il se construit — la boîte
/// écran, zoom compris, ou le slot au repos sous le masque d'un bloc —, en px de la boîte
/// droite : ce que mesurent les marges, les rayons et le modèle d'un appareil.
pub fn frame_unit_px(&self, render_px: [f32; 2]) -> f32 {
let b = self.frame_box();
frame_unit_px([b[2] * render_px[0], b[3] * render_px[1]], render_px)
}
/// Le calque de l'appareil modelé (mode 17), à dessiner APRÈS l'écran. `None` sans cadre ou
/// sous le chrome plat (mode 14).
///
/// Après et non avant : le socle d'un portable passe DEVANT le plan du métrage, et la lunette
/// mord dessus. Le shader s'arrête là où le métrage l'occulte (le plan z = 0 restreint à
/// l'ouverture), donc tout ce qui est derrière lui reste caché.
///
/// **Emplacements du cbuffer du mode 17** — les trois shaders en sont le miroir, et c'est
/// cette liste qui fait foi. Toutes les longueurs du modèle sont en UNITÉS DU MODÈLE, c'est-
/// à-dire en unités du cadre (`frame_unit_px`, cf. `DeviceView`).
///
/// | champ | contenu |
/// |---|---|
/// | `dst` / `quad_px` | boîte de dessin : l'empreinte projetée du modèle, bords entiers |
/// | `src.xy` | coin haut-gauche de cette boîte, en px relatifs à la projection du CENTRE du plan |
/// | `src.z` | distance de fuite `P` (px) |
/// | `src.w` | l'unité du modèle en px (unité du cadre × échelle de containment) |
/// | `radius_px` | rayon extérieur du corps, coins HAUTS (unités) |
/// | `color.r` | l'appareil : 1 portable, 2 téléphone, 3 moniteur (`device_kind_id`) |
/// | `color.g` | 1 = thème sombre (graphite), 0 = clair (argent) |
/// | `color.b` | rayon extérieur du corps, coins BAS (unités) |
/// | `color.a` | opacité du calque |
/// | `fx.xyz` | rotation dessinée du plan (X, Y, Z), en RADIANS |
/// | `fx.w` | épaisseur du corps (unités) : il occupe z de −`fx.w` à 0 |
/// | `src_prev` | marges du corps autour de l'écran : gauche, haut, droite, bas (unités) |
/// | `mb.xy` | demi-taille de l'écran (unités) : `[s_w, s_h] / 2u` |
/// | `mb.zw` | translation du plan dans le repère caméra (px, nulle sous un angle fixe) |
/// | `dst_prev.x` | angle du socle du portable depuis le plan, radians (`device_deck_angle`) |
/// | `dst_prev.y` | rayon des coins de l'OUVERTURE (unités) : celui du métrage, `s_radius`, pour tous |
/// | `dst_prev.z` | recouvrement de la lunette sur le métrage (unités) : `DEV_OVERLAP_PX` pixels |
/// | `dst_prev.w` | 0 ici ; la pénombre en px pour le calque d'OMBRE (`device_shadow_cb`) |
///
/// Le plan proche (`device_near_plane`) n'a pas d'emplacement : les shaders le tirent de
/// `src.z / src.w` et de `mb.xy`.
pub fn device_frame_cb(&self, render_px: [f32; 2]) -> Option<LayerCB> {
let frame = self.window_frame.as_ref().filter(|f| f.kind.is_device())?;
let [rw, rh] = render_px;
let view = self.device_view(render_px)?;
let (body_c, body_h) = view.body_rect(frame.margins);
let thick = device_thickness(frame.kind);
let [bl, bt, br_, bb] = view.body_margins(frame.margins);
// Le socle est vu par la tranche depuis la caméra droite (`device_deck_angle`) ; le
// shader lit l'angle dans `dst_prev.x`, jamais une constante.
let deck_angle = device_deck_angle(view.half, bb, thick);
let u = self.frame_unit_px(render_px);
// UNE forme de coin pour le métrage et l'ouverture : le rayon du métrage, en unités (celui
// du slot au repos sous le masque d'un bloc, qui rogne le métrage à cette ouverture).
let aperture_radius = self.frame_screen_radius() / u;
// Le recouvrement se compte en PIXELS : exprimé en unités, il fondait à 1,2 px sur un petit
// écran, sous la somme des deux antialiasings (celui du métrage, celui de la lunette).
let overlap = DEV_OVERLAP_PX / view.unit.max(1.0);
// Le corps est concentrique au bord VISIBLE de la lunette : l'ouverture, le contour du
// métrage rentré du recouvrement (rayon `r − recouvrement`, les mêmes centres), sous une
// bordure d'autant plus large. Tant que le métrage s'arrondit plus que le recouvrement,
// c'est `frame.radius` (`r + b`) ; en deçà, l'ouverture a un coin vif rentré d'un pixel et
// quart, et le corps s'arrondit autour de CE coin — sans quoi la lunette y gagnait un
// demi-pixel sur la diagonale.
let inner = (aperture_radius - overlap).max(0.0);
// Portable et moniteur : coque à rayons fixes, l'ouverture seule suit le slider.
let [top, bottom] = device_shell_radius(frame.kind)
.unwrap_or_else(|| [bt, bb].map(|b| concentric_radius(inner, bl + overlap, b + overlap)));
let [x0, y0, x1, y1] = view.footprint(frame.kind, body_c, body_h, thick, deck_angle)?;
// Bords entiers : `local` vaut alors k + 0,5 au centre des pixels, comme le rastériseur.
let (x0, y0, x1, y1) = (x0.floor(), y0.floor(), x1.ceil(), y1.ceil());
let (bw, bh) = ((x1 - x0).max(1.0), (y1 - y0).max(1.0));
let r = view.rot.map(f32::to_radians);
Some(LayerCB {
dst: [x0 / rw, y0 / rh, bw / rw, bh / rh],
src: [x0 - view.center[0], y0 - view.center[1], view.perspective, view.unit],
quad_px: [bw, bh],
radius_px: top,
mode: 17.0,
color: [device_kind_id(frame.kind), frame.dark as u8 as f32, bottom, 1.0],
fx: [r[0], r[1], r[2], thick],
src_prev: [bl, bt, br_, bb],
mb: [view.half[0], view.half[1], view.offset[0], view.offset[1]],
dst_prev: [deck_angle, aperture_radius, overlap, 0.0],
..Default::default()
})
}
/// L'ombre portée d'un APPAREIL : le calque du mode 17 en mode ombre (`dst_prev.w` = pénombre
/// `spread`, px), à dessiner à la place de `shadow_caster`, avant l'écran. `None` sans
/// appareil : la fenêtre garde son ombre de quad, exacte pour un rect arrondi plat.
///
/// Un quad plat étiré dans le plan de l'écran ne peut pas porter l'ombre d'un objet qui en
/// sort : sous le portable, il se lisait comme une dalle grise bien plus longue que le socle.
/// Le shader marche donc le modèle lui-même, et l'ombre a exactement sa silhouette projetée,
/// socle, col et pied compris, avec la pénombre, le décalage et l'opacité de celle de l'écran.
///
/// Le décalage passe par `src.xy` et non par un emplacement à lui : le pixel `X` de l'ombre
/// lance le rayon du pixel `X − offset`. La boîte, elle, est celle de l'appareil élargie de la
/// pénombre et décalée de `offset` — rien ne peut en sortir.
pub fn device_shadow_cb(
&self,
render_px: [f32; 2],
spread: f32,
offset: [f32; 2],
opacity: f32,
) -> Option<LayerCB> {
let mut cb = self.device_frame_cb(render_px)?;
let [rw, rh] = render_px;
let spread = spread.max(0.5);
let (dx, dy) = (cb.dst[0] * rw, cb.dst[1] * rh);
let x0 = (dx - spread + offset[0]).floor();
let y0 = (dy - spread + offset[1]).floor();
let x1 = (dx + cb.quad_px[0] + spread + offset[0]).ceil();
let y1 = (dy + cb.quad_px[1] + spread + offset[1]).ceil();
let (bw, bh) = (x1 - x0, y1 - y0);
cb.dst = [x0 / rw, y0 / rh, bw / rw, bh / rh];
cb.quad_px = [bw, bh];
cb.src[0] += x0 - offset[0] - dx;
cb.src[1] += y0 - offset[1] - dy;
cb.color[3] = opacity;
cb.dst_prev[3] = spread;
Some(cb)
}
/// Où dessiner le masque d'une annotation « flou » pour qu'il couvre le CONTENU qu'il
/// cachait au repos, et à quelle force. `None` si le rect est dégénéré.
///
/// C'est l'exception au contrat de `annotation_dst_in`, et elle est voulue. Une flèche ou un
/// texte peuvent rester immobiles pendant que l'image zoome dessous ; un masque de
/// confidentialité, non : ancré sur `s_ann`, il masquait un rectangle FIXE de la sortie
/// pendant que le mot de passe grossissait dans `s_dst` et sortait de dessous — en preview
/// comme dans le fichier exporté.
///
/// Le contenu à la fraction `f` de l'écran tombe exactement en `s_dst.xy + f * s_dst.wh` :
/// la coupe source ne dépend pas du zoom (elle est prise à zoom 1), seul `s_dst` en porte
/// l'agrandissement. Sous un préset 3D il tombe en `centre + quad.point_px(f)`, le warp que
/// le mode 8 inverse ; un warp bilinéaire restreint à un sous-rectangle est le warp
/// bilinéaire de ses quatre coins, donc warper ces coins-là est exact.
///
/// Tout arrondi va du côté du SUR-masquage : 1 px de marge autour du rect, la trace du flou
/// de mouvement incluse, et une force qui ne descend jamais sous celle du repos.
pub fn privacy_mask(
&self,
annotation: &crate::scene::SceneAnnotation,
render_px: [f32; 2],
) -> Option<PrivacyMask> {
let [rw, rh] = render_px;
let (x, y, w, h) = (annotation.x, annotation.y, annotation.w, annotation.h);
if w <= 0.0 || h <= 0.0 || rw <= 0.0 || rh <= 0.0 {
return None;
}
// Un sous-titre (`space: "frame"`) se mesure sur le cadre de sortie, que le zoom ne
// touche pas. Aucune annotation flou n'envoie la clé aujourd'hui ; si un jour c'est le
// cas, elle garde le comportement du cadre.
if annotation.in_frame_space() {
let dst = annotation_dst_in([0.0, 0.0, 1.0, 1.0], x, y, w, h);
let dst = pad_rect(dst, render_px, PRIVACY_MASK_PAD_PX);
return Some(PrivacyMask::upright(dst, render_px, 1.0));
}
let upright = annotation_dst_in(self.s_dst, x, y, w, h);
// Grossissement du zoom : le contenu grandit de `s_dst / s_ann`, le grain du masque doit
// grandir d'autant, sinon une mosaïque de 12 px ne moyenne plus que 6 px de source sur
// un zoom x2 et le texte redevient lisible.
let zoom_k =
if self.s_ann[3] > 0.0 { (self.s_dst[3] / self.s_ann[3]).max(1.0) } else { 1.0 };
if !self.tilted() {
// Le mode 0 étale chaque pixel entre sa position courante et celle de la frame
// précédente (`dst_prev = s_dst_prev`) : pendant une rampe de zoom, une copie traînée
// du secret sort du rect courant. Chaque coordonnée étalée reste entre ses deux
// extrémités, donc la boîte englobante des deux rects la contient.
// Mêmes conditions que le shader : `(int) mb.x > 1` et `saturate(mb.y) > 0.001`.
let trail = self.mb_taps >= 2.0 && self.mb_amount > 0.001 && self.s_dst_prev != self.s_dst;
let rect = if trail {
union_rect(upright, annotation_dst_in(self.s_dst_prev, x, y, w, h))
} else {
upright
};
let dst = pad_rect(rect, render_px, PRIVACY_MASK_PAD_PX * zoom_k);
// Sous le masque d'un layout en bloc, rien n'est dessiné hors du slot : rien à y
// cacher, et un masque y flouterait la caméra.
let (dst, clipped) = match self.screen_mask {
Some(m) => {
let c = m.clip(dst)?;
(c, c != dst)
}
None => (dst, false),
};
let mut mask = PrivacyMask::upright(dst, render_px, zoom_k);
// Un ovale inscrit dans la boîte ÉLARGIE ne contient plus l'ovale courant dès que
// les deux centres diffèrent : son bord laisserait passer une frange du secret. On
// retombe alors sur le rectangle, comme le tracé libre. Même chose dans la boîte
// ROGNÉE par le slot.
mask.oval_ok = !trail && !clipped;
return Some(mask);
}
// Écran incliné. Même quad et même centre que le dessin de l'écran et que `plan_cursor`.
let s_px = [self.s_dst[2] * rw, self.s_dst[3] * rh];
let quad = self.screen_tilt(s_px)?;
let centre = [
(self.s_dst[0] + self.s_dst[2] * 0.5) * rw,
(self.s_dst[1] + self.s_dst[3] * 0.5) * rh,
];
// Sous le remplissage incliné, le plan ne montre que la fenêtre zoomée (`cut`) d'un
// métrage dont l'annotation donne les fractions (`content_cut`) : le grossissement et la
// boîte sont ceux du même écran à plat. Ailleurs, l'échelle vaut 1 au bit près.
let scale = self.content_scale();
let zoom_k = zoom_k * scale[1];
let content_px = [s_px[0] * scale[0], s_px[1] * scale[1]];
// La marge se prend en fraction du contenu, comme sur le chemin droit : `zoom_k` px de
// la boîte zoomée, soit un pixel de la boîte au repos. La projection l'emmène ensuite
// avec le contenu qu'elle borde.
let (mx, my) = (
PRIVACY_MASK_PAD_PX * zoom_k / content_px[0].max(1.0),
PRIVACY_MASK_PAD_PX * zoom_k / content_px[1].max(1.0),
);
let [x0, y0] = self.content_to_plane([x - mx, y - my]);
let [x1, y1] = self.content_to_plane([x + w + mx, y + h + my]);
// Rogné à la carte du remplissage : ce qu'elle ne montre pas n'a rien à cacher, et un
// masque hors d'elle flouterait le fond.
let (x0, y0, x1, y1) = if self.fill_tilt {
(x0.max(0.0), y0.max(0.0), x1.min(1.0), y1.min(1.0))
} else {
(x0, y0, x1, y1)
};
if x1 <= x0 || y1 <= y0 {
return None;
}
let at = |fx: f32, fy: f32| {
let (px, py) = quad.point_px(fx, fy);
[centre[0] + px, centre[1] + py]
};
let pts = [at(x0, y0), at(x1, y0), at(x1, y1), at(x0, y1)];
// La perspective grossit localement le côté proche : la force suit l'arête la plus
// agrandie par rapport au rect droit zoomé, pour que nulle part le masque ne soit plus
// fin, rapporté au contenu, qu'au repos.
let (ew, eh) = ((x1 - x0) * s_px[0], (y1 - y0) * s_px[1]);
let len = |a: [f32; 2], b: [f32; 2]| (b[0] - a[0]).hypot(b[1] - a[1]);
let tilt_k = (len(pts[0], pts[1]) / ew)
.max(len(pts[3], pts[2]) / ew)
.max(len(pts[0], pts[3]) / eh)
.max(len(pts[1], pts[2]) / eh);
let strength = (zoom_k * tilt_k).max(1.0);
// Le mode 8 étale aussi chaque pixel vers là où le plan était une frame plus tôt
// (`tilt_trail`) : une copie traînée du secret sort du quad courant. Le masque garde la
// perspective du quad courant, élargi de la plus grande avance d'un de ses coins : chaque
// coin d'avant tombe dedans, donc tout le secret d'avant aussi (un quad convexe contient
// l'enveloppe de ses coins), et la traînée, qui va de l'un à l'autre. Même warp que le
// shader sur les coins d'avant (le drapeau projectif est celui du plan). Sans mouvement,
// la traînée EST le quad (au bit près) : rien de plus à couvrir.
let trail = self.tilt_trail(render_px).filter(|t| t.corners != quad.corners);
let pts = match trail {
Some(trail) => {
let before = crate::regions::TiltedQuad { corners: trail.corners, ..quad };
let then = |fx: f32, fy: f32| {
let (px, py) = before.point_px(fx, fy);
[centre[0] + px, centre[1] + py]
};
let prev = [then(x0, y0), then(x1, y0), then(x1, y1), then(x0, y1)];
let reach = (0..4)
.map(|i| (prev[i][0] - pts[i][0]).hypot(prev[i][1] - pts[i][1]))
.fold(0.0f32, f32::max);
grow_quad(pts, reach + 0.5)
}
None => pts,
};
let (mut min_x, mut min_y) = (f32::MAX, f32::MAX);
let (mut max_x, mut max_y) = (f32::MIN, f32::MIN);
for [px, py] in pts {
min_x = min_x.min(px);
min_y = min_y.min(py);
max_x = max_x.max(px);
max_y = max_y.max(py);
}
// Plancher d'un pixel : un masque très fin ferait diverger le warp inverse.
let mut quad_px = [(max_x - min_x).max(1.0), (max_y - min_y).max(1.0)];
let mut local = pts.map(|[px, py]| [px - min_x, py - min_y]);
let mut dst = [min_x / rw, min_y / rh, quad_px[0] / rw, quad_px[1] / rh];
// Sous le masque d'un layout en bloc, dessiné dans la part du slot qu'il couvre : les
// coins passent dans le repère de cette boîte, le warp (et son ovale) ne bouge pas.
if let Some(m) = self.screen_mask {
let c = m.clip(dst)?;
let shift = [(c[0] - dst[0]) * rw, (c[1] - dst[1]) * rh];
local = local.map(|[px, py]| [px - shift[0], py - shift[1]]);
quad_px = [c[2] * rw, c[3] * rh];
dst = c;
}
Some(PrivacyMask {
dst,
quad_px,
warp: Some(local),
projective: quad.projective,
strength,
// Un ovale inscrit dans le quad élargi ne couvrirait plus sûrement l'ovale d'avant.
oval_ok: trail.is_none(),
})
}
/// Où tombe le métrage dans l'image (`FootageQuad`) : là où `privacy_mask` pose un masque,
/// donc là où l'éditeur doit poser le gimbal d'un flou pour qu'il couvre ce qu'il cache.
pub fn footage_quad(&self, render_px: [f32; 2]) -> FootageQuad {
let [rw, rh] = render_px;
let s_px = [self.s_dst[2] * rw, self.s_dst[3] * rh];
if let Some(quad) = self.screen_tilt(s_px).filter(|_| self.tilted() && rw > 0.0 && rh > 0.0) {
let centre = self.screen_center_px(render_px);
// Les coins du métrage entier (`content_cut`), au-delà de la carte sous le
// remplissage incliné : le warp prolongé est exact, bilinéaire comme projectif.
let at = |fx: f32, fy: f32| {
let [fx, fy] = self.content_to_plane([fx, fy]);
let (px, py) = quad.point_px(fx, fy);
[(centre[0] + px) / rw, (centre[1] + py) / rh]
};
return FootageQuad {
corners: [at(0.0, 0.0), at(1.0, 0.0), at(1.0, 1.0), at(0.0, 1.0)],
projective: quad.projective,
};
}
let [x, y, w, h] = self.s_dst;
FootageQuad { corners: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], projective: false }
}
/// Largeur sur hauteur du métrage dans son propre plan : celles du rect qu'incline le tilt.
pub fn footage_aspect(&self, render_px: [f32; 2]) -> f32 {
let scale = self.content_scale();
self.s_dst[2] * render_px[0] * scale[0] / (self.s_dst[3] * render_px[1] * scale[1]).max(1e-6)
}
/// Un point du métrage, en fractions de `content_cut` (le repère des annotations, des effets
/// et du gimbal), en fractions du plan dessiné (`cut`). L'identité, au bit près, hors du
/// remplissage incliné.
fn content_to_plane(&self, f: [f32; 2]) -> [f32; 2] {
if self.content_cut == self.cut {
return f;
}
let (c, k) = (self.content_cut, self.cut);
let map = |f: f32, a0: f32, a1: f32, b0: f32, b1: f32| (a0 + f * (a1 - a0) - b0) / (b1 - b0).max(1e-6);
[map(f[0], c[0], c[2], k[0], k[2]), map(f[1], c[1], c[3], k[1], k[3])]
}
/// Combien de fois le métrage dépasse le plan dessiné, par axe : 1 hors du remplissage incliné.
fn content_scale(&self) -> [f32; 2] {
if self.content_cut == self.cut {
return [1.0; 2];
}
let (c, k) = (self.content_cut, self.cut);
[(c[2] - c[0]) / (k[2] - k[0]).max(1e-6), (c[3] - c[1]) / (k[3] - k[1]).max(1e-6)]
}
}
/// Le métrage dans l'image : ses coins TL, TR, BR, BL en fractions de la sortie, et la
/// correspondance d'un point `(u, v)` du métrage à l'image, bilinéaire entre eux ou, sous la
/// caméra réelle, l'homographie qu'ils définissent (`TiltedQuad::point_px`).
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct FootageQuad {
pub corners: [[f32; 2]; 4],
pub projective: bool,
}
/// Le quad convexe `pts` (TL, TR, BR, BL) dont chaque côté recule de `d` px vers l'extérieur :
/// ses côtés restent parallèles aux siens, donc sa perspective aussi, et il contient tout point
/// à moins de `d` de lui.
fn grow_quad(pts: [[f32; 2]; 4], d: f32) -> [[f32; 2]; 4] {
// L'extérieur d'un côté est d'un bord ou de l'autre selon le sens de parcours.
let area: f32 = (0..4)
.map(|i| {
let (a, b) = (pts[i], pts[(i + 1) % 4]);
a[0] * b[1] - b[0] * a[1]
})
.sum();
let side = area.signum();
let normal = |i: usize| {
let (a, b) = (pts[i], pts[(i + 1) % 4]);
let (ex, ey) = (b[0] - a[0], b[1] - a[1]);
let len = ex.hypot(ey).max(1e-6);
[side * ey / len, -side * ex / len]
};
std::array::from_fn(|i| {
// Le coin glisse sur la bissectrice jusqu'à la rencontre des deux côtés reculés.
let (na, nb) = (normal((i + 3) % 4), normal(i));
let k = d / (1.0 + na[0] * nb[0] + na[1] * nb[1]).max(0.2);
[pts[i][0] + (na[0] + nb[0]) * k, pts[i][1] + (na[1] + nb[1]) * k]
})
}
/// Marge ajoutée autour d'un masque de confidentialité, en px de la boîte écran AU REPOS : un
/// pixel n'est couvert que si son CENTRE tombe dans le rect, alors que le bord du contenu, lui,
/// est échantillonné en bilinéaire, sur un demi-texel source. Sans marge, la rangée de bord
/// laisse passer une frange du secret. Sous un zoom la frange grossit avec le contenu, d'où le
/// facteur `zoom_k` appliqué par `privacy_mask`.
pub const PRIVACY_MASK_PAD_PX: f32 = 1.0;
/// Placement d'un masque de confidentialité, prêt pour le mode 10.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PrivacyMask {
/// Rect de dessin, en fractions de sortie : la boîte englobante quand l'écran est incliné.
pub dst: [f32; 4],
/// Taille de `dst` en px de sortie.
pub quad_px: [f32; 2],
/// Écran incliné : coins TL, TR, BR, BL du masque, en px locaux à `dst` (la convention de
/// `i.local` dans le shader). `None` : le masque est le rect `dst` lui-même.
pub warp: Option<[[f32; 2]; 4]>,
/// `warp` suit l'homographie de ses coins (caméra réelle) plutôt que leur warp bilinéaire.
pub projective: bool,
/// Multiplicateur du rayon de flou et du pas de mosaïque, jamais sous 1.
pub strength: f32,
/// `false` quand le rect a été élargi à la trace du flou de mouvement : un ovale inscrit
/// dans ce rect-là ne couvrirait plus l'ovale courant, le backend dessine alors le rect.
pub oval_ok: bool,
}
impl PrivacyMask {
fn upright(dst: [f32; 4], render_px: [f32; 2], strength: f32) -> Self {
Self {
dst,
quad_px: [dst[2] * render_px[0], dst[3] * render_px[1]],
warp: None,
projective: false,
strength,
oval_ok: true,
}
}
/// Les champs du mode 10 qui portent le masque incliné : `(dst_prev, src_prev, mb)`, avec
/// `dst_prev` = TL, TR, `src_prev` = BR, BL, `mb.z` = 1 et `mb.w` = 1 pour le warp projectif.
/// Le mode 10 lit déjà `fx` pour ses propres réglages, d'où ces trois champs-là, qu'il ne
/// lisait pas.
pub fn warp_fields(&self) -> ([f32; 4], [f32; 4], [f32; 4]) {
match self.warp {
None => ([0.0; 4], [0.0; 4], [0.0; 4]),
Some([tl, tr, br, bl]) => (
[tl[0], tl[1], tr[0], tr[1]],
[br[0], br[1], bl[0], bl[1]],
[0.0, 0.0, 1.0, if self.projective { 1.0 } else { 0.0 }],
),
}
}
}
fn union_rect(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
let (x0, y0) = (a[0].min(b[0]), a[1].min(b[1]));
let (x1, y1) = ((a[0] + a[2]).max(b[0] + b[2]), (a[1] + a[3]).max(b[1] + b[3]));
[x0, y0, x1 - x0, y1 - y0]
}
/// Vide (largeur ou hauteur nulle) quand les deux rects ne se touchent pas.
fn intersect_rect(a: [f32; 4], b: [f32; 4]) -> [f32; 4] {
let (x0, y0) = (a[0].max(b[0]), a[1].max(b[1]));
let (x1, y1) = ((a[0] + a[2]).min(b[0] + b[2]), (a[1] + a[3]).min(b[1] + b[3]));
[x0, y0, (x1 - x0).max(0.0), (y1 - y0).max(0.0)]
}
fn pad_rect(r: [f32; 4], render_px: [f32; 2], pad_px: f32) -> [f32; 4] {
let (px, py) = (pad_px / render_px[0], pad_px / render_px[1]);
[r[0] - px, r[1] - py, r[2] + 2.0 * px, r[3] + 2.0 * py]
}
/// Où va chaque calque, pour une frame — sans toucher au GPU.
///
/// C'est la première moitié de `compose_frame`, mot pour mot : 353 lignes qui ne
/// contenaient pas un seul appel D3D11. Les deux backends doivent produire ces
/// placements au pixel près (la propriété « iso-render » que le projet mesure), et la
/// seule façon fiable d'y arriver est qu'ils appellent la même fonction.
pub fn plan_frame(input: &FrameGeometryInput) -> FrameGeometry {
let (rw, rh) = (input.render_px[0], input.render_px[1]);
let (stw, sth) = (input.screen_tex_px[0], input.screen_tex_px[1]);
let (scw, sch) = (input.screen_visible_px[0], input.screen_visible_px[1]);
let (wcw, wch) = (input.webcam_visible_px[0], input.webcam_visible_px[1]);
let (u_max, v_max) = (input.u_max, input.v_max);
let (frame, cfg) = (input.frame, input.cfg);
let mut lp = input.live;
let scene = input.scene;
let cursor = input.cursor;
let layout_time = input.timeline_t_override.unwrap_or(frame / FPS);
let sampled_layout = scene.and_then(|s| s.layout_at(layout_time));
// A cut has no layout velocity. Keep the previous zoom sample, but never trail
// the old layout into a new passage whose transition was intentionally disabled.
let previous_layout_time = if sampled_layout.as_ref().is_some_and(|s| s.hard_cut) {
layout_time
} else { layout_time - 1.0 / FPS };
let previous_layout = scene.and_then(|s| s.layout_at(previous_layout_time));
if let Some(shape) = sampled_layout.as_ref().and_then(|s| s.layout.webcam_shape.as_ref()) {
lp.webcam_shape = webcam_shape_code(shape);
}
// Scène de l'app présente → placements du layout preset (ou, mieux, le rect résolu par
// l'app dans `layout.webcam_rect`) ; sinon planning fixture (bench).
let scene_preset: Option<String> =
sampled_layout.as_ref().map(|s| s.preset.to_owned()).or_else(|| scene.map(|s| s.layout.preset.clone()));
// Webcam rect résolu par l'app (= `computeCompositeLayout`, source de vérité unique
// entre preview et natif) : quand il est présent ET que la scène est posée, on l'utilise
// COMME placement de base. Sinon, fallback sur `preset_placements` historique (PiP
// codé en dur à 320 px + 40 px de marge — l'arrangement qui dérivait de la preview).
let app_webcam_rect: Option<[f32; 4]> = sampled_layout.as_ref().map(|s| s.layout.webcam_rect)
.unwrap_or_else(|| scene.and_then(|s| s.layout.webcam_rect))
.map(|r| [r.x, r.y, r.width, r.height]);
// Idem pour l'écran. Les deux rects viennent du MÊME appel `computeCompositeLayout`, donc
// les consommer ensemble est la seule façon de garder le bloc écran+caméra cohérent :
// n'en prendre qu'un revenait à mélanger la géométrie de l'app et un placement fixture.
let app_screen_rect: Option<[f32; 4]> = sampled_layout.as_ref().map(|s| Some(s.layout.screen_rect))
.unwrap_or_else(|| scene.and_then(|s| s.layout.screen_rect))
.map(|r| [r.x, r.y, r.width, r.height]);
let (mut p, mut pp) = match &scene_preset {
Some(preset) => {
// Chaque rect résolu par l'app remplace INDÉPENDAMMENT sa contrepartie du
// preset ; sinon celle du preset reste (le padding slider l'insèrera ensuite
// dans `scale_frame`).
//
// Avant, ce match portait sur `app_webcam_rect` et le rect ÉCRAN n'était donc
// honoré que si un rect webcam arrivait aussi. Un layout sans caméra gardait
// l'écran plein cadre du preset — pendant que `fit_screen` (plus bas) coupait
// quand même son fit au ratio du crop, puisqu'un `app_screen_rect` était bien
// présent. Résultat : un clip recadré sans caméra était étiré, et aucune des
// deux voies ne le rattrapait. Coupler l'écran à la présence de la caméra
// n'avait aucune raison d'être — ce sont deux calques indépendants.
let mut fp = preset_placements(preset);
if let Some(wr) = app_webcam_rect {
fp.webcam.dst = wr;
}
if let Some(sr) = app_screen_rect {
fp.screen.dst = sr;
}
(fp, fp) // layout statique → vélocité nulle
}
None => (timeline(frame, cfg), timeline(frame - 1.0, cfg)),
};
if let Some(previous) = previous_layout.as_ref() {
let r = previous.layout.screen_rect;
pp.screen.dst = [r.x, r.y, r.width, r.height];
if let Some(r) = previous.layout.webcam_rect {
pp.webcam.dst = [r.x, r.y, r.width, r.height];
} else {
pp.webcam.dst = [0.0; 4];
}
}
// Motion blur écran : quand la scène (contrat de l'app) est posée, c'est elle qui pilote
// (parité inspector : 1.0 + motion_blur*15 taps), sinon on retombe sur `cfg.mblur_n`
// (le bench fixture continue d'utiliser ses taps explicites).
let mb_taps = scene
.map(|s| 1.0 + s.effects.motion_blur.clamp(0.0, 1.0) * 15.0)
.unwrap_or(cfg.mblur_n as f32);
let mb_amount = scene
.map(|s| s.effects.motion_blur.clamp(0.0, 1.0))
.unwrap_or(if cfg.mblur_n > 1 { 1.0 } else { 0.0 });
// Zoom regions + Full Camera : filtrées en amont pour le clip actif et échantillonnées
// dans le même référentiel source que le PTS du décodeur écran.
let empty_zoom: Vec<crate::scene::SceneZoomRegion> = Vec::new();
let empty_cam: Vec<crate::scene::SceneCameraFullscreenRegion> = Vec::new();
let zoom_regions = scene.map(|s| &s.zoom_regions).unwrap_or(&empty_zoom);
let cam_regions =
scene.map(|s| &s.camera_fullscreen_regions).unwrap_or(&empty_cam);
let webcam_reactive = sampled_layout.as_ref().map(|s| s.webcam_reactive_zoom)
.unwrap_or_else(|| scene.map(|s| s.layout.webcam_reactive_zoom as u8 as f32).unwrap_or(0.0));
let webcam_reactive_prev = previous_layout.as_ref().map(|s| s.webcam_reactive_zoom).unwrap_or(webcam_reactive);
let source_t = input.timeline_t_override.unwrap_or(frame / FPS);
// Les transitions se mesurent à l'écran (`ScreenClock`), la frame précédente aussi : une
// frame d'écran plus tôt, ce qui donne au flou de mouvement du zoom la même traînée qu'à 1×,
// y compris sur la première frame après une frontière de vitesse.
let clock = scene
.map(|s| crate::regions::ScreenClock::new(&s.speed_regions, s.active_clip_index))
.unwrap_or_default();
// Bornée au début du clip : la frame qui précède la première d'un clip n'est pas dans ce
// clip, elle tombe dans le trou d'un trim ou dans le clip d'avant. Les régions y valent
// ce qu'elles valent hors du clip (Full Camera coupée par un trim : 0), et le flou de
// mouvement traînait la caméra plein cadre jusqu'à son coin PiP sur la frame de la coupe.
// Comparé en f32, comme les bornes des régions : la première frame d'un clip tombe pile
// sur son début, et un début inexact en f32 (11.388) relu en f64 passait sous la borne.
let source_t_prev = clock.source_at(clock.at(source_t) - 1.0 / FPS);
let source_t_prev = match scene.and_then(|s| s.clips.get(s.active_clip_index)) {
Some(clip) if source_t >= clip.source_start_sec as f32 => {
source_t_prev.max(clip.source_start_sec as f32)
}
_ => source_t_prev,
};
// le focus "auto" (suivi curseur) réutilise la même piste que le rendu du curseur.
let cursor_for_zoom = cursor;
// `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_camera = 0.0f32;
let mut zoom_camera_prev = 0.0f32;
let mut zoom_strength = 0.0f32;
let mut zoom_strength_prev = 0.0f32;
let mut zoom_aim = [0.5f32; 2];
let mut zoom_orbit = [0.5f32; 2];
let (mut zoom_aim_prev, mut zoom_orbit_prev) = ([0.5f32; 2], [0.5f32; 2]);
// Curseur masqué → pas de piste pour ce qui anime le plan (parallaxe, impact, orbite en
// focus auto) : un plan ne bouge que sous un pointeur qu'on voit. Preview et export
// chargent la piste dans tous les cas (le focus auto la suit), cette porte fait le reste.
let parallax_track = cursor_for_zoom.filter(|_| scene.is_some_and(|s| s.cursor.show));
let active_crop = scene.and_then(|scene| {
scene.crop_by_clip.get(scene.active_clip_index).copied().flatten()
});
if !zoom_regions.is_empty() {
// L'orbite en focus auto lit le curseur dans l'image SOURCE recadrée — pas dans la
// coupe zoomée, qu'un focus auto recentre sur lui — et ignore ce qu'une coupe retire.
let camera = crate::regions::CameraFrame {
track: parallax_track,
crop: normalized_crop(active_crop),
window: scene
.and_then(|s| s.clips.get(s.active_clip_index))
.map(|c| [c.source_start_sec as f32, c.source_end_sec as f32])
.unwrap_or([f32::NEG_INFINITY, f32::INFINITY]),
};
let zs =
crate::regions::zoom_state_in(zoom_regions, source_t, cursor_for_zoom, &camera, &clock);
p.zoom = zs.scale;
p.focus = zs.focus;
zoom_rotation = zs.rotation;
zoom_tilt = zs.tilt;
zoom_camera = zs.camera;
zoom_strength = zs.strength;
zoom_aim = zs.aim;
zoom_orbit = zs.orbit;
// Même `CameraFrame` qu'à la frame courante : la caméra réelle d'avant (poids, visée,
// orbite) sert au flou du mode 8. Échelle et focus n'en dépendent pas.
let zs_p = crate::regions::zoom_state_in(
zoom_regions,
source_t_prev,
cursor_for_zoom,
&camera,
&clock,
);
pp.zoom = zs_p.scale;
pp.focus = zs_p.focus;
zoom_rotation_prev = zs_p.rotation;
zoom_camera_prev = zs_p.camera;
zoom_strength_prev = zs_p.strength;
zoom_aim_prev = zs_p.aim;
zoom_orbit_prev = zs_p.orbit;
}
// 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).
let cam_progress =
crate::regions::camera_fullscreen_progress_at(cam_regions, source_t, &clock);
let cam_progress_prev =
crate::regions::camera_fullscreen_progress_at(cam_regions, source_t_prev, &clock);
let shape_fade =
crate::regions::camera_fullscreen_shape_at(cam_regions, source_t, &clock);
// rétrécissement réactif : la webcam garde 70 % de sa taille pendant un zoom actif, quel
// que soit son niveau (elle suivait 1/zoom, et rétrécissait donc d'autant plus que le zoom
// était profond : ×0,6 au zoom maximal). L'enveloppe est celle de la région : elle descend
// avec le ease-in du zoom, tient 0,7 sur le span, remonte avec le ease-out. Une région à
// échelle 1 ne zoome rien : elle laisse la caméra à sa taille. Ignoré pendant Full Camera
// (voir ci-dessus).
let reactive_scale = |strength: f32, zoom: f32, progress: f32, layout_weight: f32| -> f32 {
if layout_weight > 0.0 && progress <= 0.0 && zoom > 1.0 && strength.is_finite() {
(1.0 - 0.3 * strength.clamp(0.0, 1.0) * layout_weight).clamp(0.7, 1.0)
} else {
1.0
}
};
// `lp.webcam_size_scale` vient de `scene.layout.webcamSize` (voir `live_params_from_scene`)
// — le MÊME nombre que le fraction webcamSizePreset déjà pris en compte côté app pour
// calculer `wr` (`computeCompositeLayout`, TS). Quand l'app fournit un `webcam_rect`
// explicite, la taille y est donc déjà cuite : réappliquer `lp.webcam_size_scale` ici
// double-échelonnerait la boîte (ex. un preset 34% → webcam rendue à ~34%×34% ≈ 12% au
// lieu de 34%, la webcam apparaissant bien plus petite que ce que montre l'aperçu web).
// Seul `reactive_scale` (rétrécissement pendant un zoom, une valeur ANIMÉE par frame que
// le rect statique de l'app ne capture pas) doit encore s'appliquer dans ce cas.
let base_size_scale = if app_webcam_rect.is_some() { 1.0 } else { lp.webcam_size_scale };
let webcam_size_scale = base_size_scale * reactive_scale(zoom_strength, p.zoom, cam_progress, webcam_reactive);
let webcam_size_scale_prev =
base_size_scale * reactive_scale(zoom_strength_prev, pp.zoom, cam_progress_prev, webcam_reactive_prev);
// padding : échelle globale du layout autour du centre du cadre (parité web frameRenderer :
// paddingScale = 1 - padding*0.4 → padding 0 = plein cadre). S'applique à TOUS les presets :
// côté web, side-by-side et top/bottom soudent écran+caméra en un bloc unique et c'est ce
// bloc que le padding rétrécit (cf. `compositeLayout.ts`, branche `block`). Vertical-stack
// en était exempté tant qu'il était full-bleed ; il ne l'est plus.
let padding_scale = 1.0 - lp.padding * 0.4;
let scale_frame = |dst: [f32; 4], s: f32| -> [f32; 4] {
[0.5 + (dst[0] - 0.5) * s, 0.5 + (dst[1] - 0.5) * s, dst[2] * s, dst[3] * s]
};
// webcam : ancrée à son coin bas-droite (grandit vers le haut-gauche, pas depuis le centre).
let scale_corner_br = |dst: [f32; 4], s: f32| -> [f32; 4] {
let (brx, bry) = (dst[0] + dst[2], dst[1] + dst[3]);
let (nw, nh) = (dst[2] * s, dst[3] * s);
[brx - nw, bry - nh, nw, nh]
};
// parité web (compositeLayout) : rectangle/rounded gardent le ratio natif de la webcam ;
// square/circle forcent un carré (side = min). Le placement de base est carré → on ajuste
// ici, en gardant le coin bas-droite fixe (cohérent avec le size-scale).
let is_square_shape = matches!(lp.webcam_shape, 1 | 2); // circle | square
let cam_ar = if is_square_shape { 1.0 } else { (wcw / wch).max(0.01) };
let fit_cam_aspect = |dst: [f32; 4]| -> [f32; 4] {
let s = (dst[2] * rw).min(dst[3] * rh); // côté carré de base (px)
let (pw, ph) = if cam_ar >= 1.0 { (s, s / cam_ar) } else { (s * cam_ar, s) };
let (nw, nh) = (pw / rw, ph / rh);
let (brx, bry) = (dst[0] + dst[2], dst[1] + dst[3]);
[brx - nw, bry - nh, nw, nh]
};
// Variante ancrée à l'ANCRE de la caméra (au lieu du coin bas-droite) de `dst`, pour le cas
// où `dst` vient de `app_webcam_rect` : ce rect est déjà la position que l'utilisateur a
// choisie (résolue côté app via `computeCompositeLayout`) — l'ancrer au coin bas-droite
// comme le fait `fit_cam_aspect` (pensé pour le placement par DÉFAUT) réancrerait la
// webcam posée n'importe où d'autre à ce coin (bug rapporté : webcam au coin bas-gauche,
// rendu natif décalé).
//
// L'app pose la caméra à marge constante de son ancre (un coin ou un milieu de bord) :
// `x = marge + fx·(W − 2·marge − w)`, donc le point de la boîte à la fraction `fx` vaut
// `marge + fx·(W − 2·marge)` quelle que soit sa largeur. Rétrécir autour de ce point-là,
// c'est exactement la mise en page de l'app à la taille réduite : une caméra de coin garde
// sa marge aux deux bords, une caméra de milieu de bord reste centrée sur lui. Rétrécir
// vers son propre centre l'arrachait de son coin pendant chaque zoom. Sans ancre (vieux
// payload), le centre.
let anchor = scene.map(|s| s.layout.webcam_anchor_fractions()).unwrap_or([0.5, 0.5]);
let scale_anchored = |dst: [f32; 4], s: f32| -> [f32; 4] {
let (ax, ay) = (dst[0] + dst[2] * anchor[0], dst[1] + dst[3] * anchor[1]);
let (nw, nh) = (dst[2] * s, dst[3] * s);
[ax - nw * anchor[0], ay - nh * anchor[1], nw, nh]
};
// Le crop de l'utilisateur (dialogue "Edit clip") a son PROPRE ratio (ex. une bande
// verticale 9:16 recadrée dans une source 16:9) — le zoom appliqué ensuite (§
// `screen_source_rect`) le préserve (mêmes facteurs sur les deux axes), donc c'est bien
// le ratio du CROP qui doit dimensionner le quad de destination, pas celui (fixe, issu
// du preset de layout) de `p.screen.dst`. Sans ça, le rect recadré (dont le ratio propre
// diffère de la boîte du preset) se retrouve étiré pour remplir cette boîte — parité web
// cassée : `computeCompositeLayout`/`centerRectInBounds` (TS) contiennent déjà le crop
// dans sa boîte en respectant son ratio, le natif ne le faisait pas (rapport utilisateur).
let crop_aspect = match active_crop {
Some(c) if c.width > 0.0001 && c.height > 0.0001 => {
(c.width * scw) / (c.height * sch).max(0.0001)
}
_ => scw / sch.max(0.0001),
};
// Contain (parité `centerRectInBounds`) : rétrécit `dst` (centré) pour que son ratio
// devienne `aspect`, sans jamais dépasser sa boîte d'origine. La boîte se mesure en px du
// render target, qui porte la géométrie de sortie : son ratio est celui qu'on verra.
let fit_dst_to_aspect = |dst: [f32; 4], aspect: f32| -> [f32; 4] {
let box_w_px = dst[2] * rw;
let box_h_px = dst[3] * rh;
let box_ar = box_w_px / box_h_px.max(0.0001);
let (nw_px, nh_px) = if aspect > box_ar {
(box_w_px, box_w_px / aspect.max(0.0001))
} else {
(box_h_px * aspect, box_h_px)
};
let (nw, nh) = (nw_px / rw, nh_px / rh);
let (cx, cy) = (dst[0] + dst[2] * 0.5, dst[1] + dst[3] * 0.5);
[cx - nw * 0.5, cy - nh * 0.5, nw, nh]
};
// Quand l'app a résolu la boîte écran, elle a DÉJÀ appliqué le padding (le rect est
// calculé contre `maxContentSize`) et l'a DÉJÀ mise au ratio du crop
// (`computeCompositeLayout` reçoit la taille de la source recadrée) : rejouer
// `scale_frame` + `fit_dst_to_aspect` par-dessus appliquerait le padding deux fois et
// re-contiendrait une boîte déjà au bon ratio. Même raisonnement que pour la webcam.
let fit_screen = |dst: [f32; 4]| {
if app_screen_rect.is_some() {
dst
} else {
fit_dst_to_aspect(scale_frame(dst, padding_scale), crop_aspect)
}
};
// Issue #179 : le zoom se jouait entièrement dans la coupe source, donc la boîte
// écran restait au rect paddé et le zoom butait sur cette frontière au lieu
// d'atteindre les bords du cadre. On rend le zoom à la BOÎTE (cf. `remap_box`) :
// la coupe dessinée redevient le crop nu, la boîte porte le grossissement et
// déborde le padding — c'est la géométrie de `applyZoomTransform` (TS).
let s_box = fit_screen(p.screen.dst);
let s_box_prev = fit_screen(pp.screen.dst);
// Le cadre ne touche PAS à la boîte écran : il pousse vers l'extérieur, dans la place que
// le layout de l'app lui a faite (le padding se mesure depuis son bord extérieur,
// `computeCompositeLayout`). Ombre, masques, annotations et curseurs, ancrés sur `s_dst`,
// n'ont donc rien à rattraper.
// Le cadre et son thème. `resolved` ramène les anciennes valeurs `window-light` /
// `window-dark` au chrome de fenêtre, et `theme_override` leur rend le thème qu'elles
// nommaient : un projet qui les porte encore rend exactement ce qu'il rendait, sans que
// le document ait à être migré.
let scene_frame = scene.map(|s| s.effects.frame).unwrap_or_default();
let frame_kind = scene_frame.resolved();
let frame_dark = scene_frame
.theme_override()
.or_else(|| scene.map(|s| s.effects.frame_theme))
.is_some_and(|t| t == crate::scene::SceneFrameTheme::Dark);
// Le corps du cadre autour de l'écran : la barre et le filet de la fenêtre, la lunette
// d'un appareil, en multiples de l'unité du cadre. Ce qui sort du plan (socle, pied) n'y
// est pas. Des fractions de la boîte : sous un zoom, `remap_box` les emporte avec elle.
let s_box_px = [s_box[2] * rw, s_box[3] * rh];
let s_box_u = frame_unit_px(s_box_px, [rw, rh]);
let frame_margins = match frame_kind {
crate::scene::SceneFrame::None => None,
k if k.is_device() => Some(device_frame_margins(k, s_box_px, s_box_u)),
_ => Some(window_frame_margins(s_box_px, s_box_u)),
};
let (s_base, s_base_prev) = (s_box, s_box_prev);
// Layouts "bloc" (side-by-side / top-bottom) : la boîte écran est un SLOT au ratio
// arbitraire, et le web y fait tenir l'image en `cover` (`computeCompositeLayout`
// renvoie `screenCover: true`, honoré par `frameRenderer`). Le natif l'ignorait, donc
// il étirait la source pour remplir le slot — visible dès que le clip est recadré,
// puisque le crop éloigne encore le ratio de la source de celui du slot.
//
// Le cover s'applique APRÈS le crop et le zoom, sur leur rect résultant : le crop
// décide quoi montrer, le zoom où regarder, le cover comment habiller la boîte. Son
// ratio de boîte se lit sur `s_base` : `remap_box` met les deux axes à la même
// échelle, donc la boîte finale a le même ratio et le cover ne dépend pas d'elle
// (ce qui casserait la circularité coupe → boîte → coupe).
// A zoom already running inside a block keeps that viewport until it settles.
// Releasing its clip halfway into PiP would inflate the frame and then shrink it
// during the same zoom-out. This is derived from time, so seeks and exports agree.
let keep_screen_clip = zoom_strength > 0.0 && sampled_layout.as_ref()
.and_then(|s| s.keep_screen_clip_from_sec)
.is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t, &clock));
let keep_screen_clip_prev = zoom_strength_prev > 0.0 && previous_layout.as_ref()
.and_then(|s| s.keep_screen_clip_from_sec)
.is_some_and(|from| crate::regions::zoom_continues_since(zoom_regions, from, source_t_prev, &clock));
let screen_cover = keep_screen_clip || sampled_layout.as_ref().map(|s| s.layout.screen_cover)
.unwrap_or_else(|| scene.map(|s| s.layout.screen_cover).unwrap_or(false));
let cover_box_ar = screen_cover.then_some((s_base[2] * rw) / (s_base[3] * rh).max(0.0001));
// Remplissage du format (`screen_follow`) : la fenêtre du cover suit le curseur lissé,
// en UV. Sans piste, elle reste centrée.
let follow = cover_box_ar.is_some() && scene.is_some_and(|s| s.layout.screen_follow);
let follow_at = |t: f32| -> Option<[f32; 2]> {
let (x, y) = cursor.filter(|_| follow)?.follow_at(t)?;
Some([x * u_max, y * v_max])
};
let previous_cover_box_ar = (keep_screen_clip_prev || previous_layout.as_ref()
.map(|sample| sample.layout.screen_cover).unwrap_or(screen_cover))
.then_some((s_base_prev[2] * rw) / (s_base_prev[3] * rh).max(0.0001));
let cover_for = |uv: [f32; 4], at: Option<[f32; 2]>, box_ar: Option<f32>| -> [f32; 4] {
match (box_ar, at) {
(Some(ar), Some(at)) => follow_cover_uv_rect(uv, [stw as f32, sth as f32], ar, at),
(Some(ar), None) => cover_uv_rect(uv, [stw as f32, sth as f32], ar),
(None, _) => uv,
}
};
let cover = |uv, at| cover_for(uv, at, cover_box_ar);
// La coupe RÉFÉRENCE (zoom entier) est celle qui remplissait la boîte paddée avant
// ce correctif ; la coupe DESSINÉE ne porte plus que le crop. `remap_box` reporte la
// seconde à travers le mapping de la première, ce qui conserve le cadrage exact.
// Le focus courant reste volontairement utilisé pour la frame précédente, comme avant.
//
// Sous un plan incliné (angle fixe ou caméra réelle), le remplissage penche la CARTE : la
// boîte est le slot, la coupe la fenêtre zoomée qu'il montre, et rien ne la rogne. Le slot
// n'y est pas un conteneur qu'on voit, comme dans un bloc : rogner à son rect droit le plan
// de l'enregistrement entier y coupait des coins à plat. Sous la caméra réelle, c'est sa
// visée qui cadre le zoom (`regions::resolve_focus` laisse la boîte zoomer sur son centre).
let fill_tilt =
follow && (zoom_camera > 0.0 || !crate::regions::is_identity_rotation(zoom_rotation));
let focus = if fill_tilt && zoom_camera > 0.0 { zoom_aim } else { p.focus };
let cut_ref =
cover(screen_source_rect(u_max, v_max, active_crop, p.zoom, focus), follow_at(source_t));
let cut_ref_prev = cover_for(
screen_source_rect(u_max, v_max, active_crop, pp.zoom, focus),
follow_at(source_t_prev), previous_cover_box_ar,
);
// Sous le remplissage, la coupe dessinée est le crop ENTIER : la fenêtre bouge, et une
// coupe dessinée qui ne la contiendrait plus laisserait un trou dans le slot. Le masque du
// slot (`screen_mask`) rogne le reste.
let crop_cut = screen_source_rect(u_max, v_max, active_crop, 1.0, p.focus);
let flat_cut = if follow { crop_cut } else { cover(crop_cut, None) };
// Le remplissage incliné dessine la fenêtre zoomée elle-même : sa boîte est le slot.
let cut = if fill_tilt { cut_ref } else { flat_cut };
// Ce que l'écran montre au repos : la fenêtre couverte, suivie ou non. Le curseur, les coins
// et l'ombre se mesurent sur elle, pas sur la coupe entière que le remplissage dessine.
let window = cover(crop_cut, follow_at(source_t));
let shown = |i: usize| (crop_cut[i + 2] - crop_cut[i]) / (window[i + 2] - window[i]).max(1e-6);
let screen_unit_px =
screen_unit_px([s_base[2] * rw * shown(0), s_base[3] * rh * shown(1)], padding_scale);
// Impact du clic, un réglage du curseur qui vaut sous toutes les caméras : sous un angle
// fixe, mêmes piste, coupe, porte et budget que la parallaxe ; sous la caméra réelle, les
// mêmes clics font reculer l'œil ; sur un écran droit, l'écran lui-même (`pressed`).
let (impact, press) = match (scene, parallax_track) {
(Some(s), Some(track)) if s.cursor.click_impact => {
click_impact_at(s, cfg, &lp, track, source_t, cut, [u_max, v_max])
}
_ => ([0.0; 3], 0.0),
};
// Sur un écran droit, le clic fait reculer l'écran comme l'œil recule sous la caméra réelle
// (`camera::PRESS`) : la boîte rapetisse autour de son centre, puis revient. Le faire
// basculer depuis l'écran droit amènerait des arêtes sur les axes (la règle des 2°). Là où
// un angle fixe est installé, la bascule prend le relais (`tilt_gate`) ; sous la caméra
// réelle, l'œil (son poids). Même recul aux deux frames : comme la bascule, l'impact
// n'entre pas dans le flou de mouvement.
let flat_press = press * (1.0 - crate::regions::tilt_gate(zoom_tilt)) * (1.0 - zoom_camera);
let pressed = |b: [f32; 4]| -> [f32; 4] {
let k = 1.0 / (1.0 - crate::camera::PRESS * flat_press);
[b[0] + b[2] * (1.0 - k) * 0.5, b[1] + b[3] * (1.0 - k) * 0.5, b[2] * k, b[3] * k]
};
// Sous la caméra réelle, la visée et l'orbite vivent dans le recadrage, comme le focus :
// même report dans la coupe (un cover la rogne). La mise au point suit le pointeur lissé
// (l'orbite), pas le point visé : celui-ci reste au centre au zoom 1 et bute sur sa portée
// au zoom, là où le spectateur regarde le pointeur.
// Sous le remplissage incliné, la coupe est déjà la fenêtre zoomée : la caméra filme la
// carte au zoom 1, entière et contenue dans son slot depuis toute l'orbite
// (`camera::View::new`), et l'œil se place sur le pointeur dans l'enregistrement entier,
// où vit le poids de l'orbite (rapportée à la fenêtre, elle sauterait à l'entrée du zoom).
let pose = |weight: f32, aim: [f32; 2], orbit: [f32; 2], zoom: f32| {
if fill_tilt {
crate::camera::CameraPose {
weight,
aim: [0.5; 2],
orbit: focus_in_cut(u_max, v_max, active_crop, orbit, crop_cut),
zoom: 1.0,
press,
}
} else {
crate::camera::CameraPose {
weight,
aim: focus_in_cut(u_max, v_max, active_crop, aim, cut),
orbit: focus_in_cut(u_max, v_max, active_crop, orbit, cut),
zoom,
press,
}
}
};
let camera = (zoom_camera > 0.0).then(|| pose(zoom_camera, zoom_aim, zoom_orbit, p.zoom));
// La caméra réelle de la frame d'avant, dès qu'elle y était active — y compris quand elle
// ne l'est plus à celle-ci (fin de sa moitié d'une transition vers un angle fixe) ; `None`
// quand elle ne l'était pas, et le mode 8 reprend alors la rotation d'avant.
let camera_prev = (zoom_camera_prev > 0.0)
.then(|| pose(zoom_camera_prev, zoom_aim_prev, zoom_orbit_prev, pp.zoom));
let focus_plane = match camera {
// Le pointeur sur la carte, là où l'orbite du remplissage n'est pas dans la coupe.
Some(_) if fill_tilt => focus_in_cut(u_max, v_max, active_crop, zoom_orbit, cut),
Some(pose) => pose.orbit,
None => focus_in_cut(u_max, v_max, active_crop, p.focus, cut),
};
let s_dst = pressed(remap_box(s_base, cut_ref, cut));
// Parallaxe : calculée ici, une fois la coupe connue — elle mesure la vitesse du curseur
// en coupes VISIBLES par seconde. La coupe visible est `cut_ref`, zoom compris : `cut`
// ne porte plus que le crop depuis #179, et sous un x2 le même geste traverse deux fois
// plus d'écran. La coupe passe au repère normalisé du curseur.
let cut_norm = [
cut_ref[0] / u_max.max(1e-6),
cut_ref[1] / v_max.max(1e-6),
cut_ref[2] / u_max.max(1e-6),
cut_ref[3] / v_max.max(1e-6),
];
let zoom_rotation_dyn = crate::regions::dynamic_tilt(
source_t,
parallax_track,
cut_norm,
zoom_tilt,
impact,
);
let s_dst_prev = pressed(remap_box(s_base_prev, cut_ref_prev, cut));
// le padding n'affecte QUE l'écran (la quantité de fond révélée). La webcam reste ancrée
// en bas-droite à sa marge fixe, quelle que soit la valeur de padding (pas de scale_frame)
// — SAUF quand l'app a résolu un placement explicite (`app_webcam_rect`, drag-to-reposition
// compris). Ce rect est déjà exprimé en fraction de la sortie (calculé côté web par
// `computeCompositeLayout` avec les vraies dimensions de sortie), position ET aspect déjà
// corrects. `fit_cam_aspect`/`scale_corner_br` (chemin preset par défaut) y sont donc
// inadaptés : ils le réancreraient au coin bas-droite, en ignorant la position choisie par
// l'utilisateur (rapport : webcam glissée au coin bas-gauche, rendue ailleurs), et
// recalculeraient un aspect déjà juste. On garde seulement `scale_anchored` (zoom réactif,
// préserve l'ancre et l'aspect), et le rect est dessiné tel quel : le render target porte
// la géométrie de sortie, rien ne le déforme après coup.
let mut w_dst = if app_webcam_rect.is_some() {
scale_anchored(p.webcam.dst, webcam_size_scale)
} else {
fit_cam_aspect(scale_corner_br(p.webcam.dst, webcam_size_scale))
};
let mut w_dst_prev = if app_webcam_rect.is_some() {
scale_anchored(pp.webcam.dst, webcam_size_scale_prev)
} else {
fit_cam_aspect(scale_corner_br(pp.webcam.dst, webcam_size_scale_prev))
};
// Full Camera : la caméra PREND le cadre — parité `computeCameraFullscreenRect` (TS).
// La cible est exactement [0,0,1,1] : pas de marge, pas de padding, pas d'arrondi, et
// plus rien de la composition (fond, écran, ombre) derrière. Le rect change de ratio en
// chemin, mais `cover_crop_uv` (plus bas) dérive la coupe source du ratio RÉEL de la
// boîte à chaque frame : la caméra n'est donc jamais étirée pendant l'animation.
let fullscreen_dst = |dst: [f32; 4], progress: f32| -> [f32; 4] {
if progress <= 0.0 {
return dst;
}
let lerp = |a: f32, b: f32| a + (b - a) * progress;
[lerp(dst[0], 0.0), lerp(dst[1], 0.0), lerp(dst[2], 1.0), lerp(dst[3], 1.0)]
};
// Petit côté de la boîte caméra AVANT que Full Camera ne la fasse grandir. C'est la
// référence du rayon de coin : le zoom réactif est déjà dedans (il rétrécit la boîte,
// donc l'arrondi suit tout seul — parité `borderRadius * reactiveFactor` côté TS), alors
// que Full Camera ne fait pas grossir l'arrondi, il le DISSOUT (cf. `shape_fade`).
let w_nominal_min = (w_dst[2] * rw).min(w_dst[3] * rh);
w_dst = fullscreen_dst(w_dst, cam_progress);
w_dst_prev = fullscreen_dst(w_dst_prev, cam_progress_prev);
// Aucun contre-étirement ici : le render target porte la géométrie de sortie, rien n'est
// étiré après coup, donc aucun rect n'est rétréci pour compenser.
// Le dessin du coin (SDF, shaders.hlsl) compare le rayon à `quad_px`, exprimé en px du
// RENDER TARGET : c'est donc dans cet espace-là qu'il faut le lui donner.
//
// Toutes les longueurs de la scène sont des FRACTIONS ; on les multiplie ici par ce
// qu'elles mesurent, dans l'espace du render target. C'est ce qui rend preview et export
// identiques : « un pixel » n'y désigne pas la même chose (la preview rastérise dans un
// cadre contain-fitté plus petit, cf. `preview_render_size`), alors qu'une fraction, si.
// `frame_min_px` est la référence des quantités relatives au CADRE ; un rayon de coin,
// lui, se mesure contre sa propre boîte — il doit rester en place quand on redimensionne
// la boîte, pas suivre le cadre.
let frame_min_px = rw.min(rh);
let s_px = [s_dst[2] * rw, s_dst[3] * rh];
let app_screen_radius_frac = sampled_layout.as_ref().map(|s| s.layout.screen_radius_frac)
.unwrap_or_else(|| scene.and_then(|s| s.layout.screen_radius_frac));
let scene_roundness_frac = scene.map(|s| s.effects.roundness_frac);
// ---- Le rayon des coins, en UN seul endroit ----
//
// SANS CADRE, rien ne change, à l'octet : le slider Roundness en px de sortie, ou le rayon
// qu'un layout en bloc a résolu pour sa boîte écran (parité exacte avec la caméra). Le
// rayon suit la boîte : quand le zoom l'agrandit (issue #179), les coins grandissent avec
// elle puis sortent du cadre — comme le masque de la référence, qui porte le même
// `br: maskBorderRadius * camS` et quitte l'étage au même moment.
//
// SOUS UN CADRE, le slider parcourt 0 → le plafond de CE cadre (`frame_roundness_cap`),
// en unités du cadre : le même coin sur un clip 16:9, 9:16, 1:1, 4:3 ou 21:9, et aucune
// position de la course ne rend un cadre laid (un arrondi qui mord la barre de titre de
// la fenêtre, ou un coin d'écran de téléphone sur un portable). Il vaut pour le métrage,
// donc pour l'ouverture ; le corps en est CONCENTRIQUE (`concentric_radius`), si bien que
// chaque bordure garde son épaisseur tout autour de chaque coin. Sous le chrome de
// fenêtre, les coins HAUTS du métrage restent carrés, à ras de la barre : l'arrondi du
// haut se fait une seule fois, par le cadre (`screen_square_top`, `screen_top_lift_px`).
let radius_for = |s_px: [f32; 2], app_radius: Option<f32>| match (cfg.rounded, app_radius, scene_roundness_frac) {
(false, _, _) => 0.0,
(true, _, _) if frame_kind != crate::scene::SceneFrame::None => {
let t = scene.map(roundness_slider_position).unwrap_or(0.0);
t * frame_roundness_cap(frame_kind) * frame_unit_px(s_px, [rw, rh])
}
// Preset en bloc : le rayon appartient à la boîte écran (parité exacte avec la caméra).
(true, Some(f), _) => f * s_px[0].min(s_px[1]),
// Scène sans rayon imposé : slider Roundness, en px d'une référence 1080 rapportée à
// l'écran (`screen_unit_px`) — ni à la source, ni au cadre.
(true, None, Some(f)) => f * screen_unit_px,
// Fixture/bench (pas de scène) : chemin inspector historique, inchangé.
(true, None, None) => p.screen.radius * lp.radius_scale,
};
let outer_radius_of = |s_px: [f32; 2]| {
let target = radius_for(s_px, app_screen_radius_frac);
sampled_layout.as_ref().and_then(|sample| sample.from_layout.map(|from| {
let initial = radius_for(s_px, from.screen_radius_frac);
initial + (target - initial) * sample.progress
})).unwrap_or(target)
};
let s_radius = screen_corner_radius_px(outer_radius_of(s_px), s_px);
// Layouts en bloc : le slot masque l'écran (`ScreenMask`), avec les coins de l'écran AU
// REPOS — la boîte, elle, grandit avec le zoom. `screen_cover` est le drapeau du slot :
// l'app le lève pour ces deux layouts, sur un clip qui a une caméra, et pour le
// remplissage du format, qui exclut les cadres (`formatFillAvailability`). Un cadre sous
// un slot est donc toujours dans un bloc : il y devient le conteneur, au repos autour.
// Le remplissage incliné n'a pas de masque : sa boîte est le slot, et la carte penche entière.
let screen_mask = (screen_cover && !fill_tilt).then(|| {
let slot_px = [s_base[2] * rw, s_base[3] * rh];
let cover_mix = if keep_screen_clip { 1.0 }
else { sampled_layout.as_ref().map(|s| s.screen_cover_mix).unwrap_or(1.0) };
let slot_radius = screen_corner_radius_px(outer_radius_of(slot_px), slot_px);
ScreenMask {
// A free PiP has no clipping; its equivalent mask is the zoomed box.
// Morph between that box and the fixed block slot before dropping the mask.
// Keep settled geometry bit-exact: a + (b - a) can round away from b.
rect: if cover_mix >= 1.0 { s_base } else if cover_mix <= 0.0 { s_dst }
else { lerp4(s_dst, s_base, cover_mix) },
radius_px: if cover_mix >= 1.0 { slot_radius } else if cover_mix <= 0.0 { s_radius }
else { lerp(s_radius, slot_radius, cover_mix) },
square_top: frame_kind == crate::scene::SceneFrame::Window,
}
});
// Le cadre se construit autour de la boîte écran, zoom compris ; sous le masque d'un bloc,
// autour du slot au repos et de ses coins, qui ne zooment pas.
let (f_px, f_radius) = match screen_mask {
Some(m) => ([m.rect[2] * rw, m.rect[3] * rh], m.radius_px),
None => (s_px, s_radius),
};
let window_frame = frame_margins.map(|margins| {
let (l, t, b) = (margins[0] * f_px[0], margins[1] * f_px[1], margins[3] * f_px[1]);
// La fenêtre n'a qu'un rayon (mode 14) : celui de ses coins BAS, où le métrage s'arrondit
// sous le filet. En haut, le contour intérieur du chrome a le rayon du métrage, remonté
// sous la barre (`sd_screen_under_bar`) : le même arc, rentré du filet.
let top = match frame_kind {
crate::scene::SceneFrame::Window => concentric_radius(f_radius, l, b),
_ => concentric_radius(f_radius, l, t),
};
// Portable et moniteur : la coque garde ses rayons, seule l'ouverture suit le slider.
let radius = match device_shell_radius(frame_kind) {
Some(shell) => shell.map(|r| r * frame_unit_px(f_px, [rw, rh])),
None => [top, concentric_radius(f_radius, l, b)],
};
WindowFrame { kind: frame_kind, dark: frame_dark, margins, radius }
});
let w_px = [w_dst[2] * rw, w_dst[3] * rh];
// Rayon caméra. Le slider Roundness ne s'y applique jamais (il ne vaut que pour l'ÉCRAN).
// Quand l'app le résout (`computeCompositeLayout`, source unique), on le prend : c'est la
// seule façon que les deux moitiés d'un layout en bloc soient encadrées à l'identique,
// l'écran consommant déjà `screen_radius_frac` du même calcul. La table ci-dessous en
// était une SECONDE, indépendante — fraction différente (0.12 vs 0.06 côté web) et sans
// bornes — donc écran et caméra ne pouvaient pas s'accorder.
let app_webcam_radius_frac = sampled_layout.as_ref().map(|s| s.layout.webcam_radius_frac)
.unwrap_or_else(|| scene.and_then(|s| s.layout.webcam_radius_frac));
// Full Camera dissout la forme en prenant le cadre : le rayon fond vers 0, donc le cercle
// devient un rect à coins de plus en plus francs puis un plein cadre net — aucun masque
// ne survit au plein écran. Il fond sur sa propre courbe, en retard sur le rect
// (`camera_fullscreen_shape_at`). `computeCameraFullscreenRect` (TS) le lerpe encore
// avec le progrès, mais ce rayon-là n'habille qu'une `<video>` cachée.
let w_radius = shape_fade
* w_nominal_min
* match app_webcam_radius_frac {
Some(f) => f,
// Fallback (payload sans fraction, fixture/bench) : l'ancienne table, keyée sur la
// forme. Rectangle ET square n'ont qu'un léger arrondi (0.12) et ne diffèrent que
// par le ratio ; rounded est nettement plus arrondi (0.3) ; circle = demi-côté.
None => match lp.webcam_shape {
1 => 0.5,
3 => 0.3,
_ => 0.12,
},
};
FrameGeometry {
webcam_shadow: sampled_layout.as_ref().map(|s| s.webcam_shadow)
.unwrap_or_else(|| if matches!(scene_preset.as_deref(), Some("dual-frame") | Some("vertical-stack") | Some("camera-only")) { 0.0 } else { 1.0 }),
scene_preset,
mb_taps,
mb_amount,
source_t,
programme_t: input.programme_time.unwrap_or(frame / FPS),
zoom_rotation,
zoom_rotation_dyn,
camera,
zoom_rotation_prev,
camera_prev,
padding_scale,
cut,
content_cut: flat_cut,
fill_tilt,
focus_plane,
// Sans scène (bench fixture), aucune zoom region, donc aucun tilt : rien à défocaliser.
depth_of_field: scene.is_some_and(|s| s.effects.depth_of_field),
s_dst,
s_dst_prev,
// La boîte écran telle qu'elle serait sans zoom : `remap_box` n'est PAS appliqué. C'est
// le rect du CONTENU, celui où l'overlay web pose ses poignées : `layout.screenRect` tel
// quel, puisqu'un cadre ne rétrécit plus le métrage.
s_ann: s_base,
s_radius,
frame_min_px,
screen_unit_px,
w_dst,
w_dst_prev,
w_px,
w_radius,
shape_fade,
window_frame,
screen_mask,
}
}
/// Le curseur, prêt à dessiner : où, à quelle taille, avec quelle traînée.
///
/// Extrait de la moitié « dessin » de `compose_frame` pour la même raison que
/// `plan_frame` : deux backends qui doivent poser le curseur au pixel près ne peuvent pas
/// entretenir deux copies de ce mapping. Le placement dépend de la coupe source, du zoom,
/// du padding et de l'inclinaison — autant d'endroits où deux implémentations dérivent.
pub struct CursorPlan {
pub placement: CursorPlacement,
/// Placement à `t - trail_frames/FPS`, pour la traînée. `placement` quand il n'y en a pas.
pub prev_placement: CursorPlacement,
/// Côté du sprite en px de sortie (bounce et padding déjà appliqués). Sous un angle fixe, le
/// côté sur le plan qui donne cette taille au point de focus.
pub size_px: f32,
/// Nombre d'échantillons de la traînée. 1 = curseur net, pas d'accumulation.
pub taps: u32,
/// Rect de clip « Clip to canvas » (mode 4/7 du shader lit `fx`).
pub clip: [f32; 4],
/// État du curseur à cet instant (`arrow`, `pointer`, …) pour choisir le sprite.
pub cursor_type: Option<String>,
/// Opacité effective (0..1) tenant compte de l'inactivité (auto-hide) et du zoom.
pub alpha: f32,
/// Curseur modélisé (mode 15) : `Some` quand le réglage est allumé, que le thème est celui par
/// défaut et que l'état résout un sprite (le sien, sinon la flèche) ; sa pose tient déjà compte
/// de la part « pointeur » de ce sprite. Le placement est alors toujours `Tilted` (quad
/// identité sur un écran droit), et le sprite est extrudé au lieu d'être posé à plat.
pub model: Option<CursorPose>,
/// L'impact des clics récents sur l'écran (mode 16), à dessiner SOUS le curseur. Vide sans
/// curseur modélisé, sans clic récent ou à `clickBounce` nul.
pub impacts: Vec<LayerCB>,
/// Le curseur est de verre — le cristal de Prism Glow ou la lentille de Glass Lens en 3D, le
/// verre à plat de Glass Lens sans elle (`SceneCursorSprite::glass`) : il réfracte l'image déjà
/// composée, le métrage et ses flous de confidentialité, que le backend lui copie juste avant
/// de le dessiner. Seuls des pixels floutés passent ainsi à travers le verre.
pub glass: bool,
}
impl CursorPlan {
/// Le plan tel qu'un backend le dessine. La traînée du curseur modélisé coûte une marche
/// de rayons par copie : mesuré en 1080p (taille 10, 16 copies), +0,6 à +0,9 ms/frame sur GPU
/// mais +68 à +98 ms sur WARP. Le backend logiciel ne dessine donc que la tête ; le sprite
/// plat, lui, garde sa traînée partout.
pub fn for_backend(mut self, cpu_backend: bool) -> CursorPlan {
if cpu_backend && self.model.is_some() {
self.taps = 1;
self.prev_placement = self.placement;
}
self
}
}
/// Ce que `plan_cursor` doit savoir en plus de `FrameGeometry`.
pub struct CursorPlanInput<'a> {
pub render_px: [f32; 2],
pub u_max: f32,
pub v_max: f32,
pub cfg: &'a Cfg,
pub live: LiveParams,
pub scene: Option<&'a Scene>,
pub track: &'a crate::cursor::CursorTrack,
/// Temps curseur, déjà résolu (`cursor_t_override` ou `frame / FPS`).
pub t: f32,
}
/// Opacité du curseur à `t`, avant placement : 0 quand il est masqué (`cursor.show`), sinon
/// l'auto-hide × le `hideCursor` des régions de zoom. Partagée par `plan_cursor` et l'impact du
/// clic : le plan ne bascule que sous un pointeur qu'on voit.
pub fn cursor_alpha(
scene: Option<&Scene>,
cfg: &Cfg,
live: &LiveParams,
track: &crate::cursor::CursorTrack,
t: f32,
) -> f32 {
if !scene.map(|s| s.cursor.show).unwrap_or(cfg.cursor) {
return 0.0;
}
let idle_alpha = track.opacity_at(t, live.cursor_auto_hide);
let zoom_alpha = match scene {
Some(s) => {
let clock = crate::regions::ScreenClock::new(&s.speed_regions, s.active_clip_index);
crate::regions::zoom_cursor_alpha(&s.zoom_regions, t, &clock)
}
None => 1.0,
};
idle_alpha * zoom_alpha
}
/// Où tombe la position curseur `p` (repère normalisé de l'écran) dans la coupe `cut` (UV
/// texture), en fraction 0..1 par axe ; `None` hors coupe. Le test « pointeur dans la coupe »
/// de `plan_cursor`, repris tel quel par l'impact du clic.
pub fn cursor_plane_point(cut: [f32; 4], uv_max: [f32; 2], p: (f32, f32)) -> Option<[f32; 2]> {
let [su0, sv0, su1, sv1] = cut;
let (hu, hv) = ((su1 - su0) * 0.5, (sv1 - sv0) * 0.5);
let fx = (p.0 * uv_max[0] - su0) / (2.0 * hu);
let fy = (p.1 * uv_max[1] - sv0) / (2.0 * hv);
((0.0..=1.0).contains(&fx) && (0.0..=1.0).contains(&fy)).then_some([fx, fy])
}
/// L'impact des clics (la bascule `regions::click_impact`, le recul `regions::click_press`) avec
/// les portes qui dépendent de la scène ; la porte du préset vient ensuite, dans `dynamic_tilt`
/// pour la bascule, dans `plan_frame` pour le recul.
///
/// - curseur visible (`cursor_alpha`) : `cursor.show` explicite, la piste étant chargée même
/// curseur masqué (le focus auto la suit) ;
/// - curseur caché par l'application (`visible: false`) : ses clics ne sont pas chargés
/// (`CursorTrack::load`). Un clic visible va au bout même si le pointeur disparaît juste après
/// (un glisser sur un champ numérique) : le couper là ferait sauter l'écran en plein creux ;
/// - clics dans la fenêtre source du clip actif seulement (cf. `click_impact`) ;
/// - vitesse : poids `clamp(2 − vitesse, 0, 1)`. À 100× une frame couvre 3,3 s de source, la
/// courbe serait échantillonnée une fois, au hasard : une secousse d'une frame ;
/// - masques de confidentialité : rien tant qu'un flou/mosaïque est visible. Le masque suit
/// déjà le quad dynamique (`privacy_mask`), c'est une marge de sûreté que la spec demande.
fn click_impact_at(
scene: &Scene,
cfg: &Cfg,
live: &LiveParams,
track: &crate::cursor::CursorTrack,
t: f32,
cut: [f32; 4],
uv_max: [f32; 2],
) -> ([f32; 3], f32) {
let Some(clip) = scene.clips.get(scene.active_clip_index) else { return ([0.0; 3], 0.0) };
let masked = scene.annotations.iter().any(|a| {
a.kind == "blur" && a.blur.is_some() && t >= a.start_sec as f32 && t < a.end_sec as f32
});
if masked {
return ([0.0; 3], 0.0);
}
let speed = crate::regions::speed_at(&scene.speed_regions, scene.active_clip_index, t as f64);
let speed_weight = (2.0 - speed as f32).clamp(0.0, 1.0);
let weight = cursor_alpha(Some(scene), cfg, live, track, t) * speed_weight;
if weight <= 0.0 {
return ([0.0; 3], 0.0);
}
let window = [clip.source_start_sec as f32, clip.source_end_sec as f32];
let aim = |p| cursor_plane_point(cut, uv_max, p);
(
crate::regions::click_impact(t, track, window, aim).map(|d| d * weight),
crate::regions::click_press(t, track, window, aim) * weight,
)
}
/// Pose un point de la piste (repère normalisé de l'écran) sur la sortie, à travers le zoom, le
/// layout et le tilt de la frame : ce que partagent le curseur dessiné (`plan_cursor`) et les
/// effets shader (`effect_pointer`), pour qu'un effet voie la pointe là où le curseur se dessine.
struct CursorPlacer<'a> {
g: &'a FrameGeometry,
track: &'a crate::cursor::CursorTrack,
uv_max: [f32; 2],
render_px: [f32; 2],
/// Le rect d'écran non incliné, en px.
s_px: [f32; 2],
tilt: Option<crate::regions::TiltedQuad>,
/// Centre du plan en px de sortie.
quad_center_px: [f32; 2],
model3d: bool,
}
impl<'a> CursorPlacer<'a> {
fn new(g: &'a FrameGeometry, input: &CursorPlanInput<'a>, model3d: bool) -> Self {
let [rw, rh] = input.render_px;
let s_px = [g.s_dst[2] * rw, g.s_dst[3] * rh];
CursorPlacer {
g,
track: input.track,
uv_max: [input.u_max, input.v_max],
render_px: input.render_px,
s_px,
tilt: g.screen_tilt(s_px),
quad_center_px: [(g.s_dst[0] + g.s_dst[2] * 0.5) * rw, (g.s_dst[1] + g.s_dst[3] * 0.5) * rh],
model3d,
}
}
/// La pointe à `t`, posée sur le point cliqué brut à chaque clic (`pinned_at`), pas sur la piste
/// lissée qui traîne derrière la souris. Sprite plat comme modèle 3D : le rebond, l'anneau
/// d'impact et `ctx.clicks` se centrent sur ce point brut, la pointe doit s'y trouver.
fn at(&self, t: f32) -> Option<(f32, f32)> {
self.track.pinned_at(t)
}
/// `None` hors de la coupe courante (zoom serré, hors écran).
fn place(&self, cxy: Option<(f32, f32)>, dst: [f32; 4]) -> Option<CursorPlacement> {
let [rw, rh] = self.render_px;
let [fx, fy] = cursor_plane_point(self.g.cut, self.uv_max, cxy?)?;
Some(match self.tilt.as_ref() {
Some(&quad) => CursorPlacement::Tilted {
plane_pt: [fx, fy],
quad,
center_px: self.quad_center_px,
screen_px: self.s_px,
render_px: [rw, rh],
},
// Le curseur modélisé a toujours besoin d'un plan : sur écran droit, un plan
// IDENTITÉ taillé dans `dst`. À rotation nulle `rotated_quad_corners_px` rend les
// coins exacts (±w/2, ±h/2, échelle 1) : même caméra, même mode 15.
None if self.model3d => {
let screen_px = [dst[2] * rw, dst[3] * rh];
CursorPlacement::Tilted {
plane_pt: [fx, fy],
quad: crate::regions::rotated_quad_corners_px(
screen_px[0],
screen_px[1],
[0.0; 3],
[0.0; 3],
),
center_px: [(dst[0] + dst[2] * 0.5) * rw, (dst[1] + dst[3] * 0.5) * rh],
screen_px,
render_px: [rw, rh],
}
}
None => CursorPlacement::Upright { center: [dst[0] + fx * dst[2], dst[1] + fy * dst[3]] },
})
}
}
/// Ce que les effets shader lisent du pointeur (`ctx.cursor`, `ctx.clicks`), en 0..1 de SORTIE,
/// zoom, layout et tilt appliqués : ce qu'un effet ne peut pas recalculer lui-même.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct EffectPointer {
/// La pointe, là où le curseur se dessine ; `None` quand l'enregistrement l'a cachée
/// (`visible: false`) ou qu'elle sort de la coupe.
pub cursor: Option<[f32; 2]>,
/// Les clics des `shader_fx::CLICK_WINDOW_S` dernières secondes, du plus récent au plus ancien,
/// au plus `shader_fx::MAX_CLICKS` : le point de la pointe AU MOMENT du clic, et l'âge en
/// secondes.
pub clicks: Vec<([f32; 2], f32)>,
}
/// La pointe et les clics récents pour les effets, que le curseur soit dessiné ou non. Masqué par
/// l'utilisateur (`cursor.show`, l'auto-hide, `hideCursor` d'un zoom), il reste la pointe de
/// l'enregistrement : un effet peut suivre la souris, ou remplacer le curseur par son propre
/// dessin. Seuls l'enregistrement qui la cache et la coupe qui la laisse dehors l'en privent.
pub fn effect_pointer(g: &FrameGeometry, input: &CursorPlanInput) -> EffectPointer {
let model3d = input.live.cursor_model3d
&& modelled_sprite(input.scene, input.track.type_at(input.t)).is_some();
let placer = CursorPlacer::new(g, input, model3d);
let cursor = input
.track
.visible_at(input.t)
.then(|| placer.place(placer.at(input.t), g.s_dst))
.flatten()
.map(|p| p.upright_center());
let clicks = input
.track
.clicks_with_points(input.t - crate::shader_fx::CLICK_WINDOW_S, input.t)
.collect::<Vec<_>>()
.into_iter()
.rev()
.take(crate::shader_fx::MAX_CLICKS)
.filter_map(|(tc, p)| Some((placer.place(Some(p), g.s_dst)?.upright_center(), input.t - tc)))
.collect();
EffectPointer { cursor, clicks }
}
/// `None` = rien à dessiner cette frame : curseur masqué, pointeur hors du rect source
/// courant (zoom serré, hors écran), ou sprite réduit à rien au creux d'un click bounce
/// extrême — un état normal en lecture, pas une erreur.
pub fn plan_cursor(g: &FrameGeometry, input: &CursorPlanInput) -> Option<CursorPlan> {
let (rw, rh) = (input.render_px[0], input.render_px[1]);
// Caché par l'application (`visible: false`) : rien de ce plan n'est dessiné, ni le sprite,
// ni le modèle et son ombre, ni l'anneau d'un clic. Les trois backends passent tous par ici.
if !input.track.visible_at(input.t) {
return None;
}
let alpha = cursor_alpha(input.scene, input.cfg, &input.live, input.track, input.t);
if alpha <= 0.001 {
return None;
}
let cursor_type = input.track.type_at(input.t);
let sprite = modelled_sprite(input.scene, cursor_type);
let model_sprite = sprite.filter(|_| input.live.cursor_model3d);
let model3d = model_sprite.is_some();
let placer = CursorPlacer::new(g, input, model3d);
let (s_px, tilt, quad_center_px) = (placer.s_px, placer.tilt, placer.quad_center_px);
let place = |cxy: Option<(f32, f32)>, dst: [f32; 4]| placer.place(cxy, dst);
let placement = place(placer.at(input.t), g.s_dst)?;
let lp = input.live;
// `cursor_bounce_scale` est le clickBounce brut (0..5) : au-delà de 1/0.24 ≈ 4.17, le creux
// de la pression (0.76) passe sous zéro. Une taille négative retournerait le sprite, donc
// plancher à 0 — le curseur disparaît le temps du creux, c'est ce qu'une telle amplitude dit.
// Le curseur modélisé n'a pas de rebond d'échelle : le clic le fait toucher le plan à la place.
let bounce = if model3d {
1.0
} else {
(1.0 + (input.track.bounce(input.t) - 1.0) * lp.cursor_bounce_scale).max(0.0)
};
let size_px =
CURSOR_BASE_SIZE_FRAC * g.screen_unit_px * lp.cursor_size_scale * bounce * g.padding_scale;
// Sous un angle fixe, le plan tourne autour du centre de sa boîte ZOOMÉE, réduit de son
// containment : au point de focus, un px du plan vaut `scale·P/(P − z)` px de sortie, ~0,84 au
// zoom doré. Le curseur y rapetissait donc pendant que le zoom grossissait l'image. Il est
// taillé pour faire `size_px` au focus ; ailleurs, seule la perspective le change. La caméra
// réelle n'en a pas besoin : elle vise déjà le point regardé.
let size_px = match (tilt.as_ref(), g.camera) {
(Some(quad), None) => {
let z = quad.depth_mb(s_px, g.focus_plane, false)[2];
size_px * (quad.perspective - z) / (quad.perspective * quad.scale)
}
_ => size_px,
};
// Taille nulle = rien à dessiner, et surtout rien à projeter : sur un plan incliné les quatre
// coins du sprite se confondent, et le warp inverse du mode 13 résout alors 0/0. Son rejet
// ne tiendrait qu'à des comparaisons avec NaN, que Metal (fast-math) ne garantit pas.
// Couvre aussi la traînée : ses copies partagent `size_px`.
if !(size_px > 0.0) {
return None;
}
let blur01 = lp.cursor_motion_blur.clamp(0.0, 1.0);
let has_scene = input.scene.is_some();
// La traînée ne remonte pas dans une phase cachée : à sa réapparition, le curseur ne vient pas
// de là où il était caché.
let trail_from = |t: f32| {
let prev = if input.track.visible_at(t) { place(placer.at(t), g.s_dst_prev) } else { None };
prev.unwrap_or(placement)
};
let (taps, prev_placement) = if !has_scene {
let taps = input.cfg.mblur_n;
let prev = if taps <= 1 {
placement
} else {
trail_from(input.t - 1.0 / FPS)
};
(taps, prev)
} else if blur01 <= 0.001 {
(1, placement)
} else {
// Intervalle d'obturateur court, borné à 1 frame (100% blur = 1 frame d'exposition)
let trail_dt = blur01 / FPS;
let prev = trail_from(input.t - trail_dt);
let c_now = placement.upright_center();
let c_prev = prev.upright_center();
let dist_px = ((c_now[0] - c_prev[0]) * rw).hypot((c_now[1] - c_prev[1]) * rh);
if dist_px < 1.0 {
// Quasi immobile : pas de copies superflues
(1, placement)
} else {
// Densité d'échantillonnage adaptée à la distance pour éliminer les fantômes discrets
let needed = (dist_px / 2.5).ceil() as u32;
let taps = needed.clamp(2, 16);
(taps, prev)
}
};
// « Clip to canvas » : la BOUNDING BOX des quatre coins projetés du plan — le rect dans
// lequel le curseur a le droit d'exister (`pout` est en 0..1 sortie, comme ce rect).
let cursor_bounds: [f32; 4] = match tilt.as_ref() {
None => g.s_dst,
Some(quad) => {
let (hx, hy) = quad.half_extents_px();
[
(quad_center_px[0] - hx) / rw,
(quad_center_px[1] - hy) / rh,
2.0 * hx / rw,
2.0 * hy / rh,
]
}
};
let clip = match input.scene {
Some(s) if s.cursor.clip_to_bounds => cursor_bounds,
_ => [-1.0, -1.0, 3.0, 3.0],
};
// Le curseur est sur le métrage : sous le masque d'un layout en bloc, le slot le rogne aussi.
let clip = match g.screen_mask {
Some(m) => intersect_rect(clip, m.rect),
None => clip,
};
// L'impact : un anneau par clic récent, centré sur son point BRUT, là où la pointe se pose.
let strength = (lp.cursor_bounce_scale / MODEL_CLICK_BOUNCE_REF).clamp(0.0, 2.0);
let impacts = if model3d && strength > 0.0 {
let half_px = IMPACT_EXTENT * size_px * (0.75 + 0.25 * strength);
input
.track
.clicks_with_points(input.t - IMPACT_DELAY_S - IMPACT_S, input.t - IMPACT_DELAY_S)
.filter_map(|(tc, p)| {
let impact = impact_at(input.t - tc, strength)?;
let mut cb = cursor_impact_cb(place(Some(p), g.s_dst)?, half_px, impact, alpha)?;
if let Some(m) = g.screen_mask {
let dst = m.clip(cb.dst)?;
reframe_warped(&mut cb, dst, [rw, rh]);
}
Some(cb)
})
.collect()
} else {
Vec::new()
};
Some(CursorPlan {
placement,
prev_placement,
size_px,
taps,
clip,
cursor_type: cursor_type.map(str::to_string),
alpha,
model: model_sprite.map(|s| {
let pointing = pointing_factor([s.hotspot_x, s.hotspot_y]);
cursor_pose(input.track, input.t, lp.cursor_bounce_scale, pointing)
}),
impacts,
glass: match model_sprite {
Some(s) => s.sculpt.as_deref().is_some_and(crate::sculpt::refracts),
None => sprite.and_then(|s| s.glass.as_deref()).is_some_and(|n| crate::sculpt::sculpted_shape(n).is_some()),
},
})
}
// ============ Curseur modélisé (mode 15) ============
//
// Le curseur devient un OBJET, lancé de rayons par pixel dans le shader, éclairé, et qui porte une
// vraie ombre sur l'écran : la flèche ou la main d'un thème d'origine SCULPTÉE en volumes
// (`sculpt.rs`), sinon le sprite de l'état courant extrudé, sa silhouette tirée de l'alpha
// (`cursor_sdf`), son dessus portant l'art du sprite et ses flancs la couleur de son bord. Rust
// calcule la pose, la caméra et la boîte de dessin ; les trois shaders font le reste avec les
// MÊMES constantes.
//
// Repère du MODÈLE : unité = plus grand côté du sprite (`size_px`, la taille du curseur), origine
// au hotspot, x à droite, y vers le bas, z vers la caméra ; le modèle occupe z de
// -`SpriteShape::thick` à `SpriteShape::max_height`.
//
// Emplacements du `LayerCB` au mode 15 (128 octets, inchangés) :
// dst rect de dessin (sortie 0..1) : boîte du modèle ET de son ombre
// quad_px taille de ce rect en px (le VS en tire `local`)
// src.xy décalage px : `local + src.xy` = pixel relatif à l'axe de la caméra, ancrage ôté
// src.z P, distance caméra–plan (px) ; src.w = U, l'unité du modèle (px du plan)
// color.rg coin haut-gauche du sprite, repère du modèle (unités)
// color.b facteur d'épaisseur des shaders, toujours 1 : le clic n'écrase plus le volume.
// Un texel du sprite se tire de la taille du champ (`SDF_UPSAMPLE` / plus grand côté)
// color.a opacité (auto-hide, zoom)
// fx.xyz rotation dessinée du plan (rad, X/Y/Z, ordre de `regions::rotate_point`)
// fx.w tangage du modèle (rad)
// src_prev.xyz hotspot de la face du dessus, repère du plan (px, centre du plan à l'origine)
// src_prev.w lacet du modèle (rad)
// dst_prev rect de clip « Clip to canvas » (sortie 0..1), comme au mode 13
// mb.xy demi-taille du plan dans son repère (px) : l'ombre s'arrête à ses bords
// mb.zw translation du plan dans le repère caméra (px, `TiltedQuad::offset`) : le
// plan vaut `R·p + (mb.zw, 0)`, œil en (0, 0, P). Nulle sous un angle fixe.
// radius_px rapport w/h du sprite : sa taille (unités) en découle, plus grand côté = 1
// trail_a le curseur sculpté (0 = le sprite extrudé), l'épaisseur sous z = 0 avant
// écrasement, la hauteur au-dessus de z = 0 (`SpriteShape`), 0
// Textures : le sprite RGBA (alpha droit) et son champ R16F (`cursor_sdf`), sur le même rect ;
// pour le cristal de Prism Glow (`CursorPlan::glass`), une copie de l'image composée, flous de
// confidentialité compris, qu'il réfracte.
// Windows et macOS : sprite en t2/texture(2) (`texImg`), champ en t4/texture(4) (`texSdf`),
// copie en t5/texture(5) (`texDof`).
// Linux : sprite au binding 6 (`texDof`), champ au binding 4 (`texMask`), copie au binding 1
// (`texY`).
/// Épaisseur du sprite extrudé : son dessus est en z = 0, son dessous en z = -épaisseur.
pub const MODEL_THICK: f32 = 0.19;
/// Rayon du chanfrein arrondi des arêtes du dessus et du dessous.
pub const MODEL_BEVEL: f32 = 0.045;
/// Direction VERS la lumière, repère caméra (x droite, y bas, z vers le spectateur) : en haut à
/// gauche, devant. Unitaire. Miroir de `MODEL_LIGHT` dans les trois shaders.
pub const MODEL_LIGHT: [f32; 3] = [-0.4194, -0.5792, 0.6990];
/// Garde au sol au repos, en unités du modèle.
const MODEL_HOVER: f32 = 0.35;
/// Le geste du clic (`click_height`), à « Light » (1) : il prend son élan `MODEL_LIFT` au-dessus
/// du survol dès `MODEL_LEAD_S` avant le clic, plonge en `MODEL_DIVE_S` jusqu'à toucher le plan au
/// clic même, appuie `MODEL_HOLD_S` (dans la tenue de `CursorTrack::pinned_at`), remonte
/// `MODEL_OVERSHOOT` au-dessus du survol en `MODEL_RELEASE_S` et s'y repose en `MODEL_SETTLE_S` :
/// 720 ms, une vingtaine d'images à 30 i/s. « Strong » (2) prend moitié plus d'élan, plonge en
/// 96 ms, penche et rebondit deux fois plus. L'ancienne descente tenait entre deux images.
const MODEL_LEAD_S: f32 = 0.3;
const MODEL_LIFT: f32 = 0.4;
const MODEL_DIVE_S: f32 = 0.12;
const MODEL_HOLD_S: f32 = 0.08;
const MODEL_RELEASE_S: f32 = 0.14;
const MODEL_OVERSHOOT: f32 = 0.15;
const MODEL_SETTLE_S: f32 = 0.2;
/// Tangage au repos (queue relevée, pointe vers le bas). Il suit la hauteur, pour que pivot et
/// plongée ne fassent qu'un geste : la pointe se relève pendant l'élan (jusqu'à `LIFT_DEG` par
/// `MODEL_LIFT` d'élan) et plonge vers la cible en descendant (jusqu'à `DIVE_DEG` par niveau au
/// contact).
const MODEL_PITCH_IDLE_DEG: f32 = 18.0;
const MODEL_PITCH_DIVE_DEG: f32 = 8.0;
const MODEL_PITCH_LIFT_DEG: f32 = 5.0;
/// Le supplément de tangage suit `clickBounce` rapporté à sa valeur par défaut, borné à 2× : 1,
/// « Light » (`DEFAULT_PROJECT_APPEARANCE`), donc « Strong » (2) en est le double. Restée à 2,5,
/// l'ancien défaut, elle ne donnait plus que 40 % de la pression à « Light » et 80 % à « Strong ».
const MODEL_CLICK_BOUNCE_REF: f32 = 1.0;
/// Lacet maximal, et la vitesse (largeurs de l'écran par seconde) qui en donne 76 % (`tanh 1`).
const MODEL_YAW_MAX_DEG: f32 = 25.0;
const MODEL_YAW_SPEED: f32 = 0.8;
/// Demi-fenêtre de la différence centrée qui mesure la vitesse (comme la parallaxe du plan).
const MODEL_YAW_HALF_WINDOW_S: f32 = 0.1;
/// Combien de temps avant un clic le modèle se tourne vers sa cible.
const MODEL_AIM_S: f32 = 0.3;
/// Hotspot → part « pointeur » (cf. `pointing_factor`) : sous `LO` (distance au centre rapportée
/// au demi-côté), un curseur centré ; au-delà de `HI`, un pointeur. La flèche est à 0,83.
const MODEL_POINTING_LO: f32 = 0.3;
const MODEL_POINTING_HI: f32 = 0.75;
/// Pénombre (miroir des shaders) : un point du plan est dans l'ombre douce quand son rayon vers
/// la lumière passe à moins de `t / MODEL_SOFTNESS` du modèle, `t` la distance parcourue, et
/// jamais au-delà de `MODEL_SHADOW_PAD` (la marche s'arrête à la boîte du modèle élargie d'autant).
const MODEL_SOFTNESS: f32 = 6.0;
const MODEL_SHADOW_PAD: f32 = 0.45;
/// Portée de l'ombre de contact (miroir des shaders), en unités du modèle.
const MODEL_CONTACT_RADIUS: f32 = 0.12;
/// Ce que le mode 15 sait du sprite qu'il extrude : son rect dans le repère du modèle et le haut
/// de sa silhouette. Tiré du PNG par `cursor_sdf::CursorSdf`, le hotspot venant de la scène.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SpriteShape {
/// Taille du sprite en unités du modèle : son plus grand côté vaut 1.
pub size: [f32; 2],
/// Hotspot, fraction du sprite (`SceneCursorSprite`).
pub hotspot: [f32; 2],
/// Haut de la silhouette (alpha 0,5), fraction de la hauteur du sprite.
pub top: f32,
/// Hauteur du modèle au-dessus de z = 0, en unités du modèle : 0 pour un sprite extrudé.
pub max_height: f32,
/// Épaisseur sous z = 0 : `MODEL_THICK` pour un sprite extrudé, celle du modèle pour un
/// curseur sculpté (`sculpt::sculpted_shape`).
pub thick: f32,
/// Le curseur sculpté que dessine le shader (`sculpt`), 0 pour le sprite extrudé.
pub sculpt: u32,
}
impl SpriteShape {
/// Coin haut-gauche du sprite, repère du modèle.
pub(crate) fn origin(&self) -> [f32; 2] {
[-self.hotspot[0] * self.size[0], -self.hotspot[1] * self.size[1]]
}
/// La boîte englobante du modèle : le rect du sprite, sur toute l'épaisseur.
fn model_box(&self) -> ([f32; 3], [f32; 3]) {
let [x, y] = self.origin();
(
[x, y, -self.thick],
[x + self.size[0], y + self.size[1], self.max_height],
)
}
/// Hauteur du hotspot du dessus quand le point le plus bas du modèle basculé de `pitch`
/// affleure le plan : le bas du haut de la silhouette (y minimal, face du dessous) si la
/// pointe plonge, toute la face du dessous à plat. Le chanfrein arrondit ce coin et laisse,
/// basculé, un jour d'au plus ~1 % de l'unité, invisible sous l'ombre de contact.
fn contact_lift(&self, pitch: f32) -> f32 {
let y_top = (self.top - self.hotspot[1]) * self.size[1];
self.thick * pitch.cos() - y_top * pitch.sin()
}
}
/// Part « pointeur » d'un sprite, de 0 à 1, d'après son seul hotspot : sa distance au centre du
/// sprite, rapportée au demi-côté (norme max). Près d'un bord (flèche, main qui pointe, aide,
/// flèche haute) le curseur désigne de sa pointe, et le modèle penche et tourne comme la flèche ;
/// au centre (I, croix, redimensionnements, déplacement, interdit, attente, poing fermé) il ne
/// fait ni l'un ni l'autre : tourner une flèche de redimensionnement en change le sens, et basculer
/// une forme autour de son centre en enfoncerait la moitié dans le plan.
pub fn pointing_factor(hotspot: [f32; 2]) -> f32 {
let r = 2.0 * (hotspot[0] - 0.5).abs().max((hotspot[1] - 0.5).abs());
let u = ((r - MODEL_POINTING_LO) / (MODEL_POINTING_HI - MODEL_POINTING_LO)).clamp(0.0, 1.0);
u * u * (3.0 - 2.0 * u)
}
/// La pose du curseur modélisé à un instant : une fonction pure de `t`, comme tout le reste de
/// la frame (preview == export, lecture == seek).
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct CursorPose {
/// Garde au sol du point le plus bas, en unités du modèle : 0 = il touche le plan.
pub clearance: f32,
/// Tangage (rad) autour de l'axe x passant par le hotspot : la queue monte, la pointe descend.
pub pitch: f32,
/// Lacet (rad) autour de la normale du plan, appliqué après le tangage : positif = sens
/// horaire à l'écran (y vers le bas), la pointe part vers la droite.
pub yaw: f32,
}
fn smoothstep01(x: f32) -> f32 {
let u = x.clamp(0.0, 1.0);
u * u * (3.0 - 2.0 * u)
}
/// La hauteur du point le plus bas `tau` secondes après un clic (avant lui si négatif), au
/// niveau `s` de `clickBounce` (0 à 2) : élan au-dessus du survol, plongée qui accélère jusqu'au
/// contact au clic même, appui, remontée qui freine au-delà du survol, puis repos. Sous « Light »,
/// le geste est réduit d'autant : à 0, le modèle ne bouge pas.
fn click_height(tau: f32, s: f32) -> f32 {
let top = MODEL_HOVER + MODEL_LIFT * (1.0 + s) * 0.5;
let over = MODEL_HOVER + MODEL_OVERSHOOT * s;
let dive = MODEL_DIVE_S * (1.2 - 0.2 * s.max(1.0));
let release = MODEL_HOLD_S + MODEL_RELEASE_S;
let full = if tau < -dive {
MODEL_HOVER + (top - MODEL_HOVER) * smoothstep01((tau + MODEL_LEAD_S) / (MODEL_LEAD_S - dive))
} else if tau < 0.0 {
let u = (tau + dive) / dive;
top * (1.0 - u * u)
} else if tau < MODEL_HOLD_S {
0.0
} else if tau < release {
let u = 1.0 - (tau - MODEL_HOLD_S) / MODEL_RELEASE_S;
over * (1.0 - u * u)
} else {
over + (MODEL_HOVER - over) * smoothstep01((tau - release) / MODEL_SETTLE_S)
};
MODEL_HOVER + (full - MODEL_HOVER) * s.min(1.0)
}
/// La pose à `t`. `click_bounce` est le réglage brut (0 à 2 : None, Light, Strong ; 1 par défaut),
/// `pointing` la part « pointeur » du sprite (`pointing_factor`).
///
/// - Hauteur : `MODEL_HOVER` au repos. Chaque clic est un geste en vraie profondeur
/// (`click_height`) : élan, plongée jusqu'à toucher le plan au clic même, appui, remontée,
/// repos. Il enjambe l'instant où le plan, le rebond d'échelle et l'impact lisent le contact
/// (49,5 ms). Le niveau règle le geste, comme le rebond d'échelle en 2D : « Strong » monte plus
/// haut, plonge plus vite et rebondit deux fois plus ; « None » ne bouge pas. Deux clics proches
/// se partagent le geste, l'appui l'emportant sur l'élan : un double clic ne remonte pas entre
/// eux. Tous les états.
/// - Tangage : 18° au repos, et il suit la hauteur : relevé pendant l'élan, plongé vers la cible
/// en descendant, jusqu'à +8° par niveau au contact.
/// - Lacet : vers la vitesse horizontale lissée (`follow_at`, différence centrée), et vers la
/// cible d'un clic dans les 300 ms qui le précèdent ; borné à ±25° en douceur (`tanh`), nul au
/// repos. Les contributions des clics montent avant eux et retombent sur la fenêtre de l'impact,
/// donc la pose reste continue en `t` ; à « None », seule la vitesse compte.
/// - Tangage et lacet sont multipliés par `pointing` : entiers pour la flèche, nuls pour un
/// curseur centré.
/// - Ni écrasement ni rebond d'échelle : le volume reste entier, le mouvement dit le clic.
pub fn cursor_pose(
track: &crate::cursor::CursorTrack,
t: f32,
click_bounce: f32,
pointing: f32,
) -> CursorPose {
use crate::regions::CLICK_IMPACT_WINDOW_S;
let strength = (click_bounce / MODEL_CLICK_BOUNCE_REF).clamp(0.0, 2.0);
// Le dernier clic et le suivant : l'élan le plus haut, l'appui le plus profond, et l'appui
// l'emporte. Un clic seul garde exactement sa courbe ; un double clic reste posé entre les deux.
let near = track.last_click_at(t).into_iter();
let near = near.chain(track.clicks_between(t, t + MODEL_LEAD_S).first().copied());
let (mut lift, mut press) = (0.0f32, 0.0f32);
for tc in near {
let dh = click_height(t - tc, strength) - MODEL_HOVER;
lift = lift.max(dh);
press = press.max(-dh / MODEL_HOVER);
}
let clearance = (MODEL_HOVER + lift) * (1.0 - press);
let dh = clearance - MODEL_HOVER;
let tilt = if dh < 0.0 {
-dh / MODEL_HOVER * MODEL_PITCH_DIVE_DEG * strength
} else {
-dh / MODEL_LIFT * MODEL_PITCH_LIFT_DEG
};
let pitch = pointing * (MODEL_PITCH_IDLE_DEG + tilt).to_radians();
let smooth = smoothstep01;
let h = MODEL_YAW_HALF_WINDOW_S;
let mut v = match (track.follow_at(t - h), track.follow_at(t + h)) {
(Some(a), Some(b)) => (b.0 - a.0) / (2.0 * h),
_ => 0.0,
};
// La visée d'un clic fait partie de son geste : absente à « None », entière dès « Light ».
let aim = strength.min(1.0);
if let Some(here) = track.follow_at(t) {
for (tc, target) in track.clicks_with_points(t - CLICK_IMPACT_WINDOW_S, t + MODEL_AIM_S) {
let w = if tc > t {
smooth(1.0 - (tc - t) / MODEL_AIM_S)
} else {
1.0 - smooth((t - tc) / CLICK_IMPACT_WINDOW_S)
};
v += aim * w * (target.0 - here.0) / MODEL_AIM_S;
}
}
let yaw = pointing * MODEL_YAW_MAX_DEG.to_radians() * (v / MODEL_YAW_SPEED).tanh();
CursorPose { clearance, pitch, yaw }
}
/// La forme que le mode 15 donne à `sprite` : son curseur sculpté s'il en a un
/// (`sculpt::sculpted_shape`), sinon le sprite extrudé (`sdf_shape`, du champ de son PNG) au
/// hotspot de la scène. Commun aux trois backends.
pub fn model_shape(sprite: &crate::scene::SceneCursorSprite, sdf_shape: SpriteShape) -> SpriteShape {
sprite
.sculpt
.as_deref()
.and_then(crate::sculpt::sculpted_shape)
.unwrap_or(SpriteShape { hotspot: [sprite.hotspot_x, sprite.hotspot_y], ..sdf_shape })
}
/// Le sprite que les backends résoudraient pour `cursor_type` : c'est lui que le mode 15 modèle.
/// Même résolution qu'eux : l'état s'il a un sprite, sinon la flèche.
fn modelled_sprite<'a>(
scene: Option<&'a Scene>,
cursor_type: Option<&str>,
) -> Option<&'a crate::scene::SceneCursorSprite> {
let s = scene?;
let sprites = &s.cursor.cursor_sprites;
cursor_type.and_then(|k| sprites.get(k)).or_else(|| sprites.get("arrow"))
}
/// La caméra et la pose d'un curseur modélisé posé en `placement` : de quoi projeter n'importe
/// quel point du modèle exactement comme le mode 15 le rend.
#[derive(Clone, Copy, Debug)]
pub(crate) struct ModelView {
/// Rotation dessinée du plan, degrés (`TiltedQuad::rot`).
rot: [f32; 3],
perspective: f32,
/// Translation du plan dans le repère caméra (`TiltedQuad::offset`).
offset: [f32; 2],
/// L'unité du modèle (plus grand côté du sprite) en px du plan.
unit: f32,
/// Hotspot du dessus, repère du plan (px).
tip: [f32; 3],
/// Décalage écran qui pose la pointe sur le pixel du contenu (warp bilinéaire du mode 8).
anchor: [f32; 2],
center: [f32; 2],
half: [f32; 2],
pose: CursorPose,
shape: SpriteShape,
}
impl ModelView {
/// `None` pour un placement droit (`plan_cursor` n'en produit pas pour le modèle) ou une
/// caméra dégénérée.
///
/// Le hotspot est posé sur le rayon de vue qui passe par le point du contenu (`plane_pt`),
/// à sa hauteur : la pointe reste donc sur le même pixel quand la flèche monte ou descend, et
/// seule l'ombre dit la hauteur. Le contenu, lui, est dessiné par un warp BILINÉAIRE des coins
/// projetés, qui s'écarte de la perspective exacte de quelques px : tout le rendu est décalé
/// de l'écart au point visé (`anchor`), pour que la pointe tombe sur le pixel que montre
/// l'écran.
///
/// Le hotspot est posé à `clearance + contact_lift` : le point le plus bas du modèle posé,
/// quel qu'il soit, est à `clearance` du plan, donc rien ne passe jamais dessous.
pub(crate) fn new(
placement: CursorPlacement,
size_px: f32,
pose: CursorPose,
shape: SpriteShape,
) -> Option<Self> {
let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, .. } = placement else {
return None;
};
let s = quad.scale;
let half = [screen_px[0] * s * 0.5, screen_px[1] * s * 0.5];
let perspective = quad.perspective;
let unit = size_px * s;
let eye = crate::regions::rotate_point_inv(
[-quad.offset[0], -quad.offset[1], perspective],
quad.rot,
);
if !(unit > 0.0) || !(eye[2] > 1e-3) {
return None;
}
let ground =
[(plane_pt[0] - 0.5) * 2.0 * half[0], (plane_pt[1] - 0.5) * 2.0 * half[1], 0.0];
let height = unit * (pose.clearance + shape.contact_lift(pose.pitch));
let k = height / eye[2];
let tip =
[ground[0] + (eye[0] - ground[0]) * k, ground[1] + (eye[1] - ground[1]) * k, height];
let mut view = ModelView {
rot: quad.rot,
perspective,
offset: quad.offset,
unit,
tip,
anchor: [0.0; 2],
center: center_px,
half,
pose,
shape,
};
let exact = view.project(ground)?;
let (bx, by) = quad.point_px(plane_pt[0], plane_pt[1]);
view.anchor = [center_px[0] + bx - exact[0], center_px[1] + by - exact[1]];
Some(view)
}
/// Point du modèle (unités) → repère du plan (px) : tangage, lacet, échelle, hotspot.
pub(crate) fn model_to_plane(&self, q: [f32; 3]) -> [f32; 3] {
let (cp, sp) = (self.pose.pitch.cos(), self.pose.pitch.sin());
let (cy, sy) = (self.pose.yaw.cos(), self.pose.yaw.sin());
let (x, y, z) = (q[0], q[1] * cp - q[2] * sp, q[1] * sp + q[2] * cp);
let (x, y) = (x * cy - y * sy, x * sy + y * cy);
[self.tip[0] + self.unit * x, self.tip[1] + self.unit * y, self.tip[2] + self.unit * z]
}
/// Point du repère du plan → px de sortie : la perspective exacte, puis l'ancrage.
pub(crate) fn project(&self, p: [f32; 3]) -> Option<[f32; 2]> {
let w = crate::regions::rotate_point(p, self.rot);
let d = self.perspective - w[2];
if !(d > 1e-3) {
return None;
}
let f = self.perspective / d;
let (x, y) = (w[0] + self.offset[0], w[1] + self.offset[1]);
Some([self.center[0] + self.anchor[0] + x * f, self.center[1] + self.anchor[1] + y * f])
}
/// La lumière dans le repère du plan (elle est fixée à la caméra, pas au plan).
pub(crate) fn light(&self) -> [f32; 3] {
crate::regions::rotate_point_inv(MODEL_LIGHT, self.rot)
}
/// Boîte (px de sortie, `[x0, y0, x1, y1]`) qui contient le modèle ET son ombre : les huit
/// coins de la boîte du modèle, et leur projection au sol le long de la lumière, élargie de la
/// portée de la pénombre et du contact. Conservatrice : le shader ne dessine rien hors d'elle.
///
/// Portée : un rayon qui passe à `d` d'un point du modèle part d'un point du sol décalé d'au
/// plus `d / lz` de son ombre géométrique (`lz` = élévation de la lumière au-dessus du plan),
/// et la pénombre s'arrête à `d = min(t / MODEL_SOFTNESS, MODEL_SHADOW_PAD)`.
pub(crate) fn footprint(&self) -> Option<[f32; 4]> {
let (lo, hi) = self.shape.model_box();
let light = self.light();
let lz = light[2].max(0.2);
let corners: [[f32; 3]; 8] = std::array::from_fn(|i| {
self.model_to_plane([
if i & 1 == 0 { lo[0] } else { hi[0] },
if i & 2 == 0 { lo[1] } else { hi[1] },
if i & 4 == 0 { lo[2] } else { hi[2] },
])
});
let top = corners.iter().fold(0.0f32, |m, p| m.max(p[2])) / self.unit;
// La marche du shader court jusqu'à la sortie de la boîte ÉLARGIE de `MODEL_SHADOW_PAD` :
// sous une lumière rasante (`right`, `lz` ≈ 0,2), le rayon y va bien au-delà de `top / lz`,
// et la pénombre avec lui.
let penumbra = ((top + MODEL_SHADOW_PAD) / lz / MODEL_SOFTNESS).min(MODEL_SHADOW_PAD);
let reach = (penumbra / lz + MODEL_CONTACT_RADIUS) * self.unit;
let mut b = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
let mut add = |p: [f32; 2]| {
b = [b[0].min(p[0]), b[1].min(p[1]), b[2].max(p[0]), b[3].max(p[1])];
};
for p in corners {
add(self.project(p)?);
let h = p[2].max(0.0) / lz;
let g = [p[0] - light[0] * h, p[1] - light[1] * h];
for (dx, dy) in [(-reach, -reach), (reach, -reach), (reach, reach), (-reach, reach)] {
add(self.project([g[0] + dx, g[1] + dy, 0.0])?);
}
}
const PAD_PX: f32 = 2.0;
Some([b[0] - PAD_PX, b[1] - PAD_PX, b[2] + PAD_PX, b[3] + PAD_PX])
}
}
/// `LayerCB` du curseur modélisé (mode 15) posé en `placement`, pour les trois backends : le
/// sprite `shape` extrudé. `None` quand il n'y a rien à dessiner (placement droit, caméra
/// dégénérée). Voir l'en-tête de cette section pour l'emploi des emplacements.
pub fn cursor_model_cb(
placement: CursorPlacement,
size_px: f32,
pose: CursorPose,
shape: SpriteShape,
alpha: f32,
clip: [f32; 4],
) -> Option<LayerCB> {
let view = ModelView::new(placement, size_px, pose, shape)?;
let CursorPlacement::Tilted { render_px: [rw, rh], .. } = placement else { return None };
let [x0, y0, x1, y1] = view.footprint()?;
// Bords entiers : `local` vaut alors k + 0,5 au centre des pixels, comme le rastériseur.
let (x0, y0, x1, y1) = (x0.floor(), y0.floor(), x1.ceil(), y1.ceil());
let (bw, bh) = ((x1 - x0).max(1.0), (y1 - y0).max(1.0));
let r = view.rot.map(f32::to_radians);
Some(LayerCB {
dst: [x0 / rw, y0 / rh, bw / rw, bh / rh],
src: [
x0 - view.center[0] - view.anchor[0],
y0 - view.center[1] - view.anchor[1],
view.perspective,
view.unit,
],
quad_px: [bw, bh],
mode: 15.0,
// Les shaders multiplient encore l'épaisseur par `color.b` : plus rien ne l'écrase.
color: [shape.origin()[0], shape.origin()[1], 1.0, alpha],
fx: [r[0], r[1], r[2], pose.pitch],
src_prev: [view.tip[0], view.tip[1], view.tip[2], pose.yaw],
dst_prev: clip,
mb: [view.half[0], view.half[1], view.offset[0], view.offset[1]],
radius_px: shape.size[0] / shape.size[1],
trail_a: [shape.sculpt as f32, shape.thick, shape.max_height, 0.0],
..Default::default()
})
}
// ============ Impact du clic (mode 16) ============
//
// Sous le curseur modélisé, chaque clic laisse sur l'écran une tache de pression sous la pointe et
// un anneau qui s'étend depuis le point cliqué. Les deux sont posés SUR le plan, comme le sprite du
// mode 13 : un carré du plan centré sur le point, dont les coins passent par la projection du
// contenu, puis le warp inverse du shader. Ils suivent donc l'inclinaison et la caméra, et leur
// centre est le pixel cliqué. Rust calcule la courbe dans le temps ; les shaders ne dessinent
// que la forme de l'instant.
//
// Emplacements du `LayerCB` au mode 16 (longueurs en fractions du demi-côté du carré) :
// dst, quad_px bbox du carré projeté (sortie 0..1, px)
// fx, src_prev coins TL, TR puis BR, BL, en px locaux à la bbox (comme au mode 13)
// mb.x 1 = warp projectif (caméra réelle)
// mb.y, mb.z rayon et opacité de la tache de pression
// src rayon de l'anneau, sa demi-épaisseur, son opacité, celle de son halo sombre
// dst_prev le carré en fractions du plan (x, y, l, h) : rien n'est dessiné hors de l'écran
// radius_px largeur de l'antialiasing
// color teinte de l'anneau (rgb), opacité du curseur (a)
/// L'impact part du creux de `tap`, l'instant du contact : la pression y est au plus fort.
const IMPACT_DELAY_S: f32 = 0.0495;
/// Durée de l'anneau.
const IMPACT_S: f32 = 0.4;
/// Demi-côté du carré de l'impact, en tailles de curseur, à `clickBounce` par défaut.
const IMPACT_EXTENT: f32 = 0.7;
/// L'impact d'un clic, `age` secondes après lui, à la force `strength` (`clickBounce` rapporté à
/// sa valeur par défaut). `None` hors de sa fenêtre.
///
/// L'anneau part de 12 % du carré et s'arrête à 80 % en décélérant (cubique), s'amincit de moitié
/// et s'éteint en `(1 − u)²`. La tache de pression, elle, ne dure que le contact et son rebond.
fn impact_at(age: f32, strength: f32) -> Option<Impact> {
let u = (age - IMPACT_DELAY_S) / IMPACT_S;
if !(0.0..1.0).contains(&u) {
return None;
}
let smooth = |a: f32, b: f32, x: f32| {
let v = ((x - a) / (b - a)).clamp(0.0, 1.0);
v * v * (3.0 - 2.0 * v)
};
let grow = 1.0 - (1.0 - u).powi(3);
let fade = (1.0 - u).powi(2) * smooth(0.0, 0.05, u) * strength.min(1.0);
Some(Impact {
ring_r: 0.12 + 0.68 * grow,
ring_w: 0.05 * (1.0 - 0.5 * grow),
ring_a: 0.9 * fade,
halo_a: 0.3 * fade,
spot_r: 0.3,
spot_a: 0.3 * (1.0 - smooth(0.0, 0.45, u)) * smooth(0.0, 0.05, u) * strength.min(1.0),
})
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct Impact {
ring_r: f32,
ring_w: f32,
ring_a: f32,
halo_a: f32,
spot_r: f32,
spot_a: f32,
}
/// `LayerCB` de l'impact (mode 16) centré sur le point du plan de `placement`, carré de demi-côté
/// `half_px` (px du rect d'écran non incliné, l'unité de la taille du curseur). `None` pour un
/// placement droit : le curseur modélisé a toujours un plan.
fn cursor_impact_cb(
placement: CursorPlacement,
half_px: f32,
impact: Impact,
alpha: f32,
) -> Option<LayerCB> {
let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px: [rw, rh] } =
placement
else {
return None;
};
let (hx, hy) = (half_px / screen_px[0], half_px / screen_px[1]);
let (x0, y0) = (plane_pt[0] - hx, plane_pt[1] - hy);
let corners = [(x0, y0), (x0 + 2.0 * hx, y0), (x0 + 2.0 * hx, y0 + 2.0 * hy), (x0, y0 + 2.0 * hy)]
.map(|(fx, fy)| {
let (px, py) = quad.point_px(fx, fy);
(center_px[0] + px, center_px[1] + py)
});
let (min_x, max_x) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) =
corners.iter().fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
let (bw, bh) = ((max_x - min_x).max(1.0), (max_y - min_y).max(1.0));
let local = |(x, y): (f32, f32)| [x - min_x, y - min_y];
let [tl0, tl1] = local(corners[0]);
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
Some(LayerCB {
dst: [min_x / rw, min_y / rh, bw / rw, bh / rh],
src: [impact.ring_r, impact.ring_w, impact.ring_a, impact.halo_a],
quad_px: [bw, bh],
// Un px à l'écran, en fractions du demi-côté, pris sur le petit axe de la bbox.
radius_px: 2.0 / bw.min(bh),
mode: 16.0,
color: [1.0, 1.0, 1.0, alpha],
fx: [tl0, tl1, tr0, tr1],
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()
})
}
/// Poids d'un échantillon du flou de mouvement de curseur (0 = queue/passé, taps-1 = tête/courant).
///
/// Poids croissant de 0.25 (queue) à 1.0 (tête), normalisé pour que la somme valle 1.0.
/// La somme des (0.25 + 0.75 * k / (taps - 1)) pour k de 0 à taps-1 vaut taps * (0.25 + 1.0) / 2 = taps * 0.625.
#[inline]
pub fn cursor_tap_weight(k: u32, taps: u32) -> f32 {
if taps <= 1 {
return 1.0;
}
let t = k as f32 / (taps - 1) as f32;
let ramp = 0.25 + 0.75 * t;
let sum = taps as f32 * 0.625;
ramp / sum
}
/// Les clés à évincer d'un cache de textures pour repasser sous `budget`, la moins récemment
/// utilisée d'abord. `entries` porte `(clé, octets, tick d'usage)`.
///
/// `protect_from` est le tick au DÉBUT DE LA FRAME EN COURS : toute entrée touchée depuis est
/// intouchable. Protéger la seule entrée qu'on vient de poser ne suffit pas — une frame échantillonne
/// plusieurs textures (fond d'écran, fond de caméra, sprites de curseur), et évincer l'une d'elles
/// parce qu'une autre vient d'arriver la ferait recharger à la frame suivante, puis rechasser la
/// suivante : le cache se mettrait à battre au lieu de servir. Un décodage mesuré à 129 ms en
/// release contre les ~3,5 ms d'une frame, c'est un échange qu'aucun budget mémoire ne justifie.
///
/// Si le jeu actif dépasse à lui seul le budget, la fonction s'arrête AU-DESSUS du budget plutôt
/// que d'y toucher. Dépasser est le moindre mal.
///
/// Partagé plutôt que recopié dans chaque backend, pour la raison qui vaut pour tout ce module :
/// trois copies d'une politique d'éviction finiraient par diverger sans que rien ne le dise.
pub fn lru_evictions(entries: &[(String, u64, u64)], budget: u64, protect_from: u64) -> Vec<String> {
let mut total: u64 = entries.iter().map(|(_, bytes, _)| *bytes).sum();
if total <= budget {
return Vec::new();
}
let mut candidates: Vec<&(String, u64, u64)> =
entries.iter().filter(|(_, _, tick)| *tick < protect_from).collect();
candidates.sort_by_key(|(_, _, tick)| *tick);
let mut out = Vec::new();
for (key, bytes, _) in candidates {
if total <= budget {
break;
}
total -= bytes;
out.push(key.clone());
}
out
}
#[cfg(test)]
mod tests {
use super::lru_evictions;
/// Un fond fixe a une clé qui ne reconnaît que lui, chacune de ses entrées comptant ; un fond
/// animé n'en a pas.
#[test]
fn a_static_background_is_keyed_by_everything_that_draws_it() {
use crate::scene::{SceneBackground as B, WallpaperMotion};
use super::BackgroundKey;
let image = |path: &str, motion| B::Image { path: path.to_string(), motion };
let still = image("/w/1.jpg", WallpaperMotion::None);
let (blur, fallback, size) = (0.0, [0.0; 4], [1920.0, 1080.0]);
let key = BackgroundKey::of(Some(&still), blur, fallback, size).expect("fond fixe");
assert!(key.matches(Some(&still), blur, fallback, size));
let other = image("/w/2.jpg", WallpaperMotion::None);
assert!(!key.matches(Some(&other), blur, fallback, size), "autre image");
assert!(!key.matches(Some(&still), 0.5, fallback, size), "autre flou");
assert!(!key.matches(Some(&still), blur, [1.0, 0.0, 0.0, 1.0], size), "autre repli");
assert!(!key.matches(Some(&still), blur, fallback, [1280.0, 720.0]), "autre taille");
assert!(!key.matches(None, blur, fallback, size), "pas de scène");
let drifting = image("/w/1.jpg", WallpaperMotion::Drift);
assert!(!key.matches(Some(&drifting), blur, fallback, size), "même image, animée");
assert!(BackgroundKey::of(Some(&drifting), blur, fallback, size).is_none());
let aurora = B::Gradient {
angle_deg: 90.0,
stops: vec!["#000".into(), "#fff".into()],
offsets: vec![],
motion: WallpaperMotion::Aurora,
};
assert!(BackgroundKey::of(Some(&aurora), blur, fallback, size).is_none(), "dégradé animé");
assert!(BackgroundKey::of(None, blur, fallback, size).is_some(), "fond de repli");
}
/// Les modèles 3D et le verre à plat qui en reprend les formes, eux seuls, passent par la
/// variante « modèles » du shader de calque.
#[test]
fn only_the_3d_models_need_the_models_shader() {
for mode in 0..=19 {
let cb = super::LayerCB { mode: mode as f32, ..Default::default() };
assert_eq!(cb.needs_models(), (15..=17).contains(&mode) || mode == 19, "mode {mode}");
}
}
#[test]
fn background_blur_steps_off_at_zero_and_old_switch_at_half() {
use super::background_blur_steps;
assert_eq!(background_blur_steps(0.0), None);
let (levels, off) = background_blur_steps(0.5).unwrap();
assert_eq!(levels, 3);
assert!((off - 2.2).abs() < 1e-5);
// Le rayon (2^niveaux × écart) croît avec la force, sans saut en arrière d'un niveau à
// l'autre.
let radius = |a: f32| background_blur_steps(a).map_or(0.0, |(l, o)| (1 << l) as f32 * o);
let mut prev = 0.0;
for i in 1..=100 {
let r = radius(i as f32 / 100.0);
assert!(r > prev, "rayon non croissant à {i}%");
prev = r;
}
}
/// `(clé, octets, tick)` — le tick croît avec l'usage, donc le plus petit est le plus ancien.
fn e(key: &str, mb: u64, tick: u64) -> (String, u64, u64) {
(key.to_string(), mb * 1024 * 1024, tick)
}
const BUDGET: u64 = 512 * 1024 * 1024;
#[test]
fn evicts_nothing_while_under_budget() {
assert!(lru_evictions(&[e("a", 100, 1), e("b", 100, 2)], BUDGET, 2).is_empty());
}
/// La plus ancienne part d'abord, et on s'arrête DÈS qu'on repasse sous le budget : évincer
/// au-delà ne rendrait que des rechargements.
#[test]
fn evicts_oldest_first_and_stops_at_the_budget() {
let entries = [e("vieux", 100, 1), e("moyen", 100, 2), e("neuf", 100, 9)];
assert_eq!(lru_evictions(&entries, 250 * 1024 * 1024, 9), vec!["vieux".to_string()]);
}
/// TOUT le jeu actif de la frame est protégé, pas seulement la dernière entrée posée. Une
/// frame qui échantillonne un fond d'écran ET un fond de caméra ne doit pas voir le premier
/// évincé parce que le second vient d'arriver — sinon les deux se chassent l'un l'autre à
/// chaque frame.
#[test]
fn protects_every_texture_used_this_frame() {
// frame commencée au tick 5 : `ecran` et `camera` servent tous deux maintenant.
let entries = [e("vieux", 100, 2), e("ecran", 400, 5), e("camera", 400, 6)];
assert_eq!(lru_evictions(&entries, BUDGET, 5), vec!["vieux".to_string()]);
}
/// Jeu actif plus gros que le budget : on rend ce qu'on peut et on reste au-dessus, plutôt que
/// de faire disparaître des textures dont cette frame a besoin.
#[test]
fn gives_up_rather_than_evicting_the_active_set() {
let entries = [e("a", 100, 1), e("actif", 900, 5)];
assert_eq!(lru_evictions(&entries, 256 * 1024 * 1024, 5), vec!["a".to_string()]);
}
use super::*;
fn layout_region(preset: &str, start: f32, end: f32, camera: Option<crate::scene::SceneRect>) -> crate::scene::SceneLayoutRegion {
crate::scene::SceneLayoutRegion {
clip_index: 0, start_sec: start, end_sec: end, preset: preset.to_owned(),
layout: crate::scene::ResolvedClipLayout {
screen_rect: crate::scene::SceneRect { x: 0.1, y: 0.1, width: 0.8, height: 0.8 },
webcam_rect: camera, screen_radius_frac: None, webcam_radius_frac: Some(0.0),
webcam_shape: Some("rectangle".to_owned()), screen_cover: false,
},
webcam_reactive_zoom: false, from_layout: None, from_preset: None, from_webcam_reactive_zoom: None,
keep_screen_clip_from_sec: None, transition_start_sec: start, transition_sec: 0.0,
}
}
#[test]
fn layout_partition_controls_real_frame_geometry() {
let mut scene = golden_scene();
scene.output.width = 1170;
scene.output.height = 658;
let full = crate::scene::SceneRect { x: 0.0, y: 0.0, width: 1.0, height: 1.0 };
scene.layout_regions = vec![layout_region("camera-only", 0.0, 5.0, Some(full)),
layout_region("no-webcam", 5.0, 10.0, None)];
let cfg = crate::config::all().pop().expect("compositor config");
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(2.0);
let camera = plan_frame(&input);
assert_eq!(camera.scene_preset.as_deref(), Some("camera-only"));
assert!((camera.w_dst[2] - 1.0).abs() < 0.001);
assert!((camera.w_dst[3] - 1.0).abs() < 0.001);
assert_eq!(camera.w_radius, 0.0);
input.timeline_t_override = Some(5.0);
let screen = plan_frame(&input);
assert_eq!(screen.scene_preset.as_deref(), Some("no-webcam"));
assert_eq!(screen.w_dst[2], 0.0);
assert_eq!(screen.w_dst[3], 0.0);
}
#[test]
fn a_layout_passage_keeps_zoom_inside_its_slot_and_restores_pip_overflow() {
for preset in ["dual-frame", "vertical-stack"] {
for frame in [crate::scene::SceneFrame::None, crate::scene::SceneFrame::Window,
crate::scene::SceneFrame::Laptop, crate::scene::SceneFrame::Phone,
crate::scene::SceneFrame::Monitor] {
let mut scene = zoomed_golden_scene();
scene.effects.frame = frame;
let mut block = layout_region(preset, 0.0, 3.0, None);
block.layout.screen_cover = true;
let pip = layout_region("picture-in-picture", 3.0, 10.0, None);
let slot = block.layout.screen_rect;
scene.layout_regions = vec![block, pip];
let cfg = crate::config::all().pop().expect("compositor config");
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(1.5);
let inside = plan_frame(&input);
let mask = inside.screen_mask.expect("the active block passage owns the mask");
assert_eq!(mask.rect, [slot.x, slot.y, slot.width, slot.height]);
let pixels = [inside.s_dst[2] * input.render_px[0], inside.s_dst[3] * input.render_px[1]];
let (drawn, _, _, _) = inside.mask_flat_screen(inside.s_dst, inside.cut, pixels, inside.s_radius, input.render_px);
assert!(contains(mask.rect, drawn, 1e-5), "{preset}: zoom escaped the slot");
input.timeline_t_override = Some(3.5);
let outside = plan_frame(&input);
assert!(outside.screen_mask.is_none(), "PiP must restore zoom overflow");
}
}
}
#[test]
fn layout_transition_is_source_anchored_and_never_crosses_clip_identity() {
let mut scene = golden_scene();
let full = crate::scene::SceneRect { x: 0.0, y: 0.0, width: 1.0, height: 1.0 };
let mut region = layout_region("camera-only", 3.0, 10.0, Some(full));
let mut from = region.layout.clone();
from.webcam_rect = Some(crate::scene::SceneRect { x: 0.8, y: 0.8, width: 0.2, height: 0.2 });
region.from_layout = Some(from);
region.transition_start_sec = 3.0;
region.transition_sec = 0.2;
scene.layout_regions = vec![region];
assert!((scene.layout_at(3.1).unwrap().layout.webcam_rect.unwrap().width - 0.6).abs() < 0.001);
assert_eq!(scene.layout_at(3.5).unwrap().layout.webcam_rect.unwrap().width, 1.0);
assert!(scene.layout_at(10.0).is_none());
let other = scene.for_clip_window(1, 0.0, 10.0);
assert!(other.layout_at(3.1).is_none());
let trimmed = scene.for_clip_window(0, 3.5, 7.0);
assert_eq!(trimmed.layout_at(3.5).unwrap().layout.webcam_rect.unwrap().width, 1.0);
}
#[test]
fn hard_layout_cuts_do_not_trail_the_previous_layout() {
use crate::scene::SceneRect;
let cfg = crate::config::all().pop().expect("compositor config");
let full = SceneRect { x: 0.0, y: 0.0, width: 1.0, height: 1.0 };
for explicit_from in [false, true] {
let mut scene = golden_scene();
scene.effects.motion_blur = 1.0;
let source = layout_region("picture-in-picture", 0.0, 3.0,
Some(SceneRect { x: 0.7, y: 0.7, width: 0.2, height: 0.2 }));
let mut target = layout_region("camera-only", 3.0, 10.0, Some(full));
target.layout.screen_rect = full;
target.from_layout = explicit_from.then(|| source.layout.clone());
target.transition_sec = 0.0;
scene.layout_regions = vec![source, target];
assert!(scene.layout_at(3.0).unwrap().hard_cut);
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(3.0);
let g = plan_frame(&input);
assert!(g.mb_amount > 0.0);
assert_eq!(g.s_dst, g.s_dst_prev, "a hard cut must not smear the old screen");
assert_eq!(g.w_dst, g.w_dst_prev, "a hard cut must not smear the old camera");
}
}
#[test]
fn animated_layout_changes_keep_the_previous_frame_for_motion_blur() {
use crate::scene::SceneRect;
let cfg = crate::config::all().pop().expect("compositor config");
let mut scene = golden_scene();
scene.effects.motion_blur = 1.0;
let full = SceneRect { x: 0.0, y: 0.0, width: 1.0, height: 1.0 };
let source = layout_region("picture-in-picture", 0.0, 3.0,
Some(SceneRect { x: 0.7, y: 0.7, width: 0.2, height: 0.2 }));
let mut target = layout_region("camera-only", 3.0, 10.0, Some(full));
target.layout.screen_rect = full;
target.from_layout = Some(source.layout.clone());
target.transition_sec = 0.2;
scene.layout_regions = vec![source, target];
assert!(!scene.layout_at(3.1).unwrap().hard_cut);
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(3.1);
let g = plan_frame(&input);
assert_ne!(g.s_dst, g.s_dst_prev, "an animated screen keeps its motion trail");
assert_ne!(g.w_dst, g.w_dst_prev, "an animated camera keeps its motion trail");
}
#[test]
fn layout_animation_does_not_puff_the_footage_during_an_existing_zoom() {
use crate::scene::SceneRect;
let mut scene = golden_scene();
scene.effects.frame = crate::scene::SceneFrame::Phone;
scene.crop_by_clip = vec![None];
let mut zoom = zoomed_golden_scene().zoom_regions.remove(0);
zoom.start_sec = 0.963;
zoom.end_sec = 1.301;
zoom.scale = 1.8;
let mut later_zoom = zoom.clone();
later_zoom.start_sec = 5.0;
later_zoom.end_sec = 6.0;
scene.zoom_regions = vec![zoom, later_zoom];
let screen = SceneRect { x: 0.114792, y: 0.077604, width: 0.770416, height: 0.292708 };
let mut block = layout_region("vertical-stack", 0.0, 1.129, None);
block.layout.screen_rect = screen;
block.layout.screen_cover = true;
let mut pip = layout_region("picture-in-picture", 1.129, 2.163, None);
pip.layout.screen_rect = SceneRect { y: 0.353646, ..screen };
pip.from_layout = Some(block.layout.clone());
pip.transition_sec = 0.2;
pip.keep_screen_clip_from_sec = Some(1.129);
let mut no_camera = layout_region("no-webcam", 2.163, 10.0, None);
no_camera.layout.screen_rect = pip.layout.screen_rect;
no_camera.from_layout = Some(pip.layout.clone());
no_camera.transition_sec = 0.1345;
no_camera.keep_screen_clip_from_sec = Some(1.129);
scene.layout_regions = vec![block, pip, no_camera];
let cfg = crate::config::all().pop().expect("compositor config");
let sample = |t| {
let mut input = golden_input(&scene, &cfg);
input.render_px = [1298.0, 1920.0];
input.timeline_t_override = Some(t);
plan_frame(&input)
};
// Same footage size at both endpoints: moving from top to centre must not inflate it.
for frame in 0..=180 {
let t = 1.129 + frame as f32 / 120.0;
let g = sample(t);
assert!((g.frame_box()[2] - screen.width).abs() < 0.0001,
"at {t}: the footage grew to {} instead of {}", g.frame_box()[2], screen.width);
assert!((g.frame_box()[3] - screen.height).abs() < 0.0001,
"at {t}: the footage height pulsed");
}
assert!(sample(1.25).s_dst[2] > screen.width + 0.1, "the existing zoom still runs inside");
let next = sample(5.5);
assert!(next.screen_mask.is_none(), "a later independent PiP zoom must stay free");
assert!(next.s_dst[2] > screen.width + 0.1);
}
#[test]
fn layout_animation_preserves_camera_roundness_while_it_disappears() {
use crate::scene::SceneRect;
let cfg = crate::config::all().pop().expect("compositor config");
for radius in [0.0, 0.06, 0.3, 0.5] {
for appearing in [false, true] {
let mut scene = golden_scene();
let mut camera = layout_region("picture-in-picture", 0.0, 3.0,
Some(SceneRect { x: 0.7, y: 0.6, width: 0.2, height: 0.2 * 16.0 / 9.0 }));
camera.layout.webcam_radius_frac = Some(radius);
let mut hidden = layout_region("no-webcam", 0.0, 3.0, None);
hidden.layout.webcam_radius_frac = None;
let (source, mut target) = if appearing { (hidden, camera) } else { (camera, hidden) };
target.start_sec = 3.0;
target.end_sec = 10.0;
target.transition_start_sec = 3.0;
target.transition_sec = 0.2;
target.from_layout = Some(source.layout.clone());
scene.layout_regions = vec![source, target];
for progress in [0.05, 0.25, 0.5, 0.75, 0.95] {
let mut input = golden_input(&scene, &cfg);
input.render_px = [1920.0, 1080.0];
input.timeline_t_override = Some(3.0 + 0.2 * progress);
let g = plan_frame(&input);
let side = (g.w_dst[2] * 1920.0).min(g.w_dst[3] * 1080.0);
assert!(side > 0.0);
assert!((g.w_radius / side - radius).abs() < 0.0001,
"roundness {radius}, appearing {appearing}, progress {progress}: got {}", g.w_radius / side);
}
}
}
}
#[test]
fn every_layout_pair_has_continuous_footage_at_both_transition_edges() {
use crate::scene::{SceneFrame, SceneRect};
let presets = ["picture-in-picture", "dual-frame", "vertical-stack", "camera-only", "no-webcam"];
let resolved = |preset: &str, start: f32, end: f32| {
let block = matches!(preset, "dual-frame" | "vertical-stack");
let camera = match preset {
"no-webcam" => None,
"camera-only" => Some(SceneRect { x: 0.0, y: 0.0, width: 1.0, height: 1.0 }),
"picture-in-picture" => Some(SceneRect { x: 0.7, y: 0.65, width: 0.15, height: 0.15 * 16.0 / 9.0 }),
_ => Some(SceneRect { x: 0.65, y: 0.2, width: 0.25, height: 0.6 }),
};
let mut region = layout_region(preset, start, end, camera);
region.layout.screen_rect = if block {
SceneRect { x: 0.1, y: 0.2, width: 0.45, height: 0.6 }
} else { SceneRect { x: 0.1, y: 0.1, width: 0.8, height: 0.8 } };
region.layout.screen_cover = block;
region.layout.screen_radius_frac = block.then_some(0.06);
region.layout.webcam_radius_frac = Some(if preset == "picture-in-picture" { 0.5 } else { 0.0 });
region.webcam_reactive_zoom = preset == "picture-in-picture";
region
};
let cfg = crate::config::all().pop().expect("compositor config");
for from in presets {
for to in presets {
if from == to { continue; }
for frame in [SceneFrame::None, SceneFrame::Window, SceneFrame::Laptop] {
for zoom in [1.0, 2.0] {
let mut scene = zoomed_golden_scene();
scene.effects.frame = frame;
scene.zoom_regions[0].scale = zoom;
let source = resolved(from, 0.0, 3.0);
let mut target = resolved(to, 3.0, 10.0);
target.from_layout = Some(source.layout.clone());
target.from_preset = Some(from.to_owned());
target.from_webcam_reactive_zoom = Some(source.webcam_reactive_zoom);
target.transition_sec = 0.2;
scene.layout_regions = vec![source, target];
let sample = |t| {
let mut input = golden_input(&scene, &cfg);
input.render_px = [1920.0, 1080.0];
input.timeline_t_override = Some(t);
plan_frame(&input)
};
for edge in [3.0, 3.2] {
let a = sample(edge - 0.00001);
let b = sample(edge + 0.00001);
let visible = |g: &FrameGeometry| {
g.mask_flat_screen(g.s_dst, g.cut,
[g.s_dst[2] * 1920.0, g.s_dst[3] * 1080.0], g.s_radius, [1920.0, 1080.0])
};
let (ad, au, _, ar) = visible(&a);
let (bd, bu, _, br) = visible(&b);
for k in 0..4 {
assert!((ad[k] - bd[k]).abs() < 0.0001,
"{from} → {to}, {frame:?}, zoom {zoom}, edge {edge}: footage jumped {ad:?} → {bd:?}");
assert!((au[k] - bu[k]).abs() < 0.0001,
"{from} → {to}, edge {edge}: crop jumped {au:?} → {bu:?}");
if a.w_dst[2].max(b.w_dst[2]) > 0.0001 {
assert!((a.w_dst[k] - b.w_dst[k]).abs() < 0.0001,
"{from} → {to}, edge {edge}: camera jumped");
}
}
assert!((ar - br).abs() < 0.1, "{from} → {to}, edge {edge}: corners jumped {ar} → {br}");
assert!((a.webcam_shadow - b.webcam_shadow).abs() < 0.0001,
"{from} → {to}: camera shadow jumped");
}
}
}
}
}
}
/// La scène de référence du golden : un cas qui exerce le padding, le crop, le zoom,
/// une caméra PiP décalée, un rayon et une inclinaison nulle.
fn golden_scene() -> Scene {
Scene::from_json(
r##"{
"clips":[{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":true}],
"layout":{"preset":"picture-in-picture","webcamSize":0.44,"webcamShape":"circle","webcamMirror":false,
"webcamPosition":{"cx":0.8577,"cy":0.8159},"webcamReactiveZoom":false},
"effects":{"padding":0.51,"blur":false,"shadow":0.35,"roundnessFrac":0.0255,"motionBlur":0.35},
"background":{"kind":"color","color":"#1e1e2e"},
"zoomRegions":[],
"cursor":{"show":true,"size":7.76,"smoothing":0,"motionBlur":0.35,"clickBounce":1,"clipToBounds":false,"theme":"default"},
"cropByClip":[{"x":0,"y":0,"width":0.61,"height":0.61}],
"output":{"width":1170,"height":658,"fps":60}
}"##,
)
.expect("golden scene")
}
fn golden_input(scene: &Scene, cfg: &Cfg) -> FrameGeometryInput<'static> {
// SAFETY-free: on fuit volontairement les deux références pour obtenir un
// `'static` dans le test — la scène et le cfg vivent jusqu'à la fin du process.
let scene: &'static Scene = Box::leak(Box::new(scene.clone()));
let cfg: &'static Cfg = Box::leak(Box::new(cfg.clone()));
FrameGeometryInput {
render_px: [1170.0, 658.0],
screen_tex_px: [1920.0, 1088.0],
screen_visible_px: [1920.0, 1080.0],
webcam_visible_px: [1280.0, 720.0],
u_max: 1920.0 / 1920.0,
v_max: 1080.0 / 1088.0,
frame: 90.0,
cfg,
live: live_params_from_scene(scene),
scene: Some(scene),
cursor: None,
timeline_t_override: Some(1.5),
// Distinct de `source_t` et de `frame / FPS` : un croisement des trois se verrait.
programme_time: Some(2.25),
}
}
/// Le JSON de la scène zoomée, brut : `tilted_golden_scene` n'en change QUE la
/// rotation, et le faire par substitution garantit que les deux scènes ne diffèrent
/// pas ailleurs sans qu'on s'en aperçoive.
fn zoomed_golden_scene_json() -> &'static str {
r##"{
"clips":[{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":true}],
"layout":{"preset":"picture-in-picture","webcamSize":0.44,"webcamShape":"circle","webcamMirror":false,
"webcamPosition":{"cx":0.8577,"cy":0.8159},"webcamReactiveZoom":false},
"effects":{"padding":0.51,"blur":false,"shadow":0.35,"roundnessFrac":0.0255,"motionBlur":0.35},
"background":{"kind":"color","color":"#1e1e2e"},
"zoomRegions":[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}],
"cursor":{"show":true,"size":7.76,"smoothing":0,"motionBlur":0.35,"clickBounce":1,"clipToBounds":false,"theme":"default"},
"cropByClip":[{"x":0,"y":0,"width":0.61,"height":0.61}],
"output":{"width":1170,"height":658,"fps":60}
}"##
}
/// La même scène, avec une région de zoom active à `t = 1.5 s`.
fn zoomed_golden_scene() -> Scene {
Scene::from_json(zoomed_golden_scene_json()).expect("zoomed golden scene")
}
/// L'ancre des annotations ne bouge PAS avec le zoom, alors que la boîte écran, si.
///
/// C'est tout le contrat de `SceneAnnotation` : l'overlay web est frère de l'élément qui
/// porte la transform de zoom, donc annotations et sous-titres tiennent en place pendant
/// que le contenu grossit dessous. Tant que le zoom vivait dans la coupe source, `s_dst`
/// jouait ce rôle sans effort ; depuis l'issue #179 il vit dans la BOÎTE, et le natif
/// zoomait les sous-titres avec l'écran. Ce test échoue si `s_ann` se remet à suivre.
#[test]
fn the_annotation_anchor_ignores_the_zoom() {
let cfg = crate::config::all().pop().expect("au moins une config");
let plain = golden_scene();
let zoomed = zoomed_golden_scene();
let a = plan_frame(&golden_input(&plain, &cfg));
let b = plan_frame(&golden_input(&zoomed, &cfg));
assert_ne!(
a.s_dst, b.s_dst,
"le zoom doit bel et bien agir sur la boîte écran (issue #179) — \
sinon ce test ne prouve rien"
);
assert_eq!(
a.s_ann, b.s_ann,
"l'ancre des annotations a suivi le zoom : sans zoom {:?}, avec zoom {:?}",
a.s_ann, b.s_ann
);
// Et sans zoom, l'ancre EST la boîte écran : `s_ann` ne doit pas devenir un rect
// parallèle qui dériverait de `s_dst` pour d'autres raisons (padding, cover, crop).
assert_eq!(a.s_ann, a.s_dst, "sans zoom, ancre et boîte écran coïncident");
}
/// Full Camera coupée par un trim (source 15 → 16) : la première frame après la coupe garde
/// la caméra plein cadre ET sa frame précédente aussi. Celle-ci tombait dans le trou du trim,
/// où aucun morceau de la région ne vit, donc au coin PiP : le flou de mouvement traînait la
/// caméra du plein cadre au coin sur cette frame-là (passe e2e de v2.1.0-rc.1).
#[test]
fn the_first_frame_after_a_cut_inside_full_camera_has_no_trail() {
let cfg = crate::config::all().pop().expect("au moins une config");
let scene = Scene::from_json(
r##"{
"clips":[{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":15,"webcamOffsetSec":0,"hasAudio":true},
{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":16,"sourceEndSec":20,"webcamOffsetSec":0,"hasAudio":true}],
"layout":{"preset":"picture-in-picture","webcamSize":0.44,"webcamShape":"circle","webcamMirror":false,
"webcamPosition":{"cx":0.8577,"cy":0.8159},"webcamReactiveZoom":false},
"effects":{"padding":0.51,"blur":false,"shadow":0.35,"roundnessFrac":0.0255,"motionBlur":0.35},
"background":{"kind":"color","color":"#1e1e2e"},
"zoomRegions":[],
"cameraFullscreenRegions":[{"clipIndex":0,"startSec":13,"endSec":15,"continuesAfter":true},
{"clipIndex":1,"startSec":16,"endSec":18,"continuesBefore":true}],
"cursor":{"show":true,"size":7.76,"smoothing":0,"motionBlur":0.35,"clickBounce":1,"clipToBounds":false,"theme":"default"},
"output":{"width":1170,"height":658,"fps":60}
}"##,
)
.expect("scène coupée")
.for_clip_window(1, 16.0, 20.0);
let mut input = golden_input(&scene, &cfg);
// Une frame écran à 60 i/s qui tombe juste après la coupe, comme 16.0008 s dans la passe.
input.timeline_t_override = Some(16.0008);
let g = plan_frame(&input);
assert_eq!(g.w_dst, [0.0, 0.0, 1.0, 1.0], "la caméra reste plein cadre à travers le trim");
assert_eq!(g.w_dst_prev, g.w_dst, "pas de traînée depuis le trou du trim");
}
/// La même coupe, mais la première frame du clip tombe PILE sur son début, comme à l'export
/// (`walk_composited_timeline` pose `target_source_time as f32`), et ce début n'est pas exact
/// en f32 : `11.388f32` relu en f64 vaut 11.38799953…, sous le début du clip. La borne de la
/// frame précédente ne s'appliquait donc pas, alors que la phase Full Camera, comparée en
/// f32, voyait déjà la caméra plein cadre : frame 600 traînée vers le coin PiP à l'export et
/// dans `getFrames` (passe e2e macOS de v2.1.0-rc.3).
#[test]
fn the_first_frame_of_a_clip_starting_inside_full_camera_has_no_trail() {
let cfg = crate::config::all().pop().expect("au moins une config");
let scene = Scene::from_json(
r##"{
"clips":[{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10.001,"webcamOffsetSec":0,"hasAudio":true},
{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":11.388,"sourceEndSec":27.12,"webcamOffsetSec":0,"hasAudio":true}],
"layout":{"preset":"picture-in-picture","webcamSize":0.44,"webcamShape":"circle","webcamMirror":false,
"webcamPosition":{"cx":0.8577,"cy":0.8159},"webcamReactiveZoom":false},
"effects":{"padding":0.51,"blur":false,"shadow":0.35,"roundnessFrac":0.0255,"motionBlur":0.2},
"background":{"kind":"color","color":"#1e1e2e"},
"zoomRegions":[],
"cameraFullscreenRegions":[{"clipIndex":0,"startSec":8.006,"endSec":10.001,"continuesAfter":true},
{"clipIndex":1,"startSec":11.388,"endSec":14.061,"continuesBefore":true}],
"cursor":{"show":true,"size":7.76,"smoothing":0,"motionBlur":0.35,"clickBounce":1,"clipToBounds":false,"theme":"default"},
"output":{"width":1080,"height":1920,"fps":60}
}"##,
)
.expect("scène coupée")
.for_clip_window(1, 11.388, 27.12);
assert!(f64::from(11.388f32) < 11.388, "le cas suppose un début inexact en f32");
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(11.388f64 as f32);
let g = plan_frame(&input);
assert_eq!(g.w_dst, [0.0, 0.0, 1.0, 1.0], "la caméra reste plein cadre à travers le trim");
assert_eq!(g.w_dst_prev, g.w_dst, "pas de traînée depuis le trou du trim");
}
/// La caméra en orbite, en focus auto : celle qui bouge avec le pointeur. Sans piste, elle
/// rend comme l'orbite manuelle posée au centre.
const ORBIT: &str = r#""orbit","focusMode":"auto""#;
/// Scène à boîte écran résolue par l'app, pour le cadre de fenêtre. `frame` est inséré tel
/// quel dans `effects` (chaîne vide = clé absente).
fn framed_scene(frame: &str, rotation: &str, zoom: f32, cover: bool) -> Scene {
Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}},"screenCover":{cover}}},
"effects":{{"padding":0.2,"blur":false,"shadow":0.5,"roundnessFrac":0.03,"motionBlur":0{frame}}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":{zoom},"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],
"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1920,"height":1080,"fps":60}}
}}"##
))
.expect("framed scene")
}
fn framed_plan(scene: &Scene) -> FrameGeometry {
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(scene, &cfg);
input.render_px = [1920.0, 1080.0];
plan_frame(&input)
}
const RENDER: [f32; 2] = [1920.0, 1080.0];
fn contains(outer: [f32; 4], inner: [f32; 4], eps: f32) -> bool {
inner[0] >= outer[0] - eps
&& inner[1] >= outer[1] - eps
&& inner[0] + inner[2] <= outer[0] + outer[2] + eps
&& inner[1] + inner[3] <= outer[1] + outer[3] + eps
}
/// Sans cadre — clé absente ou `"none"` —, la géométrie est celle d'avant le cadre, champ
/// pour champ, et l'ombre reprend exactement l'arithmétique des backends.
#[test]
fn no_frame_leaves_the_geometry_untouched() {
for rotation in ["null", r#""iso""#] {
let absent = framed_plan(&framed_scene("", rotation, 1.5, false));
let none = framed_plan(&framed_scene(r#","frame":"none""#, rotation, 1.5, false));
assert_eq!(absent.s_dst, none.s_dst);
assert_eq!(absent.s_ann, none.s_ann);
assert_eq!(absent.s_radius.to_bits(), none.s_radius.to_bits());
assert!(none.window_frame.is_none());
assert!(none.window_frame_cb(RENDER).is_none());
assert_eq!(none.screen_square_top(), 0.0);
let s_px = [none.s_dst[2] * RENDER[0], none.s_dst[3] * RENDER[1]];
let expected = match none.screen_tilt_in(RENDER) {
None => ShadowCaster::Upright { dst: none.s_dst, size_px: s_px, radius: none.s_radius },
Some(q) => ShadowCaster::Tilted {
corners: q.corners,
center_px: none.screen_center_px(RENDER),
radius: none.s_radius * q.scale,
mask: None,
},
};
assert_eq!(none.shadow_caster(RENDER), expected);
// Sans zoom, l'ancre des annotations reste la boîte écran.
let rest = framed_plan(&framed_scene(r#","frame":"none""#, rotation, 1.0, false));
assert_eq!(rest.s_ann, rest.s_dst);
// Et cette boîte est celle que la scène a résolue, au bit près : sans cadre, rien ne
// la rétrécit. Épinglé sur l'entrée, pas sur une mesure du code.
let want: [f32; 4] = [0.1, 0.1, 0.8, 0.8];
assert_eq!(rest.s_dst.map(f32::to_bits), want.map(f32::to_bits));
assert_eq!(rest.s_ann.map(f32::to_bits), want.map(f32::to_bits));
assert_eq!(rest.s_radius.to_bits(), (0.03f32 * rest.screen_unit_px).to_bits());
}
}
/// Une scène sans cadre, écran 16:9 (texture 1920×1080) posé par l'app dans `rect`, rendue
/// dans `render` au padding 50 % (`padding_scale` 0,8) avec un Roundness de 24 px.
fn unit_plan(rect: [f32; 4], render: [f32; 2]) -> FrameGeometry {
let scene = Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":{},"y":{},"width":{},"height":{}}},"screenCover":false}},
"effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":{},"motionBlur":0}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[],
"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":{},"height":{},"fps":60}}
}}"##,
rect[0], rect[1], rect[2], rect[3], 24.0 / 1080.0, render[0], render[1]
))
.expect("scène");
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(&scene, &cfg);
input.render_px = render;
input.u_max = 1.0;
input.v_max = 1.0;
input.screen_tex_px = [1920.0, 1080.0];
input.screen_visible_px = [1920.0, 1080.0];
plan_frame(&input)
}
/// Le curseur, l'ombre et les coins se mesurent sur l'ÉCRAN (`screen_unit_px`), plus sur le
/// cadre ni sur la source.
///
/// * sortie au ratio du clip : l'unité est le petit côté du cadre, le rendu d'avant ;
/// * clip 16:9 dans une sortie 9:16 : l'écran est une bande de 864×486, et l'unité rétrécit
/// avec lui (× 9/16) au lieu de rester à 1080 — la proportion curseur / écran est celle
/// du 16:9 ;
/// * sortie 4K (prise 2160p) : l'unité double avec l'écran, et 24 px de Roundness font
/// 48 px, la même part de l'écran qu'en 1080p.
#[test]
fn style_lengths_follow_the_screen_not_the_frame_or_the_source() {
let (w, h) = (1920.0f32, 1080.0f32);
let landscape = unit_plan([0.1, 0.1, 0.8, 0.8], [w, h]);
assert!((landscape.screen_unit_px - 1080.0).abs() < 0.01, "{}", landscape.screen_unit_px);
assert!((landscape.s_radius - 24.0).abs() < 0.01, "{}", landscape.s_radius);
let band_h = 0.8 * h * 9.0 / 16.0 / w; // 486 px sur 1920
let portrait = unit_plan([0.1, 0.5 - band_h / 2.0, 0.8, band_h], [h, w]);
assert!(
(portrait.screen_unit_px - 1080.0 * 9.0 / 16.0).abs() < 0.01,
"{}",
portrait.screen_unit_px
);
// Même part de l'écran : rayon / petit côté de l'écran.
let share = |g: &FrameGeometry, px: [f32; 2]| {
g.s_radius / (g.s_dst[2] * px[0]).min(g.s_dst[3] * px[1])
};
assert!((share(&portrait, [h, w]) - share(&landscape, [w, h])).abs() < 1e-4);
let uhd = unit_plan([0.1, 0.1, 0.8, 0.8], [2.0 * w, 2.0 * h]);
assert!((uhd.s_radius - 48.0).abs() < 0.02, "{}", uhd.s_radius);
assert!((share(&uhd, [2.0 * w, 2.0 * h]) - share(&landscape, [w, h])).abs() < 1e-4);
}
/// Sous un cadre, le masque de confidentialité couvre le rect que l'overlay web montre à
/// l'utilisateur : `layout.screenRect` TEL QUEL, puisque le cadre ne touche plus au métrage.
/// L'overlay posait autrefois ses poignées sur un rect rétréci sous la barre de titre ; ancré
/// ailleurs, le masque en laissait une bande lisible.
#[test]
fn a_framed_privacy_mask_covers_what_the_overlay_shows() {
// A plat seulement : incliné, le contenu ne tombe plus dans un rect droit, et l'overlay
// web ne s'incline pas non plus (limite antérieure au cadre).
let overlay: [f32; 4] = [0.1, 0.1, 0.8, 0.8];
for frame in [r#","frame":"window""#, r#","frame":"laptop""#, r#","frame":"phone""#, r#","frame":"monitor""#] {
let g = framed_plan(&framed_scene(frame, "null", 1.0, false));
assert_eq!(g.s_ann.map(f32::to_bits), overlay.map(f32::to_bits), "{frame}: l'ancre n'est pas le rect de l'overlay");
for (x, y) in [(0.0, 0.0), (0.62, 0.18), (0.8, 0.9)] {
let mut a = blur_annotation("");
(a.x, a.y) = (x, y);
let drawn = annotation_dst_in(overlay, a.x, a.y, a.w, a.h);
let m = g.privacy_mask(&a, RENDER).expect("masque");
assert!(contains(m.dst, drawn, 1e-6), "{frame}: masque {:?} / tracé {drawn:?}", m.dst);
// Et il ne déborde que de sa marge d'un pixel.
assert!((m.dst[1] - drawn[1]).abs() * RENDER[1] < 1.01);
}
}
}
/// Le flou de mouvement prend l'écran cadré EN BLOC (ombre, cadre, appareil compris) dès que
/// sa boîte bouge, et rend alors la main au flou par pixel du seul métrage ; jamais sous un
/// masque de bloc, dont la case reste fixe.
#[test]
fn a_moving_screen_box_is_motion_blurred_as_one_object() {
for frame in ["", r#","frame":"window""#, r#","frame":"phone""#] {
let mut g = framed_plan(&framed_scene(frame, "null", 1.5, false));
(g.mb_taps, g.mb_amount) = (16.0, 1.0);
g.s_dst_prev = g.s_dst;
assert!(!g.screen_trail(RENDER), "{frame}: boîte immobile");
assert_eq!(g.screen_pixel_taps(RENDER), 16.0);
g.s_dst_prev[2] *= 0.9;
assert!(g.screen_trail(RENDER), "{frame}: boîte qui bouge");
assert_eq!(g.screen_pixel_taps(RENDER), 1.0, "{frame}: flou compté deux fois");
let cb = g.screen_trail_cb(RENDER, true);
assert_eq!((cb.fx, cb.dst_prev, cb.src), (g.s_dst, g.s_dst_prev, g.cut));
assert_eq!(cb.mb, [16.0, 1.0, 0.0, 0.0], "{frame}: la boîte, pas le plan");
// À plat, ni profondeur de champ ni lampe : le repli relit le métrage net.
assert_eq!((cb.trail_mb, cb.color), ([0.0; 4], [0.0; 4]), "{frame}: repli net");
g.mb_amount = 0.0;
assert!(!g.screen_trail(RENDER), "{frame}: flou coupé");
g.mb_amount = 1.0;
g.screen_mask = Some(ScreenMask { rect: [0.0, 0.0, 0.5, 1.0], radius_px: 0.0, square_top: false });
assert!(!g.screen_trail(RENDER), "{frame}: la case d'un bloc ne bouge pas");
assert_eq!(g.screen_pixel_taps(RENDER), 16.0);
}
}
/// Sous une caméra 3D aussi (angle fixe ou caméra réelle), l'écran cadré est flouté en bloc :
/// pendant la rampe du zoom, son PLAN bouge, et le mode 8 lâche alors sa traînée par pixel,
/// sinon le métrage serait flouté deux fois. Le calque porte les coins du plan en fractions de
/// la sortie : ceux que le mode 8 dessine, et ceux de `tilt_trail`. Au palier, rien ne bouge.
#[test]
fn a_moving_tilted_screen_is_motion_blurred_as_one_object() {
let cfg = crate::config::all().pop().expect("au moins une config");
for rotation in [r#""iso""#, ORBIT] {
for frame in ["", r#","frame":"laptop""#] {
let mut scene = framed_scene(frame, rotation, 1.5, false);
scene.effects.motion_blur = 1.0;
// La région démarre à 2 s : à 1,6 s, sa rampe d'entrée est en cours.
scene.zoom_regions[0].start_sec = 2.0;
let at = |t: f32| {
let input = golden_input(&scene, &cfg);
plan_frame(&FrameGeometryInput { render_px: RENDER, timeline_t_override: Some(t), ..input })
};
let case = format!("{rotation}{frame}");
let hold = at(3.0);
assert!(hold.tilted(), "{case}: le palier doit être incliné");
assert!(!hold.screen_trail(RENDER), "{case}: au palier, rien ne bouge");
assert!(hold.tilt_pixel_trail(RENDER).is_some(), "{case}: le mode 8 garde sa traînée");
let g = at(1.6);
let quad = g.screen_tilt_in(RENDER).expect("incliné");
let trail = g.tilt_trail(RENDER).expect("traînée");
assert_ne!(trail.corners, quad.corners, "{case}: le plan doit bouger à 1,6 s");
assert!(g.screen_trail(RENDER), "{case}: le plan bouge, le cadre doit suivre");
assert_eq!(g.tilt_pixel_trail(RENDER), None, "{case}: flou compté deux fois");
let cb = g.screen_trail_cb(RENDER, true);
// Le warp du plan, celui du mode 8 : bilinéaire sous un angle fixe nu, projectif
// sous la caméra réelle ou un appareil.
let warp = if rotation == r#""iso""# && frame.is_empty() { 0.0 } else { 1.0 };
assert_eq!(quad.warp_flag(), warp, "{case}: warp du plan");
assert_eq!((cb.mode, cb.mb, cb.src), (18.0, [g.mb_taps, g.mb_amount, 1.0, warp], g.cut));
let c = g.screen_center_px(RENDER);
let out = |(x, y): (f32, f32)| [(c[0] + x) / RENDER[0], (c[1] + y) / RENDER[1]];
let pairs = |a: [f32; 4], b: [f32; 4]| [[a[0], a[1]], [a[2], a[3]], [b[0], b[1]], [b[2], b[3]]];
assert_eq!(pairs(cb.fx, cb.src_prev), quad.corners.map(out), "{case}: coins courants");
assert_eq!(pairs(cb.trail_a, cb.trail_b), trail.corners.map(out), "{case}: coins d'avant");
// L'ouverture du repli se mesure dans le plan, comme au mode 8.
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
assert_eq!(cb.quad_px, s_px.map(|v| v * quad.scale));
assert_eq!(cb.radius_px, g.s_radius * quad.scale);
// Et il relit le métrage comme le mode 8 l'a dessiné : même profondeur de champ
// (son `mb`), même lampe (son `color.xy`).
let mode8 = tilted_screen_cb(&quad, s_px, c, g.cut, g.focus_plane, g.s_radius, 0.0, true, RENDER, None, None);
assert!(mode8.mb[3] > 0.0, "{case}: la profondeur de champ doit tourner");
assert_eq!(cb.trail_mb, mode8.mb, "{case}: profondeur de champ du repli");
assert_eq!(cb.color, [mode8.color[0], mode8.color[1], 0.0, 0.0], "{case}: lampe du repli");
// Sous un masque de bloc, la case ne bouge pas : retour au flou par pixel.
let mut masked = g;
masked.screen_mask = Some(ScreenMask { rect: [0.0, 0.0, 0.5, 1.0], radius_px: 0.0, square_top: false });
assert!(!masked.screen_trail(RENDER), "{case}: la case d'un bloc ne bouge pas");
assert_eq!(masked.tilt_pixel_trail(RENDER), Some(trail));
}
}
}
/// À plat : le métrage garde EXACTEMENT sa boîte, et le chrome de fenêtre pousse vers
/// l'extérieur — la barre de titre au-dessus, le filet autour. Le cadre porte l'ombre, avec
/// le rayon du métrage plus le filet : un contour concentrique.
#[test]
fn the_flat_window_frame_grows_outward() {
for (frame, dark) in [(r#","frame":"window-light""#, false), (r#","frame":"window-dark""#, true)] {
for cover in [false, true] {
let old = framed_plan(&framed_scene("", "null", 1.0, cover));
let g = framed_plan(&framed_scene(frame, "null", 1.0, cover));
let wf = g.window_frame.expect("un cadre");
assert_eq!(wf.dark, dark);
assert_eq!(g.screen_square_top(), 1.0);
assert_eq!(g.s_dst.map(f32::to_bits), old.s_dst.map(f32::to_bits), "le cadre a touché au métrage");
assert_eq!(g.cut, old.cut, "le cadre a recadré la source");
let ShadowCaster::Upright { dst: outer, size_px, radius } = g.shadow_caster(RENDER) else {
panic!("un cadre droit porte une ombre droite");
};
assert!(contains(outer, g.s_dst, 1e-6), "cadre {outer:?} / écran {:?}", g.s_dst);
assert!(outer[2] > g.s_dst[2] && outer[3] > g.s_dst[3], "le cadre ne déborde pas");
// La barre de titre est en haut, le filet ailleurs.
assert!(wf.margins[1] * g.s_dst[3] > 10.0 * wf.margins[0] * g.s_dst[2]);
// Roundness arrondit le cadre ; son rayon est celui du métrage plus le filet.
let line_px = wf.margins[0] * g.s_dst[2] * RENDER[0];
assert!((radius - (g.s_radius + line_px)).abs() < 1e-3, "rayon {radius} vs {}", g.s_radius + line_px);
// Le calque du cadre : un rect exact, bbox comprise.
let cb = g.window_frame_cb(RENDER).expect("calque");
assert_eq!(cb.mode, 14.0);
assert!((cb.quad_px[0] - size_px[0]).abs() < 1e-2 && (cb.quad_px[1] - size_px[1]).abs() < 1e-2);
assert_eq!([cb.fx[0], cb.fx[1]], [0.0, 0.0]);
assert!((cb.src_prev[0] - size_px[0]).abs() < 1e-2 && (cb.src_prev[1] - size_px[1]).abs() < 1e-2);
assert!((cb.dst_prev[0] - size_px[0]).abs() < 1e-2);
assert_eq!(cb.radius_px, radius);
}
}
}
/// Incliné : le cadre est le même plan que l'écran, prolongé. Les coins de l'écran sont
/// l'image bilinéaire des coins du cadre aux fractions de ses marges — la propriété qui
/// garantit que le cadre penche exactement comme le contenu —, le cadre contient l'écran et
/// porte l'ombre (mode 12).
#[test]
fn the_tilted_frame_is_the_screen_plane_extended() {
for preset in [r#""iso""#, r#""left""#, r#""right""#] {
let g = framed_plan(&framed_scene(r#","frame":"window-light""#, preset, 1.0, false));
let wf = g.window_frame.expect("un cadre");
let quad = g.screen_tilt_in(RENDER).expect("incliné");
let ShadowCaster::Tilted { corners: frame, center_px, radius, .. } = g.shadow_caster(RENDER) else {
panic!("un cadre incliné porte une ombre inclinée");
};
assert_eq!(center_px, g.screen_center_px(RENDER));
assert!((radius - wf.radius[0] * quad.scale).abs() < 1e-4);
let [ml, mt, mr, mb] = wf.margins;
let frame_quad = crate::regions::TiltedQuad { corners: frame, ..quad };
let (u0, v0) = (ml / (1.0 + ml + mr), mt / (1.0 + mt + mb));
let (u1, v1) = ((1.0 + ml) / (1.0 + ml + mr), (1.0 + mt) / (1.0 + mt + mb));
for (i, (u, v)) in [(u0, v0), (u1, v0), (u1, v1), (u0, v1)].into_iter().enumerate() {
let (x, y) = frame_quad.point_px(u, v);
let (sx, sy) = quad.corners[i];
assert!((x - sx).abs() < 0.05 && (y - sy).abs() < 0.05, "{preset} coin {i}: {x},{y} vs {sx},{sy}");
}
// Le cadre contient l'écran : chaque coin de l'écran est du bon côté des 4 arêtes.
for &(px, py) in &quad.corners {
for k in 0..4 {
let (ax, ay) = frame[k];
let (bx, by) = frame[(k + 1) % 4];
let cross = (bx - ax) * (py - ay) - (by - ay) * (px - ax);
assert!(cross > 0.0, "{preset}: coin d'écran hors du cadre (arête {k})");
}
}
let cb = g.window_frame_cb(RENDER).expect("calque");
assert!((cb.dst_prev[2] - mt * g.s_dst[3] * RENDER[1] * quad.scale).abs() < 1e-3);
assert_eq!(g.screen_square_top(), 1.0);
}
}
/// Sous un zoom (#179) le cadre grandit avec la boîte : ses marges sont des fractions de
/// `s_dst`, qui porte le grossissement. L'ancre des annotations, elle, ne bouge pas.
#[test]
fn the_frame_zooms_with_the_box() {
let frame = r#","frame":"window-dark""#;
let rest = framed_plan(&framed_scene(frame, "null", 1.0, false));
let zoomed = framed_plan(&framed_scene(frame, "null", 2.0, false));
assert_eq!(rest.window_frame.unwrap().margins, zoomed.window_frame.unwrap().margins);
assert!((zoomed.s_dst[2] / rest.s_dst[2] - 2.0).abs() < 1e-4);
assert_eq!(rest.s_ann, zoomed.s_ann);
let ShadowCaster::Upright { dst, .. } = zoomed.shadow_caster(RENDER) else { panic!() };
assert!(contains(dst, zoomed.s_dst, 1e-6));
}
// ============ Appareils modelés (mode 17) ============
/// Les trois appareils et leur valeur dans le JSON de scène.
const DEVICES: [(&str, crate::scene::SceneFrame); 3] = [
("laptop", crate::scene::SceneFrame::Laptop),
("phone", crate::scene::SceneFrame::Phone),
("monitor", crate::scene::SceneFrame::Monitor),
];
fn device_plan(kind: &str, rotation: &str, zoom: f32) -> FrameGeometry {
framed_plan(&framed_scene(&format!(r#","frame":"{kind}""#), rotation, zoom, false))
}
/// `framed_scene` avec un Roundness choisi : la même scène, un seul nombre changé.
fn framed_plan_round(frame: &str, roundness: f32) -> FrameGeometry {
let scene = Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}},"screenCover":false}},
"effects":{{"padding":0.2,"blur":false,"shadow":0.5,"roundnessFrac":{roundness},"motionBlur":0{frame}}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":1.0,"focusX":0.5,"focusY":0.5,"rotation":null}}],
"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1920,"height":1080,"fps":60}}
}}"##
))
.expect("scène");
framed_plan(&scene)
}
/// Chaque valeur du réglage se relit en son appareil, et une valeur inconnue retombe sur
/// « aucun cadre » — c'est ce qui fait qu'un projet écrit par une version plus récente
/// s'ouvre à plat plutôt que de refuser de s'ouvrir.
#[test]
fn each_device_setting_round_trips() {
for (name, kind) in DEVICES {
let g = device_plan(name, "null", 1.0);
let frame = g.window_frame.expect("un cadre");
assert_eq!(frame.kind, kind, "{name}");
assert!(kind.is_device(), "{name}");
assert_eq!(device_kind_id(kind), 1.0 + DEVICES.iter().position(|d| d.1 == kind).unwrap() as f32);
assert!(g.device_frame_cb(RENDER).is_some(), "{name}: pas de calque");
assert!(g.window_frame_cb(RENDER).is_none(), "{name}: dessiné aussi en mode 14");
}
let unknown = framed_plan(&framed_scene(r#","frame":"holo-visor""#, "null", 1.0, false));
assert!(unknown.window_frame.is_none());
assert!(unknown.device_frame_cb(RENDER).is_none());
}
/// La face écran de l'appareil tombe EXACTEMENT sur le plan du métrage : les quatre coins de
/// l'écran, projetés par la caméra que le shader reconstruit, sont ceux que le mode 8 dessine.
/// C'est toute la condition pour que le métrage reste dans l'ouverture ; un écart s'y lirait
/// comme un jour de fond d'écran entre l'image et la lunette.
#[test]
fn the_device_screen_face_lands_on_the_footage_plane() {
for (name, _) in DEVICES {
for rotation in ["null", r#""iso""#, r#""left""#, ORBIT] {
let g = device_plan(name, rotation, 1.0);
let view = g.device_view(RENDER).expect("caméra");
let center = g.screen_center_px(RENDER);
let quad = g.screen_tilt_in(RENDER);
let mut worst: f32 = 0.0;
for (i, (fx, fy)) in [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)].iter().enumerate() {
let drawn = match &quad {
Some(q) => {
let (x, y) = q.point_px(*fx, *fy);
[center[0] + x, center[1] + y]
}
None => [
(g.s_dst[0] + g.s_dst[2] * fx) * RENDER[0],
(g.s_dst[1] + g.s_dst[3] * fy) * RENDER[1],
],
};
let m = [
(fx - 0.5) * 2.0 * view.half[0],
(fy - 0.5) * 2.0 * view.half[1],
0.0,
];
let cast = view.project(m).expect("coin projeté");
let d = ((cast[0] - drawn[0]).powi(2) + (cast[1] - drawn[1]).powi(2)).sqrt();
worst = worst.max(d);
assert!(d < 0.05, "{name} {rotation} coin {i} : {d} px ({cast:?} / {drawn:?})");
}
println!("{name:<8} {rotation:<16} coins à {worst:.4} px");
}
}
}
/// Le bord de l'image tombe sur le bord de l'ouverture PARTOUT, pas seulement aux coins.
///
/// C'est ce que le passage au warp projectif achète. Mesuré avant : le warp bilinéaire des
/// angles fixes s'écarte de la perspective exacte du mode 17 de 7,7 % de la largeur de
/// l'écran au milieu d'un bord sous `iso` — 113 px à 1080p, une bande de fond d'écran large
/// comme un doigt entre l'image et la lunette. Le recouvrement de la lunette
/// (`DEV_OVERLAP_PX`) ne couvre plus que l'arrondi du rastériseur.
#[test]
fn the_footage_edge_falls_on_the_aperture_edge() {
let mut worst: f32 = 0.0;
for (name, _) in DEVICES {
for rotation in ["null", r#""iso""#, r#""left""#, r#""right""#, ORBIT] {
let g = device_plan(name, rotation, 1.0);
let view = g.device_view(RENDER).expect("caméra");
let center = g.screen_center_px(RENDER);
let quad = g.screen_tilt_in(RENDER);
assert!(
quad.as_ref().is_none_or(|q| q.projective),
"{name} {rotation} : l'écran est encore dessiné au warp bilinéaire"
);
// Le long des quatre bords : c'est là que le warp bilinéaire s'éloignait le plus.
for k in 1..20 {
let s = k as f32 / 20.0;
for (fx, fy) in [(s, 0.0), (s, 1.0), (0.0, s), (1.0, s)] {
let drawn = match &quad {
Some(q) => {
let (x, y) = q.point_px(fx, fy);
[center[0] + x, center[1] + y]
}
None => [
(g.s_dst[0] + g.s_dst[2] * fx) * RENDER[0],
(g.s_dst[1] + g.s_dst[3] * fy) * RENDER[1],
],
};
let m = [(fx - 0.5) * 2.0 * view.half[0], (fy - 0.5) * 2.0 * view.half[1], 0.0];
let cast = view.project(m).expect("bord projeté");
let d = ((cast[0] - drawn[0]).powi(2) + (cast[1] - drawn[1]).powi(2)).sqrt();
worst = worst.max(d);
}
}
}
}
println!("écart maximal image/ouverture : {worst:.4} px, recouvrement {DEV_OVERLAP_PX} px");
assert!(worst < 0.1 * DEV_OVERLAP_PX, "l'écart {worst} px mange le recouvrement {DEV_OVERLAP_PX} px");
}
/// Un cadre d'appareil recale l'image, il ne la RÉEXPOSE pas : sous un angle fixe, le plan
/// passe au warp projectif (`dst_prev.w`) mais la lampe de la caméra reste éteinte
/// (`color` nul). Les deux étaient le même drapeau, et allumer l'un allumait l'autre — un
/// dégradé de ±4 % en travers du métrage que personne n'avait demandé.
#[test]
fn a_device_frame_takes_the_exact_warp_without_the_camera_lamp() {
let flat_cb = |g: &FrameGeometry| {
let quad = g.screen_tilt_in(RENDER).expect("plan incliné");
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
tilted_screen_cb(
&quad,
s_px,
g.screen_center_px(RENDER),
g.cut,
g.focus_plane,
g.s_radius,
g.screen_top_lift_px(RENDER),
false,
RENDER,
g.screen_mask,
None,
)
};
for (name, _) in DEVICES {
let cb = flat_cb(&device_plan(name, r#""iso""#, 1.0));
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.
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]));
let orbit = flat_cb(&framed_plan(&framed_scene("", ORBIT, 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");
}
/// La boîte de dessin du calque contient TOUT le modèle — corps, socle, pied —, et celle de
/// l'OMBRE est cette boîte élargie de la pénombre et décalée : ce qui sort de la première se
/// fait couper, et rien de l'ombre ne peut tomber au-delà de silhouette + décalage + pénombre.
#[test]
fn the_device_box_and_its_shadow_contain_the_model() {
for (name, kind) in DEVICES {
for rotation in ["null", r#""iso""#, r#""left""#, r#""right""#, ORBIT] {
let g = device_plan(name, rotation, 1.0);
let frame = g.window_frame.expect("un cadre");
let view = g.device_view(RENDER).expect("caméra");
let (c, h) = view.body_rect(frame.margins);
let cb = g.device_frame_cb(RENDER).expect("calque");
assert_eq!(cb.mode, 17.0, "{name}");
assert_eq!(cb.dst_prev[3], 0.0, "{name}: l'appareil dessiné en ombre");
let bx = [
cb.dst[0] * RENDER[0],
cb.dst[1] * RENDER[1],
(cb.dst[0] + cb.dst[2]) * RENDER[0],
(cb.dst[1] + cb.dst[3]) * RENDER[1],
];
let thick = device_thickness(kind);
let deck_angle = device_deck_angle(view.half, view.body_margins(frame.margins)[3], thick);
assert_eq!(cb.dst_prev[0], deck_angle, "{name}: angle du socle");
for p in view.model_points(kind, c, h, thick, deck_angle) {
let q = view.project(p).expect("point projeté");
assert!(
q[0] >= bx[0] - 0.01 && q[0] <= bx[2] + 0.01 && q[1] >= bx[1] - 0.01 && q[1] <= bx[3] + 0.01,
"{name} {rotation} : {q:?} hors de la boîte {bx:?}"
);
}
// L'ombre : la même caméra, le rayon du pixel décalé, la boîte élargie.
let (spread, off) = (40.0, g.screen_shadow_offset());
let sh = g.device_shadow_cb(RENDER, spread, off, 0.3).expect("ombre");
assert_eq!((sh.mode, sh.dst_prev[3], sh.color[3]), (17.0, spread, 0.3), "{name}");
assert!(sh.needs_models(), "{name}: l'ombre d'un appareil passe par le shader des modèles");
assert_eq!(&sh.dst_prev[..3], &cb.dst_prev[..3], "{name}: l'ombre n'a pas le même modèle");
let sx = [sh.dst[0] * RENDER[0], sh.dst[1] * RENDER[1]];
let sb = [sx[0], sx[1], sx[0] + sh.quad_px[0], sx[1] + sh.quad_px[1]];
let want = [bx[0] - spread + off[0], bx[1] - spread + off[1], bx[2] + spread + off[0], bx[3] + spread + off[1]];
for k in 0..4 {
assert!((sb[k] - want[k]).abs() <= 1.01, "{name} {rotation}: boîte d'ombre {sb:?} au lieu de {want:?}");
}
// Le pixel `X` de l'ombre lance le rayon du pixel `X − décalage` de l'appareil.
// (`src` = décalage du rayon de l'origine de la boîte : le rayon du pixel absolu
// `X` vaut `X − origine + src`.)
for k in 0..2 {
let ray_sh = sh.src[k] - sx[k];
let ray_dev = cb.src[k] - [bx[0], bx[1]][k];
assert!((ray_sh + off[k] - ray_dev).abs() < 1e-2, "{name} {rotation}: rayon d'ombre décalé");
}
}
}
// La fenêtre garde son ombre de quad.
let w = framed_plan(&framed_scene(r#","frame":"window""#, "null", 1.0, false));
assert!(w.device_shadow_cb(RENDER, 40.0, [0.0, 16.0], 0.3).is_none());
}
/// L'emprise d'un appareil AU REPOS, en unités du cadre autour d'un écran 16:9 dans une sortie
/// 16:9 : gauche, haut, droite, bas, socle et pied compris. `src/lib/frameFootprint.ts` en est
/// le miroir — le layout en bloc écarte la caméra de cette emprise — et son test épingle les
/// MÊMES nombres : un modèle qui change doit changer des deux côtés.
#[test]
fn the_device_footprint_at_rest_is_pinned_for_the_block_layout() {
for (name, want) in [
("laptop", [0.18596f32, 0.0409, 0.18596, 0.09983]),
("phone", [0.0193; 4]),
("monitor", [0.0231, 0.0231, 0.0231, 0.2446]),
] {
let g = device_plan(name, "null", 1.0);
let frame = g.window_frame.expect("un cadre");
let view = g.device_view(RENDER).expect("caméra");
let (c, h) = view.body_rect(frame.margins);
let thick = device_thickness(frame.kind);
let deck = device_deck_angle(view.half, view.body_margins(frame.margins)[3], thick);
let mut b = [f32::MAX, f32::MAX, f32::MIN, f32::MIN];
for p in view.model_points(frame.kind, c, h, thick, deck) {
let q = view.project(p).expect("point projeté");
b = [b[0].min(q[0]), b[1].min(q[1]), b[2].max(q[0]), b[3].max(q[1])];
}
let (o, u) = (g.screen_center_px(RENDER), g.frame_unit_px(RENDER));
let half = [g.s_dst[2] * RENDER[0] * 0.5, g.s_dst[3] * RENDER[1] * 0.5];
let got = [o[0] - b[0] - half[0], o[1] - b[1] - half[1], b[2] - o[0] - half[0], b[3] - o[1] - half[1]]
.map(|v| v / u);
for k in 0..4 {
assert!((got[k] - want[k]).abs() < 1e-4, "{name}: emprise {got:?} au lieu de {want:?}");
}
}
}
/// Le métrage a EXACTEMENT la même boîte et la même coupe sans cadre, sous la fenêtre et sous
/// chacun des appareils : le cadre pousse vers l'extérieur, jamais vers l'intérieur. Ombre,
/// masques, annotations et curseurs, ancrés sur cette boîte, n'ont donc rien à rattraper. (Son
/// RAYON, lui, suit la course de Roundness propre au cadre : `roundness_spans_each_frames_own_range`.)
#[test]
fn the_footage_box_is_the_same_under_every_frame() {
for rotation in ["null", r#""iso""#, ORBIT] {
for zoom in [1.0f32, 2.0] {
let bare = framed_plan(&framed_scene("", rotation, zoom, false));
for frame in ["window", "laptop", "phone", "monitor"] {
let g = framed_plan(&framed_scene(&format!(r#","frame":"{frame}""#), rotation, zoom, false));
let case = format!("{frame} {rotation} z{zoom}");
assert_eq!(g.s_dst.map(f32::to_bits), bare.s_dst.map(f32::to_bits), "{case}: boîte");
assert_eq!(g.s_ann.map(f32::to_bits), bare.s_ann.map(f32::to_bits), "{case}: ancre");
assert_eq!(g.cut, bare.cut, "{case}: coupe");
let (q, b) = (g.screen_tilt_in(RENDER), bare.screen_tilt_in(RENDER));
assert_eq!(q.map(|q| q.corners), b.map(|q| q.corners), "{case}: plan incliné");
}
}
}
}
/// Le rayon que `plan_frame` doit donner au métrage sous le cadre `kind`, pour la scène de
/// `framed_plan_round` (sortie 1080p) : la position du slider sur la course du cadre.
fn expected_radius(g: &FrameGeometry, kind: crate::scene::SceneFrame, roundness: f32) -> f32 {
let t = (roundness * 1080.0 / ROUNDNESS_SLIDER_MAX_PX).clamp(0.0, 1.0);
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
screen_corner_radius_px(t * frame_roundness_cap(kind) * g.frame_unit_px(RENDER), s_px)
}
/// Sous le chrome de fenêtre, le haut du métrage est CARRÉ et à ras de la barre, le bas suit
/// le slider, concentrique au cadre — à Roundness 0 comme au maximum. L'arrondi du haut se
/// fait une fois, par le cadre : le mode 0 rogne le métrage par le contour intérieur du cadre,
/// remonté de `screen_top_lift_px` au-dessus de l'écran.
#[test]
fn the_window_rounds_the_top_once_and_the_bottom_with_the_slider() {
for roundness in [0.0f32, 0.02, 0.25] {
let g = framed_plan_round(r#","frame":"window""#, roundness);
let wf = g.window_frame.expect("un cadre");
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let (bar, line) = (wf.margins[1] * s_px[1], wf.margins[0] * s_px[0]);
assert_eq!(g.screen_square_top(), 1.0, "r{roundness}");
// La remontée : du haut de l'écran au contour intérieur du cadre, sous la barre.
let lift = g.screen_top_lift_px(RENDER);
assert!((lift - (bar - line)).abs() < 1e-3, "r{roundness}: remontée {lift} au lieu de {}", bar - line);
// Le bas : le rayon du métrage, concentrique au cadre (rayon du cadre = métrage + filet).
let want = expected_radius(&g, crate::scene::SceneFrame::Window, roundness);
assert!((g.s_radius - want).abs() < 1e-4, "r{roundness}: {} au lieu de {want}", g.s_radius);
assert!((wf.radius[1] - (g.s_radius + line)).abs() < 1e-3, "r{roundness}: bas pas concentrique");
assert_eq!(wf.radius[0], wf.radius[1], "r{roundness}: le mode 14 n'a qu'un rayon");
// Le rognage du haut du metrage est le contour INTERIEUR du cadre : son contour
// exterieur rentre du filet, rayon compris. Un seul arrondi, deux contours paralleles
// -- a 2 % du filet pres depuis que les coins sont continus (`sd_round_rect`).
let (sw, sh) = (s_px[0] * 0.5, s_px[1] * 0.5);
for (x, y) in [(sw - 0.5, -sh + 0.5), (sw - 3.0, -sh + 2.0), (0.0, -sh + 0.5), (sw * 0.9, -sh * 0.9)] {
let inner = sd_round_rect_test([x, y + lift * 0.5], [sw, sh + lift * 0.5], g.s_radius);
let outer = sd_round_rect_test(
[x, y + (bar - line) * 0.5],
[sw + line, sh + (bar + line) * 0.5],
wf.radius[0],
);
let tol = 0.02 * line + 1e-2;
assert!((inner - (outer + line)).abs() < tol, "r{roundness} ({x},{y}): {inner} vs {outer} + {line}");
}
// Le plafond de la fenêtre tient dans la barre : le coin haut du métrage reste
// entièrement carré, à toutes les positions du slider.
assert!(g.s_radius <= lift, "r{roundness}: le rayon {} sort de la barre ({lift})", g.s_radius);
let d = sd_round_rect_test([sw - 0.5, -sh + 0.5 + lift * 0.5], [sw, sh + lift * 0.5], g.s_radius);
assert!(d < 0.0, "r{roundness}: coin haut rogne");
// Sans fenêtre, aucune remontée.
assert_eq!(framed_plan_round(r#","frame":"phone""#, roundness).screen_top_lift_px(RENDER), 0.0);
}
}
/// Le socle du portable est vu PAR LA TRANCHE depuis la caméra droite : son plan passe juste
/// sous l'œil, et il se projette en un fil sous l'écran — pas en une dalle qui mange l'image.
/// Rigide : sous un angle fixe, le même socle montre son clavier.
#[test]
fn the_laptop_deck_is_seen_edge_on_from_the_flat_camera() {
for (label, render) in [("paysage", [1920.0f32, 1080.0]), ("portrait", [1080.0, 1920.0])] {
let scene = framed_scene(r#","frame":"laptop""#, "null", 1.0, false);
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(&scene, &cfg);
input.render_px = render;
let g = plan_frame(&input);
let frame = g.window_frame.expect("un cadre");
let cb = g.device_frame_cb(render).expect("calque");
let view = g.device_view(render).expect("caméra");
let thick = device_thickness(frame.kind);
let angle = cb.dst_prev[0];
let opening = (std::f32::consts::PI - angle).to_degrees();
assert!((60.0..=135.0).contains(&opening), "{label}: ouverture {opening}°");
// La hauteur projetée du socle, du bas du corps à son point le plus bas à l'écran : le
// profil en COIN réel (épais à la charnière, `DEV_DECK_THICK_FRONT` au bord avant).
let (c, h) = view.body_rect(frame.margins);
let (ca, sa) = (angle.cos(), angle.sin());
let hinge = [c[1] + h[1], -thick * 0.5];
let pts = [
(DEV_DECK_GAP, 0.0),
(DEV_DECK_GAP, -DEV_DECK_THICK),
(DEV_DECK_GAP + DEV_DECK_LEN, 0.0),
(DEV_DECK_GAP + DEV_DECK_LEN, -DEV_DECK_THICK_FRONT),
]
.map(|(qy, qz)| [0.0, hinge[0] + qy * ca - qz * sa, hinge[1] + qy * sa + qz * ca]);
let body_bottom = view.project([0.0, c[1] + h[1], 0.0]).expect("bas")[1];
let lowest = pts.iter().map(|p| view.project(*p).expect("point")[1]).fold(f32::MIN, f32::max);
let drop = lowest - body_bottom;
// La barre se mesure en unités du cadre : la même sous un clip paysage ou portrait.
let u = g.frame_unit_px(render);
println!("{label}: ouverture {opening:.1}°, socle projeté {drop:.1} px ({:.4} u)", drop / u);
assert!(drop < 0.06 * u, "{label}: le socle se projette sur {drop} px, une dalle et non un fil");
assert!(drop > 0.0, "{label}: le socle a disparu");
}
}
/// UNE forme de coin : le métrage et l'ouverture de chaque appareil ont le même rayon, tiré de
/// la même fonction, à Roundness 0 comme au maximum — sinon le coin carré du contenu dépasse
/// de l'arc de la lunette. Et l'ouverture est rentrée d'un recouvrement en PIXELS.
#[test]
fn the_aperture_and_the_footage_share_one_corner() {
for roundness in [0.0f32, 0.02, 0.05, 1.0] {
for (name, kind) in DEVICES {
let g = framed_plan_round(&format!(r#","frame":"{name}""#), roundness);
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let want = expected_radius(&g, kind, roundness);
assert!((g.s_radius - want).abs() < 1e-4, "{name} r{roundness}: {} au lieu de {want}", g.s_radius);
assert!(g.s_radius <= 0.5 * s_px[0].min(s_px[1]) + 1e-3, "{name} r{roundness}: rayon non borné");
let cb = g.device_frame_cb(RENDER).expect("calque");
let view = g.device_view(RENDER).expect("caméra");
let u = g.frame_unit_px(RENDER);
assert!((cb.dst_prev[1] * u - g.s_radius).abs() < 1e-3, "{name} r{roundness}: ouverture ≠ métrage");
assert!((cb.dst_prev[2] * view.unit - DEV_OVERLAP_PX).abs() < 1e-4, "{name}: recouvrement");
// Le corps, concentrique au bord visible de la lunette : l'ouverture, rayon
// `r − recouvrement` sous une bordure élargie d'autant — soit `max(r, recouvrement)`
// plus la bordure moyenne du coin. Au-delà du recouvrement, le rayon de `plan_frame`.
// Portable et moniteur : la coque garde ses rayons (`device_shell_radius`), seule
// l'ouverture suit le slider.
let [bl, bt, _, bb] = cb.src_prev;
let (r, ov) = (cb.dst_prev[1], cb.dst_prev[2]);
let [top, bottom] = device_shell_radius(kind)
.unwrap_or([r.max(ov) + 0.5 * (bl + bt), r.max(ov) + 0.5 * (bl + bb)]);
assert!((cb.radius_px - top).abs() < 1e-5, "{name} r{roundness}: haut");
assert!((cb.color[2] - bottom).abs() < 1e-5, "{name} r{roundness}: bas");
if r >= ov {
let wf = g.window_frame.expect("un cadre");
assert!((cb.radius_px * u - wf.radius[0]).abs() < 1e-2, "{name} r{roundness}: deux rayons du corps");
assert!((cb.color[2] * u - wf.radius[1]).abs() < 1e-2, "{name} r{roundness}: deux rayons du corps");
}
}
}
}
/// Une scène 1080p dont le métrage a le ratio `ar` (largeur / hauteur), contenu dans 80 % de
/// la sortie comme l'app le contient dans la zone paddée : ce que l'utilisateur obtient en
/// changeant de clip sans toucher au projet. Une région de zoom `zoom` sous `rotation`, et le
/// curseur affiché quand `rotation` est la caméra en orbite (elle le suit).
fn ratio_scene(frame: &str, ar: f32, roundness: f32, rotation: &str, zoom: f32) -> Scene {
let (w, h) = if ar >= 16.0 / 9.0 { (0.8, 0.8 * 16.0 / 9.0 / ar) } else { (0.8 * ar * 9.0 / 16.0, 0.8) };
let show = rotation.contains("orbit");
Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":{},"y":{},"width":{w},"height":{h}}},"screenCover":false}},
"effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":{roundness},"motionBlur":0{frame}}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":{zoom},"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],
"cursor":{{"show":{show},"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1920,"height":1080,"fps":60}}
}}"##,
0.5 - w * 0.5,
0.5 - h * 0.5,
))
.expect("scène")
}
fn ratio_plan(frame: &str, ar: f32, roundness: f32) -> FrameGeometry {
framed_plan(&ratio_scene(frame, ar, roundness, "null", 1.0))
}
const CLIP_RATIOS: [(&str, f32); 5] =
[("16:9", 16.0 / 9.0), ("9:16", 9.0 / 16.0), ("1:1", 1.0), ("4:3", 4.0 / 3.0), ("21:9", 21.0 / 9.0)];
/// UN cadre, quel que soit le ratio du clip : dans la même sortie, un clip 16:9, 9:16, 1:1, 4:3
/// ou 21:9 reçoit les mêmes bordures en px sur ses quatre côtés, les mêmes rayons, la même
/// épaisseur et le même socle — seule l'ouverture change de forme. Les bordures étaient en
/// largeurs de la boîte : autour d'un clip portrait, la lunette tombait au tiers.
#[test]
fn a_frame_is_the_same_on_every_clip_ratio() {
for frame in ["window", "laptop", "phone", "monitor"] {
for roundness in [0.0f32, 0.02, 1.0] {
let mut first: Option<([f32; 4], [f32; 2], f32, f32)> = None;
for (label, ar) in CLIP_RATIOS {
let g = ratio_plan(&format!(r#","frame":"{frame}""#), ar, roundness);
let wf = g.window_frame.expect("un cadre");
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
assert!(((s_px[0] / s_px[1]) - ar).abs() < 1e-3, "{label}: le métrage a changé de ratio");
let u = g.frame_unit_px(RENDER);
assert!((u - 864.0).abs() < 0.01, "{frame} {label}: unité {u} au lieu de 864");
let m = [wf.margins[0] * s_px[0], wf.margins[1] * s_px[1], wf.margins[2] * s_px[0], wf.margins[3] * s_px[1]];
// Isotrope : la même bordure à gauche et à droite, en haut qu'à gauche (sauf la
// barre de titre et le bas du portable, voulus).
assert!((m[0] - m[2]).abs() < 1e-3, "{frame} {label}: {m:?}");
if frame != "window" {
assert!((m[0] - m[1]).abs() < 1e-3, "{frame} {label}: {m:?}");
}
if frame == "phone" || frame == "monitor" {
assert!((m[0] - m[3]).abs() < 1e-3, "{frame} {label}: {m:?}");
}
let thick = if wf.kind.is_device() {
let cb = g.device_frame_cb(RENDER).expect("calque");
assert_eq!(cb.fx[3], device_thickness(wf.kind), "{frame} {label}: épaisseur");
cb.fx[3] * u
} else {
0.0
};
let now = (m, wf.radius, g.s_radius, thick);
match first {
None => first = Some(now),
Some((m0, r0, s0, t0)) => {
let case = format!("{frame} r{roundness} {label}");
for k in 0..4 {
assert!((m[k] - m0[k]).abs() < 1e-2, "{case}: bordure {k} {} px au lieu de {} px", m[k], m0[k]);
}
for k in 0..2 {
assert!((wf.radius[k] - r0[k]).abs() < 1e-2, "{case}: rayon du corps {:?} au lieu de {r0:?}", wf.radius);
}
assert!((g.s_radius - s0).abs() < 1e-2, "{case}: rayon du métrage {} au lieu de {s0}", g.s_radius);
assert!((thick - t0).abs() < 1e-2, "{case}: épaisseur {thick} px au lieu de {t0} px");
}
}
}
let (m, r, s, t) = first.expect("un ratio");
println!("{frame:<8} r{roundness:<5} bordures {m:.1?} px, corps {r:.1?} px, métrage {s:.1} px, épaisseur {t:.1} px");
}
}
}
/// LE modèle du rayon des coins, en un test.
///
/// * sans cadre, le slider en px de sortie, comme toujours ;
/// * sous un cadre, sa course va de 0 au plafond du cadre (`frame_roundness_cap`), en unités du
/// cadre : 0, la moitié, le plafond, et rien au-delà ;
/// * fenêtre et téléphone : le corps est CONCENTRIQUE au métrage, à toutes les positions (son
/// rayon est celui du métrage plus la bordure, `concentric_radius`) ;
/// * portable et moniteur : la coque garde ses rayons industriels à toutes les positions
/// (`device_shell_radius`), seule l'ouverture suit le slider ;
/// * les plafonds se voient et restent beaux : la fenêtre sous la hauteur de sa barre, le
/// portable et le moniteur à 0,04 u, le téléphone a de grands coins.
#[test]
fn roundness_spans_each_frames_own_range() {
use crate::scene::SceneFrame as F;
// Sans cadre : rien ne change, 0,03 × 1080 px.
let bare = framed_plan_round("", 0.03);
assert_eq!(bare.s_radius.to_bits(), (0.03f32 * bare.screen_unit_px).to_bits());
// Les trois points de la course : 0, la moitié (32 px de slider), le bout (64 px) et au-delà.
let half = 32.0 / 1080.0;
for (frame, kind) in [("window", F::Window), ("laptop", F::Laptop), ("phone", F::Phone), ("monitor", F::Monitor)] {
let json = format!(r#","frame":"{frame}""#);
let at = |r: f32| framed_plan_round(&json, r);
let (zero, mid, full, beyond) = (at(0.0), at(half), at(64.0 / 1080.0), at(0.2));
let u = full.frame_unit_px(RENDER);
let cap = frame_roundness_cap(kind) * u;
assert_eq!(zero.s_radius, 0.0, "{frame}: arrondi à 0");
assert!((mid.s_radius - 0.5 * cap).abs() < 1e-3, "{frame}: {} au lieu de {}", mid.s_radius, 0.5 * cap);
assert!((full.s_radius - cap).abs() < 1e-3, "{frame}: {} au lieu de {cap}", full.s_radius);
assert_eq!(beyond.s_radius, full.s_radius, "{frame}: le plafond est dépassé");
for g in [&zero, &mid, &full] {
let wf = g.window_frame.expect("un cadre");
if let Some(shell) = device_shell_radius(kind) {
let want = shell.map(|r| r * u);
assert!(
(wf.radius[0] - want[0]).abs() < 1e-3 && (wf.radius[1] - want[1]).abs() < 1e-3,
"{frame}: la coque a bougé avec le slider, {:?} au lieu de {want:?}",
wf.radius
);
continue;
}
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let [l, t, b] = [wf.margins[0] * s_px[0], wf.margins[1] * s_px[1], wf.margins[3] * s_px[1]];
let top = if kind == F::Window { g.s_radius + l } else { g.s_radius + 0.5 * (l + t) };
assert!((wf.radius[0] - top).abs() < 1e-3, "{frame}: haut {:?} au lieu de {top}", wf.radius);
assert!((wf.radius[1] - (g.s_radius + 0.5 * (l + b))).abs() < 1e-3, "{frame}: bas {:?}", wf.radius);
}
let wf = full.window_frame.expect("un cadre");
let s_px = [full.s_dst[2] * RENDER[0], full.s_dst[3] * RENDER[1]];
match kind {
F::Window => {
let bar = wf.margins[1] * s_px[1];
assert!(wf.radius[0] < bar, "fenêtre : rayon {} pour une barre de {bar}", wf.radius[0]);
assert!(cap > 0.03 * u, "fenêtre : course trop courte pour se voir ({cap} px)");
}
F::Laptop => {
let shell = s_px[0] * (1.0 + wf.margins[0] + wf.margins[2]);
let frac = wf.radius[0] / shell;
assert!((frac - 0.025).abs() < 0.001, "portable : coque à {frac} de sa largeur");
}
F::Phone => assert!(cap > 0.07 * u, "téléphone : {cap} px"),
_ => {
assert!(cap > 0.03 * u, "moniteur : course trop courte pour se voir ({cap} px)");
assert!(wf.radius[0] < 0.02 * u, "moniteur : coque {} px", wf.radius[0]);
}
}
println!("{frame:<8} course 0 → {cap:.1} px (u = {u:.0}), corps {:.1?} px au bout", wf.radius);
}
}
/// Une scène 1080p où la caméra en orbite (focus auto) zoome de `zoom` sur un pointeur
/// garé en (x, y) de l'image, sous le cadre `frame`, clip de ratio `ar`.
fn orbit_plan(frame: &str, ar: f32, zoom: f32, x: f32, y: f32) -> FrameGeometry {
let scene = ratio_scene(&format!(r#","frame":"{frame}""#), ar, 0.03, ORBIT, zoom);
let cfg = crate::config::all().pop().expect("au moins une config");
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=150).map(|i| (i as f32 / 30.0, x, y)).collect(),
vec![],
vec![],
)));
let mut input = golden_input(&scene, &cfg);
input.render_px = RENDER;
input.cursor = Some(track);
plan_frame(&input)
}
/// Le socle du portable ne se projette JAMAIS sur l'écran : sous aucun zoom, aucun angle de
/// l'orbite, aucun ratio. Chacun des huit coins du socle tombe au-delà de la droite du bord
/// bas de l'écran, et le socle, convexe, avec eux.
///
/// C'est ce qui cassait : zoomée sur le bas de l'image, la caméra en orbite visait sous le
/// centre, l'œil du relief (reculé sur la droite qui passe par le CENTRE de l'écran) plongeait
/// de 35° sous lui, et la face inférieure du socle couvrait tout le métrage.
#[test]
fn the_laptop_deck_never_covers_the_screen() {
let mut worst = f32::MAX;
for (label, ar) in CLIP_RATIOS {
for zoom in [1.0f32, 1.5, 2.2, 3.5, 5.0] {
for (x, y) in [(0.5f32, 0.98f32), (0.02, 0.98), (0.98, 0.98), (0.5, 0.5), (0.02, 0.02), (0.98, 0.02), (0.5, 0.02)] {
let g = orbit_plan("laptop", ar, zoom, x, y);
let frame = g.window_frame.expect("un cadre");
let cb = g.device_frame_cb(RENDER).expect("calque");
let view = g.device_view(RENDER).expect("caméra");
let eye = view.model_eye();
assert!(eye[1] <= 0.0, "{label} z{zoom} ({x},{y}): œil du relief sous l'écran {eye:?}");
let (c, h) = view.body_rect(frame.margins);
let pts = view.model_points(frame.kind, c, h, cb.fx[3], cb.dst_prev[0]);
// Le bord bas de l'écran à l'image : de son coin bas-gauche à son coin bas-droit.
let [bl, br] = [-1.0f32, 1.0].map(|sx| view.project([sx * view.half[0], view.half[1], 0.0]).expect("coin"));
let (ex, ey) = (br[0] - bl[0], br[1] - bl[1]);
let n = (ex * ex + ey * ey).sqrt();
// Le centre de l'écran est du côté négatif ; tout le socle doit être du côté positif.
let side = |p: [f32; 2]| ((p[0] - bl[0]) * ey - (p[1] - bl[1]) * ex) / n;
let centre = view.project([0.0, 0.0, 0.0]).expect("centre");
let sign = -side(centre).signum();
for p in &pts[8..] {
let q = view.project(*p).expect("socle projeté");
let d = side(q) * sign;
worst = worst.min(d);
assert!(d > 0.0, "{label} z{zoom} ({x},{y}): le socle passe sur l'écran ({d:.1} px)");
}
}
}
}
println!("le socle reste à {worst:.1} px au moins sous le bord bas de l'écran");
}
/// Le plan proche du modèle : au repos, sous les angles fixes et sous l'orbite au zoom 1, il se
/// tient AU-DELÀ du bord avant du socle — rien ne change ; dès que la caméra en orbite avance
/// pour zoomer, il vient au-devant du socle, qui s'efface par son bord avant.
#[test]
fn the_near_plane_spares_the_rest_and_comes_in_with_the_orbit_camera() {
// La plus haute hauteur du socle au-dessus de l'écran, sa tranche avant comprise.
let deck_top = |g: &FrameGeometry| {
let frame = g.window_frame.expect("un cadre");
let cb = g.device_frame_cb(RENDER).expect("calque");
let view = g.device_view(RENDER).expect("caméra");
let (c, h) = view.body_rect(frame.margins);
view.model_points(frame.kind, c, h, cb.fx[3], cb.dst_prev[0])
.iter()
.fold(f32::MIN, |m, p| m.max(p[2]))
};
for (label, ar) in CLIP_RATIOS {
// Au repos et sous les angles fixes : le plan proche, bande de fondu comprise, passe
// au-delà du socle.
for rotation in ["null", r#""iso""#, r#""left""#, r#""right""#] {
for zoom in [1.0f32, 2.2, 5.0] {
let g = framed_plan(&ratio_scene(r#","frame":"laptop""#, ar, 0.02, rotation, zoom));
let view = g.device_view(RENDER).expect("caméra");
let near = view.near_plane() * (1.0 - DEV_NEAR_BAND);
let top = deck_top(&g);
assert!(near > top, "{label} {rotation} z{zoom}: plan proche {near} sous le socle {top}");
}
}
// Sous l'orbite : au zoom 1, rien ne s'efface, où que soit le pointeur ; au zoom 1,5,
// le bord avant du socle est déjà au-delà du plan proche.
for (x, y) in [(0.5f32, 0.5f32), (0.02, 0.98), (0.98, 0.02), (0.5, 0.98)] {
let rest = orbit_plan("laptop", ar, 1.0, x, y);
let near = rest.device_view(RENDER).expect("caméra").near_plane() * (1.0 - DEV_NEAR_BAND);
assert!(near > deck_top(&rest), "{label} orbite ({x},{y}): le socle s'efface au zoom 1");
let zoomed = orbit_plan("laptop", ar, 1.5, x, y);
let near = zoomed.device_view(RENDER).expect("caméra").near_plane();
assert!(near < deck_top(&zoomed), "{label} orbite ({x},{y}): le socle ne s'efface pas au zoom 1,5");
}
}
}
/// Les trois pastilles de la barre de titre restent ENTIÈRES au rayon maximal : leur bloc est
/// repoussé du coin, elles gardent leur taille et leur pas, et le milieu de la barre.
///
/// Le calcul est celui du shader (`x0 = max(dx, rad + dr + bar·0,18)`) : la borne est large,
/// donc il suffit de vérifier que la première pastille tient à l'intérieur du rect arrondi.
#[test]
fn the_title_bar_dots_survive_the_maximum_roundness() {
for roundness in [0.0f32, 0.25] {
let g = framed_plan_round(r#","frame":"window""#, roundness);
let cb = g.window_frame_cb(RENDER).expect("calque");
let (plane, bar, rad) = ([cb.dst_prev[0], cb.dst_prev[1]], cb.dst_prev[2], cb.radius_px);
let (dr, dx) = (bar * 0.214, bar * 0.714);
let x0 = dx.max(rad + dr + bar * 0.18);
for (i, cx) in [x0, x0 + dx, x0 + 2.0 * dx].into_iter().enumerate() {
let c = [cx, bar * 0.5];
// Distance du centre au contour du rect arrondi : elle doit dépasser le rayon
// de la pastille, sinon l'arc la mord.
let p = [c[0] - plane[0] * 0.5, c[1] - plane[1] * 0.5];
let d = sd_round_rect_test(p, [plane[0] * 0.5, plane[1] * 0.5], rad);
assert!(
d < -dr,
"roundness {roundness} : la pastille {i} est mordue (d = {d}, rayon {dr})"
);
assert!(c[0] + dr < plane[0], "roundness {roundness} : pastille {i} hors de la barre");
}
println!("roundness {roundness}: bar {bar:.1}, rayon {rad:.1}, pas {dx:.1}, Ø {:.1}", 2.0 * dr);
}
}
/// Masques de confidentialité et annotations restent sur le CONTENU ENCADRÉ, dans toutes les
/// combinaisons : cadre présent ou non, chacun des cadres, coins arrondis ou vifs, angles
/// fixes, caméra en orbite, avec et sans zoom.
///
/// Ce qu'on vérifie, et pourquoi : l'ancre des annotations (`s_ann`) et le masque
/// (`privacy_mask`) se mesurent tous deux sur la boîte écran, que le cadre ne touche pas. Un
/// masque qui suivrait une autre boîte découvrirait ce qu'il cache dès qu'un cadre est allumé
/// — et c'est exactement ce qu'on voit quand du contenu a l'air coupé au coin.
#[test]
fn masks_and_annotations_stay_on_the_framed_content() {
let plan = |frame: &str, roundness: f32, rotation: &str, zoom: f32| {
let scene = Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}},"screenCover":false}},
"effects":{{"padding":0.2,"blur":false,"shadow":0.5,"roundnessFrac":{roundness},"motionBlur":0{frame}}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":{zoom},"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],
"cursor":{{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1920,"height":1080,"fps":60}}
}}"##
))
.expect("scène");
framed_plan(&scene)
};
// Un rect exprimé DANS la boîte écran : c'est cette position relative qui doit être la
// même avec et sans cadre — sinon le masque a suivi une boîte qui n'est plus dessinée.
let rel = |r: [f32; 4], b: [f32; 4]| {
[(r[0] - b[0]) / b[2], (r[1] - b[1]) / b[3], r[2] / b[2], r[3] / b[3]]
};
for roundness in [0.0f32, 0.05] {
for rotation in ["null", r#""iso""#, r#""right""#, ORBIT] {
for zoom in [1.0f32, 2.0] {
let bare = plan("", roundness, rotation, zoom);
for frame in
[r#","frame":"window""#, r#","frame":"laptop""#, r#","frame":"phone""#, r#","frame":"monitor""#]
{
let g = plan(frame, roundness, rotation, zoom);
let case = format!("{frame}|r{roundness}|{rotation}|z{zoom}");
// L'ancre des annotations est la boîte écran ENCADRÉE, au repos.
if zoom == 1.0 {
assert_eq!(g.s_ann, g.s_dst, "{case}: l'ancre n'est pas la boîte encadrée");
}
for (x, y) in [(0.0, 0.0), (0.62, 0.18), (0.8, 0.9), (0.97, 0.97)] {
let mut a = blur_annotation("");
(a.x, a.y) = (x, y);
// Droit et au repos, le masque couvre ce que l'overlay dessine, dans
// la boîte encadrée. (Sous un zoom ou une inclinaison il suit le
// CONTENU, qui a bougé : `a_privacy_mask_follows_the_zoomed_content`
// et `..._the_tilted_content` en répondent.)
if zoom == 1.0 && rotation == "null" {
let drawn = annotation_dst_in(g.s_ann, a.x, a.y, a.w, a.h);
let m = g.privacy_mask(&a, RENDER).expect("masque");
assert!(
contains(m.dst, drawn, 1e-5),
"{case} @({x},{y}) : masque {:?} ne couvre pas {drawn:?}",
m.dst
);
}
// Et il est au même endroit DU CONTENU que sans cadre.
let b = g.privacy_mask(&a, RENDER).expect("masque");
let n = bare.privacy_mask(&a, RENDER).expect("masque");
if rotation == "null" {
let (p, q) = (rel(b.dst, g.s_dst), rel(n.dst, bare.s_dst));
// Tolérance en PIXELS de l'écran encadré : le masque s'élargit
// d'un pixel fixe (la marge d'antialiasing), qui pèse plus lourd
// en fraction sur une boîte rétrécie par un cadre.
let tol =
[4.0 / (g.s_dst[2] * RENDER[0]), 4.0 / (g.s_dst[3] * RENDER[1])];
for k in 0..4 {
assert!(
(p[k] - q[k]).abs() < tol[k % 2],
"{case} @({x},{y}) : masque à {p:?} du contenu au lieu de {q:?}"
);
}
} else {
// Incliné : le masque est posé sur le PLAN, dont la projection
// n'a plus le même rapport à la boîte droite. Ce qu'on exige
// alors, c'est qu'il tienne dans le plan réellement dessiné —
// s'il avait suivi la boîte d'avant le cadre, il en sortirait.
let quad = g.screen_tilt_in(RENDER).expect("plan incliné");
let c = g.screen_center_px(RENDER);
let pts: Vec<(f32, f32)> =
quad.corners.iter().map(|&(x, y)| (c[0] + x, c[1] + y)).collect();
let (x0, x1) = pts.iter().fold((f32::MAX, f32::MIN), |(a, b), p| (a.min(p.0), b.max(p.0)));
let (y0, y1) = pts.iter().fold((f32::MAX, f32::MIN), |(a, b), p| (a.min(p.1), b.max(p.1)));
// Marge : l'annotation peut dépasser le bord du plan, mais jamais
// de plus que sa propre taille.
let (mw, mh) = (b.dst[2] * RENDER[0], b.dst[3] * RENDER[1]);
let (cx, cy) = (
(b.dst[0] + b.dst[2] * 0.5) * RENDER[0],
(b.dst[1] + b.dst[3] * 0.5) * RENDER[1],
);
assert!(
cx > x0 - mw && cx < x1 + mw && cy > y0 - mh && cy < y1 + mh,
"{case} @({x},{y}) : masque centré en ({cx:.0},{cy:.0}), plan [{x0:.0},{y0:.0}]-[{x1:.0},{y1:.0}]"
);
}
}
}
}
}
}
}
/// `sd_round_rect` du shader, côté CPU : <0 dedans. Coins continus, cf. le commentaire du
/// shader.
fn sd_round_rect_test(p: [f32; 2], half: [f32; 2], r: f32) -> f32 {
let hmin = half[0].min(half[1]);
if r <= 0.0 || hmin <= 0.0 {
let q = [p[0].abs() - half[0], p[1].abs() - half[1]];
let m = [q[0].max(0.0), q[1].max(0.0)];
return (m[0] * m[0] + m[1] * m[1]).sqrt() + q[0].max(q[1]).min(0.0);
}
let u = ((r / hmin - 0.5) / 0.5).clamp(0.0, 1.0);
let n = 3.0 - u * u * (3.0 - 2.0 * u);
let e = (r * 0.292_893_22 / (1.0 - (-1.0 / n).exp2())).min(hmin);
let q = [p[0].abs() - half[0] + e, p[1].abs() - half[1] + e];
let m = [q[0].max(0.0), q[1].max(0.0)];
if m[0] > 0.0 && m[1] > 0.0 {
let len = (m[0].powf(n) + m[1].powf(n)).powf(1.0 / n);
let g = [(m[0] / len).powf(n - 1.0), (m[1] / len).powf(n - 1.0)];
return (len - e) / (g[0] * g[0] + g[1] * g[1]).sqrt();
}
m[0].max(m[1]) + q[0].max(q[1]).min(0.0) - e
}
/// Les coins continus tiennent leurs trois promesses : le coin se creuse à 45° autant qu'un
/// cercle de même rayon (un réglage arrondit autant qu'avant), un carré arrondi à fond reste
/// un cercle, et la distance garde une pente de 1 sur le contour (antialiasing régulier).
#[test]
fn continuous_corners_keep_the_depth_the_circle_and_the_edge_width() {
let half = [300.0f32, 200.0];
for r in [8.0f32, 24.0, 60.0] {
let c = [half[0] - r, half[1] - r];
let on_circle = [c[0] + r * std::f32::consts::FRAC_1_SQRT_2, c[1] + r * std::f32::consts::FRAC_1_SQRT_2];
let d = sd_round_rect_test(on_circle, half, r);
assert!(d.abs() < 0.02, "r {r}: le coin à 45° est à {d} px de celui du cercle");
// Pente de la distance SUR le contour, à plusieurs angles du coin : chaque point est
// trouvé par dichotomie le long d'un rayon partant de l'intérieur du coin, donc sans
// recopier la forme que le test vérifie.
let inside = [half[0] - 2.0 * r, half[1] - 2.0 * r];
for deg in [15.0f32, 45.0, 75.0] {
let dir = [deg.to_radians().cos(), deg.to_radians().sin()];
let (mut lo, mut hi) = (0.0f32, 4.0 * r);
for _ in 0..60 {
let mid = 0.5 * (lo + hi);
let q = [inside[0] + dir[0] * mid, inside[1] + dir[1] * mid];
if sd_round_rect_test(q, half, r) < 0.0 { lo = mid } else { hi = mid }
}
let p = [inside[0] + dir[0] * lo, inside[1] + dir[1] * lo];
assert!(sd_round_rect_test(p, half, r).abs() < 1e-3, "r {r} à {deg}°: point hors du contour");
let h = 0.01f32;
let gx = (sd_round_rect_test([p[0] + h, p[1]], half, r) - sd_round_rect_test([p[0] - h, p[1]], half, r)) / (2.0 * h);
let gy = (sd_round_rect_test([p[0], p[1] + h], half, r) - sd_round_rect_test([p[0], p[1] - h], half, r)) / (2.0 * h);
let slope = (gx * gx + gy * gy).sqrt();
assert!((slope - 1.0).abs() < 0.05, "r {r} à {deg}°: pente {slope} sur le contour");
}
}
// À fond, un carré est un cercle.
let square = [100.0f32, 100.0];
for p in [[0.0f32, 99.0], [70.0, 70.0], [60.0, 90.0], [120.0, 20.0]] {
let circle = (p[0] * p[0] + p[1] * p[1]).sqrt() - 100.0;
let d = sd_round_rect_test(p, square, 100.0);
assert!((d - circle).abs() < 1e-2, "{p:?}: {d} au lieu de {circle}");
}
}
/// La même scène, zoomée ET inclinée par un préset de rotation 3D.
fn tilted_golden_scene() -> Scene {
Scene::from_json(
&zoomed_golden_scene_json().replace(r#""rotation":"none""#, r#""rotation":"iso""#),
)
.expect("tilted golden scene")
}
/// Le rect et la taille de police d'une annotation ne bougent ni sous le zoom ni sous
/// une rotation 3D.
///
/// `the_annotation_anchor_ignores_the_zoom` prouve que `plan_frame` **calcule** la
/// bonne ancre ; il ne dit rien de ce que le backend en fait. Linux, lui, refaisait
/// l'arithmétique contre `s_dst` — donc sous-titres qui grossissent et dérivent, sur
/// la seule plateforme qui n'avait pas été corrigée. Ce test porte sur les fonctions
/// que les backends appellent maintenant, pas sur le champ brut : la méthode côté
/// Linux ET `annotation_dst_in`, par où passent Metal et D3D.
///
/// Ce qu'il ne couvre toujours PAS : le choix du rect au call site de Metal et D3D,
/// qui prennent leur ancre en paramètre. Ce niveau-là n'est vérifiable qu'en rendant
/// des pixels.
///
/// Le flou de confidentialité est l'exception, et elle a ses propres tests plus bas
/// (`a_privacy_mask_*`) : lui DOIT suivre le contenu, sinon ce qu'il cache sort de dessous.
///
/// La rotation compte autant que le zoom : un préset iso/left/right est une propriété
/// de région de zoom, donc l'incliner amenait aussi la boîte — et les sous-titres
/// partaient avec elle, sans pour autant suivre le plan incliné. Les deux symptômes,
/// une seule cause.
#[test]
fn the_annotation_rect_and_font_ignore_zoom_and_rotation() {
let cfg = crate::config::all().pop().expect("au moins une config");
let rh = 658.0;
// Un rect d'annotation quelconque, décentré : au centre, un rect qui suivrait le
// zoom garderait le même centre et la moitié de l'erreur passerait inaperçue.
let (x, y, w, h) = (0.04, 0.78, 0.92, 0.22);
let plain = plan_frame(&golden_input(&golden_scene(), &cfg));
let zoomed = plan_frame(&golden_input(&zoomed_golden_scene(), &cfg));
let tilted = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));
// Le garde-fou : sans lui, un `plan_frame` qui cesserait d'appliquer le zoom
// rendrait les assertions suivantes vraies pour la mauvaise raison.
assert_ne!(
plain.s_dst, zoomed.s_dst,
"le zoom doit agir sur la boîte écran — sinon ce test ne prouve rien"
);
assert!(
!crate::regions::is_identity_rotation(tilted.zoom_rotation),
"le préset iso doit produire une rotation — sinon ce test ne prouve rien"
);
let expected = plain.annotation_dst(x, y, w, h);
for (name, g) in [("zoom", &zoomed), ("rotation 3D", &tilted)] {
let got = g.annotation_dst(x, y, w, h);
assert_eq!(
got, expected,
"le rect de l'annotation a suivi le {name} : {got:?} au lieu de {expected:?}"
);
assert_eq!(
g.annotation_anchor_h_px(rh),
plain.annotation_anchor_h_px(rh),
"la taille de police a suivi le {name}"
);
// Metal et D3D n'appellent pas la méthode : ils passent leur rect d'ancrage à
// `annotation_dst_in`. Les deux chemins doivent rendre le MÊME rect, sinon le
// « corrigé sur une plateforme seulement » recommence par le bas.
assert_eq!(
annotation_dst_in(g.s_ann, x, y, w, h),
got,
"le chemin des backends Metal/D3D diverge de la méthode sous le {name}"
);
// Et le garde-fou qui donne un sens aux deux précédents : nourrie avec `s_dst`,
// la même fonction rend un rect DIFFÉRENT. Sans ça, un `annotation_dst_in`
// devenu constant satisferait tout ce qui précède.
assert_ne!(
annotation_dst_in(g.s_dst, x, y, w, h),
expected,
"sous le {name}, ancrer sur `s_dst` devrait déplacer le rect — \
si les deux coïncident, ce test ne prouve plus rien"
);
}
}
/// Le focus de profondeur (`z_focus`, mode 8) passe par la coupe réellement dessinée.
///
/// Crop décalé ET focus collé au bord droit sous un zoom x2 : la coupe zoomée bute sur le
/// bord, son centre tombe à 0.75 du crop alors que le point visé est à 0.95. C'est ce point-là
/// que le plan doit tenir net, pas le centre, et encore moins (0.5, 0.5).
#[test]
fn the_depth_focus_goes_through_the_drawn_cut() {
let cfg = crate::config::all().pop().expect("au moins une config");
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"iso""#)
.replace(r#""focusX":0.5"#, r#""focusX":0.95"#)
.replace(
r#""cropByClip":[{"x":0,"y":0,"#,
r#""cropByClip":[{"x":0.3,"y":0.1,"#,
);
let scene = Scene::from_json(&json).expect("scène inclinée recadrée");
let input = golden_input(&scene, &cfg);
let g = plan_frame(&input);
assert!(!crate::regions::is_identity_rotation(g.zoom_rotation), "garde : iso doit incliner");
assert!((g.focus_plane[0] - 0.95).abs() < 1e-4, "focus x {:?}", g.focus_plane);
assert!((g.focus_plane[1] - 0.3).abs() < 1e-4, "focus y {:?}", g.focus_plane);
// Garde : la coupe zoomée est bien clampée, son centre n'est PAS le focus.
let crop = scene.crop_by_clip[0];
let cut_ref = screen_source_rect(input.u_max, input.v_max, crop, 2.0, [0.95, 0.3]);
let centre_local = ((cut_ref[0] + cut_ref[2]) * 0.5 - g.cut[0]) / (g.cut[2] - g.cut[0]);
assert!((centre_local - 0.75).abs() < 1e-3, "garde : centre de coupe {centre_local}");
// Et `z_focus` est la profondeur de CE point, pas celle du centre du plan.
let render = input.render_px;
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("iso incline");
let mb = quad.depth_mb(s_px, g.focus_plane, g.depth_of_field_on(false));
assert!(mb[3] > 0.0, "réglage absent de la scène : la profondeur de champ est allumée");
assert!(!g.depth_of_field_on(true) || DOF_ON_CPU_BACKEND);
let want = (0.95 - 0.5) * mb[0] + (0.3 - 0.5) * mb[1];
assert!((mb[2] - want).abs() < 1e-3 && mb[2].abs() > 1.0, "z_focus {} au lieu de {want}", mb[2]);
}
/// Un cover rogne la coupe dans le crop : le focus s'y reporte, et retombe sur le bord du
/// plan quand le cover l'a coupé.
#[test]
fn the_depth_focus_follows_a_cover_cut_and_clamps_to_it() {
let cut = [0.25, 0.0, 0.75, 1.0];
for (focus, want) in [([0.6, 0.5], [0.7, 0.5]), ([0.95, 0.5], [1.0, 0.5]), ([f32::NAN, 0.0], [0.5, 0.0])] {
let got = focus_in_cut(1.0, 1.0, None, focus, cut);
assert!((got[0] - want[0]).abs() < 1e-5 && (got[1] - want[1]).abs() < 1e-5, "{got:?} != {want:?}");
}
}
fn blur_annotation(json_extra: &str) -> crate::scene::SceneAnnotation {
serde_json::from_str(&format!(
r#"{{"id":"secret","startSec":0,"endSec":10,"kind":"blur",
"x":0.62,"y":0.18,"w":0.2,"h":0.1{json_extra},
"blur":{{"style":"mosaic","shape":"rectangle","color":"white","intensity":12,"blockSize":12}}}}"#
))
.expect("annotation flou valide")
}
fn inside(r: [f32; 4], x: f32, y: f32) -> bool {
x >= r[0] && x <= r[0] + r[2] && y >= r[1] && y <= r[1] + r[3]
}
/// Au repos, le masque est le rect de l'annotation, marge d'un pixel comprise.
#[test]
fn a_privacy_mask_at_rest_is_the_annotation_rect_plus_a_pixel() {
let cfg = crate::config::all().pop().expect("au moins une config");
let g = plan_frame(&golden_input(&golden_scene(), &cfg));
let a = blur_annotation("");
let render = [1170.0, 658.0];
let m = g.privacy_mask(&a, render).expect("masque");
assert!(m.oval_ok);
let r = g.annotation_dst(a.x, a.y, a.w, a.h);
let (px, py) = (1.0 / render[0], 1.0 / render[1]);
let want = [r[0] - px, r[1] - py, r[2] + 2.0 * px, r[3] + 2.0 * py];
for k in 0..4 {
assert!((m.dst[k] - want[k]).abs() < 1e-6, "{:?} au lieu de {want:?}", m.dst);
}
assert_eq!(m.warp, None);
assert_eq!(m.strength, 1.0);
}
/// Sous un zoom, le masque couvre le MÊME contenu qu'au repos.
///
/// La vérification passe par ce que le mode 0 dessine vraiment : l'UV `cut + c * taille`
/// au point `s_dst + c * taille`. On relit l'UV que le masque couvrait au repos, puis on
/// cherche où ce contenu tombe sous le zoom, sans passer par `privacy_mask`.
#[test]
fn a_privacy_mask_follows_the_zoomed_content() {
let cfg = crate::config::all().pop().expect("au moins une config");
let plain = plan_frame(&golden_input(&golden_scene(), &cfg));
let zoomed = plan_frame(&golden_input(&zoomed_golden_scene(), &cfg));
assert_ne!(plain.s_dst, zoomed.s_dst, "garde : le zoom doit agir");
let a = blur_annotation("");
let render = [1170.0, 658.0];
let m = zoomed.privacy_mask(&a, render).expect("masque");
assert_eq!(m.warp, None);
let uv_at_rest = |fx: f32, fy: f32| {
let c = plain.cut;
(c[0] + fx * (c[2] - c[0]), c[1] + fy * (c[3] - c[1]))
};
let drawn_under_zoom = |(u, v): (f32, f32)| {
let (c, d) = (zoomed.cut, zoomed.s_dst);
(d[0] + (u - c[0]) / (c[2] - c[0]) * d[2], d[1] + (v - c[1]) / (c[3] - c[1]) * d[3])
};
let corners = [(a.x, a.y), (a.x + a.w, a.y), (a.x + a.w, a.y + a.h), (a.x, a.y + a.h)];
for (fx, fy) in corners {
let (x, y) = drawn_under_zoom(uv_at_rest(fx, fy));
assert!(
inside(m.dst, x, y),
"le coin ({fx}, {fy}) du contenu tombe en ({x}, {y}), hors de {:?}",
m.dst
);
}
// Serré : la marge grossit avec le contenu, un pixel du repos devient deux sous un x2.
let (x0, y0) = drawn_under_zoom(uv_at_rest(a.x, a.y));
assert!((m.dst[0] - (x0 - 2.0 / render[0])).abs() < 1e-5, "{:?}", m.dst);
assert!((m.dst[1] - (y0 - 2.0 / render[1])).abs() < 1e-5, "{:?}", m.dst);
// L'ancien placement ratait le contenu : c'est la fuite que ce test garde fermée.
let old = zoomed.annotation_dst(a.x, a.y, a.w, a.h);
let (cx, cy) = drawn_under_zoom(uv_at_rest(a.x + a.w * 0.5, a.y + a.h * 0.5));
assert!(!inside(old, cx, cy), "garde : sous ce zoom l'ancien rect devrait rater le contenu");
// Le grain grandit avec le contenu : un zoom x2 double le pas de mosaïque.
assert!((m.strength - 2.0).abs() < 1e-3, "force {} au lieu de 2", m.strength);
}
/// Le bloc « côte à côte » tel que `computeCompositeLayout` le résout : l'écran dans un slot
/// au ratio de la capture, la caméra à côté, `screenCover`. Zoom `zoom` sous `rotation`, focus
/// décentré (0.3, 0.6). `cover: false` rend le même bloc sans slot, comme les autres layouts.
fn slot_scene(rotation: &str, zoom: f32, cover: bool) -> Scene {
slot_scene_with(rotation, zoom, cover, "")
}
/// `slot_scene`, `effects_extra` inséré tel quel dans `effects` (un cadre, par exemple).
fn slot_scene_with(rotation: &str, zoom: f32, cover: bool, effects_extra: &str) -> Scene {
Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"/w.mp4","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"dual-frame","webcamSize":0.25,"webcamShape":"rectangle","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.25,"width":0.55,"height":0.55}},
"webcamRect":{{"x":0.666,"y":0.25,"width":0.234,"height":0.55}},
"screenRadiusFrac":0.04,"webcamRadiusFrac":0.04,"screenCover":{cover}}},
"effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":0.03,"motionBlur":0{effects_extra}}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":{zoom},"focusX":0.3,"focusY":0.6,"rotation":{rotation}}}],
"cursor":{{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1920,"height":1080,"fps":60}}
}}"##
))
.expect("scène côte à côte")
}
/// Le `screenRect` de `slot_scene`.
const SLOT: [f32; 4] = [0.1, 0.25, 0.55, 0.55];
/// Une piste où le pointeur reste garé en (x, y).
fn parked_track(x: f32, y: f32) -> &'static crate::cursor::CursorTrack {
Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=150).map(|i| (i as f32 / 30.0, x, y)).collect(),
vec![],
vec![],
)))
}
/// Un clip 16:9 dans une sortie 9:16 remplie (`screenCover` + `screenFollow`) : la boîte écran
/// est la zone paddée entière, `follow` décide si la fenêtre suit le pointeur.
fn fill_plan(follow: bool, pointer: Option<(f32, f32)>) -> FrameGeometry {
fill_plan_with(follow, pointer, "[]")
}
/// `fill_plan`, avec ces `zoomRegions`.
fn fill_plan_with(follow: bool, pointer: Option<(f32, f32)>, zoom_regions: &str) -> FrameGeometry {
fill_plan_track(follow, pointer.map(|(x, y)| parked_track(x, y)), zoom_regions)
}
/// `fill_plan_with`, sur cette piste curseur.
fn fill_plan_track(
follow: bool,
track: Option<&'static crate::cursor::CursorTrack>,
zoom_regions: &str,
) -> FrameGeometry {
let scene = Scene::from_json(&format!(
r##"{{
"clips":[{{"screenPath":"/s.mp4","webcamPath":"","sourceStartSec":0,"sourceEndSec":10,"webcamOffsetSec":0,"hasAudio":false}}],
"layout":{{"preset":"no-webcam","webcamSize":1,"webcamShape":"rounded","webcamMirror":false,"webcamPosition":null,
"webcamReactiveZoom":false,"screenRect":{{"x":0.1,"y":0.1,"width":0.8,"height":0.8}},
"screenCover":true,"screenFollow":{follow}}},
"effects":{{"padding":0.5,"blur":false,"shadow":0.5,"roundnessFrac":0.02,"motionBlur":0}},
"background":{{"kind":"color","color":"#1e1e2e"}},
"zoomRegions":{zoom_regions},
"cursor":{{"show":true,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":1,"clipToBounds":false,"theme":"default"}},
"cropByClip":[null],
"output":{{"width":1080,"height":1920,"fps":60}}
}}"##
))
.expect("scène remplie");
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(&scene, &cfg);
input.render_px = [1080.0, 1920.0];
input.cursor = track;
plan_frame(&input)
}
/// Le remplissage du format : un clip 16:9 remplit une sortie 9:16, et la fenêtre 9:16 qu'il
/// y montre suit le pointeur lissé, bornée à l'enregistrement.
///
/// * la fenêtre a le ratio de la boîte, toute la hauteur de l'enregistrement ;
/// * elle se centre sur le pointeur, et bute sur le bord quand il s'en approche ;
/// * sans `screenFollow`, ou sans piste, elle reste centrée ;
/// * la coupe DESSINÉE est l'enregistrement entier, et sa boîte couvre le slot : la fenêtre
/// peut bouger sans jamais laisser de trou.
#[test]
fn a_filled_format_follows_the_pointer_inside_the_recording() {
let (u, v) = (1.0f32, 1080.0f32 / 1088.0);
// Ce que le slot montre de l'enregistrement, en 0..1 : le slot reporté par s_dst → cut.
let seen = |g: &FrameGeometry| -> [f32; 4] {
let (s, d, c) = (g.s_ann, g.s_dst, g.cut);
let x = |f: f32| (c[0] + (f - d[0]) / d[2] * (c[2] - c[0])) / u;
let y = |f: f32| (c[1] + (f - d[1]) / d[3] * (c[3] - c[1])) / v;
[x(s[0]), y(s[1]), x(s[0] + s[2]), y(s[1] + s[3])]
};
let at = fill_plan(true, Some((0.7, 0.5)));
let w = seen(&at);
assert!((0.5 * (w[0] + w[2]) - 0.7).abs() < 1e-3, "fenêtre {w:?}, pointeur en 0.7");
assert!(w[1].abs() < 1e-3 && (w[3] - 1.0).abs() < 1e-3, "toute la hauteur : {w:?}");
let shown_ar = ((w[2] - w[0]) * 1920.0) / ((w[3] - w[1]) * 1080.0);
assert!((shown_ar - 864.0 / 1536.0).abs() < 1e-3, "ratio montré {shown_ar}");
assert!(contains(at.s_dst, at.s_ann, 1e-5), "la boîte dessinée ne couvre pas le slot");
// Au bord : la fenêtre bute sur l'enregistrement.
let edge = seen(&fill_plan(true, Some((0.98, 0.5))));
assert!((edge[2] - 1.0).abs() < 1e-3, "fenêtre {edge:?}");
// Sans suivi, ou sans piste : centrée.
for g in [fill_plan(false, Some((0.7, 0.5))), fill_plan(true, None)] {
let w = seen(&g);
assert!((0.5 * (w[0] + w[2]) - 0.5).abs() < 1e-3, "fenêtre centrée attendue, {w:?}");
}
}
/// Le remplissage sous un plan incliné, angle fixe ou caméra en orbite : c'est la CARTE qui
/// penche, entière, ses quatre coins arrondis. Son slot n'est pas un conteneur qu'on voit,
/// comme celui d'un bloc : y rogner le plan de l'enregistrement entier coupait des coins à plat
/// (v2.0.0 à v2.1.0).
///
/// * aucun masque ne rogne le plan, et sa boîte est le slot ;
/// * la carte montre ce qu'un zoom à plat y montre : la même fenêtre zoomée ;
/// * le plan tient dans la sortie, centré sur le slot ;
/// * à plat, rien ne change : le slot masque toujours la boîte zoomée.
#[test]
fn a_tilted_zoom_tilts_the_whole_filled_card() {
let render = [1080.0f32, 1920.0];
let zoom = |rotation: &str| {
format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.3,"focusY":0.6,"rotation":{rotation}}}]"#)
};
let pointer = Some((0.85, 0.8));
// La fenêtre que la carte montre, en UV : le slot reporté par s_dst → cut.
let seen = |g: &FrameGeometry| -> [f32; 4] {
let (s, d, c) = (g.s_ann, g.s_dst, g.cut);
let x = |f: f32| c[0] + (f - d[0]) / d[2] * (c[2] - c[0]);
let y = |f: f32| c[1] + (f - d[1]) / d[3] * (c[3] - c[1]);
[x(s[0]), y(s[1]), x(s[0] + s[2]), y(s[1] + s[3])]
};
for (rotation, flat_rotation) in [
(r#""iso""#, "null"),
(r#""right""#, "null"),
(ORBIT, r#"null,"focusMode":"auto""#),
] {
let flat = fill_plan_with(true, pointer, &zoom(flat_rotation));
assert!(!flat.tilted(), "{rotation} : garde, le zoom à plat est droit");
assert!(flat.screen_mask.is_some(), "{rotation} : à plat, le slot masque la boîte zoomée");
assert!(!contains(flat.s_ann, flat.s_dst, 1e-3), "{rotation} : garde, la boîte à plat déborde");
let g = fill_plan_with(true, pointer, &zoom(rotation));
assert!(g.tilted(), "{rotation} : garde, l'écran doit pencher");
assert_eq!(g.screen_mask, None, "{rotation} : un rect droit rogne la carte inclinée");
for k in 0..4 {
assert!((g.s_dst[k] - g.s_ann[k]).abs() < 1e-5, "{rotation} : boîte {:?}, slot {:?}", g.s_dst, g.s_ann);
}
let (w, wf) = (seen(&g), seen(&flat));
for k in 0..4 {
assert!((w[k] - wf[k]).abs() < 1e-4, "{rotation} : fenêtre {w:?}, à plat {wf:?}");
}
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("incliné");
let c = g.screen_center_px(render);
let slot_c = [(g.s_ann[0] + g.s_ann[2] * 0.5) * render[0], (g.s_ann[1] + g.s_ann[3] * 0.5) * render[1]];
let mut mean = [0.0f32; 2];
for &(x, y) in &quad.corners {
let (x, y) = (c[0] + x, c[1] + y);
assert!((0.0..=render[0]).contains(&x) && (0.0..=render[1]).contains(&y), "{rotation} : coin ({x}, {y}) hors de la sortie");
mean = [mean[0] + x * 0.25, mean[1] + y * 0.25];
}
let off = (mean[0] - slot_c[0]).hypot(mean[1] - slot_c[1]);
assert!(off < 0.1 * s_px[0].min(s_px[1]), "{rotation} : carte à {off} px du slot");
let cb = tilted_screen_cb(&quad, s_px, c, g.cut, g.focus_plane, g.s_radius, 0.0, false, render, g.screen_mask, None);
assert_eq!(cb.color[3], 0.0, "{rotation} : aucun slot ne rogne le plan");
assert!(cb.radius_px > 1.0, "{rotation} : coins arrondis attendus, rayon {}", cb.radius_px);
}
}
/// Sous le remplissage incliné, la carte ne montre que la fenêtre zoomée : un flou posé sur
/// le métrage (ses fractions sont celles de l'enregistrement entier) couvre toujours le
/// contenu qu'il cache, là où le curseur, passé par la coupe, le voit. Le gimbal de l'éditeur
/// (`footage_quad`) pose ce point au même endroit, et l'aspect est celui de l'enregistrement.
#[test]
fn a_privacy_mask_covers_its_content_on_a_tilted_filled_card() {
let render = [1080.0f32, 1920.0];
let p = (0.85f32, 0.8f32);
let uv_max = [1.0, 1080.0 / 1088.0];
for rotation in [r#""iso""#, ORBIT] {
let zoom = format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.85,"focusY":0.8,"rotation":{rotation}}}]"#);
let g = fill_plan_with(true, Some(p), &zoom);
assert!(g.fill_tilt, "{rotation} : garde, remplissage incliné");
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("incliné");
let c = g.screen_center_px(render);
// Où le contenu en `p` est dessiné, par la coupe comme le curseur.
let plane = cursor_plane_point(g.cut, uv_max, p).expect("garde : le point est sur la carte");
let (sx, sy) = quad.point_px(plane[0], plane[1]);
let seen = [c[0] + sx, c[1] + sy];
let mut a = blur_annotation("");
(a.w, a.h) = (0.04, 0.04);
(a.x, a.y) = (p.0 - 0.02, p.1 - 0.02);
let m = g.privacy_mask(&a, render).expect("masque");
let pts = m.warp.expect("incliné").map(|[x, y]| [m.dst[0] * render[0] + x, m.dst[1] * render[1] + y]);
let cross = |a: [f32; 2], b: [f32; 2], q: [f32; 2]| (b[0] - a[0]) * (q[1] - a[1]) - (b[1] - a[1]) * (q[0] - a[0]);
let sides: Vec<f32> = (0..4).map(|i| cross(pts[i], pts[(i + 1) % 4], seen)).collect();
assert!(
sides.iter().all(|&s| s >= 0.0) || sides.iter().all(|&s| s <= 0.0),
"{rotation} : le masque {pts:?} rate le contenu, dessiné en {seen:?}"
);
// Le grain grandit avec le contenu, comme à plat.
assert!(m.strength > 1.5, "{rotation} : force {}", m.strength);
// Le gimbal : le métrage entier, que la carte ne montre qu'en partie.
let f = g.footage_quad(render);
assert!(f.corners.iter().any(|q| q[0] < 0.0 || q[0] > 1.0 || q[1] < 0.0 || q[1] > 1.0), "{rotation} : gimbal réduit à la carte, {:?}", f.corners);
let ar = g.footage_aspect(render);
assert!((ar - 1920.0 / 1080.0).abs() < 1e-2, "{rotation} : aspect {ar}");
}
}
/// Le flou de mouvement de la carte inclinée du remplissage reste par pixel : la carte est
/// fixe dans son slot, seul le métrage bouge dedans. Le flou rigide (mode 18) l'étalait le
/// long du chemin du contenu, bords et coins compris.
#[test]
fn a_tilted_filled_card_keeps_a_per_pixel_motion_blur() {
let moving: &'static crate::cursor::CursorTrack = Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=150).map(|i| (i as f32 / 30.0, 0.2 + 0.6 * i as f32 / 150.0, 0.5)).collect(),
vec![],
vec![],
)));
let render = [1080.0f32, 1920.0];
let zoom = format!(r#"[{{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":{ORBIT}}}]"#);
// Le pointeur en mouvement : la fenêtre suivie glisse d'une frame à l'autre.
let mut g = fill_plan_track(true, Some(moving), &zoom);
(g.mb_taps, g.mb_amount) = (8.0, 0.5);
assert!(g.fill_tilt, "garde : remplissage incliné");
assert_ne!(g.s_dst_prev, g.s_dst, "garde : le métrage bouge dans la carte");
assert!(!g.screen_trail(render), "flou rigide sur une carte fixe");
assert!(g.tilt_pixel_trail(render).is_some(), "le flou par pixel suit le métrage");
}
/// `slot_scene` à 1,5 s (zoom tenu), pointeur garé en `pointer` (la caméra en orbite le suit).
fn slot_plan(scene: &Scene, pointer: Option<(f32, f32)>) -> FrameGeometry {
let cfg = crate::config::all().pop().expect("au moins une config");
let mut input = golden_input(scene, &cfg);
input.render_px = RENDER;
input.cursor = pointer.map(|(x, y)| parked_track(x, y));
plan_frame(&input)
}
/// Côte à côte et haut/bas : le slot MASQUE l'écran (overflow hidden). L'écran garde la
/// géométrie de tous les layouts — sa boîte zoomée déborde — et seul son dessin est rogné au
/// slot, coins du slot compris, sans déplacer un pixel. L'ombre est celle du slot.
#[test]
fn a_block_layout_masks_its_screen_with_the_slot() {
let rest = slot_plan(&slot_scene("null", 1.0, true), None);
let g = slot_plan(&slot_scene("null", 2.0, true), None);
let free = slot_plan(&slot_scene("null", 2.0, false), None);
assert_eq!(free.screen_mask, None, "sans slot, pas de masque");
let mask = g.screen_mask.expect("un layout en bloc masque son écran");
assert_eq!(mask.rect, SLOT);
assert!((mask.radius_px - rest.s_radius).abs() < 1e-3, "coins {} au lieu de {}", mask.radius_px, rest.s_radius);
// La géométrie de partout : la boîte zoomée est celle du même bloc sans slot, et déborde.
for k in 0..4 {
assert!((g.s_dst[k] - free.s_dst[k]).abs() < 1e-3, "{:?} au lieu de {:?}", g.s_dst, free.s_dst);
}
assert!(!contains(SLOT, g.s_dst, 1e-3), "garde : la boîte zoomée doit déborder, {:?}", g.s_dst);
// Le dessin, lui, est rogné au slot, avec ses coins.
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let (dst, src, quad_px, radius) = g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, RENDER);
for k in 0..4 {
assert!((dst[k] - SLOT[k]).abs() < 1e-6, "dessin {dst:?} au lieu du slot");
}
assert_eq!(quad_px, [dst[2] * RENDER[0], dst[3] * RENDER[1]]);
assert_eq!(radius, mask.radius_px);
// Rogner ne déplace aucun pixel : même mapping image→écran, coins du slot compris.
let uv = |d: [f32; 4], s: [f32; 4], x: f32, y: f32| {
[s[0] + (x - d[0]) / d[2] * (s[2] - s[0]), s[1] + (y - d[1]) / d[3] * (s[3] - s[1])]
};
for (x, y) in [(0.1, 0.25), (0.65, 0.8), (0.3, 0.5)] {
let (a, b) = (uv(dst, src, x, y), uv(g.s_dst, g.cut, x, y));
assert!((a[0] - b[0]).abs() < 1e-5 && (a[1] - b[1]).abs() < 1e-5, "({x}, {y}) : {a:?} au lieu de {b:?}");
}
let size_px = [SLOT[2] * RENDER[0], SLOT[3] * RENDER[1]];
assert_eq!(g.shadow_caster(RENDER), ShadowCaster::Upright { dst: SLOT, size_px, radius: mask.radius_px });
// Sans masque, les valeurs du backend repartent telles quelles, à l'octet.
let free_px = [free.s_dst[2] * RENDER[0], free.s_dst[3] * RENDER[1]];
assert_eq!(
free.mask_flat_screen(free.s_dst, free.cut, free_px, free.s_radius, RENDER),
(free.s_dst, free.cut, free_px, free.s_radius)
);
}
/// Incliné, angle fixe ou caméra en orbite : c'est le MÉTRAGE qui penche, avec le plan de tous
/// les layouts, et le slot le rogne — le conteneur, lui, ne penche jamais. Le plan est dessiné
/// dans le rect du slot (coins arrondis par le shader, `color.w`), et son ombre est celle de
/// ce qu'on voit, le plan rogné par le slot.
#[test]
fn a_tilted_zoom_tilts_the_footage_inside_its_slot() {
for rotation in [r#""iso""#, r#""right""#, ORBIT] {
let g = slot_plan(&slot_scene(rotation, 2.0, true), Some((0.8, 0.3)));
let free = slot_plan(&slot_scene(rotation, 2.0, false), Some((0.8, 0.3)));
let mask = g.screen_mask.expect("masque");
assert!(g.tilted(), "{rotation} : garde, l'écran doit pencher");
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let quad = g.screen_tilt(s_px).expect("incliné");
let free_px = [free.s_dst[2] * RENDER[0], free.s_dst[3] * RENDER[1]];
for (a, b) in quad.corners.iter().zip(free.screen_tilt(free_px).expect("incliné").corners.iter()) {
assert!((a.0 - b.0).abs() < 0.5 && (a.1 - b.1).abs() < 0.5, "{rotation} : {a:?} au lieu de {b:?}");
}
let (hx, hy) = quad.half_extents_px();
let slot_px = [SLOT[2] * RENDER[0], SLOT[3] * RENDER[1]];
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, 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);
assert_eq!(bare.color[3], 0.0, "sans masque, rien ne change");
// Les coins reportés dans le repère du slot : le même plan, au centième de pixel.
let corners = |c: &LayerCB| {
[[c.fx[0], c.fx[1]], [c.fx[2], c.fx[3]], [c.src_prev[0], c.src_prev[1]], [c.src_prev[2], c.src_prev[3]]]
.map(|[x, y]| [c.dst[0] * RENDER[0] + x, c.dst[1] * RENDER[1] + y])
};
for (a, b) in corners(&cb).iter().zip(corners(&bare).iter()) {
assert!((a[0] - b[0]).abs() < 1e-2 && (a[1] - b[1]).abs() < 1e-2, "{rotation} : coin {a:?} au lieu de {b:?}");
}
match g.shadow_caster(RENDER) {
ShadowCaster::Tilted { mask: m, .. } => assert_eq!(m, Some(mask), "{rotation}"),
other => panic!("{rotation} : {other:?}"),
}
}
// Le slot passé à l'ombre, en px locaux à sa boîte : décalé de l'origine de celle-ci.
let mask = ScreenMask { rect: SLOT, radius_px: 12.0, square_top: false };
let (rect, r) = shadow_mask_fields(Some(mask), [100.0, 50.0], RENDER);
let want = [0.1 * 1920.0 - 100.0, 0.25 * 1080.0 - 50.0, 0.65 * 1920.0 - 100.0, 0.8 * 1080.0 - 50.0];
for k in 0..4 {
assert!((rect[k] - want[k]).abs() < 1e-3, "{rect:?} au lieu de {want:?}");
}
assert_eq!(r, 12.0);
assert_eq!(shadow_mask_fields(None, [100.0, 50.0], RENDER), ([0.0; 4], 0.0));
}
/// Un calque au bit près : `LayerCB` n'a pas de `PartialEq`, et c'est l'octet qu'on compare.
fn cb_bits(cb: Option<LayerCB>) -> Option<Vec<u32>> {
cb.map(|c| {
[c.dst, c.src, c.color, c.fx, c.src_prev, c.dst_prev, c.mb, c.trail_a, c.trail_b, c.trail_mb]
.concat()
.into_iter()
.chain(c.quad_px)
.chain([c.radius_px, c.mode])
.map(f32::to_bits)
.collect()
})
}
/// Sous un cadre, dans un bloc, le cadre EST le conteneur : fenêtre ou appareil reste au repos
/// autour du slot — mêmes calques et même ombre qu'au repos, sous un zoom à plat, un angle fixe
/// ou la caméra en orbite —, et le métrage zoome et penche dedans, rogné au slot, avec la
/// géométrie qu'il aurait sans cadre. C'est l'inverse des autres layouts, où l'appareil zoome
/// et penche avec l'écran.
#[test]
fn a_block_frame_stays_at_rest_while_the_footage_zooms_inside() {
let pointer = Some((0.8, 0.3));
for frame in ["window", "laptop", "phone", "monitor"] {
let extra = format!(r#","frame":"{frame}""#);
let rest = slot_plan(&slot_scene_with("null", 1.0, true, &extra), pointer);
let rest_mask = rest.screen_mask.expect("un bloc masque son écran, sous un cadre aussi");
let rest_off = rest.screen_shadow_offset();
for rotation in ["null", r#""iso""#, ORBIT] {
let case = format!("{frame} {rotation}");
let g = slot_plan(&slot_scene_with(rotation, 2.0, true, &extra), pointer);
let bare = slot_plan(&slot_scene(rotation, 2.0, true), pointer);
let mask = g.screen_mask.expect("masque");
assert_eq!(mask, rest_mask, "{case}: le slot a bougé");
assert_eq!(mask.rect, SLOT, "{case}");
// Le métrage : la géométrie du même bloc sans cadre, zoom et plan compris.
assert_eq!(g.s_dst.map(f32::to_bits), bare.s_dst.map(f32::to_bits), "{case}: boîte");
assert!(!contains(SLOT, g.s_dst, 1e-3), "{case}: garde, la boîte zoomée déborde");
assert_eq!(g.tilted(), rotation != "null", "{case}");
let s_px = [g.s_dst[2] * RENDER[0], g.s_dst[3] * RENDER[1]];
let plane = |g: &FrameGeometry| g.screen_tilt(s_px).map(|q| (q.corners, q.projective));
assert_eq!(plane(&g), plane(&bare), "{case}: le métrage ne penche pas comme sans cadre");
// Le cadre : au repos, à l'octet — calque sous l'écran, appareil, ombre.
assert_eq!(g.window_frame, rest.window_frame, "{case}: corps du cadre");
assert_eq!(cb_bits(g.window_frame_cb(RENDER)), cb_bits(rest.window_frame_cb(RENDER)), "{case}: sous l'écran");
assert_eq!(cb_bits(g.device_frame_cb(RENDER)), cb_bits(rest.device_frame_cb(RENDER)), "{case}: appareil");
assert_eq!(g.shadow_caster(RENDER), rest.shadow_caster(RENDER), "{case}: ombre");
assert_eq!(g.screen_shadow_offset(), rest_off, "{case}: décalage de l'ombre");
assert_eq!(
cb_bits(g.device_shadow_cb(RENDER, 40.0, rest_off, 0.3)),
cb_bits(rest.device_shadow_cb(RENDER, 40.0, rest_off, 0.3)),
"{case}: ombre de l'appareil"
);
if let Some(cb) = g.device_frame_cb(RENDER) {
assert_eq!(&cb.fx[..3], &[0.0; 3], "{case}: l'appareil penche");
let u = g.frame_unit_px(RENDER);
assert!((cb.dst_prev[1] * u - mask.radius_px).abs() < 1e-3, "{case}: ouverture ≠ coins du slot");
}
// Le métrage est dessiné dans le slot, à plat comme incliné.
match g.screen_tilt(s_px) {
None => {
let (dst, ..) = g.mask_flat_screen(g.s_dst, g.cut, s_px, g.s_radius, RENDER);
assert_eq!(dst, SLOT, "{case}");
assert_eq!(g.screen_top_lift_px(RENDER), rest.screen_top_lift_px(RENDER), "{case}: remontée");
}
Some(quad) => {
let centre = g.screen_center_px(RENDER);
let lift = g.screen_top_lift_px(RENDER);
assert_eq!(lift, 0.0, "{case}: le plan incliné n'est pas sous la barre");
let cb = tilted_screen_cb(&quad, s_px, centre, g.cut, g.focus_plane, g.s_radius, lift, false, RENDER, g.screen_mask, None);
assert_eq!(cb.dst, SLOT, "{case}");
// Sous la barre de la fenêtre, le slot garde ses coins hauts carrés : le
// mode 8 le lit dans le signe du rayon (`slot_alpha`).
assert_eq!(mask.square_top, frame == "window", "{case}");
assert!(mask.radius_px > 0.0, "{case}: garde, un rayon à signer");
let want = if mask.square_top { -mask.radius_px } else { mask.radius_px };
assert_eq!(cb.color[3], want, "{case}: coins du slot");
}
}
}
}
}
/// Sous un appareil, dans un bloc, le verre de son écran passe SOUS le métrage, au slot et à
/// ses coins, de la teinte que le mode 17 rend de face : ce que le plan incliné découvre est
/// l'écran éteint, pas le fond d'écran. Hors d'un bloc, rien sous l'écran, comme avant.
#[test]
fn a_block_device_puts_its_glass_under_the_footage() {
for (name, _) in DEVICES {
for (theme, dark) in [("", false), (r#","frameTheme":"dark""#, true)] {
let g = slot_plan(&slot_scene_with(r#""iso""#, 2.0, true, &format!(r#","frame":"{name}"{theme}"#)), None);
let mask = g.screen_mask.expect("masque");
let cb = g.window_frame_cb(RENDER).expect("verre");
assert_eq!((cb.mode, cb.dst, cb.radius_px), (1.0, SLOT, mask.radius_px), "{name}");
assert_eq!(cb.quad_px, [SLOT[2] * RENDER[0], SLOT[3] * RENDER[1]], "{name}");
assert_eq!(cb.color, device_glass_rgba(dark), "{name} {dark}");
assert!(cb.color[3] == 1.0 && cb.color[..3].iter().all(|c| *c < 0.06), "{name}: pas du verre noir");
}
assert!(device_plan(name, r#""iso""#, 2.0).window_frame_cb(RENDER).is_none(), "{name}: hors bloc");
}
assert_ne!(device_glass_rgba(true), device_glass_rgba(false), "deux thèmes, deux verres");
}
/// Le flou de confidentialité suit le métrage comme ailleurs, et le slot le rogne : ce qui en
/// sort n'est pas dessiné, rien à y cacher, et un masque y flouterait la caméra.
#[test]
fn a_privacy_mask_stays_inside_the_slot() {
let g = slot_plan(&slot_scene("null", 2.0, true), None);
let free = slot_plan(&slot_scene("null", 2.0, false), None);
let mut a = blur_annotation("");
// La vue x2 autour de (0.3, 0.6) : [0.05, 0.55] × [0.35, 0.85] de l'écran.
(a.x, a.y) = (0.2, 0.5);
let (m, f) = (g.privacy_mask(&a, RENDER).expect("masque"), free.privacy_mask(&a, RENDER).expect("masque"));
for k in 0..4 {
assert!((m.dst[k] - f.dst[k]).abs() < 1e-4, "dedans : {:?} au lieu de {:?}", m.dst, f.dst);
}
assert!(m.oval_ok, "dedans, l'ovale tient");
// À cheval sur le bord droit de la vue.
(a.x, a.y) = (0.45, 0.5);
let (m, f) = (g.privacy_mask(&a, RENDER).expect("masque"), free.privacy_mask(&a, RENDER).expect("masque"));
assert!(!contains(SLOT, f.dst, 1e-4), "garde : sans slot, le masque sort du slot, {:?}", f.dst);
assert!(contains(SLOT, m.dst, 1e-6), "{:?} sort du slot", m.dst);
let want = intersect_rect(f.dst, SLOT);
for k in 0..4 {
assert!((m.dst[k] - want[k]).abs() < 1e-5, "rogné, pas déplacé : {:?} au lieu de {want:?}", m.dst);
}
assert!(!m.oval_ok, "rogné, l'ovale inscrit ne couvrirait plus le secret");
// Hors de la vue.
(a.x, a.y) = (0.62, 0.18);
assert!(g.privacy_mask(&a, RENDER).is_none(), "hors du slot : rien à masquer");
// Incliné : dessiné dans la part du slot qu'il couvre, le warp au même endroit.
let t = slot_plan(&slot_scene(r#""iso""#, 2.0, true), None);
let tf = slot_plan(&slot_scene(r#""iso""#, 2.0, false), None);
(a.x, a.y) = (0.45, 0.5);
let (m, f) = (t.privacy_mask(&a, RENDER).expect("masque incliné"), tf.privacy_mask(&a, RENDER).expect("masque"));
assert!(contains(SLOT, m.dst, 1e-6), "incliné : {:?} sort du slot", m.dst);
let abs = |p: &PrivacyMask| p.warp.expect("incliné").map(|[x, y]| [p.dst[0] * RENDER[0] + x, p.dst[1] * RENDER[1] + y]);
for (x, y) in abs(&m).iter().zip(abs(&f).iter()) {
assert!((x[0] - y[0]).abs() < 0.5 && (x[1] - y[1]).abs() < 0.5, "incliné : coin {x:?} au lieu de {y:?}");
}
}
/// Le curseur est sur le métrage : le slot le rogne aussi.
#[test]
fn the_cursor_is_clipped_to_the_slot() {
let cfg = crate::config::all().pop().expect("au moins une config");
for (cover, want) in [(true, SLOT), (false, [-1.0, -1.0, 3.0, 3.0])] {
let scene = slot_scene("null", 2.0, cover);
let g = slot_plan(&scene, Some((0.3, 0.6)));
let plan = plan_cursor(
&g,
&CursorPlanInput {
render_px: RENDER,
u_max: 1.0,
v_max: 1080.0 / 1088.0,
cfg: &cfg,
live: live_params_from_scene(&scene),
scene: Some(&scene),
track: parked_track(0.3, 0.6),
t: 1.5,
},
)
.expect("un curseur dans la vue");
for k in 0..4 {
assert!((plan.clip[k] - want[k]).abs() < 1e-6, "slot {cover} : clip {:?} au lieu de {want:?}", plan.clip);
}
}
}
/// La parallaxe (`regions::dynamic_tilt`) passe par `plan_frame` une seule fois, et le
/// curseur la porte comme l'écran : même quad, même échelle gelée. Curseur masqué ou
/// région sans préset → rien ne bouge.
#[test]
fn the_cursor_rides_the_same_dynamic_tilt_as_the_screen() {
let cfg = crate::config::all().pop().expect("au moins une config");
// Le curseur file vers la droite autour de t = 1,5 s (l'instant de `golden_input`).
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(
crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, 0.05 + 0.1 * i as f32 / 30.0, 0.3)).collect(),
vec![],
vec![],
),
));
let with_track = |scene: &Scene| FrameGeometryInput {
cursor: Some(track),
..golden_input(scene, &cfg)
};
let still = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));
let g = plan_frame(&with_track(&tilted_golden_scene()));
assert_eq!(still.zoom_rotation_dyn, [0.0; 3], "sans piste");
assert_eq!(g.zoom_rotation, still.zoom_rotation, "la base ne dépend pas du curseur");
assert!(g.zoom_rotation_dyn[1] > 0.1, "vers la droite → +Y : {:?}", g.zoom_rotation_dyn);
let render = [1170.0, 658.0];
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("iso incline");
let still_quad = still.screen_tilt(s_px).expect("iso incline");
assert_eq!(quad.scale, still_quad.scale, "échelle gelée");
assert_ne!(quad.corners, still_quad.corners, "la parallaxe bouge les coins");
let plan = plan_cursor(
&g,
&CursorPlanInput {
render_px: render,
u_max: 1.0,
v_max: 1080.0 / 1088.0,
cfg: &cfg,
live: live_params_from_scene(&tilted_golden_scene()),
scene: Some(&tilted_golden_scene()),
track,
t: 1.5,
},
)
.expect("curseur visible");
match plan.placement {
CursorPlacement::Tilted { quad: cursor_quad, .. } => {
assert_eq!(cursor_quad.corners, quad.corners);
assert_eq!(cursor_quad.scale, quad.scale);
}
_ => panic!("le curseur doit suivre le plan incliné"),
}
let hidden_json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"iso""#)
.replace(r#""show":true"#, r#""show":false"#);
let hidden = plan_frame(&with_track(&Scene::from_json(&hidden_json).expect("scène")));
assert_eq!(hidden.zoom_rotation_dyn, [0.0; 3], "curseur masqué : pas de piste en export");
let flat = plan_frame(&with_track(&zoomed_golden_scene()));
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);
}
/// Transition chaînée caméra réelle → angle fixe : la frame d'avant peut encore être dans la
/// moitié orbite quand celle-ci est dans la moitié fixe. La traînée doit alors partir
/// du plan vu par la caméra d'AVANT, pas d'un plan droit.
#[test]
fn the_trail_keeps_the_previous_camera_across_a_follow_to_fixed_handover() {
let cfg = crate::config::all().pop().expect("au moins une config");
let render = [1170.0, 658.0];
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(
crate::cursor::CursorTrack::new((0..=300).map(|i| (i as f32 / 30.0, 0.8, 0.3)).collect(), vec![], vec![]),
));
let json = zoomed_golden_scene_json().replace(
r#"[{"clipIndex":0,"startSec":0.0,"endSec":5.0,"scale":2.0,"focusX":0.5,"focusY":0.3,"rotation":"none"}]"#,
r#"[{"clipIndex":0,"startSec":1.0,"endSec":4.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":"orbit","focusMode":"auto"},
{"clipIndex":0,"startSec":4.5,"endSec":8.0,"scale":2.0,"focusX":0.5,"focusY":0.5,"rotation":"iso"}]"#,
);
assert_ne!(json, zoomed_golden_scene_json(), "la substitution doit poser les deux régions");
let scene = Scene::from_json(&json).expect("scène");
let mut handover = None;
for k in 0..=600 {
let t = 4.0 + k as f32 / 600.0;
let g = plan_frame(&FrameGeometryInput { cursor: Some(track), timeline_t_override: Some(t), ..golden_input(&scene, &cfg) });
assert_eq!(g.camera_prev.is_some(), g.camera_prev.is_some_and(|p| p.weight > 0.0));
if g.camera.is_none() && g.camera_prev.is_some() {
handover = Some(g);
break;
}
}
let g = handover.expect("une frame où seule la frame d'avant a la caméra");
let trail = g.tilt_trail(render).expect("traînée");
let d = g.s_dst_prev;
let px = [d[2] * render[0], d[3] * render[1]];
let seen = crate::camera::View::new(px, g.camera_prev.unwrap()).quad(px);
let upright = crate::regions::rotated_quad_corners_px(px[0], px[1], g.zoom_rotation_prev, g.zoom_rotation_dyn);
let shape = |c: [(f32, f32); 4]| c.map(|(x, y)| (x - c[0].0, y - c[0].1));
let close = |a: [(f32, f32); 4], b: [(f32, f32); 4]| a.iter().zip(b).all(|(p, q)| (p.0 - q.0).abs() < 1e-3 && (p.1 - q.1).abs() < 1e-3);
assert!(close(shape(trail.corners), shape(seen.corners)), "la traînée n'est pas le plan de la caméra d'avant");
assert!(!close(shape(trail.corners), shape(upright.corners)), "la traînée est retombée sur un plan droit");
}
/// 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, [-12.0, -18.0, -2.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, square_top: false };
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));
}
/// Le zoom réactif rétrécit la caméra vers son ANCRE : une caméra de coin garde sa marge aux
/// deux bords, une caméra de milieu de bord reste centrée sur lui. Sans ancre, le centre.
#[test]
fn the_reactive_zoom_shrinks_the_camera_toward_its_anchor() {
let cfg = crate::config::all().pop().expect("au moins une config");
// Caméra de 0,2 de côté posée par l'app, marge 0,03 ; zoom ×2 à 1,5 s → échelle 0,7.
let camera_at = |anchor: Option<&str>, x: f32, y: f32| {
let anchor = anchor.map(|a| format!(r#","webcamAnchor":"{a}""#)).unwrap_or_default();
let layout = format!(
r#""webcamReactiveZoom":true{anchor},"webcamRect":{{"x":{x},"y":{y},"width":0.2,"height":0.2}}}}"#
);
let json = zoomed_golden_scene_json().replace(r#""webcamReactiveZoom":false}"#, &layout);
let scene = Scene::from_json(&json).expect("scène");
plan_frame(&golden_input(&scene, &cfg)).w_dst
};
for (anchor, x, y, want) in [
(Some("bottom-right"), 0.77, 0.77, [0.83, 0.83]),
(Some("top-left"), 0.03, 0.03, [0.03, 0.03]),
(Some("bottom"), 0.4, 0.77, [0.43, 0.83]),
(Some("left"), 0.03, 0.4, [0.03, 0.43]),
(None, 0.77, 0.77, [0.80, 0.80]),
] {
let w = camera_at(anchor, x, y);
let got = [w[0], w[1], w[2], w[3]];
let want = [want[0], want[1], 0.14, 0.14];
assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-5), "{anchor:?} : {got:?} au lieu de {want:?}");
}
}
/// Le rétrécissement réactif vise 70 % QUEL QUE SOIT le niveau de zoom : la caméra garde la
/// même taille à 1,25×, 2× et 5× (elle suivait 1/zoom, et rétrécissait d'autant plus que le
/// zoom était profond).
#[test]
fn the_camera_shrink_is_the_same_at_every_zoom_level() {
let cfg = crate::config::all().pop().expect("au moins une config");
let camera_at = |scale: &str| {
let layout = r#""webcamReactiveZoom":true,"webcamAnchor":"bottom-right","webcamRect":{"x":0.77,"y":0.77,"width":0.2,"height":0.2}}"#;
let json = zoomed_golden_scene_json()
.replace(r#""webcamReactiveZoom":false}"#, layout)
.replace(r#""scale":2.0"#, scale);
let scene = Scene::from_json(&json).expect("scène");
plan_frame(&golden_input(&scene, &cfg)).w_dst
};
for scale in [r#""scale":1.25"#, r#""scale":2.0"#, r#""scale":5.0"#] {
let w = camera_at(scale);
let got = [w[0], w[1], w[2], w[3]];
let want = [0.83, 0.83, 0.14, 0.14];
assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-5), "{scale} : {got:?} au lieu de {want:?}");
}
}
/// Une région de zoom à échelle 1 ne zoome rien : elle ne rétrécit pas la caméra.
#[test]
fn a_one_x_zoom_region_keeps_the_camera_at_its_size() {
let cfg = crate::config::all().pop().expect("au moins une config");
let layout = r#""webcamReactiveZoom":true,"webcamAnchor":"bottom-right","webcamRect":{"x":0.77,"y":0.77,"width":0.2,"height":0.2}}"#;
let json = zoomed_golden_scene_json()
.replace(r#""webcamReactiveZoom":false}"#, layout)
.replace(r#""scale":2.0"#, r#""scale":1.0"#);
let scene = Scene::from_json(&json).expect("scène");
let w = plan_frame(&golden_input(&scene, &cfg)).w_dst;
let got = [w[0], w[1], w[2], w[3]];
let want = [0.77, 0.77, 0.2, 0.2];
assert!(got.iter().zip(want).all(|(g, w)| (g - w).abs() < 1e-5), "{got:?} au lieu de {want:?}");
}
/// 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]
fn the_parallax_speed_is_measured_in_the_zoomed_cut() {
let cfg = crate::config::all().pop().expect("au moins une config");
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(
crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, 0.05 + 0.1 * i as f32 / 30.0, 0.3)).collect(),
vec![],
vec![],
),
));
let lean = |scale: &str| {
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"iso""#)
.replace(r#""scale":2.0"#, scale);
let scene = Scene::from_json(&json).expect("scène");
plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(&scene, &cfg) })
.zoom_rotation_dyn[1]
};
let (flat, zoomed) = (lean(r#""scale":1.0"#), lean(r#""scale":2.0"#));
let budget = crate::regions::DYNAMIC_TILT_BUDGET[1];
assert!(flat > 0.1 && zoomed < budget * 0.9, "garde, hors saturation : {flat} {zoomed}");
assert!(zoomed > flat * 1.4, "zoom x2 : {zoomed} devrait dépasser {flat} nettement");
}
/// L'impact du clic passe par `plan_frame` et chacune de ses portes l'éteint : réglage absent,
/// curseur masqué (réglage ou région), clic hors du clip actif ou de la coupe, vitesse ≥ 2×,
/// masque de flou visible. Sous un angle fixe il fait basculer le plan ; sans préset, il fait
/// reculer l'écran droit, par les mêmes portes.
#[test]
fn every_gate_cancels_the_click_impact() {
let cfg = crate::config::all().pop().expect("au moins une config");
// Pointeur immobile près du bord droit du crop (0,61 de large), clic 50 ms avant
// l'instant du golden (1,5 s) : le creux de `tap`.
let track_at = |x: f32| -> &'static crate::cursor::CursorTrack {
Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, x, 0.3)).collect(),
vec![1.45],
vec![],
)))
};
let on_edge = track_at(0.6);
let impact_json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"iso""#)
.replace(r#""cursor":{"#, r#""cursor":{"clickImpact":true,"#);
let plan_of = |edit: &dyn Fn(String) -> String, track| {
let scene = Scene::from_json(&edit(impact_json.clone())).expect("scène");
plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(&scene, &cfg) })
};
let dyn_of = |edit: &dyn Fn(String) -> String, track| plan_of(edit, track).zoom_rotation_dyn;
let same = |s: String| s;
let on = dyn_of(&same, on_edge);
assert!(on[1] > 0.75 * crate::regions::CLICK_IMPACT_DEG, "clic à droite → +Y : {on:?}");
// Sans préset, rien ne bascule : l'écran droit recule, puis revient.
let flat = |s: String| s.replace(r#""rotation":"iso""#, r#""rotation":"none""#);
let off = |s: String| s.replace(r#""clickImpact":true,"#, "");
assert_eq!(plan_of(&same, on_edge).s_dst, plan_of(&off, on_edge).s_dst, "le plan bascule, il ne recule pas");
let box_of = |edit: &dyn Fn(String) -> String, track| plan_of(&|s| flat(edit(s)), track).s_dst;
let rest = box_of(&off, on_edge);
let pushed = plan_of(&flat, on_edge);
assert_eq!(pushed.zoom_rotation_dyn, [0.0; 3]);
let shrink = [pushed.s_dst[2] / rest[2], pushed.s_dst[3] / rest[3]];
assert!(shrink[0] < 0.97 && (shrink[0] - shrink[1]).abs() < 1e-5, "{shrink:?}");
let centre = |b: [f32; 4]| [b[0] + b[2] * 0.5, b[1] + b[3] * 0.5];
let (a, b) = (centre(pushed.s_dst), centre(rest));
assert!((a[0] - b[0]).abs() < 1e-5 && (a[1] - b[1]).abs() < 1e-5, "autour du centre : {a:?} {b:?}");
let prev = pushed.s_dst_prev[2] / plan_of(&|s| flat(off(s)), on_edge).s_dst_prev[2];
assert!((prev - shrink[0]).abs() < 1e-6, "hors du flou de mouvement : {prev} {shrink:?}");
assert_eq!(box_of(&same, track_at(0.9)), box_of(&off, track_at(0.9)), "clic hors du crop");
let insert = |field: &'static str| {
move |s: String| s.replace(r#""cursor":"#, &format!(r#"{field},"cursor":"#))
};
let cases: [(&str, Box<dyn Fn(String) -> String>); 6] = [
("option absente", Box::new(off)),
("curseur masqué", Box::new(|s: String| s.replace(r#""show":true"#, r#""show":false"#))),
("région hideCursor", Box::new(|s: String| s.replace(r#""rotation":"iso""#, r#""rotation":"iso","hideCursor":true"#))),
("clic avant le clip", Box::new(|s: String| s.replace(r#""sourceStartSec":0"#, r#""sourceStartSec":1.46"#))),
("vitesse 2x", Box::new(insert(r#""speedRegions":[{"clipIndex":0,"startSec":1.0,"endSec":2.0,"speed":2.0}]"#))),
("flou visible", Box::new(insert(r#""annotations":[{"id":"b","startSec":1.0,"endSec":2.0,"kind":"blur","x":0.1,"y":0.1,"w":0.2,"h":0.2,"blur":{"style":"mosaic","shape":"rectangle","color":"black","intensity":8,"blockSize":16}}]"#))),
];
for (name, edit) in &cases {
assert_eq!(dyn_of(edit.as_ref(), on_edge), [0.0; 3], "{name}");
assert_eq!(box_of(edit.as_ref(), on_edge), box_of(&|s| off(edit(s)), on_edge), "{name}, écran droit");
}
assert_eq!(dyn_of(&same, track_at(0.9)), [0.0; 3], "clic hors du crop");
// Un flou qui n'est plus visible ne retient rien ; une vitesse 1,5× pèse moitié.
let later_blur = insert(r#""annotations":[{"id":"b","startSec":3.0,"endSec":4.0,"kind":"blur","x":0.1,"y":0.1,"w":0.2,"h":0.2,"blur":{"style":"blur","shape":"rectangle","color":"black","intensity":8,"blockSize":16}}]"#);
assert_eq!(dyn_of(&later_blur, on_edge), on);
let slow = dyn_of(
&insert(r#""speedRegions":[{"clipIndex":0,"startSec":1.0,"endSec":2.0,"speed":1.5}]"#),
on_edge,
);
assert!((slow[1] - on[1] * 0.5).abs() < 1e-4, "{slow:?} vs {on:?}");
// Le curseur monte sur le même plan basculé que l'écran.
let g = plan_frame(&FrameGeometryInput {
cursor: Some(on_edge),
..golden_input(&Scene::from_json(&impact_json).expect("scène"), &cfg)
});
let render = [1170.0, 658.0];
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("iso incline");
let scene = Scene::from_json(&impact_json).expect("scène");
let plan = plan_cursor(
&g,
&CursorPlanInput {
render_px: render,
u_max: 1.0,
v_max: 1080.0 / 1088.0,
cfg: &cfg,
live: live_params_from_scene(&scene),
scene: Some(&scene),
track: on_edge,
t: 1.5,
},
)
.expect("curseur visible");
match plan.placement {
CursorPlacement::Tilted { quad: cursor_quad, .. } => {
assert_eq!(cursor_quad.corners, quad.corners)
}
_ => panic!("le curseur doit suivre le plan incliné"),
}
}
/// Un clic visible dont le pointeur disparaît juste après (un glisser sur un champ numérique)
/// garde tout son impact : l'éteindre au masquage ferait sauter l'écran en plein creux.
#[test]
fn a_click_hidden_right_after_keeps_its_impact() {
let cfg = crate::config::all().pop().expect("au moins une config");
let samples: Vec<_> = (0..=90).map(|i| (i as f32 / 30.0, 0.6, 0.3)).collect();
let track = |visibility| -> &'static crate::cursor::CursorTrack {
Box::leak(Box::new(crate::cursor::CursorTrack::new_with_visibility(
samples.clone(),
vec![1.45],
vec![],
visibility,
)))
};
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"iso""#)
.replace(r#""cursor":{"#, r#""cursor":{"clickImpact":true,"#);
let scene = Scene::from_json(&json).expect("scène");
let tilt = |track| {
plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(&scene, &cfg) })
.zoom_rotation_dyn
};
let on = tilt(track(vec![]));
assert!(on[1] > 0.75 * crate::regions::CLICK_IMPACT_DEG, "garde : {on:?}");
assert_eq!(tilt(track(vec![(0.0, true), (1.48, false)])), on);
}
/// L'orbite en focus auto passe par `plan_frame` : l'écran n'est pas incliné, la caméra vise et tourne
/// avec le pointeur lu dans le RECADRAGE, la boîte zoome sur son centre sans glisser, la mise au
/// point suit la visée, un clic fait reculer l'œil sans presser l'écran, et curseur masqué
/// (l'export n'a alors pas de piste) la caméra vise le centre, au repos.
#[test]
fn the_follow_camera_aims_at_the_pointer_in_the_crop() {
let cfg = crate::config::all().pop().expect("au moins une config");
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"orbit","focusMode":"auto""#)
.replace(r#""cursor":{"#, r#""cursor":{"clickImpact":true,"#);
let scene = Scene::from_json(&json).expect("scène");
let parked = |x: f32, clicks: Vec<f32>| -> &'static crate::cursor::CursorTrack {
Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, x, 0.3)).collect(),
clicks,
vec![],
)))
};
let plan = |scene: &Scene, track| {
plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(scene, &cfg) })
};
// Le crop du golden fait 0,61 de large : x = 0,55 est tout à droite de ce qu'on voit, alors
// que dans l'image entière ce serait presque le centre.
let right = plan(&scene, parked(0.55, vec![]));
let left = plan(&scene, parked(0.05, vec![]));
let (cr, cl) = (right.camera.expect("caméra"), left.camera.expect("caméra"));
assert_eq!(cr.weight, 1.0);
// Zoom 2 : la visée va jusqu'à [0,25 ; 0,75], la portée du gimbal.
assert!(cr.aim[0] > 0.74 && cl.aim[0] < 0.26, "{:?} {:?}", cr.aim, cl.aim);
// L'orbite lit tout le recadrage, sans la borne du zoom : 0,55 y tombe à 0,9.
assert!(cr.orbit[0] > 0.89 && cl.orbit[0] < 0.1, "{:?} {:?}", cr.orbit, cl.orbit);
assert_eq!((cr.zoom, cr.press), (2.0, 0.0));
assert_eq!((right.zoom_rotation, right.zoom_rotation_dyn), ([0.0; 3], [0.0; 3]));
assert_eq!(right.focus_plane, cr.orbit, "la mise au point suit le pointeur");
assert_eq!(right.s_dst, left.s_dst, "la boîte ne glisse pas");
assert!(right.tilted() && right.depth_of_field_on(false) == right.depth_of_field);
let render = [1170.0, 658.0];
let s_px = [right.s_dst[2] * render[0], right.s_dst[3] * render[1]];
let (qr, ql) = (right.screen_tilt(s_px).expect("caméra"), left.screen_tilt(s_px).expect("caméra"));
assert!(qr.projective && ql.projective);
assert!((qr.scale - ql.scale).abs() < 0.03, "{} {}", qr.scale, ql.scale);
// Visant à droite, la caméra rejette le centre de l'écran à gauche de l'image ; vue de la
// droite, le bord droit de l'écran est le plus haut.
assert!(qr.offset[0] < -100.0 && ql.offset[0] > 100.0, "{:?} {:?}", qr.offset, ql.offset);
let edge = |q: &crate::regions::TiltedQuad, a: usize, b: usize| q.corners[b].1 - q.corners[a].1;
assert!(edge(&qr, 1, 2) > edge(&qr, 0, 3) && edge(&ql, 0, 3) > edge(&ql, 1, 2));
// L'ombre de l'écran tombe du côté de celle de la flèche (lumière en haut à gauche), sur la
// même longueur que l'ombre droite, qui reste verticale.
let flat = plan(&zoomed_golden_scene(), parked(0.55, vec![]));
let ([fx, fy], [cx, cy]) = (flat.screen_shadow_offset(), right.screen_shadow_offset());
assert!(fx == 0.0 && fy > 0.0, "{fx} {fy}");
assert!(cx > 0.0 && cy > 0.0 && (cx.hypot(cy) - fy).abs() < 1e-3, "{cx} {cy}");
// Un clic ne presse pas l'écran immobile : l'œil recule, au creux de `tap` 50 ms après.
let clicked = plan(&scene, parked(0.55, vec![1.45]));
assert_eq!((clicked.zoom_rotation, clicked.zoom_rotation_dyn), ([0.0; 3], [0.0; 3]));
let pose = clicked.camera.expect("caméra");
assert!(pose.press < -0.9, "{pose:?}");
assert_eq!(clicked.s_dst, right.s_dst, "la boîte ne recule pas, l'œil si");
let pushed = clicked.screen_tilt(s_px).expect("caméra");
assert!(pushed.half_extents_px().0 < 0.98 * qr.half_extents_px().0);
let off = Scene::from_json(&json.replace(r#""clickImpact":true,"#, "")).expect("scène");
assert_eq!(plan(&off, parked(0.55, vec![1.45])).camera.expect("caméra").press, 0.0);
let hidden = Scene::from_json(&json.replace(r#""show":true"#, r#""show":false"#)).expect("scène");
let front = plan(&hidden, parked(0.55, vec![])).camera.expect("caméra au repos");
assert!((front.aim[0] - 0.5).abs() < 1e-4 && (front.aim[1] - 0.5).abs() < 1e-4, "{:?}", front.aim);
assert!((front.orbit[0] - 0.5).abs() < 1e-4 && (front.orbit[1] - 0.5).abs() < 1e-4, "{:?}", front.orbit);
}
/// En focus manuel, l'orbite passe par le même chemin, posée par le point de focus de la
/// région : déjà dans le recadrage, comme celui d'un zoom à plat. Le pointeur n'y change rien,
/// et curseur masqué (pas de piste) elle reste posée.
#[test]
fn the_manual_orbit_sits_on_its_focus_point_in_the_crop() {
let cfg = crate::config::all().pop().expect("au moins une config");
let json = zoomed_golden_scene_json().replace(
r#""focusX":0.5,"focusY":0.3,"rotation":"none""#,
r#""focusX":0.8,"focusY":0.3,"rotation":"orbit","focusMode":"manual""#,
);
assert_ne!(json, zoomed_golden_scene_json(), "la substitution doit poser l'orbite");
let scene = Scene::from_json(&json).expect("scène");
let hidden = Scene::from_json(&json.replace(r#""show":true"#, r#""show":false"#)).expect("scène");
let parked = |x: f32| -> &'static crate::cursor::CursorTrack {
Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, x, 0.3)).collect(),
vec![],
vec![],
)))
};
let pose = |scene: &Scene, x: f32| {
plan_frame(&FrameGeometryInput { cursor: Some(parked(x)), ..golden_input(scene, &cfg) })
.camera
.expect("caméra")
};
for p in [pose(&scene, 0.55), pose(&scene, 0.05), pose(&hidden, 0.55)] {
assert_eq!(p.weight, 1.0);
// Zoom 2 : l'œil sur l'orbite du point, la visée bornée à 0,75, la portée du gimbal.
assert!((p.orbit[0] - 0.8).abs() < 1e-3 && (p.orbit[1] - 0.3).abs() < 1e-3, "{:?}", p.orbit);
assert!((p.aim[0] - 0.75).abs() < 1e-3 && (p.aim[1] - 0.3).abs() < 1e-3, "{:?}", p.aim);
}
}
/// Sous un préset 3D, le masque est le quad du contenu, warpé comme le mode 8 le dessine.
#[test]
fn a_privacy_mask_follows_the_tilted_content() {
let cfg = crate::config::all().pop().expect("au moins une config");
let g = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));
assert!(!crate::regions::is_identity_rotation(g.zoom_rotation), "garde : iso doit incliner");
let a = blur_annotation("");
let render = [1170.0, 658.0];
let m = g.privacy_mask(&a, render).expect("masque");
let warp = m.warp.expect("un écran incliné demande un masque warpé");
// Le même quad et le même centre que le dessin du mode 8 (`compose_frame`).
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
let quad = g.screen_tilt(s_px).expect("iso incline");
let centre = [
(g.s_dst[0] + g.s_dst[2] * 0.5) * render[0],
(g.s_dst[1] + g.s_dst[3] * 0.5) * render[1],
];
let drawn = |fx: f32, fy: f32| {
let (px, py) = quad.point_px(fx, fy);
[centre[0] + px, centre[1] + py]
};
let content = [(a.x, a.y), (a.x + a.w, a.y), (a.x + a.w, a.y + a.h), (a.x, a.y + a.h)];
let mid = drawn(a.x + a.w * 0.5, a.y + a.h * 0.5);
let from_mid = |p: [f32; 2]| (p[0] - mid[0]).hypot(p[1] - mid[1]);
let origin = [m.dst[0] * render[0], m.dst[1] * render[1]];
for (k, &(fx, fy)) in content.iter().enumerate() {
let want = drawn(fx, fy);
let got = [origin[0] + warp[k][0], origin[1] + warp[k][1]];
let gap = (got[0] - want[0]).hypot(got[1] - want[1]);
// La marge vaut deux pixels de la boîte zoomée par axe, projetés : au plus ~3 px
// en diagonale.
assert!(gap > 0.5 && gap < 3.5, "coin {k} : {got:?} à {gap} px du contenu {want:?}");
// Côté sur-masquage : le coin du masque est plus loin du centre que celui du contenu.
assert!(from_mid(got) > from_mid(want), "coin {k} rentré dans le contenu");
assert!(got[0] >= origin[0] - 1e-3 && got[0] <= origin[0] + m.quad_px[0] + 1e-3);
assert!(got[1] >= origin[1] - 1e-3 && got[1] <= origin[1] + m.quad_px[1] + 1e-3);
}
// L'ancien rect droit ne couvrait pas le centre du contenu incliné.
let old = g.annotation_dst(a.x, a.y, a.w, a.h);
assert!(
!inside(old, mid[0] / render[0], mid[1] / render[1]),
"garde : sous ce préset l'ancien rect devrait rater le contenu"
);
assert!(m.strength >= 1.0);
}
/// Pendant une rampe de zoom, le flou de mouvement du mode 0 étale le contenu jusqu'à sa
/// position de la frame précédente : le masque couvre les deux.
#[test]
fn a_privacy_mask_covers_the_motion_blur_trail() {
let cfg = crate::config::all().pop().expect("au moins une config");
let scene = zoomed_golden_scene();
let a = blur_annotation("");
let render = [1170.0, 658.0];
let moving = (0..400)
.map(|k| {
let mut input = golden_input(&scene, &cfg);
input.timeline_t_override = Some(k as f32 * 0.02 - 1.0);
plan_frame(&input)
})
.find(|g| g.s_dst != g.s_dst_prev)
.expect("garde : la rampe de zoom doit déplacer la boîte d'une frame à l'autre");
assert!(moving.mb_taps >= 2.0 && moving.mb_amount > 0.001, "garde : flou de mouvement actif");
let m = moving.privacy_mask(&a, render).expect("masque");
// Élargi, le masque ne peut plus être un ovale inscrit : il retombe sur le rect.
assert!(!m.oval_ok, "un masque élargi à la trace doit refuser l'ovale");
for anchor in [moving.s_dst, moving.s_dst_prev] {
let r = annotation_dst_in(anchor, a.x, a.y, a.w, a.h);
for (x, y) in [(r[0], r[1]), (r[0] + r[2], r[1] + r[3])] {
assert!(inside(m.dst, x, y), "({x}, {y}) hors du masque {:?}", m.dst);
}
}
}
/// Le point `p` est dans le quad convexe `q` (TL, TR, BR, BL, px de sortie).
fn in_convex_quad(q: [[f32; 2]; 4], p: [f32; 2]) -> bool {
let side = |i: usize| {
let (a, b) = (q[i], q[(i + 1) % 4]);
(b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0])
};
(0..4).all(|i| side(i) >= -1e-3) || (0..4).all(|i| side(i) <= 1e-3)
}
/// Sous l'orbite, la caméra suit le pointeur et le flou de mouvement étale le contenu vers
/// sa position de la frame d'avant : le masque garde la perspective du contenu (un quad warpé
/// aux côtés parallèles aux siens, pas un rect droit) et couvre le secret aux deux frames.
#[test]
fn a_moving_tilted_mask_keeps_its_perspective() {
let cfg = crate::config::all().pop().expect("au moins une config");
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"orbit","focusMode":"auto""#);
let scene = Scene::from_json(&json).expect("scène");
// Le pointeur file vers la droite : l'orbite le suit, la caméra bouge à chaque frame.
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(crate::cursor::CursorTrack::new(
(0..=90).map(|i| (i as f32 / 30.0, 0.05 + 0.5 * i as f32 / 90.0, 0.3)).collect(),
vec![],
vec![],
)));
let g = plan_frame(&FrameGeometryInput { cursor: Some(track), ..golden_input(&scene, &cfg) });
let render = [1170.0, 658.0];
let quad = g.screen_tilt([g.s_dst[2] * render[0], g.s_dst[3] * render[1]]).expect("orbite");
let trail = g.tilt_trail(render).expect("garde : flou de mouvement actif sous l'orbite");
assert_ne!(trail.corners, quad.corners, "garde : la caméra doit bouger d'une frame à l'autre");
let a = blur_annotation("");
let m = g.privacy_mask(&a, render).expect("masque");
let warp = m.warp.expect("le masque d'un écran incliné qui bouge reste un quad warpé");
let origin = [m.dst[0] * render[0], m.dst[1] * render[1]];
let mask = warp.map(|[x, y]| [origin[0] + x, origin[1] + y]);
let centre = [(g.s_dst[0] + g.s_dst[2] * 0.5) * render[0], (g.s_dst[1] + g.s_dst[3] * 0.5) * render[1]];
let before = crate::regions::TiltedQuad { corners: trail.corners, ..quad };
for q in [quad, before] {
for (fx, fy) in [(a.x, a.y), (a.x + a.w, a.y), (a.x + a.w, a.y + a.h), (a.x, a.y + a.h)] {
let (px, py) = q.point_px(fx, fy);
let p = [centre[0] + px, centre[1] + py];
assert!(in_convex_quad(mask, p), "{p:?} hors du masque {mask:?}");
}
}
let (tl, tr) = (quad.point_px(a.x, a.y), quad.point_px(a.x + a.w, a.y));
let content = (tr.1 - tl.1) / (tr.0 - tl.0);
assert!(content.abs() > 1e-3, "garde : l'orbite doit incliner le haut du secret ({content})");
let top = (mask[1][1] - mask[0][1]) / (mask[1][0] - mask[0][0]);
assert!((top - content).abs() < 1e-3, "le haut du masque ({top}) doit suivre celui du contenu ({content})");
assert!(!m.oval_ok, "un masque élargi à la trace doit refuser l'ovale");
}
/// Le métrage que l'éditeur lit avec l'image : le rect zoomé à plat, le quad incliné du mode 8
/// sous un préset, l'homographie de ses coins sous la caméra réelle.
#[test]
fn the_footage_quad_is_where_masks_land() {
let cfg = crate::config::all().pop().expect("au moins une config");
let render = [1170.0, 658.0];
let flat = plan_frame(&golden_input(&zoomed_golden_scene(), &cfg));
let [x, y, w, h] = flat.s_dst;
assert_eq!(
flat.footage_quad(render),
FootageQuad { corners: [[x, y], [x + w, y], [x + w, y + h], [x, y + h]], projective: false }
);
let tilted = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));
let q = tilted.footage_quad(render);
let quad = tilted.screen_tilt([tilted.s_dst[2] * render[0], tilted.s_dst[3] * render[1]]).expect("iso");
let centre = [
(tilted.s_dst[0] + tilted.s_dst[2] * 0.5) * render[0],
(tilted.s_dst[1] + tilted.s_dst[3] * 0.5) * render[1],
];
for (k, (cx, cy)) in quad.corners.iter().enumerate() {
let want = [(centre[0] + cx) / render[0], (centre[1] + cy) / render[1]];
assert!((q.corners[k][0] - want[0]).abs() < 1e-5 && (q.corners[k][1] - want[1]).abs() < 1e-5, "coin {k}");
}
assert!(!q.projective);
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, r#""rotation":"orbit","focusMode":"auto""#);
let orbit = plan_frame(&golden_input(&Scene::from_json(&json).expect("scène"), &cfg));
assert!(orbit.footage_quad(render).projective, "la caméra réelle warpe par homographie");
}
/// Une entrée mesurée sur le cadre de sortie n'est pas concernée par le zoom.
#[test]
fn a_privacy_mask_in_frame_space_ignores_the_zoom() {
let cfg = crate::config::all().pop().expect("au moins une config");
let g = plan_frame(&golden_input(&tilted_golden_scene(), &cfg));
let a = blur_annotation(r#","space":"frame""#);
let m = g.privacy_mask(&a, [1170.0, 658.0]).expect("masque");
assert_eq!(m.warp, None);
assert_eq!(m.strength, 1.0);
assert!(inside(m.dst, a.x, a.y) && inside(m.dst, a.x + a.w, a.y + a.h));
}
/// **Le golden iso-render.**
///
/// Les deux backends ne peuvent pas tourner sur la même machine, donc « iso avec
/// D3D » ne peut pas être mesuré en comparant deux images rendues. Ce qui PEUT l'être,
/// et qui est la couche où la divergence s'est effectivement produite, c'est la
/// géométrie : `plan_frame` est le MÊME code des deux côtés, et ce test épingle ses 15
/// sorties au bit près. Il tourne dans le job macOS ET dans le job Windows, donc si un
/// jour les deux plateformes calculent des placements différents, l'un des deux vire au
/// rouge — ce qui est exactement la garantie qu'on cherche.
///
/// Ce que ce test ne couvre PAS, et qu'il ne faut pas lui faire dire : la rastérisation.
/// D3D11 et Metal ne rendront jamais bit-à-bit identique (la PR #162 a mesuré 93-95 %
/// de canaux identiques, écart max 3/255, entre deux backends sur la MÊME machine).
/// La parité des shaders est tenue séparément, par le fait que `shaders.metal` et
/// `shaders.hlsl` ont été diffés ligne à ligne sur les 14 modes.
#[test]
fn plan_frame_is_pinned_bit_for_bit() {
let scene = golden_scene();
let cfg = crate::config::all().pop().expect("au moins une config");
let g = plan_frame(&golden_input(&scene, &cfg));
let got = [
g.s_dst[0], g.s_dst[1], g.s_dst[2], g.s_dst[3],
g.w_dst[0], g.w_dst[1], g.w_dst[2], g.w_dst[3],
g.cut[0], g.cut[1], g.cut[2], g.cut[3],
g.s_radius, g.w_radius, g.w_px[0], g.w_px[1],
g.frame_min_px, g.padding_scale, g.shape_fade, g.mb_taps, g.source_t,
g.programme_t,
];
// Mesuré sur ce code, pas deviné : toute dérive est une divergence à expliquer,
// pas un seuil à relâcher. Ordre : s_dst[4], w_dst[4], cut[4], s_radius, w_radius,
// w_px[2], frame_min_px, padding_scale, shape_fade, mb_taps, source_t, programme_t.
// `programme_t` ajouté avec l'horloge programme : c'est une recopie de l'entrée, les
// 21 valeurs d'avant n'ont pas bougé d'un bit.
let want: [f32; 22] = [
0.10207555, 0.102, 0.7958489, 0.796,
0.9058473, 0.8325926, 0.0733194, 0.13037036,
0.0, 0.0, 0.61, 0.6055147,
16.779, 42.89185, 85.7837, 85.7837,
658.0, 0.796, 1.0, 6.25, 1.5,
2.25,
];
for (i, (a, b)) in got.iter().zip(want.iter()).enumerate() {
assert_eq!(
a.to_bits(),
b.to_bits(),
"sortie #{i} de plan_frame : {a} != {b}",
);
}
}
/// En preview, la même image arrive avec deux compteurs `frame` différents selon qu'on y
/// vient en lecture (`idx` incrémenté) ou par un seek (`idx` dérivé du temps). Le temps
/// programme ne doit dépendre que de l'instant fourni, jamais de ce compteur.
#[test]
fn programme_time_ignores_the_frame_counter() {
let scene = golden_scene();
let cfg = crate::config::all().pop().expect("au moins une config");
let mut played = golden_input(&scene, &cfg);
played.frame = 7.0;
let mut sought = golden_input(&scene, &cfg);
sought.frame = 90.0;
assert_eq!(
plan_frame(&played).programme_t.to_bits(),
plan_frame(&sought).programme_t.to_bits()
);
// Sans horloge programme (bench/fixture), repli sur le compteur comme `source_t`.
sought.programme_time = None;
assert_eq!(plan_frame(&sought).programme_t, 90.0 / FPS);
}
/// Sans mouvement, les emplacements restent les zéros d'avant (dégradé inchangé) ; avec,
/// le temps est replié sur la période commune et l'indice suit l'ordre du shader.
#[test]
fn wallpaper_motion_slots_are_zero_when_still_and_wrap_the_clock() {
use crate::scene::WallpaperMotion as M;
assert_eq!(wallpaper_motion_slots(M::None, 37.5, 16.0 / 9.0), ([0.0, 0.0], [0.0; 4]));
let (fx, mb) = wallpaper_motion_slots(M::Drift, 125.0, 2.0);
assert_eq!(fx, [5.0, 1.0]);
assert_eq!(mb, [2.0, 0.0, 0.0, 0.0]);
assert_eq!(wallpaper_motion_slots(M::Aurora, 0.0, 1.0).0[1], 2.0);
assert_eq!(wallpaper_motion_slots(M::Waves, 240.0, 1.0).0, [0.0, 3.0]);
// Chaque période du shader divise la période de repli : pas de raccord au bouclage.
for p in [6.0, 10.0, 12.0, 15.0, 20.0, 30.0] {
assert_eq!(WALLPAPER_MOTION_PERIOD_S % p, 0.0, "période {p}");
}
}
const BLACK_TEST: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
fn knots(cb: &LayerCB) -> [[f32; 4]; 4] {
[cb.color, cb.src_prev, cb.dst_prev, cb.src]
}
#[test]
fn gradient_layer_keeps_the_middle_stop_where_css_puts_it() {
// Le dégradé de l'ancien éditeur : trois stops rgb(), le milieu à 50 %.
let stops = ["rgb(255, 0, 0)", "rgb(0, 255, 0)", "rgb(0, 0, 255)"].map(String::from);
let cb = gradient_layer(&stops, &[0.0, 0.5, 1.0], BLACK_TEST);
assert_eq!(cb.mode, 5.0);
let k = knots(&cb);
assert_eq!(k[0], [1.0, 0.0, 0.0, 0.0]);
assert_eq!(k[1], [0.0, 1.0, 0.0, 0.5]);
assert_eq!(k[2], [0.0, 0.0, 1.0, 1.0]);
assert_eq!(k[3], [0.0, 0.0, 1.0, 1.0]);
}
#[test]
fn gradient_layer_premultiplies_a_translucent_stop() {
// Un stop à alpha 0 ne peint rien : le noir du dessous, pas un rouge opaque.
let stops = ["rgba(255, 0, 0, 0)", "rgba(0, 0, 255, 0.5)"].map(String::from);
let k = knots(&gradient_layer(&stops, &[0.0, 1.0], BLACK_TEST));
assert_eq!(k[0], [0.0, 0.0, 0.0, 0.0]);
assert_eq!(k[1], [0.0, 0.0, 0.5, 1.0]);
// Opaque : inchangé.
let k = knots(&gradient_layer(&["#ff0000".into()], &[0.0], BLACK_TEST));
assert_eq!(k[0], [1.0, 0.0, 0.0, 0.0]);
}
#[test]
fn gradient_layer_two_stops_render_the_old_ramp() {
// Scène d'avant les offsets : les stops se répartissent à 0 et 1, le reste répète la fin.
let cb = gradient_layer(&["#000000".into(), "#ffffff".into()], &[], BLACK_TEST);
let k = knots(&cb);
assert_eq!(k[0], [0.0, 0.0, 0.0, 0.0]);
for knot in &k[1..] {
assert_eq!(*knot, [1.0, 1.0, 1.0, 1.0]);
}
}
#[test]
fn gradient_layer_bounds_and_orders_offsets_and_skips_bad_stops() {
let stops = ["#ff0000", "nope", "#00ff00", "#0000ff"].map(String::from);
let cb = gradient_layer(&stops, &[-0.2, 0.3, 0.6, 0.4], BLACK_TEST);
let at: Vec<f32> = knots(&cb).iter().map(|k| k[3]).collect();
// -0.2 borné à 0 ; 0.4 derrière 0.6 ramené à 0.6 ; "nope" sauté.
assert_eq!(at, vec![0.0, 0.6, 0.6, 0.6]);
assert_eq!(knots(&cb)[1][1], 1.0, "le vert suit le rouge, le stop illisible est sauté");
let empty = gradient_layer(&[], &[], [0.2, 0.3, 0.4, 1.0]);
assert!(knots(&empty).iter().all(|k| *k == [0.2, 0.3, 0.4, 0.0]));
}
#[test]
fn gradient_layer_folds_a_long_preset_into_four_knots() {
// Un preset v1.5 à sept stops : les extrémités restent, les positions restent en ordre,
// et le stop retiré est celui que ses voisins reproduisaient déjà.
let stops = ["#fcc5e4", "#fda34b", "#ff7882", "#c8699e", "#7046aa", "#0c1db8", "#020f75"]
.map(String::from);
let offsets = [0.0, 0.15, 0.35, 0.52, 0.71, 0.87, 1.0];
let k = knots(&gradient_layer(&stops, &offsets, BLACK_TEST));
assert_eq!(k[0][3], 0.0);
assert_eq!(k[3][3], 1.0);
assert_eq!(&k[0][..3], &parse_hex("#fcc5e4").unwrap()[..3]);
assert_eq!(&k[3][..3], &parse_hex("#020f75").unwrap()[..3]);
assert!(k.windows(2).all(|w| w[0][3] <= w[1][3]));
// Un stop parfaitement sur la droite de ses voisins part en premier.
let straight = ["#000000", "#404040", "#808080", "#ff0000", "#ffffff"].map(String::from);
let k = knots(&gradient_layer(&straight, &[0.0, 0.25, 0.5, 0.75, 1.0], BLACK_TEST));
assert_eq!(k.iter().map(|k| k[3]).collect::<Vec<_>>(), vec![0.0, 0.5, 0.75, 1.0]);
}
/// Le contrat cross-backend, verrouillé octet par octet. Un shader qui lit un champ
/// décalé ne lève rien : il rend faux, en silence.
#[test]
fn layer_cb_matches_the_shader_constant_buffer() {
use std::mem::{align_of, offset_of, size_of};
assert_eq!(size_of::<LayerCB>(), 176);
assert_eq!(align_of::<LayerCB>(), 16);
for (name, got, want) in [
("dst", offset_of!(LayerCB, dst), 0),
("src", offset_of!(LayerCB, src), 16),
("quad_px", offset_of!(LayerCB, quad_px), 32),
("radius_px", offset_of!(LayerCB, radius_px), 40),
("mode", offset_of!(LayerCB, mode), 44),
("color", offset_of!(LayerCB, color), 48),
("fx", offset_of!(LayerCB, fx), 64),
("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}`");
}
}
/// Le pivot doit rester collé à `center` quand le sprite grandit — c'est exactement ce qui
/// était cassé (ancrage centré en dur : la pointe s'éloignait proportionnellement à la
/// taille). On dessine la même flèche à deux tailles et on vérifie que le point désigné
/// ne bouge pas.
#[test]
fn sprite_hotspot_stays_on_target_at_any_size() {
let center = [0.4, 0.6];
let hotspot = [0.1205, 0.0881]; // flèche intégrée : la pointe, près du coin haut-gauche
for (w, h) in [(0.02, 0.04), (0.08, 0.16)] {
let dst = cursor_sprite_dst(center, w, h, hotspot);
let pivot = [dst[0] + dst[2] * hotspot[0], dst[1] + dst[3] * hotspot[1]];
assert!((pivot[0] - center[0]).abs() < 1e-6, "x drifted at {w}x{h}: {pivot:?}");
assert!((pivot[1] - center[1]).abs() < 1e-6, "y drifted at {w}x{h}: {pivot:?}");
assert_eq!([dst[2], dst[3]], [w, h], "taille altérée");
}
// Et un pivot centré reste bien l'ancien comportement, pour les sprites qui le veulent
// (viseur, I-beam, poignées de redimensionnement).
assert_eq!(cursor_sprite_dst([0.5, 0.5], 0.2, 0.2, [0.5, 0.5]), [0.4, 0.4, 0.2, 0.2]);
}
fn assert_rect(actual: [f32; 4], expected: [f32; 4]) {
for (actual, expected) in actual.into_iter().zip(expected) {
assert!((actual - expected).abs() < 1e-6, "actual={actual}, expected={expected}");
}
}
#[test]
fn decodes_a_base64_data_uri() {
// "Hi!" -> SGkh
assert_eq!(decode_data_uri("data:image/png;base64,SGkh").unwrap(), b"Hi!".to_vec());
}
/// L'inspector stocke les couleurs de caption comme `couleur_hex` + `opacité` puis la
/// bridge JS recombine en `rgba(r, g, b, a)` pour la preview. Le natif doit rendre la même
/// plaque (couleur et opacité) — sinon le calque disparaît silencieusement et la caption
/// n'apparaît qu'en texte brut dans l'export. C'était exactement le bug de l'issue #178.
#[test]
fn parse_hex_understands_rgba_caption_backgrounds() {
let parsed = parse_hex("rgba(0, 0, 0, 0.55)").expect("rgba doit parser");
assert!((parsed[3] - 0.55).abs() < 1e-6, "alpha 0.55 transmise, pas tombée à 0");
assert_eq!([parsed[0], parsed[1], parsed[2]], [0.0, 0.0, 0.0]);
}
/// `rgb(...)` sans alpha est sémantiquement `rgba(..., 1)` — il faut le supporter pour
/// qu'un inspector qui n'expose pas d'opacité n'écrive pas un fond invisible.
#[test]
fn parse_hex_treats_rgb_as_opaque() {
let parsed = parse_hex("rgb(255, 128, 0)").expect("rgb doit parser");
assert_eq!(parsed, [1.0, 128.0 / 255.0, 0.0, 1.0]);
}
/// Le cas "transparent" est documenté dans le code d'appel : on garde la sémantique
/// historique (alpha 0) — la plaque est sautée côté rastérisation, ce qui est exactement ce
/// que veut le CSS. Le nouveau parseur ne doit pas le casser.
#[test]
fn parse_hex_keeps_transparent_at_alpha_zero() {
assert_eq!(parse_hex("transparent"), Some([0.0, 0.0, 0.0, 0.0]));
// La casse ne doit pas non plus casser : CSS autorise `TRANSPARENT` en théorie, et
// refuse une chaîne qui ressemble à un rgba mal formé.
assert_eq!(parse_hex("Transparent"), Some([0.0, 0.0, 0.0, 0.0]));
assert_eq!(parse_hex("rgba(0, 0, 0, 0)"), Some([0.0, 0.0, 0.0, 0.0]));
}
/// Le contrat historique `#rrggbb` / `rrggbb` ne doit pas régresser : les annotations
/// normales (saisies via `ColorField`) ne passent que par ce chemin, et leurs snapshots
/// ne pardonneraient pas un changement d'alpha implicite.
#[test]
fn parse_hex_still_understands_hex_colours() {
assert_eq!(parse_hex("#fff"), Some([1.0, 1.0, 1.0, 1.0]));
assert_eq!(parse_hex("#000000"), Some([0.0, 0.0, 0.0, 1.0]));
assert_eq!(
parse_hex("ff8800"),
Some([1.0, 136.0 / 255.0, 0.0, 1.0])
);
}
/// Hors-format (channel > 255, chaîne vide, named color) → None → l'appelant retombe sur
/// son fallback. C'est la même politique qu'avant l'ajout du parseur rgba, on la garde
/// explicite pour qu'elle ne dérive pas.
#[test]
fn parse_hex_rejects_malformed_colours() {
assert_eq!(parse_hex(""), None);
assert_eq!(parse_hex("not-a-color"), None);
assert_eq!(parse_hex("rgba(256, 0, 0, 1)"), None); // canal >255
assert_eq!(parse_hex("rgba(0, 0, 0, 1.5)"), None); // alpha >1
assert_eq!(parse_hex("rgba(0, 0, 0, 0.5, 1)"), None); // 5 composantes
assert_eq!(parse_hex("rgb(0, 0)"), None); // 2 composantes
}
/// CSS Color 4 : `rgb()` et `rgba()` sont synonymes, les deux prennent 3 ou 4 composantes.
/// Une couleur bien formée ne doit pas finir sur le fallback de l'appelant — pour un fond
/// c'est alpha 0, donc une plaque invisible, soit très exactement le symptôme de #178.
#[test]
fn parse_hex_accepts_both_arities_on_both_names() {
assert_eq!(parse_hex("rgba(0, 0, 0)"), Some([0.0, 0.0, 0.0, 1.0]));
assert_eq!(parse_hex("rgb(0, 0, 0, 0.5)"), Some([0.0, 0.0, 0.0, 0.5]));
}
/// Une couleur non-ASCII doit être refusée, pas paniquer : `strip_color_fn` découpait
/// `s[..3]` / `s[..4]` sans vérifier la frontière de caractère, donc `#ab€cd` (le `€` occupe
/// les octets 3..6) tuait le process au lieu de retomber sur le fallback. `parseWallpaper`
/// laisse passer n'importe quelle chaîne préfixée `#` jusqu'ici, une panique côté natif
/// traverserait le pont N-API et emporterait l'export.
#[test]
fn parse_hex_refuses_non_ascii_without_panicking() {
assert_eq!(parse_hex("#ab€cd"), None);
assert_eq!(parse_hex("rg€(0, 0, 0)"), None);
assert_eq!(parse_hex("é"), None);
assert_eq!(parse_hex("🎨🎨"), None);
// Le chemin hex découpe par octet sur les longueurs 3 et 6 : `éa` fait 3 octets et
// `€€` en fait 6, donc les deux tombaient pile sur une découpe intra-caractère.
assert_eq!(parse_hex("éa"), None);
assert_eq!(parse_hex("€€"), None);
}
#[test]
fn ignores_padding_and_line_breaks_inside_the_payload() {
// Un URI replié ou paddé doit décoder à l'identique : les caractères hors alphabet sont
// sautés, donc ils ne peuvent pas décaler le flux.
let folded = "data:image/png;base64,SGkh
==";
assert_eq!(decode_data_uri(folded).unwrap(), b"Hi!".to_vec());
}
#[test]
fn a_plain_path_is_not_a_data_uri() {
// Le repli lecture-disque des wallpapers en dépend.
assert!(decode_data_uri("/wallpapers/x.jpg").is_none());
assert!(decode_data_uri("C:/img/y.png").is_none());
}
#[test]
fn a_non_base64_data_uri_is_refused() {
// `data:image/svg+xml,<svg…>` n'est pas du base64 : mieux vaut échouer que décoder du
// texte comme des octets.
assert!(decode_data_uri("data:image/svg+xml,<svg/>").is_none());
}
#[test]
fn crop_maps_visible_frame_fractions_to_texture_uvs() {
let crop = SceneCrop { x: 0.25, y: 0.1, width: 0.5, height: 0.6 };
assert_rect(screen_source_rect(0.8, 0.9, None, 1.0, [0.2, 0.7]), [0.0, 0.0, 0.8, 0.9]);
assert_rect(screen_source_rect(0.8, 0.9, Some(crop), 1.0, [0.5, 0.5]), [0.2, 0.09, 0.6, 0.63]);
}
#[test]
fn zoom_focus_is_applied_inside_the_crop() {
let crop = SceneCrop { x: 0.25, y: 0.1, width: 0.5, height: 0.6 };
assert_rect(screen_source_rect(0.8, 0.9, Some(crop), 2.0, [0.5, 0.5]), [0.3, 0.225, 0.5, 0.495]);
assert_rect(screen_source_rect(0.8, 0.9, Some(crop), 2.0, [1.0, 1.0]), [0.4, 0.36, 0.6, 0.63]);
}
// --- le zoom rendu à la boîte (issue #179) ------------------------------
// Le zoom déplace et agrandit la boîte au lieu de rétrécir la coupe. Deux choses à
// figer, et elles tirent en sens inverse : la boîte DOIT déborder le padding (l'issue),
// et le mapping image→écran ne doit PAS bouger (tout le reste du compositeur en
// dépend). Une version antérieure de ce correctif protégeait si bien le second qu'elle
// annulait le premier dès que le focus n'était pas centré — d'où le balayage sur des
// focus décentrés dans les deux tests.
/// Boîte paddée (padding 50 % → `scale_frame` 0.8) dans une sortie carrée : le cas
/// plein cadre de l'issue.
const PADDED: [f32; 4] = [0.1, 0.1, 0.8, 0.8];
/// Les zooms d'un preset (`ZOOM_DEPTH_SCALES`, TS) et des focus réalistes — dont des
/// focus très décentrés, que le suivi de curseur produit en permanence.
const ZOOMS: [f32; 6] = [1.0, 1.25, 1.5, 1.8, 2.2, 3.5];
const FOCUSES: [[f32; 2]; 6] = [
[0.5, 0.5],
[0.3, 0.5],
[0.5, 0.8],
[0.15, 0.9],
[0.85, 0.2],
[0.0, 1.0],
];
/// Le couple (boîte, coupe) réellement envoyé au GPU. `u_max`/`v_max` à 1 et pas de
/// crop : la coupe est donc directement en fractions d'image.
fn drawn(base: [f32; 4], zoom: f32, focus: [f32; 2]) -> ([f32; 4], [f32; 4]) {
let cut_ref = screen_source_rect(1.0, 1.0, None, zoom, focus);
let cut = screen_source_rect(1.0, 1.0, None, 1.0, focus);
(remap_box(base, cut_ref, cut), cut)
}
/// Où un point de l'image atterrit à l'écran, en fraction du CADRE.
fn on_screen(base: [f32; 4], zoom: f32, focus: [f32; 2], point: [f32; 2]) -> [f32; 2] {
let (dst, src) = drawn(base, zoom, focus);
let at = |f: f32, s0: f32, s1: f32, d0: f32, dw: f32| d0 + dw * (f - s0) / (s1 - s0);
[
at(point[0], src[0], src[2], dst[0], dst[2]),
at(point[1], src[1], src[3], dst[1], dst[3]),
]
}
/// Le mapping d'avant : la coupe zoomée remplissait la boîte paddée, sans la bouger.
fn on_screen_before(base: [f32; 4], zoom: f32, focus: [f32; 2], point: [f32; 2]) -> [f32; 2] {
let src = screen_source_rect(1.0, 1.0, None, zoom, focus);
let at = |f: f32, s0: f32, s1: f32, d0: f32, dw: f32| d0 + dw * (f - s0) / (s1 - s0);
[
at(point[0], src[0], src[2], base[0], base[2]),
at(point[1], src[1], src[3], base[1], base[3]),
]
}
/// L'invariant : rendre le zoom à la boîte ne déplace AUCUN point de l'image — même
/// grossissement, même cadrage. Seule l'étendue dessinée change.
#[test]
fn handing_the_zoom_to_the_box_moves_no_pixel() {
for &zoom in &ZOOMS {
for &focus in &FOCUSES {
for &point in &[[0.5, 0.5], [0.0, 0.0], [1.0, 1.0], [0.25, 0.75]] {
let (was, now) = (
on_screen_before(PADDED, zoom, focus, point),
on_screen(PADDED, zoom, focus, point),
);
assert!(
(was[0] - now[0]).abs() < 1e-4 && (was[1] - now[1]).abs() < 1e-4,
"point {point:?} déplacé (zoom {zoom}, focus {focus:?}) : {was:?} → {now:?}"
);
}
}
}
}
/// Ce que l'issue demande, et la régression que le testeur a vue : dès qu'on zoome, la
/// boîte doit déborder le rect paddé — y compris (surtout) avec un focus décentré.
#[test]
fn any_zoom_overflows_the_padding() {
for &zoom in &ZOOMS {
for &focus in &FOCUSES {
let (dst, _) = drawn(PADDED, zoom, focus);
let grew = dst[2] / PADDED[2];
assert!(
(grew - zoom).abs() < 1e-4,
"la boîte n'a pas pris le zoom (zoom {zoom}, focus {focus:?}) : ×{grew}"
);
if zoom > 1.0 {
// Elle dépasse le rect paddé d'au moins un bord, donc mange du padding.
assert!(
dst[0] < PADDED[0] - 1e-6 || dst[0] + dst[2] > PADDED[0] + PADDED[2] + 1e-6,
"boîte encore dans le padding (zoom {zoom}, focus {focus:?}) : {dst:?}"
);
}
}
}
// Focus centré : le padding disparaît des QUATRE côtés dès que le zoom suffit à
// couvrir le cadre (ici 1/0.8 = 1.25).
let (dst, _) = drawn(PADDED, 1.25, [0.5, 0.5]);
assert_rect(dst, [0.0, 0.0, 1.0, 1.0]);
// Sans padding il n'y a rien à déborder, mais la boîte porte quand même le zoom.
let (dst, _) = drawn([0.0, 0.0, 1.0, 1.0], 2.0, [0.5, 0.5]);
assert_rect(dst, [-0.5, -0.5, 2.0, 2.0]);
}
// --- cover_crop_uv : la caméra n'est jamais étirée --------------------
// Le ratio de la coupe source, ramené en pixels d'image, doit TOUJOURS égaler
// celui de la boîte : c'est la définition de « pas de déformation ».
/// Ratio largeur/hauteur de la coupe, exprimé en pixels de l'image source.
fn crop_aspect(uv: (f32, f32, f32, f32), tex: [f32; 2]) -> f32 {
((uv.2 - uv.0) * tex[0]) / ((uv.3 - uv.1) * tex[1])
}
/// L'invariant, balayé sur des boîtes très diverses — dont le slot en colonne
/// du preset side-by-side, qui est précisément le cas qui étirait la caméra.
#[test]
fn cover_crop_never_distorts_whatever_the_destination_box() {
let tex = [1024.0, 1024.0];
for &cam in &[[1280.0, 720.0], [960.0, 720.0], [640.0, 480.0]] {
for &box_ar in &[0.35, 0.5, 0.75, 1.0, 16.0 / 9.0, 2.4] {
let uv = cover_crop_uv(cam, tex, box_ar);
let got = crop_aspect(uv, tex);
assert!(
(got - box_ar).abs() < 1e-3,
"cam {cam:?} boite {box_ar} → coupe de ratio {got}, attendu {box_ar}",
);
}
}
}
/// La coupe reste DANS l'image visible et centrée — on ne va jamais chercher
/// le padding décodeur au-delà de `visible`, qui contient des pixels indéfinis.
#[test]
fn cover_crop_stays_inside_the_visible_frame_and_is_centred() {
let (cam, tex) = ([1280.0, 720.0], [2048.0, 1024.0]);
for &box_ar in &[0.35, 1.0, 2.4] {
let (u0, v0, u1, v1) = cover_crop_uv(cam, tex, box_ar);
assert!(u0 >= 0.0 && v0 >= 0.0, "coupe hors image: {u0},{v0}");
assert!(u1 <= cam[0] / tex[0] + 1e-6, "u1 {u1} deborde la largeur visible");
assert!(v1 <= cam[1] / tex[1] + 1e-6, "v1 {v1} deborde la hauteur visible");
let (mx, my) = (u0 + u1, v0 + v1);
assert!((mx - cam[0] / tex[0]).abs() < 1e-6, "pas centre en x");
assert!((my - cam[1] / tex[1]).abs() < 1e-6, "pas centre en y");
}
}
/// L'écran en layout bloc : le cover s'applique au rect DÉJÀ réduit par le crop
/// et le zoom. Quel que soit ce rect de départ, ce qui atterrit dans la boîte a
/// le ratio de la boîte — c'est ce qui empêche l'étirement.
#[test]
fn cover_uv_rect_gives_the_box_aspect_whatever_the_crop_and_zoom_left() {
let tex = [2048.0, 1024.0];
// rects source plausibles : plein cadre, bande verticale (crop portrait), zoom serré
for &uv in &[
[0.0, 0.0, 0.9375, 0.7031],
[0.41, 0.04, 0.55, 0.67],
[0.30, 0.20, 0.55, 0.45],
] {
for &box_ar in &[0.4, 0.75, 1.0, 1.9, 3.2] {
let out = cover_uv_rect(uv, tex, box_ar);
let got = ((out[2] - out[0]) * tex[0]) / ((out[3] - out[1]) * tex[1]);
assert!(
(got - box_ar).abs() / box_ar < 1e-3,
"uv {uv:?} boite {box_ar} -> ratio {got}",
);
// le cover RÉDUIT : il ne va jamais chercher des pixels hors du rect source
assert!(out[0] >= uv[0] - 1e-6 && out[1] >= uv[1] - 1e-6, "deborde en haut/gauche");
assert!(out[2] <= uv[2] + 1e-6 && out[3] <= uv[3] + 1e-6, "deborde en bas/droite");
}
}
}
/// Propriété de sûreté : quand la boîte a DÉJÀ le ratio de la source (tous les
/// placements qui étaient corrects — PiP par défaut, vertical-stack, et le
/// center-crop carré de square/circle), la coupe est la frame entière. Le
/// correctif ne peut donc pas déplacer un pixel de ces cas-là.
#[test]
fn cover_crop_is_the_whole_frame_when_the_box_already_matches() {
let (cam, tex) = ([1280.0, 720.0], [2048.0, 1024.0]);
let uv = cover_crop_uv(cam, tex, cam[0] / cam[1]);
assert!((uv.0).abs() < 1e-6 && (uv.1).abs() < 1e-6);
assert!((uv.2 - cam[0] / tex[0]).abs() < 1e-6);
assert!((uv.3 - cam[1] / tex[1]).abs() < 1e-6);
// et une boîte carrée sur une source 4:3 redonne bien le center-crop carré
// que l'ancien branchement `is_square_shape` codait à la main.
let (su0, _, su1, _) = cover_crop_uv([960.0, 720.0], tex, 1.0);
assert!((su0 - (960.0 - 720.0) * 0.5 / tex[0]).abs() < 1e-6);
assert!((su1 - (960.0 + 720.0) * 0.5 / tex[0]).abs() < 1e-6);
}
#[test]
fn webcam_crop_identity_keeps_the_full_visible_frame() {
let uv = webcam_source_rect([1280.0, 720.0], [2048.0, 1024.0], None, 16.0 / 9.0);
assert_rect(uv, [0.0, 0.0, 1280.0 / 2048.0, 720.0 / 1024.0]);
}
#[test]
fn webcam_crop_applies_authored_zoom_and_pan_before_layout_cover() {
let crop = SceneCrop {
x: 0.25,
y: 0.20,
width: 0.50,
height: 0.60,
};
let uv = webcam_source_rect([100.0, 100.0], [100.0, 100.0], Some(crop), 0.50 / 0.60);
assert_rect(uv, [0.25, 0.20, 0.75, 0.80]);
}
#[test]
fn cursor_tap_weight_sums_to_one_and_is_monotonically_increasing() {
assert_eq!(cursor_tap_weight(0, 1), 1.0);
for taps in [2, 4, 8, 11, 16] {
let mut sum = 0.0;
let mut prev_w = 0.0;
for k in 0..taps {
let w = cursor_tap_weight(k, taps);
assert!(w > 0.0, "poids positif");
if k > 0 {
assert!(w > prev_w, "tête plus marquée que la queue : {w} > {prev_w}");
}
prev_w = w;
sum += w;
}
assert!((sum - 1.0).abs() < 1e-5, "somme des poids = 1.0 pour taps={taps}, got {sum}");
}
}
/// Écran droit plein cadre, sans zoom : le curseur y tombe toujours dans le rect source.
fn full_frame_geometry() -> FrameGeometry {
FrameGeometry {
scene_preset: None,
webcam_shadow: 1.0,
mb_taps: 1.0,
mb_amount: 0.0,
source_t: 0.0,
programme_t: 0.0,
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],
content_cut: [0.0, 0.0, 1.0, 1.0],
fill_tilt: false,
focus_plane: [0.5, 0.5],
depth_of_field: false,
s_dst: [0.0, 0.0, 1.0, 1.0],
s_dst_prev: [0.0, 0.0, 1.0, 1.0],
s_ann: [0.0, 0.0, 1.0, 1.0],
s_radius: 0.0,
frame_min_px: 1080.0,
screen_unit_px: 1080.0,
w_dst: [0.0, 0.0, 0.0, 0.0],
w_dst_prev: [0.0, 0.0, 0.0, 0.0],
w_px: [0.0, 0.0],
w_radius: 0.0,
shape_fade: 0.0,
window_frame: None,
screen_mask: None,
}
}
#[test]
fn plan_cursor_motion_blur_adaptive_and_stationary() {
let cfg = crate::config::all().pop().expect("cfg");
let track_immobile = crate::cursor::CursorTrack::new(
vec![(0.0, 0.5, 0.5), (2.0, 0.5, 0.5)],
vec![],
vec![],
);
let track_moving = crate::cursor::CursorTrack::new(
vec![(0.0, 0.1, 0.1), (1.0, 0.9, 0.9)],
vec![],
vec![],
);
let scene = zoomed_golden_scene();
let fg = full_frame_geometry();
// 1. Curseur immobile avec blur actif -> taps = 1
let live_with_blur = LiveParams {
cursor_motion_blur: 0.8,
..LiveParams::default()
};
let input_immobile = CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: live_with_blur,
scene: Some(&scene),
track: &track_immobile,
t: 0.5,
};
let plan = plan_cursor(&fg, &input_immobile).expect("plan cursor");
assert_eq!(plan.taps, 1, "curseur immobile doit rester à 1 tap");
// 2. Curseur avec blur = 0 -> taps = 1
let live_no_blur = LiveParams {
cursor_motion_blur: 0.0,
..LiveParams::default()
};
let input_no_blur = CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: live_no_blur,
scene: Some(&scene),
track: &track_moving,
t: 0.5,
};
let plan = plan_cursor(&fg, &input_no_blur).expect("plan cursor");
assert_eq!(plan.taps, 1, "blur=0 doit donner taps = 1");
// 3. Curseur en mouvement rapide avec blur -> taps adaptatifs entre 2 et 16
let input_moving = CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: live_with_blur,
scene: Some(&scene),
track: &track_moving,
t: 0.5,
};
let plan = plan_cursor(&fg, &input_moving).expect("plan cursor");
assert!(plan.taps >= 2 && plan.taps <= 16, "taps adaptatifs dans [2, 16], got {}", plan.taps);
}
/// clickBounce au maximum du slider (5) : le creux de la pression donnerait 1 - 0.24 * 5 < 0.
/// La taille ne doit jamais devenir négative ; au creux, rien n'est dessiné.
#[test]
fn plan_cursor_never_yields_a_negative_size_at_max_bounce() {
let cfg = crate::config::all().pop().expect("cfg");
let scene = zoomed_golden_scene();
let fg = full_frame_geometry();
let track = crate::cursor::CursorTrack::new(
vec![(0.0, 0.5, 0.5), (2.0, 0.5, 0.5)],
vec![0.5],
vec![],
);
let plan_at = |t: f32| {
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams { cursor_bounce_scale: 5.0, ..LiveParams::default() },
scene: Some(&scene),
track: &track,
t,
},
)
};
for ms in 450..=800 {
let t = ms as f32 / 1000.0;
if let Some(plan) = plan_at(t) {
assert!(plan.size_px > 0.0, "taille {} à t = {t}", plan.size_px);
}
}
let rest = plan_at(0.45).expect("hors fenêtre de clic").size_px;
assert!(plan_at(0.5 + 0.0494).is_none(), "au creux, le sprite est réduit à rien");
let peak = plan_at(0.5 + 0.1794).expect("au pic").size_px;
assert!((peak / rest - 1.8).abs() < 1e-3, "pic = 1 + 0.16 * 5, got {}", peak / rest);
}
/// Un plan de curseur immobile sous la rotation `rot`, coupe fixe.
fn plan_with(rot: [f32; 3]) -> CursorPlan {
let cfg = crate::config::all().pop().expect("cfg");
let scene = zoomed_golden_scene();
let fg = FrameGeometry { zoom_rotation: rot, ..full_frame_geometry() };
let track =
crate::cursor::CursorTrack::new(vec![(0.0, 0.4, 0.6), (2.0, 0.4, 0.6)], vec![], vec![]);
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams::default(),
scene: Some(&scene),
track: &track,
t: 0.5,
},
)
.expect("plan cursor")
}
const LEFT: [f32; 3] = [-12.0, -18.0, -2.0];
const RIGHT: [f32; 3] = [-12.0, 18.0, 2.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`.
#[test]
fn cursor_sprite_cb_is_byte_identical_to_the_flat_sprite() {
fn before(
p: CursorPlacement,
pw: f32,
ph: f32,
hotspot: [f32; 2],
a: f32,
clip: [f32; 4],
) -> LayerCB {
let CursorPlacement::Tilted { plane_pt, quad, center_px, screen_px, render_px } = p
else {
unreachable!()
};
let (wf, hf) = (pw / screen_px[0], ph / screen_px[1]);
let x0 = plane_pt[0] - hotspot[0] * wf;
let y0 = plane_pt[1] - hotspot[1] * hf;
let corners =
[(x0, y0), (x0 + wf, y0), (x0 + wf, y0 + hf), (x0, y0 + hf)].map(|(fx, fy)| {
let (px, py) = quad.point_px(fx, fy);
(center_px[0] + px, center_px[1] + py)
});
let (min_x, max_x) = corners
.iter()
.fold((f32::MAX, f32::MIN), |(mn, mx), &(x, _)| (mn.min(x), mx.max(x)));
let (min_y, max_y) = corners
.iter()
.fold((f32::MAX, f32::MIN), |(mn, mx), &(_, y)| (mn.min(y), mx.max(y)));
let (bw, bh) = ((max_x - min_x).max(1.0), (max_y - min_y).max(1.0));
let local = |(x, y): (f32, f32)| [x - min_x, y - min_y];
let [tl0, tl1] = local(corners[0]);
let [tr0, tr1] = local(corners[1]);
let [br0, br1] = local(corners[2]);
let [bl0, bl1] = local(corners[3]);
let (rw, rh) = (render_px[0], render_px[1]);
LayerCB {
dst: [min_x / rw, min_y / rh, bw / rw, bh / rh],
quad_px: [bw, bh],
mode: 13.0,
color: [1.0, 1.0, 1.0, a],
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)`, 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 [LEFT, RIGHT] {
let plan = plan_with(rot);
let clip = [0.1, 0.2, 0.7, 0.6];
let got = cursor_sprite_cb(
plan.placement,
[30.0, 34.0],
[0.2, 0.1],
0.8,
clip,
[1920.0, 1080.0],
);
let want = before(plan.placement, 30.0, 34.0, [0.2, 0.1], 0.8, clip);
assert_eq!(bytes(&got), bytes(&want), "rotation {rot:?}");
}
}
// ---- Curseur modélisé (mode 15) ----
/// Les seize états du thème par défaut et leurs hotspots (`DEFAULT_CURSOR_SPRITES`,
/// `src/lib/cursor/cursorThemes.ts`).
const DEFAULT_SPRITES: [(&str, [f32; 2]); 16] = [
("arrow", [0.1205, 0.0881]),
("text", [0.4355, 0.5369]),
("pointer", [0.3874, 0.0032]),
("crosshair", [0.4667, 0.4667]),
("open-hand", [0.4375, 0.1724]),
("closed-hand", [0.3889, 0.4455]),
("resize-ew", [0.485, 0.4706]),
("resize-ns", [0.5, 0.5]),
("resize-nesw", [0.5, 0.5]),
("resize-nwse", [0.5, 0.5]),
("move", [0.4437, 0.4437]),
("not-allowed", [0.5, 0.5]),
("wait", [0.5, 0.5]),
("app-starting", [0.05, 0.0537]),
("help", [0.0515, 0.0572]),
("up-arrow", [0.5, 0.069]),
];
/// Les états qu'on fait passer par les tests géométriques : pointeurs, centrés, entre deux.
const MODEL_STATES: [&str; 8] =
["arrow", "pointer", "up-arrow", "open-hand", "text", "resize-ew", "not-allowed", "closed-hand"];
fn hotspot_of(key: &str) -> [f32; 2] {
DEFAULT_SPRITES.iter().find(|(k, _)| *k == key).expect("état connu").1
}
fn sprite_path(key: &str) -> String {
format!("{}/../../public/cursors/default/{key}.png", env!("CARGO_MANIFEST_DIR")).replace('\\', "/")
}
/// Le champ du sprite livré et sa forme, hotspot de la scène posé.
fn sprite_model(key: &str) -> (crate::cursor_sdf::CursorSdf, SpriteShape) {
let sdf = crate::cursor_sdf::CursorSdf::load(&sprite_path(key)).expect("sprite livré");
let shape = SpriteShape { hotspot: hotspot_of(key), ..sdf.shape };
(sdf, shape)
}
/// Miroir CPU de `sd_sprite2` des shaders : le champ dans le rect du sprite, la borne le long
/// de la normale hors de lui.
fn sd2(sdf: &crate::cursor_sdf::CursorSdf, shape: SpriteShape, p: [f32; 2]) -> f32 {
let [x0, y0] = shape.origin();
let c = [p[0].clamp(x0, x0 + shape.size[0]), p[1].clamp(y0, y0 + shape.size[1])];
let d = sdf.sample([(c[0] - x0) / shape.size[0], (c[1] - y0) / shape.size[1]]);
let o = (p[0] - c[0]).hypot(p[1] - c[1]);
if o > 0.0 { o.hypot(d.max(0.0)) } else { d }
}
/// Miroir CPU de `sd_model`.
fn sd_model(sdf: &crate::cursor_sdf::CursorSdf, shape: SpriteShape, p: [f32; 3]) -> f32 {
let half_t = shape.thick * 0.5;
let w = [sd2(sdf, shape, [p[0], p[1]]) + MODEL_BEVEL, (p[2] + half_t).abs() - (half_t - MODEL_BEVEL)];
w[0].max(w[1]).min(0.0) + w[0].max(0.0).hypot(w[1].max(0.0)) - MODEL_BEVEL
}
/// Repère du plan → modèle (vecteurs) : l'inverse de `ModelView::model_to_plane`.
fn plane_to_model(v: [f32; 3], pose: CursorPose) -> [f32; 3] {
let (cp, sp) = (pose.pitch.cos(), pose.pitch.sin());
let (cy, sy) = (pose.yaw.cos(), pose.yaw.sin());
let (x, y) = (v[0] * cy + v[1] * sy, -v[0] * sy + v[1] * cy);
[x, y * cp + v[2] * sp, -y * sp + v[2] * cp]
}
/// Miroir CPU de l'ombre du mode 15 en un point `g` du plan (px du plan) : opacité 0..1.
fn model_shadow_at(view: &ModelView, sdf: &crate::cursor_sdf::CursorSdf, g: [f32; 2]) -> f32 {
let (pose, shape) = (view.pose, view.shape);
let q = plane_to_model(
[(g[0] - view.tip[0]) / view.unit, (g[1] - view.tip[1]) / view.unit, -view.tip[2] / view.unit],
pose,
);
let l = plane_to_model(view.light(), pose);
let (lo, hi) = shape.model_box();
let (mut t0, mut t1) = (f32::MIN, f32::MAX);
for k in 0..3 {
let inv = 1.0 / if l[k].abs() > 1e-6 { l[k] } else { 1e-6 };
let (a, b) = ((lo[k] - MODEL_SHADOW_PAD - q[k]) * inv, (hi[k] + MODEL_SHADOW_PAD - q[k]) * inv);
t0 = t0.max(a.min(b));
t1 = t1.min(a.max(b));
}
let mut lit = 1.0f32;
if t0 < t1 && t1 > 0.0 {
let mut t = t0.max(0.004);
for _ in 0..32 {
let d = sd_model(sdf, shape, [q[0] + l[0] * t, q[1] + l[1] * t, q[2] + l[2] * t]);
lit = lit.min(MODEL_SOFTNESS * d / t);
if lit < 0.002 || t > t1 {
break;
}
t += d.clamp(0.01, 0.2);
}
let r = lit.clamp(0.0, 1.0);
lit = r * r * (3.0 - 2.0 * r);
}
let u = (sd_model(sdf, shape, q) / MODEL_CONTACT_RADIUS).clamp(0.0, 1.0);
let contact = 1.0 - u * u * (3.0 - 2.0 * u);
((1.0 - lit) * 0.5).max(contact * 0.5)
}
/// Le point le plus bas du modèle posé, en unités au-dessus du plan. Pour un tangage ≥ 0, le
/// plus bas d'une colonne (x, y) pleine est le bas de sa colonne : l'épaisseur sous le plat
/// du dessous, relevé sur le chanfrein (`sd_model`, résolu en z).
fn lowest_point(view: &ModelView, sdf: &crate::cursor_sdf::CursorSdf) -> f32 {
let shape = view.shape;
let [x0, y0] = shape.origin();
let n = 400;
let mut lowest = f32::MAX;
for i in 0..=n {
for j in 0..=n {
let (x, y) = (x0 + shape.size[0] * i as f32 / n as f32, y0 + shape.size[1] * j as f32 / n as f32);
let s = sd2(sdf, shape, [x, y]);
if s >= 0.0 {
continue;
}
let wx = (s + MODEL_BEVEL).max(0.0);
let z = -shape.thick + MODEL_BEVEL - (MODEL_BEVEL * MODEL_BEVEL - wx * wx).sqrt();
lowest = lowest.min(view.model_to_plane([x, y, z])[2]);
}
}
lowest / view.unit
}
/// La scène dorée, thème par défaut, avec les seize sprites livrés.
fn model_scene() -> Scene {
let mut scene = zoomed_golden_scene();
scene.cursor.theme = "default".into();
for (key, [hx, hy]) in DEFAULT_SPRITES {
scene.cursor.cursor_sprites.insert(
key.into(),
crate::scene::SceneCursorSprite {
path: sprite_path(key),
hotspot_x: hx,
hotspot_y: hy,
sculpt: None,
glass: None,
},
);
}
scene
}
fn model_plan(
rot: [f32; 3],
scene: &Scene,
track: &crate::cursor::CursorTrack,
t: f32,
model3d: bool,
) -> Option<CursorPlan> {
let cfg = crate::config::all().pop().expect("cfg");
let fg = FrameGeometry { zoom_rotation: rot, ..full_frame_geometry() };
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams {
cursor_model3d: model3d,
cursor_bounce_scale: MODEL_CLICK_BOUNCE_REF,
..LiveParams::default()
},
scene: Some(scene),
track,
t,
},
)
}
/// Immobile en (0.4, 0.6), dans l'état `kind` (`None` = la flèche), avec ces clics.
fn still_track_as(kind: Option<&str>, clicks: Vec<f32>) -> crate::cursor::CursorTrack {
let types = kind.map(|k| vec![(0.0, k.to_string())]).unwrap_or_default();
crate::cursor::CursorTrack::new(vec![(0.0, 0.4, 0.6), (4.0, 0.4, 0.6)], clicks, types)
}
fn still_track(clicks: Vec<f32>) -> crate::cursor::CursorTrack {
still_track_as(None, clicks)
}
/// Le creux de `tap` : le contact que le modèle partage avec le rebond et l'impact du clic.
const CONTACT_S: f32 = 0.0495;
#[test]
fn the_model_pose_is_a_pure_function_of_time() {
let track = crate::cursor::CursorTrack::new(
vec![(0.0, 0.2, 0.5), (0.9, 0.3, 0.5), (1.0, 0.7, 0.4), (3.0, 0.7, 0.4)],
vec![1.05, 1.4],
vec![],
);
let times: Vec<f32> = (0..400).map(|k| k as f32 * 0.00731).collect();
let forward: Vec<CursorPose> = times.iter().map(|&t| cursor_pose(&track, t, MODEL_CLICK_BOUNCE_REF, 1.0)).collect();
let backward: Vec<CursorPose> =
times.iter().rev().map(|&t| cursor_pose(&track.clone(), t, MODEL_CLICK_BOUNCE_REF, 1.0)).collect();
assert!(forward.iter().eq(backward.iter().rev()), "l'ordre d'évaluation change la pose");
// Continue : pas de saut d'une milliseconde à l'autre, même autour des clics.
for k in 0..2999 {
let (a, b) = (k as f32 * 0.001, (k + 1) as f32 * 0.001);
let (p, q) = (cursor_pose(&track, a, MODEL_CLICK_BOUNCE_REF, 1.0), cursor_pose(&track, b, MODEL_CLICK_BOUNCE_REF, 1.0));
assert!((p.yaw - q.yaw).abs() < 0.02, "lacet discontinu en {a} : {} -> {}", p.yaw, q.yaw);
assert!((p.clearance - q.clearance).abs() < 0.03, "hauteur discontinue en {a}");
}
}
/// Le geste du clic, en vraie profondeur : élan au-dessus du survol pointe relevée, plongée
/// pointe la première jusqu'à toucher le plan AU clic, appui sur l'instant du contact que lisent
/// le plan et le rebond d'échelle, remontée au-delà du survol, repos. Animé sur une vingtaine
/// d'images à 30 i/s ; le niveau le règle, et « None » ne bouge pas.
#[test]
fn the_model_dives_onto_the_click() {
let track = still_track(vec![0.5]);
let at = |ms: f32, level: f32| cursor_pose(&track, 0.5 + ms / 1000.0, level, 1.0);
let rest = at(-400.0, 1.0);
assert_eq!(rest.clearance, MODEL_HOVER);
assert!((rest.pitch - MODEL_PITCH_IDLE_DEG.to_radians()).abs() < 1e-6);
assert_eq!(rest.yaw, 0.0, "immobile : pas de lacet");
let peak = at(-120.0, 1.0);
assert!(peak.clearance > 1.8 * MODEL_HOVER && peak.pitch < rest.pitch, "élan : {peak:?}");
let down = at(0.0, 1.0);
assert_eq!(down.clearance, 0.0, "au clic, le modèle touche le plan");
assert!(down.pitch > rest.pitch + 5f32.to_radians(), "il plonge la pointe la première");
for ms in 0..=75 {
assert_eq!(at(ms as f32, 1.0).clearance, 0.0, "posé à {ms} ms");
}
let press = (0..260).min_by(|&a, &b| {
track.bounce(0.5 + a as f32 / 1000.0).total_cmp(&track.bounce(0.5 + b as f32 / 1000.0))
});
assert_eq!(at(press.expect("un creux") as f32, 1.0).clearance, 0.0, "au creux du rebond 2D");
assert!(at(200.0, 1.0).clearance > MODEL_HOVER, "il remonte au-delà du survol");
assert_eq!(at(450.0, 1.0), rest);
// Animé : à 30 i/s, une vingtaine d'images différentes, dont trois pendant la plongée.
let frames: Vec<f32> = (0..24).map(|k| at(-300.0 + k as f32 * 1000.0 / 30.0, 1.0).clearance).collect();
assert!(frames.windows(2).filter(|w| w[0] != w[1]).count() >= 18, "{frames:?}");
assert!((1..4).all(|k| { let c = at(-k as f32 * 1000.0 / 30.0, 1.0).clearance; c > 0.0 && c < peak.clearance }));
// « None » ne bouge pas ; « Strong » monte et rebondit plus haut, plonge plus vite et plus penché.
for ms in -350..450 {
assert_eq!(at(ms as f32, 0.0), rest, "None, {ms} ms");
}
let top = |level: f32, from: i32, to: i32| (from..to).map(|ms| at(ms as f32, level).clearance).fold(0.0, f32::max);
assert!(top(2.0, -300, 0) > top(1.0, -300, 0) + 0.15, "élan plus haut");
assert!(top(2.0, 80, 450) > top(1.0, 80, 450) + 0.1, "rebond plus haut");
assert!(at(0.0, 2.0).pitch > down.pitch + 5f32.to_radians(), "plus penché au contact");
assert!(at(-90.0, 2.0).clearance > at(-90.0, 1.0).clearance, "plongée plus tardive, donc plus vive");
// Un double clic ne remonte pas entre les deux : le geste le plus bas l'emporte.
let double = still_track(vec![0.5, 0.62]);
for ms in 0..200 {
assert!(cursor_pose(&double, 0.5 + ms as f32 / 1000.0, 1.0, 1.0).clearance <= MODEL_HOVER, "{ms} ms");
}
}
/// « Posé » veut dire posé, pour chaque état : au repos le point le plus bas du modèle est à
/// la garde au sol (jamais sous le plan), au contact il affleure le plan à 2 % de l'unité.
#[test]
fn every_state_rests_above_the_plane_and_touches_it_on_click() {
let scene = model_scene();
for key in MODEL_STATES {
let (sdf, shape) = sprite_model(key);
for rot in [[0.0; 3], LEFT] {
let track = still_track_as(Some(key), vec![0.5]);
// Au repos avant l'élan du clic, puis au contact.
for (t, want) in [(0.1, MODEL_HOVER), (0.5 + CONTACT_S, 0.0)] {
let plan = model_plan(rot, &scene, &track, t, true).expect("plan");
let pose = plan.model.expect("modèle");
let view = ModelView::new(plan.placement, plan.size_px, pose, shape).expect("vue");
let gap = lowest_point(&view, &sdf) - want;
println!("{key} {rot:?} t={t}: point le plus bas à {want} + {gap:.4} u");
assert!((-0.002..0.02).contains(&gap), "{key} {rot:?} t={t}: écart {gap} u");
}
}
}
}
#[test]
fn the_model_leans_towards_its_motion_and_its_click_target() {
let still = still_track(vec![]);
assert_eq!(cursor_pose(&still, 1.0, MODEL_CLICK_BOUNCE_REF, 1.0).yaw, 0.0);
let right = crate::cursor::CursorTrack::new(vec![(0.0, 0.1, 0.5), (2.0, 0.9, 0.5)], vec![], vec![]);
let left = crate::cursor::CursorTrack::new(vec![(0.0, 0.9, 0.5), (2.0, 0.1, 0.5)], vec![], vec![]);
let (r, l) = (cursor_pose(&right, 1.0, MODEL_CLICK_BOUNCE_REF, 1.0).yaw, cursor_pose(&left, 1.0, MODEL_CLICK_BOUNCE_REF, 1.0).yaw);
assert!(r > 5f32.to_radians() && (r + l).abs() < 1e-5, "droite {r}, gauche {l}");
let fast = crate::cursor::CursorTrack::new(vec![(0.0, 0.0, 0.5), (0.2, 1.0, 0.5)], vec![], vec![]);
let y = cursor_pose(&fast, 0.1, MODEL_CLICK_BOUNCE_REF, 1.0).yaw;
assert!(y <= MODEL_YAW_MAX_DEG.to_radians() + 1e-6 && y > 20f32.to_radians(), "{y}");
// Arrivée sur une cible à droite puis clic : juste avant, le modèle se tourne vers elle
// plus que la même arrivée sans clic ; au repos, longtemps après, le lacet revient à 0.
// Échantillonnée à 30 Hz comme la télémétrie : la piste de suivi lissée n'interpole pas
// à travers des trous de plusieurs secondes.
let samples: Vec<(f32, f32, f32)> = (0..120)
.map(|k| {
let t = k as f32 / 30.0;
(t, if t < 0.9 { 0.3 } else { 0.3 + 0.4 * ((t - 0.9) / 0.1).min(1.0) }, 0.5)
})
.collect();
let clicked = crate::cursor::CursorTrack::new(samples.clone(), vec![1.1], vec![]);
let quiet = crate::cursor::CursorTrack::new(samples, vec![], vec![]);
assert!(cursor_pose(&clicked, 1.05, MODEL_CLICK_BOUNCE_REF, 1.0).yaw > cursor_pose(&quiet, 1.05, MODEL_CLICK_BOUNCE_REF, 1.0).yaw + 1e-3);
assert!(cursor_pose(&clicked, 3.5, MODEL_CLICK_BOUNCE_REF, 1.0).yaw.abs() < 1e-3);
// À « None », le clic ne fait rien tourner : seul le mouvement compte.
assert_eq!(cursor_pose(&clicked, 1.05, 0.0, 1.0).yaw, cursor_pose(&quiet, 1.05, 0.0, 1.0).yaw);
}
/// Les pointeurs penchent et tournent comme la flèche ; les curseurs centrés restent à plat et
/// de face, mais montent et descendent pareil.
#[test]
fn pointing_states_lean_and_centred_states_stay_level() {
for (key, hotspot) in DEFAULT_SPRITES {
let f = pointing_factor(hotspot);
match key {
"arrow" | "pointer" | "help" | "app-starting" | "up-arrow" => assert_eq!(f, 1.0, "{key}"),
"open-hand" => assert!(f > 0.5 && f < 1.0, "{key}: {f}"),
_ => assert_eq!(f, 0.0, "{key}"),
}
}
let moving = crate::cursor::CursorTrack::new(
vec![(0.0, 0.1, 0.5), (2.0, 0.9, 0.5)],
vec![1.0 - CONTACT_S],
vec![],
);
let (full, level) = (cursor_pose(&moving, 1.0, MODEL_CLICK_BOUNCE_REF, 1.0), cursor_pose(&moving, 1.0, MODEL_CLICK_BOUNCE_REF, 0.0));
assert!(full.pitch > 0.3 && full.yaw > 0.05, "{full:?}");
assert_eq!((level.pitch, level.yaw), (0.0, 0.0));
assert_eq!(level.clearance, full.clearance);
let half = cursor_pose(&moving, 1.0, MODEL_CLICK_BOUNCE_REF, 0.5);
assert!((half.pitch - full.pitch * 0.5).abs() < 1e-6 && (half.yaw - full.yaw * 0.5).abs() < 1e-6);
// À plat, le lift est l'épaisseur : toute la face du dessous est au sol.
let (_, text) = sprite_model("text");
assert_eq!(text.contact_lift(0.0), MODEL_THICK);
}
#[test]
fn every_default_state_is_modelled() {
let scene = model_scene();
let track = still_track(vec![0.5]);
let off = model_plan([0.0; 3], &scene, &track, 0.3, false).expect("plan");
assert!(off.model.is_none());
assert!(matches!(off.placement, CursorPlacement::Upright { .. }), "réglage éteint : mode 7");
let on = model_plan([0.0; 3], &scene, &track, 0.3, true).expect("plan");
assert_eq!(on.model, Some(cursor_pose(&track, 0.3, MODEL_CLICK_BOUNCE_REF, 1.0)));
let CursorPlacement::Tilted { quad, .. } = on.placement else { panic!("écran droit : plan identité") };
assert_eq!((quad.scale, quad.rot), (1.0, [0.0; 3]));
// Pas de rebond d'échelle en 3D : la taille au creux du clic est celle du repos.
let press = model_plan([0.0; 3], &scene, &track, 0.5 + CONTACT_S, true).expect("plan");
assert_eq!(press.size_px, on.size_px);
let flat_press = model_plan([0.0; 3], &scene, &track, 0.5 + CONTACT_S, false).expect("plan");
assert!(flat_press.size_px < off.size_px, "le sprite plat garde son rebond");
// Chaque état du thème, avec la pose de son hotspot.
for (key, hotspot) in DEFAULT_SPRITES {
let typed = still_track_as(Some(key), vec![]);
let plan = model_plan([0.0; 3], &scene, &typed, 0.3, true).expect("plan");
assert_eq!(plan.model, Some(cursor_pose(&typed, 0.3, MODEL_CLICK_BOUNCE_REF, pointing_factor(hotspot))), "{key}");
assert_eq!(plan.cursor_type.as_deref(), Some(key));
}
// Un état sans sprite retombe sur la flèche, donc sur sa pose.
let unknown = still_track_as(Some("zoom-in"), vec![]);
assert_eq!(
model_plan([0.0; 3], &scene, &unknown, 0.3, true).expect("plan").model,
Some(cursor_pose(&unknown, 0.3, MODEL_CLICK_BOUNCE_REF, 1.0))
);
// Un thème d'origine passe sa flèche sculptée : c'est elle que le mode 3D pose, le sprite
// plat restant l'art en 2D.
let mut themed = model_scene();
themed.cursor.theme = "studio-ink".into();
let themed_arrow = crate::scene::SceneCursorSprite {
path: "studio-ink/arrow.png".into(),
hotspot_x: 0.1947,
hotspot_y: 0.0656,
sculpt: Some("studio-ink/arrow".into()),
glass: None,
};
themed.cursor.cursor_sprites.insert("arrow".into(), themed_arrow.clone());
assert_eq!(
modelled_sprite(Some(&themed), None).and_then(|sprite| sprite.sculpt.as_deref()),
Some("studio-ink/arrow")
);
assert!(model_plan([0.0; 3], &themed, &track, 0.3, true).expect("plan").model.is_some());
// Sans aucun sprite résolu, il n'y a pas de modèle à dessiner.
let bare = zoomed_golden_scene();
assert!(model_plan([0.0; 3], &bare, &track, 0.3, true).expect("plan").model.is_none());
}
/// Glass Lens est de verre 3D éteinte aussi : le plan demande la copie de l'image composée
/// sans modèle (le verre à plat), puis avec lui (sa lentille sculptée). Le thème par défaut
/// n'a rien à réfracter.
#[test]
fn the_glass_lens_is_glass_with_and_without_3d() {
let track = still_track(vec![]);
let mut scene = model_scene();
scene.cursor.theme = "glass-lens".into();
let arrow = crate::scene::SceneCursorSprite {
path: "glass-lens/arrow.png".into(),
hotspot_x: 0.3045,
hotspot_y: 0.0255,
sculpt: Some("glass-lens/arrow".into()),
glass: Some("glass-lens/arrow".into()),
};
scene.cursor.cursor_sprites.insert("arrow".into(), arrow);
let flat = model_plan([0.0; 3], &scene, &track, 0.3, false).expect("plan");
assert!(flat.model.is_none() && flat.glass, "3D éteinte : le verre à plat");
let modelled = model_plan([0.0; 3], &scene, &track, 0.3, true).expect("plan");
assert!(modelled.model.is_some() && modelled.glass, "3D : la lentille sculptée");
let plain = model_plan([0.0; 3], &model_scene(), &track, 0.3, false).expect("plan");
assert!(!plain.glass);
}
/// Le verre à plat (mode 19) pose la boîte du modèle sculpté comme le sprite plat pose le
/// sien : son hotspot au point visé, son plus grand côté à `size_px`, ses coins sous la forme
/// du mode 13 et le clip dans `dst_prev`. Il porte le modèle et l'unité qui règle la
/// réfraction ; un nom qui n'est pas un modèle n'a pas de verre.
#[test]
fn the_flat_glass_layer_sits_the_model_box_on_the_hotspot() {
let render = [1920.0, 1080.0];
let (clip, center) = ([0.1, 0.2, 0.7, 0.6], [0.5, 0.4]);
let place = CursorPlacement::Upright { center };
let cb = cursor_glass_cb(place, 100.0, "glass-lens/arrow", 0.8, clip, render).expect("modèle");
let shape = crate::sculpt::sculpted_shape("glass-lens/arrow").unwrap();
assert_eq!(cb.mode, 19.0);
assert!(cb.needs_models());
assert_eq!((cb.dst_prev, cb.trail_a[0], cb.color[3]), (clip, shape.sculpt as f32, 0.8));
let [w, h] = [shape.size[0] * 100.0, shape.size[1] * 100.0];
assert!((cb.quad_px[0] - w).abs() < 1e-3 && (cb.quad_px[1] - h).abs() < 1e-3);
assert_eq!(cb.fx, [0.0, 0.0, cb.quad_px[0], 0.0]);
assert_eq!(cb.src_prev, [cb.quad_px[0], cb.quad_px[1], 0.0, cb.quad_px[1]]);
let tip = [cb.dst[0] * render[0] + shape.hotspot[0] * w, cb.dst[1] * render[1] + shape.hotspot[1] * h];
assert!((tip[0] - center[0] * render[0]).abs() < 1e-2, "{tip:?}");
assert!((tip[1] - center[1] * render[1]).abs() < 1e-2, "{tip:?}");
assert!((cb.color[2] - 100.0).abs() < 1e-3);
assert!((cb.src[0] - 100.0 / render[0]).abs() < 1e-6 && (cb.src[1] - 100.0 / render[1]).abs() < 1e-6);
assert!(cursor_glass_cb(place, 100.0, "studio-ink/text", 0.8, clip, render).is_none());
}
/// 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)> {
let scene = model_scene();
let mut out = Vec::new();
for key in MODEL_STATES {
let clicked = still_track_as(Some(key), vec![0.5]);
let moving = crate::cursor::CursorTrack::new(
vec![(0.0, 0.1, 0.6), (2.0, 0.9, 0.6)],
vec![],
vec![(0.0, key.to_string())],
);
for (name, rot) in [("flat", [0.0; 3]), ("left", LEFT), ("right", RIGHT)] {
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);
out.push((format!("{key}/{name}/{pose}"), plan, shape, sdf));
}
}
}
out
}
#[test]
fn the_modelled_hotspot_lands_on_the_content_pixel() {
for (name, plan, shape, _) in model_cases() {
let pose = plan.model.expect("modèle");
let view = ModelView::new(plan.placement, plan.size_px, pose, shape).expect("vue");
let CursorPlacement::Tilted { plane_pt, quad, center_px, .. } = plan.placement else {
unreachable!()
};
let (bx, by) = quad.point_px(plane_pt[0], plane_pt[1]);
let want = [center_px[0] + bx, center_px[1] + by];
let got = view.project(view.model_to_plane([0.0; 3])).expect("projection");
assert!(
(got[0] - want[0]).abs() < 0.02 && (got[1] - want[1]).abs() < 0.02,
"{name}: hotspot en {got:?}, contenu en {want:?}"
);
// Le cbuffer rend au shader le même rayon : `local + src.xy` au pixel du hotspot est
// la projection EXACTE du hotspot, ancrage ôté.
let cb = cursor_model_cb(plan.placement, plan.size_px, pose, shape, 1.0, [0.0; 4]).expect("cb");
assert_eq!(cb.mode, 15.0);
let local = [want[0] - cb.dst[0] * 1920.0, want[1] - cb.dst[1] * 1080.0];
let w = crate::regions::rotate_point(view.tip, view.rot);
let f = view.perspective / (view.perspective - w[2]);
assert!(
(local[0] + cb.src[0] - w[0] * f).abs() < 0.05 && (local[1] + cb.src[1] - w[1] * f).abs() < 0.05,
"{name}: le rayon du shader ne passe pas par le hotspot"
);
assert_eq!([cb.src[2], cb.src[3]], [view.perspective, view.unit]);
assert_eq!(view.unit, plan.size_px * quad.scale, "{name}: l'unité est le côté du curseur");
assert_eq!(cb.src_prev, [view.tip[0], view.tip[1], view.tip[2], pose.yaw]);
assert_eq!(cb.fx[3], pose.pitch);
assert!((cb.dst[2] * 1920.0 - cb.quad_px[0]).abs() < 1e-2);
// Le rect du sprite : sa taille se déduit de `radius_px` (w/h, plus grand côté = 1),
// comme `sprite_size()` dans les shaders, et `(p - color.rg) / taille` vaut le hotspot
// à l'origine. `mb.zw` porte la translation du plan, nulle sous un angle fixe.
let a = cb.radius_px;
let size = [a.min(1.0), (1.0 / a).min(1.0)];
let [x0, y0] = [cb.color[0], cb.color[1]];
let hotspot = [-x0 / size[0], -y0 / size[1]];
assert!((hotspot[0] - shape.hotspot[0]).abs() < 1e-6 && (hotspot[1] - shape.hotspot[1]).abs() < 1e-6);
assert!((size[0] - shape.size[0]).abs() < 1e-6 && (size[1] - shape.size[1]).abs() < 1e-6);
assert_eq!(cb.color[2], 1.0, "{name}: jamais d'écrasement");
assert_eq!([cb.mb[2], cb.mb[3]], view.offset, "{name}: translation du plan");
assert!(shape.size[0].max(shape.size[1]) == 1.0, "{name}: {:?}", shape.size);
}
}
/// Le pointeur file de `from` vers `to` à `speed` (écrans par seconde), s'y arrête `dwell` s
/// avant et après le clic `tc`, puis repart vers `away`. Échantillonné à 30 Hz comme la
/// télémétrie, plus l'échantillon du clic. Sans arrêt, la piste brute dérive déjà pendant le
/// contact.
fn approach_track(from: [f32; 2], to: [f32; 2], away: [f32; 2], speed: f32, dwell: f32, tc: f32) -> crate::cursor::CursorTrack {
let mix = |a: [f32; 2], b: [f32; 2], f: f32| (a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f);
let dist = |a: [f32; 2], b: [f32; 2]| (a[0] - b[0]).hypot(a[1] - b[1]);
let arrive = tc - dwell;
let start = arrive - dist(from, to) / speed;
let (leave, end) = (tc + dwell, tc + dwell + dist(to, away) / speed);
let pos = |t: f32| {
if t < start {
(from[0], from[1])
} else if t < arrive {
mix(from, to, (t - start) / (arrive - start))
} else if t < leave {
(to[0], to[1])
} else {
mix(to, away, ((t - leave) / (end - leave)).min(1.0))
}
};
let mut samples: Vec<(f32, f32, f32)> = (0..=120)
.map(|k| k as f32 / 30.0)
.filter(|&t| (t - tc).abs() > 1e-4)
.map(|t| (t, pos(t).0, pos(t).1))
.collect();
samples.push((tc, to[0], to[1]));
samples.sort_by(|a, b| a.0.total_cmp(&b.0));
crate::cursor::CursorTrack::new(samples, vec![tc], vec![])
}
/// Le curseur modélisé et son écran à `t`, par le chemin du rendu : `plan_frame` puis
/// `plan_cursor`, scène dorée (recadrée, zoomée) sous `rotation`.
fn model_frame(
rotation: &str,
click_impact: bool,
blur: f32,
track: &'static crate::cursor::CursorTrack,
t: f32,
) -> (FrameGeometry, Option<CursorPlan>) {
let cfg = crate::config::all().pop().expect("cfg");
let json = zoomed_golden_scene_json().replace(r#""rotation":"none""#, rotation);
let mut scene = Scene::from_json(&json).expect("scène");
scene.cursor.click_impact = click_impact;
scene.cursor.theme = "default".into();
scene.cursor.cursor_sprites = model_scene().cursor.cursor_sprites;
let live = LiveParams {
cursor_model3d: true,
cursor_bounce_scale: MODEL_CLICK_BOUNCE_REF,
cursor_motion_blur: blur,
..live_params_from_scene(&scene)
};
let g = plan_frame(&FrameGeometryInput {
cursor: Some(track),
timeline_t_override: Some(t),
frame: t * FPS,
live,
..golden_input(&scene, &cfg)
});
let plan = plan_cursor(
&g,
&CursorPlanInput {
render_px: [1170.0, 658.0],
u_max: 1.0,
v_max: 1080.0 / 1088.0,
cfg: &cfg,
live,
scene: Some(&scene),
track,
t,
},
);
(g, plan)
}
/// Le pixel où l'écran dessine la position `p` du contenu, sans passer par le curseur : la
/// coupe, puis le rect de l'écran droit ou le quad incliné (bilinéaire ou projectif).
fn content_px(g: &FrameGeometry, p: (f32, f32)) -> [f32; 2] {
let render = [1170.0, 658.0];
let [fx, fy] = cursor_plane_point(g.cut, [1.0, 1080.0 / 1088.0], p).expect("clic dans la coupe");
let s_px = [g.s_dst[2] * render[0], g.s_dst[3] * render[1]];
match g.screen_tilt(s_px) {
None => [(g.s_dst[0] + fx * g.s_dst[2]) * render[0], (g.s_dst[1] + fy * g.s_dst[3]) * render[1]],
Some(quad) => {
let (x, y) = quad.point_px(fx, fy);
[(g.s_dst[0] + g.s_dst[2] * 0.5) * render[0] + x, (g.s_dst[1] + g.s_dst[3] * 0.5) * render[1] + y]
}
}
}
/// Au contact, la pointe du curseur modélisé tombe sur le pixel du clic BRUT, à 0,5 px près :
/// quel que soit le lissage (le ressort traîne derrière la souris), la vitesse d'arrivée, un
/// départ immédiat, la caméra (impact du clic compris : l'écran droit recule, l'angle fixe
/// bascule, l'œil de la caméra réelle recule), et la traînée de flou (repliée sur la tête
/// pendant le contact).
#[test]
fn the_modelled_tip_touches_the_raw_click_pixel() {
const TC: f32 = 1.5;
let presets = [
("flat", r#""rotation":"none""#, false),
("flat+impact", r#""rotation":"none""#, true),
("iso", r#""rotation":"iso""#, true),
("left", r#""rotation":"left""#, true),
("right", r#""rotation":"right""#, true),
("follow", r#""rotation":"orbit","focusMode":"auto""#, true),
];
let (to, from, away) = ([0.3, 0.18], [0.08, 0.05], [0.45, 0.32]);
let mut worst = 0.0f32;
for (name, rotation, impact) in presets {
for smoothing in [0.0, 0.25, 0.5, 1.0] {
for speed in [0.5, 2.0] {
for dwell in [0.0, 0.15] {
let raw = approach_track(from, to, away, speed, dwell, TC);
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(raw.smoothed(smoothing)));
let mut contacts = 0;
let mut case_worst = 0.0f32;
for key in ["arrow", "pointer"] {
let (_, shape) = sprite_model(key);
let shape = SpriteShape { hotspot: hotspot_of(key), ..shape };
for k in 0..=15 {
let t = TC + 0.02 + k as f32 * 0.004;
let (g, plan) = model_frame(rotation, impact, 1.0, track, t);
let plan = plan.expect("curseur visible au contact");
let pose = plan.model.expect("modèle");
if pose.clearance > 0.0 {
continue;
}
contacts += 1;
let view = ModelView::new(plan.placement, plan.size_px, pose, shape).expect("vue");
let tip = view.project(view.model_to_plane([0.0; 3])).expect("pointe");
let want = content_px(&g, (to[0], to[1]));
let off = (tip[0] - want[0]).hypot(tip[1] - want[1]);
case_worst = case_worst.max(off);
assert_eq!(plan.taps, 1, "{name} lissage {smoothing} : traînée au contact");
}
}
println!("{name} lissage {smoothing} vitesse {speed} arrêt {dwell} : {case_worst:.3} px");
assert!(contacts >= 16, "{name}: {contacts} images au contact");
assert!(case_worst < 0.5, "{name} lissage {smoothing} vitesse {speed} arrêt {dwell} : {case_worst} px");
worst = worst.max(case_worst);
}
}
}
}
println!("pire écart au contact : {worst:.4} px");
}
/// L'impact : seulement sous le curseur modélisé, après un clic et à `clickBounce` non nul ;
/// il démarre au contact, dure 0,4 s, et son carré est centré sur le pixel du clic brut, posé
/// sur le plan (il penche avec lui).
#[test]
fn the_click_impact_rings_around_the_raw_click_pixel() {
const TC: f32 = 1.5;
let raw = approach_track([0.08, 0.05], [0.3, 0.18], [0.45, 0.32], 2.0, 0.0, TC);
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(raw.smoothed(0.5)));
let quiet: &'static crate::cursor::CursorTrack =
Box::leak(Box::new(crate::cursor::CursorTrack::new(vec![(0.0, 0.3, 0.18), (4.0, 0.3, 0.18)], vec![], vec![])));
for rotation in [r#""rotation":"none""#, r#""rotation":"iso""#, r#""rotation":"orbit","focusMode":"auto""#] {
let impacts = |track, t| model_frame(rotation, false, 0.0, track, t).1.expect("curseur").impacts;
assert!(impacts(quiet, TC + 0.1).is_empty(), "{rotation}: pas de clic, pas d'impact");
assert!(impacts(track, TC + 0.04).is_empty(), "{rotation}: avant le contact");
assert!(impacts(track, TC + IMPACT_DELAY_S + IMPACT_S + 0.001).is_empty(), "{rotation}: après");
for age in [0.06, 0.1, 0.2, 0.4] {
let (g, plan) = model_frame(rotation, false, 0.0, track, TC + age);
let cb = &plan.expect("curseur").impacts;
assert_eq!(cb.len(), 1, "{rotation} +{age}");
let cb = cb[0];
assert_eq!(cb.mode, 16.0);
// Le centre du carré (s = t = 0,5) : l'inverse du quad dans le shader.
let c = |i: usize| -> [f32; 2] {
let v = [cb.fx[0], cb.fx[1], cb.fx[2], cb.fx[3], cb.src_prev[0], cb.src_prev[1], cb.src_prev[2], cb.src_prev[3]];
[v[2 * i] + cb.dst[0] * 1170.0, v[2 * i + 1] + cb.dst[1] * 658.0]
};
let (tl, tr, br, bl) = (c(0), c(1), c(2), c(3));
let center = if cb.mb[0] > 0.5 {
let q = crate::regions::square_to_quad(&[(tl[0], tl[1]), (tr[0], tr[1]), (br[0], br[1]), (bl[0], bl[1])], 0.5, 0.5);
[q.0, q.1]
} else {
[(tl[0] + tr[0] + br[0] + bl[0]) / 4.0, (tl[1] + tr[1] + br[1] + bl[1]) / 4.0]
};
let want = content_px(&g, (0.3, 0.18));
assert!(
(center[0] - want[0]).abs() < 0.05 && (center[1] - want[1]).abs() < 0.05,
"{rotation} +{age}: impact en {center:?}, clic en {want:?}"
);
assert!(cb.src[0] > 0.0 && cb.src[0] <= 0.8 && cb.src[2] > 0.0, "{rotation} +{age}: {:?}", cb.src);
}
// L'anneau grandit et s'éteint.
let ring = |age: f32| impact_at(age, 1.0).expect("dans la fenêtre");
assert!(ring(0.1).ring_r < ring(0.3).ring_r && ring(0.1).ring_a > ring(0.3).ring_a);
assert!(ring(0.08).spot_a > 0.2 && ring(0.3).spot_a == 0.0);
}
// Réglage éteint, ou `clickBounce` nul : rien.
let cfg = crate::config::all().pop().expect("cfg");
let scene = model_scene();
let fg = full_frame_geometry();
let plan = |model3d: bool, bounce: f32| {
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams { cursor_model3d: model3d, cursor_bounce_scale: bounce, ..LiveParams::default() },
scene: Some(&scene),
track,
t: TC + 0.1,
},
)
.expect("plan")
.impacts
.len()
};
assert_eq!((plan(true, MODEL_CLICK_BOUNCE_REF), plan(false, MODEL_CLICK_BOUNCE_REF), plan(true, 0.0)), (1, 0, 0));
}
#[test]
fn the_model_box_holds_the_model_and_its_shadow() {
for (name, plan, shape, sdf) in model_cases() {
let pose = plan.model.expect("modèle");
let view = ModelView::new(plan.placement, plan.size_px, pose, shape).expect("vue");
let cb = cursor_model_cb(plan.placement, plan.size_px, pose, shape, 1.0, [0.0; 4]).expect("cb");
let (x0, y0) = (cb.dst[0] * 1920.0, cb.dst[1] * 1080.0);
let (x1, y1) = (x0 + cb.quad_px[0], y0 + cb.quad_px[1]);
let inside = |p: [f32; 2]| p[0] >= x0 && p[0] <= x1 && p[1] >= y0 && p[1] <= y1;
let (lo, hi) = shape.model_box();
let mut solid = 0;
for i in 0..=20 {
for j in 0..=30 {
for k in 0..=6 {
let q = [
lo[0] + (hi[0] - lo[0]) * i as f32 / 20.0,
lo[1] + (hi[1] - lo[1]) * j as f32 / 30.0,
lo[2] + (hi[2] - lo[2]) * k as f32 / 6.0,
];
if sd_model(&sdf, shape, q) > 0.0 {
continue;
}
solid += 1;
let p = view.project(view.model_to_plane(q)).expect("projection");
assert!(inside(p), "{name}: le point {q:?} du modèle tombe hors de la boîte");
}
}
}
assert!(solid > 100, "{name}: le modèle échantillonné est vide");
// L'ombre : tout point du plan qu'elle assombrit d'au moins 1/255 est dans la boîte.
let (step, reach) = (view.unit / 12.0, 3.0 * view.unit);
let mut shaded = 0;
for i in 0..=72 {
for j in 0..=72 {
let g = [view.tip[0] - reach + i as f32 * step, view.tip[1] - reach + j as f32 * step];
if model_shadow_at(&view, &sdf, g) < 0.5 / 255.0 {
continue;
}
shaded += 1;
let p = view.project([g[0], g[1], 0.0]).expect("projection");
assert!(inside(p), "{name}: l'ombre en {g:?} déborde de la boîte ({p:?})");
}
}
assert!(shaded > 50, "{name}: pas d'ombre échantillonnée");
}
}
/// Le backend logiciel ne dessine que la tête du curseur modélisé ; le GPU et le sprite plat
/// gardent leur traînée.
#[test]
fn the_software_backend_draws_the_modelled_head_only() {
let scene = model_scene();
let fast = crate::cursor::CursorTrack::new(vec![(0.0, 0.1, 0.6), (0.5, 0.9, 0.6)], vec![], vec![]);
let cfg = crate::config::all().pop().expect("cfg");
let fg = full_frame_geometry();
let plan = |model3d: bool| {
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams {
cursor_model3d: model3d,
cursor_motion_blur: 1.0,
..LiveParams::default()
},
scene: Some(&scene),
track: &fast,
t: 0.25,
},
)
.expect("plan")
};
let taps = plan(true).taps;
assert!(taps > 1, "le geste rapide doit donner une traînée");
assert_eq!(plan(true).for_backend(false).taps, taps, "GPU : traînée gardée");
let cpu = plan(true).for_backend(true);
assert_eq!(cpu.taps, 1);
assert_eq!(cpu.prev_placement.upright_center(), cpu.placement.upright_center());
assert_eq!(plan(false).for_backend(true).taps, plan(false).taps, "le sprite plat garde sa traînée");
}
/// Caché par l'application (`visible: false`), le curseur ne dessine rien, sprite plat comme
/// modèle (ombre et anneau compris), et sa traînée ne remonte pas dans la phase cachée à la
/// réapparition : il y filait à droite, il réapparaît là où il avait cliqué.
#[test]
fn a_hidden_phase_draws_no_cursor_and_no_trail_into_it() {
let scene = model_scene();
let cfg = crate::config::all().pop().expect("cfg");
let fg = full_frame_geometry();
let track = crate::cursor::CursorTrack::new_with_visibility(
vec![(0.0, 0.3, 0.6), (1.0, 0.3, 0.6), (1.1, 0.35, 0.6), (1.467, 0.9, 0.6), (1.5, 0.3, 0.6), (3.0, 0.3, 0.6)],
vec![1.0],
vec![],
vec![(0.0, true), (1.1, false), (1.5, true)],
);
let plan = |model3d: bool, t: f32| {
plan_cursor(
&fg,
&CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live: LiveParams {
cursor_model3d: model3d,
cursor_bounce_scale: MODEL_CLICK_BOUNCE_REF,
cursor_motion_blur: 1.0,
..LiveParams::default()
},
scene: Some(&scene),
track: &track,
t,
},
)
};
for model3d in [false, true] {
assert!(plan(model3d, 1.05).is_some(), "model3d {model3d} : visible avant");
for t in [1.1, 1.2, 1.4, 1.49] {
assert!(plan(model3d, t).is_none(), "model3d {model3d} : dessiné caché à {t} s");
}
let back = plan(model3d, 1.505).expect("réapparu");
assert_eq!(back.taps, 1, "model3d {model3d} : traînée venue de la phase cachée");
}
assert!(!plan(true, 1.08).expect("visible").impacts.is_empty(), "garde : l'anneau du clic");
}
/// La piste des deux tests suivants : deux clics, à 1,0 s et à 1,2 s, puis la pointe s'en va.
/// `hidden_from` : l'instant où l'enregistrement cache la pointe (`visible: false`).
fn clicked_track(hidden_from: Option<f32>) -> crate::cursor::CursorTrack {
let mut visibility = vec![(0.0, true)];
visibility.extend(hidden_from.map(|t| (t, false)));
crate::cursor::CursorTrack::new_with_visibility(
vec![(0.0, 0.3, 0.6), (1.0, 0.3, 0.6), (1.2, 0.5, 0.4), (2.0, 0.8, 0.2), (6.0, 0.8, 0.2)],
vec![1.0, 1.2],
vec![],
visibility,
)
}
fn cursor_input<'a>(
scene: &'a Scene,
cfg: &'a crate::config::Cfg,
track: &'a crate::cursor::CursorTrack,
t: f32,
) -> CursorPlanInput<'a> {
CursorPlanInput {
render_px: [1920.0, 1080.0],
u_max: 1.0,
v_max: 1.0,
cfg,
live: LiveParams::default(),
scene: Some(scene),
track,
t,
}
}
/// Les effets shader lisent la pointe et les clics récents en uv de SORTIE : un clic garde le
/// point où la pointe était quand il a eu lieu, le plus récent vient en premier, un clic sort
/// de la liste après la fenêtre, et la pointe est là où le curseur se dessine.
#[test]
fn effects_get_the_pointer_and_the_recent_clicks() {
let scene = model_scene();
let cfg = crate::config::all().pop().expect("cfg");
let fg = full_frame_geometry();
let track = clicked_track(None);
let fx = |t: f32| effect_pointer(&fg, &cursor_input(&scene, &cfg, &track, t));
assert!(fx(0.5).clicks.is_empty(), "pas encore de clic");
let (first, second) = (fx(1.0).cursor.expect("pointe"), fx(1.2).cursor.expect("pointe"));
let clicks = fx(1.5).clicks;
assert_eq!(clicks.len(), 2);
assert_eq!((clicks[0].0, clicks[1].0), (second, first), "le plus récent d'abord, au point du clic");
assert!((clicks[0].1 - 0.3).abs() < 1e-4 && (clicks[1].1 - 0.5).abs() < 1e-4, "{clicks:?}");
assert_ne!(fx(2.5).cursor, Some(second), "la pointe a bougé depuis");
assert_eq!(fx(1.1 + crate::shader_fx::CLICK_WINDOW_S).clicks.len(), 1, "le premier est sorti");
let drawn = plan_cursor(&fg, &cursor_input(&scene, &cfg, &track, 2.5)).expect("visible");
assert_eq!(fx(2.5).cursor, Some(drawn.placement.upright_center()), "là où le curseur se dessine");
}
/// Le sprite plat aussi se pose sur le clic brut : à fort lissage, le ressort traîne loin derrière
/// une souris qui clique dès l'arrivée, mais la pointe dessinée, `ctx.cursor` et `ctx.clicks`
/// tombent sur le même pixel pendant le contact.
#[test]
fn the_flat_cursor_lands_on_the_click_under_smoothing() {
const TC: f32 = 1.5;
let scene = model_scene();
let cfg = crate::config::all().pop().expect("cfg");
let fg = full_frame_geometry();
let raw = approach_track([0.08, 0.05], [0.7, 0.6], [0.2, 0.9], 2.0, 0.0, TC);
for smoothing in [0.0, 0.3, 0.67, 1.0] {
let track = raw.smoothed(smoothing);
for ms in [0, 40, 100] {
let input = cursor_input(&scene, &cfg, &track, TC + ms as f32 / 1000.0);
let fx = effect_pointer(&fg, &input);
let (cursor, click) = (fx.cursor.expect("pointe"), fx.clicks[0].0);
let drawn = plan_cursor(&fg, &input).expect("visible").placement.upright_center();
let off = |a: [f32; 2], b: [f32; 2]| ((a[0] - b[0]) * 1920.0).hypot((a[1] - b[1]) * 1080.0);
assert!(off(cursor, click) < 0.5, "lissage {smoothing}, {ms} ms : {} px", off(cursor, click));
assert!(off(drawn, click) < 0.5, "lissage {smoothing}, {ms} ms : {} px", off(drawn, click));
}
}
}
/// Masqué par l'utilisateur, le curseur n'est plus dessiné, mais les effets gardent la pointe
/// et les clics : un halo suit toujours la souris, une onde part toujours du clic. Quand c'est
/// l'enregistrement qui cache la pointe, les effets la perdent, et gardent les clics d'avant.
#[test]
fn a_hidden_cursor_still_hands_effects_the_pointer_and_the_clicks() {
let shown = model_scene();
let mut hidden = model_scene();
hidden.cursor.show = false;
let cfg = crate::config::all().pop().expect("cfg");
let fg = full_frame_geometry();
let track = clicked_track(None);
assert!(plan_cursor(&fg, &cursor_input(&hidden, &cfg, &track, 1.5)).is_none(), "rien à dessiner");
let seen = effect_pointer(&fg, &cursor_input(&hidden, &cfg, &track, 1.5));
assert_eq!(seen, effect_pointer(&fg, &cursor_input(&shown, &cfg, &track, 1.5)));
assert!(seen.cursor.is_some() && seen.clicks.len() == 2, "{seen:?}");
let recorded_hidden = clicked_track(Some(1.3));
let after = effect_pointer(&fg, &cursor_input(&shown, &cfg, &recorded_hidden, 1.5));
assert_eq!(after.cursor, None, "l'enregistrement a caché la pointe");
assert_eq!(after.clicks, seen.clicks, "les clics d'avant restent");
}
/// Sous un angle fixe, l'écran tourne autour du centre de sa boîte ZOOMÉE, réduit de son
/// containment : le curseur y perdait ~18 % au point de focus même, pendant que le zoom
/// grossissait l'image. Il y garde sa taille à plat, à la perspective de biais près ; ailleurs,
/// seule la perspective le change : plus grand du côté proche, plus petit du côté lointain.
#[test]
fn a_fixed_angle_keeps_the_cursor_size_at_the_zoom_focus() {
let cfg = crate::config::all().pop().expect("cfg");
// Taille apparente du modèle posé en `at` (repère du curseur) : différences centrées de sa
// projection autour de la pointe, en px de sortie par unité du modèle.
let size = |rotation: &str, zoom: f32, at: (f32, f32)| -> f32 {
let json = zoomed_golden_scene_json()
.replace(r#""rotation":"none""#, &format!(r#""rotation":"{rotation}""#))
.replace(r#""scale":2.0"#, &format!(r#""scale":{zoom}"#));
let mut scene = Scene::from_json(&json).expect("scène");
scene.cursor.theme = "default".into();
scene.cursor.cursor_sprites = model_scene().cursor.cursor_sprites;
let live = LiveParams { cursor_model3d: true, ..live_params_from_scene(&scene) };
let track: &'static crate::cursor::CursorTrack = Box::leak(Box::new(
crate::cursor::CursorTrack::new(vec![(0.0, at.0, at.1), (6.0, at.0, at.1)], vec![], vec![]),
));
let g = plan_frame(&FrameGeometryInput { cursor: Some(track), live, ..golden_input(&scene, &cfg) });
let input = CursorPlanInput {
render_px: [1170.0, 658.0],
u_max: 1.0,
v_max: 1080.0 / 1088.0,
cfg: &cfg,
live,
scene: Some(&scene),
track,
t: 1.5,
};
let plan = plan_cursor(&g, &input).expect("plan");
let (_, shape) = sprite_model("arrow");
let view = ModelView::new(plan.placement, plan.size_px, plan.model.expect("modèle"), shape).expect("vue");
let e = 0.05 * view.unit;
let span = |d: [f32; 3]| {
let p = |k: f32| view.project([0, 1, 2].map(|i| view.tip[i] + k * d[i])).expect("projection");
let (a, b) = (p(e), p(-e));
(a[0] - b[0]).hypot(a[1] - b[1]) / (2.0 * e) * view.unit
};
(span([1.0, 0.0, 0.0]) * span([0.0, 1.0, 0.0])).sqrt()
};
// Le focus du zoom doré, (0,5 ; 0,3) du recadrage 0,61 : c'est là que regarde le zoom.
let focus = (0.305, 0.183);
for zoom in [1.25f32, 2.0, 3.5] {
let flat = size("none", zoom, focus);
for rotation in ["left", "right"] {
let ratio = size(rotation, zoom, focus) / flat;
println!("{rotation} ×{zoom} : {ratio:.3} de la taille à plat, au focus");
assert!((0.93..1.02).contains(&ratio), "{rotation} ×{zoom} : {ratio}");
}
}
// `left` amène le bord droit vers la caméra, `right` le bord gauche.
let at_focus = size("left", 2.0, focus);
let (near, far) = (size("left", 2.0, (0.43, 0.183)), size("left", 2.0, (0.18, 0.183)));
println!("left ×2 : {:.3} côté proche, {:.3} côté lointain", near / at_focus, far / at_focus);
assert!(near > 1.04 * at_focus && far < 0.96 * at_focus, "{near} {at_focus} {far}");
}
}