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
//! Le curseur modélisé (`cursor.model3d`, mode 15) rendu par le vrai compositeur D3D11 : chaque
//! état du thème par défaut, extrudé depuis son sprite.
//!
//! La source est une frame NV12 SYNTHÉTIQUE (une texture remplie ici, présentée comme une frame
//! D3D11VA) : 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
//! $env:OPENSCREEN_CURSOR3D_OUT = "...\renders" # facultatif : un PNG par cas, et la planche
//! cargo test -p openscreen-compositor --test cursor_model_render -- --nocapture
//! # coût d'une frame 1080p, curseur 3D allumé contre éteint (opt-in) :
//! $env:OPENSCREEN_CURSOR3D_BENCH = "1"
//! cargo test -p openscreen-compositor --release --test cursor_model_render bench -- --nocapture
//! ```
#![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_cursor, plan_frame, CursorPlacement, CursorPlanInput,
FrameGeometryInput,
};
use openscreen_compositor::scene::Scene;
mod common;
use common::{gpu, Nv12Frame};
const SRC: (u32, u32) = (640, 360);
/// Instant rendu : en plein palier de la région de zoom (0..10 s).
const T: f32 = 2.0;
/// Creux de `regions::tap` : un clic à `T - CONTACT_S` montre le modèle posé à `T`.
const CONTACT_S: f32 = 0.0495;
/// Les seize états du thème par défaut et leurs hotspots (`DEFAULT_CURSOR_SPRITES`,
/// `src/lib/cursor/cursorThemes.ts`).
const STATES: [(&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 que les tests de rendu passent en revue : pointeurs, centrés, entre deux.
const TESTED: [&str; 6] = ["arrow", "pointer", "text", "open-hand", "resize-ew", "not-allowed"];
/// Les états dont le hotspot est au centre : ni tangage ni lacet.
fn is_centred(key: &str) -> bool {
matches!(key, "text" | "resize-ew" | "not-allowed")
}
/// Deux teintes de contenu : un pixel identique sur les deux est du modèle opaque, un pixel qui
/// change est le contenu, son ombre ou une frange antialiasée.
#[derive(Clone, Copy)]
enum Tint {
Blue,
Orange,
/// Pour l'œil, pas pour les masques : un damier clair et sombre sur un dégradé de teintes, où
/// la réfraction d'un verre se lit d'un coup.
Checker,
/// Pour l'œil aussi : une page claire, des lignes de texte et un bouton bleu, ce qu'une démo
/// filme le plus souvent.
Page,
/// La même page en thème sombre : là où un trait noir ne se voit plus.
DarkPage,
}
/// Une frame NV12 synthétique : `data[0]` = la texture, `data[1]` = tranche 0, comme une frame
/// D3D11VA (le seul contrat que `Compositor::nv12_srvs` lit). Une teinte moyenne striée de barres
/// plus sombres : rien d'aussi clair ni d'aussi sombre que le curseur, et surtout rien de NEUTRE,
/// si bien qu'un pixel gris est le curseur et un pixel teinté assombri, son ombre.
fn fake_frame(gpu: &Gpu, tint: Tint) -> Nv12Frame {
let (w, h) = (SRC.0 as usize, SRC.1 as usize);
let checker = matches!(tint, Tint::Checker);
let page = matches!(tint, Tint::Page | Tint::DarkPage);
let dark = matches!(tint, Tint::DarkPage);
let [u, v] = match tint {
Tint::Blue => [150, 120],
Tint::Orange | Tint::Checker => [100, 170],
Tint::Page | Tint::DarkPage => [128, 128],
};
// Le bouton de la page : un rect bleu, texte blanc.
let button = |row: usize, col: usize| (150..190).contains(&row) && (330..470).contains(&col);
// Une ligne de texte sur trois rangées de 18 px, en mots de largeur variable.
let text = |row: usize, col: usize| {
let (line, y) = (row / 18, row % 18);
let word = (col + line * 37) / 23;
(5..11).contains(&y) && (col + line * 37) % 23 < 4 + (word * 7 + line * 3) % 15 && line % 5 != 4
};
Nv12Frame::new(
gpu,
SRC,
|col, row| {
let (row, col) = (row as usize, col as usize);
let bar = row % 24 >= 8 && row % 24 < 12 && (col / 40) % 3 != 2;
match (checker, (row / 10 + col / 10) % 2 == 0) {
(true, light) => if light { 200 } else { 60 },
_ if page && button(row, col) => if text(row, col) { 235 } else { 105 },
_ if page && dark => if text(row, col) { 200 } else { 28 },
_ if page => if text(row, col) { 45 } else { 232 },
(false, _) => if bar { 90 } else { 150 },
}
},
|bx, by| {
let (bx, by) = (bx as usize, by as usize);
if checker {
[(70 + 2 * bx * 120 / w) as u8, (190 - by * 2 * 120 / h) as u8]
} else if page && button(2 * by, 2 * bx) {
[175, 105]
} else {
[u, v]
}
},
)
}
/// Des rayures verticales nettes, claires et sombres, de 7 px de source (11,2 px rendus : assez
/// serrées pour que des dizaines de bords croisent la lentille, assez larges pour qu'un décalage
/// de 5 px ne tombe pas sur le bord voisin) ; `inverse` les échange. Rendue sur les deux, une
/// lentille ajoute les mêmes reflets : le signe de l'écart des deux rendus dit quelle rayure se
/// voit en chaque pixel.
fn stripes(gpu: &Gpu, inverse: bool) -> Nv12Frame {
Nv12Frame::new(gpu, SRC, |col, _| if (col / 7 % 2 == 0) != inverse { 200 } else { 60 }, |_, _| [128, 128])
}
/// Les bords des rayures sur chaque ligne (x en px) : où ce signe change entre deux pixels de
/// `keep` à 3 px au plus. Un écart faible (le trait, un reflet saturé, la transition d'un bord) ne
/// tranche pas.
fn stripe_edges(on: &[u8], on_inverse: &[u8], keep: impl Fn(usize) -> bool) -> Vec<Vec<f32>> {
(0..720)
.map(|y| {
let (mut edges, mut last) = (Vec::new(), None);
for x in 0..1280 {
if !keep(y * 1280 + x) {
last = None;
continue;
}
let d = luma(px(on, x as i32, y as i32)) - luma(px(on_inverse, x as i32, y as i32));
if d.abs() < 30.0 {
continue;
}
if let Some((lx, light)) = last {
if light != (d > 0.0) && x - lx <= 3 {
edges.push((lx + x) as f32 / 2.0);
}
}
last = Some((x, d > 0.0));
}
edges
})
.collect()
}
/// Le dossier des curseurs livrés, `public/cursors`.
fn cursors_dir() -> String {
std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../../public/cursors")
.to_string_lossy()
.replace('\\', "/")
}
/// Les thèmes d'origine et les hotspots de leur flèche et de leur main plates (`CURSOR_THEMES`,
/// `src/lib/cursor/cursorThemes.ts`, sur 32).
const SCULPTED: [(&str, [f32; 2], [f32; 2]); 6] = [
("studio-ink", [6.2304, 2.0992], [12.848, 2.0704]),
("prism-glow", [6.3456, 2.0672], [11.968, 2.0352]),
("pop-coral", [10.4768, 2.1792], [12.3456, 2.0]),
("pixel-candy", [6.5, 2.0], [10.75, 2.0]),
("star-sprout", [4.7232, 2.1152], [13.1712, 2.0384]),
("glass-lens", [6.2304, 2.0992], [12.848, 2.0704]),
];
/// Les thèmes de verre : le cristal de Prism Glow, la lentille de Glass Lens.
fn is_glass(theme: &str) -> bool {
matches!(theme, "prism-glow" | "glass-lens")
}
/// Les seize sprites livrés au format `cursorSprites` de la scène, avec la flèche et la main
/// plates du thème d'origine `sculpted`, comme les passe `resolveCursorSprites` : leur curseur
/// sculpté en 3D, et le verre à plat de Glass Lens dans tous les cas.
fn sprites_json_with(sculpted: Option<&str>, model3d: bool) -> String {
let dir = cursors_dir();
let theme = sculpted.map(|name| *SCULPTED.iter().find(|(t, ..)| *t == name).expect("thème d'origine"));
let entries: Vec<String> = STATES
.iter()
.map(|(key, [hx, hy])| match (theme, *key) {
(Some((name, [ax, ay], _)), "arrow") | (Some((name, _, [ax, ay])), "pointer") => {
let sculpt = if model3d { format!(r#","sculpt":"{name}/{key}""#) } else { String::new() };
let glass = if name == "glass-lens" { format!(r#","glass":"{name}/{key}""#) } else { String::new() };
format!(
r#""{key}":{{"path":"{dir}/{name}/{key}.png","hotspotX":{},"hotspotY":{}{sculpt}{glass}}}"#,
ax / 32.0,
ay / 32.0
)
}
_ => format!(r#""{key}":{{"path":"{dir}/default/{key}.png","hotspotX":{hx},"hotspotY":{hy}}}"#),
})
.collect();
format!("{{{}}}", entries.join(","))
}
/// `model3d` : `None` = clé absente (payload d'avant le réglage).
fn scene_json(rotation: &str, model3d: Option<bool>, theme: &str, motion_blur: f32, size: f32) -> String {
scene_json_with(rotation, model3d, theme, motion_blur, size, &sprites_json_with(None, false))
}
/// Un thème d'origine en 3D : sa flèche et sa main sculptées.
fn sculpted_scene_json(rotation: &str, theme: &str, size: f32) -> String {
scene_json_with(rotation, Some(true), theme, 0.0, size, &sprites_json_with(Some(theme), true))
}
/// Glass Lens, 3D éteinte : son verre à plat.
fn glass_scene_json(rotation: &str, size: f32) -> String {
scene_json_with(rotation, Some(false), "glass-lens", 0.0, size, &sprites_json_with(Some("glass-lens"), false))
}
fn scene_json_with(
rotation: &str,
model3d: Option<bool>,
theme: &str,
motion_blur: f32,
size: f32,
sprites: &str,
) -> String {
let model3d = model3d.map(|m| format!(r#","model3d":{m}"#)).unwrap_or_default();
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}}}},
"effects":{{"padding":0.2,"blur":false,"shadow":0,"roundnessFrac":0.03,"motionBlur":0}},
"background":{{"kind":"gradient","angleDeg":135,"stops":["#5b6ee1","#e8a0bf"]}},
"zoomRegions":[{{"clipIndex":0,"startSec":0,"endSec":10,"scale":1,"focusX":0.5,"focusY":0.5,"focusMode":"manual","rotation":{rotation}}}],
"annotations":[],
"cursor":{{"show":true,"size":{size},"smoothing":0,"motionBlur":{motion_blur},"clickBounce":2.5{model3d},"clipToBounds":false,"theme":"{theme}",
"cursorSprites":{sprites}}},
"cropByClip":[null],
"output":{{"width":1280,"height":720,"fps":30}}}}"##
)
}
/// La même scène, curseur masqué : la référence « sans curseur ».
fn hidden_json(rotation: &str) -> String {
scene_json(rotation, Some(true), "default", 0.0, 3.0).replace(r#""show":true"#, r#""show":false"#)
}
/// Piste curseur écrite dans un sidecar temporaire : `(t, x, y, clic)`, dans l'état `kind`
/// (`None` = pas de clé, la flèche).
fn track_as(name: &str, kind: Option<&str>, samples: &[(f32, f32, f32, bool)]) -> CursorTrack {
let kind = kind.map(|k| format!(r#","cursorType":"{k}""#)).unwrap_or_default();
let body: Vec<String> = samples
.iter()
.map(|&(t, x, y, click)| {
let click = if click { r#","interactionType":"click""# } else { "" };
format!(r#"{{"timeMs":{},"cx":{x},"cy":{y}{click}{kind}}}"#, t * 1000.0)
})
.collect();
let path = std::env::temp_dir().join(format!("os_cursor_model_{name}.json"));
std::fs::write(&path, format!(r#"{{"samples":[{}]}}"#, body.join(","))).expect("sidecar");
CursorTrack::load(path.to_str().unwrap(), 0.0, 10.0).expect("piste curseur")
}
fn track(name: &str, samples: &[(f32, f32, f32, bool)]) -> CursorTrack {
track_as(name, None, samples)
}
/// Une piste immobile en (0.45, 0.45) dans l'état `kind`, avec ou sans clic au creux du contact
/// à `T`.
fn resting_as(name: &str, kind: Option<&str>, click: bool) -> CursorTrack {
resting_at(name, kind, click, 0.45)
}
/// `resting_as`, en (`at`, `at`) : 0,5 est le centre de l'écran, sur l'axe de la caméra.
fn resting_at(name: &str, kind: Option<&str>, click: bool, at: f32) -> CursorTrack {
let mut s = vec![(0.0, at, at, false), (T - CONTACT_S - 0.2, at, at, false)];
if click {
s.push((T - CONTACT_S, at, at, true));
}
s.push((9.0, at, at, false));
track_as(name, kind, &s)
}
fn resting(name: &str, click: bool) -> CursorTrack {
resting_as(name, None, click)
}
fn cfg() -> Cfg {
let mut cfg = Cfg::c8();
cfg.bg_blur = 0.0;
cfg.zoom = false;
cfg.layout_anim = false;
cfg.cursor = true;
cfg.mblur_n = 1;
cfg.shadow = false;
cfg
}
/// Ce que la frame dit du curseur : le pixel du contenu qu'il vise et son unité en px.
#[derive(Clone, Copy)]
struct Probe {
tip: [f32; 2],
unit: f32,
}
fn render(comp: &Compositor, screen: &Nv12Frame, json: &str, track: &CursorTrack) -> (Vec<u8>, Probe) {
let (rgba, probe) = render_any(comp, screen, json, track);
(rgba, probe.expect("un curseur à dessiner"))
}
/// `render`, sans exiger de curseur (scène au curseur masqué).
fn render_any(
comp: &Compositor,
screen: &Nv12Frame,
json: &str,
track: &CursorTrack,
) -> (Vec<u8>, Option<Probe>) {
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.clone()));
comp.set_cursor(track.clone());
comp.set_cursor_time(Some(T));
comp.set_timeline_time(Some(T));
let cfg = cfg();
let (w, h, rgba) = unsafe {
comp.compose_frame(screen.as_ptr(), screen.as_ptr(), 0.0, &cfg).expect("compose_frame");
comp.readback_direct().expect("readback")
};
let render_px = [w as f32, h as f32];
let src = [SRC.0 as f32, SRC.1 as f32];
let g = plan_frame(&FrameGeometryInput {
render_px,
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 Some(plan) = plan_cursor(
&g,
&CursorPlanInput {
render_px,
u_max: 1.0,
v_max: 1.0,
cfg: &cfg,
live,
scene: Some(&scene),
track,
t: T,
},
) else {
return (rgba, None);
};
let (tip, scale) = match plan.placement {
CursorPlacement::Tilted { plane_pt, quad, center_px, .. } => {
let (x, y) = quad.point_px(plane_pt[0], plane_pt[1]);
([center_px[0] + x, center_px[1] + y], quad.scale)
}
CursorPlacement::Upright { center } => ([center[0] * render_px[0], center[1] * render_px[1]], 1.0),
};
(rgba, Some(Probe { tip, unit: plan.size_px * scale }))
}
fn px(rgba: &[u8], x: i32, y: i32) -> [u8; 4] {
let i = ((y * 1280 + x) * 4) as usize;
[rgba[i], rgba[i + 1], rgba[i + 2], rgba[i + 3]]
}
fn luma(p: [u8; 4]) -> f32 {
0.2126 * p[0] as f32 + 0.7152 * p[1] as f32 + 0.0722 * p[2] as f32
}
fn is_neutral(p: [u8; 4]) -> bool {
p[0].max(p[1]).max(p[2]) - p[0].min(p[1]).min(p[2]) < 12
}
fn is_white(p: [u8; 4]) -> bool {
p[0] > 200 && p[1] > 200 && p[2] > 200
}
fn is_black(p: [u8; 4]) -> bool {
p[0] < 45 && p[1] < 45 && p[2] < 45
}
/// Ce qui distingue une frame avec flèche de la même sans : les pixels de la flèche (neutres,
/// quand le contenu est bleu) et ceux d'ombre (le bleu du contenu, assombri), avec leurs
/// centroïdes et la distance de l'ombre la plus proche de la pointe.
struct Split {
body: usize,
white: usize,
black: usize,
shadow: usize,
body_c: [f32; 2],
shadow_c: [f32; 2],
/// Distance (px) du pixel d'ombre le plus proche de l'apex de la silhouette.
shadow_near_apex: f32,
}
fn split(with: &[u8], without: &[u8], apex: [f32; 2]) -> Split {
let mut s = Split {
body: 0,
white: 0,
black: 0,
shadow: 0,
body_c: [0.0; 2],
shadow_c: [0.0; 2],
shadow_near_apex: f32::MAX,
};
let body = |x: i32, y: i32| {
(0..1280).contains(&x)
&& (0..720).contains(&y)
&& px(with, x, y) != px(without, x, y)
&& is_neutral(px(with, x, y))
};
for y in 0..720 {
for x in 0..1280 {
let (a, b) = (px(with, x, y), px(without, x, y));
if a == b {
continue;
}
// La frange antialiasée de la silhouette mêle la flèche au contenu : ni corps ni
// ombre, on l'écarte (deux pixels autour du corps).
let fringe = (-2..=2).any(|dy| (-2..=2).any(|dx| body(x + dx, y + dy)));
if is_neutral(a) {
s.body += 1;
s.white += is_white(a) as usize;
s.black += is_black(a) as usize;
s.body_c[0] += x as f32;
s.body_c[1] += y as f32;
} else if !fringe && luma(a) < luma(b) - 6.0 {
s.shadow += 1;
s.shadow_c[0] += x as f32;
s.shadow_c[1] += y as f32;
let d = (x as f32 - apex[0]).hypot(y as f32 - apex[1]);
s.shadow_near_apex = s.shadow_near_apex.min(d);
}
}
}
for (c, n) in [(&mut s.body_c, s.body), (&mut s.shadow_c, s.shadow)] {
*c = [c[0] / n.max(1) as f32, c[1] / n.max(1) as f32];
}
s
}
/// Les pixels OPAQUES du curseur : identiques sur les deux teintes de contenu, différents du
/// contenu nu.
fn opaque_mask(on_blue: &[u8], on_orange: &[u8], bare_blue: &[u8]) -> Vec<bool> {
(0..1280 * 720)
.map(|i| {
let (a, b, c) = (&on_blue[i * 4..i * 4 + 3], &on_orange[i * 4..i * 4 + 3], &bare_blue[i * 4..i * 4 + 3]);
a == b && a != c
})
.collect()
}
/// Les pixels que couvre un curseur de VERRE (le cristal de Prism Glow, qui laisse voir le contenu
/// et le réfracte) : opaques, ou changés sur les deux teintes sans y être plus sombres (une ombre
/// ne fait qu'assombrir ; le verre réfracte, reflète et luit).
fn covered_mask(on_blue: &[u8], on_orange: &[u8], bare_blue: &[u8], bare_orange: &[u8]) -> Vec<bool> {
let opaque = opaque_mask(on_blue, on_orange, bare_blue);
let px = |img: &[u8], i: usize| [img[i * 4], img[i * 4 + 1], img[i * 4 + 2], 255];
(0..1280 * 720)
.map(|i| {
let lit = |on: &[u8], bare: &[u8]| px(on, i) != px(bare, i) && luma(px(on, i)) >= luma(px(bare, i)) - 2.0;
opaque[i] || (lit(on_blue, bare_blue) && lit(on_orange, bare_orange))
})
.collect()
}
fn iou(a: &[bool], b: &[bool]) -> f32 {
let inter = a.iter().zip(b).filter(|(x, y)| **x && **y).count();
let union = a.iter().zip(b).filter(|(x, y)| **x || **y).count();
inter as f32 / union.max(1) as f32
}
/// Part des pixels de `a` qui ont un pixel de `b` à `r` px au plus (norme max) : l'accord de deux
/// silhouettes à la perspective près.
fn within(a: &[bool], b: &[bool], r: i32) -> f32 {
let near = |i: usize| {
let (x, y) = ((i % 1280) as i32, (i / 1280) as i32);
(-r..=r).any(|dy| {
(-r..=r).any(|dx| {
let (x, y) = (x + dx, y + dy);
(0..1280).contains(&x) && (0..720).contains(&y) && b[(y * 1280 + x) as usize]
})
})
};
let hits: Vec<usize> = (0..a.len()).filter(|&i| a[i]).collect();
hits.iter().filter(|&&i| near(i)).count() as f32 / hits.len().max(1) as f32
}
/// Parts des pixels sombres, clairs et rouges parmi ceux du masque qui tombent dans l'une des
/// trois classes : les demi-teintes du chanfrein n'y comptent pas.
fn palette(rgba: &[u8], mask: &[bool]) -> [f32; 3] {
let mut c = [0usize; 3];
for (i, _) in mask.iter().enumerate().filter(|(_, m)| **m) {
let p = [rgba[i * 4] as i32, rgba[i * 4 + 1] as i32, rgba[i * 4 + 2] as i32];
c[0] += (p.iter().max().unwrap() < &70) as usize;
c[1] += (p.iter().min().unwrap() > &150) as usize;
c[2] += (p[0] > p[1] + 60 && p[0] > p[2] + 60) as usize;
}
let n = c.iter().sum::<usize>().max(1) as f32;
c.map(|k| k as f32 / n)
}
fn out_dir() -> Option<String> {
let dir = std::env::var("OPENSCREEN_CURSOR3D_OUT").ok()?;
std::fs::create_dir_all(&dir).expect("dossier de sortie");
Some(dir)
}
fn save(name: &str, rgba: &[u8]) {
let Some(dir) = out_dir() else { return };
let path = format!("{dir}/{name}.png");
image::RgbaImage::from_raw(1280, 720, rgba.to_vec())
.expect("dimensions du readback")
.save(&path)
.unwrap_or_else(|e| panic!("écriture {path} : {e}"));
println!("écrit {path}");
}
#[test]
fn the_modelled_arrow_stands_on_the_screen_and_casts_its_shadow() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
let still = resting("still", false);
let clicked = resting("clicked", true);
for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
let bare = render_any(&comp, &screen, &hidden_json(rotation), &still).0;
let (hover, p) = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &still);
let (touch, q) =
render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &clicked);
save(&format!("{name}-hover"), &hover);
save(&format!("{name}-touch"), &touch);
// L'apex de la silhouette : le filet blanc dépasse le hotspot vers le haut-gauche.
let apex = |p: &Probe| [p.tip[0] - 0.03 * p.unit, p.tip[1] - 0.07 * p.unit];
let (a, b) = (split(&hover, &bare, apex(&p)), split(&touch, &bare, apex(&q)));
println!(
"{name} : unité {:.1} px, pointe {:?} | en l'air : corps {} (blanc {}, noir {}), ombre {} \
à {:.1} px de l'apex, centroïdes {:?} / {:?} | posée : ombre à {:.1} px, centroïdes {:?} / {:?}",
p.unit, p.tip, a.body, a.white, a.black, a.shadow, a.shadow_near_apex, a.body_c, a.shadow_c,
b.shadow_near_apex, b.body_c, b.shadow_c
);
// La pointe : le hotspot est la pointe de l'incrustation noire. Juste sous elle, dans le
// corps, c'est noir ; juste au-dessus-gauche, le filet blanc ; loin au-dessus-gauche, le
// contenu, intact (l'ombre part vers le bas-droite).
let u = p.unit;
let at = |dx: f32, dy: f32| px(&hover, (p.tip[0] + dx * u) as i32, (p.tip[1] + dy * u) as i32);
assert!(is_black(at(0.07, 0.3)), "{name}: pas d'incrustation noire sous la pointe : {:?}", at(0.07, 0.3));
assert!(is_white(at(-0.035, -0.02)) || is_white(at(-0.04, 0.05)), "{name}: pas de filet blanc à la pointe");
let far = [(p.tip[0] - 0.3 * u) as i32, (p.tip[1] - 0.3 * u) as i32];
assert_eq!(px(&hover, far[0], far[1]), px(&bare, far[0], far[1]), "{name}: le haut-gauche a bougé");
// Corps blanc ET noir, de la taille d'une flèche : 0,35 u² de silhouette dans le PNG.
let area = 0.35 * u * u;
assert!(a.white as f32 > 0.15 * area && a.black as f32 > 0.25 * area, "{name}: matières absentes");
assert!((a.body as f32) < 1.5 * area && (a.body as f32) > 0.7 * area, "{name}: taille {} pour {area}", a.body);
// L'ombre : présente, du côté opposé à la lumière (bas-droite de la flèche).
assert!(a.shadow as f32 > 0.1 * area, "{name}: pas d'ombre en l'air ({})", a.shadow);
assert!(
a.shadow_c[0] > a.body_c[0] && a.shadow_c[1] > a.body_c[1],
"{name}: l'ombre n'est pas en bas à droite ({:?} / {:?})",
a.shadow_c,
a.body_c
);
// Posée, l'ombre rejoint la pointe et se resserre sous la flèche.
assert!(b.shadow_near_apex < 0.1 * u, "{name}: posée, l'ombre est à {:.1} px de l'apex", b.shadow_near_apex);
assert!(a.shadow_near_apex > 0.2 * u, "{name}: en l'air, l'ombre touche l'apex ({:.1} px)", a.shadow_near_apex);
let gap = |s: &Split| (s.shadow_c[0] - s.body_c[0]).hypot(s.shadow_c[1] - s.body_c[1]);
// (La queue, relevée par la pression, garde son ombre au loin : le centroïde ne se
// rapproche que d'une fraction de la hauteur.)
assert!(gap(&b) < gap(&a) - 0.1 * u, "{name}: l'ombre ne se rapproche pas au contact ({} / {})", gap(&b), gap(&a));
// La pointe ne bouge pas quand la flèche descend (elle est sur le rayon de vue).
assert!((p.tip[0] - q.tip[0]).abs() < 0.01 && (p.tip[1] - q.tip[1]).abs() < 0.01);
}
}
/// Chaque état garde son art et sa silhouette : posé au centre de l'écran (sur l'axe de la
/// caméra, donc vu de face), le modèle couvre ce que couvre le sprite plat, avec ses couleurs, et
/// il porte une ombre en l'air.
#[test]
fn every_state_keeps_its_art_and_its_footprint() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let (blue, orange) = (fake_frame(&gpu, Tint::Blue), fake_frame(&gpu, Tint::Orange));
const SIZE: f32 = 5.0;
let bare = render_any(&comp, &blue, &hidden_json("null"), &resting("bare", false)).0;
let mut failures = Vec::new();
for key in TESTED {
let still = resting_at(&format!("art-still-{key}"), Some(key), false, 0.5);
let clicked = resting_at(&format!("art-clicked-{key}"), Some(key), true, 0.5);
let (on3d, flat) =
(scene_json("null", Some(true), "default", 0.0, SIZE), scene_json("null", Some(false), "default", 0.0, SIZE));
let (touch, p) = render(&comp, &blue, &on3d, &clicked);
let touch_b = render(&comp, &orange, &on3d, &clicked).0;
let (hover, _) = render(&comp, &blue, &on3d, &still);
let sprite = render(&comp, &blue, &flat, &still).0;
let sprite_b = render(&comp, &orange, &flat, &still).0;
save(&format!("art-{key}-touch"), &touch);
save(&format!("art-{key}-sprite"), &sprite);
let m3d = opaque_mask(&touch, &touch_b, &bare);
let m2d = opaque_mask(&sprite, &sprite_b, &bare);
let overlap = iou(&m3d, &m2d);
let (near3d, near2d) = (within(&m3d, &m2d, 2), within(&m2d, &m3d, 2));
let (pal3d, pal2d) = (palette(&touch, &m3d), palette(&sprite, &m2d));
let area = m2d.iter().filter(|m| **m).count() as f32;
// L'ombre en l'air : ce qui a changé, n'est pas du modèle, et s'est assombri.
let shadow = (0..1280 * 720)
.filter(|&i| {
let (a, b) = (&hover[i * 4..i * 4 + 4], &bare[i * 4..i * 4 + 4]);
a != b
&& !is_neutral([a[0], a[1], a[2], 255])
&& luma([a[0], a[1], a[2], 255]) < luma([b[0], b[1], b[2], 255]) - 6.0
})
.count() as f32;
println!(
"{key} : unité {:.1} px, IoU {overlap:.3}, à 2 px près {near3d:.3} / {near2d:.3}, sprite {area} px, \
palette 3D {pal3d:?} / sprite {pal2d:?}, ombre {shadow} px",
p.unit
);
// De face et à plat, un curseur centré est son sprite, à la perspective près : le dessus
// est à une épaisseur du plan, donc agrandi de ~3 % (1 à 2 px, ce qui suffit à baisser
// l'IoU d'un trait fin comme le I ; à 2 px près, les silhouettes coïncident). Un pointeur est basculé de 28°
// (tangage de la pression) : raccourci, et le flanc de sa queue relevée se voit, de la
// couleur de son bord.
let (min_iou, min_near, palette_tol) =
if is_centred(key) { (0.75, 0.98, 0.07) } else { (0.6, 0.9, 0.2) };
if overlap <= min_iou || near3d < min_near || near2d < min_near {
failures.push(format!("{key}: la silhouette s'écarte du sprite (IoU {overlap}, {near3d} / {near2d})"));
}
for (c, (a, b)) in ["sombre", "clair", "rouge"].iter().zip(pal3d.iter().zip(pal2d.iter())) {
if (a - b).abs() >= palette_tol {
failures.push(format!("{key}: part {c} {a} contre {b} dans le sprite"));
}
}
if shadow <= 0.3 * area {
failures.push(format!("{key}: pas d'ombre en l'air ({shadow} px)"));
}
}
assert!(failures.is_empty(), "{failures:#?}");
}
/// Incliné et à plat, le modèle n'a pas la même silhouette : le plan l'emporte avec lui. Au focus,
/// l'angle fixe lui garde sa taille (`plan_cursor`) : seule son orientation sépare les deux
/// silhouettes, et un demi-pixel de décalage en changerait autant de pixels. Les deux rendus
/// posent donc la pointe sur le même point, fraction de pixel comprise.
#[test]
fn the_tilt_turns_every_state_with_the_screen() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
for key in TESTED {
let mask = |rotation: &str, x: f32, y: f32| -> (Vec<bool>, Probe) {
let still = track_as(&format!("tilt-{key}"), Some(key), &[(0.0, x, y, false), (9.0, x, y, false)]);
let (rgba, p) = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &still);
// Silhouette relative au hotspot, sur une fenêtre de ±1,1 unité.
let r = (1.1 * p.unit) as i32;
let mut m = Vec::new();
for dy in -r..r {
for dx in -r..r {
let (x, y) = (p.tip[0] as i32 + dx, p.tip[1] as i32 + dy);
m.push((0..1280).contains(&x) && (0..720).contains(&y) && is_neutral(px(&rgba, x, y)));
}
}
(m, p)
};
let (iso, pi) = mask(r#""iso""#, 0.45, 0.45);
// À plat, l'écran couvre 1024 × 576 px depuis (128, 72) (`screenRect`) : la pointe s'y pose
// sur celle du rendu incliné.
let (flat, pf) = mask("null", (pi.tip[0] - 128.0) / 1024.0, (pi.tip[1] - 72.0) / 576.0);
assert!(
(pf.tip[0] - pi.tip[0]).abs() < 0.01 && (pf.tip[1] - pi.tip[1]).abs() < 0.01,
"{key}: pointes {:?} et {:?}",
pf.tip,
pi.tip
);
let n = flat.len().min(iso.len());
let differ = (0..n).filter(|&k| flat[k] != iso[k]).count();
println!("{key} : {differ} px diffèrent (unités {:.1} / {:.1})", pf.unit, pi.unit);
assert!(differ as f32 > 0.02 * pf.unit * pf.unit, "{key}: le modèle ne suit pas l'inclinaison ({differ})");
}
}
/// Le réglage éteint garde le sprite plat. Activé, le mode 3D dépend du sprite fourni au natif,
/// pas du libellé du thème.
#[test]
fn without_the_model_the_cursor_renders_the_flat_sprite() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
let still = resting("flat-sprite", false);
let clicked = resting("flat-sprite-clicked", true);
let text = resting_as("flat-sprite-text", Some("text"), false);
for rotation in ["null", r#""iso""#] {
let absent = render(&comp, &screen, &scene_json(rotation, None, "default", 0.0, 3.0), &still).0;
let off = render(&comp, &screen, &scene_json(rotation, Some(false), "default", 0.0, 3.0), &still).0;
let other = render(&comp, &screen, &scene_json(rotation, Some(true), "other", 0.0, 3.0), &still).0;
let on = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &still).0;
let off_click = render(&comp, &screen, &scene_json(rotation, Some(false), "default", 0.0, 3.0), &clicked).0;
if let Ok(dir) = std::env::var("OPENSCREEN_CURSOR3D_FLAT_REF") {
// Comparaison à des frames rendues par un commit de base : le même test, lancé
// là-bas, écrit les références ; lancé ici, il les relit. La frame plate, et celle du
// modèle au repos (sans clic), et le sprite plat au creux d'un clic.
let preset = if rotation == "null" { "flat" } else { "iso" };
for (kind, frame) in [("flat", &absent), ("model", &on), ("flat-click", &off_click)] {
let name = format!("{dir}/{kind}-{preset}.rgba");
match std::fs::read(&name) {
Ok(before) => assert!(&before == frame, "{rotation}: la frame {kind} diffère de la référence"),
Err(_) => std::fs::write(&name, frame).expect("écriture de la référence"),
}
}
}
assert!(absent == off, "{rotation}: model3d=false a changé la frame");
assert!(other == on, "{rotation}: le libellé du thème a changé le rendu natif");
assert!(absent != on, "{rotation}: le réglage allumé ne change rien");
let text_off = render(&comp, &screen, &scene_json(rotation, Some(false), "default", 0.0, 3.0), &text).0;
let text_other = render(&comp, &screen, &scene_json(rotation, Some(true), "other", 0.0, 3.0), &text).0;
let text_on = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 3.0), &text).0;
assert!(text_other == text_on, "{rotation}: le libellé du thème a changé le rendu natif du I");
assert!(text_off != text_on, "{rotation}: le I ne passe pas en 3D");
assert!(text_off != off, "{rotation}: l'état n'a pas changé le sprite");
}
}
/// Le lacet : en mouvement vers la droite, la flèche tourne sa pointe vers la droite ; un
/// curseur centré, lui, ne tourne pas.
#[test]
fn a_moving_pointer_turns_towards_its_motion_and_a_centred_cursor_does_not() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
let json = scene_json(r#""iso""#, Some(true), "default", 0.0, 3.0);
// En T, la piste mobile passe en x = 0,2 + 0,6 × T / (T + 1) = 0,6 : la piste immobile y est.
let moving_as = |key: Option<&str>| {
track_as(&format!("moving-{}", key.unwrap_or("arrow")), key, &[(0.0, 0.2, 0.45, false), (T + 1.0, 0.8, 0.45, false)])
};
let still_as =
|key: Option<&str>| track_as(&format!("still-yaw-{}", key.unwrap_or("arrow")), key, &[(0.0, 0.6, 0.45, false), (9.0, 0.6, 0.45, false)]);
let (rgba, p) = render(&comp, &screen, &json, &moving_as(None));
save("iso-moving", &rgba);
// Au repos la queue descend à droite de la pointe ; tournée vers la droite, elle part vers
// la gauche : l'extrémité de la queue (bas du corps) est donc moins à droite qu'au repos.
let (rest, r) = render(&comp, &screen, &json, &still_as(None));
let tail_x = |rgba: &[u8], p: &Probe| {
let y = (p.tip[1] + 0.8 * p.unit) as i32;
let xs: Vec<i32> = (0..1280).filter(|&x| is_neutral(px(rgba, x, y))).collect();
xs.iter().sum::<i32>() as f32 / xs.len().max(1) as f32 - p.tip[0]
};
let (moving_x, rest_x) = (tail_x(&rgba, &p), tail_x(&rest, &r));
println!("queue : {moving_x:.1} px en mouvement, {rest_x:.1} px au repos");
assert!(moving_x < rest_x - 0.05 * p.unit, "la flèche ne tourne pas vers son mouvement");
// Le redimensionnement horizontal, même mouvement : même silhouette qu'immobile. Sur un écran
// à plat, que le mouvement du curseur n'incline pas : les deux pistes s'y croisent au pixel.
let flat = scene_json("null", Some(true), "default", 0.0, 3.0);
let silhouette = |rgba: &[u8]| -> Vec<bool> { (0..1280 * 720).map(|i| is_neutral(px(rgba, i % 1280, i / 1280))).collect() };
let pair = |key: Option<&str>| {
let (moved, pm) = render(&comp, &screen, &flat, &moving_as(key));
let (held, ph) = render(&comp, &screen, &flat, &still_as(key));
assert!((pm.tip[0] - ph.tip[0]).abs() < 0.01, "les deux pistes ne se croisent pas en T : {:?} / {:?}", pm.tip, ph.tip);
iou(&silhouette(&moved), &silhouette(&held))
};
let (same, arrow_same) = (pair(Some("resize-ew")), pair(None));
println!("silhouettes mobile/immobile : redimensionnement {same:.3}, flèche {arrow_same:.3}");
assert!(same > 0.97, "le redimensionnement tourne avec son mouvement ({same})");
assert!(arrow_same < same - 0.05, "la flèche devrait, elle, tourner ({arrow_same})");
}
/// La traînée de flou de mouvement : des copies du modèle, pas un sprite plat.
#[test]
fn the_motion_blur_trail_draws_modelled_copies() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
let moving = track("trail", &[(0.0, 0.2, 0.45, false), (T + 1.0, 0.8, 0.45, false)]);
let (rgba, _) = render(&comp, &screen, &scene_json("null", Some(true), "default", 1.0, 3.0), &moving);
let (flat, _) = render(&comp, &screen, &scene_json("null", Some(false), "default", 1.0, 3.0), &moving);
save("flat-trail", &rgba);
assert!(rgba != flat, "la traînée 3D est celle du sprite plat");
}
/// Les curseurs sculptés (flèche et main de chaque thème), dessinés par le shader et non extrudés
/// d'un PNG : chacun est là, sa pointe sur le hotspot, son corps en bas à droite de celle-ci (y
/// vers le bas : un modèle retourné finirait au-dessus), et il porte son ombre en l'air. Le
/// cristal de Prism Glow est de verre : son corps compte ce qu'il couvre, et il doit laisser voir
/// le contenu (une bonne part de lui change avec la teinte de l'écran).
#[test]
fn the_sculpted_cursors_stand_at_the_hotspot() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let (blue, orange) = (fake_frame(&gpu, Tint::Blue), fake_frame(&gpu, Tint::Orange));
let bare = render_any(&comp, &blue, &hidden_json("null"), &resting("sculpt-bare", false)).0;
let bare_orange = render_any(&comp, &orange, &hidden_json("null"), &resting("sculpt-bare", false)).0;
let mut failures = Vec::new();
for (theme, ..) in SCULPTED {
for state in ["arrow", "pointer"] {
let json = sculpted_scene_json("null", theme, 5.0);
let still = resting_at(&format!("sculpt-{theme}-{state}"), Some(state), false, 0.5);
let (hover, p) = render(&comp, &blue, &json, &still);
let hover_b = render(&comp, &orange, &json, &still).0;
save(&format!("sculpt-{theme}-{state}"), &hover);
let glass = is_glass(theme);
let mask = if glass { covered_mask(&hover, &hover_b, &bare, &bare_orange) } else { opaque_mask(&hover, &hover_b, &bare) };
let (mut body, mut c, mut near) = (0usize, [0.0f32; 2], f32::MAX);
for y in 0..720 {
for x in 0..1280 {
if mask[y * 1280 + x] {
body += 1;
c = [c[0] + x as f32, c[1] + y as f32];
near = near.min((x as f32 - p.tip[0]).hypot(y as f32 - p.tip[1]));
}
}
}
let c = [c[0] / body.max(1) as f32, c[1] / body.max(1) as f32];
let shadow = (0..1280 * 720)
.filter(|&i| {
let (a, b) = (&hover[i * 4..i * 4 + 4], &bare[i * 4..i * 4 + 4]);
!mask[i] && a != b && luma([a[0], a[1], a[2], 255]) < luma([b[0], b[1], b[2], 255]) - 6.0
})
.count();
let u = p.unit;
println!(
"{theme}/{state} : unité {u:.1} px, corps {body} px, pointe à {near:.1} px du hotspot, \
centroïde {c:?} pour la pointe {:?}, ombre {shadow} px",
p.tip
);
if (body as f32) < 0.12 * u * u {
failures.push(format!("{theme}/{state} : {body} px de corps pour {u:.0} px d'unité"));
}
if near > 0.08 * u {
failures.push(format!("{theme}/{state} : le modèle est à {near:.1} px du hotspot"));
}
if !(c[0] > p.tip[0] && c[1] > p.tip[1] + 0.2 * u) {
failures.push(format!("{theme}/{state} : corps en {c:?}, pas en bas à droite de {:?}", p.tip));
}
if shadow * 10 < body * 3 {
failures.push(format!("{theme}/{state} : pas d'ombre en l'air ({shadow} px)"));
}
if glass {
let through = (0..1280 * 720).filter(|&i| mask[i] && hover[i * 4..i * 4 + 3] != hover_b[i * 4..i * 4 + 3]).count();
println!("{theme}/{state} : {through} px du corps laissent voir l'écran");
if through * 10 < body * 3 {
failures.push(format!("{theme}/{state} : le cristal ne laisse voir l'écran que sur {through} px"));
}
}
}
}
assert!(failures.is_empty(), "{failures:#?}");
}
/// Glass Lens, 3D éteinte : son verre à plat (mode 19), sans ombre, donc tout pixel changé est le
/// sien. La flèche et la main sont là, pointe au hotspot et corps en bas à droite ; l'écran se
/// voit au travers (une bonne part du corps change avec sa teinte) ; le trait les cerne (des
/// pixels sombres, les mêmes sur les deux teintes) ; et le verre réfracte : sur des rayures, des
/// bords vus au travers de la lentille sont à plusieurs pixels de tout bord de la même ligne sans
/// elle. Un verre sans réfraction (indice 1) y éclaire l'image, mais n'en déplace aucun bord.
#[test]
fn the_flat_glass_lens_refracts_the_picture() {
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let (blue, orange) = (fake_frame(&gpu, Tint::Blue), fake_frame(&gpu, Tint::Orange));
let (light, dark) = (stripes(&gpu, false), stripes(&gpu, true));
let bare = render_any(&comp, &blue, &hidden_json("null"), &resting("glass-bare", false)).0;
let bare_orange = render_any(&comp, &orange, &hidden_json("null"), &resting("glass-bare", false)).0;
let bare_light = render_any(&comp, &light, &hidden_json("null"), &resting("glass-bare", false)).0;
let bare_dark = render_any(&comp, &dark, &hidden_json("null"), &resting("glass-bare", false)).0;
let bare_edges = stripe_edges(&bare_light, &bare_dark, |_| true);
let mut failures = Vec::new();
for state in ["arrow", "pointer"] {
let json = glass_scene_json("null", 5.0);
let still = resting_at(&format!("glass-flat-{state}"), Some(state), false, 0.5);
let (on_blue, p) = render(&comp, &blue, &json, &still);
let on_orange = render(&comp, &orange, &json, &still).0;
let (on_light, on_dark) = (render(&comp, &light, &json, &still).0, render(&comp, &dark, &json, &still).0);
save(&format!("glass-flat-{state}"), &on_blue);
save(&format!("glass-flat-{state}-stripes"), &on_light);
let rgb = |img: &[u8], i: usize| [img[i * 4], img[i * 4 + 1], img[i * 4 + 2], 255];
let (mut body, mut c, mut near) = (0usize, [0.0f32; 2], f32::MAX);
let (mut through, mut line) = (0usize, 0usize);
for i in 0..1280 * 720 {
let (a, b) = (rgb(&on_blue, i), rgb(&on_orange, i));
if a == rgb(&bare, i) && b == rgb(&bare_orange, i) {
continue;
}
let (x, y) = ((i % 1280) as f32, (i / 1280) as f32);
body += 1;
c = [c[0] + x, c[1] + y];
near = near.min((x - p.tip[0]).hypot(y - p.tip[1]));
if a != b {
through += 1;
} else if luma(a) < 60.0 {
line += 1;
}
}
let c = [c[0] / body.max(1) as f32, c[1] / body.max(1) as f32];
// Les bords vus au travers du verre (les pixels qu'il change), chacun à sa distance du bord
// le plus proche de la même ligne sans lui.
let in_glass = |i: usize| rgb(&on_light, i) != rgb(&bare_light, i) || rgb(&on_dark, i) != rgb(&bare_dark, i);
let shifts: Vec<f32> = stripe_edges(&on_light, &on_dark, in_glass)
.iter()
.zip(&bare_edges)
.flat_map(|(seen, under)| seen.iter().map(|e| under.iter().map(|b| (e - b).abs()).fold(f32::MAX, f32::min)))
.collect();
let shifted = shifts.iter().filter(|s| **s >= 3.0).count();
let widest = shifts.iter().copied().fold(0.0, f32::max);
let u = p.unit;
println!(
"glass-lens/{state} à plat : unité {u:.1} px, corps {body} px, pointe à {near:.1} px du hotspot, \
centroïde {c:?} pour la pointe {:?}, {through} px laissent voir l'écran, {line} px de trait, \
{} bords vus au travers, {shifted} décalés de 3 px ou plus, jusqu'à {widest:.1} px",
p.tip,
shifts.len()
);
if (body as f32) < 0.12 * u * u {
failures.push(format!("glass-lens/{state} : {body} px de corps pour {u:.0} px d'unité"));
}
if near > 0.08 * u {
failures.push(format!("glass-lens/{state} : le verre est à {near:.1} px du hotspot"));
}
if !(c[0] > p.tip[0] && c[1] > p.tip[1] + 0.2 * u) {
failures.push(format!("glass-lens/{state} : corps en {c:?}, pas en bas à droite de {:?}", p.tip));
}
if through * 10 < body * 5 {
failures.push(format!("glass-lens/{state} : l'écran ne se voit que sur {through} px"));
}
if line * 20 < body {
failures.push(format!("glass-lens/{state} : {line} px de trait seulement"));
}
// Mesuré : 23 et 67 bords décalés (jusqu'à 5,5 px) ; à l'indice 1, aucun (1 px au plus).
if shifted < 10 {
failures.push(format!(
"glass-lens/{state} : le verre ne décale que {shifted} bords de 3 px ou plus, au plus de {widest:.1} px"
));
}
}
assert!(failures.is_empty(), "{failures:#?}");
}
/// Planches à regarder (opt-in, `OPENSCREEN_CURSOR3D_OUT`) : les seize états en l'air sur un
/// écran à plat, chacun à côté de son sprite plat ; la flèche, la main et le I posés sur un écran
/// incliné ; et les grandes flèches (taille 8) qui servent à la comparaison avec le modèle
/// analytique d'avant.
#[test]
fn contact_sheets() {
let Some(dir) = out_dir() else {
eprintln!("OPENSCREEN_CURSOR3D_OUT absent — saute");
return;
};
let Some(gpu) = gpu() else { return };
let comp = Compositor::new_sized(&gpu, 1280, 720).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
const CELL: u32 = 300;
let crop = |rgba: &[u8], p: Probe| {
let img = image::RgbaImage::from_raw(1280, 720, rgba.to_vec()).expect("readback");
let (x, y) = ((p.tip[0] - 0.7 * p.unit).max(0.0) as u32, (p.tip[1] - 0.7 * p.unit).max(0.0) as u32);
image::imageops::crop_imm(&img, x, y, CELL, CELL).to_image()
};
let mut sheet = image::RgbaImage::new(8 * CELL, 4 * CELL);
for (i, (key, _)) in STATES.iter().enumerate() {
let still = resting_as(&format!("sheet-{key}"), Some(key), false);
let (flat, p) = render(&comp, &screen, &scene_json("null", Some(false), "default", 0.0, 5.0), &still);
let (hover, q) = render(&comp, &screen, &scene_json("null", Some(true), "default", 0.0, 5.0), &still);
let (col, row) = ((i % 4) as u32 * 2, (i / 4) as u32);
image::imageops::overlay(&mut sheet, &crop(&flat, p), (col * CELL) as i64, (row * CELL) as i64);
image::imageops::overlay(&mut sheet, &crop(&hover, q), ((col + 1) * CELL) as i64, (row * CELL) as i64);
}
sheet.save(format!("{dir}/states-hover-flat.png")).expect("planche");
let mut tilted = image::RgbaImage::new(3 * CELL, 2 * CELL);
for (i, key) in ["arrow", "pointer", "text"].iter().enumerate() {
let clicked = resting_as(&format!("sheet-touch-{key}"), Some(key), true);
for (row, rotation) in ["null", r#""iso""#].iter().enumerate() {
let (touch, p) = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 5.0), &clicked);
image::imageops::overlay(&mut tilted, &crop(&touch, p), i as i64 * CELL as i64, row as i64 * CELL as i64);
}
}
tilted.save(format!("{dir}/states-touch-flat-and-iso.png")).expect("planche");
// Les curseurs sculptés : un thème par ligne, flèche et main en l'air sur l'écran à plat,
// puis posées sur l'écran incliné.
let cases = [("arrow", "null", false), ("pointer", "null", false), ("arrow", r#""iso""#, true), ("pointer", r#""iso""#, true)];
let mut sculpted = image::RgbaImage::new(4 * CELL, SCULPTED.len() as u32 * CELL);
for (row, (theme, ..)) in SCULPTED.iter().enumerate() {
for (col, (state, rotation, click)) in cases.iter().enumerate() {
let track = resting_as(&format!("sheet-{theme}-{col}"), Some(state), *click);
let (rgba, p) = render(&comp, &screen, &sculpted_scene_json(rotation, theme, 5.0), &track);
image::imageops::overlay(&mut sculpted, &crop(&rgba, p), (col as u32 * CELL) as i64, (row as u32 * CELL) as i64);
}
}
sculpted.save(format!("{dir}/sculpted.png")).expect("planche");
// Glass Lens à la taille par défaut, sur une page claire puis sombre : son verre à plat (3D
// éteinte, sans clic : le sprite plat rapetisse au clic) sur l'écran droit puis incliné, et son
// modèle 3D dans les mêmes cases.
let checker = fake_frame(&gpu, Tint::Checker);
let page = fake_frame(&gpu, Tint::Page);
let dark_page = fake_frame(&gpu, Tint::DarkPage);
let mut glass = image::RgbaImage::new(4 * CELL, 4 * CELL);
for (row, screen) in [&page, &dark_page].into_iter().enumerate() {
for (col, (state, rotation, click)) in cases.iter().enumerate() {
let still = resting_as(&format!("sheet-glass-flat-{col}"), Some(state), false);
let (rgba, p) = render(&comp, screen, &glass_scene_json(rotation, 3.6), &still);
let y = (2 * row as u32 * CELL) as i64;
image::imageops::overlay(&mut glass, &crop(&rgba, p), (col as u32 * CELL) as i64, y);
let track = resting_as(&format!("sheet-glass-{col}"), Some(state), *click);
let (rgba, p) = render(&comp, screen, &sculpted_scene_json(rotation, "glass-lens", 3.6), &track);
image::imageops::overlay(&mut glass, &crop(&rgba, p), (col as u32 * CELL) as i64, y + CELL as i64);
}
}
glass.save(format!("{dir}/glass-lens.png")).expect("planche");
for (bg, screen) in [("checker", &checker), ("page", &page), ("dark", &dark_page)] {
for state in ["arrow", "pointer"] {
let still = resting_as(&format!("big-glass-{state}"), Some(state), false);
let (rgba, _) = render(&comp, screen, &glass_scene_json("null", 10.0), &still);
save(&format!("big-glass-flat-{state}-{bg}"), &rgba);
let (rgba, _) = render(&comp, screen, &sculpted_scene_json("null", "glass-lens", 10.0), &still);
save(&format!("big-glass-3d-{state}-{bg}"), &rgba);
}
}
let (still, clicked) = (resting("big-still", false), resting("big-clicked", true));
for (name, rotation) in [("flat", "null"), ("iso", r#""iso""#)] {
for (case, tr) in [("hover", &still), ("touch", &clicked)] {
let (rgba, _) = render(&comp, &screen, &scene_json(rotation, Some(true), "default", 0.0, 8.0), tr);
save(&format!("big-{name}-{case}"), &rgba);
}
}
}
/// Coût d'une frame 1080p, curseur 3D allumé contre éteint (opt-in, à lancer en release). Le
/// readback synchronise chaque frame (sans lui on ne mesurerait que la mise en file) et pèse
/// autant des deux côtés : on alterne les deux réglages et on garde le meilleur de cinq passes.
/// `OPENSCREEN_CURSOR3D_BENCH=warp` mesure le backend logiciel (WARP) au lieu du GPU.
#[test]
fn bench_the_modelled_cursor_at_1080p() {
let Ok(which) = std::env::var("OPENSCREEN_CURSOR3D_BENCH") else {
eprintln!("OPENSCREEN_CURSOR3D_BENCH absent — saute");
return;
};
let gpu = if which == "warp" {
Gpu::create_backend(openscreen_compositor::d3d::Backend::Cpu, false).expect("WARP")
} else {
let Some(gpu) = gpu() else { return };
gpu
};
let comp = Compositor::new_sized(&gpu, 1920, 1080).expect("compositor");
let screen = fake_frame(&gpu, Tint::Blue);
let still = resting("bench", false);
let text = resting_as("bench-text", Some("text"), false);
// Un geste rapide : la traînée prend ses 16 copies.
let fast = track("bench-fast", &[(0.0, 0.2, 0.45, false), (T - 0.15, 0.2, 0.45, false), (T + 0.15, 0.8, 0.45, false), (9.0, 0.8, 0.45, false)]);
let time = |json: &str, track: &CursorTrack| {
let scene = Scene::from_json(json).expect("scène");
comp.set_live_params(live_params_from_scene(&scene));
comp.set_has_webcam(false);
comp.set_scene(Some(scene));
comp.set_cursor(track.clone());
comp.set_cursor_time(Some(T));
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""#] {
for (label, blur, size, tr) in [
("taille 3, net", 0.0, 3.0, &still),
("taille 10, net", 0.0, 10.0, &still),
("taille 10, I", 0.0, 10.0, &text),
("taille 10, traînée 16", 1.0, 10.0, &fast),
] {
let (off_json, on_json) = (
scene_json(rotation, Some(false), "default", blur, size),
scene_json(rotation, Some(true), "default", blur, size),
);
time(&off_json, tr);
time(&on_json, tr);
let (mut off, mut on) = (f64::MAX, f64::MAX);
for _ in 0..5 {
off = off.min(time(&off_json, tr));
on = on.min(time(&on_json, tr));
}
println!("{which} 1080p {rotation} {label} : sprite {off:.2} ms, curseur 3D {on:.2} ms ({:+.2} ms)", on - off);
}
}
}