AppleEvent

2026 visionOS 27 WebXR saccades : comment Three.js stabiliser les images et éviter les plantages

2026 visionOS 27 WebXR saccades : comment Three.js stabiliser les images et éviter les plantages

Une scène Three.js devient fluide dans Safari, puis saccade dès l’entrée en mode immersif, avant de perdre son contexte WebGL ou de se fermer.

La solution la plus fiable consiste à mesurer d’abord le temps d’image, à compresser les ressources et à libérer chaque objet devenu inutile, puis seulement à réduire les appels de dessin et les effets coûteux. Le passage à WebGPU doit venir en dernier, après détection de fonctionnalité et comparaison sur Vision Pro réel.

À qui cette méthode s’adresse

Cette méthode concerne les ingénieurs front-end qui transforment une vitrine Three.js en expérience WebXR pour Apple Vision Pro, ainsi que les artistes techniques qui livrent des scènes audio, vidéo ou 3D interactives.

Elle s’adresse aussi aux responsables techniques qui doivent distinguer un problème d’actifs, de pipeline de rendu ou de WebKit, et aux équipes distantes qui ne disposent pas durablement d’un Mac, de Safari et d’un environnement de simulation visionOS.

Dernière mise à jour : 16 septembre 2026. Les éléments de version et de compatibilité doivent être revérifiés dans les notes officielles d’Apple, de WebKit et dans la documentation actuelle de Three.js avant chaque livraison.

Saccades WebXR de visionOS 27 : commencer par le signal mesurable

Une chute de fluidité n’est pas un diagnostic. Quatre symptômes peuvent se ressembler à l’œil, mais demander des corrections opposées :

  • un temps d’image élevé et stable indique souvent trop de pixels, de géométrie, d’ombres ou de post-traitement ;
  • une chute qui apparaît uniquement au passage en immersion pointe vers la surface de rendu, la stéréoscopie, une texture ou une étape WebXR ;
  • une mémoire qui monte à chaque entrée et sortie de scène évoque plutôt des textures, matériaux, géométries, render targets ou ImageBitmap non libérés ;
  • WebGL Context Lost doit faire rechercher une pression de ressources, une erreur de pilote ou une séquence de commandes invalide, et non être automatiquement attribué à une prétendue limite fixe de Safari.

Le WebKit officiel n’a pas publié de plafond générique de mémoire graphique par onglet qui s’appliquerait à toutes les pages et à tous les appareils. La « muraille de mémoire » peut donc servir d’hypothèse de test, pas de conclusion. Les signalements dans les problèmes Three.js ou les communautés WebXR ne deviennent pertinents qu’avec le modèle de Vision Pro, la version du système, le navigateur, la scène et la procédure de reproduction.

Pour chaque scénario, la base de comparaison doit contenir trois exécutions :

Base de comparaison Ce qu’il faut enregistrer Ce que cela permet d’isoler
Page Safari ordinaire Temps d’image, appels de dessin, triangles, programme actif, mémoire apparente Le coût de la scène avant WebXR
Session WebXR immersive Même relevé, avec étape exacte d’entrée en immersion Le coût du changement de surface et du rendu stéréoscopique
Vision Pro réel Version de visionOS, Safari, backend, qualité, durée et étapes de reproduction La différence entre simulation et appareil physique

Le panneau Safari Web Inspector destiné à l’inspection de visionOS permet de relier les métriques du navigateur à la scène en cours ; il faut l’utiliser avec les indications officielles d’Apple plutôt qu’avec une simple observation visuelle. Le compteur renderer.info de Three.js apporte un autre niveau de preuve : render.calls, render.triangles, programs et les compteurs de textures ou géométries orientent l’enquête, sans prétendre mesurer toute la mémoire GPU.

La journalisation doit également noter l’instant précis où la scène entre en immersion, où une ressource est chargée et où un contexte est perdu. Une vidéo de reproduction sans ces événements est rarement suffisante pour départager CPU, GPU et cycle de vie.

Pourquoi Vision Pro Safari fait-il soudainement chuter les images avec Three.js ?
La cause peut être le cumul de plusieurs coûts : une surface de rendu plus grande, des objets indépendants, des matériaux transparents, des ombres dynamiques, une boucle d’animation trop chargée ou une ressource décodée plusieurs fois. Safari 27 et visionOS 27 ne justifient pas, à eux seuls, une explication universelle. La première comparaison utile est celle d’une scène identique en page ordinaire, en immersion simulée et sur Vision Pro.

Première étape : empêcher les textures de devenir une dette permanente

Le poids d’un fichier compressé sur le réseau ne décrit pas directement la pression exercée après décodage. Il faut examiner au moins quatre variables :

  • la largeur et la hauteur de la texture ;
  • le format de pixels choisi par le GPU ;
  • les niveaux de mipmap ;
  • le nombre de textures résidentes au même moment.

Une texture carrée de grande dimension peut donc coûter beaucoup plus en mémoire de rendu que ne le laisse penser la taille de son fichier. La présence d’un mipmap, d’une version transparente et d’une copie temporaire peut aussi maintenir plusieurs représentations pendant le chargement. Aucune de ces observations ne permet cependant de déduire un plafond fixe propre à Safari.

KTX2 et Basis Universal réduisent généralement la quantité de données transférées et peuvent permettre l’emploi d’un format compressé adapté à l’appareil. Cela ne doit pas être présenté comme une garantie automatique contre un plantage : le résultat dépend du transcodage, du format réellement retenu, de la durée de résidence et du nombre de textures actives. La documentation de KTX2Loader dans Three.js décrit l’intégration et les prérequis à vérifier.

import { KTX2Loader } from 'three/addons/loaders/KTX2Loader.js';

const ktx2Loader = new KTX2Loader()
  .setTranscoderPath('/basis/')
  .detectSupport(renderer);

const texture = await ktx2Loader.loadAsync('/assets/scene-color.ktx2');
texture.colorSpace = THREE.SRGBColorSpace;
material.map = texture;

Le point important est detectSupport(renderer). Le pipeline doit choisir un format réellement supporté par le moteur présent, puis vérifier le résultat avec une scène avant et après compression. Une image plus petite à télécharger ne prouve pas que la ressource GPU finale est plus petite.

Le cycle de vie doit être contrôlé lors de chaque transition de scène. Une fonction de nettoyage explicite évite de confondre disparition d’un objet dans le graphe de scène et libération de ses ressources :

function disposeMaterial(material) {
  for (const value of Object.values(material)) {
    if (value && value.isTexture) value.dispose();
  }
  material.dispose();
}

function disposeObject(root) {
  root.traverse((object) => {
    if (object.geometry) object.geometry.dispose();

    if (Array.isArray(object.material)) {
      object.material.forEach(disposeMaterial);
    } else if (object.material) {
      disposeMaterial(object.material);
    }
  });
}

Cette logique doit aussi couvrir les WebGLRenderTarget, les textures temporaires et les ImageBitmap. Le guide Three.js sur la libération des objets rappelle qu’un objet retiré de la scène n’est pas nécessairement détruit. Les render targets méritent une surveillance séparée, notamment lorsqu’ils alimentent une vidéo, un effet ou une miniature ; la documentation Three.js sur les render targets décrit leur rôle et leur nettoyage.

Pour établir une fuite, il faut répéter le même parcours : entrer dans la scène, en sortir, recharger les mêmes ressources, puis recommencer. Si les compteurs de renderer.info augmentent après chaque cycle alors que le nombre d’objets visibles reste identique, le nettoyage est prioritaire sur tout changement de backend.

KTX2 et BasisU peuvent-ils réduire les plantages d’une scène WebXR sur Vision Pro ?
Ils peuvent réduire la pression liée au transfert et aux textures si le transcodage et le cycle de vie sont corrects. Ils ne corrigent ni les appels de dessin excessifs, ni les render targets oubliés, ni une fuite de ImageBitmap. La validation doit donc comparer la scène complète, avec la même durée d’exécution et le même parcours d’entrée et de sortie.

Deuxième étape : réduire les appels avant de réduire les détails

La taille du fichier GLB est un mauvais indicateur de coût par image. Une scène compacte peut contenir de nombreux objets indépendants, chacun imposant une soumission, un matériau ou une mise à jour.

Le premier relevé doit exploiter :

  • renderer.info.render.calls pour le nombre d’appels de rendu ;
  • renderer.info.render.triangles pour la géométrie effectivement soumise ;
  • renderer.info.programs pour repérer une multiplication des variantes de matériaux ;
  • le temps passé dans l’animation, les raycasts et la création d’objets par image.

Des objets répétés, comme des panneaux, des arbres ou des particules statiques, sont de bons candidats pour InstancedMesh :

const mesh = new THREE.InstancedMesh(
  geometry,
  material,
  transforms.length
);

const matrix = new THREE.Matrix4();

transforms.forEach((transform, index) => {
  matrix.compose(transform.position, transform.quaternion, transform.scale);
  mesh.setMatrixAt(index, matrix);
});

mesh.instanceMatrix.needsUpdate = true;
scene.add(mesh);

Le gain dépend de la scène. Une instance ne convient pas si chaque élément exige un matériau radicalement différent, une transparence particulière ou une animation indépendante. Le regroupement de géométries statiques peut également réduire les soumissions, mais il rend les mises à jour sélectives et la libération plus complexes.

Les matériaux transparents affaiblissent souvent les bénéfices du regroupement parce que l’ordre de profondeur, le tri et le mélange imposent des contraintes supplémentaires. Les changements fréquents de matériau peuvent multiplier les programmes et les états. Les ombres dynamiques ajoutent leurs propres passes et textures ; elles doivent donc être désactivées temporairement pour mesurer leur coût réel, sans modifier plusieurs paramètres en même temps.

Expérience de terrain : lorsque calls reste élevé alors que le nombre de triangles est modéré, l’optimisation des modèles ne suffit généralement pas. Il faut inspecter la hiérarchie, les matériaux, les objets générés par l’animation et les raycasts effectués à chaque image.

WebXR affiche-t-il un WebGL Context Lost : que vérifier en premier ?
Il faut conserver le dernier relevé de calls, triangles, textures, render targets et programmes, puis reproduire la séquence avec les effets désactivés. La vérification suivante porte sur les ressources créées à chaque entrée en immersion. Enfin, le test doit être répété sur Vision Pro réel : le simulateur peut signaler une incompatibilité, mais il ne remplace pas une validation de mémoire et de stabilité sur l’appareil.

Troisième étape : traiter les pixels et les effets en dernier

Le rendu stéréoscopique rend chaque pixel plus important, surtout lorsque la scène ajoute des ombres, des transparences et plusieurs passes. Les points à isoler sont :

  • devicePixelRatio et la résolution effective du renderer ;
  • l’anticrénelage ;
  • la taille des shadow maps ;
  • les superpositions transparentes ;
  • les passes de flou, profondeur, couleur ou composition ;
  • les render targets temporaires.

La résolution dynamique est préférable à une réduction permanente imposée à tous les appareils. Le contrôleur peut observer le temps d’image sur une fenêtre glissante, puis passer à un niveau de qualité inférieur si le seuil convenu est dépassé. Le retour à la qualité supérieure doit être plus lent afin d’éviter les oscillations.

const qualityLevels = [
  { pixelRatio: 0.75, shadows: false, post: false },
  { pixelRatio: 1.00, shadows: false, post: true },
  { pixelRatio: 1.00, shadows: true, post: true }
];

let qualityIndex = 1;
let slowFrames = 0;
let fastFrames = 0;

function updateQuality(frameMs) {
  if (frameMs > 20) {
    slowFrames++;
    fastFrames = 0;
  } else if (frameMs < 14) {
    fastFrames++;
    slowFrames = 0;
  }

  if (slowFrames >= 8 && qualityIndex > 0) {
    qualityIndex--;
    applyQuality(qualityLevels[qualityIndex]);
    slowFrames = 0;
  }

  if (fastFrames >= 30 && qualityIndex < qualityLevels.length - 1) {
    qualityIndex++;
    applyQuality(qualityLevels[qualityIndex]);
    fastFrames = 0;
  }
}

Les valeurs ci-dessus sont des exemples de politique, pas des seuils universels. Elles doivent être ajustées avec les fréquences d’images réellement observées et documentées par l’équipe. Une comparaison utile désactive un seul effet à la fois : d’abord les ombres, puis le post-traitement, puis la transparence. Si plusieurs réglages changent simultanément, le résultat devient difficile à attribuer.

Modification Gain à mesurer Risque de régression
Baisser la résolution de rendu Temps de composition et remplissage Image moins nette
Désactiver les ombres dynamiques Passes et textures d’ombre en moins Éclairage moins convaincant
Réduire les transparences Tri et mélange simplifiés Aspect visuel modifié
Retirer un post-traitement Moins de render targets Perte d’un effet créatif
Réduire les mises à jour d’animation Charge du thread principal Animation moins détaillée

Pour les projets de design, vidéo ou présentation de produit, un profil « aperçu » peut privilégier la stabilité pendant la navigation, puis restaurer les effets lorsque la caméra est immobile. Cette stratégie est plus acceptable qu’une image systématiquement dégradée.

WebGL ou WebGPU : choisir par capacité, pas par promesse

Safari 26.2 a ajouté la prise en charge de WebGPU pour WebXR sur visionOS, selon les fonctionnalités WebKit documentées pour Safari 26.2. Cela ne signifie pas qu’un projet Three.js devient automatiquement plus rapide après migration. Le coût peut se déplacer vers les shaders, les matériaux, le post-traitement ou les abstractions encore incomplètes.

La documentation de WebGPURenderer dans Three.js doit être lue avec le projet réel. ShaderMaterial, onBeforeCompile, les passes personnalisées et les effets conçus pour WebGL peuvent nécessiter une adaptation. Le fait que WebKit s’appuie sur Metal en interne ne crée pas un bouton « Metal » que le code WebXR pourrait sélectionner comme backend universel.

La décision peut être formalisée ainsi :

  • Si la scène reste stable en WebGL après compression, nettoyage et réduction des appels, alors conservez WebGL pour la livraison initiale et comparez WebGPU séparément.
  • Si WebGPU est détecté et que les matériaux, shaders et passes critiques ont été validés sur Vision Pro réel, alors ajoutez-le comme chemin expérimental ou principal selon les résultats mesurés.
  • Si WebGPURenderer échoue, si une extension nécessaire manque ou si un shader personnalisé diverge, alors revenez à WebGL sans bloquer l’expérience.
  • Si le seul argument en faveur de WebGPU est une attente de performance, alors ne migrez pas encore : produisez d’abord une comparaison instrumentée.
  • Si l’expérience dépend d’un effet WebGL non porté, alors conservez le backend compatible et documentez la limite plutôt que de masquer un rendu incorrect.

La sélection doit reposer sur la détection de fonctionnalité et sur le résultat d’un test, jamais sur une chaîne d’agent utilisateur. Les notes de version récentes de WebKit peuvent signaler des corrections WebXR, de viewport ou de simulation, mais elles ne remplacent pas un essai de la scène livrée.

Le WebXR de visionOS doit-il utiliser WebGL ou WebGPU ?
WebGL reste le choix de repli lorsque la scène et les effets sont déjà maîtrisés. WebGPU mérite une comparaison lorsque le navigateur, Three.js, les shaders et les passes nécessaires sont compatibles. Il ne faut pas le présenter comme plus rapide par définition, ni comme une commande permettant de forcer directement Metal.

Tester sans Vision Pro : utile pour prévenir, insuffisant pour conclure

Une équipe sans appareil peut utiliser un Mac distant pour vérifier le chargement, les permissions, les versions de Safari, la compilation des assets, le comportement du simulateur et les erreurs JavaScript. Le simulateur est particulièrement utile pour détecter une API absente ou un parcours WebXR impossible.

Il ne permet pas de conclure sur la fréquence d’images finale, la consommation graphique ou la stabilité d’une session prolongée. La procédure de test doit séparer les niveaux :

Niveau de test Acceptation possible Ce qui reste obligatoire sur Vision Pro
Mac et navigateur Chargement, console, détection de backend Fluidité et mémoire réelle
Simulateur visionOS Parcours WebXR, compatibilité de base, erreurs d’interface Temps d’image et plantages représentatifs
Vision Pro réel Rendu, interaction, durée, sortie et retour en immersion Confirmation finale de livraison

Avant publication, l’ordre d’acceptation recommandé est le suivant :

  1. définir un budget d’actifs : textures, variantes, géométries, render targets et ressources simultanées ;
  2. mesurer la page ordinaire, l’immersion et l’appareil réel avec les mêmes indicateurs ;
  3. tester une session longue, puis une sortie et une nouvelle entrée répétées ;
  4. comparer WebGL et WebGPU avec le même niveau de qualité ;
  5. vérifier le repli lorsque le backend préféré ou un shader n’est pas disponible ;
  6. consigner le modèle d’appareil, les versions de Safari et visionOS, le commit Three.js, les paramètres graphiques et la date du test.

Pour une équipe distante, un environnement Mac accessible à distance peut prendre en charge la conversion des assets, les essais Safari et les contrôles du simulateur. La documentation d’accès et de fonctionnement peut être consultée via le centre d’aide ProxyMac. Cette organisation réduit les allers-retours de configuration, mais elle ne transforme pas le simulateur en référence matérielle.

Le scénario le plus sûr reste donc : préparer les assets sur Mac, automatiser les contrôles de chargement, effectuer le pré-contrôle dans le simulateur, puis réserver une vraie session Vision Pro à la mesure finale et aux régressions. Les bugs WebXR corrigés dans Safari 27 ne doivent être considérés comme réglés dans un projet donné qu’après reproduction avec les versions effectivement livrées.

Ce que le choix d’environnement change réellement

Un Mac local permanent simplifie les tests fréquents, conserve les versions et facilite l’accès aux outils Apple, mais il immobilise du matériel et peut devenir insuffisant lorsqu’une équipe doit comparer plusieurs environnements. Un poste distant ou loué apporte une configuration reproductible pour les conversions KTX2, les builds et le contrôle Safari, mais la latence et l’accès aux périphériques physiques doivent être pris en compte. Une infrastructure virtuelle ne remplace pas non plus la mesure sur Vision Pro.

Pour une équipe qui doit seulement préparer des assets, vérifier Safari et exécuter des régressions ponctuelles, louer un Mac via ProxyMac peut être plus souple que maintenir une machine dédiée inutilisée entre deux versions. Pour une charge lourde permanente, une exigence de périphérique physique ou une validation immersive quotidienne, l’achat d’un Mac et la possession d’un Vision Pro restent plus cohérents. La décision dépend donc de la fréquence des tests et non d’une promesse abstraite de performance.

La règle opérationnelle est simple : mesurer avant d’expliquer, libérer avant de changer de moteur, puis comparer WebGL et WebGPU sur la même scène. Cette séquence évite de transformer une fuite de texture, un excès d’appels ou un post-traitement trop coûteux en prétendue limite fixe de Safari.

Testez votre WebXR sur un Mac distant avec ProxyMac

Accédez à un Mac distant pour reproduire vos scénarios Three.js dans un environnement macOS adapté aux tests WebXR.
Mesurez plus facilement la fréquence d’images, la consommation des ressources et la stabilité de vos expériences immersives.