Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

129 KB
Raw Blame
// Tranche verticale WP3 — port 1:1 des modes 0 (vidéo NV12) et 1 (couleur pleine)
// du `ps_main` HLSL (`crates/compositor/src/shaders.hlsl`). Le mode 2 (ombre
// portée) partage la même SDF et le même feather que les autres modes, donc on
// l'inclut aussi pour parité.
//
// Les constantes YUV (BT.709 limited) sont reprises à l'identique du HLSL :
//   Yf  = (Y  * 255 − 16) / 219
//   Cb  = (UV.x * 255 − 128) / 224
//   Cr  = (UV.y * 255 − 128) / 224
//   R   = Yf + 1.5748 · Cr
//   G   = Yf − 0.1873 · Cb − 0.4681 · Cr
//   B   = Yf + 1.8556 · Cb
// Mesuré en S1 (cf. doc §7 E1). Une déviation > 0/255 entre HLSL et WGSL ici
// indiquerait une différence de précision fp32 ; IEEE-754 round-to-nearest est
// identique sur les deux backends.
//
// Le rendu est en alpha PRÉMULTIPLIÉ (cf. commentaire HLSL), convention qu'on
// retrouve dans tous les autres modes du compositeur (texte, curseur, ombre).
//
// `LAYER_MODELS` n'est PAS declare ici : `compositor_linux.rs` (`layer_source`) le prefixe et
// compile ce source deux fois. Un shader unique alloue a CHAQUE calque les registres de sa
// branche la plus lourde, et ce sont les modeles 3D ray-traces (modes 15 a 17) : 168 VGPR sous
// ACO (Radeon 610M), donc 6 vagues par SIMD au lieu de 32 pour le fond, l'ombre et la video, qui
// couvrent toute la sortie : l'export Linux du banc etait passe de 31 a 57 s. Sans ces trois modes,
// 48 VGPR et 20 vagues. Le pipeline plat (`false`) dessine donc tout le reste, et seuls le
// curseur modelise, l'impact de son clic, l'appareil et son ombre passent par l'autre : c'est
// `LayerCB::needs_models` qui en decide, au draw (`draw_layer`), d'apres le mode du calque.

struct Layer {
    dst: vec4<f32>,       // x,y,w,h sortie 0..1 (origine haut-gauche)
    src: vec4<f32>,       // u0,v0,u1,v1 source 0..1 ; mode 14 : .x = 1 si warp projectif ; modes 15 et 17 : (decalage px du rayon, P, unite du modele px)
    quad_px: vec2<f32>,   // taille du quad en px de sortie (pour la SDF isotrope)
    radius_px: f32,       // mode 15 : rapport w/h du sprite (son plus grand cote vaut 1 unite) ; mode 17 : rayon exterieur des coins HAUTS du corps (unites du modele)
    mode: f32,            // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre, 8 = écran tilté, 9 = flèche, 10 = flou/mosaïque, 12 = ombre du quad tilté, 13 = curseur tilté, 14 = cadre de fenetre, 15 = curseur modelise, 16 = impact du clic (emplacements : `cursor_impact_cb`), 17 = cadre d'appareil modelise (`device_frame_cb`)
    color: vec4<f32>,     // mode 8 (camera reelle) : .xy = gradient d'eclairage ; mode 14 : fond de la barre de titre ; mode 15 : .rg = coin du sprite (unites du modele), .b = ecrasement de l'epaisseur, .a = opacite ; mode 17 : .r = l'appareil (1 portable, 2 telephone, 3 moniteur), .g = 1 si theme sombre, .b = rayon exterieur des coins BAS du corps (unites du modele), .a = opacite
    fx: vec4<f32>,        // mode 2 : spread ombre en px ; mode 5 : (direction xy, temps programme replie, mouvement 0..3) ; modes 8/12/13/14 : coins TL,TR du quad projeté ; mode 9 : hampe de la flèche ; mode 10 : (flou?, rayon/bloc px, ovale?, teinté?) ; mode 15 : (rotation du plan X, Y, Z en rad, tangage) ; mode 17 : (rotation du plan X, Y, Z en rad, epaisseur du corps)
    src_prev: vec4<f32>,  // modes 8/12/13/14 : coins BR,BL du quad projeté ; mode 9 : barbe 1 ; mode 10 incliné : coins BR,BL du masque ; mode 15 : (hotspot du dessus, repere du plan en px ; lacet) ; mode 17 : marges du corps (gauche, haut, droite, bas ; unites du modele)
    dst_prev: vec4<f32>,  // mode 8 : .xy = taille du plan en px AVANT projection (le rayon y vit), .z = 1 si coins hauts carres (sous un cadre), .w = 1 si warp projectif ; mode 14 : .xy = taille du plan du cadre, .z = hauteur de la barre, .w = epaisseur du filet (px du plan) ; modes 13 et 15 : rect de clip ; mode 9 : barbe 2 ; mode 10 incliné : coins TL,TR du masque ; mode 17 : (angle du socle depuis le plan en rad, rayon de l'ouverture et recouvrement de la lunette en unites du modele, penombre de l'ombre ou 0)
    mb: vec4<f32>,        // mode 8 : [gx, gy, z_focus, k], profondeur du plan et flou (texels source) par px d'ecart, k = 0 coupe ; mode 0 : .x taps, .y force du flou, .w = 1 si coins hauts carres (sous un cadre) ; mode 5 : mb.x = aspect w/h de la sortie (fond anime) ; mode 12 : mb.y = spread de la pénombre en px ; mode 9 : mb.y = demi-épaisseur du trait en px ; mode 10 : mb.z = 1 si masque incliné, mb.w = 1 si son warp est projectif ; mode 13 : mb.x = 1 si warp projectif ; mode 14 : couleur du filet (alpha droit) ; modes 15 et 17 : .xy = demi-taille du plan dans son repere (px pour le 15, unites pour le 17), .zw = translation du plan (repere camera, px) ; mode 18 : .z = 1 si le plan est incline, .w = 1 si son warp est projectif
    trail_a: vec4<f32>,   // mode 8 : coins TL, TR du plan a la frame precedente (px locaux, comme fx) ; mode 18 incline : en fractions de sortie
    trail_b: vec4<f32>,   // mode 8 : coins BR, BL du plan a la frame precedente (comme src_prev) ; mode 18 incline : en fractions de sortie
    trail_mb: vec4<f32>,  // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; mode 18 incline : le `mb` du mode 8 (profondeur de champ), et `color.xy` sa lampe ; 0 ailleurs
}

@group(0) @binding(0) var<uniform> layer: Layer;
@group(0) @binding(1) var texY:  texture_2d<f32>;   // R8Unorm, sample .r ; modes 7 et 13 : le sprite RGBA ; mode 15 : la copie de l'image composee
@group(0) @binding(2) var texU:  texture_2d<f32>;   // R8Unorm, sample .r
@group(0) @binding(3) var samp:  sampler;
// Masque de segmentation du sujet webcam, R8. Une vue 1x1 est liee quand aucun masque
// n'existe : la branche n'est de toute facon prise que si layer.fx.z > 0.5.
// Mode 18 : ce binding porte a la place le rendu isole de l'ecran cadre ; mode 15, le champ R16F
// du sprite.
@group(0) @binding(4) var texMask: texture_2d<f32>;
// Pyramide RGBA de profondeur de champ (`tilted_sample`), lue par le mode 8 et par le repli du
// mode 18, qui garde le binding 4 pour son rendu isole : d'ou un binding a elle. Mode 15 : le
// sprite RGBA. Vue 1x1 ailleurs.
@group(0) @binding(6) var texDof: texture_2d<f32>;
// Le maillage de Prism Glow (mode 15), rempli de `prism_mesh.rs` : un uniform et non des tables
// dans le shader, que lavapipe recopierait a chaque pixel de chaque calque (cf. `PrismMesh`).
@group(0) @binding(7) var<uniform> prism: PrismMesh;

// Plafond de la profondeur de champ du mode 8, en niveau de la pyramide demi-resolution.
// Meme valeur que `DOF_MAX_LOD` du HLSL.
const DOF_MAX_LOD: f32 = 1.5;
// V est en binding 5 et pas 3 : les bindings 0-4 etaient deja pris quand le plan
// de chroma a ete dedouble, et renumeroter aurait touche tous les bind groups
// pour un gain nul.
@group(0) @binding(5) var texV:  texture_2d<f32>;   // R8Unorm, sample .r

struct VsOut {
    @builtin(position) pos: vec4<f32>,
    @location(0) uv: vec2<f32>,     // UV d'échantillonnage source
    @location(1) local: vec2<f32>,  // pixel local dans le quad (SDF)
    @location(2) pout: vec2<f32>,   // position 0..1 sortie
};

@vertex
fn vs_main(@builtin(vertex_index) vid: u32) -> VsOut {
    // strip 4 vertices : (0,0)(1,0)(0,1)(1,1)
    let c = vec2<f32>(f32(vid & 1u), f32((vid >> 1u) & 1u));
    let p = layer.dst.xy + c * layer.dst.zw;
    let ndc = vec2<f32>(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0);
    var o: VsOut;
    o.pos = vec4<f32>(ndc, 0.0, 1.0);
    o.uv = layer.src.xy + c * (layer.src.zw - layer.src.xy);
    o.local = c * layer.quad_px;
    o.pout = p;
    return o;
}

fn yuv709_limited(y: f32, cbcr: vec2<f32>) -> vec3<f32> {
    let Yf = (y * 255.0 - 16.0) / 219.0;
    let Cb = (cbcr.x * 255.0 - 128.0) / 224.0;
    let Cr = (cbcr.y * 255.0 - 128.0) / 224.0;
    return clamp(vec3<f32>(
        Yf + 1.5748 * Cr,
        Yf - 0.1873 * Cb - 0.4681 * Cr,
        Yf + 1.8556 * Cb,
    ), vec3<f32>(0.0), vec3<f32>(1.0));
}

fn sample_yuv(uv: vec2<f32>) -> vec3<f32> {
    let y = textureSample(texY, samp, uv).r;
    let cbcr = vec2<f32>(
        textureSample(texU, samp, uv).r,
        textureSample(texV, samp, uv).r,
    );
    return yuv709_limited(y, cbcr);
}

// `sample_yuv` à LOD explicite : utilisable hors du flot uniforme (mode 18).
fn sample_yuv_level(uv: vec2<f32>) -> vec3<f32> {
    let y = textureSampleLevel(texY, samp, uv, 0.0).r;
    let cbcr = vec2<f32>(
        textureSampleLevel(texU, samp, uv, 0.0).r,
        textureSampleLevel(texV, samp, uv, 0.0).r,
    );
    return yuv709_limited(y, cbcr);
}

// Mode 18 -- l'ecran CADRE (ombre, cadre, metrage, appareil) floute comme UN objet rigide
// (`FrameGeometry::screen_trail`), port 1:1 du HLSL. Binding 4 = son rendu isole, premultiplie,
// a la taille de la sortie. Chaque tap retrouve le point de l'objet qui couvrait ce pixel plus tot
// sur la trajectoire (`f`) et le relit la ou il est dessine maintenant (`q`). A plat, sa boite va
// de `dst_prev` (frame precedente) a `fx` (courante) ; incline (`mb.z` = 1), les coins du plan
// vont de `trail_a`/`trail_b` a `fx`/`src_prev`, et le warp du plan (`mb.w`, celui du mode 8) fait
// l'aller et le retour ; un pixel que le plan prolonge n'atteint pas (aller sans solution) n'a pas
// de tap. Hors de la sortie rien n'a ete rendu : dans l'ouverture arrondie de l'ecran (`quad_px`,
// `radius_px`, 2 px en retrait) on relit le metrage (`src` = la coupe) comme le mode 8 l'a dessine,
// avec sa profondeur de champ (`trail_mb` = son `mb`, pyramide en binding 6) et sa lampe
// (`color.xy`), nulles a plat ; ailleurs le tap est ecarte.
fn screen_trail(pout: vec2<f32>) -> vec4<f32> {
    let taps = i32(layer.mb.x);
    var acc = vec4<f32>(0.0);
    var n = 0.0;
    for (var k: i32 = 0; k < 16; k = k + 1) {
        if k >= taps { break; }
        let a = clamp(layer.mb.y, 0.0, 1.0) * (1.0 - f32(k) / f32(taps - 1));
        var f: vec2<f32>;
        var q: vec2<f32>;
        if layer.mb.z > 0.5 {
            let ta = mix(layer.fx, layer.trail_a, a);
            let tb = mix(layer.src_prev, layer.trail_b, a);
            let r = quad_inverse(pout, ta.xy, ta.zw, tb.xy, tb.zw, layer.mb.w);
            if r.z < -0.5 { continue; }
            f = r.xy;
            q = quad_forward(f, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);
        } else {
            let r = mix(layer.fx, layer.dst_prev, a);
            f = (pout - r.xy) / r.zw;
            q = layer.fx.xy + f * layer.fx.zw;
        }
        let rendered = all(q >= vec2<f32>(0.0)) && all(q <= vec2<f32>(1.0));
        // Un `if`, pas un `select` : `select` evalue ses deux branches, soit trois lectures du
        // metrage et une SDF par tap pour rien. Parite HLSL / MSL.
        if rendered {
            acc = acc + textureSampleLevel(texMask, samp, q, 0.0);
            n = n + 1.0;
        } else {
            let hs = layer.quad_px * 0.5;
            if sd_round_rect(f * layer.quad_px - hs, hs, layer.radius_px) < -2.0 {
                let z = (f.x - 0.5) * layer.trail_mb.x + (f.y - 0.5) * layer.trail_mb.y;
                let rgb = tilted_sample(mix(layer.src.xy, layer.src.zw, f),
                                        layer.trail_mb.w * abs(z - layer.trail_mb.z));
                let shade = 1.0 + layer.color.x * (f.x - 0.5) + layer.color.y * (f.y - 0.5);
                acc = acc + vec4<f32>(clamp(rgb * shade, vec3<f32>(0.0), vec3<f32>(1.0)), 1.0);
                n = n + 1.0;
            }
        }
    }
    return acc / max(n, 1.0);
}

// SDF rectangle à coins arrondis (< 0 dedans). Identique au HLSL.
//
// Coins CONTINUS : le quart de coin est une superellipse d'exposant n, pas un arc de cercle.
// Un arc rejoint le bord droit sans angle, mais sa courbure y saute d'un coup de 0 à 1/r, et
// l'œil lit ce saut comme une cassure ; ici elle monte en douceur depuis zéro (les coins
// « continus » d'Apple). `r` garde son sens : l'étendue E = K(n)·r creuse le coin à 45° autant
// qu'un cercle de rayon r, donc un réglage arrondit autant qu'avant, et deux contours
// concentriques (r, et r + b autour) gardent une bordure d'épaisseur b à 2 % près. L'exposant
// revient à 2 quand r approche le demi-petit-côté : à fond, un carré est un cercle et un
// rectangle une pilule. La distance est divisée par la pente de la norme, donc l'antialiasing
// garde sa largeur tout autour du coin. r <= 0 : le rectangle vif d'avant, à l'identique.
fn sd_round_rect(p: vec2<f32>, halfsz: vec2<f32>, r: f32) -> f32 {
    let hmin = min(halfsz.x, halfsz.y);
    let q0 = abs(p) - halfsz;
    // Hors des coins, la distance est celle du rectangle vif quel que soit l'exposant : un seul
    // axe deborde de l'etendue E, qui s'y ajoute puis s'en retranche. E ne depasse pas 1,42 r
    // (n = 3) : sous 1,5 r du bord sur un axe, on rend la boite sans calculer `n` ni E, deux
    // transcendantes de moins sur presque tous les pixels d'un calque arrondi.
    if (r <= 0.0 || hmin <= 0.0 || min(q0.x, q0.y) <= -min(1.5 * r, hmin)) {
        return length(max(q0, vec2<f32>(0.0))) + min(max(q0.x, q0.y), 0.0);
    }
    let n = 3.0 - smoothstep(0.5, 1.0, r / hmin);
    let e = min(r * 0.29289322 / (1.0 - exp2(-1.0 / n)), hmin);
    let q = abs(p) - halfsz + vec2<f32>(e);
    let m = max(q, vec2<f32>(0.0));
    if (m.x > 0.0 && m.y > 0.0) {
        let len = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
        let g = pow(m / len, vec2<f32>(n - 1.0));
        return (len - e) / length(g);
    }
    return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;
}

// L'ecran sous le chrome de FENETRE (modes 0 et 8) : coins HAUTS carres, rognes par l'arc du
// cadre quand le rayon depasse la barre. Port de `sd_screen_under_bar` (HLSL), qui fait foi.
fn sd_screen_under_bar(p: vec2<f32>, halfsz: vec2<f32>, r: f32, lift: f32) -> f32 {
    let own = sd_round_rect(p, halfsz, select(r, 0.0, p.y < 0.0));
    let up = vec2<f32>(0.0, lift * 0.5);
    return max(own, sd_round_rect(p + up, halfsz + up, r));
}

// Couverture du quad avec coins arrondis, pour le mode 6 qui retourne AVANT la queue de
// `fs_main`. Il s'en passait tant qu'il ne servait qu'au fond plein cadre, qui n'a pas de
// rayon ; depuis que la bulle webcam peut porter une image, sans ca le fond deborde en carre
// opaque sur les coins arrondis de la bulle et mange l'ombre. Renvoie 1.0 quand aucun rayon
// n'est demande -- le fond plein cadre est donc inchange.
fn quad_round_alpha(local: vec2<f32>, quad_px: vec2<f32>, radius_px: f32) -> f32 {
    if radius_px <= 0.0 || quad_px.x <= 0.0 || quad_px.y <= 0.0 {
        return 1.0;
    }
    let halfsz = quad_px * 0.5;
    let d = sd_round_rect(local - halfsz, halfsz, radius_px);
    return 1.0 - smoothstep(0.0, 1.5, d); // meme feather ~1.5px que la queue
}

// Le slot d'un layout en bloc, qui rogne le plan incline (mode 8, cf. HLSL). Negatif : coins
// HAUTS carres, sous la barre de la fenetre qui le contient.
fn slot_alpha(local: vec2<f32>, quad_px: vec2<f32>, r: f32) -> f32 {
    if r >= 0.0 {
        return quad_round_alpha(local, quad_px, r);
    }
    let halfsz = quad_px * 0.5;
    let p = local - halfsz;
    return 1.0 - smoothstep(0.0, 1.5, sd_round_rect(p, halfsz, select(-r, 0.0, p.y < 0.0)));
}

// ---- Primitives du tilt 3D (modes 8 et 12), portees de `shaders.metal` ----

// SDF segment a bouts ronds.
fn sd_segment(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> f32 {
    let pa = p - a;
    let ba = b - a;
    let h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0);
    return length(pa - ba * h);
}

// Intersection de deux droites donnees par (normale, offset) : n.x = d. Cramer.
fn line_cross(n1: vec2<f32>, d1: f32, n2: vec2<f32>, d2: f32) -> vec2<f32> {
    let det = n1.x * n2.y - n1.y * n2.x;
    if abs(det) < 1e-6 {
        return vec2<f32>(0.0, 0.0);
    }
    return vec2<f32>(d1 * n2.y - d2 * n1.y, d2 * n1.x - d1 * n2.x) / det;
}

// Contribution d'une arete a la SDF du quad : .x = distance signee au demi-plan
// porte par l'arete (>0 dehors), .y = distance au SEGMENT.
fn quad_edge(p: vec2<f32>, a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
    let e = b - a;
    // Division par la longueur plutot que `normalize` : une arete degeneree
    // donnerait un NaN qui effacerait le calque entier.
    let n = vec2<f32>(e.y, -e.x) / max(length(e), 1e-6);
    return vec2<f32>(dot(p - a, n), sd_segment(p, a, b));
}

// Distance signee EXACTE a un quadrilatere convexe (<0 dedans). La boucle `k`
// du MSL est deroulee : elle indexait un tableau local avec un indice runtime,
// ce que naga 24 traduit en SPIR-V invalide (cf. `blur.wgsl`).
fn sd_convex_quad(p: vec2<f32>, v0: vec2<f32>, v1: vec2<f32>, v2: vec2<f32>, v3: vec2<f32>) -> f32 {
    let e0 = quad_edge(p, v0, v1);
    let e1 = quad_edge(p, v1, v2);
    let e2 = quad_edge(p, v2, v3);
    let e3 = quad_edge(p, v3, v0);
    let inside = max(max(e0.x, e1.x), max(e2.x, e3.x));
    let border = min(min(e0.y, e1.y), min(e2.y, e3.y));
    if inside < 0.0 {
        return -border;
    }
    return border;
}

// Coin d'un quad rentre de `r` : intersection des deux aretes adjacentes,
// chacune decalee de `r` vers l'interieur. Meme deroulement que ci-dessus.
fn inset_corner(prev: vec2<f32>, cur: vec2<f32>, next: vec2<f32>, r: f32) -> vec2<f32> {
    let ep = cur - prev;
    let ec = next - cur;
    // TL->TR->BR->BL tourne dans le sens horaire en y-bas, donc (e.y, -e.x) sort du quad.
    let np = vec2<f32>(ep.y, -ep.x) / max(length(ep), 1e-6);
    let nc = vec2<f32>(ec.y, -ec.x) / max(length(ec), 1e-6);
    return line_cross(np, dot(prev, np) - r, nc, dot(cur, nc) - r);
}

// (s, t, ok) du warp inverse du mode 8 pour une racine `t` donnee.
fn quad_st_for_root(t: f32, e: vec2<f32>, f: vec2<f32>, g: vec2<f32>, h: vec2<f32>) -> vec3<f32> {
    let denom_x = e.x + g.x * t;
    let denom_y = e.y + g.y * t;
    var s: f32;
    if abs(denom_x) > abs(denom_y) {
        s = (h.x - f.x * t) / denom_x;
    } else {
        s = (h.y - f.y * t) / denom_y;
    }
    // Tolerance de 2 % reprise telle quelle du MSL : sans elle une rangee de
    // pixels du bord tombe hors du quad par arrondi et l'ecran se liseree.
    var ok = 0.0;
    if s >= -0.02 && s <= 1.02 && t >= -0.02 && t <= 1.02 {
        ok = 1.0;
    }
    return vec3<f32>(s, t, ok);
}

// (s, t, ok) du point `P` dans le quad c00->c10->c11->c01 : le warp bilineaire INVERSE.
// `ok` = -1 quand `P` n'a AUCUN antecedent (au-dela du pli du warp) : (s, t) n'y veut rien dire,
// et ce n'est pas l'origine du plan (cf. HLSL, qui fait foi).
fn quad_inverse_bilinear(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>) -> vec3<f32> {
    let e = c10 - c00;
    let f = c01 - c00;
    let g = c00 - c10 - c01 + c11;
    let h = P - c00;
    let k2 = g.x * f.y - g.y * f.x;
    let k1 = e.x * f.y - e.y * f.x + h.x * g.y - h.y * g.x;
    let k0 = h.x * e.y - h.y * e.x;
    // Quad quasi affine (rotation Y pure, p.ex.) : le terme quadratique s'evanouit
    // et resoudre la quadratique diviserait par ~0.
    if abs(k2) < 1e-5 * abs(k1) {
        // k1 nul aussi : l'equation ne fixe plus `t`, aucun point a rendre.
        if abs(k1) < 1e-6 {
            return vec3<f32>(0.0, 0.0, -1.0);
        }
        return quad_st_for_root(-k0 / k1, e, f, g, h);
    }
    let disc = k1 * k1 - 4.0 * k2 * k0;
    if disc < 0.0 {
        return vec3<f32>(0.0, 0.0, -1.0);
    }
    // Forme stable de la quadratique : additionner deux termes de meme signe evite
    // l'annulation catastrophique que `(-k1 +- sqrt(disc)) / (2 k2)` produit quand
    // `disc` approche `k1^2`. `sign()` de WGSL rend 0 en 0, la ou le ternaire MSL
    // rend +1 : d'ou le signe explicite.
    var sgn = 1.0;
    if k1 < 0.0 {
        sgn = -1.0;
    }
    let q = -0.5 * (k1 + sgn * sqrt(disc));
    let r0 = quad_st_for_root(q / k2, e, f, g, h);
    var t1 = q / k2;
    if abs(q) > 0.0 {
        t1 = k0 / q;
    }
    let r1 = quad_st_for_root(t1, e, f, g, h);
    if r0.z > 0.5 {
        return r0;
    }
    return r1;
}

// (s, t, ok) du point `P` par l'homographie EXACTE du carre unite sur le quad (forme de Heckbert,
// relative a c00), resolue a l'envers par Cramer : la projection d'un plan par la camera reelle.
// Miroir du HLSL et de `regions::square_to_quad`.
fn quad_inverse_projective(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>) -> vec3<f32> {
    let p1 = c10 - c00;
    let p2 = c11 - c00;
    let p3 = c01 - c00;
    let d1 = p1 - p2;
    let d2 = p3 - p2;
    let d3 = p2 - p1 - p3;
    let den = d1.x * d2.y - d2.x * d1.y;
    let g = (d3.x * d2.y - d2.x * d3.y) / den;
    let h = (d1.x * d3.y - d3.x * d1.y) / den;
    let q = P - c00;
    let m00 = p1.x * (1.0 + g) - g * q.x;
    let m01 = p3.x * (1.0 + h) - h * q.x;
    let m10 = p1.y * (1.0 + g) - g * q.y;
    let m11 = p3.y * (1.0 + h) - h * q.y;
    let det = m00 * m11 - m01 * m10;
    let s = (q.x * m11 - m01 * q.y) / det;
    let t = (m00 * q.y - q.x * m10) / det;
    var ok = 0.0;
    if s >= -0.02 && s <= 1.02 && t >= -0.02 && t <= 1.02 {
        ok = 1.0;
    }
    return vec3<f32>(s, t, ok);
}

// Warp inverse d'un calque pose sur le plan : projectif sous la camera reelle ou un appareil
// (`projective` = 1), bilineaire sous un angle fixe, inchange.
// `ok` : 1 dans le quad, 0 dehors, -1 sans antecedent (`quad_inverse_bilinear`).
fn quad_inverse(P: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>, projective: f32) -> vec3<f32> {
    if projective > 0.5 {
        return quad_inverse_projective(P, c00, c10, c11, c01);
    }
    return quad_inverse_bilinear(P, c00, c10, c11, c01);
}

// Le point (s, t) du plan dans le quad : le warp de `quad_inverse` dans le sens direct, prolonge
// hors du carre unite. Miroir du HLSL et de `TiltedQuad::point_px`.
fn quad_forward(st: vec2<f32>, c00: vec2<f32>, c10: vec2<f32>, c11: vec2<f32>, c01: vec2<f32>, projective: f32) -> vec2<f32> {
    if projective > 0.5 {
        let p1 = c10 - c00;
        let p2 = c11 - c00;
        let p3 = c01 - c00;
        let d1 = p1 - p2;
        let d2 = p3 - p2;
        let d3 = p2 - p1 - p3;
        let den = d1.x * d2.y - d2.x * d1.y;
        let g = (d3.x * d2.y - d2.x * d3.y) / den;
        let h = (d1.x * d3.y - d3.x * d1.y) / den;
        return c00 + (p1 * (1.0 + g) * st.x + p3 * (1.0 + h) * st.y) / (g * st.x + h * st.y + 1.0);
    }
    return c00 + st.x * (c10 - c00) + st.y * (c01 - c00) + st.x * st.y * (c00 - c10 - c01 + c11);
}

// Un echantillon de l'ecran incline (mode 8) : la video nette, fondue vers la pyramide de
// profondeur de champ (binding 6) au-dela d'un demi-texel de cercle de confusion `coc`. Sous ce
// seuil, l'echantillon net d'avant, a l'octet. Miroir de `tilted_sample` (HLSL). LOD explicite
// partout : les plans video n'ont qu'un niveau, donc c'est le meme echantillon, et le repli du
// mode 18 l'appelle hors du flot uniforme.
fn tilted_sample(uv: vec2<f32>, coc: f32) -> vec3<f32> {
    var rgb = sample_yuv_level(uv);
    if coc > 0.5 {
        let lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);
        let far_rgb = textureSampleLevel(texDof, samp, uv, lod).rgb;
        rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));
    }
    return rgb;
}

// Hash 2D -> [0,1) sans sin(). Miroir de `hash12` cote HLSL.
fn hash12(p: vec2<f32>) -> f32 {
    var p3 = fract(vec3<f32>(p.x, p.y, p.x) * 0.1031);
    p3 = p3 + vec3<f32>(dot(p3, p3.yzx + vec3<f32>(33.33)));
    return fract((p3.x + p3.y) * p3.z);
}

// Bruit de valeur lisse (hermite), sans texture. Miroir de `value_noise` cote HLSL.
fn value_noise(q: vec2<f32>) -> f32 {
    let i = floor(q);
    let f = fract(q);
    let u = f * f * (vec2<f32>(3.0) - 2.0 * f);
    let a = hash12(i);
    let b = hash12(i + vec2<f32>(1.0, 0.0));
    let c = hash12(i + vec2<f32>(0.0, 1.0));
    let d = hash12(i + vec2<f32>(1.0, 1.0));
    return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
}

// Rampe du mode 5 a quatre noeuds. Miroir de `ramp4` cote HLSL (commentaires complets la-bas).
fn ramp4(t: f32, k0: vec4<f32>, k1: vec4<f32>, k2: vec4<f32>, k3: vec4<f32>) -> vec3<f32> {
    var c = k0.rgb;
    c = mix(c, k1.rgb, clamp((t - k0.w) / max(k1.w - k0.w, 1e-5), 0.0, 1.0));
    c = mix(c, k2.rgb, clamp((t - k1.w) / max(k2.w - k1.w, 1e-5), 0.0, 1.0));
    c = mix(c, k3.rgb, clamp((t - k2.w) / max(k3.w - k2.w, 1e-5), 0.0, 1.0));
    return c;
}

// Eclaircit vers le blanc (k > 0) ou assombrit vers le noir (k < 0) d'une fraction |k|.
fn lighten(c: vec3<f32>, k: f32) -> vec3<f32> {
    return select(c * (1.0 + k), c + (vec3<f32>(1.0) - c) * k, k > 0.0);
}

// Les trois nappes de l'aurore. Miroir de `aurora_blobs` cote HLSL.
fn aurora_blobs(p: vec2<f32>, time: f32, aspect: f32) -> vec3<f32> {
    let TAU = 6.2831853;
    let b0 = vec2<f32>(0.35 * aspect * sin(TAU * time / 10.0), 0.25 * sin(TAU * time / 15.0 + 1.0));
    let b1 = vec2<f32>(0.30 * aspect * sin(TAU * time / 12.0 + 2.0), 0.22 * cos(TAU * time / 20.0));
    let b2 = vec2<f32>(0.25 * aspect * cos(TAU * time / 15.0 + 4.0), 0.28 * sin(TAU * time / 12.0 + 3.0));
    return vec3<f32>(exp(-dot(p - b0, p - b0) / 0.176), exp(-dot(p - b1, p - b1) / 0.132),
                     exp(-dot(p - b2, p - b2) / 0.11));
}

// Mouvements 2 (aurore) et 3 (vagues) du mode 5. Miroir ligne pour ligne de
// `gradient_motion` cote HLSL (commentaires complets la-bas).
fn gradient_motion(gp: vec2<f32>, dir: vec2<f32>, denom: f32, k0: vec4<f32>, k1: vec4<f32>,
                   k2: vec4<f32>, k3: vec4<f32>, time: f32, motion: f32, aspect: f32) -> vec3<f32> {
    let TAU = 6.2831853;
    let u = dot(gp - vec2<f32>(0.5), dir) / denom; // position le long de l'axe, -0.5..0.5
    if motion < 2.5 {
        // Aurore : rampe perturbee par un bruit, puis trois larges nappes gaussiennes.
        let p = vec2<f32>((gp.x - 0.5) * aspect, gp.y - 0.5);
        let ph = TAU * time / 30.0;
        let n = value_noise(p * 1.8 + 1.5 * vec2<f32>(cos(ph), sin(ph)));
        var g = ramp4(clamp(0.5 + u + 0.6 * (n - 0.5), 0.0, 1.0), k0, k1, k2, k3);
        let blobs = aurora_blobs(p, time, aspect);
        let light = lighten(k3.rgb, 0.15);
        g = mix(g, light, 0.7 * blobs.x);
        g = mix(g, lighten(k0.rgb, -0.15), 0.7 * blobs.y);
        g = mix(g, light, 0.6 * blobs.z);
        return g;
    }
    // Vagues : trois bandes sinus perpendiculaires a l'axe (6 s), ondulees (10 s), cretes eclairees.
    let v = dot(gp - vec2<f32>(0.5), vec2<f32>(-dir.y, dir.x)) / denom;
    let w = sin(TAU * (3.0 * u + 0.04 * sin(TAU * (1.5 * v + time / 10.0)) - time / 6.0));
    return lighten(ramp4(clamp(0.5 + u + 0.18 * w, 0.0, 1.0), k0, k1, k2, k3), 0.07 * w);
}

// Les memes mouvements sur une image (mode 6). Miroir ligne pour ligne de `image_motion` cote
// HLSL (commentaires complets la-bas) : rend `q` deplace (xy) et l'eclairage (z).
fn image_motion(q: vec2<f32>, time: f32, motion: f32, aspect: f32) -> vec3<f32> {
    let TAU = 6.2831853;
    if motion < 1.5 {
        // Derive : zoom lent entre 8 et 22 % (20 s), panoramique dans sa marge (15 et 24 s).
        let z = 1.15 + 0.07 * sin(TAU * time / 20.0);
        let m = 0.375 * (1.0 - 1.0 / z);
        return vec3<f32>(q / z + m * vec2<f32>(sin(TAU * time / 15.0), cos(TAU * time / 24.0)), 0.0);
    }
    if motion < 2.5 {
        // Aurore : ecoulement sous un bruit de +-3 %, eclaire par les nappes.
        let p = vec2<f32>(q.x * aspect, q.y);
        let ph = TAU * time / 30.0;
        let c = p * 1.6 + 1.5 * vec2<f32>(cos(ph), sin(ph));
        let flow = vec2<f32>(value_noise(c), value_noise(c + vec2<f32>(5.2, 1.3))) - vec2<f32>(0.5);
        let blobs = aurora_blobs(p, time, aspect);
        return vec3<f32>(q / 1.08 + 0.06 * flow, 0.12 * (blobs.x - blobs.y + 0.85 * blobs.z));
    }
    // Vagues : bandes a 135 deg qui ondulent l'image de +-0,85 % et eclairent leurs cretes.
    let d = vec2<f32>(0.7071068, 0.7071068);
    let u = dot(q, d) / 1.4142136;
    let v = dot(q, vec2<f32>(-d.y, d.x)) / 1.4142136;
    let w = sin(TAU * (3.0 * u + 0.04 * sin(TAU * (1.5 * v + time / 10.0)) - time / 6.0));
    return vec3<f32>(q / 1.06 + 0.012 * w * d, 0.07 * w);
}

// Couverture d'une pastille (disque) adoucie sur ~1.5 px, pour la barre de titre du mode 14.
fn disc_cov(p: vec2<f32>, c: vec2<f32>, r: f32) -> f32 {
    return 1.0 - smoothstep(r - 0.75, r + 0.75, length(p - c));
}

// Couverture d'un trait centre sur `x = 0`, de demi-epaisseur `half_w`, sur ~1 px.
fn band_cov(x: f32, half_w: f32) -> f32 {
    return clamp(half_w + 0.5 - abs(x), 0.0, 1.0);
}

// Fond flouté pour le mode "blur" de la webcam.
// Disque de Vogel (spirale à angle d'or) à 21 échantillons avec pondération gaussienne et
// rotation par pixel via Interleaved Gradient Noise (IGN) pour un bokeh photographique doux, isotrope et rapide.
const VOGEL_TAPS = array<vec3<f32>, 21>(
    vec3<f32>( 0.154303,  0.000000, 0.942213),
    vec3<f32>(-0.197070,  0.180532, 0.836464),
    vec3<f32>( 0.030165, -0.343712, 0.742584),
    vec3<f32>( 0.248394,  0.323986, 0.659241),
    vec3<f32>(-0.455834, -0.080631, 0.585251),
    vec3<f32>( 0.431806, -0.274679, 0.519566),
    vec3<f32>(-0.144431,  0.537274, 0.461253),
    vec3<f32>(-0.275445, -0.530352, 0.409484),
    vec3<f32>( 0.597605,  0.218244, 0.363526),
    vec3<f32>(-0.621708,  0.256632, 0.322726),
    vec3<f32>( 0.299704, -0.640451, 0.286505),
    vec3<f32>( 0.221474,  0.706094, 0.254349),
    vec3<f32>(-0.667525, -0.386844, 0.225802),
    vec3<f32>( 0.783083, -0.172159, 0.200460),
    vec3<f32>(-0.477903,  0.679768, 0.177961),
    vec3<f32>(-0.110407, -0.852001, 0.157988),
    vec3<f32>( 0.677789,  0.571241, 0.140256),
    vec3<f32>(-0.912091,  0.037718, 0.124514),
    vec3<f32>( 0.665301, -0.662063, 0.110540),
    vec3<f32>(-0.044511,  0.962596, 0.098133),
    vec3<f32>(-0.633036, -0.758588, 0.087119)
);

fn blur_webcam_bg(uv: vec2<f32>, intensity: f32, qpx: vec2<f32>, local_px: vec2<f32>) -> vec3<f32> {
    let max_r_px = max(intensity, 0.0) * 22.0 + 1.5;
    let step = max_r_px / max(qpx, vec2<f32>(1.0));
    let noise = fract(52.9829189 * fract(0.06711056 * local_px.x + 0.00583715 * local_px.y));
    let angle = noise * 6.2831853;
    let s = sin(angle);
    let c = cos(angle);
    var sum = vec3<f32>(0.0);
    var total = 0.0;
    for (var k: i32 = 0; k < 21; k = k + 1) {
        let p = VOGEL_TAPS[k].xy;
        let w = VOGEL_TAPS[k].z;
        let rot_p = vec2<f32>(p.x * c - p.y * s, p.x * s + p.y * c);
        sum = sum + sample_yuv(clamp(uv + rot_p * step, vec2<f32>(0.0), vec2<f32>(1.0))) * w;
        total = total + w;
    }
    return sum / max(total, 1e-4);
}

// ---- Curseur MODELISE (mode 15) ----
// Port ligne pour ligne de `cursor_model` (HLSL), dont les commentaires font foi : un curseur
// SCULPTE (`trail_a.x` > 0, la fleche ou la main d'un des cinq themes d'origine modelee en
// volumes), sinon le sprite de l'etat courant extrude ; eclaire par une lampe proche, avec ombres
// propres et occlusion, et qui porte une ombre douce et une ombre de contact sur le plan de
// l'ecran. Constantes : miroir exact de `frame_geometry.rs` (MODEL_*) et de `sculpt.rs`
// (SCULPT_*), emplacements du cbuffer : `cursor_model_cb`.
// Textures : la copie de l'image composee au binding 1 (`texY`), que refracte le cristal de Prism
// Glow ; le sprite RGBA (alpha droit) est au binding 6 (`texDof`), son champ R16F au
// binding 4 (`texMask`), sur le meme rect ; `color.rg` = coin du sprite dans le repere du modele,
// `sprite_size()` = sa taille (w/h dans `radius_px`), `color.b` = l'ecrasement au clic.
const MODEL_BEVEL: f32 = 0.045;
const MODEL_LIGHT = vec3<f32>(-0.4194, -0.5792, 0.6990);
const MODEL_FILL = vec3<f32>(0.7557, 0.2519, 0.6046);
// Ambiance et diffus de l'appareil modele (mode 17), qui garde son eclairage d'origine.
const MODEL_AMBIENT: f32 = 0.36;
const MODEL_DIFFUSE: f32 = 0.75;
const MODEL_RIM_INSET: f32 = 1.5;
const MODEL_SOFTNESS: f32 = 6.0;
const MODEL_SHADOW_PAD: f32 = 0.45;
const MODEL_SHADOW_ALPHA: f32 = 0.5;
const MODEL_CONTACT_RADIUS: f32 = 0.12;
const MODEL_CONTACT_ALPHA: f32 = 0.5;

// Taille du sprite, repere du modele : son plus grand cote vaut 1, `radius_px` porte w/h.
fn sprite_size() -> vec2<f32> {
    return vec2<f32>(min(layer.radius_px, 1.0), min(1.0 / layer.radius_px, 1.0));
}

// Un texel du sprite, en unites du modele : le champ est le sprite surechantillonne x4.
const CURSOR_SDF_UPSAMPLE: f32 = 4.0;
fn sprite_texel() -> f32 {
    let d = vec2<f32>(textureDimensions(texMask));
    return CURSOR_SDF_UPSAMPLE / max(d.x, d.y);
}

// Epaisseur sous z = 0 (`SpriteShape::thick`), ecrasee au clic de `color.b`.
fn model_thick() -> f32 {
    return layer.trail_a.y * layer.color.b;
}

// Le curseur sculpte de ce dessin (`SpriteShape::sculpt`), 0 = le sprite extrude.
fn sculpt_id() -> i32 {
    return i32(layer.trail_a.x + 0.5);
}

// ---- Curseurs sculptes ---- (repere du PROTOTYPE : hauteur 1, y vers le haut, ecran en z = 0)
const SCULPT_SCALE: f32 = 0.85;
const SCULPT_HOVER: f32 = 0.05;
const SCULPT_VOX: f32 = 0.0625;
const SCULPT_ZREF_ARROW: f32 = 0.2;
const SCULPT_ZREF_HAND: f32 = 0.185;
const SCULPT_LAMP_DIST: f32 = 1.9;
const SCULPT_SCREEN = vec3<f32>(0.32, 0.32, 0.32);

fn s_lin(r: f32, g: f32, b: f32) -> vec3<f32> {
    return pow(vec3<f32>(r, g, b), vec3<f32>(2.2));
}

fn s_smin(a: f32, b: f32, k: f32) -> f32 {
    let h = max(k - abs(a - b), 0.0) / k;
    return min(a, b) - h * h * k * 0.25;
}

fn s_opu(a: vec2<f32>, b: vec2<f32>) -> vec2<f32> {
    return select(b, a, a.x < b.x);
}

fn s_round_box(p: vec3<f32>, b: vec3<f32>, r: f32) -> f32 {
    let q = abs(p) - b + vec3<f32>(r);
    return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
}

fn s_ellipsoid(p: vec3<f32>, r: vec3<f32>) -> f32 {
    let k0 = length(p / r);
    let k1 = length(p / (r * r));
    return k0 * (k0 - 1.0) / k1;
}

// Extrusion d'une distance 2D a aretes arrondies : demi-hauteur h, rayon r.
fn s_extrude(d2: f32, z: f32, h: f32, r: f32) -> f32 {
    let w = vec2<f32>(d2 + r, abs(z) - h + r);
    return min(max(w.x, w.y), 0.0) + length(max(w, vec2<f32>(0.0))) - r;
}

fn s_rot(v: vec2<f32>, a: f32) -> vec2<f32> {
    let c = cos(a);
    let s = sin(a);
    return vec2<f32>(c * v.x - s * v.y, s * v.x + c * v.y);
}

fn s_star5(p0: vec2<f32>, r: f32, rf: f32) -> f32 {
    let k1 = vec2<f32>(0.809016994375, -0.587785252292);
    let k2 = vec2<f32>(-0.809016994375, -0.587785252292);
    var p = vec2<f32>(abs(p0.x), p0.y);
    p = p - 2.0 * max(dot(k1, p), 0.0) * k1;
    p = p - 2.0 * max(dot(k2, p), 0.0) * k2;
    p.x = abs(p.x);
    p.y = p.y - r;
    let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);
    let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
    return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
}

fn s_vesica(p0: vec2<f32>, r: f32, d: f32) -> f32 {
    let p = abs(p0);
    let b = sqrt(r * r - d * d);
    return select(length(p + vec2<f32>(d, 0.0)) - r, length(p - vec2<f32>(0.0, b)), (p.y - b) * d > p.x * b);
}

// Curseurs cercles (cf. HLSL) : Studio Ink, Pop Coral, Star Sprout.
const RIM_POLY = array<vec2<f32>, 28>(
    vec2<f32>(0.0, -0.06), vec2<f32>(0.0, -0.7712), vec2<f32>(0.165, -0.6325), vec2<f32>(0.313, -0.9318),
    vec2<f32>(0.4234, -0.8557), vec2<f32>(0.2672, -0.5686), vec2<f32>(0.456, -0.5393),
    vec2<f32>(-0.173, -0.5237), vec2<f32>(-0.016, -0.75), vec2<f32>(0.329, -0.75), vec2<f32>(0.411, -0.592),
    vec2<f32>(0.411, -0.43), vec2<f32>(0.19, -0.435), vec2<f32>(-0.03, -0.44),
    vec2<f32>(-0.1825, -0.6215), vec2<f32>(0.0037, -0.9195), vec2<f32>(0.3462, -0.9195), vec2<f32>(0.467, -0.6906),
    vec2<f32>(0.467, -0.49), vec2<f32>(0.2, -0.49), vec2<f32>(-0.03, -0.49),
    vec2<f32>(-0.1807, -0.5534), vec2<f32>(0.0194, -0.872), vec2<f32>(0.3485, -0.872), vec2<f32>(0.47, -0.6795),
    vec2<f32>(0.47, -0.49), vec2<f32>(0.2, -0.49), vec2<f32>(-0.03, -0.49)
);

const RIM_GLOVE = array<vec4<f32>, 27>(
    vec4<f32>(0.0, -0.1077, 0.0, -0.6), vec4<f32>(0.1493, -0.3279, 0.1493, -0.6),
    vec4<f32>(0.2863, -0.3654, 0.2863, -0.6), vec4<f32>(0.4193, -0.4043, 0.4193, -0.6),
    vec4<f32>(-0.2, -0.478, -0.075, -0.625), vec4<f32>(0.0788, -0.25, 0.0788, -0.3992),
    vec4<f32>(0.2188, -0.3, 0.2188, -0.4234), vec4<f32>(0.3552, -0.33, 0.3552, -0.4534),
    vec4<f32>(-0.0845, -0.5386, 0.762, 0.648),
    vec4<f32>(0.0, -0.1186, 0.0, -0.65), vec4<f32>(0.1614, -0.3838, 0.1614, -0.65),
    vec4<f32>(0.3177, -0.427, 0.3177, -0.65), vec4<f32>(0.4645, -0.4848, 0.4645, -0.65),
    vec4<f32>(-0.215, -0.535, -0.1208, -0.6864), vec4<f32>(0.0832, -0.3, 0.0832, -0.48),
    vec4<f32>(0.2414, -0.35, 0.2414, -0.482), vec4<f32>(0.3959, -0.41, 0.3959, -0.533),
    vec4<f32>(-0.122, -0.5718, 0.867, 0.498),
    vec4<f32>(0.0, -0.122, 0.0, -0.65), vec4<f32>(0.172, -0.387, 0.172, -0.65),
    vec4<f32>(0.3267, -0.427, 0.3267, -0.65), vec4<f32>(0.4727, -0.4867, 0.4727, -0.65),
    vec4<f32>(-0.199, -0.483, -0.102, -0.645), vec4<f32>(0.0927, -0.3, 0.0927, -0.476),
    vec4<f32>(0.2493, -0.35, 0.2493, -0.478), vec4<f32>(0.402, -0.41, 0.402, -0.52),
    vec4<f32>(-0.0993, -0.5267, 0.858, 0.514)
);

const RIM_GLOVE_R = array<vec4<f32>, 9>(
    vec4<f32>(0.0552, 0.047, 0.045, 0.0375), vec4<f32>(0.052, 0.0235, 0.0225, 0.0225), vec4<f32>(0.0552, -0.548, 0.0525, 0.0),
    vec4<f32>(0.064, 0.0585, 0.0585, 0.0515), vec4<f32>(0.06, 0.0197, 0.0178, 0.0172), vec4<f32>(0.0648, -0.6, 0.058, 0.0),
    vec4<f32>(0.066, 0.0553, 0.0553, 0.0507), vec4<f32>(0.063, 0.024, 0.022, 0.02), vec4<f32>(0.0647, -0.555, 0.056, 0.0)
);

fn s_rim_poly(p: vec2<f32>, base: i32) -> f32 {
    var d = dot(p - RIM_POLY[base], p - RIM_POLY[base]);
    var s = 1.0;
    var j = base + 6;
    for (var i = base; i < base + 7; i++) {
        let e = RIM_POLY[j] - RIM_POLY[i];
        let w = p - RIM_POLY[i];
        let b = w - e * saturate(dot(w, e) / dot(e, e));
        d = min(d, dot(b, b));
        let c0 = p.y >= RIM_POLY[i].y;
        let c1 = p.y < RIM_POLY[j].y;
        let c2 = e.x * w.y > e.y * w.x;
        if (c0 && c1 && c2) || (!c0 && !c1 && !c2) {
            s = -s;
        }
        j = i;
    }
    return s * sqrt(d);
}

fn s_rim_glove(p: vec2<f32>, g: i32, palm: f32) -> vec2<f32> {
    let r0 = RIM_GLOVE_R[3 * g];
    let r1 = RIM_GLOVE_R[3 * g + 1];
    let r2 = RIM_GLOVE_R[3 * g + 2];
    let i = 9 * g;
    var f = min(sd_segment(p, RIM_GLOVE[i].xy, RIM_GLOVE[i].zw) - r0.x,
                sd_segment(p, RIM_GLOVE[i + 1].xy, RIM_GLOVE[i + 1].zw) - r0.y);
    f = min(f, sd_segment(p, RIM_GLOVE[i + 2].xy, RIM_GLOVE[i + 2].zw) - r0.z);
    f = min(f, sd_segment(p, RIM_GLOVE[i + 3].xy, RIM_GLOVE[i + 3].zw) - r0.w);
    f = min(f, sd_segment(p, RIM_GLOVE[i + 4].xy, RIM_GLOVE[i + 4].zw) - r1.x);
    var grooves = min(sd_segment(p, RIM_GLOVE[i + 5].xy, RIM_GLOVE[i + 5].zw) - r1.y,
                      sd_segment(p, RIM_GLOVE[i + 6].xy, RIM_GLOVE[i + 6].zw) - r1.z);
    grooves = min(grooves, sd_segment(p, RIM_GLOVE[i + 7].xy, RIM_GLOVE[i + 7].zw) - r1.w);
    let sil = s_smin(palm, f, 0.03);
    let v = RIM_GLOVE[i + 8];
    let wedge = max(max(-dot(p - v.xy, v.zw), p.x + r2.x), r2.y - p.y);
    return vec2<f32>(sil, max(sil, -min(grooves, wedge)));
}

fn s_piece(d: f32, dc: f32, sil: f32, z: f32, w: f32, zt: f32, h: f32, bump: f32, mat: f32) -> vec2<f32> {
    let tray = s_extrude(sil - w, z - 0.5 * (SCULPT_HOVER + zt), 0.5 * (zt - SCULPT_HOVER), 0.012);
    let bead = length(vec2<f32>(d - 0.5 * w, z - zt)) - 0.5 * w;
    let u = saturate(-dc / 0.045);
    let cushion = 0.8 * s_extrude(dc, z - zt, h + 0.022 * u * (2.0 - u) + bump, 0.75 * h);
    return s_opu(vec2<f32>(min(tray, bead), 5.0), vec2<f32>(cushion, mat));
}

fn s_paper(d: f32, sil: f32, z: f32, w: f32) -> vec2<f32> {
    let navy = s_extrude(sil - w, z - 0.5 * (SCULPT_HOVER + 0.15), 0.5 * (0.15 - SCULPT_HOVER), 0.006);
    let sheet = s_extrude(d, z - 0.16, 0.01, 0.004);
    return s_opu(vec2<f32>(navy, 5.0), vec2<f32>(sheet, 1.0));
}

fn s_bump(p: vec2<f32>, c: vec2<f32>, r: f32) -> f32 {
    let k = saturate(1.0 - dot(p - c, p - c) / (r * r));
    return k * k;
}

fn s_dash(p: vec2<f32>, a: vec2<f32>, b0: vec2<f32>, ra: f32, rb: f32) -> f32 {
    let q0 = p - a;
    let b = b0 - a;
    let hb = dot(b, b);
    let q = vec2<f32>(abs(dot(q0, vec2<f32>(b.y, -b.x))), dot(q0, b)) / hb;
    let c = vec2<f32>(sqrt(hb - (ra - rb) * (ra - rb)), ra - rb);
    let k = c.x * q.y - c.y * q.x;
    if k < 0.0 {
        return sqrt(hb * dot(q, q)) - ra;
    }
    if k > c.x {
        return sqrt(hb * (dot(q, q) + 1.0 - 2.0 * q.y)) - rb;
    }
    return dot(c, q) - ra;
}

fn s_rimmed(p: vec3<f32>, theme: i32, shape: i32) -> vec2<f32> {
    let arrow = shape == 0;
    let g = select(select(2, 1, theme == 0), 0, theme == 4);
    let poly = s_rim_poly(p.xy, select(7 * g + 7, 0, arrow));
    var body = vec2<f32>(poly, poly);
    var w = 0.06;
    var zt = 0.17;
    var h = 0.03;
    var bump = 0.022 * s_bump(p.xy, vec2<f32>(0.15, -0.45), 0.3);
    var back = 1e9;
    if !arrow {
        w = RIM_GLOVE_R[3 * g + 2].z;
        for (var i = 0; i < 2; i++) {
            let q = p.xy + select(vec2<f32>(0.0), vec2<f32>(0.03, 0.04), i == 1);
            let v = s_rim_glove(q, g, select(poly, s_rim_poly(q, 7 * g + 7), i == 1) - 0.05);
            if i == 1 {
                back = v.x - w;
            } else {
                body = v;
                if theme != 2 || v.x - w <= 0.0 {
                    break;
                }
            }
        }
        zt = 0.185;
        h = 0.028;
        bump = 0.03 * s_bump(p.xy, vec2<f32>(0.19, -0.62), 0.28);
    }
    var dc = body.y;
    if arrow && theme == 0 {
        body = body - vec2<f32>(0.015);
        w = 0.045;
        dc = 1.0;
    }
    var r: vec2<f32>;
    if theme == 2 {
        r = s_paper(body.y, body.x, p.z, w);
    } else {
        r = s_piece(body.y, dc, body.x, p.z, w, zt, h, bump, 1.0);
    }
    if theme == 0 {
        if arrow {
            let band = s_extrude(abs(poly + 0.0075) - 0.0225, p.z - zt, 0.028, 0.012);
            r = s_opu(r, vec2<f32>(band, 2.0));
        }
        return r;
    }
    if theme == 2 {
        var dash: f32;
        if arrow {
            let back = s_rim_poly(p.xy + vec2<f32>(0.025, 0.05), 0) - 0.06;
            r = s_opu(r, vec2<f32>(s_extrude(back, p.z - 0.08, 0.03, 0.006), 2.0));
            dash = min(s_dash(p.xy, vec2<f32>(-0.1179, -0.1374), vec2<f32>(-0.1799, -0.0443), 0.028, 0.045),
                       s_dash(p.xy, vec2<f32>(-0.1347, -0.2493), vec2<f32>(-0.248, -0.2056), 0.026, 0.042));
        } else {
            r = s_opu(r, vec2<f32>(s_extrude(back, p.z - 0.08, 0.03, 0.006), 3.0));
            dash = min(s_dash(p.xy, vec2<f32>(0.216, -0.1695), vec2<f32>(0.2593, -0.0685), 0.028, 0.042),
                       s_dash(p.xy, vec2<f32>(0.3054, -0.2339), vec2<f32>(0.3949, -0.1652), 0.0275, 0.041));
        }
        return s_opu(r, vec2<f32>(s_extrude(dash, p.z - 0.11, 0.06, 0.006), 3.0));
    }
    if !arrow {
        let cq = p.xy - vec2<f32>(0.1541, -0.9047);
        let bq = abs(vec2<f32>(cq.x, cq.y - 0.2066 * cq.x * cq.x)) - vec2<f32>(0.214, 0.0361);
        let cuff = length(max(bq, vec2<f32>(0.0))) + min(max(bq.x, bq.y), 0.0) - 0.03;
        r = s_opu(r, s_piece(cuff, cuff, cuff, p.z, 0.0477, 0.225, 0.025, 0.0, 2.0));
    }
    let c = select(vec2<f32>(0.15, -0.885), vec2<f32>(0.6118, -0.8079), arrow);
    let rs = select(0.128, 0.1678, arrow);
    let zs = select(0.285, 0.23, arrow);
    let q = s_rot(p.xy - c, select(0.0, 0.2443, arrow)) / rs;
    let star = (s_star5(q, 0.82, 0.55) - 0.18) * rs;
    let l1 = s_rot(q - vec2<f32>(-0.33, 1.38), -0.925);
    let l2 = s_rot(q - vec2<f32>(0.53, 1.37), 0.873);
    let leaves = min(s_vesica(l1, 0.4296, 0.2626), s_vesica(l2, 0.4296, 0.2626)) * rs;
    r = s_opu(r, s_piece(leaves, leaves, leaves, p.z, 0.038, zs - 0.02, 0.018, 0.0, 4.0));
    r = s_opu(r, s_piece(star, star, star, p.z, 0.038, zs, 0.022, 0.018 * s_bump(q, vec2<f32>(0.0), 1.0), 3.0));
    let e = vec3<f32>(abs(q.x) - 0.25, q.y - 0.08, (p.z - zs - 0.056) / rs);
    return s_opu(r, vec2<f32>(s_ellipsoid(e, vec3<f32>(0.075, 0.13, 0.1)) * rs, 5.0));
}

// ---- Glass Lens ---- (cf. HLSL : une lentille de verre dans un trait sombre, un liseré de verre
// au-delà ; `s_glass` en volume, `cursor_glass` à plat, `glass_shade` pour le verre.)
const GLASS_LINE: f32 = 0.04;
const GLASS_RIM: f32 = 0.085;
const GLASS_TOP: f32 = 0.18;
const GLASS_DOME: f32 = 0.03;
const GLASS_RISE: f32 = 0.08;
const GLASS_IOR: f32 = 1.5;
const GLASS_DISPERSION: f32 = 0.012;
const GLASS_MAT: f32 = 10.0;
const GLASS_GAP_FLAT: f32 = 0.15;
const GLASS_SMEAR: f32 = 0.15;
const GLASS_LIFT: f32 = 0.02;
const GLASS_SHADOW: f32 = 0.6;

// x = la silhouette, y = la lentille (distances signées du prototype, négatives dedans).
fn s_glass2(p: vec2<f32>, shape: i32) -> vec2<f32> {
    if shape == 0 {
        let poly = s_rim_poly(p + vec2<f32>(0.0, GLASS_RIM - 0.06), 0);
        return vec2<f32>(poly - GLASS_RIM, poly);
    }
    let q = p + vec2<f32>(0.0, GLASS_RIM - RIM_GLOVE_R[5].z);
    let v = s_rim_glove(q, 1, s_rim_poly(q, 14) - 0.05);
    return vec2<f32>(v.x - GLASS_RIM, v.y);
}

// La hauteur du verre au-dessus de GLASS_TOP selon la distance `d` à la lentille, et sa pente.
fn s_glass_relief(d: f32) -> vec2<f32> {
    if d < 0.0 {
        let u = saturate(-d / GLASS_RISE);
        return vec2<f32>(GLASS_DOME * u * (2.0 - u), -2.0 * GLASS_DOME * (1.0 - u) / GLASS_RISE);
    }
    let w = GLASS_RIM - GLASS_LINE;
    let x = saturate((d - GLASS_LINE) / w);
    let s = sqrt(max(1.0 - x * x, 0.05));
    return vec2<f32>(w * (s - 1.0), -x / s);
}

fn s_glass(p: vec3<f32>, shape: i32) -> vec2<f32> {
    let g = s_glass2(p.xy, shape);
    let half_h = 0.5 * (GLASS_TOP - SCULPT_HOVER);
    let slab = s_extrude(g.x, p.z - SCULPT_HOVER - half_h, half_h, min(GLASS_RIM - GLASS_LINE, half_h));
    let u = saturate(-g.y / GLASS_RISE);
    let dome = 0.8 * s_extrude(g.y, p.z - GLASS_TOP, 0.009 + GLASS_DOME * u * (2.0 - u), 0.008);
    let band = s_extrude(abs(g.y - 0.5 * GLASS_LINE) - 0.5 * GLASS_LINE, p.z - GLASS_TOP, 0.016, 0.008);
    return s_opu(vec2<f32>(min(slab, dome), GLASS_MAT), vec2<f32>(band, 5.0));
}

// Pixel Candy : tables générées par scripts/generate-pixel-candy-voxels.mjs (cf. HLSL).
// <pixel-candy-voxels>
const PIX_BODY = array<i32, 32>(1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 127, 247, 243, 480, 192, 48, 120, 120, 120, 504, 4088, 32760, 65534, 65535, 65535, 65534, 32766, 32764, 16380, 16376, 16376);
const PIX_LINE = array<i32, 32>(1, 3, 5, 9, 17, 33, 65, 129, 257, 513, 1985, 73, 149, 147, 288, 192, 48, 72, 72, 72, 456, 3656, 29256, 37454, 32777, 32769, 32770, 16386, 16388, 8196, 8200, 16376);
const PIX_HI = array<i32, 32>(0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 18, 34, 32, 64, 0, 0, 16, 16, 16, 16, 16, 16, 16, 22, 18, 4, 4, 8, 8, 16, 0);
const PIX_SHADE = array<i32, 32>(0, 0, 0, 4, 8, 16, 32, 64, 128, 448, 40, 36, 64, 64, 128, 0, 0, 32, 32, 32, 32, 288, 2336, 18720, 16384, 16384, 16384, 8192, 8192, 4096, 8160, 0);
const PIX_RECT_N = array<i32, 3>(0, 17, 29);
const PIX_GRID = array<vec4<i32>, 2>(
    vec4<i32>(11, 16, 0, 0),
    vec4<i32>(16, 16, 16, 0)
);
const PIX_ORIGIN = array<vec2<f32>, 2>(
    vec2<f32>(0.0, 0.0),
    vec2<f32>(-0.3125, 0.0)
);
const PIX_BOX = array<vec4<f32>, 2>(
    vec4<f32>(0.3438, -0.5, 0.3438, 0.5),
    vec4<f32>(0.1875, -0.5, 0.5, 0.5)
);
const PIX_RECT = array<vec4<f32>, 29>(
    vec4<f32>(0.0313, -0.0313, 0.0313, 0.0313),
    vec4<f32>(0.0625, -0.0938, 0.0625, 0.0313),
    vec4<f32>(0.0938, -0.1563, 0.0938, 0.0313),
    vec4<f32>(0.125, -0.2188, 0.125, 0.0313),
    vec4<f32>(0.1563, -0.2813, 0.1563, 0.0313),
    vec4<f32>(0.1875, -0.3438, 0.1875, 0.0313),
    vec4<f32>(0.2188, -0.4063, 0.2188, 0.0313),
    vec4<f32>(0.25, -0.4688, 0.25, 0.0313),
    vec4<f32>(0.2813, -0.5313, 0.2813, 0.0313),
    vec4<f32>(0.3125, -0.5938, 0.3125, 0.0313),
    vec4<f32>(0.3438, -0.6563, 0.3438, 0.0313),
    vec4<f32>(0.2188, -0.7188, 0.2188, 0.0313),
    vec4<f32>(0.0938, -0.7813, 0.0938, 0.0313),
    vec4<f32>(0.375, -0.8125, 0.125, 0.0625),
    vec4<f32>(0.0625, -0.8438, 0.0625, 0.0313),
    vec4<f32>(0.4375, -0.9063, 0.125, 0.0313),
    vec4<f32>(0.4375, -0.9688, 0.0625, 0.0313),
    vec4<f32>(0.0, -0.0313, 0.0625, 0.0313),
    vec4<f32>(0.0, -0.1563, 0.125, 0.0938),
    vec4<f32>(0.0625, -0.2813, 0.1875, 0.0313),
    vec4<f32>(0.1563, -0.3438, 0.2813, 0.0313),
    vec4<f32>(0.25, -0.4063, 0.375, 0.0313),
    vec4<f32>(0.2188, -0.4688, 0.4688, 0.0313),
    vec4<f32>(0.1875, -0.5625, 0.5, 0.0625),
    vec4<f32>(0.2188, -0.6563, 0.4688, 0.0313),
    vec4<f32>(0.1875, -0.7188, 0.4375, 0.0313),
    vec4<f32>(0.2188, -0.7813, 0.4063, 0.0313),
    vec4<f32>(0.1875, -0.8438, 0.375, 0.0313),
    vec4<f32>(0.2188, -0.9375, 0.3438, 0.0625)
);
// </pixel-candy-voxels>

fn s_pix_bit(m: i32, c: i32) -> bool {
    return ((m >> u32(clamp(c, 0, 31))) & 1) == 1;
}

fn s_pix_body(shape: i32, c: i32, r: i32) -> bool {
    let g = PIX_GRID[shape];
    return c >= 0 && c < g.x && r >= 0 && r < g.y && s_pix_bit(PIX_BODY[g.z + clamp(r, 0, g.y - 1)], c);
}

fn s_pix_cell(p: vec2<f32>, shape: i32) -> vec2<i32> {
    let o = PIX_ORIGIN[shape];
    return vec2<i32>(i32(floor((p.x - o.x) / SCULPT_VOX)), i32(floor((o.y - p.y) / SCULPT_VOX)));
}

fn s_voxels(p: vec3<f32>, shape: i32) -> vec2<f32> {
    let b = PIX_BOX[shape];
    let bq = max(abs(p.xy - b.xy) - b.zw, vec2<f32>(0.0));
    let bz = max(abs(p.z - (SCULPT_HOVER + 0.07)) - 0.07, 0.0);
    var d = max(SCULPT_VOX, sqrt(dot(bq, bq) + bz * bz));
    let o = PIX_ORIGIN[shape];
    let cell = s_pix_cell(p.xy, shape);
    let cube = vec3<f32>(0.5 * SCULPT_VOX, 0.5 * SCULPT_VOX, 0.07);
    for (var j = -1; j <= 1; j++) {
        for (var i = -1; i <= 1; i++) {
            let c = cell.x + i;
            let r = cell.y + j;
            if s_pix_body(shape, c, r) {
                let q = vec3<f32>(p.x - o.x - (f32(c) + 0.5) * SCULPT_VOX, p.y - o.y + (f32(r) + 0.5) * SCULPT_VOX,
                                  p.z - SCULPT_HOVER - 0.07);
                d = min(d, s_round_box(q, cube, 0.006));
            }
        }
    }
    return vec2<f32>(d, 6.0);
}

fn s_pixel_outline(p: vec2<f32>, shape: i32) -> f32 {
    var d = 1e9;
    for (var i = PIX_RECT_N[shape]; i < PIX_RECT_N[shape + 1]; i++) {
        let q = abs(p - PIX_RECT[i].xy) - PIX_RECT[i].zw;
        d = min(d, length(max(q, vec2<f32>(0.0))) + min(max(q.x, q.y), 0.0));
    }
    return d;
}

// ---- Prism Glow : un cristal en MAILLAGE ---- (port du HLSL, dont les commentaires font foi)
// Les facettes tracees sur son dessin, en triangles dans le repere du modele ; le serti est la
// silhouette extrudee (champ de distance), le cristal est lance de rayons boite par boite.
// prism mesh: generated by design/cursors/prism-glow/model/export_compositor.py
var<private> PRISM_TRI_START = array<i32, 2>(0, 31);
var<private> PRISM_TRI_COUNT = array<i32, 2>(31, 130);
var<private> PRISM_SIL_START = array<i32, 2>(0, 25);
var<private> PRISM_SIL_COUNT = array<i32, 2>(25, 42);
var<private> PRISM_OUT_START = array<i32, 2>(67, 76);
var<private> PRISM_OUT_COUNT = array<i32, 2>(9, 34);
var<private> PRISM_BOX_START = array<i32, 2>(0, 4);
var<private> PRISM_BOX_COUNT = array<i32, 2>(4, 18);
struct PrismMesh {
    tris: array<vec4<f32>, 644>,
    poly: array<vec4<f32>, 110>,
    boxes: array<vec4<f32>, 44>,
}
const PRISM_BEVEL: f32 = 0.012883;
// end of the prism mesh

const PRISM_IOR: f32 = 1.61;
const PRISM_DISPERSION: f32 = 0.035;
const PRISM_GLOW: f32 = 0.45;
const PRISM_FOLD: f32 = 0.35;
const PRISM_BOUNCES: i32 = 6;
const PRISM_MAT: f32 = 9.0;

fn prism_shape() -> i32 {
    let id = sculpt_id();
    if id == 3 || id == 4 {
        return id - 3;
    }
    return -1;
}

// Drapeaux d'un triangle : paroi (bit 0), aretes reelles (bits 1 a 3).
fn prism_flags(k: i32) -> i32 {
    return i32(prism.tris[4 * k].w + 0.5);
}

fn prism_poly_dist(p: vec2<f32>, i0: i32, n: i32) -> f32 {
    var vj = prism.poly[i0 + n - 1].xy;
    var d = 1e9;
    var sgn = 1.0;
    for (var i = 0; i < n; i++) {
        let vi = prism.poly[i0 + i].xy;
        let e = vj - vi;
        let w = p - vi;
        let b = w - e * saturate(dot(w, e) / dot(e, e));
        d = min(d, dot(b, b));
        let c0 = p.y >= vi.y;
        let c1 = p.y < vj.y;
        let c2 = e.x * w.y > e.y * w.x;
        if (c0 && c1 && c2) || (!c0 && !c1 && !c2) {
            sgn = -sgn;
        }
        vj = vi;
    }
    return sgn * sqrt(d);
}

fn prism_rim(p: vec3<f32>, shape: i32) -> f32 {
    let half_t = model_thick() * 0.5;
    let sil = prism_poly_dist(p.xy, PRISM_SIL_START[shape], PRISM_SIL_COUNT[shape]);
    let w = vec2<f32>(sil + PRISM_BEVEL, abs(p.z + half_t) - (half_t - PRISM_BEVEL));
    return min(max(w.x, w.y), 0.0) + length(max(w, vec2<f32>(0.0))) - PRISM_BEVEL;
}

fn prism_tri(ro: vec3<f32>, rd: vec3<f32>, k: i32) -> f32 {
    let v0 = prism.tris[4 * k].xyz;
    let e1 = prism.tris[4 * k + 1].xyz;
    let e2 = prism.tris[4 * k + 2].xyz;
    let pv = cross(rd, e2);
    let det = dot(e1, pv);
    if abs(det) < 1e-10 {
        return -1.0;
    }
    let inv = 1.0 / det;
    let sv = ro - v0;
    let u = dot(sv, pv) * inv;
    let qv = cross(sv, e1);
    let v = dot(rd, qv) * inv;
    if u < -2e-4 || v < -2e-4 || u + v > 1.0004 {
        return -1.0;
    }
    return dot(e2, qv) * inv;
}

// (distance, indice) du triangle du cristal `shape` le plus proche devant (ro, rd) ; (1e9, -1)
// s'il n'y en a pas. Les triangles sont parcourus boîte par boîte (cf. HLSL).
fn prism_trace(ro: vec3<f32>, rd: vec3<f32>, shape: i32) -> vec2<f32> {
    let inv = vec3<f32>(1.0) / select(vec3<f32>(1e-6), rd, abs(rd) > vec3<f32>(1e-6));
    let b0 = PRISM_BOX_START[shape];
    let nb = PRISM_BOX_COUNT[shape];
    var best = 1e9;
    var hit = -1;
    for (var j = b0; j < b0 + nb; j++) {
        let lo = prism.boxes[2 * j];
        let hi = prism.boxes[2 * j + 1];
        let t0 = (lo.xyz - ro) * inv;
        let t1 = (hi.xyz - ro) * inv;
        let tn = min(t0, t1);
        let tf = max(t0, t1);
        let tmin = max(max(tn.x, tn.y), tn.z);
        let tmax = min(min(tf.x, tf.y), tf.z);
        if tmax < max(tmin, 1e-5) || tmin > best {
            continue;
        }
        let k0 = i32(lo.w + 0.5);
        let n = i32(hi.w + 0.5);
        for (var i = k0; i < k0 + n; i++) {
            let t = prism_tri(ro, rd, i);
            if t > 1e-5 && t < best {
                best = t;
                hit = i;
            }
        }
    }
    return vec2<f32>(best, f32(hit));
}

fn sculpt_proto(p: vec3<f32>, theme: i32, shape: i32) -> vec2<f32> {
    if theme == 3 {
        return s_voxels(p, shape);
    }
    if theme == 5 {
        return s_glass(p, shape);
    }
    return s_rimmed(p, theme, shape);
}

fn sculpt_point(q: vec3<f32>) -> vec3<f32> {
    let zref = select(SCULPT_ZREF_HAND, SCULPT_ZREF_ARROW, (sculpt_id() - 1) % 2 == 0);
    return vec3<f32>(q.x, -q.y, q.z / max(layer.color.b, 1e-3)) / SCULPT_SCALE + vec3<f32>(0.0, 0.0, zref);
}

fn sculpt_units() -> f32 {
    return SCULPT_SCALE * min(layer.color.b, 1.0);
}

fn sculpt_eval(q: vec3<f32>, occ: bool) -> vec2<f32> {
    let id = sculpt_id() - 1;
    let theme = id / 2;
    let shape = id % 2;
    if theme == 1 {
        // Prism Glow : son serti seul, dans le repere du modele (le cristal est trace a part).
        return vec2<f32>(prism_rim(q, shape), 8.0);
    }
    let p = sculpt_point(q);
    var r: vec2<f32>;
    if occ && theme == 3 {
        let d2 = s_pixel_outline(p.xy, shape);
        let dz = abs(p.z - (SCULPT_HOVER + 0.07)) - 0.07;
        r = vec2<f32>(length(max(vec2<f32>(d2, dz), vec2<f32>(0.0))) + min(max(d2, dz), 0.0), 7.0);
    } else {
        r = sculpt_proto(p, theme, shape);
    }
    return vec2<f32>(r.x * sculpt_units(), r.y);
}

fn sd_sprite2(p: vec2<f32>) -> f32 {
    let lo = layer.color.rg;
    let c = clamp(p, lo, lo + sprite_size());
    // Niveau 0 explicite : la marche est une boucle a sortie anticipee (pas de derivees).
    let d = textureSampleLevel(texMask, samp, (c - lo) / sprite_size(), 0.0).r;
    let o = p - c;
    let out2 = dot(o, o);
    let e = max(d, 0.0);
    return select(d, sqrt(out2 + e * e), out2 > 0.0);
}

fn model_eval(p: vec3<f32>, occ: bool) -> vec2<f32> {
    if sculpt_id() > 0 {
        return sculpt_eval(p, occ);
    }
    let half_t = model_thick() * 0.5;
    let w = vec2<f32>(sd_sprite2(p.xy) + MODEL_BEVEL, abs(p.z + half_t) - (half_t - MODEL_BEVEL));
    return vec2<f32>(min(max(w.x, w.y), 0.0) + length(max(w, vec2<f32>(0.0))) - MODEL_BEVEL, 0.0);
}

fn ray_box(o: vec3<f32>, d: vec3<f32>, lo: vec3<f32>, hi: vec3<f32>) -> vec2<f32> {
    let inv = vec3<f32>(1.0) / select(vec3<f32>(1e-6), d, abs(d) > vec3<f32>(1e-6));
    let t0 = (lo - o) * inv;
    let t1 = (hi - o) * inv;
    let tn = min(t0, t1);
    let tf = max(t0, t1);
    return vec2<f32>(max(max(tn.x, tn.y), tn.z), min(min(tf.x, tf.y), tf.z));
}

struct ModelFrame {
    c: vec3<f32>,
    s: vec3<f32>,
    cp: f32,
    sp: f32,
    cy: f32,
    sy: f32,
}

fn world_to_plane(v: vec3<f32>, f: ModelFrame) -> vec3<f32> {
    let y = v.y * f.c.x + v.z * f.s.x;
    var z = -v.y * f.s.x + v.z * f.c.x;
    let x = v.x * f.c.y - z * f.s.y;
    z = v.x * f.s.y + z * f.c.y;
    return vec3<f32>(x * f.c.z + y * f.s.z, -x * f.s.z + y * f.c.z, z);
}

fn model_to_plane(v: vec3<f32>, f: ModelFrame) -> vec3<f32> {
    let y = v.y * f.cp - v.z * f.sp;
    let z = v.y * f.sp + v.z * f.cp;
    return vec3<f32>(v.x * f.cy - y * f.sy, v.x * f.sy + y * f.cy, z);
}

fn plane_to_model(v: vec3<f32>, f: ModelFrame) -> vec3<f32> {
    let x = v.x * f.cy + v.y * f.sy;
    let y = -v.x * f.sy + v.y * f.cy;
    return vec3<f32>(x, y * f.cp + v.z * f.sp, -y * f.sp + v.z * f.cp);
}

fn model_albedo(p: vec2<f32>) -> vec3<f32> {
    let texel = sprite_texel();
    let e = 0.25 * texel;
    let g = vec2<f32>(sd_sprite2(p + vec2<f32>(e, 0.0)) - sd_sprite2(p - vec2<f32>(e, 0.0)),
                      sd_sprite2(p + vec2<f32>(0.0, e)) - sd_sprite2(p - vec2<f32>(0.0, e)));
    let q = p - g / max(length(g), 1e-6) * max(sd_sprite2(p) + MODEL_RIM_INSET * texel, 0.0);
    return textureSampleLevel(texDof, samp, (q - layer.color.rg) / sprite_size(), 0.0).rgb;
}

struct SculptMat {
    alb: vec3<f32>,
    rough: f32,
    spec: f32,
    sss: f32,
    refl: f32,
}

fn s_pixel_colour(p: vec3<f32>, shape: i32) -> vec3<f32> {
    let cell = s_pix_cell(p.xy, shape);
    let g = PIX_GRID[shape];
    let row = g.z + clamp(cell.y, 0, g.y - 1);
    if s_pix_bit(PIX_LINE[row], cell.x) {
        return s_lin(0.29, 0.12, 0.36);
    }
    if s_pix_bit(PIX_HI[row], cell.x) {
        return s_lin(1.0, 0.78, 0.87);
    }
    if s_pix_bit(PIX_SHADE[row], cell.x) {
        return s_lin(0.87, 0.27, 0.51);
    }
    return s_lin(1.0, 0.435, 0.66);
}

fn sculpt_material(mat: f32, p: vec3<f32>, theme: i32, shape: i32) -> SculptMat {
    let primary = mat < 1.5;
    if theme == 0 {
        if mat < 2.5 {
            return SculptMat(s_lin(0.95, 0.92, 0.85), 0.3, 0.6, 0.35, 0.25);
        }
        return SculptMat(s_lin(0.1, 0.1, 0.11), 0.55, 0.05, 0.0, 0.1);
    }
    if theme == 1 {
        return SculptMat(s_lin(0.02, 0.05, 0.33), 0.35, 0.5, 0.05, 0.3);
    }
    if theme == 5 {
        return SculptMat(s_lin(0.05, 0.055, 0.07), 0.25, 0.7, 0.0, 0.35);
    }
    if theme == 2 {
        if (primary && shape == 0) || (mat > 2.5 && mat < 3.5 && shape == 1) {
            return SculptMat(s_lin(1.0, 0.40, 0.30), 0.85, 0.08, 0.15, 0.03);
        }
        if mat < 3.5 {
            return SculptMat(s_lin(1.0, 0.80, 0.10), 0.85, 0.08, 0.15, 0.03);
        }
        return SculptMat(s_lin(0.09, 0.13, 0.45), 0.9, 0.05, 0.05, 0.02);
    }
    if theme == 4 {
        if primary && shape == 0 {
            return SculptMat(s_lin(0.68, 0.93, 0.80), 0.25, 0.7, 0.3, 0.3);
        }
        if primary {
            return SculptMat(s_lin(0.97, 0.95, 0.90), 0.3, 0.6, 0.35, 0.25);
        }
        if mat < 2.5 {
            return SculptMat(s_lin(0.52, 0.87, 0.78), 0.25, 0.7, 0.3, 0.3);
        }
        if mat < 3.5 {
            return SculptMat(s_lin(1.0, 0.75, 0.25), 0.25, 0.7, 0.3, 0.3);
        }
        if mat < 4.5 {
            return SculptMat(s_lin(0.62, 0.92, 0.72), 0.3, 0.6, 0.3, 0.35);
        }
        return SculptMat(s_lin(0.07, 0.15, 0.33), 0.7, 0.15, 0.05, 0.08);
    }
    return SculptMat(s_pixel_colour(p, shape), 0.65, 0.1, 0.12, 0.04);
}

fn model_env(d: vec3<f32>, rough: f32, l: vec3<f32>, fill: vec3<f32>) -> vec3<f32> {
    var col = mix(SCULPT_SCREEN * 0.9, s_lin(0.82, 0.85, 0.92) * 0.55, smoothstep(-0.15, 0.35, d.z));
    let w = rough * 0.3;
    let k = 1.0 - rough * 0.6;
    col = col + s_lin(1.0, 0.97, 0.92) * 5.0 * k * smoothstep(0.90 - w, 0.97, dot(d, l));
    col = col + s_lin(0.85, 0.9, 1.0) * 1.6 * k * smoothstep(0.93 - w, 0.98, dot(d, fill));
    return col;
}

fn model_tonemap(c0: vec3<f32>) -> vec3<f32> {
    let start = 0.76;
    let x = min(c0.r, min(c0.g, c0.b));
    var c = c0 - vec3<f32>(select(0.04, x - 6.25 * x * x, x < 0.08));
    let peak = max(c.r, max(c.g, c.b));
    if peak >= start {
        let d = 1.0 - start;
        let np = 1.0 - d * d / (peak + d - start);
        c = c * (np / peak);
        let g = 1.0 - 1.0 / (0.15 * (peak - np) + 1.0);
        c = mix(c, vec3<f32>(np), g);
    }
    return pow(saturate(c), vec3<f32>(1.0 / 2.2));
}

fn model_shade(q: vec3<f32>, n: vec3<f32>, rd: vec3<f32>, L: vec3<f32>, fall: f32, sh: f32, ao: f32, mat: f32,
               l: vec3<f32>, fill: vec3<f32>) -> vec3<f32> {
    let id = sculpt_id();
    var m: SculptMat;
    var gloss = 1.0;
    if id > 0 {
        let p = sculpt_point(q) - vec3<f32>(n.x, -n.y, n.z) * 0.01;
        m = sculpt_material(mat, p, (id - 1) / 2, (id - 1) % 2);
        if id == 3 || id == 4 || id > 10 {
            // Le serti de Prism Glow et le trait de Glass Lens, comme un sprite : brillants sur
            // leur arrondi seulement.
            gloss = 1.0 - smoothstep(0.97, 0.995, abs(n.z));
        }
    } else {
        m = SculptMat(pow(model_albedo(q.xy), vec3<f32>(2.2)), 0.45, 0.35, 0.2, 0.3);
        gloss = 1.0 - smoothstep(0.97, 0.995, abs(n.z));
    }
    let key = s_lin(1.0, 0.97, 0.93) * 2.1 * fall;
    let ndl = dot(n, L);
    let wrap = 0.5 * m.sss;
    let dif = saturate((ndl + wrap) / (1.0 + wrap)) * mix(sh, 1.0, 0.15 * m.sss);
    let ndh = saturate(dot(n, normalize(L - rd)));
    let shin = exp2(10.0 * (1.0 - m.rough) + 1.0);
    let spe = (pow(ndh, shin) * (shin + 8.0) / 25.0 + 0.15 * pow(ndh, 8.0)) * sh * saturate(ndl * 4.0);
    let fre = pow(1.0 - saturate(dot(n, -rd)), 5.0);
    let amb = mix(SCULPT_SCREEN * 0.12, s_lin(0.88, 0.92, 1.0) * 0.22, 0.5 + 0.5 * n.z);
    let fl = s_lin(0.85, 0.9, 1.0) * saturate(dot(n, fill)) * 0.12;
    var col = m.alb * (key * dif + (amb + fl) * ao * mix(vec3<f32>(1.0), m.alb, 0.5));
    col = col + key * spe * m.spec * gloss;
    col = col + model_env(reflect(rd, n), m.rough, l, fill) * m.refl * (0.04 + 0.96 * fre) * ao * gloss;
    col = col + s_lin(0.9, 0.95, 1.0) * fre * 0.08 * ao * sh;
    return model_tonemap(col);
}

// ---- Le cristal de Prism Glow ----

fn prism_fresnel(c: f32, ior: f32) -> f32 {
    var f0 = (ior - 1.0) / (ior + 1.0);
    f0 = f0 * f0;
    return f0 + (1.0 - f0) * pow(1.0 - c, 5.0);
}

// (distance, facette) du cristal sur le rayon ; (1e9, -1) si rate, hors de Prism Glow, ou sur une
// paroi sous le dessus du serti (le rayon a traverse le serti avant).
fn prism_primary(ro: vec3<f32>, rd: vec3<f32>) -> vec2<f32> {
    let shape = prism_shape();
    if shape < 0 {
        return vec2<f32>(1e9, -1.0);
    }
    let r = prism_trace(ro, rd, shape);
    let h = i32(r.y);
    if h >= 0 && (prism_flags(h) & 1) == 1 && ro.z + rd.z * r.x < 0.0 {
        return vec2<f32>(1e9, -1.0);
    }
    return r;
}

fn prism_normal(h: i32, rd: vec3<f32>) -> vec3<f32> {
    let n = prism.tris[4 * h + 3].xyz;
    return select(n, -n, dot(n, rd) > 0.0);
}

fn prism_seg(p: vec3<f32>, a: vec3<f32>, b: vec3<f32>) -> f32 {
    let pa = p - a;
    let ba = b - a;
    return length(pa - ba * saturate(dot(pa, ba) / dot(ba, ba)));
}

// Distance, en pixels, de `p` aux aretes reelles de la facette `h` (plis et bord du serti).
fn prism_edge_px(p: vec3<f32>, h: i32, px: f32) -> f32 {
    let a = prism.tris[4 * h].xyz;
    let b = a + prism.tris[4 * h + 1].xyz;
    let c = a + prism.tris[4 * h + 2].xyz;
    let bits = prism_flags(h) >> 1u;
    var d = 1e9;
    if (bits & 1) != 0 {
        d = min(d, prism_seg(p, b, c));
    }
    if (bits & 2) != 0 {
        d = min(d, prism_seg(p, c, a));
    }
    if (bits & 4) != 0 {
        d = min(d, prism_seg(p, a, b));
    }
    return d / px;
}

// La rotation inverse de `world_to_plane` : du repere du plan a celui de la camera.
fn plane_to_world(v: vec3<f32>, f: ModelFrame) -> vec3<f32> {
    let x = v.x * f.c.z - v.y * f.s.z;
    let y = v.x * f.s.z + v.y * f.c.z;
    let z = -x * f.s.y + v.z * f.c.y;
    return vec3<f32>(x * f.c.y + v.z * f.s.y, y * f.c.x - z * f.s.x, y * f.s.x + z * f.c.x);
}

// L'uv de sortie du point ou le rayon (q, d) du modele retombe sur le plan, (-1, -1) s'il n'y
// retombe pas (cf. HLSL).
fn screen_uv(q: vec3<f32>, d: vec3<f32>, nz: vec3<f32>, hz: f32, tip: vec3<f32>, unit: f32, f: ModelFrame) -> vec2<f32> {
    let denom = dot(d, nz);
    if denom > -1e-4 {
        return vec2<f32>(-1.0);
    }
    let g = q + d * ((hz - dot(q, nz)) / denom);
    let w = plane_to_world(tip + unit * model_to_plane(g, f), f);
    let k = 1.0 - w.z / layer.src.z;
    if k < 1e-3 {
        return vec2<f32>(-1.0);
    }
    return layer.dst.xy + ((w.xy + layer.mb.zw) / k - layer.src.xy) / layer.quad_px * layer.dst.zw;
}

// L'image composee en `uv` : sa copie au binding 1, en lineaire ; hors de l'image, l'ecran sombre
// du studio.
fn screen_at(uv: vec2<f32>) -> vec3<f32> {
    if any(uv < vec2<f32>(0.0)) || any(uv > vec2<f32>(1.0)) {
        return SCULPT_SCREEN * 0.2;
    }
    return pow(textureSampleLevel(texY, samp, uv, 0.0).rgb, vec3<f32>(2.2));
}

// L'image composee la ou le rayon retombe sur le plan (cf. HLSL).
fn prism_screen(q: vec3<f32>, d: vec3<f32>, nz: vec3<f32>, hz: f32, tip: vec3<f32>, unit: f32, f: ModelFrame) -> vec3<f32> {
    return screen_at(screen_uv(q, d, nz, hz, tip, unit, f));
}

fn prism_shade(p: vec3<f32>, n: vec3<f32>, rd: vec3<f32>, h: i32, px: f32, l: vec3<f32>, fill: vec3<f32>,
               nz: vec3<f32>, hz: f32, tip: vec3<f32>, unit: f32, f: ModelFrame) -> vec3<f32> {
    let shape = prism_shape();
    let facet = vec3<f32>(prism.tris[4 * h + 1].w, prism.tris[4 * h + 2].w, prism.tris[4 * h + 3].w);
    let F = prism_fresnel(saturate(-dot(rd, n)), PRISM_IOR);
    let zb = -model_thick();
    var trans = vec3<f32>(0.0);
    for (var ch = 0; ch < 3; ch++) {
        // Le rouge plie le moins, le bleu le plus ; le canal passe par un masque (comme au HLSL).
        let mask = vec3<f32>(f32(ch == 0), f32(ch == 1), f32(ch == 2));
        let ior = PRISM_IOR + PRISM_DISPERSION * f32(ch - 1);
        var d = refract(rd, n, 1.0 / ior);
        var pos = p;
        var thr = 1.0;
        var acc = 0.0;
        for (var b = 0; b < PRISM_BOUNCES; b++) {
            let hit = prism_trace(pos, d, shape);
            let hh = i32(hit.y);
            let th = hit.x;
            var tb = 1e9;
            if d.z < -1e-6 {
                tb = (zb - pos.z) / d.z;
            }
            if tb <= th {
                let qb = pos + d * tb;
                let d2 = refract(d, vec3<f32>(0.0, 0.0, 1.0), ior);
                if dot(d2, d2) < 1e-8 {
                    pos = qb;
                    d = reflect(d, vec3<f32>(0.0, 0.0, 1.0));
                    continue;
                }
                acc = acc + thr * dot(prism_screen(qb, d2, nz, hz, tip, unit, f), mask);
                thr = 0.0;
                break;
            }
            if hh < 0 {
                break;
            }
            pos = pos + d * th;
            let rn = prism.tris[4 * hh + 3].xyz;
            if (prism_flags(hh) & 1) == 1 && pos.z < 0.0 {
                acc = acc + thr * dot(s_lin(0.03, 0.06, 0.37) * 0.35, mask);
                thr = 0.0;
                break;
            }
            let dout = refract(d, -rn, ior);
            if dot(dout, dout) < 1e-8 {
                d = reflect(d, -rn);
                continue;
            }
            let fi = prism_fresnel(saturate(dot(dout, rn)), ior);
            acc = acc + thr * (1.0 - fi) * dot(model_env(dout, 0.05, l, fill), mask);
            thr = thr * fi;
            d = reflect(d, -rn);
        }
        trans = trans + acc * mask;
    }
    var col = F * model_env(reflect(rd, n), 0.05, l, fill) + (1.0 - F) * trans + facet * PRISM_GLOW;
    let fold = 1.0 - smoothstep(0.2, 1.0, prism_edge_px(p, h, px));
    col = mix(col, s_lin(0.96, 0.99, 1.0) * 1.3, PRISM_FOLD * fold * (0.35 + 0.65 * saturate(dot(n, l))));
    return model_tonemap(col);
}

// ---- Le verre de Glass Lens ---- (cf. HLSL)

// Ce que le verre ajoute a ce qu'il transmet : Fresnel, l'eclat de la lampe, le liseré de lumiere.
fn glass_light(trans: vec3<f32>, n: vec3<f32>, rd: vec3<f32>, L: vec3<f32>, fall: f32, l: vec3<f32>,
               fill: vec3<f32>) -> vec3<f32> {
    let c = saturate(-dot(rd, n));
    let F = prism_fresnel(c, GLASS_IOR);
    let ndh = saturate(dot(n, normalize(L - rd)));
    let ndl = dot(n, L);
    let key = s_lin(1.0, 0.97, 0.93) * 2.1 * fall;
    let spe = (pow(ndh, 900.0) * 5.0 + pow(ndh, 40.0) * 0.12) * saturate(ndl * 4.0);
    let edge = pow(1.0 - c, 4.0) * (0.25 + 0.75 * saturate(ndl + 0.3));
    let col = (1.0 - F) * (trans * s_lin(0.97, 0.985, 1.0) + vec3<f32>(GLASS_LIFT))
        + F * model_env(reflect(rd, n), 0.03, l, fill);
    return col + key * spe + s_lin(0.92, 0.96, 1.0) * edge * 0.6;
}

// L'image en `uv`, moyennee le long de la refraction depuis `uv0` (cf. HLSL).
fn glass_smear(uv: vec2<f32>, uv0: vec2<f32>) -> vec3<f32> {
    let s = select(vec2<f32>(0.0), (uv - uv0) * GLASS_SMEAR, all(uv0 >= vec2<f32>(0.0)));
    return (screen_at(uv) + screen_at(uv - s) + screen_at(uv + s)) / 3.0;
}

fn glass_shade(q: vec3<f32>, n: vec3<f32>, rd: vec3<f32>, L: vec3<f32>, fall: f32, l: vec3<f32>,
               fill: vec3<f32>, nz: vec3<f32>, hz: f32, tip: vec3<f32>, unit: f32, f: ModelFrame) -> vec3<f32> {
    let zb = -model_thick();
    let uv0 = screen_uv(q, rd, nz, hz, tip, unit, f);
    var trans = vec3<f32>(0.0);
    for (var ch = 0; ch < 3; ch++) {
        let mask = vec3<f32>(f32(ch == 0), f32(ch == 1), f32(ch == 2));
        let ior = GLASS_IOR + GLASS_DISPERSION * f32(ch - 1);
        let d = refract(rd, n, 1.0 / ior);
        var seen = model_env(d, 0.05, l, fill);
        if d.z < -1e-4 {
            let qb = q + d * ((zb - q.z) / d.z);
            let d2 = refract(d, vec3<f32>(0.0, 0.0, 1.0), ior);
            if dot(d2, d2) < 1e-8 {
                seen = model_env(reflect(d, vec3<f32>(0.0, 0.0, 1.0)), 0.05, l, fill);
            } else {
                seen = glass_smear(screen_uv(qb, d2, nz, hz, tip, unit, f), uv0);
            }
        }
        trans = trans + seen * mask;
    }
    return pow(saturate(glass_light(trans, n, rd, L, fall, l, fill)), vec3<f32>(1.0 / 2.2));
}

// Les passes de la boucle unique de `cursor_model` (cf. HLSL : un seul appel de `model_eval`).
const STAGE_MARCH: i32 = 0;
const STAGE_NORMAL: i32 = 1;
const STAGE_AO: i32 = 2;
const STAGE_SELF: i32 = 3;
const STAGE_PLANE: i32 = 4;
const STAGE_EDGE: i32 = 5;
const STAGE_SHADE: i32 = 6;
const STAGE_DONE: i32 = 7;

const MODEL_SUBPIXEL = array<vec2<f32>, 3>(vec2<f32>(0.35, 0.2), vec2<f32>(-0.35, 0.2), vec2<f32>(0.0, -0.4));

fn model_tetra(k: i32) -> vec3<f32> {
    let b = vec3<f32>(f32(((k + 3) >> 1u) & 1), f32((k >> 1u) & 1), f32(k & 1));
    return 0.5773 * (2.0 * b - vec3<f32>(1.0));
}

fn cursor_model(local: vec2<f32>) -> vec4<f32> {
    var f: ModelFrame;
    f.c = cos(layer.fx.xyz);
    f.s = sin(layer.fx.xyz);
    f.cp = cos(layer.fx.w);
    f.sp = sin(layer.fx.w);
    f.cy = cos(layer.src_prev.w);
    f.sy = sin(layer.src_prev.w);
    let persp = layer.src.z;
    let unit = layer.src.w;
    let tip = layer.src_prev.xyz;
    let lo = vec3<f32>(layer.color.rg, -model_thick());
    let hi = vec3<f32>(layer.color.rg + sprite_size(), layer.trail_a.z);

    let dw = vec3<f32>(local + layer.src.xy, -persp);
    var dlen = length(dw);
    // Plan translate de mb.zw dans le repere camera (camera reelle ; 0 sous un angle fixe).
    let ro = plane_to_model((world_to_plane(vec3<f32>(-layer.mb.z, -layer.mb.w, persp), f) - tip) / unit, f);
    let rd = plane_to_model(world_to_plane(dw / dlen, f), f);
    let l = plane_to_model(world_to_plane(MODEL_LIGHT, f), f);
    let fill = plane_to_model(world_to_plane(MODEL_FILL, f), f);
    let nz = plane_to_model(vec3<f32>(0.0, 0.0, 1.0), f);
    let hz = -tip.z / unit;
    let stride = select(1.0, 0.85, sculpt_id() > 0);
    let lamp = vec3<f32>(layer.color.rg + sprite_size() * 0.5, 0.0) + l * SCULPT_LAMP_DIST;

    var ray = rd;
    var tb = ray_box(ro, ray, lo - vec3<f32>(0.02), hi + vec3<f32>(0.02));
    var stage = select(STAGE_DONE, STAGE_MARCH, tb.x < tb.y && tb.y > 0.0);
    var plane_next = stage == STAGE_DONE;
    // Prism Glow : le cristal, trace au depart de chaque rayon (`tc` son point, `hc` sa facette).
    var need_tc = stage == STAGE_MARCH;
    var tc = 1e9;
    var hc = -1;
    var k = 0;
    var t = max(tb.x, 0.0);
    var best = 1e9;
    var t_best = t;
    var d_best = 0.0;
    var mat = 0.0;
    var cov = 0.0;
    var cov_s = 0.0;
    var q = vec3<f32>(0.0);
    var n = vec3<f32>(0.0);
    var L = vec3<f32>(0.0);
    var ao = 1.0;
    var sh = 1.0;
    var ts = vec2<f32>(0.0);
    var res = 1.0;
    var g = vec3<f32>(0.0);
    var inside = 0.0;
    var contact = 0.0;
    var dropped = 0.0;
    var sub = 0;
    var shaded = 0;
    var acc = vec4<f32>(0.0);
    for (var it = 0; it < 500; it++) {
        if need_tc {
            need_tc = false;
            let pr = prism_primary(ro, ray);
            tc = pr.x;
            hc = i32(pr.y);
        }
        if plane_next {
            plane_next = false;
            stage = select(STAGE_DONE, STAGE_SHADE, cov > 0.0);
            let denom = dot(rd, nz);
            if cov < 1.0 && denom < -1e-4 {
                g = ro + rd * ((hz - dot(ro, nz)) / denom);
                let gp = tip + unit * model_to_plane(g, f);
                inside = saturate(min(layer.mb.x - abs(gp.x), layer.mb.y - abs(gp.y)) + 0.5);
                if inside > 0.0 {
                    stage = STAGE_PLANE;
                    k = 0;
                    ts = vec2<f32>(0.0);
                }
            }
        }
        if stage == STAGE_SHADE {
            if cov_s > 0.0 {
                var c: vec3<f32>;
                let tl = lamp - q;
                let fall = SCULPT_LAMP_DIST * SCULPT_LAMP_DIST / dot(tl, tl);
                if abs(mat - PRISM_MAT) < 0.5 {
                    c = prism_shade(q, n, ray, hc, t_best / dlen, l, fill, nz, hz, tip, unit, f);
                } else if mat > GLASS_MAT - 0.5 {
                    c = glass_shade(q, n, ray, normalize(tl), fall, l, fill, nz, hz, tip, unit, f);
                } else {
                    c = model_shade(q, n, ray, normalize(tl), fall, sh, ao, mat, l, fill);
                }
                acc = acc + vec4<f32>(c * cov_s, cov_s);
            }
            shaded++;
            stage = STAGE_DONE;
            if sub > 0 {
                let dws = vec3<f32>(local + MODEL_SUBPIXEL[3 - sub] + layer.src.xy, -persp);
                sub--;
                dlen = length(dws);
                ray = plane_to_model(world_to_plane(dws / dlen, f), f);
                tb = ray_box(ro, ray, lo - vec3<f32>(0.02), hi + vec3<f32>(0.02));
                cov_s = 0.0;
                stage = STAGE_SHADE;
                if tb.x < tb.y && tb.y > 0.0 {
                    stage = STAGE_MARCH;
                    k = 0;
                    t = max(tb.x, 0.0);
                    best = 1e9;
                    t_best = t;
                    need_tc = true;
                }
            }
            continue;
        }
        var pos: vec3<f32>;
        if stage == STAGE_MARCH {
            pos = ro + ray * t;
        } else if stage == STAGE_NORMAL {
            pos = q + 0.002 * model_tetra(k);
        } else if stage == STAGE_EDGE {
            let side = normalize(cross(n, ray));
            let e = select(side, cross(n, side), k >= 2) * select(1.0, -1.0, k % 2 == 1);
            pos = q + e * 0.5 * t_best / dlen;
        } else if stage == STAGE_AO {
            pos = q + (0.01 + 0.0175 * f32(k)) * SCULPT_SCALE * n;
        } else if stage == STAGE_SELF {
            pos = q + n * 0.003 + L * ts.x;
        } else if stage == STAGE_PLANE {
            pos = g + l * ts.x;
        } else {
            break;
        }
        let m = model_eval(pos, stage == STAGE_PLANE);
        let d = m.x;
        if stage == STAGE_MARCH {
            let fp = t / dlen;
            var hit = d < 0.1 * fp;
            if hit || d / fp < best {
                best = select(d / fp, 0.0, hit);
                t_best = t;
                d_best = d;
                mat = m.y;
            }
            t = t + d * stride;
            k++;
            if !hit && t >= tc {
                // Le pas depasse le cristal : c'est lui que le rayon touche, avant le serti.
                hit = true;
                best = 0.0;
                t_best = tc;
                d_best = 0.0;
                mat = PRISM_MAT;
            }
            if hit || t > tb.y || k == 96 {
                cov_s = saturate(1.0 - best);
                if shaded > 0 {
                    stage = STAGE_SHADE;
                    if cov_s > 0.0 {
                        q = ro + ray * t_best;
                        n = vec3<f32>(0.0);
                        stage = STAGE_NORMAL;
                        k = 0;
                    }
                } else {
                    cov = cov_s;
                    if cov > 0.0 {
                        q = ro + ray * t_best;
                        stage = STAGE_NORMAL;
                        k = 0;
                    } else {
                        plane_next = true;
                    }
                }
                if stage == STAGE_NORMAL && abs(mat - PRISM_MAT) < 0.5 {
                    // Le cristal : la normale de sa facette, ni occlusion ni ombre propre ; un bord
                    // reel a moins d'un pixel appelle les trois rayons de plus.
                    n = prism_normal(hc, ray);
                    k = 0;
                    if shaded > 0 {
                        stage = STAGE_SHADE;
                    } else {
                        if prism_edge_px(q, hc, t_best / dlen) < 0.75 {
                            sub = 3;
                        }
                        stage = STAGE_DONE;
                        plane_next = true;
                    }
                }
            }
        } else if stage == STAGE_NORMAL {
            n = n + model_tetra(k) * d;
            k++;
            if k == 4 {
                n = normalize(n);
                k = 0;
                stage = select(STAGE_EDGE, STAGE_SHADE, shaded > 0);
            }
        } else if stage == STAGE_EDGE {
            if m.y != mat || abs(d - d_best) > 0.02 * t_best / dlen {
                sub = 3;
            }
            if k == 0 && mat > 7.5 && mat < PRISM_MAT + 0.5 {
                // Le serti de Prism Glow au bord du cristal : son contour a moins d'un pixel.
                let ps = prism_shape();
                if ps >= 0 {
                    let dout = prism_poly_dist(q.xy, PRISM_OUT_START[ps], PRISM_OUT_COUNT[ps]);
                    if abs(dout) < 0.75 * t_best / dlen {
                        sub = 3;
                    }
                }
            }
            k++;
            if k == 4 {
                stage = STAGE_AO;
                k = 0;
                ao = 0.0;
            }
        } else if stage == STAGE_AO {
            ao = ao + ((0.01 + 0.0175 * f32(k)) * SCULPT_SCALE - d) * pow(0.85, f32(k));
            k++;
            if k == 5 {
                ao = saturate(1.0 - 3.5 * ao / SCULPT_SCALE);
                L = normalize(lamp - q);
                let tbs = ray_box(q + n * 0.003, L, lo - vec3<f32>(MODEL_SHADOW_PAD), hi + vec3<f32>(MODEL_SHADOW_PAD));
                if tbs.x < tbs.y && tbs.y > 0.0 {
                    stage = STAGE_SELF;
                    k = 0;
                    ts = vec2<f32>(max(tbs.x, 0.004), tbs.y);
                    res = 1.0;
                } else {
                    plane_next = true;
                }
            }
        } else if stage == STAGE_SELF {
            res = min(res, MODEL_SOFTNESS * d / ts.x);
            ts.x = ts.x + clamp(d, 0.01, 0.2);
            k++;
            if res < 0.002 || ts.x > ts.y || k == 32 {
                res = saturate(res);
                sh = res * res * (3.0 - 2.0 * res);
                plane_next = true;
            }
        } else if k == 0 {
            contact = 1.0 - smoothstep(0.0, MODEL_CONTACT_RADIUS, d);
            let tbp = ray_box(g, l, lo - vec3<f32>(MODEL_SHADOW_PAD), hi + vec3<f32>(MODEL_SHADOW_PAD));
            ts = vec2<f32>(max(tbp.x, 0.004), tbp.y);
            res = 1.0;
            k = 1;
            if !(tbp.x < tbp.y && tbp.y > 0.0) {
                stage = select(STAGE_DONE, STAGE_SHADE, cov > 0.0);
            }
        } else {
            res = min(res, MODEL_SOFTNESS * d / ts.x);
            ts.x = ts.x + clamp(d, 0.01, 0.2);
            k++;
            if res < 0.002 || ts.x > ts.y || k == 33 {
                res = saturate(res);
                dropped = 1.0 - res * res * (3.0 - 2.0 * res);
                stage = select(STAGE_DONE, STAGE_SHADE, cov > 0.0);
            }
        }
    }

    let w = 1.0 / f32(max(shaded, 1));
    // La lentille de Glass Lens laisse passer la lumiere : son ombre est plus claire.
    let clear = select(1.0, GLASS_SHADOW, sculpt_id() > 10);
    let shadow = inside * clear * max(dropped * MODEL_SHADOW_ALPHA, contact * MODEL_CONTACT_ALPHA);
    let a = acc.a * w * layer.color.a;
    return vec4<f32>(acc.rgb * w * layer.color.a, a + (1.0 - a) * shadow * layer.color.a); // premultiplie, ombre noire
}

// ============ Verre a plat (mode 19) ============ (cf. HLSL, `cursor_glass`) : la copie de
// l'image composee au binding 1.
fn cursor_glass(local: vec2<f32>, pout: vec2<f32>) -> vec4<f32> {
    if pout.x < layer.dst_prev.x || pout.x > layer.dst_prev.x + layer.dst_prev.z ||
        pout.y < layer.dst_prev.y || pout.y > layer.dst_prev.y + layer.dst_prev.w {
        return vec4<f32>(0.0);
    }
    let r = quad_inverse(local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.x);
    if r.z < 0.5 {
        return vec4<f32>(0.0);
    }
    let m = layer.color.rg + saturate(r.xy) * sprite_size();
    let p = vec2<f32>(m.x, -m.y) / SCULPT_SCALE;
    let px = 1.0 / max(layer.color.b * SCULPT_SCALE, 1e-3);
    let shape = (sculpt_id() - 1) % 2;
    var g = vec2<f32>(0.0);
    var gd = vec2<f32>(0.0);
    let e = 0.25 * px;
    for (var k = 0; k < 3; k++) {
        let o = select(select(vec2<f32>(0.0), vec2<f32>(0.0, e), k == 2), vec2<f32>(e, 0.0), k == 1);
        let v = s_glass2(p + o, shape);
        if k == 0 {
            g = v;
        } else if k == 1 {
            gd.x = v.y;
        } else {
            gd.y = v.y;
        }
    }
    let cov = saturate(0.5 - g.x / px);
    if cov <= 0.0 {
        return vec4<f32>(0.0);
    }
    var out_dir = (gd - vec2<f32>(g.y)) / e;
    out_dir = out_dir / max(length(out_dir), 1e-4);
    let relief = s_glass_relief(g.y);
    let dir = vec2<f32>(out_dir.x, -out_dir.y);
    let n = normalize(vec3<f32>(-relief.y * dir, 1.0));
    let rd = vec3<f32>(0.0, 0.0, -1.0);
    let rim = g.y > GLASS_LINE;
    let depth = select(GLASS_TOP - SCULPT_HOVER + relief.x, GLASS_RIM - GLASS_LINE, rim);
    var trans = vec3<f32>(0.0);
    for (var ch = 0; ch < 3; ch++) {
        let mask = vec3<f32>(f32(ch == 0), f32(ch == 1), f32(ch == 2));
        let ior = GLASS_IOR + GLASS_DISPERSION * f32(ch - 1);
        let d = refract(rd, n, 1.0 / ior);
        let d2 = refract(d, vec3<f32>(0.0, 0.0, 1.0), ior);
        var off = d.xy * depth / max(-d.z, 0.05);
        if !rim && dot(d2, d2) > 1e-8 {
            off = off + d2.xy * GLASS_GAP_FLAT / max(-d2.z, 0.05);
        }
        off = off * SCULPT_SCALE * layer.src.xy;
        trans = trans + glass_smear(pout + off, pout) * mask;
    }
    var col = glass_light(trans, n, rd, MODEL_LIGHT, 1.0, MODEL_LIGHT, MODEL_FILL);
    let edge_k = saturate(1.0 - min(g.y, GLASS_LINE - g.y) / (0.25 * GLASS_LINE));
    let side = select(1.0, -1.0, g.y < 0.5 * GLASS_LINE);
    let nl = normalize(vec3<f32>(side * edge_k * dir, 1.0));
    let hl = normalize(MODEL_LIGHT + vec3<f32>(0.0, 0.0, 1.0));
    let line_col = s_lin(0.05, 0.055, 0.07) * (0.6 + 0.5 * saturate(dot(nl, MODEL_LIGHT)))
        + s_lin(1.0, 0.97, 0.93) * 0.8 * edge_k * pow(saturate(dot(nl, hl)), 40.0);
    let in_line = saturate(0.5 + g.y / px) * saturate(0.5 - (g.y - GLASS_LINE) / px);
    col = mix(col, line_col, in_line);
    let a = cov * layer.color.a;
    return vec4<f32>(pow(saturate(col), vec3<f32>(1.0 / 2.2)) * a, a); // premultiplie
}

// ---- Impact du clic (mode 16) ----
// Port ligne pour ligne de `cursor_impact` (HLSL), dont les commentaires font foi.
fn cursor_impact(local: vec2<f32>) -> vec4<f32> {
    let r = quad_inverse(local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.x);
    let pf = layer.dst_prev.xy + r.xy * layer.dst_prev.zw;
    if r.z < 0.5 || any(pf < vec2<f32>(0.0)) || any(pf > vec2<f32>(1.0)) {
        return vec4<f32>(0.0);
    }
    let d = length(r.xy * 2.0 - vec2<f32>(1.0));
    let x = abs(d - layer.src.x);
    let aa = layer.radius_px;
    let ring = layer.src.z * (1.0 - smoothstep(layer.src.y - aa, layer.src.y + aa, x));
    let halo = layer.src.w * exp(-x * x / (6.0 * layer.src.y * layer.src.y + aa * aa));
    let spot = layer.mb.z * exp(-d * d / max(layer.mb.y * layer.mb.y, 1e-6));
    let shade = clamp(halo + spot, 0.0, 1.0);
    let a = ring + (1.0 - ring) * shade;
    return vec4<f32>(layer.color.rgb * ring, a) * layer.color.a; // premultiplie, ombre noire
}

// ---- Cadre d'APPAREIL modelise (mode 17) ----
// Port ligne pour ligne de `device_frame` (HLSL), dont les commentaires font foi : un portable,
// un telephone ou un moniteur modeles en vraie 3D autour du metrage, lances de rayons dans la
// MEME camera que le plan, la face ecran exactement sur le plan du metrage (mode 8), qui continue
// de le dessiner dans l'ouverture. Aluminium mat et verre noir, micro-chanfrein et filet de
// lumiere peint : un produit, pas un jouet gonfle. Formes neutres dessinees ici, aucune marque.
// Constantes : miroir de `frame_geometry.rs` (DEV_*), en unites du modele — l'unite du cadre
// (`frame_unit_px`), la meme quel que soit le ratio du clip ; emplacements du cbuffer :
// `frame_geometry::device_frame_cb`, resume au-dessus de `device_frame` dans le HLSL. Les deux
// rayons du corps y sont CONCENTRIQUES a celui de l'ouverture (`concentric_radius`).
const DEV_CHAMFER: f32 = 0.0021;
// Distance minimale de l'oeil du relief (`DEV_EYE_MIN`).
const DEV_EYE_MIN: f32 = 9.6;
// Le plan proche du modele (`device_near_plane`) et l'objectif des presets (1,6 petit cote).
const DEV_NEAR: f32 = 0.16;
const DEV_NEAR_BAND: f32 = 0.1;
const DEV_LENS: f32 = 1.6;
// Le socle a la largeur de la coque ; tout le reste de ce qui depasse est fixe.
const DEV_DECK_LEN: f32 = 1.30;
// Liseré d'aluminium, rayon de la semelle, encoche du socle (cf. HLSL).
const DEV_RIM: f32 = 0.0053;
const DEV_FOOT_R: f32 = 0.0365;
const DEV_SCOOP_W: f32 = 0.14;
const DEV_SCOOP_D: f32 = 0.0372;
const DEV_SCOOP_H: f32 = 0.0112;
const DEV_DECK_THICK: f32 = 0.0446;
const DEV_DECK_THICK_FRONT: f32 = 0.0391;
const DEV_DECK_GAP: f32 = 0.0093;
const DEV_NECK_W: f32 = 0.255;
const DEV_NECK_LEN: f32 = 0.177;
const DEV_FOOT_W: f32 = 0.456;
const DEV_FOOT_H: f32 = 0.0456;
const DEV_STAND_Z: f32 = 0.0219;
const DEV_FOOT_Z: f32 = 0.195;
const DEV_SHELL_LIGHT = vec3<f32>(0.800, 0.806, 0.812);
const DEV_SHELL_LIGHT_BACK = vec3<f32>(0.600, 0.610, 0.622);
const DEV_GLASS_LIGHT = vec3<f32>(0.031, 0.034, 0.040);
const DEV_SHELL_GRAPHITE = vec3<f32>(0.255, 0.263, 0.278);
const DEV_SHELL_GRAPHITE_BACK = vec3<f32>(0.153, 0.161, 0.176);
const DEV_GLASS_GRAPHITE = vec3<f32>(0.043, 0.047, 0.055);
const DEV_SHEEN: f32 = 0.11;

fn dev_dark() -> bool {
    return layer.color.g > 0.5;
}

fn dev_shell() -> vec3<f32> {
    return select(DEV_SHELL_LIGHT, DEV_SHELL_GRAPHITE, dev_dark());
}

fn dev_shell_back() -> vec3<f32> {
    return select(DEV_SHELL_LIGHT_BACK, DEV_SHELL_GRAPHITE_BACK, dev_dark());
}

fn dev_glass() -> vec3<f32> {
    return select(DEV_GLASS_LIGHT, DEV_GLASS_GRAPHITE, dev_dark());
}

fn dev_body_c() -> vec2<f32> {
    return vec2<f32>((layer.src_prev.z - layer.src_prev.x) * 0.5, (layer.src_prev.w - layer.src_prev.y) * 0.5);
}

fn dev_body_h() -> vec2<f32> {
    return layer.mb.xy + vec2<f32>((layer.src_prev.x + layer.src_prev.z) * 0.5,
                                   (layer.src_prev.y + layer.src_prev.w) * 0.5);
}

fn dev_chamfer() -> f32 {
    return min(DEV_CHAMFER, layer.fx.w * 0.3);
}

// La hauteur du PLAN PROCHE devant l'ecran (unites), pour la camera REELLE en `eye` (repere du
// plan, unites) qui regarde le long de `axis` (cf. HLSL ; miroir de `device_near_plane`).
fn dev_near_plane(eye: vec3<f32>, axis: vec3<f32>) -> f32 {
    let dist = eye.z / max(-axis.z, 1e-3);
    return DEV_NEAR * DEV_EYE_MIN * dist / max(DEV_LENS * 2.0 * min(layer.mb.x, layer.mb.y), 1e-4);
}

// Ce qui reste d'un point `q` du modele sous le plan proche `h_near` : un fondu, jamais une coupe.
fn dev_near_fade(q: vec3<f32>, h_near: f32) -> f32 {
    return 1.0 - smoothstep(h_near * (1.0 - DEV_NEAR_BAND), h_near, q.z);
}

fn dev_deck_angle() -> f32 {
    return layer.dst_prev.x;
}

// L'appareil : 1 = portable, 2 = telephone, 3 = moniteur (`device_kind_id`).
fn dev_is(k: f32) -> bool {
    return abs(layer.color.r - k) < 0.5;
}

fn sd_dev_box(p: vec3<f32>, h: vec3<f32>, r: f32) -> f32 {
    let q = abs(p) - h + vec3<f32>(r);
    return length(max(q, vec3<f32>(0.0))) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
}

fn sd_dev_outline(p: vec2<f32>) -> f32 {
    // Coins hauts `radius_px`, coins bas `color.b` (cf. HLSL).
    let q = p - dev_body_c();
    return sd_round_rect(q, dev_body_h(), select(layer.color.b, layer.radius_px, q.y < 0.0));
}

// Ellipsoide (borne de distance) : l'encoche du socle.
fn sd_dev_ellipsoid(p: vec3<f32>, r: vec3<f32>) -> f32 {
    let k0 = length(p / r);
    let k1 = length(p / (r * r));
    return k0 * (k0 - 1.0) / max(k1, 1e-6);
}

// La dalle PLEINE du corps, sans le creux de l'ecran : la silhouette qui porte l'ombre.
fn sd_dev_slab(p: vec3<f32>) -> f32 {
    let t = layer.fx.w;
    let ch = dev_chamfer();
    let w = vec2<f32>(sd_dev_outline(p.xy) + ch, abs(p.z + t * 0.5) - (t * 0.5 - ch));
    return min(max(w.x, w.y), 0.0) + length(max(w, vec2<f32>(0.0))) - ch;
}

// L'OUVERTURE (<0 dedans) : le contour du metrage (rayon `dst_prev.y`) rentre du recouvrement
// `dst_prev.z` comme un decalage -- memes centres d'arc, rayon diminue d'autant -- : la lunette
// mord le metrage de la meme largeur aux coins que le long des bords (cf. HLSL).
fn sd_dev_aperture(p: vec2<f32>) -> f32 {
    let ah = layer.mb.xy - vec2<f32>(layer.dst_prev.z);
    return sd_round_rect(p, ah, clamp(layer.dst_prev.y - layer.dst_prev.z, 0.0, min(ah.x, ah.y)));
}

fn sd_dev_body(p: vec3<f32>) -> f32 {
    let hole = max(sd_dev_aperture(p.xy), -p.z - layer.fx.w * 0.55);
    return max(sd_dev_slab(p), -hole);
}

fn dev_deck_local(p: vec3<f32>) -> vec3<f32> {
    let c = dev_body_c();
    let h = dev_body_h();
    let d = p - vec3<f32>(0.0, c.y + h.y, -layer.fx.w * 0.5);
    let ca = cos(dev_deck_angle());
    let sa = sin(dev_deck_angle());
    return vec3<f32>(d.x, d.y * ca + d.z * sa, -d.y * sa + d.z * ca);
}

fn sd_dev_deck(p: vec3<f32>) -> f32 {
    let q = dev_deck_local(p);
    let y0 = DEV_DECK_GAP;
    let y1 = y0 + DEV_DECK_LEN;
    let tb = DEV_DECK_THICK;
    let slab = sd_dev_box(q - vec3<f32>(0.0, (y0 + y1) * 0.5, -tb * 0.5),
                          vec3<f32>(dev_body_h().x, (y1 - y0) * 0.5, tb * 0.5),
                          DEV_CHAMFER * 2.0);
    // Le dessous remonte vers l'avant : le profil en coin.
    let k = (DEV_DECK_THICK - DEV_DECK_THICK_FRONT) / DEV_DECK_LEN;
    let under = (-tb + k * (q.y - y0) - q.z) * inverseSqrt(1.0 + k * k);
    // L'encoche au milieu de l'arete avant (cf. HLSL).
    let scoop = sd_dev_ellipsoid(q - vec3<f32>(0.0, y1, 0.0), vec3<f32>(DEV_SCOOP_W, DEV_SCOOP_D, DEV_SCOOP_H));
    return max(max(slab, under), -scoop);
}

// Entree ANALYTIQUE du rayon dans le coin du socle, 1e9 s'il le manque (cf. HLSL, qui fait foi).
fn dev_deck_hit(ro: vec3<f32>, rd: vec3<f32>) -> f32 {
    let q0 = dev_deck_local(ro);
    let qd = dev_deck_local(ro + rd) - q0;
    let hw = dev_body_h().x;
    let y0 = DEV_DECK_GAP;
    let len = DEV_DECK_LEN;
    let tb = DEV_DECK_THICK;
    var tt = ray_box(q0, qd, vec3<f32>(-hw, y0, -tb), vec3<f32>(hw, y0 + len, 0.0));
    let k = (DEV_DECK_THICK - DEV_DECK_THICK_FRONT) / len;
    let g0 = -tb + k * (q0.y - y0) - q0.z;
    let gd = k * qd.y - qd.z;
    if abs(gd) > 1e-9 {
        let tg = -g0 / gd;
        if gd > 0.0 {
            tt.y = min(tt.y, tg);
        } else {
            tt.x = max(tt.x, tg);
        }
    } else if g0 > 0.0 {
        return 1e9;
    }
    if tt.x > tt.y || tt.y <= 0.0 {
        return 1e9;
    }
    // Entre par l'encoche, le rayon touche la matiere a sa sortie de l'ellipsoide.
    var t_in = max(tt.x, 0.0);
    let sr = vec3<f32>(DEV_SCOOP_W, DEV_SCOOP_D, DEV_SCOOP_H);
    let o = (q0 - vec3<f32>(0.0, y0 + len, 0.0)) / sr;
    let e = qd / sr;
    let ea = dot(e, e);
    let eb = dot(o, e);
    let disc = eb * eb - ea * (dot(o, o) - 1.0);
    if disc > 0.0 {
        let s = sqrt(disc);
        if t_in >= (-eb - s) / ea && t_in < (-eb + s) / ea {
            t_in = (-eb + s) / ea;
        }
    }
    if t_in <= tt.y {
        return t_in;
    }
    return 1e9;
}

fn sd_dev_stand(p: vec3<f32>) -> f32 {
    let y0 = dev_body_c().y + dev_body_h().y;
    let zc = -layer.fx.w * 0.5;
    let neck = sd_dev_box(p - vec3<f32>(0.0, y0 + DEV_NECK_LEN * 0.5 - 0.01, zc - DEV_STAND_Z * 0.5),
                          vec3<f32>(DEV_NECK_W, DEV_NECK_LEN * 0.5 + 0.01, DEV_STAND_Z * 0.5),
                          DEV_CHAMFER * 2.0);
    // La semelle : une plaque plate, coins arrondis dans son plan (xz), flancs droits.
    let f = p - vec3<f32>(0.0, y0 + DEV_NECK_LEN + DEV_FOOT_H * 0.5, zc - DEV_FOOT_Z * 0.5);
    let fd = vec2<f32>(sd_round_rect(f.xz, vec2<f32>(DEV_FOOT_W, DEV_FOOT_Z * 0.5), DEV_FOOT_R),
                       abs(f.y) - DEV_FOOT_H * 0.5);
    let foot = min(max(fd.x, fd.y), 0.0) + length(max(fd, vec2<f32>(0.0)));
    return min(neck, foot);
}

fn sd_dev_extra(p: vec3<f32>) -> f32 {
    if dev_is(1.0) {
        return sd_dev_deck(p);
    }
    if dev_is(3.0) {
        return sd_dev_stand(p);
    }
    return 1e9;
}

fn sd_device(p: vec3<f32>) -> f32 {
    return min(sd_dev_body(p), sd_dev_extra(p));
}

// Le modele PLEIN, ecran compris : ce que l'ombre voit.
fn sd_dev_solid(p: vec3<f32>) -> f32 {
    return min(sd_dev_slab(p), sd_dev_extra(p));
}

fn device_normal(p: vec3<f32>) -> vec3<f32> {
    let e = 0.0006;
    let ka = vec3<f32>(1.0, -1.0, -1.0);
    let kb = vec3<f32>(-1.0, -1.0, 1.0);
    let kc = vec3<f32>(-1.0, 1.0, -1.0);
    let kd = vec3<f32>(1.0, 1.0, 1.0);
    return normalize(ka * sd_device(p + ka * e) + kb * sd_device(p + kb * e) +
                     kc * sd_device(p + kc * e) + kd * sd_device(p + kd * e));
}

fn dev_cov(d: f32, aa: f32) -> f32 {
    return clamp(0.5 - d / max(aa, 1e-6), 0.0, 1.0);
}

// Filet de lumiere d'un pixel, peint juste a l'interieur d'un contour `d2` (<0 dedans).
fn dev_hairline(d2: f32, aa: f32) -> f32 {
    return dev_cov(abs(d2 + aa) - aa * 0.55, aa);
}

fn device_albedo(p: vec3<f32>, n: vec3<f32>, aa: f32) -> vec4<f32> {
    let metal = dev_shell();
    let back = dev_shell_back();
    if sd_dev_body(p) > sd_dev_extra(p) {
        if !dev_is(1.0) {
            // Le pied du moniteur : de l'aluminium, un degrade vertical doux.
            let v = clamp((p.y - dev_body_c().y - dev_body_h().y) / (DEV_NECK_LEN + DEV_FOOT_H), 0.0, 1.0);
            return vec4<f32>(mix(metal, back, 0.15 + 0.45 * v), 1.0);
        }
        let q = dev_deck_local(p);
        let hw = dev_body_h().x;
        let y0 = DEV_DECK_GAP;
        let len = DEV_DECK_LEN;
        // La tranche AVANT : une barre d'argent qui fonce doucement vers son arete basse.
        if q.y > y0 + len - DEV_CHAMFER * 3.0 {
            let s = clamp(-q.z / DEV_DECK_THICK_FRONT, 0.0, 1.0);
            return vec4<f32>(mix(metal, back, smoothstep(0.35, 1.0, s) * 0.8), 1.0);
        }
        if q.z < -DEV_DECK_THICK * 0.25 {
            return vec4<f32>(back, 1.0);
        }
        var top = metal;
        let key = sd_round_rect(q.xy - vec2<f32>(0.0, y0 + len * 0.33),
                                vec2<f32>(hw * 0.75, len * 0.23), len * 0.02);
        top = mix(top, metal * 0.52, dev_cov(key, aa));
        top = mix(top, metal * 1.06, dev_hairline(key, aa));
        let pad = sd_round_rect(q.xy - vec2<f32>(0.0, y0 + len * 0.76),
                                vec2<f32>(hw * 0.26, len * 0.14), len * 0.015);
        top = mix(top, metal * 0.88, dev_cov(pad, aa));
        top = mix(top, metal * 1.04, dev_hairline(pad, aa));
        return vec4<f32>(top, 1.0);
    }
    let shell = mix(back, metal, clamp(n.z * 0.8 + 0.5, 0.0, 1.0));
    // Le quart avant du corps seulement (cf. HLSL) : la colonne du moniteur n'est pas du verre.
    let front = select(smoothstep(0.30, 0.80, n.z), 0.0, p.z < -layer.fx.w * 0.25);
    if front <= 0.0 {
        return vec4<f32>(shell, 1.0);
    }
    // Le lisere d'aluminium qui borde la face avant, et le filet de lumiere sur son arete.
    let edge = sd_dev_outline(p.xy);
    let band = 1.0 - dev_cov(edge + DEV_RIM, aa);
    let rim = dev_hairline(edge, aa);
    var c = dev_glass();
    if dev_is(2.0) {
        // Telephone : un oeil de camera, rien d'autre, au milieu de la lunette du HAUT DU
        // TELEPHONE. Une ouverture paysage est un telephone COUCHE, son haut vers la gauche. Sa
        // taille est fixe, comme l'epaisseur du corps.
        let upright = layer.mb.y >= layer.mb.x;
        let e = select(vec2<f32>(-p.y, p.x), p.xy, upright);
        let hh = select(vec2<f32>(layer.mb.y, layer.mb.x), layer.mb.xy, upright);
        let bez = select(layer.src_prev.x, layer.src_prev.y, upright) - DEV_RIM;
        c = mix(c, vec3<f32>(0.086, 0.102, 0.133), dev_cov(length(e - vec2<f32>(0.0, -hh.y - bez * 0.5)) - 0.003, aa));
    } else {
        // Portable et moniteur : un oeil de camera centre dans la lunette du haut, pas d'encoche.
        let bez = layer.src_prev.y - DEV_RIM;
        c = mix(c, vec3<f32>(0.120, 0.133, 0.161), dev_cov(length(p.xy - vec2<f32>(0.0, -layer.mb.y - bez * 0.5)) - 0.2 * bez, aa));
    }
    c = mix(c, metal, band);
    c = mix(c, min(metal * 1.12, vec3<f32>(1.0)), rim);
    return vec4<f32>(mix(shell, c, front), max(band, rim));
}

// L'OMBRE portee de l'appareil (`dst_prev.w` = penombre en px) : la silhouette reelle du modele,
// socle et pied compris. Cf. `device_shadow` (HLSL), qui fait foi. Ce que le plan proche `h_near`
// efface de l'appareil, il l'efface de son ombre.
fn device_shadow(ro: vec3<f32>, rd: vec3<f32>, fpk: f32, lo: vec3<f32>, hi: vec3<f32>, h_near: f32) -> vec4<f32> {
    let spread = layer.dst_prev.w;
    let m = vec3<f32>(2.0 * spread / layer.src.w);
    let tb = ray_box(ro, rd, lo - m, hi + m);
    if tb.x >= tb.y || tb.y <= 0.0 {
        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
    }
    // Dans la silhouette pleine, a coup sur : le rayon perce la face avant ou le socle.
    if rd.z < -1e-5 && sd_dev_outline((ro + rd * (-ro.z / rd.z)).xy) < 0.0 {
        return vec4<f32>(0.0, 0.0, 0.0, layer.color.a);
    }
    var t_deck = 1e9;
    if dev_is(1.0) {
        t_deck = dev_deck_hit(ro, rd);
    }
    if t_deck < 1e9 {
        return vec4<f32>(0.0, 0.0, 0.0, layer.color.a * dev_near_fade(ro + rd * t_deck, h_near));
    }
    var t = max(tb.x, 0.0);
    var best = 1e9;
    var t_best = t;
    for (var k = 0; k < 96; k = k + 1) {
        let d = sd_dev_solid(ro + rd * t);
        let fp = t * fpk;
        if max(d, 0.0) / fp < best {
            best = max(d, 0.0) / fp;
            t_best = t;
        }
        if d < 0.08 * fp || t > tb.y {
            break;
        }
        t = t + max(d, fp);
    }
    let a = layer.color.a * (1.0 - smoothstep(0.0, spread, best)) * dev_near_fade(ro + rd * t_best, h_near);
    return vec4<f32>(0.0, 0.0, 0.0, a); // noir premultiplie
}

fn device_frame(local: vec2<f32>) -> vec4<f32> {
    var f: ModelFrame;
    f.c = cos(layer.fx.xyz);
    f.s = sin(layer.fx.xyz);
    f.cp = 1.0;
    f.sp = 0.0;
    f.cy = 1.0;
    f.sy = 0.0;
    let persp = layer.src.z;
    let unit = layer.src.w;

    let dw = vec3<f32>(local + layer.src.xy, -persp);
    let dlen = length(dw);
    let ro0 = world_to_plane(vec3<f32>(-layer.mb.z, -layer.mb.w, persp), f) / unit;
    let rd0 = world_to_plane(dw / dlen, f);
    let l = world_to_plane(MODEL_LIGHT, f);

    // Le plan proche (`DeviceView::near_plane`) : tire de la camera REELLE, avant qu'on la recule.
    let h_near = dev_near_plane(ro0, world_to_plane(vec3<f32>(0.0, 0.0, -1.0), f));

    // L'OEIL DU MODELE (`DeviceView::model_eye`, cf. HLSL) : recule sur sa droite a au moins
    // `DEV_EYE_MIN`, et jamais plus bas que la ligne du centre de l'ecran -- d'en dessous, le socle
    // montrait sa face inferieure et couvrait le bas du metrage. Chaque rayon passe par le MEME
    // point du plan.
    var ro = ro0;
    var rd = rd0;
    var fpk = 1.0 / dlen;
    if rd.z < -1e-5 {
        let ts = -ro.z / rd.z;
        let e0 = vec3<f32>(ro.x, min(ro.y, 0.0), ro.z);
        let eye = e0 * max(1.0, DEV_EYE_MIN / max(length(e0), 1e-3));
        let v = ro + rd * ts - eye;
        let lv = length(v);
        fpk = ts / dlen / lv;
        ro = eye;
        rd = v / lv;
    }

    // La boite du modele, miroir de `DeviceView::model_points`.
    let bc = dev_body_c();
    let bh = dev_body_h();
    var lo = vec3<f32>(bc - bh, -layer.fx.w);
    var hi = vec3<f32>(bc + bh, 0.0);
    if dev_is(1.0) {
        // Les quatre coins du profil du socle, de la charniere au bord avant, dessus et dessous.
        let ca = cos(dev_deck_angle());
        let sa = sin(dev_deck_angle());
        let hinge = vec2<f32>(bc.y + bh.y, -layer.fx.w * 0.5);
        let qy = vec2<f32>(DEV_DECK_GAP, DEV_DECK_GAP + DEV_DECK_LEN);
        let qz = vec2<f32>(0.0, -DEV_DECK_THICK);
        for (var j = 0; j < 4; j = j + 1) {
            let a = qy[j & 1];
            let b = qz[j >> 1u];
            let yz = hinge + vec2<f32>(a * ca - b * sa, a * sa + b * ca);
            lo = vec3<f32>(lo.x, min(lo.yz, yz));
            hi = vec3<f32>(hi.x, max(hi.yz, yz));
        }
    } else if dev_is(3.0) {
        lo = vec3<f32>(min(lo.x, -DEV_FOOT_W), lo.y, lo.z - DEV_FOOT_Z);
        hi = vec3<f32>(max(hi.x, DEV_FOOT_W), hi.y + DEV_NECK_LEN + DEV_FOOT_H, hi.z);
    }

    if layer.dst_prev.w > 0.0 {
        return device_shadow(ro, rd, fpk, lo, hi, h_near);
    }

    // Le plan du metrage occulte tout ce qui est derriere lui DANS l'ouverture ARRONDIE : entre
    // l'arc et le coin carre, c'est de la lunette.
    // Hors de l'ouverture, le meme point du plan dit si le rayon perce la FACE AVANT ; le socle a
    // son entree analytique. La marche ne sert qu'a ce qui les precede et a l'antialiasing.
    var t_max = 1e9;
    var t_solid = 1e9;
    if rd.z < -1e-5 {
        let ts = -ro.z / rd.z;
        let qp = ro.xy + rd.xy * ts;
        if ts > 0.0 && sd_dev_aperture(qp) < 0.0 {
            t_max = ts;
        } else if ts > 0.0 && sd_dev_outline(qp) < 0.0 {
            t_solid = ts;
        }
    }
    if dev_is(1.0) {
        t_solid = min(t_solid, dev_deck_hit(ro, rd));
    }
    let solid = t_solid < t_max;

    let tb = ray_box(ro, rd, lo - vec3<f32>(0.01), hi + vec3<f32>(0.01));
    let t1 = min(min(tb.y, t_max), t_solid);
    if !solid && (tb.x >= t1 || t1 <= 0.0) {
        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
    }

    var t = max(tb.x, 0.0);
    var best = 1e9;
    var t_best = t;
    var hit = false;
    for (var k = 0; k < 80; k = k + 1) {
        let d = sd_device(ro + rd * t);
        let fp = t * fpk;
        if d < 0.08 * fp {
            hit = true;
            t_best = t;
            break;
        }
        if d / fp < best {
            best = d / fp;
            t_best = t;
        }
        t = t + max(d, 0.25 * fp);
        if t > t1 {
            break;
        }
    }
    if !hit && solid {
        hit = true;
        t_best = t_solid;
    }
    let cov = select(clamp(1.0 - best, 0.0, 1.0), 1.0, hit);
    if cov <= 0.0 {
        return vec4<f32>(0.0, 0.0, 0.0, 0.0);
    }
    let q = ro + rd * t_best;
    let n = device_normal(q);
    let mat = device_albedo(q, n, t_best * fpk);
    let diffuse = clamp(dot(n, l), 0.0, 1.0);
    // Aucun lobe speculaire large : rien qu'un voile directionnel etroit sur le metal.
    let sheen = DEV_SHEEN * mat.a * pow(diffuse, 4.0);
    let rgb = mat.rgb * (MODEL_AMBIENT + MODEL_DIFFUSE * diffuse) + vec3<f32>(sheen);
    // Au-dela du plan proche, l'appareil s'efface (le socle, quand la camera en orbite avance).
    let a = cov * layer.color.a * dev_near_fade(q, h_near);
    return vec4<f32>(rgb * a, a); // premultiplie
}

@fragment
fn fs_main(i: VsOut) -> @location(0) vec4<f32> {
    var rgb: vec3<f32>;
    var alpha: f32;
    // 1 sauf en detourage, ou il porte le masque du sujet. Cf. la branche fx.z plus bas.
    var alpha_mask = 1.0;

    if layer.mode < 0.5 {
        // Mode 0 — vidéo NV12 + flou de mouvement par vélocité (§8), port 1:1 du
        // HLSL/MSL. Pour CE pixel de sortie, l'UV qu'il occupait à la frame
        // précédente se retrouve en le remappant par (dst_prev, src_prev) : on
        // floute le long de ce segment, ce qui capture la translation ET le zoom
        // du calque sans avoir à transporter un champ de vitesse.
        let taps = i32(layer.mb.x);
        let mb_scale = clamp(layer.mb.y, 0.0, 1.0);
        // `taps` d'abord : un draw qui a oublié `dst_prev` le laisse à zéro, et
        // la division par `dst_prev.zw` produirait des UV infinis. Dégrader vers
        // le chemin net est le seul échec acceptable pour un effet cosmétique.
        if taps <= 1 || mb_scale <= 0.001 || layer.dst_prev.z <= 0.0 || layer.dst_prev.w <= 0.0 {
            rgb = sample_yuv(i.uv);
        } else {
            let localp = (i.pout - layer.dst_prev.xy) / layer.dst_prev.zw;
            let uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);
            let duv = i.uv - uv_prev;
            let duv_blur = duv * mb_scale;
            if dot(duv_blur, duv_blur) < 1e-9 {
                rgb = sample_yuv(i.uv);
            } else {
                // Borne 16 en dur, identique au HLSL et au MSL : `taps` vient d'un
                // uniform et une boucle sans borne statique ne se déroule pas.
                // L'échelle de l'inspector s'arrête pile à 16 (1 + 15·blur), donc
                // c'est `taps` qui coupe, jamais la borne.
                var acc = vec3<f32>(0.0);
                let step = 1.0 / f32(taps - 1);
                for (var k: i32 = 0; k < 16; k = k + 1) {
                    if k >= taps { break; }
                    acc = acc + sample_yuv(i.uv - duv_blur * (1.0 - f32(k) * step));
                }
                rgb = acc / f32(taps);
            }
        }

        // Effet d'arriere-plan webcam. Miroir exact des branches HLSL et MSL : fx.z porte le
        // mode (1 = detourage, 2 = flou, 3 = fond plat), fx.w l'intensite du flou, fx.xy
        // l'etendue valide de la texture webcam pour ramener uv dans l'espace du masque.
        let effect = layer.fx.z;
        if effect > 0.5 {
            let mask_uv = i.uv / max(layer.fx.xy, vec2<f32>(1e-6));
            let person = clamp(textureSample(texMask, samp, mask_uv).r, 0.0, 1.0);
            if effect > 2.5 {
                rgb = mix(layer.color.rgb, rgb, person);
            } else if effect > 1.5 {
                rgb = mix(blur_webcam_bg(i.uv, layer.fx.w, layer.quad_px, i.local), rgb, person);
            } else {
                alpha_mask = person;
            }
        }
    } else if layer.mode < 1.5 {
        // Mode 1 — couleur pleine.
        rgb = layer.color.rgb;
    } else if layer.mode > 4.5 && layer.mode < 5.5 {
        // Mode 5 -- gradient lineaire jusqu'a 4 stops : noeuds `rgb + position` dans color,
        // src_prev, dst_prev, src (cf. `ramp4`), le long de la direction fx.xy (sin, -cos de
        // l'angle). Parite avec le HLSL/MSL.
        // `denom` : HLSL et MSL normalisent coin-a-coin (|dx|+|dy|) pour couvrir toute la
        // diagonale. Il manquait ici, donc le meme degrade ne rendait pas pareil sur Linux.
        // Fond anime : fx.z = temps programme (s, replie sur 120), fx.w = mouvement (0 immobile,
        // 1 derive, 2 aurore, 3 vagues), mb.x = aspect w/h. 0 rend le degrade d'avant a l'octet.
        var dir = layer.fx.xy;
        var slide = 0.0;
        if layer.fx.w > 0.5 && layer.fx.w < 1.5 {
            // Derive : l'axe balance de +-30 deg (0.5235988 rad) en 20 s, le degrade glisse le
            // long de lui de +-20 % en 15 s.
            let da = 0.5235988 * sin(6.2831853 * layer.fx.z / 20.0);
            let sa = sin(da);
            let ca = cos(da);
            dir = vec2<f32>(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);
            slide = 0.2 * sin(6.2831853 * layer.fx.z / 15.0);
        }
        let denom = max(abs(dir.x) + abs(dir.y), 1e-4);
        // Parametre sur le QUAD des qu'il en a un (la bulle webcam), sinon sur la sortie. Pour
        // le fond plein cadre les deux coincident ; pour une bulle dans un coin, `pout` ne
        // montrerait que la tranche du degrade plein cadre qui passe dessous.
        var gp = i.pout;
        if layer.quad_px.x > 0.0 && layer.quad_px.y > 0.0 {
            gp = i.local / layer.quad_px;
        }
        let t = clamp(0.5 + dot(gp - vec2<f32>(0.5), dir) / denom + slide, 0.0, 1.0);
        rgb = ramp4(t, layer.color, layer.src_prev, layer.dst_prev, layer.src);
        if layer.fx.w > 1.5 {
            rgb = gradient_motion(gp, dir, denom, layer.color, layer.src_prev, layer.dst_prev,
                                  layer.src, layer.fx.z, layer.fx.w, layer.mb.x);
        }
    } else if layer.mode > 10.5 && layer.mode < 11.5 {
        // Mode 11 : texte. texY est l'atlas R8 (couverture alpha au canal .r,
        // produit par text_cosmic::TextRasterizer), teinte par layer.color.
        // Sortie en alpha premultiplie, comme les autres modes.
        let cov = textureSample(texY, samp, i.uv).r;
        let a = layer.color.a * cov;
        return vec4<f32>(layer.color.rgb * a, a);
    } else if layer.mode > 8.5 && layer.mode < 9.5 {
        // Mode 9 -- annotation « figure » : une fleche. Parite EXACTE avec
        // `ArrowSvgs.tsx`, dont chaque direction est un trace de trois segments a
        // bouts ronds dans un viewBox 0..100 : une hampe et deux barbes. Trois
        // `sd_segment` et un `min` reproduisent la forme telle quelle, pas une
        // approximation. Les extremites arrivent deja converties en px locaux du
        // quad par `regions::arrow_local_geometry` (echelle uniforme centree,
        // comme le `preserveAspectRatio` par defaut du SVG), donc ce shader n'a
        // aucune geometrie a deviner.
        //
        // fx = hampe (a.xy, b.xy), src_prev = barbe 1, dst_prev = barbe 2 ;
        // mb.y = demi-epaisseur en px.
        var d = sd_segment(i.local, layer.fx.xy, layer.fx.zw);
        d = min(d, sd_segment(i.local, layer.src_prev.xy, layer.src_prev.zw));
        d = min(d, sd_segment(i.local, layer.dst_prev.xy, layer.dst_prev.zw));
        // Couverture sur ~1 px : le trait reste net sans crenelage, et une fleche
        // fine ne disparait pas quand la demi-epaisseur descend sous le pixel.
        let a = clamp(layer.mb.y - d + 0.5, 0.0, 1.0) * layer.color.a;
        return vec4<f32>(layer.color.rgb * a, a);
    } else if layer.mode > 9.5 && layer.mode < 10.5 {
        // Mode 10 -- annotation « flou » : masque la zone en reutilisant l'image
        // DEJA composee, qui arrive sur texY (recopie mipmappee du render target
        // -- on ne peut pas echantillonner la cible sur laquelle on dessine).
        // `i.pout` donne directement l'UV de sortie, donc aucun mapping a refaire.
        //
        // fx.x = 0 mosaique / 1 flou ; fx.y = taille de bloc px (mosaique) ou
        // rayon px (flou) ; fx.z = 0 rectangle / 1 ovale ; fx.w = 1 si teinte ;
        // mb.z = 1 si le masque est un quad incline (coins TL, TR dans dst_prev,
        // BR, BL dans src_prev) ; mb.w = 1 si son warp est projectif.
        var n = i.local / max(layer.quad_px, vec2<f32>(1e-6));
        // Ecran incline : le masque est warpe comme le contenu qu'il cache
        // (`FrameGeometry::privacy_mask`), par le meme inverse que le mode 8.
        // Bord net, marge de 2 % comprise : un fondu rendrait le masque en
        // partie transparent SUR la zone a cacher.
        if layer.mb.z > 0.5 {
            let wq = quad_inverse(i.local, layer.dst_prev.xy, layer.dst_prev.zw,
                                  layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);
            if wq.z < 0.5 {
                return vec4<f32>(0.0, 0.0, 0.0, 0.0);
            }
            n = wq.xy;
        }
        var cov = 1.0;
        if layer.fx.z > 0.5 {
            // Ovale inscrit : distance au centre en unites de demi-axes, adoucie
            // sur ~1px. Le fondu tombe HORS de l'ellipse : dedans, le masque
            // reste plein.
            let dc = (n - vec2<f32>(0.5)) * 2.0;
            let r = length(dc);
            let aa = 2.0 / max(min(layer.quad_px.x, layer.quad_px.y), 1.0);
            cov = 1.0 - smoothstep(1.0, 1.0 + aa, r);
        }
        if cov <= 0.0 {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        var masked: vec3<f32>;
        if layer.fx.x > 0.5 {
            // Flou : on echantillonne un niveau de mip de l'image composee.
            // `log2(rayon)` donne le niveau dont un texel couvre a peu pres le
            // rayon demande, et le filtrage trilineaire lisse la transition entre
            // deux niveaux quand le rayon varie.
            //
            // Un noyau de quelques taps espaces du rayon ne floute PAS : il
            // superpose autant de copies decalees, ce qui se voit comme du texte
            // fantome. Atteindre un vrai lissage par taps demanderait un tap par
            // pixel de rayon ; la pyramide de mips donne le meme resultat a cout
            // constant, et c'est le GPU qui l'a construite.
            let lod = log2(max(layer.fx.y, 1.0));
            masked = textureSampleLevel(texY, samp, i.pout, lod).rgb;
        } else {
            // Mosaique : on quantifie l'UV sur une grille de `fx.y` px, alignee
            // sur le quad pour que les blocs ne rampent pas quand l'annotation
            // bouge.
            let px_uv = layer.dst.zw / max(layer.quad_px, vec2<f32>(1e-6));
            let block = max(layer.fx.y, 1.0) * px_uv;
            let origin = layer.dst.xy;
            let q = origin + (floor((i.pout - origin) / block) + vec2<f32>(0.5)) * block;
            // Niveau 0 explicite : l'UV quantifie est une marche d'escalier, donc
            // ses derivees explosent en bord de bloc et le choix automatique de
            // mip ramollirait justement les aretes qui font la mosaique.
            masked = textureSampleLevel(texY, samp, q, 0.0).rgb;
        }
        if layer.fx.w > 0.5 {
            // Teinte blanc/noir : la couleur choisie, melee a moitie, garde la
            // forme lisible sans effacer completement ce qu'il y a dessous.
            masked = mix(masked, layer.color.rgb, 0.5);
        }
        let a = cov * layer.color.a;
        return vec4<f32>(masked * a, a);
    } else if layer.mode > 6.5 && layer.mode < 7.5 {
        // Mode 7 -- sprite curseur (PNG RGBA, alpha droite) echantillonne sur
        // texY (comme le mode 11 y lie son atlas). `fx` = rect de clip "Clip to
        // canvas" [x,y,w,h] en sortie 0..1 (= s_dst si actif, sinon un rect
        // englobant : sans effet). Sortie en alpha premultiplie.
        if i.pout.x < layer.fx.x || i.pout.x > layer.fx.x + layer.fx.z
            || i.pout.y < layer.fx.y || i.pout.y > layer.fx.y + layer.fx.w {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        let s = textureSample(texY, samp, i.uv);
        let ca = s.a * layer.color.a;
        return vec4<f32>(s.rgb * ca, ca);
    } else if layer.mode > 5.5 && layer.mode < 6.5 {
        // Mode 6 -- fond image (wallpaper RGBA) cover-fit, echantillonne sur
        // texY. `src` porte le rect UV cover-fit (calcule cote Rust). Opaque :
        // le fond couvre tout le cadre.
        // Fond anime : memes emplacements qu'au mode 5 (fx.z temps, fx.w mouvement,
        // mb.x aspect). fx.w = 0 lit l'image telle quelle, a l'octet pres.
        var uv = i.uv;
        var light = 0.0;
        if layer.fx.w > 0.5 {
            let size = layer.src.zw - layer.src.xy;
            let m = image_motion((i.uv - layer.src.xy) / size - vec2<f32>(0.5), layer.fx.z,
                                 layer.fx.w, layer.mb.x);
            uv = layer.src.xy + (m.xy + vec2<f32>(0.5)) * size;
            light = m.z;
        }
        let bg_a = quad_round_alpha(i.local, layer.quad_px, layer.radius_px);
        return vec4<f32>(lighten(textureSample(texY, samp, uv).rgb, light) * bg_a, bg_a); // premultiplie
    } else if layer.mode > 7.5 && layer.mode < 8.5 {
        // Mode 8 -- ecran tilte (rotation 3D des zoom regions). Le quad projete est
        // dessine dans sa BBOX (le VS ne sait tracer qu'un rect) et chaque fragment
        // remonte au (s,t) du plan par warp inverse : bilineaire sous un angle fixe, projectif
        // exact sous la camera reelle ou un appareil (dst_prev.w = 1) ; la camera reelle eclaire
        // aussi le plan (color.xy).
        //
        // PAS de test de clip sur `dst_prev` : en mode 8 `dst_prev.xy` porte
        // `plane_px`, la taille du plan en PIXELS (~1600), la ou `i.pout` vit dans
        // [0,1]. Un clip la-dessus serait vrai partout et n'afficherait rien.
        let r = quad_inverse(
            i.local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.dst_prev.w,
        );
        if r.z < 0.5 {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0); // hors du quad projete
        }
        // La coupe source s'applique ICI : `r` est une position DANS le plan (0..1),
        // pas une coordonnee de texture. Echantillonner `r` directement ignorerait le
        // crop utilisateur et le zoom.
        let uv = vec2<f32>(
            mix(layer.src.x, layer.src.z, clamp(r.x, 0.0, 1.0)),
            mix(layer.src.y, layer.src.w, clamp(r.y, 0.0, 1.0)),
        );
        // Coins arrondis DANS LE REPERE DU PLAN : le rayon reste constant le long du
        // bord, la ou un arrondi calcule dans la bbox s'etirerait avec la perspective.
        // Inconditionnel, rayon 0 compris -- `sd_round_rect` degenere en SDF de
        // rectangle et le feather de 1,5 px subsiste, ce qui fait lire une arete
        // inclinee COMME une arete plutot que comme un escalier.
        // dst_prev.z = 1 : ecran sous le chrome de fenetre, coins HAUTS carres et rognes par
        // l'arc du cadre (`sd_screen_under_bar`, `color.z` = la remontee, px du plan).
        let plane_px = layer.dst_prev.xy;
        let p = vec2<f32>(r.x, r.y) * plane_px - plane_px * 0.5;
        let rad = max(layer.radius_px, 0.0);
        // Une branche et non un `select`, qui evaluerait les DEUX distances (trois SDF par pixel).
        var d: f32;
        if layer.dst_prev.z > 0.5 {
            d = sd_screen_under_bar(p, plane_px * 0.5, rad, layer.color.z);
        } else {
            d = sd_round_rect(p, plane_px * 0.5, rad);
        }
        // Slot d'un layout en bloc (`color.w` = rayon de ses coins, px ; 0 ailleurs, sans effet) :
        // `dst` EST le slot, dont le rect arrondi rogne le plan (`ScreenMask`, cf. HLSL).
        let tilt_a = (1.0 - smoothstep(0.0, 1.5, d))
            * slot_alpha(i.local, layer.quad_px, layer.color.w);
        // Profondeur de champ (cf. HLSL) : net sous un demi-texel de flou, l'echantillon
        // d'avant a l'octet ; au-dela, fondu vers la pyramide demi-resolution liee en binding 6,
        // au niveau `log2(coc) - 1`, plafonne. LOD explicite : pas de derivees dans cette branche
        // (`tilted_sample`).
        let rs = clamp(vec2<f32>(r.x, r.y), vec2<f32>(0.0), vec2<f32>(1.0));
        let z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;
        let coc = layer.mb.w * abs(z - layer.mb.z);
        var tilt_rgb = tilted_sample(uv, coc);
        // Flou de mouvement, celui du mode 0 (cf. HLSL) : l'UV que CE pixel montrait a la frame
        // precedente, par le meme warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis
        // `taps` echantillons de celui-la a celui-ci, raccourcis de la force. Borne a une frame. Le
        // mouvement se mesure entre les deux points NON bornes (cf. HLSL).
        let trail_taps = i32(layer.trail_mb.x);
        if trail_taps > 1 && layer.trail_mb.y > 0.001 {
            let rp = quad_inverse(
                i.local, layer.trail_a.xy, layer.trail_a.zw, layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w,
            );
            let duv = (r.xy - rp.xy) * (layer.src.zw - layer.src.xy) * clamp(layer.trail_mb.y, 0.0, 1.0);
            // Sans antecedent sur le plan d'avant, pas de point d'avant : l'echantillon reste net.
            if rp.z > -0.5 && dot(duv, duv) >= 1e-9 {
                var acc = vec3<f32>(0.0);
                let step = 1.0 / f32(trail_taps - 1);
                for (var k: i32 = 0; k < 16; k = k + 1) {
                    if k >= trail_taps { break; }
                    acc = acc + tilted_sample(uv - duv * (1.0 - f32(k) * step), coc);
                }
                tilt_rgb = acc / f32(trail_taps);
            }
        }
        if layer.dst_prev.w > 0.5 {
            // La lampe de la camera reelle : le cote proche un peu plus clair.
            let shade = 1.0 + layer.color.x * (rs.x - 0.5) + layer.color.y * (rs.y - 0.5);
            tilt_rgb = clamp(tilt_rgb * shade, vec3<f32>(0.0), vec3<f32>(1.0));
        }
        // L'alpha est cette couverture, pas `color.a` : les draws du mode 8 laissent
        // `color` a zero, donc s'en servir rendrait un plan totalement transparent.
        return vec4<f32>(tilt_rgb * tilt_a, tilt_a);
    } else if layer.mode > 11.5 && layer.mode < 12.5 {
        // Mode 12 -- ombre du quad projete. La penombre suit le QUADRILATERE, pas son
        // rect englobant : un rect droit derriere un ecran incline se lit comme une
        // seconde surface, pas comme son ombre.
        //
        // `fx`/`src_prev` portent les COINS (en px locaux a la bbox, comme `i.local`),
        // et le spread vit dans `mb.y` -- pas dans `fx.x` comme au mode 2.
        let tl = layer.fx.xy;
        let tr = layer.fx.zw;
        let br = layer.src_prev.xy;
        let bl = layer.src_prev.zw;
        // Coins arrondis du meme rayon que le plan : une ombre a coins vifs derriere un
        // ecran arrondi depasse en pointe a chaque coin, d'autant plus que le rayon monte.
        let r = max(layer.radius_px, 0.0);
        let v0 = inset_corner(bl, tl, tr, r);
        let v1 = inset_corner(tl, tr, br, r);
        let v2 = inset_corner(tr, br, bl, r);
        let v3 = inset_corner(br, bl, tl, r);
        var d = sd_convex_quad(i.local, v0, v1, v2, v3) - r;
        // Slot d'un layout en bloc (`dst_prev` = le slot en px locaux, `mb.w` = son rayon ; nul
        // ailleurs) : l'ombre est celle de ce qu'on voit, le plan rogne par le slot (cf. HLSL).
        if layer.dst_prev.z > layer.dst_prev.x {
            let h = (layer.dst_prev.zw - layer.dst_prev.xy) * 0.5;
            d = max(d, sd_round_rect(i.local - layer.dst_prev.xy - h, h, layer.mb.w));
        }
        let spread = max(layer.mb.y, 1e-3);
        let a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
        return vec4<f32>(layer.color.rgb * a, a);
    } else if layer.mode > 12.5 && layer.mode < 13.5 {
        // Mode 13 -- sprite de curseur POSE sur l'ecran incline : ses quatre coins
        // ont traverse la meme projection que la video, et le fragment remonte a sa
        // position dans le sprite par le meme warp inverse que le mode 8.
        //
        // Le rect de clip « Clip to canvas » est ici dans `dst_prev` (en sortie
        // 0..1, [x,y,w,h]) et NON dans `fx` comme au mode 7 : `fx` porte les coins.
        if i.pout.x < layer.dst_prev.x || i.pout.x > layer.dst_prev.x + layer.dst_prev.z
            || i.pout.y < layer.dst_prev.y || i.pout.y > layer.dst_prev.y + layer.dst_prev.w {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        // mb.x = 1 : warp projectif (camera reelle).
        let r = quad_inverse(
            i.local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.x,
        );
        if r.z < 0.5 {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        // Sprite RGBA a alpha DROITE sur texY (comme le mode 7 y lie le sien) :
        // on premultiplie ici.
        let s = textureSample(texY, samp, clamp(vec2<f32>(r.x, r.y), vec2<f32>(0.0), vec2<f32>(1.0)));
        let ca = s.a * layer.color.a;
        return vec4<f32>(s.rgb * ca, ca);
    } else if layer.mode > 13.5 && layer.mode < 14.5 {
        // Mode 14 -- CADRE DE FENETRE autour de l'ecran (barre de titre, trois pastilles,
        // filet), dessine SOUS lui. Meme warp que le mode 8 : le cadre est le quad de l'ecran
        // prolonge, il penche donc avec lui ; a plat le quad est un rect et le warp l'identite.
        // src.x = 1 : warp projectif (camera reelle).
        let r = quad_inverse(
            i.local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.src.x,
        );
        if r.z < 0.5 {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0); // hors du cadre projete
        }
        let plane_px = layer.dst_prev.xy;
        let bar = layer.dst_prev.z;
        let line_w = layer.dst_prev.w;
        let q = vec2<f32>(r.x, r.y) * plane_px; // px du plan depuis le coin haut-gauche
        let p = q - plane_px * 0.5;
        // Le MEME rayon aux quatre coins : le metrage est arrondi partout, donc le cadre aussi
        // (cf. le commentaire du HLSL, et `plan_frame` section « Le rayon des coins »).
        let rad = max(layer.radius_px, 0.0);
        let d = sd_round_rect(p, plane_px * 0.5, rad);
        let cov = 1.0 - smoothstep(0.0, 1.5, d);
        // Filet interieur le long du contour, et separation entre la barre et le contenu.
        let stroke = max(band_cov(-d - line_w * 0.5, line_w * 0.5),
                         band_cov(q.y - (bar - line_w * 0.5), line_w * 0.5));
        var frame_rgb = mix(layer.color.rgb, layer.mb.rgb, stroke * layer.mb.a);
        // Pastilles : proportions d'une barre de 28 px (rayon 6, pas de 20). Deroulees a la
        // main, comme `sd_convex_quad` : pas de tableau local indexe.
        // Leur bloc est repousse du coin d'au moins le rayon PLUS leur propre rayon et une marge :
        // sans ca, l'arrondi mordait la premiere des que Roundness montait.
        let dr = bar * 0.214;
        let dx = bar * 0.714;
        let x0 = max(dx, rad + dr + bar * 0.18);
        frame_rgb = mix(frame_rgb, vec3<f32>(1.000, 0.373, 0.341), disc_cov(q, vec2<f32>(x0, bar * 0.5), dr));
        frame_rgb = mix(frame_rgb, vec3<f32>(0.996, 0.737, 0.180), disc_cov(q, vec2<f32>(x0 + dx, bar * 0.5), dr));
        frame_rgb = mix(frame_rgb, vec3<f32>(0.157, 0.784, 0.251), disc_cov(q, vec2<f32>(x0 + 2.0 * dx, bar * 0.5), dr));
        let fa = cov * layer.color.a;
        return vec4<f32>(frame_rgb * fa, fa); // premultiplie
    } else if layer.mode > 14.5 && layer.mode < 17.5 {
        // Modes 15 a 17 -- les modeles 3D, que seul le pipeline `LAYER_MODELS` compile (cf. le
        // haut du fichier). Le pipeline plat ne les recoit jamais ; s'il en recevait un, il ne
        // dessinerait rien plutot qu'une ombre faite de leurs emplacements.
        if !LAYER_MODELS {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        if layer.mode < 15.5 {
            // Mode 15 -- curseur modelise (`cursor_model`). Clip « Clip to canvas » dans
            // `dst_prev`, comme au mode 13.
            if i.pout.x < layer.dst_prev.x || i.pout.x > layer.dst_prev.x + layer.dst_prev.z
                || i.pout.y < layer.dst_prev.y || i.pout.y > layer.dst_prev.y + layer.dst_prev.w {
                return vec4<f32>(0.0, 0.0, 0.0, 0.0);
            }
            return cursor_model(i.local);
        }
        if layer.mode < 16.5 {
            // Mode 16 -- impact du clic sous le curseur modelise (`cursor_impact`).
            return cursor_impact(i.local);
        }
        // Mode 17 -- cadre d'appareil modelise (`device_frame`).
        return device_frame(i.local);
    } else if layer.mode > 18.5 {
        // Mode 19 -- verre a plat de Glass Lens (`cursor_glass`) : un modele, que seul le
        // pipeline `LAYER_MODELS` compile, comme les modes 15 a 17.
        if !LAYER_MODELS {
            return vec4<f32>(0.0, 0.0, 0.0, 0.0);
        }
        return cursor_glass(i.local, i.pout);
    } else if layer.mode > 17.5 {
        // Mode 18 -- ecran cadre floute en bloc (`screen_trail`).
        return screen_trail(i.pout);
    } else {
        // Mode 2 — ombre portée (SDF d'un quad arrondi élargi de `fx.x`).
        let spread = layer.fx.x;
        let halfsz = layer.quad_px * 0.5 - vec2<f32>(spread);
        let p = i.local - layer.quad_px * 0.5;
        let d = sd_round_rect(p, halfsz, layer.radius_px);
        let a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
        return vec4<f32>(layer.color.rgb * a, a);
    }

    // Le mode 5 range la POSITION de son premier stop dans color.a (`gradient_layer`), pas une
    // opacite : un degrade est opaque, comme dans le HLSL et le MSL, qui ne lisent pas color.a.
    // Le lire ici rendait transparent tout degrade dont le premier stop est a 0.
    var base_alpha = layer.color.a;
    if layer.mode > 4.5 && layer.mode < 5.5 {
        base_alpha = 1.0;
    }
    alpha = base_alpha * alpha_mask;

    if layer.radius_px > 0.0 {
        // Feather ~1.5 px sur le bord du quad — parité exacte avec le HLSL
        // (`smoothstep(0.0, 1.5, d)`). Le shader HLSL inclut `quad_px` en px de
        // SORTIE ; on reproduit la même chose ici.
        // mb.w = 1 : ecran sous le chrome de fenetre, coins HAUTS carres et rognes par l'arc du
        // cadre (`sd_screen_under_bar`, `mb.z` = la remontee du contour interieur, px).
        let halfsz = layer.quad_px * 0.5;
        let p = i.local - layer.quad_px * 0.5;
        // Une branche et non un `select` : celui-ci evaluait les DEUX distances, soit trois SDF
        // par pixel de l'ecran au lieu d'une -- 0,6 ms par frame 1080p sur une Radeon 610M.
        var d: f32;
        if layer.mb.w > 0.5 {
            d = sd_screen_under_bar(p, halfsz, layer.radius_px, layer.mb.z);
        } else {
            d = sd_round_rect(p, halfsz, layer.radius_px);
        }
        alpha *= 1.0 - smoothstep(0.0, 1.5, d);
    }

    return vec4<f32>(rgb * alpha, alpha); // alpha prémultiplié
}