Communitygithub.com

liquid-glass

Implémentez le matériau Liquid Glass (verre liquide) d'Apple WWDC25, ses contrôles et toutes ses interactions. Idéal pour recréer des UI en verre liquide / verre morphique, des boutons, cartes, barres de navigation, Dock, menus en verre liquide Apple, avec transparence réfractive, clic, développement, séparation, fusion, glissement, retour de pression, ou encore analyse en temps réel du chemin lumineux, sur Web (WebGL/CSS), C++/Qt6 et SwiftUI.

Qu'est-ce que liquid-glass ?

Liquid Glass est un skill spécialisé dans la reproduction du nouveau matériau "Liquid Glass" (verre liquide) introduit par Apple lors de la WWDC25. Il fournit une implémentation complète du rendu WebGL, y compris la réfraction de Snell, le déplacement latéral pondéré par l'épaisseur, le bord Fresnel, la dispersion RVB, le gradient d'épaisseur, la lèvre de lentille, la lueur interne, les variantes Regular/Clear, l'adaptation à la lumière/obscurité, l'estompage des bords de défilement, et une architecture de performances avec des appels de draw indépendants pour chaque panneau. Le skill inclut un fichier de démarrage minimaliste (`starter/glass-starter.html`) de 90 lignes de shader, un seul programme et un seul draw, déjà testé et validé. Il contient aussi un fichier studio complet (`liquid-glass-studio.html`) avec neuf panneaux interactifs, une analyse en temps réel du chemin lumineux, et des recettes de paramètres. Enfin, il offre des solutions de repli : CSS/SVG pour les environnements sans WebGL, C++/Qt6 pour les applications de bureau natives, et SwiftUI avec l'API système `glassEffect` ou une émulation `SimulatedGlass`. Les plateformes cibles sont Web (WebGL/CSS), C++/Qt6 et SwiftUI. Le skill insiste sur la nécessité de partir du fichier starter, de suivre un modèle optique précis en 7 étapes, et d'éviter les pièges courants comme les tableaux d'uniformes, le Y inversé des textures, ou les boucles avec branches conditionnelles optimisées de manière incorrecte. Il fournit également une checklist de validation rigoureuse pour la qualité du rendu, des interactions et des performances.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Cyt-56/liquid-glass-webgl/tree/main/legacy

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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à.

  1. Copiez starter/glass-starter.html dans le répertoire de livraison.
  2. Modifiez uniquement les cinq nombres du CONFIG en haut du fichier (refract / mag / rim / disp / tint), puis rafraîchissez immédiatement pour voir les changements.
  3. 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.
  4. Ajustez la largeur, la hauteur et le rayon des coins du PANEL pour définir la forme du verre (r = h/2 donne une capsule complète).
  5. 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

  1. 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é.

  2. Les erreurs du shader doivent être affichées sur la page. console.error n'est pas visible dans une capture d'écran ; vous ne verrez qu'un écran noir sans comprendre pourquoi. Immédiatement après compileShader :

    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
    
  3. 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ômeCause la plus probableCorrection
Écran entièrement noir, seul l'arrière-plan est visibleLe panneau n'est pas dessiné du toutVé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 verreL'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 flouLe déplacement est trop faibleoff = 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 pourtourLa dispersion recouvre tout le bordMultipliez 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 grisLe contenu en dessous est trop monotoneLe 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 torcheLa bande lumineuse est rétrécie latéralementConservez 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 énergieUtilisation d'une interpolation exponentielle du premier ordreRemplacez par un ressort du second ordre, amortissement 0,60,7, autorisez 58% de dépassement (voir section 6.5)
Le framerate chute en dessous de 30 fpsTrop de panneaux / draw plein écran à chaque frameNe 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

CibleRessource à utiliserDescription
Verre unique / pour aller vitestarter/glass-starter.html90 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.htmlUn 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 tracasliquid-glass-webgl.htmlVersion légère à panneau unique et passe unique, déplacement approximatif, sans couche d'interaction
Impossible d'utiliser WebGL / besoin d'un repliliquid-glass-css.htmlbackdrop-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 natifswift/LiquidGlassDemo.swiftAPI 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) :

uniformSignificationSource
uC uHCentre écran / demi-largeur-hauteur (pixels réels, origine haut-gauche)(g.x+g.w/2)*dpr etc.
uRadRayon des coins (pixels réels)min(g.radius, min(w,h)/2)*dpr
uVariant uThick uMagMulVariante / matériau épais / facteur d'agrandissement par panneauPropriétés du panneau
uHover uPress uGlow uActiveÉtat d'interaction 0~1Valeurs de ressort par frame
uPtrCoordonnée normalisée du pointeur dans le panneau, de -1 à 1(cx-c)/(w/2)
uAmbCouleur ambiante de la couche inférieure (rgb)Échantillonnage getImageData
GlobauxuRes uTex uRefraction uRim uTint uDisp uN uMode uContrast uOpaque uMag uWireDéfinis une fois par frame

4. Modèle du chemin lumineux (À LIRE avant d'écrire le shader)

Sept étapes, l'ordre est immuable :

  1. Contour : sdRoundBox pour obtenir la distance signée d (négatif à l'intérieur). Profondeur normalisée x = clamp(-d/band, 0, 1), 0 = contour, 1 = centre ; band = max(5, min(hx,hy)*0.30).
  2. Champ de hauteur convexe : H(x) = sqrt(1 - (1-x)²), H'(x) = v/sqrt(1-v²) (v = clamp(1-x, 0.02, 0.9995)). Utilisez sqrt, pas pow — pow est beaucoup plus lent sous ANGLE.
  3. 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.
  4. É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). tpx est "l'épaisseur en pixels". Plage normale : 0.1 ~ 0.4 * mdim. Au-delà de 0.5, il y aura forcément une distorsion.
  5. 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.
  6. 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-focal doit toujours être positif, sinon il y a un retournement local de 180°, donnant un texte inversé. uMagMul est 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ême uMag transformerait 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 et magMul : lens 1.30, plate 0.55, capsule 0.85, panel 0.60, dock 0.80, nav 0.90.
  7. Échantillonnage et composition : sp = c + rel*(1-focal) - off ; séparez les trois canaux avec ±uDisp*7*eW pour la dispersion RVB ; puis appliquez dans l'ordre : assombrissement par variant, débordement de couleur ambiante uAmb à 0.10, compression de la luminance de la teinte 0.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" :

CanalSignificationLecture
Rlength(off)/mdim*22Rouge = intensité de la déviation. Le centre doit être presque noir, le pourtour rouge
Gx (profondeur du bord)Anneau vert collé au contour, retourne rapidement à zéro vers l'intérieur
Bfocal*2Bleu = 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érefractmagrimdisptintthick
Capsule en verre épais (gros, bords lumineux, arc inférieur marqué, intérieur sombre et translucide)1.200.350.950.220.24✓
Lentille sur bandes colorées (bandes agrandies et déplacées, points lumineux à gauche et à droite)1.500.601.000.180.10✓
Verre épais sur petit texte (texte agrandi + distorsion des bords)1.250.420.800.300.16✓
Barre de navigation supérieure (fine, discrète)0.900.200.600.150.10✗
Panneau de contrôle (grand, lisible)1.000.150.550.120.14✗
Défaut (0)1.200.450.850.350.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 :

ÉcritureRé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 (tx est toujours lay.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 = 1 de 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)

  1. Les tableaux d'uniforms ne sont pas fiables. uniform vec4 uGeo[12] renvoie un getUniformLocation("uGeo[0]") non nul sous ANGLE/D3D, uniform4fv ne 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 par if(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.

  2. Les boucles + branches uniformes peuvent être optimisées entièrement. Écrire if(uOpaque > 0.5){...} dans une boucle for peut entraîner la suppression du corps de la boucle sur certains pilotes. Dans une boucle, utilisez systématiquement mix/step sans branche. Si c'est "un draw par panneau", il n'y a même pas de boucle.

  3. Un uniform déclaré mais inutilisé est optimisé, getUniformLocation renvoie null, ce qui donne une fausse alerte "uniform manquant". La déclaration et l'utilisation doivent aller de pair.

  4. 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.

  5. Axe Y de la texture (voir section 4) : sans inversion, vous obtenez une image miroir + un texte inversé.

  6. N'attachez que click car vous perdrez des événements. Dans les environnements automatisés ou certains hôtes, click n'est pas synthétisé, laissant toutes les interactions muettes. Utilisez pointerdown + pointerup + seuil de déplacement pour détecter un clic, et click uniquement en complément.

  7. half est un mot réservé en GLSL ES : écrire vec2 half = uRect.zw*0.5; fait échouer la compilation du shader entier, et le journal ne mentionne qu'une syntax error, rendant le diagnostic très difficile. Utilisez hb pour demi-largeur/hauteur. Autres mots dangereux : filter, input, output, long, short, double, packed.

  8. 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 en 1.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 FPS est 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émentBudgetQue faire si dépassé
Panneaux de verre simultanés≤ 10Fusionnez-les en un seul, ou rétrogradez les panneaux secondaires vers le repli CSS
Surface couverte par chaque drawSeulement sa propre AABBNe lancez pas la passe de verre en plein écran
Transfert de la texture d'arrière-planToutes les 5 frames (les taches sont lentes)En statique, réduisez à toutes les 8 frames
Ratio de pixels d'arrière-planmin(dpr, 1.5)Si chute de fps, passez à 1.0
Facteur de renduAdaptatif 0.72 / 1.0Passez en dessous si < 42fps, remontez si > 56fps
Échantillonnage de la luminosité inférieure getImageDataToutes les 10 frames, uniquement pour les panneaux w*h > 24000C'est la plus grande surcharge synchrone, réduisez la fréquence
Diagramme en coupe du chemin lumineuxToutes les 4 framesEn statique, réduisez à toutes les 6 frames
Hauteur du panneau de contrôlemin(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.2 donne 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.h contient les mêmes fonctions pures H(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. Utilisez SimulatedGlass uniquement 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).

Skills associés