Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
// Compositeur — un draw par calque (quad). NV12->RGB maison (E1), coins arrondis SDF (E2).
// Port MSL strict de `crates/compositor/src/shaders.hlsl`. Le shape du constant buffer,
// les noms d'entry points, et les contrats d'interface doivent rester identiques d'un
// backend à l'autre — c'est ce qui permet à `compositor.rs::new_inner` (Windows) et à
// `compositor_macos.rs::new_sized` (macOS) de partager le même ensemble d'effets.
//
// HLSL → MSL différences notables :
// - `cbuffer X : register(b0)` → `constant X & [[buffer(0)]]`
// - `Texture2D<float> T : register(tN)` → `texture2d<float, access::sample> T [[texture(N)]]`
// - `SamplerState S : register(sN)` → `sampler S [[sampler(N)]]`
// - `SV_VertexID` → `[[vertex_id]]`, `SV_Position` (sortie) → `[[position]]`
// - `TEXCOORDn` → champ libre de struct (MSL n'a pas de qualificateur ; on les
// regroupe dans des structs `VSOut`/`FSOut` comme en HLSL)
// - `T.Sample(samp, uv)` → `T.sample(samp, uv)` (sampler sur l'instance, pas en arg)
// - `SV_Target` (sortie) → `[[color(0)]]` (ou aucun qualificateur — Metal utilise
// l'attachement 0 par défaut, qui est ce qu'on veut pour ces 9 entry points)
// - `saturate(x)` → `clamp(x, 0.0, 1.0)` (Metal 2.0 ; `saturate` existe en 2.4+ mais
// on reste portable)
// - `[unroll]` → `[[unroll]]` (sur le `for`)
//
// DIFFÉRENCE STRUCTURELLE, et c'est la seule qui n'est pas cosmétique : HLSL déclare
// `cbuffer`, `Texture2D` et `SamplerState` en portée GLOBALE, MSL ne le permet pas.
// « 'texture' attribute only applies to parameters » et « program scope variable must
// reside in constant address space » : les ressources doivent être des PARAMÈTRES de
// chaque entry point, et les helpers qui les lisent doivent les recevoir en argument.
// Un port ligne-pour-ligne des globales HLSL ne compile donc pas du tout — d'où les
// signatures ci-dessous, qui sont la seule liberté prise avec le fichier d'origine.
// (Les `constexpr sampler` restent légaux en portée globale : ils sont immuables et
// résolus à la compilation.)
//
// IMPORTANT : ce fichier est inclus via `include_str!("shaders.metal")` côté Rust et
// compilé à l'exécution via `MTLDevice.makeLibrary(source:options:)`. Le test
// `compositor_macos::tests::every_shader_entry_point_compiles` le compile sur le device
// système au `cargo test`, pour qu'une faute de syntaxe MSL ne se découvre pas à
// l'ouverture de l'éditeur chez un utilisateur.
//
// Il est compilé DEUX fois (`compositor_macos.rs::new_sized`) : tel quel pour tous les calques,
// et avec `LAYER_MODELS` défini pour les seuls modèles 3D (modes 15 à 17,
// `LayerCB::needs_models`). Un shader alloue à chaque draw les registres de sa branche la plus
// lourde, et ce sont ces modèles ray-tracés : le même `ps_main` les portait pour le fond,
// l'ombre et la vidéo, qui couvrent toute la sortie (cf. le haut de `shaders.hlsl`).
#include <metal_stdlib>
using namespace metal;
// =================================================================================
// Constant buffer — symétrique de `cbuffer Layer : register(b0)` côté HLSL.
// =================================================================================
//
// Le moteur côté CPU upload ce buffer via `setVertexBytes` (vertex stage) et
// `setFragmentBytes` (fragment stage) avant chaque draw — la copie est de 176 octets,
// ce qui est sous le seuil d'alignement 4K de Metal pour le mode « immediate ».
struct Layer
{
float4 dst; // x,y,w,h dans l'espace sortie 0..1 (origine haut-gauche)
float4 src; // u0,v0,u1,v1 dans l'espace source 0..1 ; modes 15 et 17 : décalage px du rayon, P, U
float2 quad_px; // taille du quad en pixels (pour les SDF)
float radius_px; // rayon des coins arrondis en px (0 = aucun) ; mode 17 : rayon des coins hauts du corps (unités du modèle)
float mode; // 0 = vidéo NV12, 1 = couleur pleine, 2 = ombre portée, ..., 15 = curseur 3D, 16 = impact du clic, 17 = appareil modelé, 18 = écran cadré flouté en bloc, 19 = curseur de verre à plat
float4 color; // couleur pleine / teinte (ombre : rgb + opacité dans a) ; mode 15 : coin du sprite, texel, opacité ; mode 17 : .r = l'appareil (1 portable, 2 téléphone, 3 moniteur), .g = thème sombre, .b = rayon des coins bas du corps, .a = opacité
float4 fx; // fx.x = spread ombre (px), fx.y,fx.z libres ; mode 15 : rotation du plan (rad), tangage ; mode 17 : rotation du plan (rad), épaisseur
float4 src_prev; // src à la frame précédente (flou de mouvement par vélocité) ; mode 15 : hotspot, lacet ; mode 17 : marges du corps (unités du modèle)
float4 dst_prev; // dst à la frame précédente ; modes 13 et 15 : rect de clip ; mode 17 : angle du socle, rayon et recouvrement de l'ouverture, pénombre de l'ombre
float4 mb; // mb.x = nombre de taps de motion blur (1 = désactivé) ; modes 15 et 17 : demi-taille du plan, translation ; mode 18 : .z = 1 si le plan est incliné, .w = 1 si son warp est projectif
float4 trail_a; // mode 8 : coins TL, TR du plan à la frame précédente (px locaux, comme fx) ; mode 18 incliné : en fractions de sortie
float4 trail_b; // mode 8 : coins BR, BL du plan à la frame précédente (comme src_prev) ; mode 18 incliné : en fractions de sortie
float4 trail_mb; // mode 8 : x = taps, y = force du flou de mouvement (ceux du mode 0) ; 0 ailleurs
};
// Mode 15 (curseur modélisé) : le détail des emplacements est dans `frame_geometry.rs`, en tête
// de la section « Curseur modélisé » (`cursor_model_cb`). Mode 17 (appareil modelé) : en tête de
// « Appareils modelés » (`device_frame_cb`), et résumé au-dessus de `device_frame` dans le HLSL.
// `layer` est passé en `constant Layer& [[buffer(0)]]` à chaque entry point qui le lit
// (cf. la note « DIFFÉRENCE STRUCTURELLE » en tête de fichier). Côté Rust, il est lié par
// `set_vertex_bytes(0, …)` ET `set_fragment_bytes(0, …)` : `vs_main` le lit autant que
// `ps_main`.
// =================================================================================
// Vertex stage : quads à partir de `SV_VertexID`, fullscreen triangle pour fs pass.
// =================================================================================
struct VSOut
{
float4 pos [[position]];
float2 uv [[user(TEXCOORD0)]]; // coords d'échantillonnage source
float2 local [[user(TEXCOORD1)]]; // coords pixel dans le quad (pour SDF)
float2 pout [[user(TEXCOORD2)]]; // position 0..1 sortie (pour la vélocité par pixel)
};
vertex VSOut vs_main(uint vid [[vertex_id]],
constant Layer &layer [[buffer(0)]])
{
float2 c = float2(vid & 1, (vid >> 1) & 1); // strip: (0,0)(1,0)(0,1)(1,1)
float2 p = layer.dst.xy + c * layer.dst.zw; // 0..1 sortie
float2 ndc = float2(p.x * 2.0 - 1.0, 1.0 - p.y * 2.0);
VSOut o;
o.pos = float4(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;
}
// =================================================================================
// Textures et samplers.
// =================================================================================
// `mip_filter::linear` n'est PAS décoratif : sans lui MSL retombe sur `mip_filter::none`,
// et `sample(..., level(lod))` rend le mip 0 quel que soit `lod`. Le masque « flou »
// d'annotation (mode 10) échantillonne la pyramide de mips de la copie du RT — sans ce
// filtre il ne floute rien, alors que la mosaïque, qui demande explicitement `level(0)`,
// marche par accident. Équivalent de `D3D11_FILTER_MIN_MAG_MIP_LINEAR` côté Windows.
constexpr sampler samp(filter::linear, mip_filter::linear, address::clamp_to_edge);
constexpr sampler sampNV(filter::linear, address::clamp_to_edge);
// Plafond de la profondeur de champ du mode 8, en niveau de la pyramide demi-résolution.
// Même valeur que `DOF_MAX_LOD` du HLSL.
constant float DOF_MAX_LOD = 1.5;
// Slots de texture, tenus par les paramètres des entry points :
// ps_main : 0 = texY (Y, R8), 1 = texUV (CbCr, RG8), 2 = texImg (RGBA), 3 = texMask (R8),
// 4 = texSdf (champ du sprite de curseur, R16F, mode 15),
// 5 = texDof (pyramide de profondeur de champ, RGBA, modes 8 et 18)
// ps_fs_* : 0 = rgbTex (RGBA)
// =================================================================================
// Helpers : conversions couleur, primitives SDF.
// =================================================================================
// BT.709 limited -> RGB (§7 E1), matrice en dur, range mesuré en S1.
inline float3 yuv709_limited(float y, float2 cbcr)
{
float Yf = (y * 255.0 - 16.0) / 219.0;
float Cb = (cbcr.x * 255.0 - 128.0) / 224.0;
float Cr = (cbcr.y * 255.0 - 128.0) / 224.0;
float3 rgb;
rgb.r = Yf + 1.5748 * Cr;
rgb.g = Yf - 0.1873 * Cb - 0.4681 * Cr;
rgb.b = Yf + 1.8556 * Cb;
return clamp(rgb, 0.0, 1.0);
}
// BT.709 pleine plage -> RGB : Y sur 0..255, CbCr centrés sur 128 et étalés sur 255.
inline float3 yuv709_full(float y, float2 cbcr)
{
float Cb = cbcr.x - 128.0 / 255.0;
float Cr = cbcr.y - 128.0 / 255.0;
float3 rgb;
rgb.r = y + 1.5748 * Cr;
rgb.g = y - 0.1873 * Cb - 0.4681 * Cr;
rgb.b = y + 1.8556 * Cb;
return clamp(rgb, 0.0, 1.0);
}
// BT.601 / BT.2020 -> RGB. `m` : coefficients Cr->R, Cb->G, Cr->G, Cb->B. BT.709 garde ses
// deux fonctions à constantes littérales, pour rendre ses frames à l'octet près comme avant.
// `ten_bit` : un échantillon P010 lu en `R16Unorm` vaut code10 * 64 / 65535, pas code8 / 255 ;
// on revient au code 10 bits pour appliquer ses bornes (64..940, chroma 512, pleine 0..1023).
inline float3 yuv_matrix(float y, float2 cbcr, float4 m, bool full, bool ten_bit)
{
float Yf, Cb, Cr;
if (ten_bit) {
float code = 65535.0 / 64.0;
Yf = full ? y * code / 1023.0 : (y * code - 64.0) / 876.0;
Cb = full ? (cbcr.x * code - 512.0) / 1023.0 : (cbcr.x * code - 512.0) / 896.0;
Cr = full ? (cbcr.y * code - 512.0) / 1023.0 : (cbcr.y * code - 512.0) / 896.0;
} else {
Yf = full ? y : (y * 255.0 - 16.0) / 219.0;
Cb = full ? cbcr.x - 128.0 / 255.0 : (cbcr.x * 255.0 - 128.0) / 224.0;
Cr = full ? cbcr.y - 128.0 / 255.0 : (cbcr.y * 255.0 - 128.0) / 224.0;
}
float3 rgb;
rgb.r = Yf + m.x * Cr;
rgb.g = Yf - m.y * Cb - m.z * Cr;
rgb.b = Yf + m.w * Cb;
return clamp(rgb, 0.0, 1.0);
}
// `texture2d<float>::sample` rend TOUJOURS un `float4` en MSL, là où le HLSL
// `Texture2D<float>` rend un scalaire : d'où les `.r` / `.rg` que le port d'origine
// n'avait pas (et qui ne compilaient pas).
inline float3 sample_yuv(float2 uv,
texture2d<float, access::sample> texY,
texture2d<float, access::sample> texUV)
{
float4 y = texY.sample(samp, uv);
float4 c = texUV.sample(samp, uv);
// Bleu à 1 sur la vue CbCr : pleine plage (420f, xf20).
bool full = c.b > 0.5;
// Vert ou bleu à 1 sur la vue Y : matrice BT.601 ou BT.2020 posée par `nv12_srvs` ;
// alpha à 0 sur cette vue : échantillons 10 bits.
bool ten_bit = y.a < 0.5;
if (y.g > 0.5)
return yuv_matrix(y.r, c.rg, float4(1.402, 0.344136, 0.714136, 1.772), full, ten_bit);
if (y.b > 0.5)
return yuv_matrix(y.r, c.rg, float4(1.4746, 0.164553, 0.571353, 1.8814), full, ten_bit);
return full ? yuv709_full(y.r, c.rg) : yuv709_limited(y.r, c.rg);
}
// SDF segment à bouts ronds — la primitive des flèches d'annotation.
inline float sd_segment(float2 p, float2 a, float2 b)
{
float2 pa = p - a;
float2 ba = b - a;
float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-6), 0.0, 1.0);
return length(pa - ba * h);
}
// SDF rectangle à coins arrondis (§7 E2) : <0 dedans.
//
// 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.
inline float sd_round_rect(float2 p, float2 halfsz, float r)
{
float hmin = min(halfsz.x, halfsz.y);
float2 q0 = abs(p) - halfsz;
// Hors des coins, la distance est celle du rectangle vif quel que soit l'exposant : un seul
// axe déborde de l'étendue E, qui s'y ajoute puis s'en retranche. E ne dépasse pas 1,42 r
// (n = 3) : sous 1,5 r du bord sur un axe, on rend la boîte 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, 0.0)) + min(max(q0.x, q0.y), 0.0);
}
float n = 3.0 - smoothstep(0.5, 1.0, r / hmin);
float e = min(r * 0.29289322 / (1.0 - exp2(-1.0 / n)), hmin);
float2 q = abs(p) - halfsz + e;
float2 m = max(q, 0.0);
if (m.x > 0.0 && m.y > 0.0)
{
float len = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
float2 g = pow(m / len, float2(n - 1.0));
return (len - e) / length(g);
}
return max(m.x, m.y) + min(max(q.x, q.y), 0.0) - e;
}
// L'écran sous le chrome de FENÊTRE (modes 0 et 8) : coins HAUTS carrés, rognés par l'arc du
// cadre quand le rayon dépasse la barre. Port de `sd_screen_under_bar` (HLSL), qui fait foi.
inline float sd_screen_under_bar(float2 p, float2 halfsz, float r, float lift)
{
float own = sd_round_rect(p, halfsz, (p.y < 0.0) ? 0.0 : r);
float2 up = float2(0.0, lift * 0.5);
return max(own, sd_round_rect(p + up, halfsz + up, r));
}
// Couverture du quad avec coins arrondis, pour les modes qui retournent AVANT la queue de
// `ps_main` (5 gradient, 6 image). Ils s'en passaient tant qu'ils ne servaient qu'au fond plein
// cadre, qui n'a pas de rayon ; depuis que la bulle webcam peut porter un dégradé ou une image,
// sans ça le fond déborde en carré opaque sur les coins arrondis de la bulle et mange l'ombre.
// Renvoie 1.0 quand aucun rayon n'est demandé — le fond plein cadre est donc inchangé.
inline float quad_round_alpha(float2 local, float2 quad_px, float radius_px)
{
if (radius_px <= 0.0 || quad_px.x <= 0.0 || quad_px.y <= 0.0)
{
return 1.0;
}
float2 halfsz = quad_px * 0.5;
float d = sd_round_rect(local - halfsz, halfsz, radius_px);
return 1.0 - smoothstep(0.0, 1.5, d); // même feather ~1.5px que la queue
}
// Le slot d'un layout en bloc, qui rogne le plan incliné (mode 8, cf. HLSL). Négatif : coins
// HAUTS carrés, sous la barre de la fenêtre qui le contient.
inline float slot_alpha(float2 local, float2 quad_px, float r)
{
if (r >= 0.0)
{
return quad_round_alpha(local, quad_px, r);
}
float2 halfsz = quad_px * 0.5;
float2 p = local - halfsz;
return 1.0 - smoothstep(0.0, 1.5, sd_round_rect(p, halfsz, (p.y < 0.0) ? 0.0 : -r));
}
// Intersection de deux droites données par (normale, offset) : n·x = d. Cramer.
inline float2 line_cross(float2 n1, float d1, float2 n2, float d2)
{
float det = n1.x * n2.y - n1.y * n2.x;
if (abs(det) < 1e-6) return float2(0.0, 0.0);
return float2(d1 * n2.y - d2 * n1.y, d2 * n1.x - d1 * n2.x) / det;
}
// Distance signée EXACTE à un quadrilatère convexe (<0 dedans).
inline float sd_convex_quad(float2 p, float2 v0, float2 v1, float2 v2, float2 v3)
{
float2 v0n = v0, v1n = v1, v2n = v2, v3n = v3, v4n = v0;
float inside = -1e9;
float border = 1e9;
for (int k = 0; k < 4; k++)
{
float2 a;
float2 e_next;
if (k == 0) { a = v0n; e_next = v1n; }
else if (k == 1) { a = v1n; e_next = v2n; }
else if (k == 2) { a = v2n; e_next = v3n; }
else { a = v3n; e_next = v4n; }
float2 e = e_next - a;
float2 n = float2(e.y, -e.x) / max(length(e), 1e-6);
inside = max(inside, dot(p - a, n));
border = min(border, sd_segment(p, a, e_next));
}
return (inside < 0.0) ? -border : border;
}
// (s, t, ok) du warp inverse du mode 8 pour une racine `t` donnée.
inline float3 quad_st_for_root(float t, float2 e, float2 f, float2 g, float2 h)
{
float denomX = e.x + g.x * t;
float denomY = e.y + g.y * t;
float s = (abs(denomX) > abs(denomY)) ? (h.x - f.x * t) / denomX : (h.y - f.y * t) / denomY;
float ok = (s >= -0.02 && s <= 1.02 && t >= -0.02 && t <= 1.02) ? 1.0 : 0.0;
return float3(s, t, ok);
}
// (s, t, ok) du point `P` dans le quad c00->c10->c11->c01 : le warp bilinéaire INVERSE.
// `ok` = −1 quand `P` n'a AUCUN antécédent (au-delà 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).
inline float3 quad_inverse_bilinear(float2 P, float2 c00, float2 c10, float2 c11, float2 c01)
{
float2 e = c10 - c00;
float2 f = c01 - c00;
float2 g = c00 - c10 - c01 + c11;
float2 h = P - c00;
float k2 = g.x * f.y - g.y * f.x;
float k1 = e.x * f.y - e.y * f.x + h.x * g.y - h.y * g.x;
float k0 = h.x * e.y - h.y * e.x;
if (abs(k2) < 1e-5 * abs(k1))
{
// k1 nul aussi : l'équation ne fixe plus `t`, aucun point à rendre.
if (abs(k1) < 1e-6) return float3(0.0, 0.0, -1.0);
return quad_st_for_root(-k0 / k1, e, f, g, h);
}
float disc = k1 * k1 - 4.0 * k2 * k0;
if (disc < 0.0) return float3(0.0, 0.0, -1.0);
float q = -0.5 * (k1 + (k1 >= 0.0 ? 1.0 : -1.0) * sqrt(disc));
float3 r0 = quad_st_for_root(q / k2, e, f, g, h);
float3 r1 = quad_st_for_root(abs(q) > 0.0 ? k0 / q : q / k2, e, f, g, h);
return (r0.z > 0.5) ? r0 : r1;
}
// (s, t, ok) du point `P` par l'homographie EXACTE du carré unité sur le quad (forme de Heckbert,
// relative à c00), résolue à l'envers par Cramer : la projection d'un plan par la caméra réelle.
// Cf. commentaires HLSL.
inline float3 quad_inverse_projective(float2 P, float2 c00, float2 c10, float2 c11, float2 c01)
{
float2 p1 = c10 - c00;
float2 p2 = c11 - c00;
float2 p3 = c01 - c00;
float2 d1 = p1 - p2;
float2 d2 = p3 - p2;
float2 d3 = p2 - p1 - p3;
float den = d1.x * d2.y - d2.x * d1.y;
float g = (d3.x * d2.y - d2.x * d3.y) / den;
float h = (d1.x * d3.y - d3.x * d1.y) / den;
float2 q = P - c00;
float m00 = p1.x * (1.0 + g) - g * q.x;
float m01 = p3.x * (1.0 + h) - h * q.x;
float m10 = p1.y * (1.0 + g) - g * q.y;
float m11 = p3.y * (1.0 + h) - h * q.y;
float det = m00 * m11 - m01 * m10;
float s = (q.x * m11 - m01 * q.y) / det;
float t = (m00 * q.y - q.x * m10) / det;
float ok = (s >= -0.02 && s <= 1.02 && t >= -0.02 && t <= 1.02) ? 1.0 : 0.0;
return float3(s, t, ok);
}
// Warp inverse d'un calque posé sur le plan : projectif sous la caméra réelle ou un appareil
// (`projective` = 1), bilinéaire sous un angle fixe, inchangé.
// `ok` : 1 dans le quad, 0 dehors, −1 sans antécédent (`quad_inverse_bilinear`).
inline float3 quad_inverse(float2 P, float2 c00, float2 c10, float2 c11, float2 c01, float projective)
{
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, prolongé
// hors du carré unité. Miroir du HLSL et de `TiltedQuad::point_px`.
inline float2 quad_forward(float2 st, float2 c00, float2 c10, float2 c11, float2 c01, float projective)
{
if (projective > 0.5)
{
float2 p1 = c10 - c00;
float2 p2 = c11 - c00;
float2 p3 = c01 - c00;
float2 d1 = p1 - p2;
float2 d2 = p3 - p2;
float2 d3 = p2 - p1 - p3;
float den = d1.x * d2.y - d2.x * d1.y;
float g = (d3.x * d2.y - d2.x * d3.y) / den;
float 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 échantillon de l'écran incliné (mode 8) : la vidéo nette, fondue vers la pyramide de
// profondeur de champ (texture(5)) au-delà d'un demi-texel de cercle de confusion `coc`. Sous ce
// seuil, l'échantillon net d'avant, à l'octet. Miroir de `tilted_sample` (HLSL).
inline float3 tilted_sample(float2 uv, float coc,
texture2d<float, access::sample> texY,
texture2d<float, access::sample> texUV,
texture2d<float, access::sample> texDof)
{
float3 rgb = sample_yuv(uv, texY, texUV);
if (coc > 0.5)
{
float lod = clamp(log2(coc) - 1.0, 0.0, DOF_MAX_LOD);
float3 far_rgb = texDof.sample(samp, uv, level(lod)).rgb;
rgb = mix(rgb, far_rgb, clamp((coc - 0.5) / 1.5, 0.0, 1.0));
}
return rgb;
}
// Couverture d'une pastille (disque) adoucie sur ~1.5 px, pour la barre de titre du mode 14.
inline float disc_cov(float2 p, float2 c, float r)
{
return 1.0 - smoothstep(r - 0.75, r + 0.75, length(p - c));
}
// Couverture d'un trait centré sur `x = 0`, de demi-épaisseur `half_w`, sur ~1 px.
inline float band_cov(float x, float half_w)
{
return clamp(half_w + 0.5 - abs(x), 0.0, 1.0);
}
// =================================================================================
// Pixel shader principal : un seul `ps_main` qui gère 15 modes via `layer.mode`.
// Identique à `ps_main` côté HLSL ligne pour ligne (à la syntaxe MSL près).
// =================================================================================
// Fond floute du mode "blur" webcam. Miroir de `blur_webcam_bg` cote HLSL : memes 25 taps,
// memes poids, meme rayon — les deux back-ends doivent rendre le meme pixel.
// 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.
constant float3 VOGEL_TAPS[21] = {
float3( 0.154303, 0.000000, 0.942213),
float3(-0.197070, 0.180532, 0.836464),
float3( 0.030165, -0.343712, 0.742584),
float3( 0.248394, 0.323986, 0.659241),
float3(-0.455834, -0.080631, 0.585251),
float3( 0.431806, -0.274679, 0.519566),
float3(-0.144431, 0.537274, 0.461253),
float3(-0.275445, -0.530352, 0.409484),
float3( 0.597605, 0.218244, 0.363526),
float3(-0.621708, 0.256632, 0.322726),
float3( 0.299704, -0.640451, 0.286505),
float3( 0.221474, 0.706094, 0.254349),
float3(-0.667525, -0.386844, 0.225802),
float3( 0.783083, -0.172159, 0.200460),
float3(-0.477903, 0.679768, 0.177961),
float3(-0.110407, -0.852001, 0.157988),
float3( 0.677789, 0.571241, 0.140256),
float3(-0.912091, 0.037718, 0.124514),
float3( 0.665301, -0.662063, 0.110540),
float3(-0.044511, 0.962596, 0.098133),
float3(-0.633036, -0.758588, 0.087119)
};
inline float3 blur_webcam_bg(float2 uv, float intensity, float2 qpx, float2 local_px,
texture2d<float, access::sample> texY,
texture2d<float, access::sample> texUV)
{
float max_r_px = max(intensity, 0.0) * 22.0 + 1.5;
float2 step = max_r_px / max(qpx, float2(1.0));
float noise = fract(52.9829189 * fract(0.06711056 * local_px.x + 0.00583715 * local_px.y));
float angle = noise * 6.2831853;
float s = sin(angle);
float c = cos(angle);
float3 sum = float3(0.0);
float total = 0.0;
for (int k = 0; k < 21; k++)
{
float2 p = VOGEL_TAPS[k].xy;
float w = VOGEL_TAPS[k].z;
float2 rot_p = float2(p.x * c - p.y * s, p.x * s + p.y * c);
sum += sample_yuv(saturate(uv + rot_p * step), texY, texUV) * w;
total += w;
}
return sum / max(total, 1e-4);
}
// Hash 2D -> [0,1) sans sin(). Miroir de `hash12` côté HLSL.
inline float hash12(float2 p)
{
float3 p3 = fract(float3(p.x, p.y, p.x) * 0.1031);
p3 += dot(p3, p3.yzx + 33.33);
return fract((p3.x + p3.y) * p3.z);
}
// Bruit de valeur lissé (hermite), sans texture. Miroir de `value_noise` côté HLSL.
inline float value_noise(float2 q)
{
float2 i = floor(q);
float2 f = fract(q);
float2 u = f * f * (3.0 - 2.0 * f);
float a = hash12(i);
float b = hash12(i + float2(1.0, 0.0));
float c = hash12(i + float2(0.0, 1.0));
float d = hash12(i + float2(1.0, 1.0));
return mix(mix(a, b, u.x), mix(c, d, u.x), u.y);
}
// Rampe du mode 5 à quatre nœuds. Miroir de `ramp4` côté HLSL (commentaires complets là-bas).
inline float3 ramp4(float t, float4 k0, float4 k1, float4 k2, float4 k3)
{
float3 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;
}
// Éclaircit vers le blanc (k > 0) ou assombrit vers le noir (k < 0) d'une fraction |k|.
inline float3 lighten(float3 c, float k)
{
return k > 0.0 ? c + (1.0 - c) * k : c * (1.0 + k);
}
// Les trois nappes de l'aurore. Miroir de `aurora_blobs` côté HLSL.
inline float3 aurora_blobs(float2 p, float time, float aspect)
{
const float TAU = 6.2831853;
float2 b0 = float2(0.35 * aspect * sin(TAU * time / 10.0), 0.25 * sin(TAU * time / 15.0 + 1.0));
float2 b1 = float2(0.30 * aspect * sin(TAU * time / 12.0 + 2.0), 0.22 * cos(TAU * time / 20.0));
float2 b2 = float2(0.25 * aspect * cos(TAU * time / 15.0 + 4.0), 0.28 * sin(TAU * time / 12.0 + 3.0));
return float3(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` côté HLSL (commentaires complets là-bas).
inline float3 gradient_motion(float2 gp, float2 dir, float denom, float4 k0, float4 k1,
float4 k2, float4 k3, float time, float motion, float aspect)
{
const float TAU = 6.2831853;
float u = dot(gp - 0.5, dir) / denom; // position le long de l'axe, -0.5..0.5
if (motion < 2.5)
{
// Aurore : rampe perturbée par un bruit, puis trois larges nappes gaussiennes.
float2 p = float2((gp.x - 0.5) * aspect, gp.y - 0.5);
float ph = TAU * time / 30.0;
float n = value_noise(p * 1.8 + 1.5 * float2(cos(ph), sin(ph)));
float3 g = ramp4(clamp(0.5 + u + 0.6 * (n - 0.5), 0.0, 1.0), k0, k1, k2, k3);
float3 blobs = aurora_blobs(p, time, aspect);
float3 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 à l'axe (6 s), ondulées (10 s), crêtes éclairées.
float v = dot(gp - 0.5, float2(-dir.y, dir.x)) / denom;
float 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 mêmes mouvements sur une image (mode 6). Miroir ligne pour ligne de `image_motion` côté
// HLSL (commentaires complets là-bas) : rend `q` déplacé (xy) et l'éclairage (z).
inline float3 image_motion(float2 q, float time, float motion, float aspect)
{
const float TAU = 6.2831853;
if (motion < 1.5)
{
// Dérive : zoom lent entre 8 et 22 % (20 s), panoramique dans sa marge (15 et 24 s).
float z = 1.15 + 0.07 * sin(TAU * time / 20.0);
float m = 0.375 * (1.0 - 1.0 / z);
return float3(q / z + m * float2(sin(TAU * time / 15.0), cos(TAU * time / 24.0)), 0.0);
}
if (motion < 2.5)
{
// Aurore : écoulement sous un bruit de ±3 %, éclairé par les nappes.
float2 p = float2(q.x * aspect, q.y);
float ph = TAU * time / 30.0;
float2 c = p * 1.6 + 1.5 * float2(cos(ph), sin(ph));
float2 flow = float2(value_noise(c), value_noise(c + float2(5.2, 1.3))) - 0.5;
float3 blobs = aurora_blobs(p, time, aspect);
return float3(q / 1.08 + 0.06 * flow, 0.12 * (blobs.x - blobs.y + 0.85 * blobs.z));
}
// Vagues : bandes à 135° qui ondulent l'image de ±0,85 % et éclairent leurs crêtes.
float2 d = float2(0.7071068, 0.7071068);
float u = dot(q, d) / 1.4142136;
float v = dot(q, float2(-d.y, d.x)) / 1.4142136;
float w = sin(TAU * (3.0 * u + 0.04 * sin(TAU * (1.5 * v + time / 10.0)) - time / 6.0));
return float3(q / 1.06 + 0.012 * w * d, 0.07 * w);
}
// ============ Curseur MODÉLISÉ (mode 15) ============
// Port ligne pour ligne de `cursor_model` (HLSL), dont les commentaires font foi ; seules
// différences : `layer` et les textures arrivent en paramètres (le sprite en texture(2), son
// champ R16F en texture(4), la copie de l'image composée en texture(5) pour le cristal de Prism
// Glow),
// `lerp` s'écrit `mix`, `SampleLevel` s'écrit `sample(…, level(0.0))`, un `out` s'écrit `thread &`,
// et `pow` veut un exposant du type de sa base.
// Constantes : miroir exact de `frame_geometry.rs` (MODEL_*) et de `sculpt.rs` (SCULPT_*).
constant float MODEL_BEVEL = 0.045;
constant float3 MODEL_LIGHT = float3(-0.4194, -0.5792, 0.6990);
constant float3 MODEL_FILL = float3(0.7557, 0.2519, 0.6046);
// Ambiance et diffus de l'appareil modelé (mode 17), qui garde son éclairage d'origine.
constant float MODEL_AMBIENT = 0.36;
constant float MODEL_DIFFUSE = 0.75;
constant float MODEL_RIM_INSET = 1.5;
constant float MODEL_SOFTNESS = 6.0;
constant float MODEL_SHADOW_PAD = 0.45;
constant float MODEL_SHADOW_ALPHA = 0.5;
constant float MODEL_CONTACT_RADIUS = 0.12;
constant float MODEL_CONTACT_ALPHA = 0.5;
// Taille du sprite, repère du modèle : son plus grand côté vaut 1, `radius_px` porte w/h.
inline float2 sprite_size(constant Layer &layer)
{
return float2(min(layer.radius_px, 1.0), min(1.0 / layer.radius_px, 1.0));
}
// Un texel du sprite, en unités du modèle : le champ est le sprite suréchantillonné ×4.
constant float CURSOR_SDF_UPSAMPLE = 4.0;
inline float sprite_texel(texture2d<float, access::sample> texSdf)
{
return CURSOR_SDF_UPSAMPLE / float(max(texSdf.get_width(), texSdf.get_height()));
}
// Épaisseur sous z = 0 (`SpriteShape::thick`), écrasée au clic de `color.b`.
inline float model_thick(constant Layer &layer)
{
return layer.trail_a.y * layer.color.b;
}
// Le curseur sculpté de ce dessin (`SpriteShape::sculpt`), 0 = le sprite extrudé.
inline int sculpt_id(constant Layer &layer)
{
return int(layer.trail_a.x + 0.5);
}
// ---- Curseurs sculptés ---- (repère du PROTOTYPE : hauteur 1, y vers le haut, écran en z = 0)
constant float SCULPT_SCALE = 0.85;
constant float SCULPT_HOVER = 0.05;
constant float SCULPT_VOX = 0.0625;
constant float SCULPT_ZREF_ARROW = 0.2;
constant float SCULPT_ZREF_HAND = 0.185;
constant float SCULPT_LAMP_DIST = 1.9;
constant float3 SCULPT_SCREEN = float3(0.32, 0.32, 0.32);
inline float3 s_lin(float r, float g, float b)
{
return pow(float3(r, g, b), float3(2.2));
}
inline float s_smin(float a, float b, float k)
{
float h = max(k - abs(a - b), 0.0) / k;
return min(a, b) - h * h * k * 0.25;
}
inline float2 s_opu(float2 a, float2 b)
{
return a.x < b.x ? a : b;
}
static float s_round_box(float3 p, float3 b, float r)
{
float3 q = abs(p) - b + r;
return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
}
static float s_ellipsoid(float3 p, float3 r)
{
float k0 = length(p / r);
float k1 = length(p / (r * r));
return k0 * (k0 - 1.0) / k1;
}
// Extrusion d'une distance 2D à arêtes arrondies : demi-hauteur h, rayon r.
static float s_extrude(float d2, float z, float h, float r)
{
float2 w = float2(d2 + r, abs(z) - h + r);
return min(max(w.x, w.y), 0.0) + length(max(w, 0.0)) - r;
}
inline float2 s_rot(float2 v, float a)
{
float c = cos(a), s = sin(a);
return float2(c * v.x - s * v.y, s * v.x + c * v.y);
}
static float s_star5(float2 p, float r, float rf)
{
const float2 k1 = float2(0.809016994375, -0.587785252292);
const float2 k2 = float2(-0.809016994375, -0.587785252292);
p.x = abs(p.x);
p -= 2.0 * max(dot(k1, p), 0.0) * k1;
p -= 2.0 * max(dot(k2, p), 0.0) * k2;
p.x = abs(p.x);
p.y -= r;
float2 ba = rf * float2(-k1.y, k1.x) - float2(0.0, 1.0);
float 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);
}
static float s_vesica(float2 p, float r, float d)
{
p = abs(p);
float b = sqrt(r * r - d * d);
return (p.y - b) * d > p.x * b ? length(p - float2(0.0, b)) : length(p + float2(d, 0.0)) - r;
}
// Curseurs cercles (cf. HLSL) : Studio Ink, Pop Coral, Star Sprout.
constant float2 RIM_POLY[28] = {
float2(0.0, -0.06), float2(0.0, -0.7712), float2(0.165, -0.6325), float2(0.313, -0.9318),
float2(0.4234, -0.8557), float2(0.2672, -0.5686), float2(0.456, -0.5393),
float2(-0.173, -0.5237), float2(-0.016, -0.75), float2(0.329, -0.75), float2(0.411, -0.592),
float2(0.411, -0.43), float2(0.19, -0.435), float2(-0.03, -0.44),
float2(-0.1825, -0.6215), float2(0.0037, -0.9195), float2(0.3462, -0.9195), float2(0.467, -0.6906),
float2(0.467, -0.49), float2(0.2, -0.49), float2(-0.03, -0.49),
float2(-0.1807, -0.5534), float2(0.0194, -0.872), float2(0.3485, -0.872), float2(0.47, -0.6795),
float2(0.47, -0.49), float2(0.2, -0.49), float2(-0.03, -0.49)
};
constant float4 RIM_GLOVE[27] = {
float4(0.0, -0.1077, 0.0, -0.6), float4(0.1493, -0.3279, 0.1493, -0.6),
float4(0.2863, -0.3654, 0.2863, -0.6), float4(0.4193, -0.4043, 0.4193, -0.6),
float4(-0.2, -0.478, -0.075, -0.625), float4(0.0788, -0.25, 0.0788, -0.3992),
float4(0.2188, -0.3, 0.2188, -0.4234), float4(0.3552, -0.33, 0.3552, -0.4534),
float4(-0.0845, -0.5386, 0.762, 0.648),
float4(0.0, -0.1186, 0.0, -0.65), float4(0.1614, -0.3838, 0.1614, -0.65),
float4(0.3177, -0.427, 0.3177, -0.65), float4(0.4645, -0.4848, 0.4645, -0.65),
float4(-0.215, -0.535, -0.1208, -0.6864), float4(0.0832, -0.3, 0.0832, -0.48),
float4(0.2414, -0.35, 0.2414, -0.482), float4(0.3959, -0.41, 0.3959, -0.533),
float4(-0.122, -0.5718, 0.867, 0.498),
float4(0.0, -0.122, 0.0, -0.65), float4(0.172, -0.387, 0.172, -0.65),
float4(0.3267, -0.427, 0.3267, -0.65), float4(0.4727, -0.4867, 0.4727, -0.65),
float4(-0.199, -0.483, -0.102, -0.645), float4(0.0927, -0.3, 0.0927, -0.476),
float4(0.2493, -0.35, 0.2493, -0.478), float4(0.402, -0.41, 0.402, -0.52),
float4(-0.0993, -0.5267, 0.858, 0.514)
};
constant float4 RIM_GLOVE_R[9] = {
float4(0.0552, 0.047, 0.045, 0.0375), float4(0.052, 0.0235, 0.0225, 0.0225), float4(0.0552, -0.548, 0.0525, 0.0),
float4(0.064, 0.0585, 0.0585, 0.0515), float4(0.06, 0.0197, 0.0178, 0.0172), float4(0.0648, -0.6, 0.058, 0.0),
float4(0.066, 0.0553, 0.0553, 0.0507), float4(0.063, 0.024, 0.022, 0.02), float4(0.0647, -0.555, 0.056, 0.0)
};
static float s_rim_poly(float2 p, int base)
{
float d = dot(p - RIM_POLY[base], p - RIM_POLY[base]);
float s = 1.0;
int j = base + 6;
for (int i = base; i < base + 7; i++)
{
float2 e = RIM_POLY[j] - RIM_POLY[i];
float2 w = p - RIM_POLY[i];
float2 b = w - e * saturate(dot(w, e) / dot(e, e));
d = min(d, dot(b, b));
bool c0 = p.y >= RIM_POLY[i].y;
bool c1 = p.y < RIM_POLY[j].y;
bool c2 = e.x * w.y > e.y * w.x;
if ((c0 && c1 && c2) || (!c0 && !c1 && !c2))
{
s = -s;
}
j = i;
}
return s * sqrt(d);
}
static float2 s_rim_glove(float2 p, int g, float palm)
{
float4 r0 = RIM_GLOVE_R[3 * g];
float4 r1 = RIM_GLOVE_R[3 * g + 1];
float4 r2 = RIM_GLOVE_R[3 * g + 2];
int i = 9 * g;
float 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);
float 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);
float sil = s_smin(palm, f, 0.03);
float4 v = RIM_GLOVE[i + 8];
float wedge = max(max(-dot(p - v.xy, v.zw), p.x + r2.x), r2.y - p.y);
return float2(sil, max(sil, -min(grooves, wedge)));
}
static float2 s_piece(float d, float dc, float sil, float z, float w, float zt, float h, float bump, float mat)
{
float tray = s_extrude(sil - w, z - 0.5 * (SCULPT_HOVER + zt), 0.5 * (zt - SCULPT_HOVER), 0.012);
float bead = length(float2(d - 0.5 * w, z - zt)) - 0.5 * w;
float u = saturate(-dc / 0.045);
float cushion = 0.8 * s_extrude(dc, z - zt, h + 0.022 * u * (2.0 - u) + bump, 0.75 * h);
return s_opu(float2(min(tray, bead), 5.0), float2(cushion, mat));
}
static float2 s_paper(float d, float sil, float z, float w)
{
float navy = s_extrude(sil - w, z - 0.5 * (SCULPT_HOVER + 0.15), 0.5 * (0.15 - SCULPT_HOVER), 0.006);
float sheet = s_extrude(d, z - 0.16, 0.01, 0.004);
return s_opu(float2(navy, 5.0), float2(sheet, 1.0));
}
inline float s_bump(float2 p, float2 c, float r)
{
float k = saturate(1.0 - dot(p - c, p - c) / (r * r));
return k * k;
}
static float s_dash(float2 p, float2 a, float2 b, float ra, float rb)
{
p -= a;
b -= a;
float hb = dot(b, b);
float2 q = float2(abs(dot(p, float2(b.y, -b.x))), dot(p, b)) / hb;
float2 c = float2(sqrt(hb - (ra - rb) * (ra - rb)), ra - rb);
float 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;
}
static float2 s_rimmed(float3 p, int theme, int shape)
{
bool arrow = shape == 0;
int g = theme == 4 ? 0 : (theme == 0 ? 1 : 2);
float poly = s_rim_poly(p.xy, arrow ? 0 : 7 * g + 7);
float2 body = float2(poly, poly);
float w = 0.06, zt = 0.17, h = 0.03;
float bump = 0.022 * s_bump(p.xy, float2(0.15, -0.45), 0.3);
float back = 1e9;
if (!arrow)
{
w = RIM_GLOVE_R[3 * g + 2].z;
for (int i = 0; i < 2; i++)
{
float2 q = p.xy + (i == 1 ? float2(0.03, 0.04) : float2(0.0, 0.0));
float2 v = s_rim_glove(q, g, (i == 1 ? s_rim_poly(q, 7 * g + 7) : poly) - 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, float2(0.19, -0.62), 0.28);
}
float dc = body.y;
if (arrow && theme == 0)
{
body -= 0.015;
w = 0.045;
dc = 1.0;
}
float2 r = theme == 2 ? s_paper(body.y, body.x, p.z, w)
: s_piece(body.y, dc, body.x, p.z, w, zt, h, bump, 1.0);
if (theme == 0)
{
if (arrow)
{
float band = s_extrude(abs(poly + 0.0075) - 0.0225, p.z - zt, 0.028, 0.012);
r = s_opu(r, float2(band, 2.0));
}
return r;
}
if (theme == 2)
{
float dash;
if (arrow)
{
float back = s_rim_poly(p.xy + float2(0.025, 0.05), 0) - 0.06;
r = s_opu(r, float2(s_extrude(back, p.z - 0.08, 0.03, 0.006), 2.0));
dash = min(s_dash(p.xy, float2(-0.1179, -0.1374), float2(-0.1799, -0.0443), 0.028, 0.045),
s_dash(p.xy, float2(-0.1347, -0.2493), float2(-0.248, -0.2056), 0.026, 0.042));
}
else
{
r = s_opu(r, float2(s_extrude(back, p.z - 0.08, 0.03, 0.006), 3.0));
dash = min(s_dash(p.xy, float2(0.216, -0.1695), float2(0.2593, -0.0685), 0.028, 0.042),
s_dash(p.xy, float2(0.3054, -0.2339), float2(0.3949, -0.1652), 0.0275, 0.041));
}
return s_opu(r, float2(s_extrude(dash, p.z - 0.11, 0.06, 0.006), 3.0));
}
if (!arrow)
{
float2 cq = p.xy - float2(0.1541, -0.9047);
float2 bq = abs(float2(cq.x, cq.y - 0.2066 * cq.x * cq.x)) - float2(0.214, 0.0361);
float cuff = length(max(bq, 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));
}
float2 c = arrow ? float2(0.6118, -0.8079) : float2(0.15, -0.885);
float rs = arrow ? 0.1678 : 0.128;
float zs = arrow ? 0.23 : 0.285;
float2 q = s_rot(p.xy - c, arrow ? 0.2443 : 0.0) / rs;
float star = (s_star5(q, 0.82, 0.55) - 0.18) * rs;
float leaves = min(s_vesica(s_rot(q - float2(-0.33, 1.38), -0.925), 0.4296, 0.2626),
s_vesica(s_rot(q - float2(0.53, 1.37), 0.873), 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, float2(0.0), 1.0), 3.0));
float3 e = float3(abs(q.x) - 0.25, q.y - 0.08, (p.z - zs - 0.056) / rs);
return s_opu(r, float2(s_ellipsoid(e, float3(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.)
constant float GLASS_LINE = 0.04;
constant float GLASS_RIM = 0.085;
constant float GLASS_TOP = 0.18;
constant float GLASS_DOME = 0.03;
constant float GLASS_RISE = 0.08;
constant float GLASS_IOR = 1.5;
constant float GLASS_DISPERSION = 0.012;
constant float GLASS_MAT = 10.0;
constant float GLASS_GAP_FLAT = 0.15;
constant float GLASS_SMEAR = 0.15;
constant float GLASS_LIFT = 0.02;
constant float GLASS_SHADOW = 0.6;
// x = la silhouette, y = la lentille (distances signées du prototype, négatives dedans).
static float2 s_glass2(float2 p, int shape)
{
if (shape == 0)
{
float poly = s_rim_poly(p + float2(0.0, GLASS_RIM - 0.06), 0);
return float2(poly - GLASS_RIM, poly);
}
float2 q = p + float2(0.0, GLASS_RIM - RIM_GLOVE_R[5].z);
float2 v = s_rim_glove(q, 1, s_rim_poly(q, 14) - 0.05);
return float2(v.x - GLASS_RIM, v.y);
}
// La hauteur du verre au-dessus de GLASS_TOP selon la distance `d` à la lentille, et sa pente.
inline float2 s_glass_relief(float d)
{
if (d < 0.0)
{
float u = saturate(-d / GLASS_RISE);
return float2(GLASS_DOME * u * (2.0 - u), -2.0 * GLASS_DOME * (1.0 - u) / GLASS_RISE);
}
float w = GLASS_RIM - GLASS_LINE;
float x = saturate((d - GLASS_LINE) / w);
float s = sqrt(max(1.0 - x * x, 0.05));
return float2(w * (s - 1.0), -x / s);
}
static float2 s_glass(float3 p, int shape)
{
float2 g = s_glass2(p.xy, shape);
float half_h = 0.5 * (GLASS_TOP - SCULPT_HOVER);
float slab = s_extrude(g.x, p.z - SCULPT_HOVER - half_h, half_h, min(GLASS_RIM - GLASS_LINE, half_h));
float u = saturate(-g.y / GLASS_RISE);
float dome = 0.8 * s_extrude(g.y, p.z - GLASS_TOP, 0.009 + GLASS_DOME * u * (2.0 - u), 0.008);
float 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(float2(min(slab, dome), GLASS_MAT), float2(band, 5.0));
}
// Pixel Candy : tables générées par scripts/generate-pixel-candy-voxels.mjs (cf. HLSL).
// <pixel-candy-voxels>
constant int PIX_BODY[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 };
constant int PIX_LINE[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 };
constant int PIX_HI[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 };
constant int PIX_SHADE[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 };
constant int PIX_RECT_N[3] = { 0, 17, 29 };
constant int4 PIX_GRID[2] = {
int4(11, 16, 0, 0),
int4(16, 16, 16, 0)
};
constant float2 PIX_ORIGIN[2] = {
float2(0.0, 0.0),
float2(-0.3125, 0.0)
};
constant float4 PIX_BOX[2] = {
float4(0.3438, -0.5, 0.3438, 0.5),
float4(0.1875, -0.5, 0.5, 0.5)
};
constant float4 PIX_RECT[29] = {
float4(0.0313, -0.0313, 0.0313, 0.0313),
float4(0.0625, -0.0938, 0.0625, 0.0313),
float4(0.0938, -0.1563, 0.0938, 0.0313),
float4(0.125, -0.2188, 0.125, 0.0313),
float4(0.1563, -0.2813, 0.1563, 0.0313),
float4(0.1875, -0.3438, 0.1875, 0.0313),
float4(0.2188, -0.4063, 0.2188, 0.0313),
float4(0.25, -0.4688, 0.25, 0.0313),
float4(0.2813, -0.5313, 0.2813, 0.0313),
float4(0.3125, -0.5938, 0.3125, 0.0313),
float4(0.3438, -0.6563, 0.3438, 0.0313),
float4(0.2188, -0.7188, 0.2188, 0.0313),
float4(0.0938, -0.7813, 0.0938, 0.0313),
float4(0.375, -0.8125, 0.125, 0.0625),
float4(0.0625, -0.8438, 0.0625, 0.0313),
float4(0.4375, -0.9063, 0.125, 0.0313),
float4(0.4375, -0.9688, 0.0625, 0.0313),
float4(0.0, -0.0313, 0.0625, 0.0313),
float4(0.0, -0.1563, 0.125, 0.0938),
float4(0.0625, -0.2813, 0.1875, 0.0313),
float4(0.1563, -0.3438, 0.2813, 0.0313),
float4(0.25, -0.4063, 0.375, 0.0313),
float4(0.2188, -0.4688, 0.4688, 0.0313),
float4(0.1875, -0.5625, 0.5, 0.0625),
float4(0.2188, -0.6563, 0.4688, 0.0313),
float4(0.1875, -0.7188, 0.4375, 0.0313),
float4(0.2188, -0.7813, 0.4063, 0.0313),
float4(0.1875, -0.8438, 0.375, 0.0313),
float4(0.2188, -0.9375, 0.3438, 0.0625)
};
// </pixel-candy-voxels>
inline bool s_pix_bit(int m, int c)
{
return ((m >> clamp(c, 0, 31)) & 1) == 1;
}
static bool s_pix_body(int shape, int c, int r)
{
int4 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);
}
inline int2 s_pix_cell(float2 p, int shape)
{
float2 o = PIX_ORIGIN[shape];
return int2(int(floor((p.x - o.x) / SCULPT_VOX)), int(floor((o.y - p.y) / SCULPT_VOX)));
}
static float2 s_voxels(float3 p, int shape)
{
float4 b = PIX_BOX[shape];
float2 bq = max(abs(p.xy - b.xy) - b.zw, 0.0);
float bz = max(abs(p.z - (SCULPT_HOVER + 0.07)) - 0.07, 0.0);
float d = max(SCULPT_VOX, sqrt(dot(bq, bq) + bz * bz));
float2 o = PIX_ORIGIN[shape];
int2 cell = s_pix_cell(p.xy, shape);
const float3 cube = float3(0.5 * SCULPT_VOX, 0.5 * SCULPT_VOX, 0.07);
for (int j = -1; j <= 1; j++)
{
for (int i = -1; i <= 1; i++)
{
int c = cell.x + i;
int r = cell.y + j;
if (s_pix_body(shape, c, r))
{
float3 q = float3(p.x - o.x - (float(c) + 0.5) * SCULPT_VOX, p.y - o.y + (float(r) + 0.5) * SCULPT_VOX,
p.z - SCULPT_HOVER - 0.07);
d = min(d, s_round_box(q, cube, 0.006));
}
}
}
return float2(d, 6.0);
}
static float s_pixel_outline(float2 p, int shape)
{
float d = 1e9;
for (int i = PIX_RECT_N[shape]; i < PIX_RECT_N[shape + 1]; i++)
{
float2 q = abs(p - PIX_RECT[i].xy) - PIX_RECT[i].zw;
d = min(d, length(max(q, 0.0)) + min(max(q.x, q.y), 0.0));
}
return d;
}
// ---- Prism Glow : un cristal en MAILLAGE ---- (cf. HLSL)
// prism mesh: generated by design/cursors/prism-glow/model/export_compositor.py
constant int PRISM_TRI_START[2] = { 0, 31 };
constant int PRISM_TRI_COUNT[2] = { 31, 130 };
constant int PRISM_SIL_START[2] = { 0, 25 };
constant int PRISM_SIL_COUNT[2] = { 25, 42 };
constant int PRISM_OUT_START[2] = { 67, 76 };
constant int PRISM_OUT_COUNT[2] = { 9, 34 };
constant int PRISM_BOX_START[2] = { 0, 4 };
constant int PRISM_BOX_COUNT[2] = { 4, 18 };
constant float4 PRISM_TRIS[644] = {
float4(0.252301, 0.266258, -0.042945, 11.0),
float4(-0.221166, -0.203988, 0.0, 0.01033),
float4(-0.221166, -0.203988, 0.042945, 0.045182),
float4(0.677984, -0.735077, 0.0, 0.577584),
float4(0.252301, 0.266258, -0.042945, 3.0),
float4(-0.221166, -0.203988, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.677984, -0.735077, 0.0, 0.577584),
float4(0.031135, 0.06227, -0.042945, 7.0),
float4(0.004294, 0.419785, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(-0.999948, 0.01023, 0.0, 0.577584),
float4(0.169632, 0.356442, 0.115951, 14.0),
float4(0.082669, -0.090184, -0.115951, 0.590616),
float4(-0.138497, -0.294172, -0.115951, 0.737911),
float4(0.466385, -0.505659, 0.725806, 0.973449),
float4(0.035429, 0.482055, 0.0, 14.0),
float4(0.134202, -0.125614, 0.115951, 0.000305),
float4(-0.004294, -0.419785, 0.0, 0.938689),
float4(-0.650191, 0.006652, 0.759742, 0.854994),
float4(0.031135, 0.06227, -0.042945, 9.0),
float4(0.004294, 0.419785, 0.0, 0.01033),
float4(0.004294, 0.419785, 0.042945, 0.045182),
float4(-0.999948, 0.01023, 0.0, 0.577584),
float4(0.169632, 0.356442, 0.115951, 14.0),
float4(0.159969, 0.080521, -0.045092, 0.381323),
float4(0.082669, -0.090184, -0.115951, 0.056123),
float4(0.461407, -0.510214, 0.725799, 0.973449),
float4(0.541104, 0.544325, -0.042945, 9.0),
float4(-0.288804, -0.278068, 0.0, 0.01033),
float4(-0.288804, -0.278068, 0.042945, 0.045182),
float4(0.69359, -0.72037, 0.0, 0.577584),
float4(0.329601, 0.436963, 0.070859, 14.0),
float4(0.211503, 0.107362, -0.070859, 0.545724),
float4(-0.077301, -0.170706, -0.070859, 0.064805),
float4(0.49567, -0.514808, 0.699488, 0.973449),
float4(0.268405, 0.533589, 0.081595, 14.0),
float4(0.061196, -0.096626, -0.010736, 0.000916),
float4(-0.098773, -0.177147, 0.034356, 0.046662),
float4(0.247834, 0.049458, 0.967539, 0.904662),
float4(0.541104, 0.544325, -0.042945, 7.0),
float4(-0.288804, -0.278068, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.69359, -0.72037, 0.0, 0.577584),
float4(0.199693, 0.595859, 0.0, 14.0),
float4(0.068712, -0.06227, 0.081595, 0.0),
float4(-0.030061, -0.239417, 0.115951, 0.01445),
float4(-0.504461, 0.426837, 0.750553, 0.254154),
float4(0.268405, 0.533589, 0.081595, 14.0),
float4(0.272699, 0.010736, -0.081595, 0.0),
float4(0.061196, -0.096626, -0.010736, 0.025193),
float4(0.283244, 0.073137, 0.956255, 0.527108),
float4(0.035429, 0.482055, 0.0, 14.0),
float4(0.0, 0.258742, 0.0, 0.0),
float4(0.134202, -0.125614, 0.115951, 0.473533),
float4(-0.653777, 0.0, 0.756687, 0.964691),
float4(0.359663, 0.559356, 0.0, 14.0),
float4(0.181442, -0.015031, 0.0, 0.006043),
float4(-0.091258, -0.025767, 0.081595, 0.076188),
float4(0.076465, 0.923048, 0.37701, 0.964691),
float4(0.035429, 0.482055, -0.042945, 3.0),
float4(0.0, 0.258742, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(-1.0, 0.0, 0.0, 0.577584),
float4(0.035429, 0.482055, -0.042945, 11.0),
float4(0.0, 0.258742, 0.0, 0.01033),
float4(0.0, 0.258742, 0.042945, 0.045182),
float4(-1.0, 0.0, 0.0, 0.577584),
float4(0.035429, 0.740798, -0.042945, 7.0),
float4(0.164264, -0.144939, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.661622, 0.749838, 0.0, 0.577584),
float4(0.035429, 0.740798, 0.0, 14.0),
float4(0.164264, -0.144939, 0.0, 0.0),
float4(0.134202, -0.384356, 0.115951, 0.010956),
float4(0.332572, 0.376915, 0.864483, 0.215854),
float4(0.035429, 0.740798, -0.042945, 11.0),
float4(0.164264, -0.144939, 0.0, 0.01033),
float4(0.164264, -0.144939, 0.042945, 0.045182),
float4(0.661622, 0.749838, 0.0, 0.577584),
float4(0.199693, 0.595859, -0.042945, 7.0),
float4(0.105215, 0.22546, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(-0.906183, 0.422886, 0.0, 0.577584),
float4(0.199693, 0.595859, 0.0, 14.0),
float4(0.105215, 0.22546, 0.0, 0.0),
float4(0.068712, -0.06227, 0.081595, 0.015991),
float4(-0.613882, 0.286478, 0.735581, 0.473533),
float4(0.199693, 0.595859, -0.042945, 11.0),
float4(0.105215, 0.22546, 0.0, 0.01033),
float4(0.105215, 0.22546, 0.042945, 0.045182),
float4(-0.906183, 0.422886, 0.0, 0.577584),
float4(0.304908, 0.821319, 0.0, 14.0),
float4(0.128834, -0.067638, 0.0, 0.0),
float4(-0.036503, -0.28773, 0.081595, 0.254154),
float4(0.133686, 0.254641, 0.957751, 0.973449),
float4(0.304908, 0.821319, -0.042945, 7.0),
float4(0.128834, -0.067638, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.464834, 0.885398, 0.0, 0.577584),
float4(0.433742, 0.753681, 0.0, 14.0),
float4(-0.07408, -0.194325, 0.0, 0.0),
float4(-0.165337, -0.220092, 0.081595, 0.964691),
float4(0.683362, -0.260508, 0.682021, 0.964691),
float4(0.433742, 0.753681, -0.042945, 11.0),
float4(-0.07408, -0.194325, 0.0, 0.01033),
float4(-0.07408, -0.194325, 0.042945, 0.045182),
float4(0.934406, -0.35621, 0.0, 0.577584),
float4(0.304908, 0.821319, -0.042945, 11.0),
float4(0.128834, -0.067638, 0.0, 0.01033),
float4(0.128834, -0.067638, 0.042945, 0.045182),
float4(0.464834, 0.885398, 0.0, 0.577584),
float4(0.433742, 0.753681, -0.042945, 7.0),
float4(-0.07408, -0.194325, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.934406, -0.35621, 0.0, 0.577584),
float4(0.359663, 0.559356, -0.042945, 7.0),
float4(0.181442, -0.015031, 0.042945, 0.01033),
float4(0.0, 0.0, 0.042945, 0.045182),
float4(0.082557, 0.996586, 0.0, 0.577584),
float4(0.359663, 0.559356, -0.042945, 11.0),
float4(0.181442, -0.015031, 0.0, 0.01033),
float4(0.181442, -0.015031, 0.042945, 0.045182),
float4(0.082557, 0.996586, 0.0, 0.577584),
float4(0.044345, 0.043263, -0.043263, 11.0),
float4(-0.043263, -0.005408, 0.0, 0.01033),
float4(-0.043263, -0.005408, 0.043263, 0.045182),
float4(0.124035, -0.992278, 0.0, 0.577584),
float4(0.044345, 0.043263, -0.043263, 7.0),
float4(-0.043263, -0.005408, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.124035, -0.992278, 0.0, 0.577584),
float4(0.001082, 0.037855, -0.043263, 7.0),
float4(-0.044345, 0.040019, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.669964, -0.742393, 0.0, 0.577584),
float4(0.044345, 0.043263, 0.0, 10.0),
float4(-0.043263, -0.005408, 0.0, 0.000305),
float4(-0.040019, 0.030284, 0.049753, 0.964691),
float4(0.101434, -0.811469, 0.575525, 0.973449),
float4(0.004326, 0.073548, 0.049753, 14.0),
float4(-0.003245, -0.035692, -0.049753, 0.0),
float4(-0.04759, 0.004326, -0.049753, 0.955978),
float4(-0.580475, -0.643229, 0.499304, 0.896269),
float4(0.001082, 0.037855, -0.043263, 11.0),
float4(-0.044345, 0.040019, 0.0, 0.01033),
float4(-0.044345, 0.040019, 0.043263, 0.045182),
float4(-0.669964, -0.742393, 0.0, 0.577584),
float4(-0.031366, 0.229295, 0.058405, 14.0),
float4(0.035692, -0.155748, -0.008653, 0.000305),
float4(-0.011897, -0.151422, -0.058405, 0.955978),
float4(-0.716533, -0.20131, 0.667874, 0.904662),
float4(-0.043263, 0.077874, -0.043263, 7.0),
float4(-0.001082, 0.154666, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.999976, -0.006993, 0.0, 0.577584),
float4(-0.031366, 0.229295, 0.058405, 14.0),
float4(0.089771, -0.137361, -0.02055, 0.445197),
float4(0.035692, -0.155748, -0.008653, 0.973449),
float4(0.216369, -0.004654, 0.976301, 0.973449),
float4(-0.031366, 0.229295, 0.058405, 14.0),
float4(-0.011897, -0.151422, -0.058405, 0.000305),
float4(-0.012979, 0.003245, -0.058405, 0.955978),
float4(-0.976245, -0.006827, 0.216564, 0.904662),
float4(-0.043263, 0.077874, -0.043263, 9.0),
float4(-0.001082, 0.154666, 0.0, 0.01033),
float4(-0.001082, 0.154666, 0.043263, 0.045182),
float4(-0.999976, -0.006993, 0.0, 0.577584),
float4(-0.045426, 0.564586, 0.052998, 14.0),
float4(0.014061, -0.335291, 0.005408, 0.520989),
float4(0.001082, -0.332046, -0.052998, 0.088655),
float4(-0.975941, -0.037462, 0.214794, 0.973449),
float4(-0.044345, 0.23254, 0.0, 3.0),
float4(0.0, 0.0, -0.043263, 0.01033),
float4(-0.001082, 0.332046, -0.043263, 0.045182),
float4(-0.999995, -0.003257, 0.0, 0.577584),
float4(-0.163319, 0.380717, -0.043263, 7.0),
float4(-0.060569, 0.02704, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.407651, -0.913138, 0.0, 0.577584),
float4(-0.094098, 0.431551, -0.043263, 11.0),
float4(-0.069221, -0.050834, 0.0, 0.01033),
float4(-0.069221, -0.050834, 0.043263, 0.045182),
float4(0.591909, -0.806004, 0.0, 0.577584),
float4(-0.163319, 0.380717, -0.043263, 11.0),
float4(-0.060569, 0.02704, 0.0, 0.01033),
float4(-0.060569, 0.02704, 0.043263, 0.045182),
float4(-0.407651, -0.913138, 0.0, 0.577584),
float4(0.075711, 0.08869, -0.043263, 11.0),
float4(-0.031366, -0.045426, 0.0, 0.01033),
float4(-0.031366, -0.045426, 0.043263, 0.045182),
float4(0.822897, -0.568191, 0.0, 0.577584),
float4(0.044345, 0.043263, 0.0, 6.0),
float4(-0.040019, 0.030284, 0.049753, 0.000305),
float4(0.014061, 0.048671, 0.037855, 0.964691),
float4(0.365607, -0.634949, 0.680566, 0.973449),
float4(0.075711, 0.08869, -0.043263, 7.0),
float4(-0.031366, -0.045426, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.822897, -0.568191, 0.0, 0.577584),
float4(0.058405, 0.091934, 0.037855, 14.0),
float4(0.017305, -0.003245, -0.037855, 0.0),
float4(-0.014061, -0.048671, -0.037855, 0.473533),
float4(0.757369, -0.522945, 0.39105, 0.904662),
float4(-0.031366, 0.229295, 0.058405, 14.0),
float4(0.107077, -0.140606, -0.058405, 0.0),
float4(0.089771, -0.137361, -0.02055, 0.376257),
float4(0.812052, 0.481346, 0.329966, 0.830777),
float4(0.077874, 0.407756, -0.043263, 11.0),
float4(-0.002163, -0.319067, 0.0, 0.01033),
float4(-0.002163, -0.319067, 0.043263, 0.045182),
float4(0.999977, -0.006779, 0.0, 0.577584),
float4(-0.031366, 0.229295, 0.058405, 14.0),
float4(0.10924, 0.178461, -0.058405, 0.0),
float4(0.107077, -0.140606, -0.058405, 0.376257),
float4(0.475583, -0.003224, 0.879665, 0.830777),
float4(0.147095, 0.272559, -0.043263, 7.0),
float4(-0.035692, 0.034611, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.696146, -0.7179, 0.0, 0.577584),
float4(0.147095, 0.272559, -0.043263, 11.0),
float4(-0.035692, 0.034611, 0.0, 0.01033),
float4(-0.035692, 0.034611, 0.043263, 0.045182),
float4(-0.696146, -0.7179, 0.0, 0.577584),
float4(0.144932, 0.307169, 0.049753, 14.0),
float4(0.002163, -0.034611, -0.049753, 0.0),
float4(-0.033529, 0.0, -0.049753, 0.9131),
float4(-0.630237, -0.649931, 0.424725, 0.904662),
float4(0.183869, 0.317985, 0.037855, 6.0),
float4(-0.036774, -0.045426, -0.037855, 0.0),
float4(-0.038937, -0.010816, 0.011897, 0.806958),
float4(0.374433, -0.753477, 0.540438, 0.854994),
float4(0.077874, 0.407756, -0.043263, 7.0),
float4(-0.002163, -0.319067, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.999977, -0.006779, 0.0, 0.577584),
float4(0.111403, 0.307169, -0.043263, 7.0),
float4(-0.002163, 0.131953, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.999866, -0.016391, 0.0, 0.577584),
float4(0.10924, 0.439122, 0.0, 6.0),
float4(0.035692, -0.131953, 0.049753, 0.18117),
float4(0.002163, -0.131953, 0.0, 0.955978),
float4(-0.82919, -0.013593, 0.558802, 0.964691),
float4(0.128708, 0.463999, 0.063813, 14.0),
float4(0.055161, -0.146014, -0.025958, 0.246204),
float4(0.016224, -0.156829, -0.014061, 0.964691),
float4(0.305397, -0.053644, 0.950713, 0.973449),
float4(0.111403, 0.307169, -0.043263, 11.0),
float4(-0.002163, 0.131953, 0.0, 0.01033),
float4(-0.002163, 0.131953, 0.043263, 0.045182),
float4(-0.999866, -0.016391, 0.0, 0.577584),
float4(0.189277, 0.28013, -0.043263, 11.0),
float4(-0.042182, -0.007571, 0.0, 0.01033),
float4(-0.042182, -0.007571, 0.043263, 0.045182),
float4(0.176664, -0.984271, 0.0, 0.577584),
float4(0.183869, 0.317985, 0.037855, 10.0),
float4(0.005408, -0.037855, -0.037855, 0.0),
float4(-0.036774, -0.045426, -0.037855, 0.806958),
float4(0.124328, -0.692684, 0.710445, 0.854994),
float4(0.189277, 0.28013, -0.043263, 7.0),
float4(-0.042182, -0.007571, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.176664, -0.984271, 0.0, 0.577584),
float4(0.183869, 0.317985, 0.037855, 14.0),
float4(0.02704, -0.004326, -0.037855, 0.0),
float4(0.005408, -0.037855, -0.037855, 0.514916),
float4(0.70062, -0.452013, 0.552101, 0.846876),
float4(0.210908, 0.313659, -0.043263, 11.0),
float4(-0.021632, -0.033529, 0.0, 0.01033),
float4(-0.021632, -0.033529, 0.043263, 0.045182),
float4(0.840297, -0.542127, 0.0, 0.577584),
float4(0.210908, 0.445612, 0.0, 10.0),
float4(0.0, -0.131953, 0.0, 0.0),
float4(-0.02704, -0.127627, 0.037855, 0.439658),
float4(0.813734, 0.0, 0.581238, 0.871366),
float4(0.210908, 0.313659, -0.043263, 7.0),
float4(-0.021632, -0.033529, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.840297, -0.542127, 0.0, 0.577584),
float4(0.210908, 0.445612, -0.043263, 11.0),
float4(0.0, -0.131953, 0.0, 0.01033),
float4(0.0, -0.131953, 0.043263, 0.045182),
float4(1.0, 0.0, 0.0, 0.577584),
float4(0.241193, 0.343943, -0.043263, 7.0),
float4(-0.002163, 0.107077, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.999796, -0.020198, 0.0, 0.577584),
float4(0.276885, 0.311496, -0.043263, 11.0),
float4(-0.035692, 0.032447, 0.0, 0.01033),
float4(-0.035692, 0.032447, 0.043263, 0.045182),
float4(-0.672673, -0.73994, 0.0, 0.577584),
float4(0.23903, 0.45102, 0.0, 14.0),
float4(0.042182, -0.108158, 0.046508, 0.000305),
float4(0.002163, -0.107077, 0.0, 0.846876),
float4(-0.758098, -0.015315, 0.651961, 0.896269),
float4(0.276885, 0.311496, -0.043263, 7.0),
float4(-0.035692, 0.032447, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.672673, -0.73994, 0.0, 0.577584),
float4(0.281211, 0.342862, 0.046508, 14.0),
float4(-0.004326, -0.031366, -0.046508, 0.0),
float4(-0.040019, 0.001082, -0.046508, 0.752941),
float4(-0.58651, -0.645161, 0.489667, 0.846876),
float4(0.246601, 0.459672, 0.06165, 14.0),
float4(0.070303, -0.101669, -0.024876, 0.262257),
float4(0.034611, -0.116811, -0.015142, 0.973449),
float4(0.27928, -0.041605, 0.959308, 0.973449),
float4(0.319067, 0.319067, -0.043263, 11.0),
float4(-0.042182, -0.007571, 0.0, 0.01033),
float4(-0.042182, -0.007571, 0.043263, 0.045182),
float4(0.176664, -0.984271, 0.0, 0.577584),
float4(0.319067, 0.319067, 0.0, 10.0),
float4(-0.042182, -0.007571, 0.0, 0.0),
float4(-0.037855, 0.023795, 0.046508, 0.896269),
float4(0.1483, -0.826245, 0.54344, 0.896269),
float4(0.319067, 0.319067, -0.043263, 7.0),
float4(-0.042182, -0.007571, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.176664, -0.984271, 0.0, 0.577584),
float4(0.319067, 0.319067, 0.0, 6.0),
float4(-0.037855, 0.023795, 0.046508, 0.0),
float4(-0.002163, 0.038937, 0.036774, 0.896269),
float4(0.437906, -0.604311, 0.665618, 0.896269),
float4(0.316904, 0.358004, 0.036774, 14.0),
float4(0.024876, -0.004326, -0.036774, 0.0),
float4(0.002163, -0.038937, -0.036774, 0.617212),
float4(0.707338, -0.464191, 0.533104, 0.921584),
float4(0.34178, 0.353677, -0.043263, 11.0),
float4(-0.022713, -0.034611, 0.0, 0.01033),
float4(-0.022713, -0.034611, 0.043263, 0.045182),
float4(0.836048, -0.548657, 0.0, 0.577584),
float4(0.340698, 0.474815, 0.0, 14.0),
float4(0.001082, -0.121137, 0.0, 0.0),
float4(-0.023795, -0.116811, 0.036774, 0.473533),
float4(0.828664, 0.007399, 0.559697, 0.930114),
float4(0.34178, 0.353677, -0.043263, 7.0),
float4(-0.022713, -0.034611, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.836048, -0.548657, 0.0, 0.577584),
float4(0.340698, 0.474815, -0.043263, 11.0),
float4(0.001082, -0.121137, 0.0, 0.01033),
float4(0.001082, -0.121137, 0.043263, 0.045182),
float4(0.99996, 0.008928, 0.0, 0.577584),
float4(0.411001, 0.351514, -0.043263, 11.0),
float4(-0.034611, 0.030284, 0.0, 0.01033),
float4(-0.034611, 0.030284, 0.043263, 0.045182),
float4(-0.658505, -0.752577, 0.0, 0.577584),
float4(0.411001, 0.351514, -0.043263, 7.0),
float4(-0.034611, 0.030284, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.658505, -0.752577, 0.0, 0.577584),
float4(0.412083, 0.38288, 0.043263, 14.0),
float4(-0.001082, -0.031366, -0.043263, 0.0),
float4(-0.035692, -0.001082, -0.043263, 0.745403),
float4(-0.574039, -0.656045, 0.489984, 0.854994),
float4(0.45102, 0.359085, -0.043263, 11.0),
float4(-0.040019, -0.007571, 0.0, 0.01033),
float4(-0.040019, -0.007571, 0.043263, 0.045182),
float4(0.185892, -0.98257, 0.0, 0.577584),
float4(0.45102, 0.359085, 0.0, 10.0),
float4(-0.040019, -0.007571, 0.0, 0.000305),
float4(-0.038937, 0.023795, 0.043263, 0.879622),
float4(0.151736, -0.802035, 0.577682, 0.9131),
float4(0.45102, 0.359085, -0.043263, 7.0),
float4(-0.040019, -0.007571, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.185892, -0.98257, 0.0, 0.577584),
float4(0.45102, 0.359085, 0.0, 6.0),
float4(-0.038937, 0.023795, 0.043263, 0.000305),
float4(0.003245, 0.0411, 0.032447, 0.879622),
float4(0.417852, -0.583049, 0.696744, 0.9131),
float4(0.473733, 0.391533, -0.043263, 11.0),
float4(-0.022713, -0.032447, 0.0, 0.01033),
float4(-0.022713, -0.032447, 0.043263, 0.045182),
float4(0.819232, -0.573462, 0.0, 0.577584),
float4(0.454264, 0.400185, 0.032447, 14.0),
float4(0.019468, -0.008653, -0.032447, 0.0),
float4(-0.003245, -0.0411, -0.032447, 0.527108),
float4(0.688617, -0.482032, 0.541712, 0.887922),
float4(0.473733, 0.391533, -0.043263, 7.0),
float4(-0.022713, -0.032447, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.819232, -0.573462, 0.0, 0.577584),
float4(-0.223888, 0.407756, -0.043263, 7.0),
float4(0.002163, 0.06814, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.999496, 0.03173, 0.0, 0.577584),
float4(-0.223888, 0.407756, -0.043263, 11.0),
float4(0.002163, 0.06814, 0.0, 0.01033),
float4(0.002163, 0.06814, 0.043263, 0.045182),
float4(-0.999496, 0.03173, 0.0, 0.577584),
float4(-0.167645, 0.416409, 0.046508, 14.0),
float4(-0.056242, -0.008653, -0.046508, 0.000305),
float4(-0.054079, 0.059487, -0.046508, 0.955978),
float4(-0.638985, 0.020285, 0.768952, 0.973449),
float4(-0.167645, 0.416409, 0.046508, 14.0),
float4(0.004326, -0.035692, -0.046508, 0.000305),
float4(-0.056242, -0.008653, -0.046508, 0.955978),
float4(-0.339782, -0.761112, 0.552501, 0.973449),
float4(-0.221724, 0.475896, 0.0, 14.0),
float4(0.139524, 0.055161, 0.043263, 0.520989),
float4(0.054079, -0.059487, 0.046508, 0.973449),
float4(-0.39307, 0.317373, 0.863001, 0.973449),
float4(-0.167645, 0.416409, 0.046508, 6.0),
float4(0.073548, 0.015142, -0.046508, 0.0),
float4(0.004326, -0.035692, -0.046508, 0.768154),
float4(0.490917, -0.668482, 0.558688, 0.871366),
float4(-0.094098, 0.431551, -0.043263, 7.0),
float4(-0.069221, -0.050834, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.591909, -0.806004, 0.0, 0.577584),
float4(-0.167645, 0.416409, 0.046508, 10.0),
float4(0.085445, 0.114648, -0.003245, 0.0),
float4(0.073548, 0.015142, -0.046508, 0.768154),
float4(0.548356, -0.38771, 0.740936, 0.871366),
float4(-0.0822, 0.531057, -0.043263, 11.0),
float4(-0.011897, -0.099506, 0.0, 0.01033),
float4(-0.011897, -0.099506, 0.043263, 0.045182),
float4(0.992928, -0.11872, 0.0, 0.577584),
float4(-0.044345, 0.23254, 0.0, 7.0),
float4(-0.001082, 0.332046, -0.043263, 0.01033),
float4(-0.001082, 0.332046, 0.052998, 0.045182),
float4(-0.999995, -0.003257, 0.0, 0.577584),
float4(-0.045426, 0.564586, 0.052998, 14.0),
float4(0.1233, -0.156829, -0.052998, 0.520989),
float4(0.014061, -0.335291, 0.005408, 0.088655),
float4(0.429355, 0.032562, 0.902549, 0.973449),
float4(0.10924, 0.439122, 0.0, 14.0),
float4(-0.031366, -0.031366, 0.0, 0.132876),
float4(-0.154666, 0.125464, 0.052998, 0.028428),
float4(0.182761, -0.182761, 0.966021, 0.955978),
float4(0.10924, 0.439122, -0.043263, 11.0),
float4(-0.031366, -0.031366, 0.0, 0.01033),
float4(-0.031366, -0.031366, 0.043263, 0.045182),
float4(0.707107, -0.707107, 0.0, 0.577584),
float4(0.10924, 0.439122, -0.043263, 7.0),
float4(-0.031366, -0.031366, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.707107, -0.707107, 0.0, 0.577584),
float4(0.10924, 0.439122, 0.0, 10.0),
float4(0.019468, 0.024876, 0.063813, 0.18117),
float4(0.035692, -0.131953, 0.049753, 0.955978),
float4(-0.933936, -0.126584, 0.334276, 0.964691),
float4(0.128708, 0.463999, 0.063813, 14.0),
float4(0.050834, 0.002163, -0.005408, 0.0),
float4(0.0822, -0.018387, -0.063813, 0.439658),
float4(0.07859, -0.92643, 0.368172, 0.871366),
float4(-0.221724, 0.475896, -0.043263, 7.0),
float4(0.122219, 0.207664, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.861819, 0.507216, 0.0, 0.577584),
float4(-0.221724, 0.475896, -0.043263, 9.0),
float4(0.122219, 0.207664, 0.0, 0.01033),
float4(0.122219, 0.207664, 0.043263, 0.045182),
float4(-0.861819, 0.507216, 0.0, 0.577584),
float4(-0.099506, 0.68356, 0.0, 14.0),
float4(0.017305, -0.152503, 0.043263, 0.0),
float4(-0.122219, -0.207664, 0.0, 0.723049),
float4(-0.365879, 0.215335, 0.905408, 0.854994),
float4(-0.0822, 0.531057, -0.043263, 7.0),
float4(-0.011897, -0.099506, 0.043263, 0.01033),
float4(0.0, 0.0, 0.086527, 0.045182),
float4(0.992928, -0.11872, 0.0, 0.577584),
float4(-0.099506, 0.68356, 0.0, 14.0),
float4(0.054079, -0.118974, 0.052998, 0.0),
float4(0.017305, -0.152503, 0.043263, 0.514916),
float4(-0.41958, 0.203352, 0.884647, 0.863157),
float4(-0.099506, 0.68356, -0.043263, 3.0),
float4(0.086527, 0.149258, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.86514, 0.501531, 0.0, 0.577584),
float4(-0.045426, 0.564586, -0.043263, 11.0),
float4(-0.036774, -0.033529, 0.0, 0.01033),
float4(-0.036774, -0.033529, 0.086527, 0.045182),
float4(0.673754, -0.738956, 0.0, 0.577584),
float4(-0.045426, 0.564586, -0.043263, 7.0),
float4(-0.036774, -0.033529, 0.086527, 0.01033),
float4(0.0, 0.0, 0.096261, 0.045182),
float4(0.673754, -0.738956, 0.0, 0.577584),
float4(-0.099506, 0.68356, 0.0, 14.0),
float4(0.086527, 0.149258, 0.0, 0.0),
float4(0.054079, -0.118974, 0.052998, 0.262257),
float4(-0.385563, 0.223515, 0.8952, 0.9131),
float4(-0.099506, 0.68356, -0.043263, 11.0),
float4(0.086527, 0.149258, 0.0, 0.01033),
float4(0.086527, 0.149258, 0.043263, 0.045182),
float4(-0.86514, 0.501531, 0.0, 0.577584),
float4(-0.012979, 0.832818, 0.0, 14.0),
float4(0.214153, -0.194685, 0.0822, 0.000305),
float4(-0.032447, -0.268232, 0.052998, 0.930114),
float4(-0.176863, 0.211325, 0.961281, 0.973449),
float4(0.128708, 0.463999, 0.063813, 14.0),
float4(-0.019468, -0.024876, -0.063813, 0.168276),
float4(-0.174135, 0.100587, -0.010816, 0.038209),
float4(-0.469238, -0.764881, 0.441331, 0.955978),
float4(0.201174, 0.638133, 0.0822, 14.0),
float4(-0.072466, -0.174135, -0.018387, 0.18117),
float4(-0.246601, -0.073548, -0.029203, 0.082277),
float4(-0.098561, -0.063844, 0.993081, 0.973449),
float4(-0.012979, 0.832818, -0.043263, 7.0),
float4(0.339617, -0.002163, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.006369, 0.99998, 0.0, 0.577584),
float4(0.179543, 0.466162, 0.058405, 10.0),
float4(-0.050834, -0.002163, 0.005408, 0.000305),
float4(0.021632, 0.171972, 0.023795, 0.022171),
float4(0.110896, -0.149888, 0.982464, 0.381323),
float4(-0.012979, 0.832818, 0.0, 14.0),
float4(0.339617, -0.002163, 0.0, 0.0),
float4(0.214153, -0.194685, 0.0822, 0.027314),
float4(0.002492, 0.391296, 0.920261, 0.49102),
float4(0.183869, 0.317985, 0.037855, 10.0),
float4(-0.055161, 0.146014, 0.025958, 0.0),
float4(0.02704, 0.127627, -0.037855, 0.439658),
float4(0.623841, 0.097823, 0.775405, 0.871366),
float4(0.210908, 0.445612, -0.043263, 7.0),
float4(0.0, -0.131953, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(1.0, 0.0, 0.0, 0.577584),
float4(0.210908, 0.445612, 0.0, 10.0),
float4(-0.031366, 0.02055, 0.058405, 0.000305),
float4(0.035692, 0.014061, 0.06165, 0.022171),
float4(-0.105864, -0.954447, 0.278971, 0.381323),
float4(0.23903, 0.45102, -0.043263, 11.0),
float4(-0.028121, -0.005408, 0.0, 0.01033),
float4(-0.028121, -0.005408, 0.043263, 0.045182),
float4(0.188847, -0.982006, 0.0, 0.577584),
float4(0.23903, 0.45102, -0.043263, 7.0),
float4(-0.028121, -0.005408, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.188847, -0.982006, 0.0, 0.577584),
float4(0.246601, 0.459672, 0.06165, 11.0),
float4(-0.007571, -0.008653, -0.06165, 0.000305),
float4(-0.035692, -0.014061, -0.06165, 0.022171),
float4(0.187618, -0.975617, 0.113888, 0.381323),
float4(0.241193, 0.343943, -0.043263, 11.0),
float4(-0.002163, 0.107077, 0.0, 0.01033),
float4(-0.002163, 0.107077, 0.043263, 0.045182),
float4(-0.999796, -0.020198, 0.0, 0.577584),
float4(0.23903, 0.45102, 0.0, 15.0),
float4(0.007571, 0.008653, 0.06165, 0.000305),
float4(0.042182, -0.108158, 0.046508, 0.846876),
float4(-0.94107, -0.299262, 0.157572, 0.896269),
float4(0.316904, 0.358004, 0.036774, 14.0),
float4(-0.070303, 0.101669, 0.024876, 0.0),
float4(0.023795, 0.116811, -0.036774, 0.473533),
float4(0.523424, 0.157027, 0.837478, 0.930114),
float4(0.340698, 0.474815, -0.043263, 7.0),
float4(0.001082, -0.121137, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.99996, 0.008928, 0.0, 0.577584),
float4(0.376391, 0.381799, -0.043263, 11.0),
float4(-0.001082, 0.107077, 0.0, 0.01033),
float4(-0.001082, 0.107077, 0.043263, 0.045182),
float4(-0.999949, -0.0101, 0.0, 0.577584),
float4(0.376391, 0.381799, -0.043263, 7.0),
float4(-0.001082, 0.107077, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(-0.999949, -0.0101, 0.0, 0.577584),
float4(0.375309, 0.488875, 0.0, 14.0),
float4(0.036774, -0.105995, 0.043263, 0.000305),
float4(0.001082, -0.107077, 0.0, 0.879622),
float4(-0.771254, -0.00779, 0.63648, 0.896269),
float4(0.375309, 0.488875, 0.0, 14.0),
float4(0.078955, -0.08869, 0.032447, 0.223224),
float4(0.036774, -0.105995, 0.043263, 0.964691),
float4(0.071225, 0.39802, 0.914608, 0.973449),
float4(0.473733, 0.603523, 0.0, 14.0),
float4(0.0, -0.21199, 0.0, 0.158953),
float4(-0.019468, -0.203337, 0.032447, 0.030716),
float4(0.857493, 0.0, 0.514496, 0.964691),
float4(0.473733, 0.603523, -0.043263, 11.0),
float4(0.0, -0.21199, 0.0, 0.01033),
float4(0.0, -0.21199, 0.043263, 0.045182),
float4(1.0, 0.0, 0.0, 0.577584),
float4(0.276885, 0.484549, 0.058405, 10.0),
float4(-0.030284, -0.024876, 0.003245, 0.000305),
float4(-0.097342, -0.018387, 0.0, 0.022171),
float4(-0.03153, 0.166923, 0.985466, 0.381323),
float4(0.246601, 0.459672, 0.06165, 14.0),
float4(0.030284, 0.024876, -0.003245, 0.0),
float4(0.094098, 0.015142, -0.06165, 0.473533),
float4(0.518869, -0.545855, 0.657888, 0.930114),
float4(0.375309, 0.488875, -0.043263, 11.0),
float4(-0.034611, -0.014061, 0.0, 0.01033),
float4(-0.034611, -0.014061, 0.043263, 0.045182),
float4(0.376377, -0.926467, 0.0, 0.577584),
float4(0.340698, 0.474815, 0.0, 14.0),
float4(-0.063813, 0.009734, 0.058405, 0.000305),
float4(0.034611, 0.014061, 0.0, 0.022171),
float4(0.3276, -0.806402, 0.492334, 0.381323),
float4(0.375309, 0.488875, -0.043263, 7.0),
float4(-0.034611, -0.014061, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.376377, -0.926467, 0.0, 0.577584),
float4(0.454264, 0.400185, 0.032447, 12.0),
float4(-0.078955, 0.08869, -0.032447, 0.158953),
float4(0.019468, 0.203337, -0.032447, 0.030716),
float4(-0.201684, 0.173144, 0.964025, 0.964691),
float4(0.201174, 0.638133, 0.0822, 8.0),
float4(0.075711, -0.153585, -0.023795, 0.000305),
float4(-0.021632, -0.171972, -0.023795, 0.022171),
float4(0.026497, -0.140281, 0.989757, 0.381323),
float4(0.473733, 0.603523, -0.043263, 7.0),
float4(0.0, -0.21199, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(1.0, 0.0, 0.0, 0.577584),
float4(0.276885, 0.484549, 0.058405, 14.0),
float4(-0.075711, 0.153585, 0.023795, 0.000305),
float4(0.098424, 0.004326, -0.058405, 0.022171),
float4(0.50316, 0.115345, 0.856461, 0.381323),
float4(0.375309, 0.488875, 0.0, 10.0),
float4(0.090853, 0.12979, 0.0, 0.158953),
float4(0.098424, 0.114648, 0.0, 0.030716),
float4(0.0, 0.0, 1.0, 0.964691),
float4(0.466162, 0.618665, -0.043263, 11.0),
float4(0.007571, -0.015142, 0.0, 0.01033),
float4(0.007571, -0.015142, 0.043263, 0.045182),
float4(0.894427, 0.447214, 0.0, 0.577584),
float4(0.466162, 0.618665, -0.043263, 3.0),
float4(0.007571, -0.015142, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.894427, 0.447214, 0.0, 0.577584),
float4(0.326638, 0.830655, 0.0, 14.0),
float4(0.139524, -0.21199, 0.0, 0.0),
float4(0.048671, -0.34178, 0.0, 0.015213),
float4(0.0, 0.0, 1.0, 0.428687),
float4(0.326638, 0.830655, 0.0, 14.0),
float4(0.048671, -0.34178, 0.0, 0.007492),
float4(-0.125464, -0.192522, 0.0822, 0.054475),
float4(0.472493, 0.067285, 0.878762, 0.964691),
float4(0.326638, 0.830655, -0.043263, 9.0),
float4(0.139524, -0.21199, 0.0, 0.01033),
float4(0.139524, -0.21199, 0.043263, 0.045182),
float4(0.835314, 0.549773, 0.0, 0.577584),
float4(0.326638, 0.830655, -0.043263, 7.0),
float4(0.139524, -0.21199, 0.043263, 0.01033),
float4(0.0, 0.0, 0.043263, 0.045182),
float4(0.835314, 0.549773, 0.0, 0.577584),
float4(-0.012979, 0.832818, -0.043263, 11.0),
float4(0.339617, -0.002163, 0.0, 0.01033),
float4(0.339617, -0.002163, 0.043263, 0.045182),
float4(0.006369, 0.99998, 0.0, 0.577584)
};
constant float4 PRISM_BOXES[44] = {
float4(0.030135, 0.06127, -0.043945, 0.0),
float4(0.330601, 0.483055, 0.116951, 7.0),
float4(0.034429, 0.265258, -0.043945, 7.0),
float4(0.542104, 0.741798, 0.116951, 8.0),
float4(0.034429, 0.355442, -0.043945, 15.0),
float4(0.305908, 0.822319, 0.116951, 8.0),
float4(0.267405, 0.532589, -0.043945, 23.0),
float4(0.542104, 0.822319, 0.082595, 8.0),
float4(-0.045345, 0.036855, -0.044263, 31.0),
float4(0.045345, 0.23354, 0.059405, 8.0),
float4(-0.224888, 0.072548, -0.044263, 39.0),
float4(0.059405, 0.565586, 0.059405, 8.0),
float4(-0.032366, 0.042263, -0.044263, 47.0),
float4(0.148095, 0.408756, 0.059405, 8.0),
float4(0.074711, 0.08769, -0.044263, 55.0),
float4(0.184869, 0.464999, 0.064813, 8.0),
float4(0.146095, 0.271559, -0.044263, 63.0),
float4(0.211908, 0.446612, 0.038855, 8.0),
float4(0.23803, 0.310496, -0.044263, 71.0),
float4(0.320067, 0.460672, 0.06265, 8.0),
float4(0.275885, 0.310496, -0.044263, 79.0),
float4(0.412001, 0.475815, 0.047508, 8.0),
float4(0.375391, 0.350514, -0.044263, 87.0),
float4(0.45202, 0.38388, 0.044263, 4.0),
float4(0.410001, 0.350514, -0.044263, 91.0),
float4(0.474733, 0.401185, 0.044263, 5.0),
float4(-0.224888, 0.379717, -0.044263, 96.0),
float4(-0.0812, 0.532057, 0.047508, 8.0),
float4(-0.095098, 0.228295, -0.044263, 104.0),
float4(0.211908, 0.565586, 0.064813, 8.0),
float4(-0.222724, 0.430551, -0.044263, 112.0),
float4(-0.011979, 0.833818, 0.053998, 8.0),
float4(-0.100506, 0.438122, -0.044263, 120.0),
float4(0.327638, 0.833818, 0.0832, 8.0),
float4(0.127708, 0.312659, -0.044263, 128.0),
float4(0.282211, 0.467162, 0.064813, 8.0),
float4(0.245601, 0.352677, -0.044263, 136.0),
float4(0.474733, 0.604523, 0.06265, 8.0),
float4(0.178543, 0.390533, -0.044263, 144.0),
float4(0.474733, 0.639133, 0.0832, 8.0),
float4(0.200174, 0.483549, -0.044263, 152.0),
float4(0.474733, 0.639133, 0.0832, 4.0),
float4(-0.013979, 0.487875, -0.044263, 156.0),
float4(0.467162, 0.833818, 0.0832, 5.0)
};
constant float2 PRISM_POLY[110] = {
float2(0.006442, -0.002147),
float2(-0.001074, 0.001074),
float2(-0.004294, 0.007515),
float2(-0.004294, 0.806288),
float2(-0.001074, 0.809509),
float2(0.004294, 0.809509),
float2(0.022546, 0.796626),
float2(0.185736, 0.655982),
float2(0.281288, 0.86319),
float2(0.286656, 0.870706),
float2(0.293098, 0.871779),
float2(0.465951, 0.781595),
float2(0.478834, 0.773006),
float2(0.478834, 0.763344),
float2(0.407975, 0.592638),
float2(0.45092, 0.586196),
float2(0.601227, 0.573313),
float2(0.606595, 0.569018),
float2(0.606595, 0.564724),
float2(0.601227, 0.556135),
float2(0.50138, 0.453067),
float2(0.425153, 0.37684),
float2(0.289877, 0.246933),
float2(0.081595, 0.057975),
float2(0.013957, 0.0),
float2(-0.011897, 0.0),
float2(-0.055161, 0.037855),
float2(-0.081119, 0.063813),
float2(-0.083282, 0.06814),
float2(-0.084363, 0.38288),
float2(-0.089771, 0.38288),
float2(-0.158993, 0.33529),
float2(-0.166564, 0.336372),
float2(-0.250927, 0.379635),
float2(-0.261743, 0.388288),
float2(-0.263906, 0.461836),
float2(-0.262824, 0.486712),
float2(-0.173053, 0.638133),
float2(-0.044345, 0.860939),
float2(-0.036774, 0.867429),
float2(-0.024876, 0.871755),
float2(0.33529, 0.871755),
float2(0.349351, 0.867429),
float2(0.363412, 0.853368),
float2(0.513752, 0.619747),
float2(0.513752, 0.379635),
float2(0.466162, 0.322311),
float2(0.461836, 0.320148),
float2(0.399104, 0.311496),
float2(0.393696, 0.313659),
float2(0.374227, 0.332046),
float2(0.343943, 0.288782),
float2(0.336372, 0.282293),
float2(0.269314, 0.271477),
float2(0.263906, 0.27364),
float2(0.243356, 0.292027),
float2(0.21199, 0.244438),
float2(0.207664, 0.241193),
float2(0.149258, 0.231459),
float2(0.138443, 0.231459),
float2(0.118974, 0.248764),
float2(0.116811, 0.222806),
float2(0.117892, 0.162237),
float2(0.115729, 0.076792),
float2(0.06814, 0.011897),
float2(0.062732, 0.007571),
float2(0.005408, 0.0),
float2(0.031135, 0.06227),
float2(0.252301, 0.266258),
float2(0.541104, 0.544325),
float2(0.359663, 0.559356),
float2(0.433742, 0.753681),
float2(0.304908, 0.821319),
float2(0.199693, 0.595859),
float2(0.035429, 0.740798),
float2(0.035429, 0.482055),
float2(-0.043263, 0.077874),
float2(0.001082, 0.037855),
float2(0.044345, 0.043263),
float2(0.075711, 0.08869),
float2(0.077874, 0.407756),
float2(0.10924, 0.439122),
float2(0.111403, 0.307169),
float2(0.147095, 0.272559),
float2(0.189277, 0.28013),
float2(0.210909, 0.313659),
float2(0.210909, 0.445612),
float2(0.23903, 0.45102),
float2(0.241193, 0.343943),
float2(0.276885, 0.311496),
float2(0.319067, 0.319067),
float2(0.34178, 0.353677),
float2(0.340698, 0.474815),
float2(0.375309, 0.488875),
float2(0.376391, 0.381799),
float2(0.411001, 0.351514),
float2(0.45102, 0.359085),
float2(0.473733, 0.391533),
float2(0.473733, 0.603523),
float2(0.466162, 0.618665),
float2(0.326638, 0.830655),
float2(-0.012979, 0.832818),
float2(-0.099506, 0.68356),
float2(-0.221724, 0.475896),
float2(-0.223888, 0.407756),
float2(-0.163319, 0.380717),
float2(-0.094098, 0.431551),
float2(-0.0822, 0.531057),
float2(-0.045426, 0.564586),
float2(-0.044345, 0.23254)
};
constant float PRISM_BEVEL = 0.012883;
// end of the prism mesh
constant float PRISM_IOR = 1.61;
constant float PRISM_DISPERSION = 0.035;
constant float PRISM_GLOW = 0.45;
constant float PRISM_FOLD = 0.35;
constant int PRISM_BOUNCES = 6;
constant float PRISM_MAT = 9.0;
inline int prism_shape(constant Layer &layer)
{
int id = sculpt_id(layer);
return id == 3 || id == 4 ? id - 3 : -1;
}
static float prism_poly_dist(float2 p, int i0, int n)
{
float2 vj = PRISM_POLY[i0 + n - 1];
float d = 1e9;
float sgn = 1.0;
for (int i = 0; i < n; i++)
{
float2 vi = PRISM_POLY[i0 + i];
float2 e = vj - vi;
float2 w = p - vi;
float2 b = w - e * saturate(dot(w, e) / dot(e, e));
d = min(d, dot(b, b));
bool c0 = p.y >= vi.y;
bool c1 = p.y < vj.y;
bool c2 = e.x * w.y > e.y * w.x;
if ((c0 && c1 && c2) || (!c0 && !c1 && !c2))
{
sgn = -sgn;
}
vj = vi;
}
return sgn * sqrt(d);
}
static float prism_rim(float3 p, int shape, constant Layer &layer)
{
float half_t = model_thick(layer) * 0.5;
float sil = prism_poly_dist(p.xy, PRISM_SIL_START[shape], PRISM_SIL_COUNT[shape]);
float2 w = float2(sil + PRISM_BEVEL, abs(p.z + half_t) - (half_t - PRISM_BEVEL));
return min(max(w.x, w.y), 0.0) + length(max(w, 0.0)) - PRISM_BEVEL;
}
static float prism_tri(float3 ro, float3 rd, int k)
{
float3 v0 = PRISM_TRIS[4 * k].xyz;
float3 e1 = PRISM_TRIS[4 * k + 1].xyz;
float3 e2 = PRISM_TRIS[4 * k + 2].xyz;
float3 pv = cross(rd, e2);
float det = dot(e1, pv);
if (abs(det) < 1e-10)
{
return -1.0;
}
float inv = 1.0 / det;
float3 sv = ro - v0;
float u = dot(sv, pv) * inv;
float3 qv = cross(sv, e1);
float v = dot(rd, qv) * inv;
if (u < -2e-4 || v < -2e-4 || u + v > 1.0004)
{
return -1.0;
}
return dot(e2, qv) * inv;
}
static float prism_trace(float3 ro, float3 rd, int shape, thread int &hit)
{
float3 inv = 1.0 / select(float3(1e-6), rd, abs(rd) > 1e-6);
int b0 = PRISM_BOX_START[shape];
int nb = PRISM_BOX_COUNT[shape];
float best = 1e9;
hit = -1;
for (int j = b0; j < b0 + nb; j++)
{
float4 lo = PRISM_BOXES[2 * j];
float4 hi = PRISM_BOXES[2 * j + 1];
float3 t0 = (lo.xyz - ro) * inv;
float3 t1 = (hi.xyz - ro) * inv;
float3 tn = min(t0, t1);
float3 tf = max(t0, t1);
float tmin = max(max(tn.x, tn.y), tn.z);
float tmax = min(min(tf.x, tf.y), tf.z);
if (tmax < max(tmin, 1e-5) || tmin > best)
{
continue;
}
int k0 = int(lo.w);
int n = int(hi.w);
for (int i = k0; i < k0 + n; i++)
{
float t = prism_tri(ro, rd, i);
if (t > 1e-5 && t < best)
{
best = t;
hit = i;
}
}
}
return best;
}
static float2 sculpt_proto(float3 p, int theme, int shape)
{
if (theme == 3)
{
return s_voxels(p, shape);
}
if (theme == 5)
{
return s_glass(p, shape);
}
return s_rimmed(p, theme, shape);
}
inline float3 sculpt_point(float3 q, constant Layer &layer)
{
float zref = (sculpt_id(layer) - 1) % 2 == 0 ? SCULPT_ZREF_ARROW : SCULPT_ZREF_HAND;
return float3(q.x, -q.y, q.z / max(layer.color.b, 1e-3)) / SCULPT_SCALE + float3(0.0, 0.0, zref);
}
inline float sculpt_units(constant Layer &layer)
{
return SCULPT_SCALE * min(layer.color.b, 1.0);
}
static float2 sculpt_eval(float3 q, bool occ, constant Layer &layer)
{
int id = sculpt_id(layer) - 1;
int theme = id / 2, shape = id % 2;
if (theme == 1)
{
return float2(prism_rim(q, shape, layer), 8.0);
}
float3 p = sculpt_point(q, layer);
float2 r;
if (occ && theme == 3)
{
float d2 = s_pixel_outline(p.xy, shape);
float dz = abs(p.z - (SCULPT_HOVER + 0.07)) - 0.07;
r = float2(length(max(float2(d2, dz), 0.0)) + min(max(d2, dz), 0.0), 7.0);
}
else
{
r = sculpt_proto(p, theme, shape);
}
return float2(r.x * sculpt_units(layer), r.y);
}
static float sd_sprite2(float2 p, constant Layer &layer, texture2d<float, access::sample> texSdf)
{
float2 lo = layer.color.rg;
float2 c = clamp(p, lo, lo + sprite_size(layer));
float d = texSdf.sample(samp, (c - lo) / sprite_size(layer), level(0.0)).r;
float2 o = p - c;
float out2 = dot(o, o);
float e = max(d, 0.0);
return out2 > 0.0 ? sqrt(out2 + e * e) : d;
}
static float2 model_eval(float3 p, bool occ, constant Layer &layer, texture2d<float, access::sample> texSdf)
{
if (sculpt_id(layer) > 0)
{
return sculpt_eval(p, occ, layer);
}
float half_t = model_thick(layer) * 0.5;
float2 w = float2(sd_sprite2(p.xy, layer, texSdf) + MODEL_BEVEL,
abs(p.z + half_t) - (half_t - MODEL_BEVEL));
return float2(min(max(w.x, w.y), 0.0) + length(max(w, 0.0)) - MODEL_BEVEL, 0.0);
}
static float2 ray_box(float3 o, float3 d, float3 lo, float3 hi)
{
float3 inv = 1.0 / select(float3(1e-6), d, abs(d) > 1e-6);
float3 t0 = (lo - o) * inv;
float3 t1 = (hi - o) * inv;
float3 tn = min(t0, t1);
float3 tf = max(t0, t1);
return float2(max(max(tn.x, tn.y), tn.z), min(min(tf.x, tf.y), tf.z));
}
struct ModelFrame
{
float3 c;
float3 s;
float cp;
float sp;
float cy;
float sy;
};
static float3 world_to_plane(float3 v, ModelFrame f)
{
float y = v.y * f.c.x + v.z * f.s.x;
float z = -v.y * f.s.x + v.z * f.c.x;
float x = v.x * f.c.y - z * f.s.y;
z = v.x * f.s.y + z * f.c.y;
return float3(x * f.c.z + y * f.s.z, -x * f.s.z + y * f.c.z, z);
}
static float3 model_to_plane(float3 v, ModelFrame f)
{
float y = v.y * f.cp - v.z * f.sp;
float z = v.y * f.sp + v.z * f.cp;
return float3(v.x * f.cy - y * f.sy, v.x * f.sy + y * f.cy, z);
}
static float3 plane_to_model(float3 v, ModelFrame f)
{
float x = v.x * f.cy + v.y * f.sy;
float y = -v.x * f.sy + v.y * f.cy;
return float3(x, y * f.cp + v.z * f.sp, -y * f.sp + v.z * f.cp);
}
static float3 model_albedo(float2 p, constant Layer &layer, texture2d<float, access::sample> texSdf,
texture2d<float, access::sample> texImg)
{
float texel = sprite_texel(texSdf);
float e = 0.25 * texel;
float2 g = float2(sd_sprite2(p + float2(e, 0.0), layer, texSdf) - sd_sprite2(p - float2(e, 0.0), layer, texSdf),
sd_sprite2(p + float2(0.0, e), layer, texSdf) - sd_sprite2(p - float2(0.0, e), layer, texSdf));
float2 q = p - g / max(length(g), 1e-6) *
max(sd_sprite2(p, layer, texSdf) + MODEL_RIM_INSET * texel, 0.0);
return texImg.sample(samp, (q - layer.color.rg) / sprite_size(layer), level(0.0)).rgb;
}
struct SculptMat
{
float3 alb;
float rough;
float spec;
float sss;
float refl;
};
inline SculptMat s_mat(float3 alb, float rough, float spec, float sss, float refl)
{
SculptMat m;
m.alb = alb;
m.rough = rough;
m.spec = spec;
m.sss = sss;
m.refl = refl;
return m;
}
static float3 s_pixel_colour(float3 p, int shape)
{
int2 cell = s_pix_cell(p.xy, shape);
int4 g = PIX_GRID[shape];
int 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);
}
static SculptMat sculpt_material(float mat, float3 p, int theme, int shape)
{
bool primary = mat < 1.5;
if (theme == 0)
{
if (mat < 2.5) return s_mat(s_lin(0.95, 0.92, 0.85), 0.3, 0.6, 0.35, 0.25);
return s_mat(s_lin(0.1, 0.1, 0.11), 0.55, 0.05, 0.0, 0.1);
}
if (theme == 1) return s_mat(s_lin(0.02, 0.05, 0.33), 0.35, 0.5, 0.05, 0.3);
if (theme == 5) return s_mat(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 s_mat(s_lin(1.0, 0.40, 0.30), 0.85, 0.08, 0.15, 0.03);
if (mat < 3.5) return s_mat(s_lin(1.0, 0.80, 0.10), 0.85, 0.08, 0.15, 0.03);
return s_mat(s_lin(0.09, 0.13, 0.45), 0.9, 0.05, 0.05, 0.02);
}
if (theme == 4)
{
if (primary && shape == 0) return s_mat(s_lin(0.68, 0.93, 0.80), 0.25, 0.7, 0.3, 0.3);
if (primary) return s_mat(s_lin(0.97, 0.95, 0.90), 0.3, 0.6, 0.35, 0.25);
if (mat < 2.5) return s_mat(s_lin(0.52, 0.87, 0.78), 0.25, 0.7, 0.3, 0.3);
if (mat < 3.5) return s_mat(s_lin(1.0, 0.75, 0.25), 0.25, 0.7, 0.3, 0.3);
if (mat < 4.5) return s_mat(s_lin(0.62, 0.92, 0.72), 0.3, 0.6, 0.3, 0.35);
return s_mat(s_lin(0.07, 0.15, 0.33), 0.7, 0.15, 0.05, 0.08);
}
return s_mat(s_pixel_colour(p, shape), 0.65, 0.1, 0.12, 0.04);
}
static float3 model_env(float3 d, float rough, float3 l, float3 fill)
{
float3 col = mix(SCULPT_SCREEN * 0.9, s_lin(0.82, 0.85, 0.92) * 0.55, smoothstep(-0.15, 0.35, d.z));
float w = rough * 0.3;
float k = 1.0 - rough * 0.6;
col += s_lin(1.0, 0.97, 0.92) * 5.0 * k * smoothstep(0.90 - w, 0.97, dot(d, l));
col += s_lin(0.85, 0.9, 1.0) * 1.6 * k * smoothstep(0.93 - w, 0.98, dot(d, fill));
return col;
}
static float3 model_tonemap(float3 c)
{
const float start = 0.76;
float x = min(c.r, min(c.g, c.b));
c -= x < 0.08 ? x - 6.25 * x * x : 0.04;
float peak = max(c.r, max(c.g, c.b));
if (peak >= start)
{
const float d = 1.0 - start;
float np = 1.0 - d * d / (peak + d - start);
c *= np / peak;
float g = 1.0 - 1.0 / (0.15 * (peak - np) + 1.0);
c = mix(c, float3(np), g);
}
return pow(saturate(c), float3(1.0 / 2.2));
}
static float3 model_shade(float3 q, float3 n, float3 rd, float3 L, float fall, float sh, float ao, float mat,
float3 l, float3 fill, constant Layer &layer,
texture2d<float, access::sample> texSdf,
texture2d<float, access::sample> texImg)
{
int id = sculpt_id(layer);
SculptMat m;
float gloss = 1.0;
if (id > 0)
{
float3 p = sculpt_point(q, layer) - float3(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)
{
gloss = 1.0 - smoothstep(0.97, 0.995, abs(n.z));
}
}
else
{
m = s_mat(pow(model_albedo(q.xy, layer, texSdf, texImg), float3(2.2)), 0.45, 0.35, 0.2, 0.3);
gloss = 1.0 - smoothstep(0.97, 0.995, abs(n.z));
}
float3 key = s_lin(1.0, 0.97, 0.93) * 2.1 * fall;
float ndl = dot(n, L);
float wrap = 0.5 * m.sss;
float dif = saturate((ndl + wrap) / (1.0 + wrap)) * mix(sh, 1.0, 0.15 * m.sss);
float ndh = saturate(dot(n, normalize(L - rd)));
float shin = exp2(10.0 * (1.0 - m.rough) + 1.0);
float spe = (pow(ndh, shin) * (shin + 8.0) / 25.0 + 0.15 * pow(ndh, 8.0)) * sh * saturate(ndl * 4.0);
float fre = pow(1.0 - saturate(dot(n, -rd)), 5.0);
float3 amb = mix(SCULPT_SCREEN * 0.12, s_lin(0.88, 0.92, 1.0) * 0.22, 0.5 + 0.5 * n.z);
float3 fl = s_lin(0.85, 0.9, 1.0) * saturate(dot(n, fill)) * 0.12;
float3 col = m.alb * (key * dif + (amb + fl) * ao * mix(float3(1.0), m.alb, 0.5));
col += key * spe * m.spec * gloss;
col += model_env(reflect(rd, n), m.rough, l, fill) * m.refl * (0.04 + 0.96 * fre) * ao * gloss;
col += s_lin(0.9, 0.95, 1.0) * fre * 0.08 * ao * sh;
return model_tonemap(col);
}
// ---- Le cristal de Prism Glow ---- (cf. HLSL)
inline float prism_fresnel(float c, float ior)
{
float f0 = (ior - 1.0) / (ior + 1.0);
f0 *= f0;
return f0 + (1.0 - f0) * pow(1.0 - c, 5.0);
}
static float prism_primary(float3 ro, float3 rd, thread int &hc, constant Layer &layer)
{
hc = -1;
int shape = prism_shape(layer);
if (shape < 0)
{
return 1e9;
}
float t = prism_trace(ro, rd, shape, hc);
if (hc >= 0 && fmod(PRISM_TRIS[4 * hc].w, 2.0) > 0.5 && ro.z + rd.z * t < 0.0)
{
hc = -1;
return 1e9;
}
return t;
}
inline float3 prism_normal(int h, float3 rd)
{
float3 n = PRISM_TRIS[4 * h + 3].xyz;
return dot(n, rd) > 0.0 ? -n : n;
}
inline float prism_seg(float3 p, float3 a, float3 b)
{
float3 pa = p - a, ba = b - a;
return length(pa - ba * saturate(dot(pa, ba) / dot(ba, ba)));
}
static float prism_edge_px(float3 p, int h, float px)
{
float4 r0 = PRISM_TRIS[4 * h];
float3 a = r0.xyz;
float3 b = a + PRISM_TRIS[4 * h + 1].xyz;
float3 c = a + PRISM_TRIS[4 * h + 2].xyz;
int bits = int(r0.w * 0.5);
float 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;
}
static float3 plane_to_world(float3 v, ModelFrame f)
{
float x = v.x * f.c.z - v.y * f.s.z;
float y = v.x * f.s.z + v.y * f.c.z;
float z = -x * f.s.y + v.z * f.c.y;
return float3(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 où le rayon (q, d) du modèle retombe sur le plan, (-1, -1) s'il n'y
// retombe pas (cf. HLSL).
static float2 screen_uv(float3 q, float3 d, float3 nz, float hz, float3 tip, float unit, ModelFrame f,
constant Layer &layer)
{
float denom = dot(d, nz);
if (denom > -1e-4)
{
return float2(-1.0);
}
float3 g = q + d * ((hz - dot(q, nz)) / denom);
float3 w = plane_to_world(tip + unit * model_to_plane(g, f), f);
float k = 1.0 - w.z / layer.src.z;
if (k < 1e-3)
{
return float2(-1.0);
}
return layer.dst.xy + ((w.xy + layer.mb.zw) / k - layer.src.xy) / layer.quad_px * layer.dst.zw;
}
// La copie de l'image composée en `uv`, en linéaire ; hors de l'image, l'écran sombre du studio.
static float3 screen_at(float2 uv, texture2d<float, access::sample> texFrame)
{
if (any(uv < 0.0) || any(uv > 1.0))
{
return SCULPT_SCREEN * 0.2;
}
return pow(texFrame.sample(samp, uv, level(0.0)).rgb, float3(2.2));
}
static float3 prism_screen(float3 q, float3 d, float3 nz, float hz, float3 tip, float unit, ModelFrame f,
constant Layer &layer, texture2d<float, access::sample> texFrame)
{
return screen_at(screen_uv(q, d, nz, hz, tip, unit, f, layer), texFrame);
}
static float3 prism_shade(float3 p, float3 n, float3 rd, int h, float px, float3 l, float3 fill, float3 nz,
float hz, float3 tip, float unit, ModelFrame f, constant Layer &layer,
texture2d<float, access::sample> texFrame)
{
int shape = prism_shape(layer);
float4 r3 = PRISM_TRIS[4 * h + 3];
float3 facet = float3(PRISM_TRIS[4 * h + 1].w, PRISM_TRIS[4 * h + 2].w, r3.w);
float F = prism_fresnel(saturate(-dot(rd, n)), PRISM_IOR);
float zb = -model_thick(layer);
float3 trans = float3(0.0);
for (int ch = 0; ch < 3; ch++)
{
float3 mask = float3(float(ch == 0), float(ch == 1), float(ch == 2));
float ior = PRISM_IOR + PRISM_DISPERSION * float(ch - 1);
float3 d = refract(rd, n, 1.0 / ior);
float3 pos = p;
float thr = 1.0;
float acc = 0.0;
for (int b = 0; b < PRISM_BOUNCES; b++)
{
int hh;
float th = prism_trace(pos, d, shape, hh);
float tb = d.z < -1e-6 ? (zb - pos.z) / d.z : 1e9;
if (tb <= th)
{
float3 qb = pos + d * tb;
float3 d2 = refract(d, float3(0.0, 0.0, 1.0), ior);
if (dot(d2, d2) < 1e-8)
{
pos = qb;
d = reflect(d, float3(0.0, 0.0, 1.0));
continue;
}
acc += thr * dot(prism_screen(qb, d2, nz, hz, tip, unit, f, layer, texFrame), mask);
thr = 0.0;
break;
}
if (hh < 0)
{
break;
}
pos += d * th;
float4 rn = PRISM_TRIS[4 * hh + 3];
if (fmod(PRISM_TRIS[4 * hh].w, 2.0) > 0.5 && pos.z < 0.0)
{
acc += thr * dot(s_lin(0.03, 0.06, 0.37) * 0.35, mask);
thr = 0.0;
break;
}
float3 dout = refract(d, -rn.xyz, ior);
if (dot(dout, dout) < 1e-8)
{
d = reflect(d, -rn.xyz);
continue;
}
float fi = prism_fresnel(saturate(dot(dout, rn.xyz)), ior);
acc += thr * (1.0 - fi) * dot(model_env(dout, 0.05, l, fill), mask);
thr *= fi;
d = reflect(d, -rn.xyz);
}
trans += acc * mask;
}
float3 col = F * model_env(reflect(rd, n), 0.05, l, fill) + (1.0 - F) * trans + facet * PRISM_GLOW;
float 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 à ce qu'il transmet : Fresnel, l'éclat de la lampe, le liseré de lumière.
static float3 glass_light(float3 trans, float3 n, float3 rd, float3 L, float fall, float3 l, float3 fill)
{
float c = saturate(-dot(rd, n));
float F = prism_fresnel(c, GLASS_IOR);
float ndh = saturate(dot(n, normalize(L - rd)));
float ndl = dot(n, L);
float3 key = s_lin(1.0, 0.97, 0.93) * 2.1 * fall;
float spe = (pow(ndh, 900.0) * 5.0 + pow(ndh, 40.0) * 0.12) * saturate(ndl * 4.0);
float edge = pow(1.0 - c, 4.0) * (0.25 + 0.75 * saturate(ndl + 0.3));
float3 col = (1.0 - F) * (trans * s_lin(0.97, 0.985, 1.0) + 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`, moyennée le long de la réfraction depuis `uv0` (cf. HLSL).
static float3 glass_smear(float2 uv, float2 uv0, texture2d<float, access::sample> texFrame)
{
float2 s = all(uv0 >= 0.0) ? (uv - uv0) * GLASS_SMEAR : float2(0.0);
return (screen_at(uv, texFrame) + screen_at(uv - s, texFrame) + screen_at(uv + s, texFrame)) / 3.0;
}
static float3 glass_shade(float3 q, float3 n, float3 rd, float3 L, float fall, float3 l, float3 fill, float3 nz,
float hz, float3 tip, float unit, ModelFrame f, constant Layer &layer,
texture2d<float, access::sample> texFrame)
{
float zb = -model_thick(layer);
float2 uv0 = screen_uv(q, rd, nz, hz, tip, unit, f, layer);
float3 trans = float3(0.0);
for (int ch = 0; ch < 3; ch++)
{
float3 mask = float3(float(ch == 0), float(ch == 1), float(ch == 2));
float ior = GLASS_IOR + GLASS_DISPERSION * float(ch - 1);
float3 d = refract(rd, n, 1.0 / ior);
float3 seen = model_env(d, 0.05, l, fill);
if (d.z < -1e-4)
{
float3 qb = q + d * ((zb - q.z) / d.z);
float3 d2 = refract(d, float3(0.0, 0.0, 1.0), ior);
seen = dot(d2, d2) < 1e-8
? model_env(reflect(d, float3(0.0, 0.0, 1.0)), 0.05, l, fill)
: glass_smear(screen_uv(qb, d2, nz, hz, tip, unit, f, layer), uv0, texFrame);
}
trans += seen * mask;
}
return pow(saturate(glass_light(trans, n, rd, L, fall, l, fill)), float3(1.0 / 2.2));
}
// Les passes de la boucle unique de `cursor_model` (cf. HLSL : un seul appel de `model_eval`).
constant int STAGE_MARCH = 0;
constant int STAGE_NORMAL = 1;
constant int STAGE_AO = 2;
constant int STAGE_SELF = 3;
constant int STAGE_PLANE = 4;
constant int STAGE_EDGE = 5;
constant int STAGE_SHADE = 6;
constant int STAGE_DONE = 7;
constant float2 MODEL_SUBPIXEL[3] = { float2(0.35, 0.2), float2(-0.35, 0.2), float2(0.0, -0.4) };
inline float3 model_tetra(int k)
{
return 0.5773 * (2.0 * float3(float(((k + 3) >> 1) & 1), float((k >> 1) & 1), float(k & 1)) - 1.0);
}
static float4 cursor_model(float2 local, constant Layer &layer,
texture2d<float, access::sample> texSdf,
texture2d<float, access::sample> texImg,
texture2d<float, access::sample> texFrame)
{
ModelFrame f;
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);
float persp = layer.src.z;
float unit = layer.src.w;
float3 tip = layer.src_prev.xyz;
float3 lo = float3(layer.color.rg, -model_thick(layer));
float3 hi = float3(layer.color.rg + sprite_size(layer), layer.trail_a.z);
float3 dw = float3(local + layer.src.xy, -persp);
float dlen = length(dw);
// Plan translaté de mb.zw dans le repère caméra (caméra réelle ; 0 sous un angle fixe).
float3 ro = plane_to_model((world_to_plane(float3(-layer.mb.z, -layer.mb.w, persp), f) - tip) / unit, f);
float3 rd = plane_to_model(world_to_plane(dw / dlen, f), f);
float3 l = plane_to_model(world_to_plane(MODEL_LIGHT, f), f);
float3 fill = plane_to_model(world_to_plane(MODEL_FILL, f), f);
float3 nz = plane_to_model(float3(0.0, 0.0, 1.0), f);
float hz = -tip.z / unit;
float stride = sculpt_id(layer) > 0 ? 0.85 : 1.0;
float3 lamp = float3(layer.color.rg + sprite_size(layer) * 0.5, 0.0) + l * SCULPT_LAMP_DIST;
float3 ray = rd;
float2 tb = ray_box(ro, ray, lo - 0.02, hi + 0.02);
int stage = tb.x < tb.y && tb.y > 0.0 ? STAGE_MARCH : STAGE_DONE;
bool plane_next = stage == STAGE_DONE;
bool need_tc = stage == STAGE_MARCH;
float tc = 1e9;
int hc = -1;
int k = 0;
float t = max(tb.x, 0.0);
float best = 1e9;
float t_best = t;
float d_best = 0.0;
float mat = 0.0;
float cov = 0.0;
float cov_s = 0.0;
float3 q = float3(0.0);
float3 n = float3(0.0);
float3 L = float3(0.0);
float ao = 1.0;
float sh = 1.0;
float2 ts = float2(0.0);
float res = 1.0;
float3 g = float3(0.0);
float inside = 0.0;
float contact = 0.0;
float dropped = 0.0;
int sub = 0;
int shaded = 0;
float4 acc = float4(0.0);
for (int it = 0; it < 500; it++)
{
if (need_tc)
{
need_tc = false;
tc = prism_primary(ro, ray, hc, layer);
}
if (plane_next)
{
plane_next = false;
stage = cov > 0.0 ? STAGE_SHADE : STAGE_DONE;
float denom = dot(rd, nz);
if (cov < 1.0 && denom < -1e-4)
{
g = ro + rd * ((hz - dot(ro, nz)) / denom);
float3 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 = float2(0.0);
}
}
}
if (stage == STAGE_SHADE)
{
if (cov_s > 0.0)
{
float3 c;
float3 tl = lamp - q;
float 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, layer, texFrame);
}
else if (mat > GLASS_MAT - 0.5)
{
c = glass_shade(q, n, ray, normalize(tl), fall, l, fill, nz, hz, tip, unit, f, layer, texFrame);
}
else
{
c = model_shade(q, n, ray, normalize(tl), fall, sh, ao, mat, l, fill, layer, texSdf, texImg);
}
acc += float4(c * cov_s, cov_s);
}
shaded++;
stage = STAGE_DONE;
if (sub > 0)
{
float3 dws = float3(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 - 0.02, hi + 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;
}
float3 pos;
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)
{
float3 side = normalize(cross(n, ray));
float3 e = (k >= 2 ? cross(n, side) : side) * (k % 2 == 1 ? -1.0 : 1.0);
pos = q + e * 0.5 * t_best / dlen;
}
else if (stage == STAGE_AO)
{
pos = q + (0.01 + 0.0175 * 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;
}
float2 m = model_eval(pos, stage == STAGE_PLANE, layer, texSdf);
float d = m.x;
if (stage == STAGE_MARCH)
{
float fp = t / dlen;
bool hit = d < 0.1 * fp;
if (hit || d / fp < best)
{
best = hit ? 0.0 : d / fp;
t_best = t;
d_best = d;
mat = m.y;
}
t += d * stride;
k++;
if (!hit && t >= tc)
{
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 = float3(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)
{
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 += model_tetra(k) * d;
k++;
if (k == 4)
{
n = normalize(n);
k = 0;
stage = shaded > 0 ? STAGE_SHADE : STAGE_EDGE;
}
}
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)
{
int ps = prism_shape(layer);
if (ps >= 0)
{
float 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 += ((0.01 + 0.0175 * k) * SCULPT_SCALE - d) * pow(0.85, float(k));
k++;
if (k == 5)
{
ao = saturate(1.0 - 3.5 * ao / SCULPT_SCALE);
L = normalize(lamp - q);
float2 tbs = ray_box(q + n * 0.003, L, lo - MODEL_SHADOW_PAD, hi + MODEL_SHADOW_PAD);
if (tbs.x < tbs.y && tbs.y > 0.0)
{
stage = STAGE_SELF;
k = 0;
ts = float2(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 += 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);
float2 tbp = ray_box(g, l, lo - MODEL_SHADOW_PAD, hi + MODEL_SHADOW_PAD);
ts = float2(max(tbp.x, 0.004), tbp.y);
res = 1.0;
k = 1;
if (!(tbp.x < tbp.y && tbp.y > 0.0))
{
stage = cov > 0.0 ? STAGE_SHADE : STAGE_DONE;
}
}
else
{
res = min(res, MODEL_SOFTNESS * d / 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 = cov > 0.0 ? STAGE_SHADE : STAGE_DONE;
}
}
}
float w = 1.0 / max(shaded, 1);
// La lentille de Glass Lens laisse passer la lumière : son ombre est plus claire.
float clear = sculpt_id(layer) > 10 ? GLASS_SHADOW : 1.0;
float shadow = inside * clear * max(dropped * MODEL_SHADOW_ALPHA, contact * MODEL_CONTACT_ALPHA);
float a = acc.a * w * layer.color.a;
return float4(acc.rgb * w * layer.color.a, a + (1.0 - a) * shadow * layer.color.a); // prémultiplié, ombre noire
}
// ============ Verre à plat (mode 19) ============ (cf. HLSL, `cursor_glass`)
static float4 cursor_glass(float2 local, float2 pout, constant Layer &layer,
texture2d<float, access::sample> texFrame)
{
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 float4(0.0);
}
float3 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 float4(0.0);
}
float2 m = layer.color.rg + saturate(r.xy) * sprite_size(layer);
float2 p = float2(m.x, -m.y) / SCULPT_SCALE;
float px = 1.0 / max(layer.color.b * SCULPT_SCALE, 1e-3);
int shape = (sculpt_id(layer) - 1) % 2;
float2 g = float2(0.0);
float2 gd = float2(0.0);
float e = 0.25 * px;
for (int k = 0; k < 3; k++)
{
float2 v = s_glass2(p + (k == 1 ? float2(e, 0.0) : (k == 2 ? float2(0.0, e) : float2(0.0))), shape);
if (k == 0) g = v;
else if (k == 1) gd.x = v.y;
else gd.y = v.y;
}
float cov = saturate(0.5 - g.x / px);
if (cov <= 0.0)
{
return float4(0.0);
}
float2 out_dir = (gd - g.y) / e;
out_dir /= max(length(out_dir), 1e-4);
float2 relief = s_glass_relief(g.y);
float2 dir = float2(out_dir.x, -out_dir.y);
float3 n = normalize(float3(-relief.y * dir, 1.0));
float3 rd = float3(0.0, 0.0, -1.0);
bool rim = g.y > GLASS_LINE;
float depth = rim ? GLASS_RIM - GLASS_LINE : GLASS_TOP - SCULPT_HOVER + relief.x;
float3 trans = float3(0.0);
for (int ch = 0; ch < 3; ch++)
{
float3 mask = float3(float(ch == 0), float(ch == 1), float(ch == 2));
float ior = GLASS_IOR + GLASS_DISPERSION * float(ch - 1);
float3 d = refract(rd, n, 1.0 / ior);
float3 d2 = refract(d, float3(0.0, 0.0, 1.0), ior);
float2 off = d.xy * depth / max(-d.z, 0.05);
if (!rim && dot(d2, d2) > 1e-8)
{
off += d2.xy * GLASS_GAP_FLAT / max(-d2.z, 0.05);
}
off *= SCULPT_SCALE * layer.src.xy;
trans += glass_smear(pout + off, pout, texFrame) * mask;
}
float3 col = glass_light(trans, n, rd, MODEL_LIGHT, 1.0, MODEL_LIGHT, MODEL_FILL);
float edge_k = saturate(1.0 - min(g.y, GLASS_LINE - g.y) / (0.25 * GLASS_LINE));
float side = g.y < 0.5 * GLASS_LINE ? -1.0 : 1.0;
float3 nl = normalize(float3(side * edge_k * dir, 1.0));
float3 hl = normalize(MODEL_LIGHT + float3(0.0, 0.0, 1.0));
float3 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);
float in_line = saturate(0.5 + g.y / px) * saturate(0.5 - (g.y - GLASS_LINE) / px);
col = mix(col, line_col, in_line);
float a = cov * layer.color.a;
return float4(pow(saturate(col), float3(1.0 / 2.2)) * a, a); // prémultiplié
}
// ============ Impact du clic (mode 16) ============
// Port ligne pour ligne de `cursor_impact` (HLSL), dont les commentaires font foi.
static float4 cursor_impact(float2 local, constant Layer &layer)
{
float3 r = quad_inverse(local, layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.mb.x);
float2 pf = layer.dst_prev.xy + r.xy * layer.dst_prev.zw;
if (r.z < 0.5 || any(pf < 0.0) || any(pf > 1.0))
{
return float4(0.0);
}
float d = length(r.xy * 2.0 - 1.0);
float x = abs(d - layer.src.x);
float aa = layer.radius_px;
float ring = layer.src.z * (1.0 - smoothstep(layer.src.y - aa, layer.src.y + aa, x));
float halo = layer.src.w * exp(-x * x / (6.0 * layer.src.y * layer.src.y + aa * aa));
float spot = layer.mb.z * exp(-d * d / max(layer.mb.y * layer.mb.y, 1e-6));
float shade = clamp(halo + spot, 0.0, 1.0);
float a = ring + (1.0 - ring) * shade;
return float4(layer.color.rgb * ring, a) * layer.color.a; // prémultiplié, ombre noire
}
// ============ Cadre d'APPAREIL modelé (mode 17) ============
// Un portable, un téléphone ou un moniteur, modelés en VRAIE 3D autour du métrage : un corps qui
// a une épaisseur, des arêtes chanfreinées et une lunette, dont la face écran tombe EXACTEMENT
// sur le plan du métrage — le mode 8 continue donc de le dessiner dans l'ouverture, que ce mode
// creuse dans la face avant. Lancé de rayons par pixel dans la MÊME caméra que le plan,
// reconstruite comme au mode 15 (`regions::rotate_point` puis perspective P / (P − z)). Des
// formes neutres que l'on dessine soi-même : aucune marque, aucun logo.
//
// Repère du MODÈLE : unité = l'unité du cadre (`frame_geometry::frame_unit_px`, la même quel que
// soit le ratio du clip), origine au CENTRE du plan, x à droite,
// y vers le bas, z vers la caméra. L'écran occupe ±`layer.mb.xy`, le corps l'entoure de `src_prev` et
// va de z = −`layer.fx.w` à 0 ; ce qui dépasse (socle, pied) sort vers +y et ±z.
// Emplacements du cbuffer — miroir de `frame_geometry::device_frame_cb`, qui en fait foi :
// src = (décalage px du rayon, P, unité du modèle en px)
// layer.radius_px = rayon extérieur du corps, coins HAUTS (unités du modèle)
// layer.color.r = l'appareil (1 portable, 2 téléphone, 3 moniteur) ; layer.color.g = 1 si thème sombre ;
// layer.color.b = rayon extérieur du corps, coins BAS (unités) ; layer.color.a = opacité
// fx = (rotation du plan X, Y, Z en rad ; épaisseur du corps)
// src_prev = marges du corps (gauche, haut, droite, bas), unités du modèle
// mb = (demi-taille de l'écran ; translation du plan dans le repère caméra, px)
// dst_prev = (angle du socle du portable depuis le plan, rad ; rayon des coins de l'OUVERTURE,
// celui du métrage, unités ; recouvrement de la lunette sur le métrage, unités ;
// pénombre de l'OMBRE en px, 0 pour l'appareil lui-même)
// Les deux rayons du corps sont CONCENTRIQUES à celui de l'ouverture (`concentric_radius`) : la
// lunette garde son épaisseur tout autour de chaque coin. Ils viennent tout faits du cbuffer.
// Constantes : miroir exact de `frame_geometry.rs` (DEV_*), sauf ce qui ne change jamais
// l'encombrement — le micro-chanfrein, l'encoche du socle, les coins de la semelle — et n'existe
// donc que côté shader. Toutes en unités du modèle. L'éclairage est celui du curseur modélisé
// (MODEL_LIGHT/AMBIENT/DIFFUSE), pour que les deux objets d'une même frame soient vus sous la
// même lampe.
//
// Le parti pris matière : ALUMINIUM MAT ET VERRE NOIR, pas de plastique. Un gros arrondi d'arête
// et un reflet large font un objet gonflé ; un produit se lit à ses faces PLATES, à une arête
// nette et à un filet de lumière d'un pixel. D'où : un chanfrein de deux millièmes d'unité — assez
// pour que l'arête ne coupe pas, trop peu pour arrondir la silhouette —, aucun lobe spéculaire
// large, et un filet PEINT le long du contour (un tel chanfrein fait moins de deux pixels à
// l'écran : modelé, il ne s'antialiaserait pas).
constant float DEV_CHAMFER = 0.0021;
// Distance MINIMALE de l'œil qui voit le relief du modèle : celle d'un bras devant un portable.
// Miroir de `frame_geometry::DEV_EYE_MIN`.
constant float DEV_EYE_MIN = 9.6;
// Le plan proche du modèle (`frame_geometry::device_near_plane`) : une fraction de la distance
// de l'œil du modèle, rapprochée du travelling de la caméra réelle, et la bande de fondu. L'objectif
// des présets, 1,6 petit côté (`regions::PERSPECTIVE_FACTOR`), sert de distance de repos.
constant float DEV_NEAR = 0.16;
constant float DEV_NEAR_BAND = 0.1;
constant float DEV_LENS = 1.6;
// Le socle a sa profondeur réelle ; c'est son ANGLE (`device_deck_angle`) qui le rend discret vu
// de face. Il a la largeur de la coque ; tout le reste de ce qui dépasse est fixe, en unités du
// modèle, quelle que soit la forme du métrage encadré.
constant float DEV_DECK_LEN = 1.30;
// Le liseré d'aluminium qui borde la face avant (`DEV_RIM`), le rayon des coins avant de la
// semelle du moniteur (`DEV_FOOT_R`) et l'encoche du socle du portable, au milieu de son arête
// avant (`DEV_SCOOP_*` : demi-largeur, profondeur, hauteur de l'ellipsoïde retiré).
constant float DEV_RIM = 0.0053;
constant float DEV_FOOT_R = 0.0365;
constant float DEV_SCOOP_W = 0.14;
constant float DEV_SCOOP_D = 0.0372;
constant float DEV_SCOOP_H = 0.0112;
constant float DEV_DECK_THICK = 0.0446;
constant float DEV_DECK_THICK_FRONT = 0.0391;
constant float DEV_DECK_GAP = 0.0093;
constant float DEV_NECK_W = 0.255;
constant float DEV_NECK_LEN = 0.177;
constant float DEV_FOOT_W = 0.456;
constant float DEV_FOOT_H = 0.0456;
constant float DEV_STAND_Z = 0.0219;
constant float DEV_FOOT_Z = 0.195;
// Teintes (alpha droit). Deux thèmes, `layer.color.g` = 1 pour le sombre : aluminium argent ou
// graphite, et le verre de la dalle qui va avec. Neutres — c'est ce qui fait un appareil
// « schématique » et non une marque.
constant float3 DEV_SHELL_LIGHT = float3(0.800, 0.806, 0.812);
constant float3 DEV_SHELL_LIGHT_BACK = float3(0.600, 0.610, 0.622);
constant float3 DEV_GLASS_LIGHT = float3(0.031, 0.034, 0.040);
constant float3 DEV_SHELL_GRAPHITE = float3(0.255, 0.263, 0.278);
constant float3 DEV_SHELL_GRAPHITE_BACK = float3(0.153, 0.161, 0.176);
constant float3 DEV_GLASS_GRAPHITE = float3(0.043, 0.047, 0.055);
// Voile directionnel de l'aluminium brossé : doux et étroit, jamais une tache.
constant float DEV_SHEEN = 0.11;
static inline bool dev_dark(constant Layer &layer) { return layer.color.g > 0.5; }
static inline float3 dev_shell(constant Layer &layer) { return dev_dark(layer) ? DEV_SHELL_GRAPHITE : DEV_SHELL_LIGHT; }
static inline float3 dev_shell_back(constant Layer &layer) { return dev_dark(layer) ? DEV_SHELL_GRAPHITE_BACK : DEV_SHELL_LIGHT_BACK; }
static inline float3 dev_glass(constant Layer &layer) { return dev_dark(layer) ? DEV_GLASS_GRAPHITE : DEV_GLASS_LIGHT; }
static inline float2 dev_body_c(constant Layer &layer) { return float2((layer.src_prev.z - layer.src_prev.x) * 0.5, (layer.src_prev.w - layer.src_prev.y) * 0.5); }
static inline float2 dev_body_h(constant Layer &layer) { return layer.mb.xy + float2((layer.src_prev.x + layer.src_prev.z) * 0.5, (layer.src_prev.y + layer.src_prev.w) * 0.5); }
// Le chanfrein, borné par l'épaisseur : garde-fou, jamais atteint aux épaisseurs livrées.
static inline float dev_chamfer(constant Layer &layer) { return min(DEV_CHAMFER, layer.fx.w * 0.3); }
static inline float dev_deck_angle(constant Layer &layer) { return layer.dst_prev.x; }
// L'appareil : 1 = portable, 2 = téléphone, 3 = moniteur (`device_kind_id`).
static inline bool dev_is(constant Layer &layer, float k) { return abs(layer.color.r - k) < 0.5; }
// La hauteur du PLAN PROCHE devant l'écran (unités), pour la caméra RÉELLE en `eye` (repère du
// plan, unités) qui regarde le long de `axis`. Cf. `dev_near_plane` (HLSL), qui fait foi ; miroir
// de `frame_geometry::device_near_plane`.
static inline float dev_near_plane(float3 eye, float3 axis, constant Layer &layer)
{
float 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 modèle sous le plan proche `h_near` : un fondu, jamais une coupe.
static inline float dev_near_fade(float3 q, float h_near)
{
return 1.0 - smoothstep(h_near * (1.0 - DEV_NEAR_BAND), h_near, q.z);
}
// Boîte 3D à arêtes chanfreinées.
static float sd_dev_box(float3 p, float3 h, float r)
{
float3 q = abs(p) - h + r;
return length(max(q, 0.0)) + min(max(q.x, max(q.y, q.z)), 0.0) - r;
}
// Le contour du CORPS dans le plan xy, signé (<0 dedans) : la silhouette de la face avant. Le
// filet de lumière et le liseré du navigateur s'y accrochent.
static float sd_dev_outline(float2 p, constant Layer &layer)
{
// Coins hauts `radius_px`, coins bas `color.b` (cf. HLSL).
float2 q = p - dev_body_c(layer);
return sd_round_rect(q, dev_body_h(layer), (q.y < 0.0) ? layer.radius_px : layer.color.b);
}
// Ellipsoïde (borne de distance) : l'encoche du socle.
static float sd_dev_ellipsoid(float3 p, float3 r)
{
float k0 = length(p / r);
float k1 = length(p / (r * r));
return k0 * (k0 - 1.0) / max(k1, 1e-6);
}
// La dalle PLEINE du corps : arrondie en xy, mince en z, chanfreinée. Sans le creux de l'écran,
// c'est la silhouette qui porte l'ombre.
static float sd_dev_slab(float3 p, constant Layer &layer)
{
float t = layer.fx.w;
float ch = dev_chamfer(layer);
float2 w = float2(sd_dev_outline(p.xy, layer) + ch, abs(p.z + t * 0.5) - (t * 0.5 - ch));
return min(max(w.x, w.y), 0.0) + length(max(w, 0.0)) - ch;
}
// L'OUVERTURE dans le plan (<0 dedans) : le contour du métrage (rayon `dst_prev.y`) rentré du
// recouvrement `dst_prev.z` comme un décalage — mêmes centres d'arc, rayon diminué d'autant —, si
// bien que la lunette mord le métrage de la même largeur aux coins que le long des bords (cf. HLSL).
static float sd_dev_aperture(float2 p, constant Layer &layer)
{
float2 ah = layer.mb.xy - 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)));
}
// Le CORPS : la dalle moins le creux de l'écran, ouvert vers la caméra et fermé au fond — un trou
// débouchant laisserait voir au travers par le côté.
static float sd_dev_body(float3 p, constant Layer &layer)
{
float hole = max(sd_dev_aperture(p.xy, layer), -p.z - layer.fx.w * 0.55);
return max(sd_dev_slab(p, layer), -hole);
}
// Le repère du socle du portable : origine à la charnière (bord bas de la coque, à mi-épaisseur),
// y vers l'avant le long du socle, z sa normale. Miroir de `DeviceView::model_points`.
static float3 dev_deck_local(float3 p, constant Layer &layer)
{
float2 c = dev_body_c(layer);
float2 h = dev_body_h(layer);
float3 d = p - float3(0.0, c.y + h.y, -layer.fx.w * 0.5);
float ca = cos(dev_deck_angle(layer));
float sa = sin(dev_deck_angle(layer));
return float3(d.x, d.y * ca + d.z * sa, -d.y * sa + d.z * ca);
}
// Le socle : un COIN, pleine épaisseur à la charnière et aminci vers le bord avant, EXACTEMENT
// aussi large que la coque, et séparé d'elle par un jeu — le trait sombre qui dit deux pièces.
static float sd_dev_deck(float3 p, constant Layer &layer)
{
float3 q = dev_deck_local(p, layer);
float y0 = DEV_DECK_GAP;
float y1 = y0 + DEV_DECK_LEN;
float tb = DEV_DECK_THICK;
float slab = sd_dev_box(q - float3(0.0, (y0 + y1) * 0.5, -tb * 0.5),
float3(dev_body_h(layer).x, (y1 - y0) * 0.5, tb * 0.5),
DEV_CHAMFER * 2.0);
// Le dessous remonte vers l'avant : c'est lui, et non l'épaisseur, qui fait le profil en coin.
float k = (DEV_DECK_THICK - DEV_DECK_THICK_FRONT) / DEV_DECK_LEN;
float under = (-tb + k * (q.y - y0) - q.z) * rsqrt(1.0 + k * k);
// L'encoche au milieu de l'arête avant (cf. HLSL).
float scoop = sd_dev_ellipsoid(q - float3(0.0, y1, 0.0), float3(DEV_SCOOP_W, DEV_SCOOP_D, DEV_SCOOP_H));
return max(max(slab, under), -scoop);
}
// Entrée ANALYTIQUE du rayon dans le coin du socle, 1e9 s'il le manque (cf. HLSL, qui fait foi).
static float dev_deck_hit(float3 ro, float3 rd, constant Layer &layer)
{
float3 q0 = dev_deck_local(ro, layer);
float3 qd = dev_deck_local(ro + rd, layer) - q0;
float hw = dev_body_h(layer).x;
float y0 = DEV_DECK_GAP;
float len = DEV_DECK_LEN;
float tb = DEV_DECK_THICK;
float2 tt = ray_box(q0, qd, float3(-hw, y0, -tb), float3(hw, y0 + len, 0.0));
float k = (DEV_DECK_THICK - DEV_DECK_THICK_FRONT) / len;
float g0 = -tb + k * (q0.y - y0) - q0.z;
float gd = k * qd.y - qd.z;
if (abs(gd) > 1e-9)
{
float 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;
}
// Entré par l'encoche, le rayon touche la matière à sa sortie de l'ellipsoïde.
float t_in = max(tt.x, 0.0);
float3 o = (q0 - float3(0.0, y0 + len, 0.0)) / float3(DEV_SCOOP_W, DEV_SCOOP_D, DEV_SCOOP_H);
float3 e = qd / float3(DEV_SCOOP_W, DEV_SCOOP_D, DEV_SCOOP_H);
float ea = dot(e, e);
float eb = dot(o, e);
float disc = eb * eb - ea * (dot(o, o) - 1.0);
if (disc > 0.0)
{
float s = sqrt(disc);
if (t_in >= (-eb - s) / ea && t_in < (-eb + s) / ea) { t_in = (-eb + s) / ea; }
}
return (t_in <= tt.y) ? t_in : 1e9;
}
// Le pied du moniteur : colonne mince contre le dos, puis semelle basse et plate qui part en
// arrière. Pas de palet épais — un pied de moniteur est une tôle.
static float sd_dev_stand(float3 p, constant Layer &layer)
{
float y0 = dev_body_c(layer).y + dev_body_h(layer).y;
float zc = -layer.fx.w * 0.5;
float neck = sd_dev_box(p - float3(0.0, y0 + DEV_NECK_LEN * 0.5 - 0.01, zc - DEV_STAND_Z * 0.5),
float3(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.
float3 f = p - float3(0.0, y0 + DEV_NECK_LEN + DEV_FOOT_H * 0.5, zc - DEV_FOOT_Z * 0.5);
float2 fd = float2(sd_round_rect(f.xz, float2(DEV_FOOT_W, DEV_FOOT_Z * 0.5), DEV_FOOT_R),
abs(f.y) - DEV_FOOT_H * 0.5);
float foot = min(max(fd.x, fd.y), 0.0) + length(max(fd, 0.0));
return min(neck, foot);
}
// Ce qui sort du corps : le socle du portable, le pied du moniteur, rien pour les deux autres.
static float sd_dev_extra(float3 p, constant Layer &layer)
{
if (dev_is(layer, 1.0)) { return sd_dev_deck(p, layer); }
if (dev_is(layer, 3.0)) { return sd_dev_stand(p, layer); }
return 1e9;
}
static float sd_device(float3 p, constant Layer &layer)
{
return min(sd_dev_body(p, layer), sd_dev_extra(p, layer));
}
// Le modèle PLEIN, écran compris : ce que l'ombre voit.
static float sd_dev_solid(float3 p, constant Layer &layer)
{
return min(sd_dev_slab(p, layer), sd_dev_extra(p, layer));
}
static float3 device_normal(float3 p, constant Layer &layer)
{
const float e = 0.0006;
return normalize(float3(1, -1, -1) * sd_device(p + float3(1, -1, -1) * e, layer) +
float3(-1, -1, 1) * sd_device(p + float3(-1, -1, 1) * e, layer) +
float3(-1, 1, -1) * sd_device(p + float3(-1, 1, -1) * e, layer) +
float3(1, 1, 1) * sd_device(p + float3(1, 1, 1) * e, layer));
}
// Couverture d'une SDF 2D adoucie sur un pixel (`aa` = un pixel en unités du modèle).
static inline float dev_cov(float d, float aa)
{
return saturate(0.5 - d / max(aa, 1e-6));
}
// Filet de lumière d'un pixel, peint juste à l'intérieur d'un contour `d2` (<0 dedans).
static inline float dev_hairline(float d2, float aa)
{
return dev_cov(abs(d2 + aa) - aa * 0.55, aa);
}
// La matière au point `p`, normale `n` : `.rgb` l'albédo (alpha droit), `.a` = 1 pour le métal
// (qui prend le voile directionnel), 0 pour le verre, qui reste mat.
static float4 device_albedo(float3 p, float3 n, float aa, constant Layer &layer)
{
float3 metal = dev_shell(layer);
float3 back = dev_shell_back(layer);
if (sd_dev_body(p, layer) > sd_dev_extra(p, layer))
{
if (!dev_is(layer, 1.0))
{
// Le pied du moniteur : de l'aluminium, un dégradé vertical doux.
float v = saturate((p.y - dev_body_c(layer).y - dev_body_h(layer).y) / (DEV_NECK_LEN + DEV_FOOT_H));
return float4(mix(metal, back, 0.15 + 0.45 * v), 1.0);
}
float3 q = dev_deck_local(p, layer);
float hw = dev_body_h(layer).x;
float y0 = DEV_DECK_GAP;
float len = DEV_DECK_LEN;
// La tranche AVANT : une barre d'argent qui fonce doucement vers son arête basse.
if (q.y > y0 + len - DEV_CHAMFER * 3.0)
{
float s = saturate(-q.z / DEV_DECK_THICK_FRONT);
return float4(mix(metal, back, smoothstep(0.35, 1.0, s) * 0.8), 1.0);
}
// Le dessous, puis le dessus : clavier et pavé tactile.
if (q.z < -DEV_DECK_THICK * 0.25) { return float4(back, 1.0); }
float3 top = metal;
// Clavier : 0,75 de la largeur du socle, de 0,10 à 0,56 de sa profondeur.
float key = sd_round_rect(q.xy - float2(0.0, y0 + len * 0.33),
float2(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));
// Pavé tactile, centré dans la moitié avant.
float pad = sd_round_rect(q.xy - float2(0.0, y0 + len * 0.76),
float2(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 float4(top, 1.0);
}
// Le dos et les flancs : l'aluminium, plus sombre quand il tourne le dos à la caméra.
float3 shell = mix(back, metal, saturate(n.z * 0.8 + 0.5));
// Le quart avant du corps seulement (cf. HLSL) : la colonne du moniteur n'est pas du verre.
float front = (p.z < -layer.fx.w * 0.25) ? 0.0 : smoothstep(0.30, 0.80, n.z);
if (front <= 0.0) { return float4(shell, 1.0); }
// Le liseré d'aluminium qui borde la face avant, et le filet de lumière sur son arête.
float edge = sd_dev_outline(p.xy, layer);
float band = 1.0 - dev_cov(edge + DEV_RIM, aa);
float rim = dev_hairline(edge, aa);
// La face avant : une dalle de verre noir pour les trois appareils.
float3 c = dev_glass(layer);
if (dev_is(layer, 2.0))
{
// Téléphone : un œil de caméra, rien d'autre — pas de fente de haut-parleur, qui date un
// téléphone. Au milieu de la lunette du HAUT DU TÉLÉPHONE, pas du métrage : une ouverture
// paysage est un téléphone COUCHÉ, son haut vers la gauche de l'image. Sa taille est fixe,
// comme l'épaisseur du corps.
bool upright = layer.mb.y >= layer.mb.x;
float2 e = upright ? p.xy : float2(-p.y, p.x);
float2 hh = upright ? layer.mb.xy : float2(layer.mb.y, layer.mb.x);
float bez = (upright ? layer.src_prev.y : layer.src_prev.x) - DEV_RIM;
c = mix(c, float3(0.086, 0.102, 0.133), dev_cov(length(e - float2(0.0, -hh.y - bez * 0.5)) - 0.003, aa));
}
else
{
// Portable et moniteur : un œil de caméra centré dans la lunette du haut, pas d'encoche.
float bez = layer.src_prev.y - DEV_RIM;
c = mix(c, float3(0.120, 0.133, 0.161), dev_cov(length(p.xy - float2(0.0, -layer.mb.y - bez * 0.5)) - 0.2 * bez, aa));
}
c = mix(c, metal, band);
c = mix(c, min(metal * 1.12, 1.0), rim);
return float4(mix(shell, c, front), max(band, rim));
}
// L'OMBRE portée de l'appareil (même calque, `dst_prev.w` = pénombre en px) : la silhouette que
// la caméra voit VRAIMENT du modèle, socle et pied compris. Cf. `device_shadow` (HLSL), qui fait
// foi : le décalage est déjà dans `src.xy`, on marche le modèle PLEIN, et la plus courte approche
// du rayon, en px, tient lieu de distance au contour, avec la pénombre du mode 2. Ce que le plan
// proche `h_near` efface de l'appareil, il l'efface de son ombre.
static float4 device_shadow(float3 ro, float3 rd, float fpk, float3 lo, float3 hi, float h_near, constant Layer &layer)
{
float spread = layer.dst_prev.w;
float m = 2.0 * spread / layer.src.w;
float2 tb = ray_box(ro, rd, lo - m, hi + m);
if (tb.x >= tb.y || tb.y <= 0.0)
{
return float4(0.0, 0.0, 0.0, 0.0);
}
// Dans la silhouette pleine, à coup sûr : le rayon perce la face avant ou le socle.
if (rd.z < -1e-5 && sd_dev_outline((ro + rd * (-ro.z / rd.z)).xy, layer) < 0.0)
{
return float4(0.0, 0.0, 0.0, layer.color.a);
}
float t_deck = dev_is(layer, 1.0) ? dev_deck_hit(ro, rd, layer) : 1e9;
if (t_deck < 1e9)
{
return float4(0.0, 0.0, 0.0, layer.color.a * dev_near_fade(ro + rd * t_deck, h_near));
}
float t = max(tb.x, 0.0);
float best = 1e9;
float t_best = t;
for (int k = 0; k < 96; k++)
{
float d = sd_dev_solid(ro + rd * t, layer);
float 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 += max(d, fp);
}
float a = layer.color.a * (1.0 - smoothstep(0.0, spread, best)) * dev_near_fade(ro + rd * t_best, h_near);
return float4(0.0, 0.0, 0.0, a); // noir prémultiplié
}
static float4 device_frame(float2 local, constant Layer &layer)
{
ModelFrame f;
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;
float persp = layer.src.z;
float unit = layer.src.w;
// Le rayon de ce pixel, dans le repère DU PLAN (= celui du modèle, à `unit` près) : caméra en
// (0, 0, P) du repère caméra, plan translaté de `layer.mb.zw` dans ce même repère.
float3 dw = float3(local + layer.src.xy, -persp);
float dlen = length(dw);
float3 ro = world_to_plane(float3(-layer.mb.z, -layer.mb.w, persp), f) / unit;
float3 rd = world_to_plane(dw / dlen, f);
float3 l = world_to_plane(MODEL_LIGHT, f);
// Le plan proche (`DeviceView::near_plane`) : tiré de la caméra RÉELLE, avant qu'on la recule.
float h_near = dev_near_plane(ro, world_to_plane(float3(0.0, 0.0, -1.0), f), layer);
// L'ŒIL DU MODÈLE (`DeviceView::model_eye`, cf. HLSL) : celui du plan, reculé sur sa droite à
// au moins `DEV_EYE_MIN`, et jamais plus bas que la ligne du centre de l'écran — d'en dessous,
// le socle montrait sa face inférieure et couvrait le bas du métrage. Chaque rayon passe par le
// MÊME point du plan que celui de l'objectif. `fpk` = empreinte d'un pixel par unité de
// distance le long du nouveau rayon (celle du plan, rapportée à sa distance).
float fpk = 1.0 / dlen;
if (rd.z < -1e-5)
{
float ts = -ro.z / rd.z;
float3 e = float3(ro.x, min(ro.y, 0.0), ro.z);
float3 eye = e * max(1.0, DEV_EYE_MIN / max(length(e), 1e-3));
float3 v = ro + rd * ts - eye;
float lv = length(v);
fpk = ts / dlen / lv;
ro = eye;
rd = v / lv;
}
// La boîte du modèle, corps et débords compris : le socle du portable vient vers la caméra,
// le pied du moniteur s'en éloigne. Miroir de `DeviceView::model_points`.
float2 bc = dev_body_c(layer);
float2 bh = dev_body_h(layer);
float3 lo = float3(bc - bh, -layer.fx.w);
float3 hi = float3(bc + bh, 0.0);
if (dev_is(layer, 1.0))
{
// Les quatre coins du profil du socle, de la charnière au bord avant, dessus et dessous.
float ca = cos(dev_deck_angle(layer));
float sa = sin(dev_deck_angle(layer));
float2 hinge = float2(bc.y + bh.y, -layer.fx.w * 0.5);
float2 qy = float2(DEV_DECK_GAP, DEV_DECK_GAP + DEV_DECK_LEN);
float2 qz = float2(0.0, -DEV_DECK_THICK);
for (int j = 0; j < 4; j++)
{
float a = qy[j & 1];
float b = qz[j >> 1];
float2 yz = hinge + float2(a * ca - b * sa, a * sa + b * ca);
lo = float3(lo.x, min(lo.yz, yz));
hi = float3(hi.x, max(hi.yz, yz));
}
}
else if (dev_is(layer, 3.0))
{
lo = float3(min(lo.x, -DEV_FOOT_W), lo.y, lo.z - DEV_FOOT_Z);
hi = float3(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, layer);
}
// Le plan du métrage occulte tout ce qui est derrière lui DANS l'ouverture ARRONDIE : la
// marche s'y arrête (cf. HLSL : entre l'arc et le coin carré, c'est de la lunette).
// Hors de l'ouverture, le même point du plan dit si le rayon perce la FACE AVANT ; le socle a
// son entrée analytique. La marche ne sert qu'à ce qui les précède et à l'antialiasing.
float t_max = 1e9;
float t_solid = 1e9;
if (rd.z < -1e-5)
{
float ts = -ro.z / rd.z;
float2 qp = ro.xy + rd.xy * ts;
if (ts > 0.0 && sd_dev_aperture(qp, layer) < 0.0) { t_max = ts; }
else if (ts > 0.0 && sd_dev_outline(qp, layer) < 0.0) { t_solid = ts; }
}
if (dev_is(layer, 1.0)) { t_solid = min(t_solid, dev_deck_hit(ro, rd, layer)); }
bool solid = t_solid < t_max;
float2 tb = ray_box(ro, rd, lo - 0.01, hi + 0.01);
float t1 = min(min(tb.y, t_max), t_solid);
if (!solid && (tb.x >= t1 || t1 <= 0.0))
{
return float4(0.0, 0.0, 0.0, 0.0);
}
// Marche, avec la même silhouette antialiasée qu'au mode 15 : un rayon qui frôle le modèle à
// moins d'un pixel le couvre en partie.
float t = max(tb.x, 0.0);
float best = 1e9;
float t_best = t;
bool hit = false;
for (int k = 0; k < 80; k++)
{
float d = sd_device(ro + rd * t, layer);
float 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 += max(d, 0.25 * fp);
if (t > t1)
{
break;
}
}
if (!hit && solid)
{
hit = true;
t_best = t_solid;
}
float cov = hit ? 1.0 : saturate(1.0 - best);
if (cov <= 0.0)
{
return float4(0.0, 0.0, 0.0, 0.0);
}
float3 q = ro + rd * t_best;
float3 n = device_normal(q, layer);
float4 mat = device_albedo(q, n, t_best * fpk, layer);
float diffuse = saturate(dot(n, l));
// Aucun lobe spéculaire large : c'est lui qui donnait l'air plastique et gonflé. Rien qu'un
// voile directionnel étroit sur le métal, et le filet de lumière déjà peint dans l'albédo.
float sheen = DEV_SHEEN * mat.a * pow(diffuse, 4.0);
float3 rgb = mat.rgb * (MODEL_AMBIENT + MODEL_DIFFUSE * diffuse) + sheen;
// Au-delà du plan proche, l'appareil s'efface (le socle, quand la caméra en orbite avance).
float a = cov * layer.color.a * dev_near_fade(q, h_near);
return float4(rgb * a, a); // prémultiplié
}
fragment float4 ps_main(VSOut i [[stage_in]],
constant Layer &layer [[buffer(0)]],
texture2d<float, access::sample> texY [[texture(0)]],
texture2d<float, access::sample> texUV [[texture(1)]],
texture2d<float, access::sample> texImg [[texture(2)]],
// Masque de segmentation du sujet webcam. Non lie tant qu'aucun
// masque n'existe : Metal rend alors 0, ce qui est sans effet
// puisque la branche n'est prise que si layer.fx.z > 0.5.
texture2d<float, access::sample> texMask [[texture(3)]],
// Champ de distance du sprite de curseur (mode 15 seulement), R16F, cf.
// `cursor_sdf.rs`. Le sprite lui-même est en texture(2), comme aux
// modes 7 et 13.
texture2d<float, access::sample> texSdf [[texture(4)]],
// Pyramide de profondeur de champ (`tilted_sample`), lue par le mode 8 et
// par le repli du mode 18, qui garde texture(2) pour son rendu isolé.
texture2d<float, access::sample> texDof [[texture(5)]])
{
// mode 19 : VERRE À PLAT de Glass Lens (`cursor_glass`). Testé avant le mode 18, dont la
// branche n'a pas de borne haute. C'est un modèle, compilé avec les modes 15 à 17.
if (layer.mode > 18.5)
{
#ifdef LAYER_MODELS
return cursor_glass(i.local, i.pout, layer, texDof);
#else
return float4(0.0);
#endif
}
// mode 18 : l'écran CADRÉ (ombre, cadre, métrage, appareil) flouté comme UN objet rigide
// (`FrameGeometry::screen_trail`), port 1:1 du HLSL. texImg = son rendu isolé, prémultiplié,
// à la taille de la sortie. À plat, sa boîte va de `dst_prev` (frame précédente) à `fx`
// (courante) ; incliné (`mb.z` = 1), les coins du plan vont de `trail_a`/`trail_b` à
// `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 prolongé n'atteint pas (aller sans solution) n'a pas de tap.
// Hors de la sortie rien n'a été rendu : dans l'ouverture arrondie de l'écran (`quad_px`,
// `radius_px`, 2 px en retrait) on relit le métrage (`src` = la coupe) comme le mode 8 l'a
// dessiné, avec sa profondeur de champ (`trail_mb` = son `mb`, pyramide en texture(5)) et sa
// lampe (`color.xy`), nulles à plat ; ailleurs le tap est écarté.
if (layer.mode > 17.5)
{
int taps = int(layer.mb.x);
float4 acc = float4(0.0);
float n = 0.0;
for (int k = 0; k < 16; k++)
{
if (k >= taps) break;
float a = saturate(layer.mb.y) * (1.0 - float(k) / float(taps - 1));
float2 f;
float2 q;
if (layer.mb.z > 0.5)
{
float4 ta = mix(layer.fx, layer.trail_a, a);
float4 tb = mix(layer.src_prev, layer.trail_b, a);
float3 r = quad_inverse(i.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
{
float4 r = mix(layer.fx, layer.dst_prev, a);
f = (i.pout - r.xy) / r.zw;
q = layer.fx.xy + f * layer.fx.zw;
}
if (all(q >= 0.0) && all(q <= 1.0))
{
acc += texImg.sample(samp, q, level(0.0));
n += 1.0;
}
else if (sd_round_rect(f * layer.quad_px - layer.quad_px * 0.5, layer.quad_px * 0.5,
layer.radius_px) < -2.0)
{
float z = (f.x - 0.5) * layer.trail_mb.x + (f.y - 0.5) * layer.trail_mb.y;
float3 rgb = tilted_sample(mix(layer.src.xy, layer.src.zw, f),
layer.trail_mb.w * abs(z - layer.trail_mb.z), texY, texUV, texDof);
rgb = clamp(rgb * (1.0 + layer.color.x * (f.x - 0.5) + layer.color.y * (f.y - 0.5)), 0.0, 1.0);
acc += float4(rgb, 1.0);
n += 1.0;
}
}
return acc / max(n, 1.0);
}
#ifdef LAYER_MODELS
// mode 17 : CADRE D'APPAREIL MODELÉ (`device_frame`). Testé en premier, comme le 16.
if (layer.mode > 16.5)
{
return device_frame(i.local, layer);
}
// mode 16 : IMPACT DU CLIC (`cursor_impact`). Testé en premier, comme le mode 15.
if (layer.mode > 15.5)
{
return cursor_impact(i.local, layer);
}
// mode 15 : CURSEUR MODÉLISÉ (`cursor_model`). Testé en premier : les branches suivantes
// n'ont pas de borne haute. dst_prev = rect de clip « Clip to canvas », comme au mode 13.
if (layer.mode > 14.5)
{
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 float4(0.0, 0.0, 0.0, 0.0);
}
return cursor_model(i.local, layer, texSdf, texImg, texDof);
}
#else
// Les modèles 3D n'existent que dans la variante `LAYER_MODELS` ; un draw qui les enverrait
// ici ne peint rien plutôt qu'une ombre faite de leurs emplacements.
if (layer.mode > 14.5)
{
return float4(0.0, 0.0, 0.0, 0.0);
}
#endif
// mode 14 : CADRE DE FENÊTRE autour de l'écran, dessiné SOUS lui. Cf. commentaires HLSL.
// Testé avant le mode 13, dont la branche n'a pas de borne haute.
// fx/src_prev = coins du cadre projeté ; dst_prev = (taille du plan, barre, filet) ;
// radius_px = rayon extérieur ; color = fond de la barre ; mb = couleur du filet ;
// src.x = 1 : warp projectif.
if (layer.mode > 13.5)
{
float3 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 float4(0.0, 0.0, 0.0, 0.0); // hors du cadre projeté
}
float2 plane_px = layer.dst_prev.xy;
float bar = layer.dst_prev.z;
float line_w = layer.dst_prev.w;
float2 q = float2(r.x, r.y) * plane_px;
float2 p = q - plane_px * 0.5;
// Le MEME rayon aux quatre coins : le metrage est arrondi partout (cf. HLSL).
float rad = max(layer.radius_px, 0.0);
float d = sd_round_rect(p, plane_px * 0.5, rad);
float cov = 1.0 - smoothstep(0.0, 1.5, d);
float 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));
float3 rgb = mix(layer.color.rgb, layer.mb.rgb, stroke * layer.mb.a);
float dr = bar * 0.214;
float dx = bar * 0.714;
// Le bloc est repousse du coin d'au moins le rayon PLUS celui d'une pastille et une
// marge : sans ca, l'arrondi mordait la premiere des que Roundness montait.
float x0 = max(dx, rad + dr + bar * 0.18);
rgb = mix(rgb, float3(1.000, 0.373, 0.341), disc_cov(q, float2(x0, bar * 0.5), dr));
rgb = mix(rgb, float3(0.996, 0.737, 0.180), disc_cov(q, float2(x0 + dx, bar * 0.5), dr));
rgb = mix(rgb, float3(0.157, 0.784, 0.251), disc_cov(q, float2(x0 + 2.0 * dx, bar * 0.5), dr));
float a = cov * layer.color.a;
return float4(rgb * a, a);
}
// mode 13 : SPRITE DE CURSEUR posé sur l'écran incliné. Cf. commentaires HLSL.
// Un mode supérieur doit être testé AVANT cette branche, qui n'a pas de borne haute.
// mb.x = 1 : warp projectif.
if (layer.mode > 12.5)
{
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 float4(0.0, 0.0, 0.0, 0.0);
}
float3 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 float4(0.0, 0.0, 0.0, 0.0);
}
float4 s = texImg.sample(samp, clamp(float2(r.x, r.y), 0.0, 1.0));
float a = s.a * layer.color.a;
return float4(s.rgb * a, a);
}
// mode 11 : texte en alpha DÉJÀ prémultiplié (CoreText/Direct2D rendent ainsi) — on
// module juste l'opacité globale.
//
// Le commentaire du port disait « ne PAS re-multiplier » et le code faisait exactement
// ça : `s.rgb * (s.a * color.a)`, soit un alpha appliqué deux fois. Le texte sortait
// trop sombre sur ses bords adoucis et disparaissait sur les fines.
if (layer.mode > 10.5 && layer.mode < 11.5)
{
return texImg.sample(samp, i.uv) * layer.color.a;
}
// mode 12 : ombre du quad projeté. Pénombre douce autour du quad tilté.
if (layer.mode > 11.5)
{
// Le port lisait `spread` dans `fx.x`, recentrait `i.local` sur `quad_px * 0.5`, et
// remplaçait l'inset de rayon par un simple `+ spread`. Trois écarts : `fx` porte les
// COINS (pas le spread, qui vit dans `mb.y`), `i.local` est déjà dans le repère de la
// bbox, et sans l'inset l'ombre n'a aucun coin arrondi. Signature du dernier :
// `line_cross` était défini et jamais appelé nulle part dans le fichier.
float2 quad[5] = { layer.fx.xy, layer.fx.zw, layer.src_prev.xy, layer.src_prev.zw, layer.fx.xy };
// Coins arrondis du même rayon que le plan. Une ombre à coins vifs derrière un écran
// arrondi dépasse en pointe à chaque coin, d'autant plus que le rayon monte.
float r = max(layer.radius_px, 0.0);
float2 v[4];
for (int k = 0; k < 4; k++)
{
// TL→TR→BR→BL tourne dans le sens horaire en y-bas, donc (e.y, -e.x) sort du quad.
// Division par la longueur plutôt que `normalize` : une arête dégénérée donnerait
// un NaN qui effacerait l'ombre entière.
float2 ep = quad[k] - quad[(k + 3) & 3];
float2 ec = quad[k + 1] - quad[k];
float2 np = float2(ep.y, -ep.x) / max(length(ep), 1e-6);
float2 nc = float2(ec.y, -ec.x) / max(length(ec), 1e-6);
v[k] = line_cross(np, dot(quad[(k + 3) & 3], np) - r, nc, dot(quad[k], nc) - r);
}
float d = sd_convex_quad(i.local, v[0], v[1], v[2], v[3]) - 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 rogné par le slot (cf. HLSL).
if (layer.dst_prev.z > layer.dst_prev.x)
{
float2 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));
}
float spread = max(layer.mb.y, 1e-3);
float a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
return float4(layer.color.rgb * a, a);
}
// mode 8 : écran tilté (zoom regions "rotation") ou vu par la caméra réelle. Warp inverse :
// bilinéaire sous un angle fixe, projectif exact sous la caméra réelle ou un appareil
// (dst_prev.w = 1) ; la caméra réelle éclaire aussi le plan (color.xy : 1 + color.x·(s − 0.5)
// + color.y·(t − 0.5)).
// mb = [gx, gy, z_focus, k] : profondeur du point r du plan = (r.x - 0.5)*gx + (r.y - 0.5)*gy
// en px, positive vers la caméra ; z_focus = celle du focus du zoom (`TiltedQuad::depth_mb`) ;
// k = texels source de flou par px d'écart de profondeur (0 = profondeur de champ coupée).
// texture(5) (texDof) = pyramide demi-résolution de la vidéo, 5 niveaux, mêmes UV que
// texture(0/1) ; liée explicitement à chaque draw du mode 8. Cf. commentaires HLSL.
if (layer.mode > 7.5 && layer.mode < 8.5)
{
// PAS de test de clip sur `dst_prev` ici — le port en avait copié un depuis le
// mode 13. En mode 8 `dst_prev.xy` porte `plane_px`, la taille du plan en PIXELS
// (~1600), comparée à `i.pout` qui vit dans [0,1] : la condition était vraie pour
// tout pixel et la branche rendait du transparent partout. Le tilt ne dessinait rien.
float3 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 float4(0.0, 0.0, 0.0, 0.0); // hors du quad projeté
}
// La coupe source s'applique ICI : `r` est une position DANS le plan (0..1), pas
// une coordonnée de texture. Le port échantillonnait `r` directement, ignorant le
// crop et le zoom.
float2 uv = float2(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 REPÈRE DU PLAN : le rayon reste constant le long du bord,
// là où un arrondi calculé dans la bbox s'étirerait avec la perspective.
// Inconditionnel, rayon 0 compris — `sd_round_rect` dégénère en SDF de rectangle et
// le feather de 1,5 px subsiste, ce qui fait lire une arête inclinée COMME une arête
// plutôt que comme une troncature en marches d'escalier.
// dst_prev.z = 1 : écran sous le chrome de fenêtre, coins HAUTS carrés et rognés par
// l'arc du cadre (`sd_screen_under_bar`, `color.z` = la remontée, px du plan).
float2 plane_px = layer.dst_prev.xy;
float2 p = float2(r.x, r.y) * plane_px - plane_px * 0.5;
float rad = max(layer.radius_px, 0.0);
// Une branche et non `?:`, pour ne jamais évaluer les DEUX distances (trois SDF par pixel).
float d;
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);
float tilt_a = 1.0 - smoothstep(0.0, 1.5, d);
// 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).
tilt_a *= slot_alpha(i.local, layer.quad_px, layer.color.w);
// Profondeur de champ : net sous un demi-texel de flou (l'échantillon d'avant, à
// l'octet), fondu au-delà vers la pyramide au niveau `log2(coc) - 1`, plafonné.
// `level(lod)` exige `mip_filter::linear` sur `samp` : sans lui, niveau 0 partout.
float2 rs = clamp(float2(r.x, r.y), 0.0, 1.0);
float z = (rs.x - 0.5) * layer.mb.x + (rs.y - 0.5) * layer.mb.y;
float coc = layer.mb.w * abs(z - layer.mb.z);
float3 rgb = tilted_sample(uv, coc, texY, texUV, texDof);
// Flou de mouvement, celui du mode 0 : l'UV que CE pixel montrait à la frame précédente,
// par le même warp inverse sur les coins d'avant (`trail_a`/`trail_b`), puis `taps`
// échantillons de celui-là à celui-ci, raccourcis de la force. Borné à une frame. Le
// mouvement se mesure entre les deux points NON bornés (cf. HLSL).
int taps = int(layer.trail_mb.x);
if (taps > 1 && layer.trail_mb.y > 0.001)
{
float3 rp = quad_inverse(i.local, layer.trail_a.xy, layer.trail_a.zw,
layer.trail_b.xy, layer.trail_b.zw, layer.dst_prev.w);
float2 duv = (r.xy - rp.xy) * (layer.src.zw - layer.src.xy)
* clamp(layer.trail_mb.y, 0.0, 1.0);
// Sans antécédent sur le plan d'avant, pas de point d'avant : l'échantillon reste net.
if (rp.z > -0.5 && dot(duv, duv) >= 1e-9)
{
float3 acc = float3(0.0);
for (int k = 0; k < 16; k++)
{
if (k >= taps) break;
float t = float(k) / float(taps - 1);
acc += tilted_sample(uv - duv * (1.0 - t), coc, texY, texUV, texDof);
}
rgb = acc / float(taps);
}
}
if (layer.dst_prev.w > 0.5)
{
// La lampe de la caméra réelle : le côté proche un peu plus clair.
rgb = clamp(rgb * (1.0 + layer.color.x * (rs.x - 0.5) + layer.color.y * (rs.y - 0.5)), 0.0, 1.0);
}
// L'alpha est cette couverture, pas `color.a` : les draws du mode 8 laissent `color`
// à zéro, donc le port rendait de toute façon un plan totalement transparent.
return float4(rgb * tilt_a, tilt_a);
}
// mode 7 : sprite curseur thème (PNG alpha droite). Prémultiplie ici, comme partout
// ailleurs. `fx` = rect de clip « Clip to canvas » en espace sortie 0..1 [x,y,w,h]
// (= s_dst quand actif, sinon un rect englobant tout, donc sans effet).
//
// Le port avait omis ce test : `plan_cursor` calcule bien le rect et le draw le passe
// dans `fx`, mais le shader l'ignorait — `cursor.clipToBounds` était inerte sur macOS.
if (layer.mode > 6.5 && layer.mode < 7.5)
{
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 float4(0.0, 0.0, 0.0, 0.0);
}
float4 s = texImg.sample(samp, i.uv);
float a = s.a * layer.color.a;
return float4(s.rgb * a, a);
}
// mode 6 : wallpaper image RGBA (cover-fit). src = rect uv déjà calculé (crop de
// recouvrement), i.uv l'interpole. OPAQUE — comme le HLSL.
//
// Le port lisait `layer.color.a` ici. `LayerCB::default()` met `color` à zéro, donc
// l'alpha valait 0 et le fond image était rigoureusement invisible : un fond noir,
// qu'on lit comme « le compositeur ne dessine pas le wallpaper » plutôt que comme
// « le wallpaper est dessiné avec alpha 0 ».
//
// Fond animé : mêmes emplacements qu'au mode 5 (fx.z temps, fx.w mouvement, mb.x aspect).
// fx.w = 0 lit l'image telle quelle, à l'octet près.
if (layer.mode > 5.5 && layer.mode < 6.5)
{
float2 uv = i.uv;
float light = 0.0;
if (layer.fx.w > 0.5)
{
float2 size = layer.src.zw - layer.src.xy;
float3 m = image_motion((i.uv - layer.src.xy) / size - 0.5, layer.fx.z, layer.fx.w,
layer.mb.x);
uv = layer.src.xy + (m.xy + 0.5) * size;
light = m.z;
}
float a = quad_round_alpha(i.local, layer.quad_px, layer.radius_px);
return float4(lighten(texImg.sample(samp, uv).rgb, light) * a, a); // prémultiplié
}
// mode 5 : gradient linéaire jusqu'à 4 stops (parité web wallpaper dégradé). Nœuds
// `rgb + position` dans color, src_prev, dst_prev, src (cf. `ramp4`), fx.xy = direction unitaire (espace sortie, y vers le bas). t est
// normalisé coin-à-coin (dénominateur = |dx|+|dy|) pour couvrir toute la diagonale.
//
// Le port avait remplacé tout ce calcul par une couleur plate : un dégradé s'affichait
// comme son premier stop, uniformément.
//
// Fond animé : fx.z = temps programme (s, replié sur 120), fx.w = mouvement (0 immobile,
// 1 dérive, 2 aurore, 3 vagues), mb.x = aspect w/h. 0 rend le dégradé d'avant à l'octet.
if (layer.mode > 4.5 && layer.mode < 5.5)
{
float2 dir = layer.fx.xy;
float slide = 0.0;
if (layer.fx.w > 0.5 && layer.fx.w < 1.5)
{
// Dérive : l'axe balance de ±30° (0.5235988 rad) en 20 s, le dégradé glisse le long
// de lui de ±20 % en 15 s.
float da = 0.5235988 * sin(6.2831853 * layer.fx.z / 20.0);
float sa = sin(da);
float ca = cos(da);
dir = float2(dir.x * ca - dir.y * sa, dir.x * sa + dir.y * ca);
slide = 0.2 * sin(6.2831853 * layer.fx.z / 15.0);
}
float denom = max(abs(dir.x) + abs(dir.y), 1e-4);
// Paramétré sur le QUAD dès qu'il en a un (la bulle webcam), sinon sur la sortie. Pour le
// fond plein cadre les deux coïncident ; pour une bulle dans un coin, `pout` ne montrerait
// que la tranche du dégradé plein cadre qui passe dessous, jamais la rampe complète que
// le sélecteur affiche.
float2 gp = (layer.quad_px.x > 0.0 && layer.quad_px.y > 0.0)
? (i.local / layer.quad_px)
: i.pout;
float t = clamp(0.5 + dot(gp - 0.5, dir) / denom + slide, 0.0, 1.0);
float3 g = ramp4(t, layer.color, layer.src_prev, layer.dst_prev, layer.src);
if (layer.fx.w > 1.5)
{
g = gradient_motion(gp, dir, denom, layer.color, layer.src_prev, layer.dst_prev,
layer.src, layer.fx.z, layer.fx.w, layer.mb.x);
}
float a = quad_round_alpha(i.local, layer.quad_px, layer.radius_px);
return float4(g * a, a); // prémultiplié
}
// mode 4 : curseur dessiné (dot + ring SDF).
if (layer.mode > 3.5 && layer.mode < 4.5)
{
float2 p = i.local - layer.quad_px * 0.5;
float R = min(layer.quad_px.x, layer.quad_px.y) * 0.5;
float r = length(p);
float aa = 1.5;
float dot_r = R * 0.34;
float ring_r = R * 0.72;
float ring_w = R * 0.09;
float ddot = 1.0 - clamp((r - (dot_r - aa)) / (2.0 * aa), 0.0, 1.0);
float ring = clamp((r - (ring_r - ring_w - aa)) / aa, 0.0, 1.0)
* (1.0 - clamp((r - (ring_r + ring_w)) / aa, 0.0, 1.0));
float halo = (1.0 - clamp((r - (dot_r + aa)) / 2.5, 0.0, 1.0)) * (1.0 - ddot);
float a = clamp(ddot + ring, 0.0, 1.0) * layer.color.a;
float3 rgb = layer.color.rgb * (ddot + ring);
a = clamp(a + halo * 0.35 * layer.color.a, 0.0, 1.0);
return float4(rgb * a, a);
}
// mode 9 : annotation « figure » — une flèche. Parité EXACTE avec `ArrowSvgs.tsx`, dont
// chaque direction est un tracé de trois segments à bouts ronds : une hampe et deux
// barbes. Trois `sd_segment` et un `min` reproduisent la forme telle quelle.
// fx = hampe, src_prev = barbe 1, dst_prev = barbe 2 ; mb.y = demi-épaisseur px.
//
// Le port avait INVENTÉ une forme : un seul segment dérivé de `quad_px`, avec
// `radius_px` en épaisseur. Ce n'était pas une approximation de la flèche, c'était une
// autre figure — et elle ignorait la géométrie que `regions::arrow_local_geometry`
// calcule et uploade.
if (layer.mode > 8.5 && layer.mode < 9.5)
{
float 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 crénelage, et une flèche fine ne
// disparaît pas quand la demi-épaisseur descend sous le pixel.
float a = clamp(layer.mb.y - d + 0.5, 0.0, 1.0) * layer.color.a;
return float4(layer.color.rgb * a, a);
}
// mode 10 : annotation « flou » — masque la zone en réutilisant l'image DÉJÀ composée,
// qui arrive dans `texImg` (recopie mipmappée du render target : on ne peut pas
// échantillonner la cible sur laquelle on dessine). `i.pout` donne directement l'UV de
// sortie. fx.x = 0 mosaïque / 1 flou ; fx.y = taille de bloc px ou rayon px ;
// fx.z = 0 rectangle / 1 ovale ; fx.w = 1 si le masque doit être teinté ;
// mb.z = 1 si le masque est un quad incliné (coins TL, TR dans dst_prev, BR, BL dans src_prev),
// mb.w = 1 si son warp est projectif.
//
// Le port se contentait de recopier `texImg` : ni forme, ni flou, ni mosaïque, ni teinte.
if (layer.mode > 9.5 && layer.mode < 10.5)
{
float2 n = i.local / max(layer.quad_px, float2(1e-6));
// Écran incliné : masque warpé comme le contenu qu'il cache. Cf. commentaires HLSL.
if (layer.mb.z > 0.5)
{
float3 w = quad_inverse(i.local, layer.dst_prev.xy, layer.dst_prev.zw,
layer.src_prev.xy, layer.src_prev.zw, layer.mb.w);
if (w.z < 0.5)
{
return float4(0.0, 0.0, 0.0, 0.0);
}
n = w.xy;
}
float cov = 1.0;
if (layer.fx.z > 0.5)
{
// Ovale inscrit : distance au centre en unités de demi-axes, adoucie sur ~1px. Le
// fondu tombe HORS de l'ellipse : dedans, le masque reste plein.
float2 dd = (n - 0.5) * 2.0;
float r = length(dd);
float 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 float4(0.0, 0.0, 0.0, 0.0);
float3 rgb;
if (layer.fx.x > 0.5)
{
// Flou : un niveau de mip de l'image composée. `log2(rayon)` donne le niveau dont
// un texel couvre à peu près le rayon demandé. Un noyau de quelques taps espacés
// du rayon ne floute PAS, il superpose des copies décalées — du texte fantôme.
float lod = log2(max(layer.fx.y, 1.0));
rgb = texImg.sample(samp, i.pout, level(lod)).rgb;
}
else
{
// Mosaïque : UV quantifié sur une grille de `fx.y` px, alignée sur le quad pour
// que les blocs ne rampent pas quand l'annotation bouge.
float2 px_uv = layer.dst.zw / max(layer.quad_px, float2(1e-6));
float2 block = max(layer.fx.y, 1.0) * px_uv;
float2 origin = layer.dst.xy;
float2 q = origin + (floor((i.pout - origin) / block) + 0.5) * block;
// Niveau 0 explicite : l'UV quantifié est une marche d'escalier, ses dérivées
// explosent en bord de bloc et le choix automatique de mip ramollirait justement
// les arêtes qui font la mosaïque.
rgb = texImg.sample(samp, q, level(0.0)).rgb;
}
if (layer.fx.w > 0.5)
{
rgb = mix(rgb, layer.color.rgb, 0.5);
}
float a = cov * layer.color.a;
return float4(rgb * a, a);
}
// mode 2 : ombre portée (§7 E4). Pénombre douce dérivée de la SDF du quad source,
// qui est inséré à l'intérieur du quad d'ombre (élargi de `spread` de chaque côté).
if (layer.mode > 1.5 && layer.mode < 2.5)
{
float spread = layer.fx.x;
float2 halfsz = layer.quad_px * 0.5 - spread;
float2 p = i.local - layer.quad_px * 0.5;
float d = sd_round_rect(p, halfsz, layer.radius_px);
float a = layer.color.a * (1.0 - smoothstep(0.0, spread, d));
return float4(layer.color.rgb * a, a);
}
float3 rgb;
// 1 sauf en detourage, ou il porte le masque du sujet. Cf. la branche fx.z plus bas.
float alpha_mask = 1.0;
if (layer.mode < 0.5)
{
// flou de mouvement par vélocité (§8)
float2 uv_now = i.uv;
float2 localp = (i.pout - layer.dst_prev.xy) / layer.dst_prev.zw;
float2 uv_prev = layer.src_prev.xy + localp * (layer.src_prev.zw - layer.src_prev.xy);
float2 duv = uv_now - uv_prev;
float mb_scale = saturate(layer.mb.y);
float2 duv_blur = duv * mb_scale;
int taps = int(layer.mb.x);
if (taps <= 1 || mb_scale <= 0.001 || dot(duv_blur, duv_blur) < 1e-9)
{
rgb = sample_yuv(uv_now, texY, texUV);
}
else
{
float3 acc = float3(0.0);
for (int k = 0; k < 16; k++)
{
if (k >= taps) break;
float t = float(k) / float(taps - 1);
acc += sample_yuv(uv_now - duv_blur * (1.0 - t), texY, texUV);
}
rgb = acc / float(taps);
}
// Effet d'arriere-plan webcam. Miroir exact de la branche HLSL : 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.
float effect = layer.fx.z;
if (effect > 0.5)
{
float2 mask_uv = uv_now / max(layer.fx.xy, float2(1e-6));
float person = saturate(texMask.sample(samp, mask_uv).r);
if (effect > 2.5)
{
rgb = mix(layer.color.rgb, rgb, person);
}
else if (effect > 1.5)
{
rgb = mix(blur_webcam_bg(uv_now, layer.fx.w, layer.quad_px, i.local, texY, texUV), rgb, person);
}
else
{
alpha_mask = person;
}
}
}
else
{
rgb = layer.color.rgb;
}
float alpha = layer.color.a * alpha_mask;
if (layer.radius_px > 0.0)
{
// mb.w = 1 : écran sous le chrome de fenêtre, coins HAUTS carrés et rognés par l'arc du
// cadre (`sd_screen_under_bar`, `mb.z` = la remontée du contour intérieur, px).
float2 halfsz = layer.quad_px * 0.5;
float2 p = i.local - layer.quad_px * 0.5;
// Une branche et non `?:`, pour ne jamais évaluer les DEUX distances : trois SDF par pixel
// de l'écran au lieu d'une, 0,6 ms par frame 1080p sur une Radeon 610M (mesuré en WGSL).
float d;
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 float4(rgb * alpha, alpha);
}
// =================================================================================
// Fullscreen pass : RGB -> NV12. Mêmes shaders que la passe équivalente HLSL.
// =================================================================================
struct FSOut
{
float4 pos [[position]];
float2 uv [[user(TEXCOORD0)]];
};
vertex FSOut vs_fs(uint vid [[vertex_id]])
{
FSOut o;
o.uv = float2((vid << 1) & 2, vid & 2);
o.pos = float4(o.uv * float2(2, -2) + float2(-1, 1), 0, 1);
return o;
}
inline float rgb2y(float3 c) { return (16.0 + 219.0 * (0.2126*c.r + 0.7152*c.g + 0.0722*c.b)) / 255.0; }
inline float2 rgb2uv(float3 c)
{
float yp = 0.2126*c.r + 0.7152*c.g + 0.0722*c.b;
float cb = (c.b - yp) / 1.8556;
float cr = (c.r - yp) / 1.5748;
return float2(128.0 + 224.0 * cb, 128.0 + 224.0 * cr) / 255.0;
}
fragment float ps_y(FSOut i [[stage_in]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
return rgb2y(rgbTex.sample(sampNV, i.uv).rgb);
}
fragment float2 ps_uv(FSOut i [[stage_in]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
return rgb2uv(rgbTex.sample(sampNV, i.uv).rgb);
}
// =================================================================================
// Flou gaussien séparable (§7 E3) — shader conservé pour référence, le port actif
// utilise `ps_kawase_down/up` (cf. commit « Kawase » plus loin si on revient).
// =================================================================================
// Une variable de portée programme doit vivre dans `constant` en MSL.
constant int BLUR_R = 24;
fragment float4 ps_blur(FSOut i [[stage_in]],
constant Layer &layer [[buffer(0)]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
float sigma = max(layer.fx.x, 0.001);
float2 step = layer.fx.y * layer.fx.zw;
float4 acc = float4(0.0);
float wsum = 0.0;
for (int k = -BLUR_R; k <= BLUR_R; k++)
{
float w = exp(-0.5 * float(k * k) / (sigma * sigma));
acc += rgbTex.sample(sampNV, i.uv + float(k) * step) * w;
wsum += w;
}
return acc / wsum;
}
fragment float4 ps_tex(FSOut i [[stage_in]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
return rgbTex.sample(sampNV, i.uv);
}
// =================================================================================
// Dual-Kawase (fond flouté rapide).
// =================================================================================
fragment float4 ps_kawase_down(FSOut i [[stage_in]],
constant Layer &layer [[buffer(0)]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
float2 hp = layer.fx.xy * 0.5 * layer.fx.z;
float2 uv = i.uv;
float4 s = rgbTex.sample(sampNV, uv) * 4.0;
s += rgbTex.sample(sampNV, uv - hp);
s += rgbTex.sample(sampNV, uv + hp);
s += rgbTex.sample(sampNV, uv + float2(hp.x, -hp.y));
s += rgbTex.sample(sampNV, uv - float2(hp.x, -hp.y));
return s / 8.0;
}
// Poids 1,2,1,2,1,2,1,2 — somme 12, d'où le `/ 12.0`. Le port avait doublé les deux taps
// purement verticaux : somme 14 divisée par 12, soit +16,7 % de luminosité PAR PASSE et un
// biais vertical. Trois passes UP → un fond flouté 1,59× trop clair et étiré.
fragment float4 ps_kawase_up(FSOut i [[stage_in]],
constant Layer &layer [[buffer(0)]],
texture2d<float, access::sample> rgbTex [[texture(0)]])
{
float2 hp = layer.fx.xy * 0.5 * layer.fx.z;
float2 uv = i.uv;
float4 s = rgbTex.sample(sampNV, uv + float2(-hp.x * 2.0, 0.0));
s += rgbTex.sample(sampNV, uv + float2(-hp.x, hp.y)) * 2.0;
s += rgbTex.sample(sampNV, uv + float2(0.0, hp.y * 2.0));
s += rgbTex.sample(sampNV, uv + float2(hp.x, hp.y)) * 2.0;
s += rgbTex.sample(sampNV, uv + float2(hp.x * 2.0, 0.0));
s += rgbTex.sample(sampNV, uv + float2(hp.x, -hp.y)) * 2.0;
s += rgbTex.sample(sampNV, uv + float2(0.0, -hp.y * 2.0));
s += rgbTex.sample(sampNV, uv + float2(-hp.x, -hp.y)) * 2.0;
return s / 12.0;
}