Implémentation Liquid Glass
0. Le chemin le plus rapide (10 minutes pour obtenir un verre fonctionnel)
N'écrivez pas un shader à partir de zéro. Partir de zéro pour écrire 400 lignes de GLSL a très peu de chances de réussir ; la plupart des échecs "ça ne ressemble à rien" viennent de là.
- Copiez
starter/glass-starter.htmldans le répertoire de livraison. - Modifiez uniquement les cinq nombres du
CONFIGen haut du fichier (refract / mag / rim / disp / tint), puis rafraîchissez immédiatement pour voir les changements. - Remplacez le contenu dessiné par
drawBG()par le contenu souhaité par l'utilisateur. C'est l'étape la plus cruciale : 90% de l'effet verre provient de ce qui se trouve en dessous. - Ajustez la largeur, la hauteur et le rayon des coins du
PANELpour définir la forme du verre (r = h/2 donne une capsule complète). - Pour ajouter d'autres verres, dupliquez le rectangle et dessinez-le dans une boucle avec
uRect(voir l'architecture à la section 3).
Le starter ne contient qu'environ 90 lignes de shader, 1 programme, 1 draw, et inclut déjà : la réfraction de Snell, le déplacement latéral pondéré par l'épaisseur, le bord Fresnel, l'opalescence des bords, la bande lumineuse supérieure, l'arc lumineux inférieur, la dispersion RVB, la lèvre de lentille et le retour de pression. Il a été testé et vérifié avec une capture d'écran sous Chrome (y compris le rendu logiciel SwiftShader).
Pour voir le résultat directement : ouvrez starter/glass-starter.html dans un navigateur, faites glisser la souris sur le verre et observez la barre bleue se déplacer et s'agrandir.
0.5 Trois règles strictes
-
Vous DEVEZ ouvrir le fichier et vérifier avant de livrer. Livrer sans ouvrir, en se fiant uniquement au code, est la première cause d'échec de ce skill. En l'absence d'interface graphique, utilisez une capture d'écran headless :
chrome --headless=new --enable-unsafe-swiftshader --virtual-time-budget=5000 ^ --window-size=820,700 --screenshot=out.png "file:///<chemin absolu>"Ensuite, examinez réellement l'image pour confirmer que le verre apparaît. Sans preuve de capture d'écran, ne prétendez pas que c'est terminé.
-
Les erreurs du shader doivent être affichées sur la page.
console.errorn'est pas visible dans une capture d'écran ; vous ne verrez qu'un écran noir sans comprendre pourquoi. Immédiatement aprèscompileShader:if (!gl.getShaderParameter(s, gl.COMPILE_STATUS)) appendPre("échec de la compilation du shader :\n" + gl.getShaderInfoLog(s)); // appendPre = insère un <pre> rouge dans le body -
Commencez petit, puis ajoutez. Faites d'abord fonctionner un seul verre correctement, puis ajoutez le second. En combinant réfraction + interaction + multiples panneaux + animation dès le départ, il est impossible de localiser l'erreur.
0.6 Ça ne ressemble à rien ? Vérifiez selon les symptômes
| Symptôme | Cause la plus probable | Correction |
|---|---|---|
| Écran entièrement noir, seul l'arrière-plan est visible | Le panneau n'est pas dessiné du tout | Vérifiez que uRect est transmis, que uRad n'est pas 0, et que le draw utilise 4 sommets en TRIANGLE_STRIP |
| Image miroir / texte inversé dans le verre | L'axe Y de la texture est inversé | Si UNPACK_FLIP_Y est activé, échantillonnez avec 1.0 - uv.y ; sinon, utilisez uv.y directement |
| Pas de réfraction visible, juste un flou | Le déplacement est trop faible | off = lat * tpx * refract, vérifiez d'abord que tpx fait plusieurs dizaines de pixels ; mettez temporairement refract à 3 pour voir un changement |
| Bande arc-en-ciel dure sur le pourtour | La dispersion recouvre tout le bord | Multipliez la dispersion par eW*eW (atténuation au carré) pour ne séparer les canaux que sur le bord le plus extérieur |
| Le verre ressemble à du plastique gris | Le contenu en dessous est trop monotone | Le dessous doit avoir un contraste élevé (texte, bandes colorées, grille), sinon, quels que soient les paramètres, cela ressemblera à du brouillard |
| Le point lumineux en haut suit la souris comme une lampe torche | La bande lumineuse est rétrécie latéralement | Conservez une luminosité de base sur toute la bande supérieure, le pointeur ne fait que l'augmenter localement (0,7 de base + 0,3 de gain) |
| L'animation est molle et sans énergie | Utilisation d'une interpolation exponentielle du premier ordre | Remplacez par un ressort du second ordre, amortissement 0,6 |
| Le framerate chute en dessous de 30 fps | Trop de panneaux / draw plein écran à chaque frame | Ne rasterisez que la AABB de chaque verre ; ≤ 10 panneaux simultanés ; réduisez la fréquence d'upload de l'arrière-plan |
Pour la version flagship (multi-panneaux, interactions complètes, analyse du chemin lumineux), continuez à lire ; pour un simple verre, le starter suffit, lisez jusqu'à la section 4.
1. Décision de plateforme
| Cible | Ressource à utiliser | Description |
|---|---|---|
| Verre unique / pour aller vite | starter/glass-starter.html | 90 lignes de shader, 1 draw, testé et vérifié. Partez de ce fichier, n'écrivez pas à partir de zéro |
| Web / Démo / Prototype interactif (recommandé) | liquid-glass-studio.html | Un seul canvas WebGL + 9 verres + interactions complètes + analyse en temps réel du chemin lumineux. Réfraction de Snell réelle, dispersion, gradient d'épaisseur |
| Juste un verre, sans tracas | liquid-glass-webgl.html | Version légère à panneau unique et passe unique, déplacement approximatif, sans couche d'interaction |
| Impossible d'utiliser WebGL / besoin d'un repli | liquid-glass-css.html | backdrop-filter + déplacement SVG, comportement approximatif mais sans réfraction pixel par pixel |
| C++ de bureau / rendu personnalisé | cpp/glass_math.h + cpp/qt6/ | Librairie mathématique pure + contrôles Qt6 ; en production, intégrez les formules dans le GLSL |
| iOS / macOS natif | swift/LiquidGlassDemo.swift | API officielle .glassEffect ; pour les versions plus anciennes, utilisez SimulatedGlass comme repli |
Pourquoi WebGL est prioritaire : la réfraction doit échantillonner le contenu inférieur pixel par pixel ; le CSS ne peut que déplacer des blocs entiers et ne peut pas produire la "lèvre de lentille" sur les bords.
2. Ressources et documentation
liquid-glass/
├── starter/
│ └── glass-starter.html # Squelette minimal fonctionnel : 90 lignes de shader, 1 program 1 draw, testé et vérifié
├── liquid-glass-studio.html # Flagship : interactions complètes + chemin lumineux en temps réel (livraison principale de ce skill)
├── liquid-glass-webgl.html # Version légère à panneau unique
├── liquid-glass-css.html # Repli CSS/SVG
├── cpp/
│ ├── glass_math.h # Fonctions pures pour SDF, squircle, Snell/Fresnel, dispersion BK7, épaisseur/lèvre/arc rim
│ └── qt6/ # Projet CMake
├── swift/LiquidGlassDemo.swift # API officielle + repli simulé
└── references/
├── feature-matrix.md # Matrice des 22 fonctionnalités de la Session 219, couverture par plateforme, lignes rouges de conception
├── optics-model.md # Modèle physique du chemin lumineux et plages de paramètres (À LIRE avant d'écrire le shader)
├── interaction-playbook.md # Machine à états pour cliquer/développer/séparer/glisser + checklist de validation
└── swiftui-api.md # Signatures et notes de l'API SwiftUI pour le verre
3. Architecture de rendu (version studio)
Deux programmes, 9 draw calls. Ne mettez JAMAIS plusieurs verres dans un tableau d'uniforms d'une passe plein écran.
Pass 1 pBg : quad plein écran, échantillonne directement la texture d'arrière-plan
Pass 2 pGl : même VBO de quad, chaque verre est translaté/redimensionné à sa propre AABB, un seul drawArrays
Le vertex shader mappe le quad [-1,1] sur le panneau :
uniform vec2 uC, uH, uRes; // centre, demi-largeur/hauteur, taille du canvas (en pixels réels)
void main(){
vec2 cN = (uC/uRes)*2.0 - 1.0; cN.y = -cN.y; // origine haut-gauche écran → NDC
vec2 hN = ((uH + vec2(6.0))/uRes)*2.0; // extension de 6px pour l'anti-aliasing
gl_Position = vec4(cN + vec2(aPos.x, -aPos.y)*hN, 0.0, 1.0);
}
Le fragment shader utilise gl_FragCoord pour retrouver les coordonnées écran (pas un varying, car le varying est en coordonnées locales dans le quad translaté) :
vec2 px = vec2(gl_FragCoord.x, uRes.y - gl_FragCoord.y);
float d = sdRoundBox(px - uC, uH, uRad);
float aa = smoothstep(-1.0, 1.4, d);
if(aa > 0.995) discard; // pixels en dehors du contour de la AABB sont rejetés
gl_FragColor = vec4(gcol, 1.0 - aa); // transition alpha sur le bord
Activez gl.enable(BLEND) + blendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA) en dehors, puis désactivez après.
Ainsi, chaque verre ne rasterise que son propre rectangle ; 8 verres ont un taux de remplissage équivalent à un seul plein écran, soit un ordre de grandeur plus rapide qu'un "plein écran × 8 passages en boucle".
Pour un verre, les uniformes scalaires à définir par draw (ordre fixe, tous requis) :
| uniform | Signification | Source |
|---|---|---|
uC uH | Centre écran / demi-largeur-hauteur (pixels réels, origine haut-gauche) | (g.x+g.w/2)*dpr etc. |
uRad | Rayon des coins (pixels réels) | min(g.radius, min(w,h)/2)*dpr |
uVariant uThick uMagMul | Variante / matériau épais / facteur d'agrandissement par panneau | Propriétés du panneau |
uHover uPress uGlow uActive | État d'interaction 0~1 | Valeurs de ressort par frame |
uPtr | Coordonnée normalisée du pointeur dans le panneau, de -1 à 1 | (cx-c)/(w/2) |
uAmb | Couleur ambiante de la couche inférieure (rgb) | Échantillonnage getImageData |
| Globaux | uRes uTex uRefraction uRim uTint uDisp uN uMode uContrast uOpaque uMag uWire | Définis une fois par frame |
4. Modèle du chemin lumineux (À LIRE avant d'écrire le shader)
Sept étapes, l'ordre est immuable :
- Contour :
sdRoundBoxpour obtenir la distance signéed(négatif à l'intérieur). Profondeur normaliséex = clamp(-d/band, 0, 1),0 = contour,1 = centre;band = max(5, min(hx,hy)*0.30). - Champ de hauteur convexe :
H(x) = sqrt(1 - (1-x)²),H'(x) = v/sqrt(1-v²)(v = clamp(1-x, 0.02, 0.9995)). Utilisezsqrt, paspow—powest beaucoup plus lent sous ANGLE. - Angle d'incidence :
sinI = min(H'/sqrt(1+H'²), 0.62),thI = asin(sinI),thT = asin(sinI/n),n = 1.5168(BK7). La limite de 0.62 est une contrainte dure : si vous la montez à 0.93, le déplacement des bords atteindra 200 pixels, et le panneau entier sera poussé vers un bloc noir. - Épaisseur :
tpx = mdim*(0.05 + 0.28*H)*(1 + 0.40*thick)*vg,vg = 1 + 0.24*(1 - smoothstep(-0.85, 0.35, q.y))(plus épais en bas, plus fin en haut).tpxest "l'épaisseur en pixels". Plage normale :0.1 ~ 0.4 * mdim. Au-delà de 0.5, il y aura forcément une distorsion. - Déplacement :
lat = tan(thI-thT),off = -dir*lat*tpx*uRefraction*Tf, plus un terme de bord supplémentaire-dir*(1-smoothstep(0,0.28,x))*tpx*0.22. Enfin,off = clamp(off, -10, 10)— le clamp est la seule protection contre le fait que le bord "tire" le contenu éloigné vers l'intérieur. - Foyer / Lèvre de lentille :
focal = uMag * uMagMul * (0.50*cW - 0.40*eW),cW = smoothstep(0.10,0.90,x),eW = 1-smoothstep(0,0.62,x). Au centre,focal > 0→ le point d'échantillonnage se rapproche du centre → agrandissement ; sur le bord,focal < 0→ le point d'échantillonnage s'éloigne → le contenu est dévié vers l'extérieur, c'est la lèvre d'Apple.1-focaldoit toujours être positif, sinon il y a un retournement local de 180°, donnant un texte inversé.uMagMulest le facteur d'agrandissement par panneau (voir section 6) : un petit verre a une courbure plus forte et agrandit plus, une grande plaque est presque plane et agrandit moins. Sans ce coefficient, le mêmeuMagtransformerait une plaque de texte de 214×300 en charabia agrandi, tandis qu'une lentille de 158×126 ne serait pas assez grossissante. Correspondance taille du panneau etmagMul:lens 1.30,plate 0.55,capsule 0.85,panel 0.60,dock 0.80,nav 0.90. - Échantillonnage et composition :
sp = c + rel*(1-focal) - off; séparez les trois canaux avec±uDisp*7*eWpour la dispersion RVB ; puis appliquez dans l'ordre : assombrissement parvariant, débordement de couleur ambianteuAmbà 0.10, compression de la luminance de la teinte0.58*L + 0.133, compensation des zones sombres+vec3(0.048,0.051,0.058), Fresnel rim + opalescence + spéculaire supérieur + arc lumineux inférieur ((1+0.75*press)), et lueur interne.
Les coordonnées de texture DOIVENT être inversées en Y
Lors du transfert du canvas d'arrière-plan, si UNPACK_FLIP_Y_WEBGL = true est activé, la texture v=0 correspond au bas de l'écran ; alors que px a son origine en haut à gauche. Donc :
vec2 uv0 = vec2(sp.x/uRes.x, 1.0 - sp.y/uRes.y); // Sans cette ligne, tout le verre échantillonnerait une image miroir
Ce n'est pas optionnel. Le symptôme est l'apparition de texte inversé verticalement dans le verre, et le contenu provient du côté opposé de l'image.
5. Analyse en temps réel du chemin lumineux
Deux approches, non substituables :
A. Champ de diagnostic (params.wire = 1) — Affiche directement les grandeurs intermédiaires du shader pour savoir "s'il y a vraiment de la réfraction" :
| Canal | Signification | Lecture |
|---|---|---|
| R | length(off)/mdim*22 | Rouge = intensité de la déviation. Le centre doit être presque noir, le pourtour rouge |
| G | x (profondeur du bord) | Anneau vert collé au contour, retourne rapidement à zéro vers l'intérieur |
| B | focal*2 | Bleu = facteur d'agrandissement, clair au centre, foncé sur le bord |
Si les trois apparaissent ensemble et que les zones sont bien distinctes, le chemin lumineux est correct ; un écran entièrement noir indique généralement que les uniformes n'ont pas été transmis (voir piège 1, section 7).
B. Diagramme de chemin lumineux en coupe (canvas 308×150 en bas à droite) — Dessine 11 rayons lumineux traversant le verre convexe (incidence, intérieur, émergence), avec annotation pour les rayons de bord : θi / θt / Δx et la plage d'épaisseur (thin/thick). Le panneau de mise au point change au survol du pointeur.
Les deux courbes (shader et diagramme 2D) DOIVENT utiliser les mêmes formules et la même limite sinI, sinon le diagramme affichera 68° alors que l'écran calcule avec 38°, ce qui induit en erreur lors du réglage des paramètres.
6. Recettes de paramètres (à ajuster avec l'image de référence)
| Effet recherché | refract | mag | rim | disp | tint | thick |
|---|---|---|---|---|---|---|
| Capsule en verre épais (gros, bords lumineux, arc inférieur marqué, intérieur sombre et translucide) | 1.20 | 0.35 | 0.95 | 0.22 | 0.24 | ✓ |
| Lentille sur bandes colorées (bandes agrandies et déplacées, points lumineux à gauche et à droite) | 1.50 | 0.60 | 1.00 | 0.18 | 0.10 | ✓ |
| Verre épais sur petit texte (texte agrandi + distorsion des bords) | 1.25 | 0.42 | 0.80 | 0.30 | 0.16 | ✓ |
| Barre de navigation supérieure (fine, discrète) | 0.90 | 0.20 | 0.60 | 0.15 | 0.10 | ✗ |
| Panneau de contrôle (grand, lisible) | 1.00 | 0.15 | 0.55 | 0.12 | 0.14 | ✗ |
| Défaut (0) | 1.20 | 0.45 | 0.85 | 0.35 | 0.20 | — |
Ordre de réglage : refract d'abord pour l'amplitude du déplacement → mag pour la force de la lèvre → rim pour la luminosité des bords → disp/tint en dernier pour la texture. Si vous inversez, vous tournerez en rond.
Trois recettes en un clic (intégré dans la version studio)
En haut du panneau de contrôle, quatre boutons « Capsule épaisse / Lentille / Texte / Défaut ». Un clic effectue deux actions : il positionne les cinq curseurs selon le tableau ci-dessus, et il déclenche une flash de lueur interne sur le panneau correspondant (pour attirer l'œil "regarde ici").
var PRESETS = {
capsule: { refract:1.20, mag:0.35, rim:0.95, disp:0.22, tint:0.24, focus:"capsule" },
lens: { refract:1.50, mag:0.60, rim:1.00, disp:0.18, tint:0.10, focus:"lens" },
text: { refract:1.25, mag:0.42, rim:0.80, disp:0.30, tint:0.16, focus:"plate" },
reset: { refract:1.20, mag:0.45, rim:0.85, disp:0.35, tint:0.20, focus:null }
};
Changer params par programme ne déclenche pas l'événement input des curseurs. Vous devez donc appeler syncUI() manuellement pour mettre à jour la position et l'étiquette numérique des curseurs, sinon ils seront déconnectés des paramètres réels.
La décroissance du flash est écrite dans step() et fusionnée dans glow (pas une substitution, sinon la lueur maintenue serait écrasée par le flash) :
if(g.flash > 0.002) g.flash *= 0.90; else g.flash = 0;
var gl = Math.max(g.active ? 1 : 0, g.flash*0.85);
g.glow += (gl - g.glow)*k;
6.5 Quatre détails Apple les plus souvent oubliés
Ces trois éléments apparaissent dans la Session 219, mais sont très faciles à négliger dans la démo ; sans eux, le rendu "verre" perd instantanément en qualité.
① Le point lumineux supérieur suit le pointeur (le spéculaire se déplace, mais ne doit pas courir après le pointeur)
Une ligne lumineuse fixe en haut est un "autocollant" ; mais faire en sorte que le point lumineux s'atténue de part et d'autre du pointeur le transforme en lampe torche qui balaie le verre — c'est l'erreur la plus fréquente. La bonne méthode : la bande supérieure entière est toujours lumineuse, le pointeur ne fait qu'un renforcement local.
float tx = q.x - uPtr.x*0.30; // Le décalage du pointeur doit être petit (0.3, pas 0.55)
float baseTop = 1.0 - smoothstep(-0.92, -0.30, q.y); // Luminosité de base de toute la bande
float boostTop = 1.0 - smoothstep(0.12, 1.00, abs(tx)); // Gain supplémentaire au niveau du pointeur
float topW = baseTop * (0.70 + 0.30*boostTop); // Minimum 0.70, maximum 1.0
Comparez l'écriture erronée et ses conséquences :
| Écriture | Résultat |
|---|---|
smoothstep(-0.30,-0.92,q.y) * (1-smoothstep(0.06,0.72,abs(tx))) | Quand le pointeur bouge, seule une petite section reste lumineuse, le reste est noir → effet lampe torche |
baseTop * (0.70 + 0.30*boostTop) | Le bord reste connecté en une ligne continue, légèrement plus lumineux au niveau du pointeur → vrai aspect de miroir |
De plus, n'utilisez pas de smoothstep inversé : smoothstep(1.0, -1.0, d) et smoothstep(-0.30, -0.92, x) avec edge0 > edge1 sont des comportements non définis selon la spécification GLSL, et peuvent échouer sur certaines implémentations. Utilisez systématiquement 1.0 - smoothstep(petit, grand, x).
Le spéculaire ponctuel dans la direction du pointeur (spec calculé par dot(dir, pdir)) ne doit être renforcé que lors de l'appui ; en survol, il ne doit pas être ajouté. Sinon, en glissant la souris, il y aura un petit point lumineux qui suit le bord.
② La lueur interne se propage aux verres voisins (environ 12%) Lorsque A est pressé, le verre adjacent B s'illumine aussi légèrement, donnant l'impression que la lumière circule entre les verres.
var maxGlow = 0;
G.forEach(g => { if(g.glow > maxGlow) maxGlow = g.glow; });
if(maxGlow > 0.02)
G.forEach(g => { if(!g.active) g.glow = Math.max(g.glow, maxGlow*0.12); });
Ne dépassez pas 0.15, sinon l'écran entier s'illumine, brisant la ligne rouge de la "lueur discrète".
③ Effet de fondu des bords lors du défilement (Scroll edge effect) Le contenu derrière le verre, lorsqu'il défile jusqu'au bord, doit "se fondre" dans l'arrière-plan, sans ligne de démarcation dure. Utilisez un masque alpha, et uniquement lorsqu'il reste du contenu :
var st = el.scrollTop;
var rest = el.scrollHeight - el.clientHeight - st;
var top = st > 3 ? 28 : 0; // Pas de masque si le défilement est en haut, sinon une fausse ombre persiste
var bot = rest > 3 ? 28 : 0;
el.style.webkitMaskImage =
"linear-gradient(to bottom, rgba(0,0,0,0) 0px, #000 "+top+"px, " +
"#000 calc(100% - "+bot+"px), rgba(0,0,0,0) 100%)";
Point important : le mask lit le canal alpha ; utilisez rgba(0,0,0,0) plutôt que transparent (dans certaines anciennes implémentations, transparent est un noir transparent, le comportement est identique mais la sémantique est plus claire). Le conteneur de défilement doit lui-même avoir pointer-events:auto, sinon il ne défile pas ; mais attention, cela empêche le verre entier de recevoir le glissement : les verres qui nécessitent un glissement ne doivent pas être remplis par le conteneur de défilement.
④ Séparation / Fusion : ça doit "rebondir", pas "glisser"
L'interpolation exponentielle du premier ordre x += (tx - x)*0.19 ne dépasse jamais et s'arrête toujours mollement. Remplacez-la par un ressort du second ordre :
// dt = 1/60 à chaque frame
g.vx += ((g.tx - g.x)*omX*omX - 2*z*omX*g.vx)*dt;
g.x += g.vx*dt;
g.vw += ((g.tw - g.w)*omW*omW - 2*z*omW*g.vw)*dt;
g.w += g.vw*dt;
if (g.w < 0){ g.w = 0; g.vw = 0; } // Si la largeur devient négative en se rétrécissant, le dessin est erroné
omX = 15, omW = 18.5, z = 0.66 → environ 6% de dépassement, période ~0.45s. La raideur en largeur doit être supérieure à celle en position (18.5 > 15), pour obtenir "d'abord une déformation, puis un retour à la position" ; si elles sont identiques, le bloc se translate en entier, ce qui donne l'impression d'une plaque de bois.
Deux éléments essentiels pour que la séparation ne ressemble pas à "deux plaques poussées l'une contre l'autre" :
- La position de la partie droite est fixe (
txest toujourslay.x + lay.w - largeur d'une partie). Seule la largeur varie entre 0 et 140 → visuellement, c'est "une fissure au milieu", pas "un rétrécissement et un allongement, une traction horizontale". - Au moment de la séparation / réunification, donnez un
flash = 1de lueur interne à chaque partie pour marquer le mouvement.
Quelle que soit la valeur du coefficient d'interpolation du premier ordre, vous n'obtiendrez jamais de rebond : c'est une question de forme de courbe, pas de vitesse.
7. Huit pièges inévitables (testés localement)
-
Les tableaux d'uniforms ne sont pas fiables.
uniform vec4 uGeo[12]renvoie ungetUniformLocation("uGeo[0]")non nul sous ANGLE/D3D,uniform4fvne génère pas d'erreur, mais les données n'atteignent pas le shader — tous les panneaux lisent 0, et sont tous ignorés parif(hh.x < 1.5) continue, ne laissant que l'arrière-plan sombre. Conclusion : n'utilisez JAMAIS de tableau d'uniforms pour transmettre la géométrie de plusieurs panneaux, préférez un draw call par panneau. -
Les boucles + branches uniformes peuvent être optimisées entièrement. Écrire
if(uOpaque > 0.5){...}dans une boucleforpeut entraîner la suppression du corps de la boucle sur certains pilotes. Dans une boucle, utilisez systématiquementmix/stepsans branche. Si c'est "un draw par panneau", il n'y a même pas de boucle. -
Un uniform déclaré mais inutilisé est optimisé,
getUniformLocationrenvoie null, ce qui donne une fausse alerte "uniform manquant". La déclaration et l'utilisation doivent aller de pair. -
gl.getUniform(prog, null)lève une TypeError, ce qui ignore tout le code suivant de la même frame (FPS, sondes ne sont pas mis à jour), donnant l'impression que la page est bloquée. Vérifiez toujours que le location n'est pas null avant de l'utiliser. -
Axe Y de la texture (voir section 4) : sans inversion, vous obtenez une image miroir + un texte inversé.
-
N'attachez que
clickcar vous perdrez des événements. Dans les environnements automatisés ou certains hôtes,clickn'est pas synthétisé, laissant toutes les interactions muettes. Utilisezpointerdown + pointerup + seuil de déplacementpour détecter un clic, etclickuniquement en complément. -
halfest un mot réservé en GLSL ES : écrirevec2 half = uRect.zw*0.5;fait échouer la compilation du shader entier, et le journal ne mentionne qu'unesyntax error, rendant le diagnostic très difficile. Utilisezhbpour demi-largeur/hauteur. Autres mots dangereux :filter,input,output,long,short,double,packed. -
Un smoothstep inversé est un comportement non défini :
smoothstep(1.0, -1.0, d),smoothstep(-0.30, -0.92, y)avec edge0 > edge1 peut fonctionner sur le navigateur de test, mais donner des valeurs aléatoires sur un autre. Réécrivez systématiquement en1.0 - smoothstep(-1.0, 1.0, d).
8. Checklist de validation (à exécuter après chaque modification)
Rendu
- Les 8 verres sont tous visibles, leurs positions correspondent au tableau de layout
- On voit le contenu inférieur à travers le verre (texte/barres bleues/grille), ce n'est pas un bloc de couleur unie
- Le contenu dans le verre est orienté correctement (pas d'inversion verticale, pas d'image miroir horizontale)
- Le pourtour a un rim lumineux, le haut a un spéculaire de miroir, le bas a un arc lumineux
- À l'intérieur du verre sur fond sombre, ce n'est pas complètement noir (il y a un léger gris brumeux)
- L'anti-aliasing des contours est propre, sans bord dur ni bord blanc
Interactions (version détaillée dans references/interaction-playbook.md)
- Clic sur la capsule → le menu pousse vers le haut, le bord inférieur reste fixe ; un nouveau clic le rétracte
- Glissement de la capsule → elle suit, relâchement → retour élastique ; bloquée au bord
- Clic sur le bouton de séparation du Dock → les deux parties s'écartent ; nouveau clic → elles se referment
- Maintien sur n'importe quel panneau → léger retrait + lueur interne ; relâchement → retour à zéro
- Survol → le spéculaire se déplace vers le pointeur
- Les touches clavier Espace / S / W ont l'effet attendu
- Clic sur les quatre boutons « Capsule épaisse / Lentille / Texte / Défaut » : la position et les valeurs des cinq curseurs changent de manière synchronisée, le panneau cible clignote avec une lueur interne
- Après un redimensionnement, les états de déploiement et de séparation sont conservés
Performances
- Le
FPSest stable, sans chute périodique de framerate - Après modification du nombre de panneaux, réévaluez le nombre de draw calls
9. Budget de performance et dégradation
| Élément | Budget | Que faire si dépassé |
|---|---|---|
| Panneaux de verre simultanés | ≤ 10 | Fusionnez-les en un seul, ou rétrogradez les panneaux secondaires vers le repli CSS |
| Surface couverte par chaque draw | Seulement sa propre AABB | Ne lancez pas la passe de verre en plein écran |
| Transfert de la texture d'arrière-plan | Toutes les 5 frames (les taches sont lentes) | En statique, réduisez à toutes les 8 frames |
| Ratio de pixels d'arrière-plan | min(dpr, 1.5) | Si chute de fps, passez à 1.0 |
| Facteur de rendu | Adaptatif 0.72 / 1.0 | Passez en dessous si < 42fps, remontez si > 56fps |
Échantillonnage de la luminosité inférieure getImageData | Toutes les 10 frames, uniquement pour les panneaux w*h > 24000 | C'est la plus grande surcharge synchrone, réduisez la fréquence |
| Diagramme en coupe du chemin lumineux | Toutes les 4 frames | En statique, réduisez à toutes les 6 frames |
| Hauteur du panneau de contrôle | min(520, VH*0.62, VH-250) | Laissez 240 px pour le diagramme de chemin lumineux en bas à droite, sinon il y aura superposition sur les petites fenêtres |
Ordre de dégradation : Réduisez le nombre de panneaux → Réduisez le facteur de rendu → Réduisez la fréquence de transfert de l'arrière-plan → Désactivez la dispersion → Passez à la version CSS.
10. Lignes rouges de conception (Apple HIG)
- Le verre s'utilise uniquement sur le calque de navigation : le calque de contenu ne doit pas être recouvert de verre.
- Pas de superposition de verre : si deux verres se chevauchent, la référence de réfraction est perdue et cela ressemble à des taches sales.
- Ne mélangez pas les variantes : dans un même écran, ne mélangez pas Regular et Clear.
- La teinte (tint) est réservée à l'action principale, et doit être de petite surface ; une coloration complète n'est plus du verre.
- Les reflets sont discrets : le rim est un "contour", pas une "bande blanche entière".
uRim > 1.2donne un aspect artificiel. - Trois options d'accessibilité doivent être conservées : réduction de la transparence, augmentation du contraste, réduction des mouvements. La première remplace le contenu d'arrière-plan par un fond opaque, la troisième fixe le ressort
kà 1. - Lorsque du texte est superposé au verre, le contenu DOM doit avoir une
text-shadow, sinon le texte blanc sur un verre lumineux est illisible.
11. Migration vers C++ / SwiftUI
- C++ :
cpp/glass_math.hcontient les mêmes fonctions puresH(x),H'(x),fres(), de gradient d'épaisseur, de lèvre et d'arc rim ; intégrez-les directement dans le fragment shader. L'exemple Qt6 ne montre que la forme de l'interface ; en production, n'utilisez pas le CPU pixel par pixel. - SwiftUI : privilégiez
.glassEffect(.regular, in: shape)en utilisant l'implémentation système. UtilisezSimulatedGlassuniquement pour les formes personnalisées ou les réfractions personnalisées, et documentez dans un commentaire les différences avec l'effet système (la version système bénéficie d'un échantillonnage d'arrière-plan inter-processus et d'un spéculaire dynamique réaliste).