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
//! Les cadres d'appareil modelés (`effects.frame`, mode 17) rendus par le vrai compositeur
//! D3D11 : portable, téléphone et moniteur, à plat, sous un angle fixe et sous la caméra en
//! orbite, dans les deux thèmes et sur quatre formats de clip.
//!
//! La source est une frame NV12 SYNTHÉTIQUE, comme `cursor_model_render.rs` : rien à décoder,
//! donc le test tourne sur toute machine qui a un GPU, sans variable d'environnement. Sans
//! adaptateur matériel, il se saute (« test saute »).
//!
//! ```powershell
//! cargo test -p openscreen-compositor --test device_frame_render -- --nocapture
//! $env:OPENSCREEN_DEVICE_OUT = "...\renders" # planches à regarder
//! $env:OPENSCREEN_DEVICE_BENCH = "1" # coût d'une frame 1080p, cadre allumé/éteint
//! $env:OPENSCREEN_DEVICE_CLIP = "...\clip" # 6 s de PNG pour un MP4 (portable en orbite)
//! ```
#![cfg(windows)]
use openscreen_compositor::compositor::Compositor;
use openscreen_compositor::config::Cfg;
use openscreen_compositor::cursor::CursorTrack;
use openscreen_compositor::d3d::Gpu;
use openscreen_compositor::frame_geometry::{live_params_from_scene, plan_frame, FrameGeometry, FrameGeometryInput};
use openscreen_compositor::regions::TiltedQuad;
use openscreen_compositor::scene::Scene;
mod common;
use common::{gpu, Nv12Frame};
const W: u32 = 1280;
const H: u32 = 720;
const SRC: (u32, u32) = (640, 360);
/// Instant rendu : en plein palier de la région de zoom.
const T: f32 = 2.0;
/// Les trois appareils modelés. Aucun n'est réservé à une forme de clip : c'est le cadre qui
/// s'adapte au métrage (cf. `SHAPES`).
const DEVICES: [&str; 3] = ["laptop", "phone", "monitor"];
/// Les formats de sortie passes en revue : paysage, portrait, et deux ratios inhabituels. Le
/// cadre s'adapte au METRAGE, donc chacun doit tenir dans chacun — un telephone autour d'un clip
/// paysage est un telephone couche, pas un telephone etire, et rien n'est jamais recadre pour
/// faire tenir un appareil.
const SHAPES: [(&str, (u32, u32), (u32, u32)); 4] = [
("16:9", (1280, 720), (640, 360)),
("9:16", (720, 1280), (360, 640)),
("4:3", (960, 720), (480, 360)),
("21:9", (1260, 540), (630, 270)),
];
/// Deux teintes de contenu : un pixel identique sur les deux est de l'appareil ou du fond, un
/// pixel qui change est le métrage.
#[derive(Clone, Copy)]
enum Tint {
Blue,
Orange,
}
/// Une frame NV12 synthétique, striée pour que le métrage se distingue d'un aplat.
fn fake_frame(gpu: &Gpu, size: (u32, u32), tint: Tint) -> Nv12Frame {
let [u, v] = match tint {
Tint::Blue => [150, 120],
Tint::Orange => [100, 170],
};
Nv12Frame::new(
gpu,
size,
|col, row| {
let bar = row % 24 >= 8 && row % 24 < 12 && (col / 40) % 3 != 2;
if bar { 90 } else { 170 }
},
|_, _| [u, v],
)
}
/// Une scène d'un seul écran : `frame` = la valeur du réglage (`""` = clé absente).
fn scene_json(frame: &str, rotation: &str, shadow: f32, cursor: &str, out: (u32, u32)) -> String {
scene_json_themed(frame, "light", rotation, shadow, cursor, out)
}
/// `scene_json` avec le theme du cadre : clair (argent) ou sombre (graphite), pour TOUS les
/// cadres. Omis a « light », comme l'app l'omet.
fn scene_json_themed(
frame: &str,
theme: &str,
rotation: &str,
shadow: f32,
cursor: &str,
out: (u32, u32),
) -> String {
let theme = if theme == "light" { String::new() } else { format!(r#","frameTheme":"{theme}""#) };
let frame =
if frame.is_empty() { String::new() } else { format!(r#","frame":"{frame}"{theme}"#) };
let (ow, oh) = out;
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.08,"y":0.08,"width":0.84,"height":0.84}}}},
"effects":{{"padding":0.25,"blur":false,"shadow":{shadow},"roundnessFrac":0.02,"motionBlur":0{frame}}},
"background":{{"kind":"gradient","angleDeg":135,"stops":["#5b6ee1","#e8a0bf"]}},
"zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":10,"scale":1,"focusX":0.5,"focusY":0.5,"rotation":{rotation}}}],
"annotations":[],
"cursor":{cursor},
"cropByClip":[null],
"output":{{"width":{ow},"height":{oh},"fps":30}}}}"##
)
}
const NO_CURSOR: &str = r#"{"show":false,"size":1,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default"}"#;
/// La caméra en orbite, en focus auto : celle qui bouge avec le pointeur.
const ORBIT: &str = r#""orbit","focusMode":"auto""#;
fn cfg() -> Cfg {
let mut cfg = Cfg::c8();
cfg.bg_blur = 0.0;
cfg.zoom = false;
cfg.layout_anim = false;
cfg.cursor = false;
cfg.mblur_n = 1;
cfg.shadow = true;
cfg
}
fn render(comp: &Compositor, screen: &Nv12Frame, json: &str, track: Option<&CursorTrack>, t: f32) -> Vec<u8> {
let scene = Scene::from_json(json).expect("scène valide");
let mut live = live_params_from_scene(&scene);
live.has_webcam = false;
comp.set_live_params(live);
comp.set_has_webcam(false);
comp.set_scene(Some(scene));
let mut cfg = cfg();
match track {
Some(tr) => {
cfg.cursor = true;
comp.set_cursor(tr.clone());
comp.set_cursor_time(Some(t));
}
None => comp.clear_cursor(),
}
comp.set_timeline_time(Some(t));
unsafe {
comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");
comp.readback_direct().expect("readback").2
}
}
/// Le quadrilatère de l'écran RÉELLEMENT dessiné, en px de sortie — c'est l'ouverture que
/// l'appareil laisse au métrage —, et les marges de son CORPS, en fractions de ce quad. Même
/// chemin que les backends (`plan_frame` + `screen_tilt`).
fn aperture(json: &str, out: (u32, u32)) -> ([(f32, f32); 4], [f32; 4]) {
let g = plan(json, out, SRC);
let render_px = [out.0 as f32, out.1 as f32];
let s = g.s_dst;
let s_px = [s[2] * render_px[0], s[3] * render_px[1]];
let center = [(s[0] + s[2] * 0.5) * render_px[0], (s[1] + s[3] * 0.5) * render_px[1]];
let margins = g.window_frame.map(|f| f.margins).unwrap_or([0.0; 4]);
let corners = match g.screen_tilt(s_px) {
Some(q) => std::array::from_fn(|i| {
let (fx, fy) = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)][i];
let (x, y) = q.point_px(fx, fy);
(center[0] + x, center[1] + y)
}),
None => std::array::from_fn(|i| {
let (fx, fy) = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)][i];
((s[0] + s[2] * fx) * render_px[0], (s[1] + s[3] * fy) * render_px[1])
}),
};
(corners, margins)
}
/// Le plan de la scène, par le même chemin que les backends.
fn plan(json: &str, out: (u32, u32), src: (u32, u32)) -> FrameGeometry {
plan_at(json, out, src, T)
}
/// `plan` à l'instant `t` de la timeline.
fn plan_at(json: &str, out: (u32, u32), src: (u32, u32), t: f32) -> FrameGeometry {
let scene = Scene::from_json(json).expect("scène valide");
let cfg = cfg();
let mut live = live_params_from_scene(&scene);
live.has_webcam = false;
let src = [src.0 as f32, src.1 as f32];
plan_frame(&FrameGeometryInput {
render_px: [out.0 as f32, out.1 as f32],
screen_tex_px: src,
screen_visible_px: src,
webcam_visible_px: src,
u_max: 1.0,
v_max: 1.0,
frame: 0.0,
cfg: &cfg,
live,
scene: Some(&scene),
cursor: None,
timeline_t_override: Some(t),
programme_time: None,
})
}
/// Le métrage et le corps du cadre dans le repère du rect DROIT du métrage (px, origine au coin
/// haut-gauche), et le passage vers l'image rendue par le warp que le plan utilise VRAIMENT
/// (`TiltedQuad::point_px` : projectif sous un appareil ou la caméra, bilinéaire sinon) : un point
/// pris sur le métrage ou dans la lunette tombe au bon pixel, à plat comme incliné.
struct Geo {
s_px: [f32; 2],
/// Rayon des coins du métrage (et de l'ouverture), px.
radius: f32,
/// Corps : marges gauche, haut, droite, bas, et rayons extérieurs (coins hauts, bas), px.
body: [f32; 4],
body_radius: [f32; 2],
tilt: Option<TiltedQuad>,
center: [f32; 2],
origin: [f32; 2],
}
impl Geo {
fn new(json: &str, out: (u32, u32), src: (u32, u32)) -> Geo {
Geo::at(json, out, src, T)
}
/// `Geo::new` à l'instant `t` : pendant une rampe de zoom, le plan d'une autre frame.
fn at(json: &str, out: (u32, u32), src: (u32, u32), t: f32) -> Geo {
let g = plan_at(json, out, src, t);
let (rw, rh) = (out.0 as f32, out.1 as f32);
let s_px = [g.s_dst[2] * rw, g.s_dst[3] * rh];
let center = [(g.s_dst[0] + g.s_dst[2] * 0.5) * rw, (g.s_dst[1] + g.s_dst[3] * 0.5) * rh];
let origin = [g.s_dst[0] * rw, g.s_dst[1] * rh];
let (body, body_radius) = match g.window_frame {
Some(f) => {
let m = f.margins;
([m[0] * s_px[0], m[1] * s_px[1], m[2] * s_px[0], m[3] * s_px[1]], f.radius)
}
None => ([0.0; 4], [g.s_radius; 2]),
};
Geo { s_px, radius: g.s_radius, body, body_radius, tilt: g.screen_tilt(s_px), center, origin }
}
fn to_out(&self, p: [f32; 2]) -> (f32, f32) {
match &self.tilt {
Some(q) => {
let (x, y) = q.point_px(p[0] / self.s_px[0], p[1] / self.s_px[1]);
(self.center[0] + x, self.center[1] + y)
}
None => (self.origin[0] + p[0], self.origin[1] + p[1]),
}
}
/// Distance signée au contour du métrage (rect arrondi de `radius`), <0 dedans.
fn footage_sd(&self, p: [f32; 2]) -> f32 {
let h = [self.s_px[0] * 0.5, self.s_px[1] * 0.5];
sd_rr([p[0] - h[0], p[1] - h[1]], h, self.radius)
}
/// Distance signée au contour extérieur du corps, <0 dedans.
fn body_sd(&self, p: [f32; 2]) -> f32 {
let [l, t, r, b] = self.body;
let h = [(self.s_px[0] + l + r) * 0.5, (self.s_px[1] + t + b) * 0.5];
let c = [-l + h[0], -t + h[1]];
let r = if p[1] < c[1] { self.body_radius[0] } else { self.body_radius[1] };
sd_rr([p[0] - c[0], p[1] - c[1]], h, r)
}
/// Les sondes de couture : un point du bord du métrage, sa normale sortante, et jusqu'où
/// marcher dehors sans quitter le corps du cadre (px). Le milieu des quatre bords et le
/// sommet de l'arc des quatre coins — sauf les coins HAUTS de la fenêtre, carrés et à ras de
/// la barre, dont le bord haut est déjà sondé.
fn seam_probes(&self, window: bool) -> Vec<([f32; 2], [f32; 2], f32)> {
let [w, h] = self.s_px;
let [l, t, r, b] = self.body;
// Jusqu'à un pixel et demi du bord EXTÉRIEUR du cadre : au-delà, c'est son propre
// antialiasing sur le fond, pas une couture.
let reach = |m: f32| (m - 1.5).min(6.0);
let mut v = vec![
([w * 0.5, 0.0], [0.0, -1.0], reach(t)),
([w * 0.5, h], [0.0, 1.0], reach(b)),
([0.0, h * 0.5], [-1.0, 0.0], reach(l)),
([w, h * 0.5], [1.0, 0.0], reach(r)),
];
let k = self.radius * (1.0 - std::f32::consts::FRAC_1_SQRT_2);
let n = std::f32::consts::FRAC_1_SQRT_2;
for (c, s, m) in [
([0.0, 0.0], [-1.0, -1.0], l.min(t)),
([w, 0.0], [1.0, -1.0], r.min(t)),
([w, h], [1.0, 1.0], r.min(b)),
([0.0, h], [-1.0, 1.0], l.min(b)),
] {
if window && s[1] < 0.0 {
continue;
}
v.push(([c[0] - s[0] * k, c[1] - s[1] * k], [s[0] * n, s[1] * n], reach(m)));
}
v
}
}
/// `sd_round_rect` des shaders, <0 dedans.
fn sd_rr(p: [f32; 2], h: [f32; 2], r: f32) -> f32 {
let r = r.min(h[0].min(h[1])).max(0.0);
let q = [p[0].abs() - h[0] + r, p[1].abs() - h[1] + r];
q[0].max(0.0).hypot(q[1].max(0.0)) + q[0].max(q[1]).min(0.0) - r
}
/// Un fond uni VERT, loin du métrage (lavande) comme des lunettes (neutres) : un pixel vert dans
/// une couture ou dans un coin de lunette, c'est le fond d'écran qui passe.
fn on_green(json: &str) -> String {
json.replace(
r##"{"kind":"gradient","angleDeg":135,"stops":["#5b6ee1","#e8a0bf"]}"##,
r##"{"kind":"color","color":"#10c040"}"##,
)
}
fn greenish(p: [u8; 3]) -> bool {
p[1] as i32 - p[0].max(p[2]) as i32 > 30
}
/// Roundness au maximum : au-delà de la moitié du petit côté, le rayon est borné
/// (`screen_corner_radius_px`), donc 1 est le bout du slider et au-delà.
const MAX_ROUND: f32 = 1.0;
fn with_roundness(json: &str, r: f32) -> String {
json.replace(r#""roundnessFrac":0.02"#, &format!(r#""roundnessFrac":{r}"#))
}
/// Le métrage dans un rect PLUS PETIT que celui des planches, pour que le cadre tienne entier
/// dans l'image (pied du moniteur compris) : `(x, y, w, h)` en fractions de la sortie.
fn with_rect(json: &str, r: (f32, f32, f32, f32)) -> String {
json.replace(
r#""screenRect":{"x":0.08,"y":0.08,"width":0.84,"height":0.84}"#,
&format!(r#""screenRect":{{"x":{},"y":{},"width":{},"height":{}}}"#, r.0, r.1, r.2, r.3),
)
}
/// Un clip paysage et un clip PORTRAIT dans le même projet 16:9 (1280×720) : le portrait est un
/// rect étroit au ratio 9:16 exact.
const CLIPS: [(&str, (f32, f32, f32, f32), (u32, u32)); 2] = [
("landscape", (0.2, 0.14, 0.6, 0.6), (640, 360)),
("portrait", (0.3734375, 0.1, 0.253125, 0.8), (360, 640)),
];
/// Le point du quad aux fractions (fx, fy), prolongé au-delà de 0..1 par l'homographie de ses
/// coins — donc aussi juste dans la lunette, qui vit hors de l'écran.
fn quad_at(q: &[(f32, f32); 4], fx: f32, fy: f32) -> (f32, f32) {
// Homographie du carré unité sur le quad (forme de Heckbert), comme `regions::square_to_quad`.
let (x0, y0) = q[0];
let (dx1, dy1) = (q[1].0 - q[2].0, q[1].1 - q[2].1);
let (dx2, dy2) = (q[3].0 - q[2].0, q[3].1 - q[2].1);
let (sx, sy) = (q[0].0 - q[1].0 + q[2].0 - q[3].0, q[0].1 - q[1].1 + q[2].1 - q[3].1);
let den = dx1 * dy2 - dx2 * dy1;
let (g, h) = if den.abs() < 1e-9 {
(0.0, 0.0)
} else {
((sx * dy2 - dx2 * sy) / den, (dx1 * sy - sx * dy1) / den)
};
let a = q[1].0 - q[0].0 + g * q[1].0;
let b = q[3].0 - q[0].0 + h * q[3].0;
let d = q[1].1 - q[0].1 + g * q[1].1;
let e = q[3].1 - q[0].1 + h * q[3].1;
let w = g * fx + h * fy + 1.0;
((a * fx + b * fy + x0) / w, (d * fx + e * fy + y0) / w)
}
fn px(rgba: &[u8], out: (u32, u32), x: f32, y: f32) -> Option<[u8; 3]> {
let (xi, yi) = (x.round() as i32, y.round() as i32);
if xi < 0 || yi < 0 || xi >= out.0 as i32 || yi >= out.1 as i32 {
return None;
}
let i = ((yi * out.0 as i32 + xi) * 4) as usize;
Some([rgba[i], rgba[i + 1], rgba[i + 2]])
}
fn neutral(p: [u8; 3]) -> bool {
p[0].max(p[1]).max(p[2]) - p[0].min(p[1]).min(p[2]) < 40
}
fn differing(a: &[u8], b: &[u8], tol: u8) -> usize {
a.chunks_exact(4)
.zip(b.chunks_exact(4))
.filter(|(p, q)| p.iter().zip(q.iter()).take(3).any(|(x, y)| x.abs_diff(*y) > tol))
.count()
}
fn out_dir(var: &str) -> Option<String> {
let dir = std::env::var(var).ok()?;
std::fs::create_dir_all(&dir).expect("dossier de sortie");
Some(dir)
}
fn save(dir: &str, name: &str, rgba: &[u8], out: (u32, u32)) {
image::RgbaImage::from_raw(out.0, out.1, rgba.to_vec())
.expect("dimensions du readback")
.save(format!("{dir}/{name}.png"))
.unwrap_or_else(|e| panic!("écriture {name} : {e}"));
}
/// Chaque appareil se dessine AUTOUR du metrage sans jamais le recouvrir, QUELLE QUE SOIT la
/// forme du clip : dans l'ouverture, le pixel change avec la teinte de la source (c'est le
/// metrage que le mode 8 y dessine) ; dans la lunette, il n'en depend pas et il est neutre
/// (c'est l'appareil, pas le fond d'ecran colore).
///
/// Les quatre formats couvrent ce que le produit demande : un telephone autour d'un clip paysage
/// est un telephone couche, un portable autour d'un clip portrait reste un portable, et deux
/// ratios inhabituels (4:3, 21:9) disent que rien ne degenere.
#[test]
fn each_device_draws_around_untouched_footage() {
let Some(gpu) = gpu() else { return };
for (shape, out, src) in SHAPES {
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let blue = fake_frame(&gpu, src, Tint::Blue);
let orange = fake_frame(&gpu, src, Tint::Orange);
for &device in &DEVICES {
for rotation in ["null", r#""iso""#, ORBIT] {
let json = scene_json(device, rotation, 0.0, NO_CURSOR, out);
let a = render(&comp, &blue, &json, None, T);
let b = render(&comp, &orange, &json, None, T);
let (q, margins) = aperture(&json, out);
// Dans l'ouverture, bien a l'interieur du bord : du metrage, partout.
for i in 1..=9 {
for j in 1..=9 {
let (x, y) = quad_at(&q, i as f32 / 10.0, j as f32 / 10.0);
let (Some(pa), Some(pb)) = (px(&a, out, x, y), px(&b, out, x, y)) else {
panic!("{shape} {device} {rotation} : l'ouverture sort de l'image");
};
assert_ne!(
pa, pb,
"{shape} {device} {rotation} : ({x:.0},{y:.0}) n'est pas du metrage"
);
}
}
// Juste DEHORS, au milieu de la lunette : l'appareil, et lui seul.
let [ml, mt, mr, mb] = margins.map(|v| v * 0.5);
let mut bezel = 0;
for k in 1..=9 {
let s = k as f32 / 10.0;
for ((fx, fy), (ex, ey)) in [(s, -mt), (s, 1.0 + mb), (-ml, s), (1.0 + mr, s)]
.into_iter()
.zip([(s, 0.0), (s, 1.0), (0.0, s), (1.0, s)])
{
let (x, y) = quad_at(&q, fx, fy);
// Une lunette vue par la tranche peut mesurer moins d'un pixel.
let (bx, by) = quad_at(&q, ex, ey);
if (x - bx).hypot(y - by) < 2.5 {
continue;
}
let (Some(pa), Some(pb)) = (px(&a, out, x, y), px(&b, out, x, y)) else {
continue;
};
assert_eq!(
pa, pb,
"{shape} {device} {rotation} : du metrage deborde en ({x:.0},{y:.0})"
);
assert!(
neutral(pa),
"{shape} {device} {rotation} : ({x:.0},{y:.0}) = {pa:?}, pas l'appareil"
);
bezel += 1;
}
}
assert!(bezel >= 18, "{shape} {device} {rotation} : {bezel} points de lunette");
// Et l'appareil se voit.
let bare =
render(&comp, &blue, &scene_json("none", rotation, 0.0, NO_CURSOR, out), None, T);
let seen = differing(&a, &bare, 8);
println!("{shape:<5} {device:<8} {rotation:<16} {seen:>7} px changent");
// Une lunette fine autour d'un grand metrage : un anneau de 1 a 2 % de la largeur.
assert!(
seen > (out.0 * out.1) as usize / 80,
"{shape} {device} {rotation} : cadre invisible"
);
}
}
}
}
/// Les deux themes donnent deux objets differents, et le metrage ne bouge pas d'un pixel entre
/// les deux : le theme peint la coque, il ne touche pas a l'image.
#[test]
fn the_frame_theme_repaints_the_body_and_nothing_else() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
for &device in &["window", "laptop", "phone", "monitor"] {
for rotation in ["null", r#""iso""#] {
let light =
render(&comp, &screen, &scene_json_themed(device, "light", rotation, 0.0, NO_CURSOR, (W, H)), None, T);
let dark =
render(&comp, &screen, &scene_json_themed(device, "dark", rotation, 0.0, NO_CURSOR, (W, H)), None, T);
let seen = differing(&light, &dark, 8);
println!("{device:<8} {rotation:<8} clair/sombre {seen:>7} px");
assert!(seen > (W * H) as usize / 200, "{device} {rotation} : les deux themes se confondent");
// Le metrage : identique au bit pres dans l'ouverture.
let (q, _) = aperture(&scene_json(device, rotation, 0.0, NO_CURSOR, (W, H)), (W, H));
for i in 1..=9 {
for j in 1..=9 {
let (x, y) = quad_at(&q, i as f32 / 10.0, j as f32 / 10.0);
let (Some(pa), Some(pb)) = (px(&light, (W, H), x, y), px(&dark, (W, H), x, y))
else {
continue;
};
assert_eq!(pa, pb, "{device} {rotation} : le theme a touche le metrage");
}
}
}
}
}
/// L'appareil suit le plan : incliné ou vu par la caméra en orbite, il n'est plus là où il était
/// à plat, et il reste à l'intérieur de l'image. À plat et curseur éteint, deux rendus successifs
/// sont identiques à l'octet — une fonction pure de `t`.
#[test]
fn the_device_follows_the_tilt_and_the_orbit_camera() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
for &device in &["laptop", "window"] {
let flat = render(&comp, &screen, &scene_json(device, "null", 0.0, NO_CURSOR, (W, H)), None, T);
assert!(
flat == render(&comp, &screen, &scene_json(device, "null", 0.0, NO_CURSOR, (W, H)), None, T),
"{device} : le rendu à plat n'est pas stable"
);
for rotation in [r#""iso""#, r#""left""#, ORBIT] {
let tilted = render(&comp, &screen, &scene_json(device, rotation, 0.0, NO_CURSOR, (W, H)), None, T);
let moved = differing(&flat, &tilted, 8);
println!("{device:<8} {rotation:<16} {moved:>7} px bougent");
assert!(moved > (W * H) as usize / 20, "{device} {rotation} : l'appareil n'a pas suivi");
// (Le cadre peut sortir de l'image : le métrage garde sa taille et le cadre pousse
// vers l'extérieur, la sortie le coupe. `the_footage_box_is_the_same_under_every_frame`.)
}
}
}
/// Le flou de mouvement prend l'écran CADRÉ en bloc, à plat comme sous une caméra 3D : pendant la
/// rampe du zoom, le corps du cadre (lunette, barre de titre) file avec le métrage, donc ses pixels
/// changent avec le flou. Au palier, le rendu flou est le rendu net, à l'octet. Sous un angle fixe
/// ou la caméra en orbite, seul le métrage était flouté : l'appareil restait net autour de lui.
#[test]
fn the_device_trails_with_the_screen_under_motion_blur() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
// Zoom ×1,6 de 2 à 6 s : sa rampe d'entrée court de 1,14 à 2 s, vitesse au plus fort vers 1,26 s.
// Le petit rect garde l'appareil dans l'image pendant la rampe.
let json = |device: &str, rotation: &str, blur: f32| {
let json = with_rect(&scene_json(device, rotation, 0.6, NO_CURSOR, (W, H)), CLIPS[0].1)
.replace(r#""startSec":0,"endSec":10,"scale":1,"#, r#""startSec":2,"endSec":6,"scale":1.6,"#)
.replace(r#""roundnessFrac":0.02,"motionBlur":0"#, &format!(r#""roundnessFrac":0.02,"motionBlur":{blur}"#));
assert!(json.contains(r#""scale":1.6"#), "la substitution doit poser la rampe");
json
};
for device in ["laptop", "window"] {
// Un libellé par rotation : ORBIT est un fragment JSON, illégal dans un nom de fichier Windows.
for (label, rotation) in [("flat", "null"), ("iso", r#""iso""#), ("orbit", ORBIT)] {
let case = format!("{device} {rotation}");
let still = |blur| render(&comp, &blue, &json(device, rotation, blur), None, 4.0);
assert!(still(0.0) == still(1.0), "{case} : immobile, le flou ne doit rien changer");
let t = 1.3;
let sharp = render(&comp, &blue, &json(device, rotation, 0.0), None, t);
let blurred = render(&comp, &blue, &json(device, rotation, 1.0), None, t);
// Le corps du cadre à CET instant, sondé tous les 4 px du plan : hors du métrage et dans
// le corps, loin de leurs deux franges. Ni l'ombre ni le fond n'y entrent.
let g = Geo::at(&json(device, rotation, 0.0), (W, H), SRC, t);
let [l, top, r, b] = g.body;
let (mut probes, mut smeared) = (0usize, 0usize);
let mut y = -top;
while y <= g.s_px[1] + b {
let mut x = -l;
while x <= g.s_px[0] + r {
if g.footage_sd([x, y]) > 3.5 && g.body_sd([x, y]) < -2.0 {
let (ox, oy) = g.to_out([x, y]);
if let (Some(a), Some(c)) = (px(&sharp, (W, H), ox, oy), px(&blurred, (W, H), ox, oy)) {
probes += 1;
smeared += a.iter().zip(c).any(|(p, q)| p.abs_diff(q) > 8) as usize;
}
}
x += 4.0;
}
y += 4.0;
}
println!("{case:<24} {smeared:>5} / {probes:>5} sondes du cadre changent avec le flou");
if let Some(dir) = out_dir("OPENSCREEN_DEVICE_OUT") {
let name = format!("trail-{device}-{label}");
save(&dir, &format!("{name}-sharp"), &sharp, (W, H));
save(&dir, &format!("{name}-blurred"), &blurred, (W, H));
}
assert!(probes > 50, "{case} : trop peu de sondes du cadre ({probes})");
// Le milieu d'un aplat (la barre de titre) file dans lui-même : seules ses franges
// changent. Net, le cadre ne change en AUCUNE sonde.
assert!(smeared * 50 > probes, "{case} : le cadre reste net pendant le zoom ({smeared} / {probes})");
}
}
}
/// Le cadre porte l'ombre, pas l'écran : avec l'ombre allumée, le fond s'assombrit AUTOUR de
/// l'appareil, y compris sous le socle du portable, qui descend plus bas que l'écran.
#[test]
fn the_frame_casts_the_contact_shadow() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
for &device in &DEVICES {
let on = render(&comp, &screen, &scene_json(device, "null", 0.7, NO_CURSOR, (W, H)), None, T);
let off = render(&comp, &screen, &scene_json(device, "null", 0.0, NO_CURSOR, (W, H)), None, T);
let mut darker = 0usize;
let mut lowest = 0u32;
for y in 0..H {
for x in 0..W {
let i = ((y * W + x) * 4) as usize;
let (a, b) = (&on[i..i + 3], &off[i..i + 3]);
if a.iter().zip(b.iter()).all(|(p, q)| *p < *q) && b.iter().any(|c| *c > 60) {
darker += 1;
lowest = lowest.max(y);
}
}
}
let bottom = aperture(&scene_json(device, "null", 0.0, NO_CURSOR, (W, H)), (W, H))
.0
.iter()
.fold(0.0f32, |m, &(_, y)| m.max(y));
println!("{device:<8} ombre {darker:>7} px, jusqu'à y={lowest} (écran jusqu'à {bottom:.0})");
assert!(darker > (W * H) as usize / 200, "{device} : pas d'ombre ({darker} px)");
assert!(lowest as f32 > bottom, "{device} : l'ombre s'arrête au-dessus du bas de l'écran");
}
}
/// AUCUNE couture ne laisse passer le fond d'écran entre le métrage et son cadre : le long de
/// chaque bord et à travers chaque coin, du dedans du métrage jusqu'au corps du cadre, pas un
/// pixel n'est du fond. Fond VERT, loin du métrage comme des lunettes : la moindre frange s'y
/// voit. Roundness 0 et maximal, à plat, angle fixe et caméra en orbite, 1080p et 4K — le
/// recouvrement se compte en pixels (`DEV_OVERLAP_PX`), il doit tenir à toutes les tailles.
#[test]
fn no_seam_lets_the_wallpaper_through() {
let Some(gpu) = gpu() else { return };
for (res, out) in [("1080p", (1920u32, 1080u32)), ("4K", (3840, 2160))] {
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
for frame in ["window", "laptop", "phone", "monitor"] {
for roundness in [0.0f32, MAX_ROUND] {
for rotation in ["null", r#""iso""#, ORBIT] {
let json = on_green(&with_roundness(&scene_json(frame, rotation, 0.6, NO_CURSOR, out), roundness));
let rgba = render(&comp, &screen, &json, None, T);
let g = Geo::new(&json, out, SRC);
let (mut seen, mut leaks) = (0usize, Vec::new());
for (p, n, reach) in g.seam_probes(frame == "window") {
let mut d = -2.5f32;
while d <= reach {
let (x, y) = g.to_out([p[0] + n[0] * d, p[1] + n[1] * d]);
if let Some(c) = px(&rgba, out, x, y) {
seen += 1;
if greenish(c) {
leaks.push((x.round(), y.round(), c));
}
}
d += 0.5;
}
}
let case = format!("{res} {frame} r{roundness} {rotation}");
println!("{case:<40} {seen:>4} px sondés, {} verts", leaks.len());
assert!(seen > 30, "{case} : trop peu de sondes ({seen})");
assert!(leaks.is_empty(), "{case} : le fond passe en {:?}", &leaks[..leaks.len().min(6)]);
}
}
}
}
}
/// Au Roundness MAXIMAL, la région du coin entre l'arc du métrage et le coin carré n'est JAMAIS du
/// métrage (il changerait avec la teinte de la source), et là où elle est dans le corps du cadre,
/// jamais du fond (vert) : de la lunette, pixel par pixel. C'est là que le métrage non borné et
/// l'ouverture bornée traçaient deux coins différents. Le corps est concentrique au métrage : loin
/// de l'arc, le coin carré lui-même est hors du corps — du fond, voulu.
#[test]
fn the_bezel_fills_the_corners_at_maximum_roundness() {
let Some(gpu) = gpu() else { return };
let out = (1920u32, 1080u32);
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
let orange = fake_frame(&gpu, SRC, Tint::Orange);
for frame in ["window", "laptop", "phone", "monitor"] {
for rotation in ["null", r#""iso""#, ORBIT] {
let json = on_green(&with_roundness(&scene_json(frame, rotation, 0.0, NO_CURSOR, out), MAX_ROUND));
let (a, b) = (render(&comp, &blue, &json, None, T), render(&comp, &orange, &json, None, T));
let g = Geo::new(&json, out, SRC);
let [w, h] = g.s_px;
// Coins : origine et sens vers l'intérieur. La fenêtre n'a que ses coins BAS arrondis.
let corners: &[([f32; 2], [f32; 2])] = if frame == "window" {
&[([w, h], [-1.0, -1.0]), ([0.0, h], [1.0, -1.0])]
} else {
&[([0.0, 0.0], [1.0, 1.0]), ([w, 0.0], [-1.0, 1.0]), ([w, h], [-1.0, -1.0]), ([0.0, h], [1.0, -1.0])]
};
let (mut n, mut inside, mut bad) = (0usize, 0usize, Vec::new());
// Le carré du coin, de son sommet jusqu'au rayon : dehors l'arc, dedans le corps.
for &(c, s) in corners {
let mut u = 0.75f32;
while u < g.radius {
let mut v = 0.75f32;
while v < g.radius {
let p = [c[0] + s[0] * u, c[1] + s[1] * v];
// Hors de l'arc : jamais de metrage. Et dans le corps : jamais de fond.
// (3,5 px du plan : un angle fixe raccourcit le côté lointain, et la frange
// d'antialiasing du métrage fait 1,5 px d'IMAGE.)
if g.footage_sd(p) > 3.5 {
let (x, y) = g.to_out(p);
if let (Some(pa), Some(pb)) = (px(&a, out, x, y), px(&b, out, x, y)) {
let in_body = g.body_sd(p) < -2.0;
n += 1;
inside += in_body as usize;
if pa != pb || (in_body && greenish(pa)) {
bad.push((x.round(), y.round(), pa, pb));
}
}
}
v += 1.5;
}
u += 1.5;
}
}
println!("{frame:<8} {rotation:<16} {n:>6} px de coin dont {inside:>6} dans le corps, {} faux", bad.len());
// Sous un petit rayon, le coin carré n'est qu'à quelques pixels de l'arc, en deçà de la
// frange sondée : on ne compte la région que quand le rayon en laisse une.
if g.radius * (std::f32::consts::SQRT_2 - 1.0) > 8.0 {
// La fenêtre ne se sonde qu'à ses deux coins BAS (les hauts sont sa barre), sous un
// rayon plus petit que celui du téléphone : une région bien moindre à compter.
let min_n = if frame == "window" { 40 } else { 200 };
assert!(n > min_n, "{frame} {rotation} : région de coin vide ({n})");
// La fenetre n'a qu'un filet d'un pixel entre son arc et celui du metrage.
assert!(frame == "window" || inside > 200, "{frame} {rotation} : lunette de coin vide ({inside})");
}
assert!(bad.is_empty(), "{frame} {rotation} : métrage ou fond dans le coin en {:?}", &bad[..bad.len().min(6)]);
}
}
}
/// Distance (px) de chaque pixel au masque, par chanfrein (1, √2) en deux passes : elle
/// SURESTIME l'euclidienne d'au plus 8 %, donc une borne vérifiée sur elle vaut a fortiori.
fn distance_to(mask: &[bool], w: usize, h: usize) -> Vec<f32> {
let s2 = std::f32::consts::SQRT_2;
let mut d: Vec<f32> = mask.iter().map(|&m| if m { 0.0 } else { 1e9 }).collect();
for y in 0..h {
for x in 0..w {
let i = y * w + x;
let mut v = d[i];
if x > 0 {
v = v.min(d[i - 1] + 1.0);
}
if y > 0 {
v = v.min(d[i - w] + 1.0);
if x > 0 {
v = v.min(d[i - w - 1] + s2);
}
if x + 1 < w {
v = v.min(d[i - w + 1] + s2);
}
}
d[i] = v;
}
}
for y in (0..h).rev() {
for x in (0..w).rev() {
let i = y * w + x;
let mut v = d[i];
if x + 1 < w {
v = v.min(d[i + 1] + 1.0);
}
if y + 1 < h {
v = v.min(d[i + w] + 1.0);
if x + 1 < w {
v = v.min(d[i + w + 1] + s2);
}
if x > 0 {
v = v.min(d[i + w - 1] + s2);
}
}
d[i] = v;
}
}
d
}
/// L'ombre d'un appareil a la forme de sa SILHOUETTE 3D, socle et pied compris : aucun pixel
/// assombri à plus de décalage + pénombre de la silhouette (l'ancien quad plat pendait sous le
/// portable comme une dalle grise), et une ombre bien présente juste sous le socle et le pied.
/// Clair et sombre, à plat, angle fixe et orbite.
#[test]
fn the_device_shadow_follows_the_silhouette() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
let orange = fake_frame(&gpu, SRC, Tint::Orange);
let rect = CLIPS[0].1;
// SCREEN_SHADOW_SPREAD_FRAC (40 px réglés contre un cadre 1080), en px de CETTE sortie.
let spread = 40.0 / 1080.0 * W.min(H) as f32;
for frame in ["laptop", "monitor", "phone"] {
for theme in ["light", "dark"] {
for rotation in ["null", r#""iso""#, ORBIT] {
let json = |shadow: f32, f: &str| {
with_rect(&scene_json_themed(f, theme, rotation, shadow, NO_CURSOR, (W, H)), rect)
};
let on = render(&comp, &blue, &json(1.0, frame), None, T);
let off = render(&comp, &blue, &json(0.0, frame), None, T);
let off_o = render(&comp, &orange, &json(0.0, frame), None, T);
let bare = render(&comp, &blue, &json(0.0, "none"), None, T);
let (w, h) = (W as usize, H as usize);
let differs = |a: &[u8], b: &[u8], i: usize, tol: u8| {
(0..3).any(|k| a[i * 4 + k].abs_diff(b[i * 4 + k]) > tol)
};
// La silhouette : l'appareil (ce qui change avec le cadre) et le métrage (ce qui
// change avec la teinte de la source).
let sil: Vec<bool> =
(0..w * h).map(|i| differs(&off, &bare, i, 6) || differs(&off, &off_o, i, 6)).collect();
let dist = distance_to(&sil, w, h);
let g = plan(&json(1.0, frame), (W, H), SRC);
let off_px = g.screen_shadow_offset();
let reach = (off_px[0].hypot(off_px[1]) + spread) * 1.09 + 2.0;
let (mut shade, mut worst) = (0usize, 0.0f32);
for i in 0..w * h {
let darker = (0..3).all(|k| on[i * 4 + k] <= off[i * 4 + k])
&& (0..3).any(|k| off[i * 4 + k] - on[i * 4 + k] > 2);
if darker && !sil[i] {
shade += 1;
worst = worst.max(dist[i]);
}
}
// Juste sous la silhouette, dans la colonne du milieu : de l'ombre.
let x = w / 2;
let low = (0..h).rev().find(|&y| sil[y * w + x]).expect("silhouette");
let under = (low + 2..(low + 8).min(h)).any(|y| {
let i = y * w + x;
(0..3).any(|k| off[i * 4 + k].saturating_sub(on[i * 4 + k]) > 4)
});
let case = format!("{frame} {theme} {rotation}");
println!("{case:<28} ombre {shade:>7} px, au plus à {worst:.1} px (borne {reach:.1})");
assert!(shade > (w * h) / 200, "{case} : pas d'ombre");
assert!(worst <= reach, "{case} : ombre à {worst} px de la silhouette (borne {reach})");
assert!(under || low + 3 >= h, "{case} : pas d'ombre sous la silhouette (y = {low})");
}
}
}
}
/// Planches a regarder (opt-in, `OPENSCREEN_DEVICE_OUT`) : chaque appareil a plat et sous `iso`,
/// dans les deux themes, plus un gros plan de la charniere du portable pour juger le chanfrein.
#[test]
fn contact_sheets() {
let Some(dir) = out_dir("OPENSCREEN_DEVICE_OUT") else {
eprintln!("OPENSCREEN_DEVICE_OUT absent - saute");
return;
};
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
let all: [&str; 4] = ["window", "laptop", "phone", "monitor"];
// Une planche par theme : quatre cadres x (plat, iso).
for theme in ["light", "dark"] {
let mut sheet = image::RgbaImage::new(W * 2, H * 4);
for (row, &device) in all.iter().enumerate() {
for (col, (name, rotation)) in [("flat", "null"), ("iso", r#""iso""#)].iter().enumerate()
{
let json = scene_json_themed(device, theme, rotation, 0.6, NO_CURSOR, (W, H));
let rgba = render(&comp, &screen, &json, None, T);
save(&dir, &format!("{device}-{name}-{theme}"), &rgba, (W, H));
let img = image::RgbaImage::from_raw(W, H, rgba).expect("readback");
image::imageops::overlay(&mut sheet, &img, (col as u32 * W) as i64, (row as u32 * H) as i64);
}
}
sheet.save(format!("{dir}/devices-{theme}.png")).expect("planche");
}
// Le telephone dans les deux orientations de clip : debout et couche.
for (name, out, src) in [("portrait", (720u32, 1280u32), (360u32, 640u32)), ("landscape", (W, H), SRC)] {
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let f = fake_frame(&gpu, src, Tint::Blue);
for (label, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
let rgba = render(&comp, &f, &scene_json("phone", rotation, 0.6, NO_CURSOR, out), None, T);
save(&dir, &format!("phone-{name}-{label}"), &rgba, out);
}
}
// Ratios inhabituels : rien ne degenere.
for (shape, out, src) in SHAPES {
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let f = fake_frame(&gpu, src, Tint::Blue);
for &device in &["laptop", "monitor"] {
let rgba = render(&comp, &f, &scene_json(device, "null", 0.6, NO_CURSOR, out), None, T);
save(&dir, &format!("shape-{}-{device}", shape.replace(':', "x")), &rgba, out);
}
}
// Gros plan : les coins HAUTS du chrome de fenetre, au rayon maximal. C'est la qu'ils etaient
// faux (cadre arrondi, metrage carre) et que l'arrondi mordait la premiere pastille.
for roundness in ["0.02", "0.09"] {
let json = scene_json("window", "null", 0.6, NO_CURSOR, (W, H))
.replace(r#""roundnessFrac":0.02"#, &format!(r#""roundnessFrac":{roundness}"#));
let rgba = render(&comp, &screen, &json, None, T);
let img = image::RgbaImage::from_raw(W, H, rgba).expect("readback");
let crop = image::imageops::crop_imm(&img, 120, 30, 420, 150).to_image();
let zoom = image::imageops::resize(&crop, 420 * 3, 150 * 3, image::imageops::FilterType::Nearest);
zoom.save(format!("{dir}/window-top-corner-r{}.png", roundness.replace('.', "")))
.expect("gros plan");
}
// Gros plan : la charniere et l'arete du portable, agrandies cinq fois au plus proche pour
// que le micro-chanfrein et son filet de lumiere se jugent au pixel.
let rgba = render(&comp, &screen, &scene_json("laptop", r#""iso""#, 0.6, NO_CURSOR, (W, H)), None, T);
let img = image::RgbaImage::from_raw(W, H, rgba).expect("readback");
let crop = image::imageops::crop_imm(&img, W / 2 - 120, H / 2 - 20, 240, 150).to_image();
let zoom = image::imageops::resize(&crop, 240 * 5, 150 * 5, image::imageops::FilterType::Nearest);
zoom.save(format!("{dir}/laptop-hinge-closeup.png")).expect("gros plan");
println!("planches ecrites dans {dir}");
}
/// Un carré de `2r` px centré sur `p`, agrandi `k` fois au plus proche.
fn closeup(rgba: &[u8], out: (u32, u32), p: (f32, f32), r: u32, k: u32) -> image::RgbaImage {
let img = image::RgbaImage::from_raw(out.0, out.1, rgba.to_vec()).expect("readback");
let x0 = (p.0.round() as i64 - r as i64).clamp(0, (out.0 - 2 * r) as i64) as u32;
let y0 = (p.1.round() as i64 - r as i64).clamp(0, (out.1 - 2 * r) as i64) as u32;
let crop = image::imageops::crop_imm(&img, x0, y0, 2 * r, 2 * r).to_image();
image::imageops::resize(&crop, 2 * r * k, 2 * r * k, image::imageops::FilterType::Nearest)
}
/// Des images côte à côte, séparées d'un filet blanc.
fn strip(imgs: &[image::RgbaImage]) -> image::RgbaImage {
let h = imgs.iter().map(|i| i.height()).max().unwrap_or(1);
let w = imgs.iter().map(|i| i.width() + 6).sum::<u32>();
let mut s = image::RgbaImage::from_pixel(w, h, image::Rgba([255, 255, 255, 255]));
let mut x = 0i64;
for i in imgs {
image::imageops::overlay(&mut s, i, x, 0);
x += i.width() as i64 + 6;
}
s
}
fn save_in(dir: &str, sub: &str, name: &str, img: &image::RgbaImage) {
let d = format!("{dir}/{sub}");
std::fs::create_dir_all(&d).expect("dossier");
img.save(format!("{d}/{name}.png")).unwrap_or_else(|e| panic!("écriture {name} : {e}"));
}
/// Les rendus de la passe 3 (opt-in, `OPENSCREEN_DEVICE_V3`) : chaque cadre autour d'un clip
/// paysage et d'un clip portrait, à plat et sous `iso`, dans les deux thèmes ; les gros plans de
/// coins (portable, fenêtre) à Roundness 0, par défaut et maximal ; les coutures sur fond vert ;
/// les ombres (plat, iso, orbite) ; et les vues de face à comparer aux références produit.
#[test]
fn v3_renders() {
let Some(dir) = out_dir("OPENSCREEN_DEVICE_V3") else {
eprintln!("OPENSCREEN_DEVICE_V3 absent - saute");
return;
};
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let all: [&str; 4] = ["window", "laptop", "phone", "monitor"];
let cams = [("flat", "null"), ("iso", r#""iso""#)];
let img = |rgba: Vec<u8>| image::RgbaImage::from_raw(W, H, rgba).expect("readback");
// 1. Paysage et portrait, plat et iso, clair et sombre : une image par cas, une planche par
// clip et par thème.
for (clip, rect, src) in CLIPS {
let f = fake_frame(&gpu, src, Tint::Blue);
for theme in ["light", "dark"] {
let mut sheet = image::RgbaImage::new(W * 2, H * 4);
for (row, &frame) in all.iter().enumerate() {
for (col, (cam, rotation)) in cams.iter().enumerate() {
let json = with_rect(&scene_json_themed(frame, theme, rotation, 0.6, NO_CURSOR, (W, H)), rect);
let i = img(render(&comp, &f, &json, None, T));
save_in(&dir, "clips", &format!("{frame}-{clip}-{cam}-{theme}"), &i);
image::imageops::overlay(&mut sheet, &i, (col as u32 * W) as i64, (row as u32 * H) as i64);
}
}
save_in(&dir, "clips", &format!("sheet-{clip}-{theme}"), &sheet);
}
}
// 2. Gros plans de coins : les quatre coins de l'écran du portable et de la fenêtre, pris au
// sommet de l'arc du métrage.
let screen = fake_frame(&gpu, SRC, Tint::Blue);
let arc_points = |g: &Geo| {
let [w, h] = g.s_px;
let k = g.radius * (1.0 - std::f32::consts::FRAC_1_SQRT_2);
[[k, k], [w - k, k], [w - k, h - k], [k, h - k]].map(|p| g.to_out(p))
};
for (label, roundness) in [("r0", 0.0f32), ("r002", 0.02), ("rmax", MAX_ROUND)] {
for frame in ["laptop", "window", "phone", "monitor"] {
for (cam, rotation) in cams {
let json =
with_roundness(&with_rect(&scene_json(frame, rotation, 0.6, NO_CURSOR, (W, H)), CLIPS[0].1), roundness);
let rgba = render(&comp, &screen, &json, None, T);
let g = Geo::new(&json, (W, H), SRC);
let crops: Vec<_> = arc_points(&g).iter().map(|&p| closeup(&rgba, (W, H), p, 30, 5)).collect();
save_in(&dir, "closeups", &format!("{frame}-corners-{label}-{cam}"), &strip(&crops));
}
}
}
// 3. Coutures sur fond VERT : les quatre coins (sommet de l'arc) et le milieu du bord bas,
// Roundness 0 et maximal, à plat et iso.
for frame in all {
for (label, roundness) in [("r0", 0.0f32), ("rmax", MAX_ROUND)] {
for (cam, rotation) in cams {
let json = on_green(&with_roundness(&scene_json(frame, rotation, 0.6, NO_CURSOR, (W, H)), roundness));
let rgba = render(&comp, &screen, &json, None, T);
let g = Geo::new(&json, (W, H), SRC);
let mut pts = arc_points(&g).to_vec();
pts.push(g.to_out([g.s_px[0] * 0.5, g.s_px[1]]));
let crops: Vec<_> = pts.iter().map(|&p| closeup(&rgba, (W, H), p, 16, 8)).collect();
save_in(&dir, "seams", &format!("{frame}-{label}-{cam}"), &strip(&crops));
}
}
}
// 4. Ombres : chaque cadre, clair et sombre, à plat, iso et en orbite, ombre au maximum.
for frame in all {
for theme in ["light", "dark"] {
let mut row = Vec::new();
for (cam, rotation) in [("flat", "null"), ("iso", r#""iso""#), ("orbit", ORBIT)] {
let json = with_rect(&scene_json_themed(frame, theme, rotation, 1.0, NO_CURSOR, (W, H)), CLIPS[0].1);
let i = img(render(&comp, &screen, &json, None, T));
save_in(&dir, "shadows", &format!("{frame}-{cam}-{theme}"), &i);
row.push(image::imageops::resize(&i, W / 2, H / 2, image::imageops::FilterType::Triangle));
}
save_in(&dir, "shadows", &format!("strip-{frame}-{theme}"), &strip(&row));
}
}
// 5. Références produit : portable, moniteur et téléphone DE FACE, en 1080p, clair et sombre.
let big = Compositor::new_sized(&gpu, 1920, 1080).expect("compositor");
for frame in ["laptop", "monitor", "phone"] {
for theme in ["light", "dark"] {
let json = with_rect(&scene_json_themed(frame, theme, "null", 0.6, NO_CURSOR, (1920, 1080)), CLIPS[0].1);
let rgba = render(&big, &screen, &json, None, T);
let i = image::RgbaImage::from_raw(1920, 1080, rgba).expect("readback");
save_in(&dir, "reference-match", &format!("{frame}-front-{theme}"), &i);
}
}
println!("rendus v3 écrits dans {dir}");
}
/// 6 s de portable sous la caméra en orbite, curseur modélisé allumé (opt-in,
/// `OPENSCREEN_DEVICE_CLIP`) : un PNG par frame, à assembler en MP4 par ffmpeg.
#[test]
fn orbit_clip_frames() {
let Some(dir) = out_dir("OPENSCREEN_DEVICE_CLIP") else {
eprintln!("OPENSCREEN_DEVICE_CLIP absent — saute");
return;
};
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
// Le pointeur fait le tour de l'écran : l'œil de la caméra le suit sur son orbite.
let mut samples = Vec::new();
for k in 0..=120 {
let t = k as f32 / 20.0;
let a = std::f32::consts::TAU * t / 6.0;
samples.push(format!(
r#"{{"timeMs":{},"cx":{},"cy":{}}}"#,
t * 1000.0,
0.5 + 0.34 * a.cos(),
0.5 + 0.30 * a.sin()
));
}
let path = std::env::temp_dir().join("os_device_orbit.json");
std::fs::write(&path, format!(r#"{{"samples":[{}]}}"#, samples.join(","))).expect("sidecar");
let track = CursorTrack::load(path.to_str().unwrap(), 0.0, 10.0).expect("piste curseur");
let cursor = format!(
r#"{{"show":true,"size":4,"smoothing":0.2,"motionBlur":0,"clickBounce":2.5,"model3d":true,"clipToBounds":false,"theme":"default","cursorSprites":{{"arrow":{{"path":"{}/arrow.png","hotspotX":0.1205,"hotspotY":0.0881}}}}}}"#,
std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../public/cursors/default")
.to_string_lossy()
.replace('\\', "/")
);
let json = scene_json("laptop", ORBIT, 0.6, &cursor, (W, H));
for k in 0..180 {
let t = k as f32 / 30.0;
let rgba = render(&comp, &screen, &json, Some(&track), t);
save(&dir, &format!("f{k:04}"), &rgba, (W, H));
}
println!("180 frames écrites dans {dir}");
}
// ============ Épaisseur des bordures, ratios, plan proche ============
/// Le pixel en (x, y), interpolé entre ses quatre voisins : une mesure au dixième de pixel.
fn bilinear(rgba: &[u8], out: (u32, u32), x: f32, y: f32) -> Option<[f32; 3]> {
let (x, y) = (x - 0.5, y - 0.5);
let (x0, y0) = (x.floor(), y.floor());
if x0 < 0.0 || y0 < 0.0 || x0 + 1.0 >= out.0 as f32 || y0 + 1.0 >= out.1 as f32 {
return None;
}
let (fx, fy) = (x - x0, y - y0);
let at = |i: f32, j: f32| {
let k = ((j as u32 * out.0 + i as u32) * 4) as usize;
[rgba[k] as f32, rgba[k + 1] as f32, rgba[k + 2] as f32]
};
let (a, b, c, d) = (at(x0, y0), at(x0 + 1.0, y0), at(x0, y0 + 1.0), at(x0 + 1.0, y0 + 1.0));
Some(std::array::from_fn(|k| {
(a[k] * (1.0 - fx) + b[k] * fx) * (1.0 - fy) + (c[k] * (1.0 - fx) + d[k] * fx) * fy
}))
}
/// Ce qu'un rayon du plan traverse, du métrage vers le dehors : la distance (px du plan) où le
/// métrage finit, où le verre noir de la lunette finit (le liseré commence), et où le fond d'écran
/// commence. Chacune au passage de mi-hauteur, interpolée entre deux échantillons.
#[derive(Clone, Copy, Debug, Default)]
struct Crossings {
footage: f32,
glass: Option<f32>,
wallpaper: Option<f32>,
}
/// Le vert du fond de `on_green`, en marge vert − max(rouge, bleu).
const GREEN_MARGIN: f32 = 128.0;
/// Marche le rayon `p0 + n·t` (px du plan, `n` unitaire), `p0` bien dans le métrage, sur les deux
/// rendus `a` (teinte bleue) et `b` (orange) : le métrage est ce qui change entre les deux.
fn crossings(g: &Geo, a: &[u8], b: &[u8], out: (u32, u32), p0: [f32; 2], n: [f32; 2], len: f32, dark: bool) -> Option<Crossings> {
let sample = |t: f32| {
let (x, y) = g.to_out([p0[0] + n[0] * t, p0[1] + n[1] * t]);
Some((bilinear(a, out, x, y)?, bilinear(b, out, x, y)?))
};
let diff = |pa: [f32; 3], pb: [f32; 3]| (0..3).map(|k| (pa[k] - pb[k]).abs()).sum::<f32>();
let (a0, b0) = sample(0.0)?;
let full = diff(a0, b0);
assert!(full > 60.0, "sonde hors du métrage ({full})");
// Verre : noir (~10) ; liseré : argent (~180) ou graphite (~55).
let glass_thr = if dark { 30.0 } else { 80.0 };
let (step, mut t) = (0.1f32, 0.0f32);
let mut prev = (1.0f32, 0.0f32, 0.0f32);
let mut c = Crossings::default();
let mut found_footage = false;
while t <= len {
let Some((pa, pb)) = sample(t) else { break };
let foot = diff(pa, pb) / full;
let lum = (pa[0] + pa[1] + pa[2]) / 3.0;
let green = ((pa[1] - pa[0].max(pa[2])) / GREEN_MARGIN).clamp(0.0, 1.0);
let cross = |v0: f32, v1: f32, thr: f32| t - step + (thr - v0) / (v1 - v0) * step;
if !found_footage {
if foot < 0.5 {
c.footage = cross(prev.0, foot, 0.5);
found_footage = true;
}
} else {
if c.glass.is_none() && c.wallpaper.is_none() && lum > glass_thr && prev.1 <= glass_thr {
c.glass = Some(cross(prev.1, lum, glass_thr));
}
if c.wallpaper.is_none() && green > 0.5 {
c.wallpaper = Some(cross(prev.2, green, 0.5));
break;
}
}
prev = (foot, lum, green);
t += step;
}
found_footage.then_some(c)
}
/// Une mesure de bordure en px du PLAN : (l'anneau jusqu'au fond, le verre jusqu'au liseré).
type Border = (Option<f32>, Option<f32>);
/// La bordure qu'un rayon du plan traverse, du métrage vers le dehors, en px du PLAN (la boîte
/// droite) : la géométrie du cadre, qu'on veut concentrique. À plat, ce sont des px de sortie ; sous
/// un angle fixe, la perspective raccourcit x, y et la diagonale différemment, et seule la mesure
/// dans le plan compare un coin à ses bords.
fn border(g: &Geo, a: &[u8], b: &[u8], out: (u32, u32), p0: [f32; 2], n: [f32; 2], len: f32, dark: bool) -> Border {
let Some(c) = crossings(g, a, b, out, p0, n, len, dark) else { return (None, None) };
(c.wallpaper.map(|t| t - c.footage), c.glass.map(|t| t - c.footage))
}
/// Un coin du cadre mesuré sur l'image : le long de sa diagonale à 45°, depuis le centre de l'arc
/// du métrage, et à travers les deux bords qui s'y rejoignent, juste après l'arc du corps — à la
/// même échelle de projection que le coin.
struct CornerProbe {
diag: Border,
side: Border,
end: Border,
/// Px de sortie par px du plan, le long de la diagonale, au coin : 1 à plat. La tolérance d'un
/// pixel de SORTIE vaut `1 / scale` px du plan.
scale: f32,
}
/// Les quatre coins : haut-gauche, haut-droit, bas-droit, bas-gauche.
fn measure_corners(g: &Geo, a: &[u8], b: &[u8], out: (u32, u32), dark: bool) -> [CornerProbe; 4] {
let [w, h] = g.s_px;
let r = g.radius;
let widest = g.body.iter().fold(0.0f32, |m, v| m.max(*v));
let reach = 4.0 * widest + 30.0;
// Assez loin du coin pour que le bord soit droit : au-delà de l'arc extérieur du corps.
let along = r + widest + 12.0;
let k = std::f32::consts::FRAC_1_SQRT_2;
[([0.0, 0.0], [-1.0f32, -1.0f32]), ([w, 0.0], [1.0, -1.0]), ([w, h], [1.0, 1.0]), ([0.0, h], [-1.0, 1.0])].map(
|(c, s)| {
let centre = [c[0] - s[0] * (r + 12.0 * k), c[1] - s[1] * (r + 12.0 * k)];
let apex = [c[0] - s[0] * r * (1.0 - k), c[1] - s[1] * r * (1.0 - k)];
let (p, q) = (g.to_out(apex), g.to_out([apex[0] + s[0] * k, apex[1] + s[1] * k]));
CornerProbe {
scale: (q.0 - p.0).hypot(q.1 - p.1),
diag: border(g, a, b, out, centre, [s[0] * k, s[1] * k], reach + r, dark),
// Le bord vertical (gauche ou droit), puis le bord horizontal (haut ou bas).
side: border(g, a, b, out, [c[0] - s[0] * 12.0, c[1] - s[1] * along], [s[0], 0.0], reach, dark),
end: border(g, a, b, out, [c[0] - s[0] * along, c[1] - s[1] * 12.0], [0.0, s[1]], reach, dark),
}
},
)
}
/// Le Roundness que l'app envoie à sa valeur par défaut (40 px de slider) dans une sortie 1080p.
const DEFAULT_ROUND: f32 = 40.0 / 1080.0;
/// La bordure de la fenêtre et du téléphone garde son épaisseur TOUT AUTOUR de chaque coin, à
/// toutes les valeurs de Roundness : mesurée le long de la diagonale à 45° de chaque coin, elle
/// vaut, au pixel près, celle des deux bords qui s'y rejoignent. Les deux contours sont
/// concentriques (`concentric_radius`). Le portable et le moniteur n'y sont pas soumis : leur
/// coque garde ses rayons et seul l'intérieur de la lunette suit le slider
/// (`only_the_inside_of_the_laptop_and_screen_bezel_follows_roundness`).
///
/// Les épaisseurs se mesurent dans le PLAN (la géométrie du cadre) : sous un angle fixe, la
/// perspective raccourcit x, y et la diagonale différemment. L'écart toléré, lui, est d'un pixel
/// de SORTIE, converti au coin par l'échelle locale de la projection.
///
/// Fenêtre, téléphone ; Roundness 0, par défaut et maximal ; à plat et sous
/// `iso` ; clair et sombre. À plat, l'anneau entier jusqu'au fond d'écran ; sous `iso`, où les
/// flancs de l'appareil se voient, le verre de la lunette jusqu'à son liseré. Les coins HAUTS de
/// la fenêtre sont sous la barre de titre, carrés par construction : on n'y mesure rien.
#[test]
fn the_border_keeps_its_thickness_around_every_corner() {
let Some(gpu) = gpu() else { return };
let out = (1920u32, 1080u32);
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
let orange = fake_frame(&gpu, SRC, Tint::Orange);
let (mut worst, mut failures) = (0.0f32, Vec::new());
for frame in ["window", "phone"] {
for (rlabel, roundness) in [("r0", 0.0f32), ("rdef", DEFAULT_ROUND), ("rmax", MAX_ROUND)] {
for (cam, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
for theme in ["light", "dark"] {
let dark = theme == "dark";
let json = on_green(&with_roundness(
&scene_json_themed(frame, theme, rotation, 0.0, NO_CURSOR, out),
roundness,
));
let (a, b) = (render(&comp, &blue, &json, None, T), render(&comp, &orange, &json, None, T));
let g = Geo::new(&json, out, SRC);
let probes = measure_corners(&g, &a, &b, out, dark);
let case = format!("{frame} {rlabel} {cam} {theme}");
// Deux mesures. Le VERRE de la lunette, du métrage à son liseré, pour les
// appareils — à plat comme sous iso, où les flancs se voient. L'ANNEAU entier,
// du métrage au fond d'écran, à plat — sauf au bas du portable, où la tranche du
// socle prolonge le corps. La fenêtre n'a que son anneau : un filet.
let device = frame != "window";
for (what, pick) in [("verre", 1usize), ("anneau", 0usize)] {
if (what == "verre" && !device) || (what == "anneau" && device && cam != "flat") {
continue;
}
let get = |v: Border| if pick == 0 { v.0 } else { v.1 };
let mut line = String::new();
for (k, p) in probes.iter().enumerate() {
// Les coins hauts de la fenêtre sont sa barre de titre ; le bas du
// portable, à l'anneau, sa charnière et son socle.
if (frame == "window" && k < 2) || (frame == "laptop" && what == "anneau" && k >= 2) {
line.push_str(" - ");
continue;
}
let (Some(dg), Some(e0), Some(e1)) = (get(p.diag), get(p.side), get(p.end)) else {
panic!("{case} {what}: coin {k} non mesuré");
};
let want = 0.5 * (e0 + e1);
line.push_str(&format!(" {dg:5.1}/{e0:5.1}/{e1:5.1} "));
// L'écart, en px de SORTIE : c'est un pixel à l'image qu'on s'accorde.
let off = (dg - want).abs() * p.scale;
worst = worst.max(off);
if off > 1.0 {
failures.push(format!(
"{case} {what}: coin {k} {dg:.2} px au lieu de {want:.2} px (bords {e0:.2} / {e1:.2})"
));
}
}
println!("{case:<26} {what:<6} diag/côté/bout HG HD BD BG :{line}");
}
}
}
}
}
println!("écart maximal diagonale / bords : {worst:.2} px de sortie");
assert!(failures.is_empty(), "{} coins hors tolérance :\n{}", failures.len(), failures.join("\n"));
}
/// Portable et écran : le slider Roundness n'arrondit QUE l'intérieur de la lunette. Entre
/// Roundness 0 et maximal, la silhouette de l'appareil sur le fond (vert, sans ombre) est la même
/// au pixel près, alors que les coins de l'écran, eux, changent visiblement.
#[test]
fn only_the_inside_of_the_laptop_and_screen_bezel_follows_roundness() {
let Some(gpu) = gpu() else { return };
let out = (1920u32, 1080u32);
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
for frame in ["laptop", "monitor"] {
let at = |r: f32| {
let json = on_green(&with_roundness(&scene_json(frame, "null", 0.0, NO_CURSOR, out), r));
render(&comp, &blue, &json, None, T)
};
let (square, round) = (at(0.0), at(MAX_ROUND));
let wall = |rgba: &[u8]| -> Vec<bool> { rgba.chunks_exact(4).map(|p| greenish([p[0], p[1], p[2]])).collect() };
let (ws, wr) = (wall(&square), wall(&round));
let silhouette = ws.iter().zip(&wr).filter(|(a, b)| a != b).count();
let inside = differing(&square, &round, 24);
println!("{frame:<8} silhouette {silhouette} px différents, intérieur {inside} px différents");
assert!(silhouette <= 4, "{frame} : la coque a bougé avec Roundness ({silhouette} px)");
assert!(inside > 400, "{frame} : les coins de l'écran ne suivent pas Roundness ({inside} px)");
}
}
/// Un métrage de ratio `ar` contenu dans 80 % d'une sortie 16:9, comme l'app le contient dans la
/// zone paddée : la même sortie, un autre clip.
fn contained_rect(ar: f32) -> (f32, f32, f32, f32) {
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) };
(0.5 - w * 0.5, 0.5 - h * 0.5, w, h)
}
const RATIOS: [(&str, f32); 5] =
[("16x9", 16.0 / 9.0), ("9x16", 9.0 / 16.0), ("1x1", 1.0), ("4x3", 4.0 / 3.0), ("21x9", 21.0 / 9.0)];
/// Le même cadre sur un clip 16:9, 9:16, 1:1, 4:3 et 21:9, dans la MÊME sortie : les mêmes
/// bordures en px sur les quatre côtés, le même rayon de coin — seule l'ouverture change de
/// forme. Mesuré sur l'image. Les bordures étaient en largeurs de la boîte : autour d'un clip
/// portrait, la lunette tombait au tiers de celle d'un clip paysage.
#[test]
fn a_frame_looks_the_same_on_every_clip_ratio() {
let Some(gpu) = gpu() else { return };
let out = (1920u32, 1080u32);
let comp = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let (w0, h0) = (1280u32, 720u32);
for frame in ["window", "laptop", "phone", "monitor"] {
let mut first: Option<([f32; 4], f32, f32)> = None;
for (label, ar) in RATIOS {
// La source a le ratio du clip : rien n'est recadré, rien n'est étiré.
let src = if ar >= 1.0 { (w0, (w0 as f32 / ar).round() as u32) } else { ((h0 as f32 * ar).round() as u32, h0) };
let src = (src.0 & !1, src.1 & !1);
let blue = fake_frame(&gpu, src, Tint::Blue);
let orange = fake_frame(&gpu, src, Tint::Orange);
let json = on_green(&with_roundness(
&with_rect(&scene_json(frame, "null", 0.0, NO_CURSOR, out), contained_rect(ar)),
DEFAULT_ROUND,
));
let (a, b) = (render(&comp, &blue, &json, None, T), render(&comp, &orange, &json, None, T));
let g = Geo::new(&json, out, src);
let p = measure_corners(&g, &a, &b, out, false);
// Les quatre bords (gauche, haut, droite, bas), mesurés près des coins haut-gauche et
// bas-droit : l'anneau de la fenêtre, le verre des appareils — sous eux, l'anneau
// traverserait le socle du portable ou le pied du moniteur.
let m = |v: Border| if frame == "window" { v.0 } else { v.1 };
let edges = [p[0].side, p[0].end, p[2].side, p[2].end].map(|e| m(e).expect("bord mesuré"));
// Le rayon extérieur du coin haut-droit : depuis le centre de l'arc du métrage, l'arc
// du corps est à R — concentriques — soit le rayon du métrage plus la bordure mesurée.
let outer = g.radius + m(p[1].diag).expect("coin mesuré");
let now = (edges, outer, g.radius);
println!(
"{frame:<8} {label:<5} bords {:5.1?} px, métrage r = {:5.1} px, extérieur R = {outer:5.1} px",
edges, g.radius
);
match first {
None => first = Some(now),
Some((e0, o0, r0)) => {
for k in 0..4 {
assert!((edges[k] - e0[k]).abs() <= 1.0, "{frame} {label}: bord {k} {} px au lieu de {} px", edges[k], e0[k]);
}
assert!((outer - o0).abs() <= 1.0, "{frame} {label}: rayon extérieur {outer} px au lieu de {o0} px");
assert!((g.radius - r0).abs() <= 0.01, "{frame} {label}: rayon du métrage {} au lieu de {r0}", g.radius);
}
}
}
}
}
/// Une piste curseur garée en (x, y) de l'image pendant dix secondes.
fn parked_track(name: &str, x: f32, y: f32) -> CursorTrack {
let samples: Vec<String> = (0..=100).map(|k| format!(r#"{{"timeMs":{},"cx":{x},"cy":{y}}}"#, k * 100)).collect();
let path = std::env::temp_dir().join(format!("os_device_parked_{name}.json"));
std::fs::write(&path, format!(r#"{{"samples":[{}]}}"#, samples.join(","))).expect("sidecar");
CursorTrack::load(path.to_str().unwrap(), 0.0, 10.0).expect("piste curseur")
}
/// Le curseur affiché (la caméra en orbite le suit), minuscule : il ne masque aucune sonde.
const SHOWN_CURSOR: &str = r#"{"show":true,"size":0.2,"smoothing":0,"motionBlur":0,"clickBounce":0,"clipToBounds":false,"theme":"default","cursorSprites":{}}"#;
/// La caméra en orbite qui zoome de `zoom` : la région de zoom de `scene_json`, sous
/// l'orbite en focus auto, à l'échelle voulue.
fn orbit_json(frame: &str, zoom: f32, out: (u32, u32)) -> String {
scene_json(frame, ORBIT, 0.6, SHOWN_CURSOR, out).replace(r#""scale":1,"#, &format!(r#""scale":{zoom},"#))
}
/// Le socle du portable ne couvre JAMAIS le métrage que le zoom montre : au plus fort zoom et aux
/// angles extrêmes de l'orbite, toute la région de mise au point — le centre de l'image, où la
/// caméra vise — est du métrage, pixel par pixel.
///
/// 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 plongeait sous l'écran, et la face inférieure du socle couvrait tout le métrage,
/// son bord avant énorme au premier plan. Au zoom 1, le pointeur en bas : l'ouverture entière.
#[test]
fn the_laptop_deck_never_covers_the_zoom_focus() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let blue = fake_frame(&gpu, SRC, Tint::Blue);
let orange = fake_frame(&gpu, SRC, Tint::Orange);
let pointers = [
("bas", (0.5f32, 0.98f32)),
("bas-gauche", (0.02, 0.98)),
("bas-droite", (0.98, 0.98)),
("haut-gauche", (0.02, 0.02)),
("haut-droite", (0.98, 0.02)),
];
for (name, (x, y)) in pointers {
let track = parked_track(name, x, y);
for zoom in [1.0f32, 2.2, 3.5, 5.0] {
let json = orbit_json("laptop", zoom, (W, H));
let a = render(&comp, &blue, &json, Some(&track), T);
let b = render(&comp, &orange, &json, Some(&track), T);
let (mut n, mut covered) = (0usize, Vec::new());
if zoom > 1.0 {
// La région de mise au point : le centre de l'image, 60 % de chaque côté.
for j in 0..40 {
for i in 0..40 {
let (px_x, px_y) = (W as f32 * (0.2 + 0.6 * i as f32 / 39.0), H as f32 * (0.2 + 0.6 * j as f32 / 39.0));
let (Some(pa), Some(pb)) = (px(&a, (W, H), px_x, px_y), px(&b, (W, H), px_x, px_y)) else { continue };
n += 1;
if pa == pb {
covered.push((px_x.round(), px_y.round(), pa));
}
}
}
} else {
// Au zoom 1 : l'ouverture entière, de 5 % à 95 % de chaque côté.
let (q, _) = aperture_tracked(&json, (W, H), &track);
for j in 1..=19 {
for i in 1..=19 {
let (px_x, px_y) = quad_at(&q, i as f32 / 20.0, j as f32 / 20.0);
let (Some(pa), Some(pb)) = (px(&a, (W, H), px_x, px_y), px(&b, (W, H), px_x, px_y)) else { continue };
n += 1;
if pa == pb {
covered.push((px_x.round(), px_y.round(), pa));
}
}
}
}
println!("{name:<12} zoom {zoom:<4} {n:>5} px sondés, {} couverts", covered.len());
assert!(n > 300, "{name} z{zoom}: trop peu de sondes ({n})");
assert!(covered.is_empty(), "{name} z{zoom}: le socle couvre le métrage en {:?}", &covered[..covered.len().min(6)]);
}
}
}
/// `aperture` sous une piste curseur : la caméra en orbite dépend du pointeur.
fn aperture_tracked(json: &str, out: (u32, u32), track: &CursorTrack) -> ([(f32, f32); 4], [f32; 4]) {
let scene = Scene::from_json(json).expect("scène valide");
let cfg = cfg();
let mut live = live_params_from_scene(&scene);
live.has_webcam = false;
let src = [SRC.0 as f32, SRC.1 as f32];
let g = plan_frame(&FrameGeometryInput {
render_px: [out.0 as f32, out.1 as f32],
screen_tex_px: src,
screen_visible_px: src,
webcam_visible_px: src,
u_max: 1.0,
v_max: 1.0,
frame: 0.0,
cfg: &cfg,
live,
scene: Some(&scene),
cursor: Some(track),
timeline_t_override: Some(T),
programme_time: None,
});
let render_px = [out.0 as f32, out.1 as f32];
let s = g.s_dst;
let s_px = [s[2] * render_px[0], s[3] * render_px[1]];
let center = [(s[0] + s[2] * 0.5) * render_px[0], (s[1] + s[3] * 0.5) * render_px[1]];
let q = g.screen_tilt(s_px).expect("caméra en orbite");
let corners = std::array::from_fn(|i| {
let (fx, fy) = [(0.0, 0.0), (1.0, 0.0), (1.0, 1.0), (0.0, 1.0)][i];
let (x, y) = q.point_px(fx, fy);
(center[0] + x, center[1] + y)
});
(corners, g.window_frame.map(|f| f.margins).unwrap_or([0.0; 4]))
}
/// Les rendus de la passe 4 (opt-in, `OPENSCREEN_DEVICE_V4`) :
/// - `corners/` : les quatre coins de chaque cadre au Roundness maximal, clair et sombre, agrandis ;
/// - `ratios/` : chaque cadre sur un clip 16:9, 9:16, 1:1, 4:3 et 21:9, dans la même sortie ;
/// - `roundness/` : chaque cadre × slider 0, 50 et 100 % × clips 16:9, 9:16, 4:3 et 21:9.
///
/// Le plan proche a son propre rendu, `v4_near_clip`.
#[test]
fn v4_renders() {
let Some(dir) = out_dir("OPENSCREEN_DEVICE_V4") else {
eprintln!("OPENSCREEN_DEVICE_V4 absent - saute");
return;
};
let Some(gpu) = gpu() else { return };
let all: [&str; 4] = ["window", "laptop", "phone", "monitor"];
let out = (1920u32, 1080u32);
let big = Compositor::new_sized(&gpu, out.0, out.1).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
let img = |rgba: Vec<u8>, o: (u32, u32)| image::RgbaImage::from_raw(o.0, o.1, rgba).expect("readback");
// 1. Coins, au Roundness maximal : les quatre coins, 40 px de côté agrandis six fois, clair et
// sombre, à plat et sous iso. En haut de la fenêtre, la barre de titre entière : le coin du
// cadre au-dessus, le coin carré du métrage dessous.
for frame in all {
for theme in ["light", "dark"] {
for (cam, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
let json = with_roundness(&scene_json_themed(frame, theme, rotation, 0.6, NO_CURSOR, out), MAX_ROUND);
let rgba = render(&big, &screen, &json, None, T);
let g = Geo::new(&json, out, SRC);
let [w, h] = g.s_px;
let k = g.radius * (1.0 - std::f32::consts::FRAC_1_SQRT_2);
let top = if frame == "window" { -0.4 * g.body[1] } else { k };
let pts: Vec<[f32; 2]> = vec![[k, top], [w - k, top], [w - k, h - k], [k, h - k]];
let crops: Vec<_> = pts.iter().map(|&p| closeup(&rgba, out, g.to_out(p), 40, 6)).collect();
save_in(&dir, "corners", &format!("{frame}-rmax-{cam}-{theme}"), &strip(&crops));
}
}
}
// 2. Ratios : le même cadre autour de cinq clips, dans la même sortie 1080p.
for theme in ["light", "dark"] {
let mut sheet = image::RgbaImage::from_pixel(out.0 / 2 * 5 + 24, out.1 / 2 * 4 + 18, image::Rgba([255, 255, 255, 255]));
for (row, &frame) in all.iter().enumerate() {
for (col, (label, ar)) in RATIOS.iter().enumerate() {
let src = if *ar >= 1.0 { (1280u32, (1280.0 / ar).round() as u32 & !1) } else { ((720.0 * ar).round() as u32 & !1, 720u32) };
let f = fake_frame(&gpu, src, Tint::Blue);
let json = with_rect(&scene_json_themed(frame, theme, "null", 0.6, NO_CURSOR, out), contained_rect(*ar));
let json = with_roundness(&json, DEFAULT_ROUND);
let i = img(render(&big, &f, &json, None, T), out);
save_in(&dir, "ratios", &format!("{frame}-{label}-{theme}"), &i);
let small = image::imageops::resize(&i, out.0 / 2, out.1 / 2, image::imageops::FilterType::Triangle);
image::imageops::overlay(&mut sheet, &small, (col as u32 * (out.0 / 2 + 6)) as i64, (row as u32 * (out.1 / 2 + 6)) as i64);
}
}
save_in(&dir, "ratios", &format!("sheet-{theme}"), &sheet);
}
// 3. La course de Roundness de chaque cadre : 0, 50 et 100 % du slider, sur quatre clips.
let ratios4 = [RATIOS[0], RATIOS[1], RATIOS[3], RATIOS[4]];
for frame in all {
let mut sheet = image::RgbaImage::from_pixel(out.0 / 2 * 4 + 18, out.1 / 2 * 3 + 12, image::Rgba([255, 255, 255, 255]));
for (row, pct) in [0.0f32, 0.5, 1.0].into_iter().enumerate() {
for (col, (label, ar)) in ratios4.iter().enumerate() {
let src = if *ar >= 1.0 { (1280u32, (1280.0 / ar).round() as u32 & !1) } else { ((720.0 * ar).round() as u32 & !1, 720u32) };
let f = fake_frame(&gpu, src, Tint::Blue);
let json = with_rect(&scene_json(frame, "null", 0.6, NO_CURSOR, out), contained_rect(*ar));
let json = with_roundness(&json, pct * 64.0 / 1080.0);
let i = img(render(&big, &f, &json, None, T), out);
save_in(&dir, "roundness", &format!("{frame}-{}-{label}", (pct * 100.0) as u32), &i);
let small = image::imageops::resize(&i, out.0 / 2, out.1 / 2, image::imageops::FilterType::Triangle);
image::imageops::overlay(&mut sheet, &small, (col as u32 * (out.0 / 2 + 6)) as i64, (row as u32 * (out.1 / 2 + 6)) as i64);
}
}
save_in(&dir, "roundness", &format!("sheet-{frame}"), &sheet);
}
println!("rendus v4 écrits dans {dir}");
}
/// Le plan proche, en images (opt-in, `OPENSCREEN_DEVICE_V4`, dans `near-clip/`) : le portable
/// sous la caméra en orbite, pointeur au bas de l'écran — là où le socle couvrait le métrage —,
/// zoom avant de 1 à 3,5 puis retour, 6 s à 30 images/s (à assembler en MP4), et une planche de
/// douze instants. Le métrage est plus petit que la sortie : l'appareil y tient entier au repos.
#[test]
fn v4_near_clip() {
let Some(dir) = out_dir("OPENSCREEN_DEVICE_V4") else {
eprintln!("OPENSCREEN_DEVICE_V4 absent - saute");
return;
};
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, W, H).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
let track = parked_track("near", 0.5, 0.97);
let json = with_rect(&scene_json("laptop", ORBIT, 0.6, SHOWN_CURSOR, (W, H)), CLIPS[0].1)
.replace(
r#""zoomRegions":[{"clipIndex":0,"startSec":0,"endSec":10,"scale":1,"#,
r#""zoomRegions":[{"clipIndex":0,"startSec":1.2,"endSec":4.4,"scale":3.5,"#,
);
std::fs::create_dir_all(format!("{dir}/near-clip/frames")).expect("dossier");
let mut sheet = Vec::new();
for k in 0..180 {
let t = k as f32 / 30.0;
let rgba = render(&comp, &screen, &json, Some(&track), t);
save(&format!("{dir}/near-clip/frames"), &format!("f{k:04}"), &rgba, (W, H));
if k % 15 == 0 {
let i = image::RgbaImage::from_raw(W, H, rgba).expect("readback");
sheet.push(image::imageops::resize(&i, W / 4, H / 4, image::imageops::FilterType::Triangle));
}
}
let (w4, h4) = (W / 4 + 6, H / 4 + 6);
let mut grid = image::RgbaImage::from_pixel(w4 * 6, h4 * 2, image::Rgba([255, 255, 255, 255]));
for (k, i) in sheet.iter().enumerate() {
image::imageops::overlay(&mut grid, i, ((k % 6) as u32 * w4) as i64, ((k / 6) as u32 * h4) as i64);
}
save_in(&dir, "near-clip", "sheet", &grid);
println!("180 images écrites dans {dir}/near-clip/frames");
}
/// Coût d'une frame 1080p, cadre d'appareil allumé contre éteint (opt-in, à lancer en release).
/// Le readback synchronise chaque frame et pèse autant des deux côtés ; on alterne les deux
/// réglages et on garde le meilleur de cinq passes.
#[test]
fn bench_the_device_frame_at_1080p() {
if std::env::var("OPENSCREEN_DEVICE_BENCH").is_err() {
eprintln!("OPENSCREEN_DEVICE_BENCH absent — saute");
return;
}
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1920, 1080).expect("compositor");
let screen = fake_frame(&gpu, SRC, Tint::Blue);
let time = |json: &str| {
let scene = Scene::from_json(json).expect("scène");
let mut live = live_params_from_scene(&scene);
live.has_webcam = false;
comp.set_live_params(live);
comp.set_has_webcam(false);
comp.set_scene(Some(scene));
comp.clear_cursor();
comp.set_timeline_time(Some(T));
let cfg = cfg();
let t0 = std::time::Instant::now();
for _ in 0..100 {
unsafe {
comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose");
comp.readback_direct().expect("readback");
}
}
t0.elapsed().as_secs_f64() * 10.0
};
for rotation in ["null", r#""iso""#, ORBIT] {
for &device in &DEVICES {
let (off, on) = (
scene_json("none", rotation, 0.6, NO_CURSOR, (1920, 1080)),
scene_json(device, rotation, 0.6, NO_CURSOR, (1920, 1080)),
);
time(&off);
time(&on);
let (mut a, mut b) = (f64::MAX, f64::MAX);
for _ in 0..5 {
a = a.min(time(&off));
b = b.min(time(&on));
}
println!("{rotation:<16} {device:<8} éteint {a:6.3} ms allumé {b:6.3} ms (+{:.3})", b - a);
}
}
}