Update deplacement_dans_env/viewer_pr_env.js

deplacement_dans_env/viewer_pr_env.js

@@ -1,28 +1,28 @@
-// viewer_pr_env.js — Physics (Ammo) version
+// viewer_pr_env.js — robuste (boot non-bloquant, logs, physics avec fallback)
 // ============================================================================
-// - Charge PlayCanvas (ESM)
-// - Charge Ammo (WASM) avec fallback JS et timeout, base URL configurable
-// - Instancie le GLB d’environnement et lui ajoute des colliders statiques (mesh)
-// - Crée un "player" capsule dynamique et attache la caméra en enfant (yeux)
-// - Garde le chargement GSplat (.sog) et la gestion DPR dynamique
-// - NE CHARGE PAS le script de contrôle caméra ici (tu le demanderas ensuite)
+// - PlayCanvas ESM
+// - Boot non-bloquant : l'app démarre et rend tout de suite (caméra au root)
+// - Ammo (WASM) en parallèle, avec timeout + double API (promise/callback)
+// - Colliders mesh posés après 1ère frame (postrender)
+// - Player capsule créé seulement si Ammo OK, puis caméra reparentée
+// - Chargement GSplat/GLB tolérant (logs + timeout) ; DPR dynamique ; logs jalons
+// - NE CHARGE PAS le script de contrôle caméra (à ajouter côté scène)
 // ============================================================================
 
 /* -------------------------------------------
-   State (module / instance)
+   Error surface (avant tout)
 -------------------------------------------- */
-
-// === Error surface ===
-window.addEventListener('error', e => {
+window.addEventListener('error', (e) => {
   console.error('[BOOT] Uncaught error:', e.message || e.error, e);
 });
-window.addEventListener('unhandledrejection', e => {
+window.addEventListener('unhandledrejection', (e) => {
   console.error('[BOOT] Unhandled promise rejection:', e.reason);
 });
-console.log('[BOOT] JS boot reached');   // doit s’afficher quoi qu’il arrive
-
-
+console.log('[BOOT] JS boot reached');
 
+/* -------------------------------------------
+   State (module / instance)
+-------------------------------------------- */
 let pc;
 export let app = null;
 export let cameraEntity = null;
@@ -49,17 +49,20 @@ let idleRestoreDelay = 350;
 let idleTimer = null;
 
 // Physique
-let ammoBaseUrl = "https://playcanvas.github.io/examples/lib/ammo/"; // surchargable par config
-let physicsEnabled = true; // si Ammo indisponible -> false
-let gravityVec = null;     // sera défini selon config (free-fly vs grounded)
+let ammoBaseUrl = 'https://playcanvas.github.io/examples/lib/ammo/'; // surchargable par config
+let wantPhysics = true; // souhait ; peut être désactivé si Ammo KO
+let gravityVec = null; // défini via config
 
 /* -------------------------------------------
    Utils
 -------------------------------------------- */
+const stamp = () => new Date().toISOString().slice(11,19);
+const step = (label, extra) => console.log(`[${stamp()}] [VIEWER] ${label}`, extra ?? '');
+
 function hexToRgbaArray(hex) {
   try {
-    hex = String(hex || "").replace("#", "");
-    if (hex.length === 6) hex += "FF";
+    hex = String(hex || '').replace('#', '');
+    if (hex.length === 6) hex += 'FF';
     if (hex.length !== 8) return [1, 1, 1, 1];
     const num = parseInt(hex, 16);
     return [
@@ -68,7 +71,8 @@ function hexToRgbaArray(hex) {
       ((num >> 8) & 0xff) / 255,
       (num & 0xff) / 255
     ];
-  } catch {
+  } catch (e) {
+    console.warn('[viewer] hexToRgbaArray error:', e);
     return [1, 1, 1, 1];
   }
 }
@@ -86,65 +90,66 @@ function isMobileUA() {
   return isIOS || isAndroid;
 }
 
-async function loadAmmoOrFallback(baseUrl, timeoutMs = 4000) {
-  // Configure URLs
-  pc.WasmModule.setConfig("Ammo", {
-    glueUrl: `${baseUrl}ammo.wasm.js`,
-    wasmUrl: `${baseUrl}ammo.wasm.wasm`,
-    fallbackUrl: `${baseUrl}ammo.js`
-  });
-
-  // Essaye l’API Promise d’abord
-  const tryPromise = async () => {
-    try {
-      const p = pc.WasmModule.getInstance("Ammo", `${baseUrl}ammo.wasm.js`);
-      if (p && typeof p.then === "function") {
-        await Promise.race([
-          p,
-          new Promise((_, rej) => setTimeout(() => rej(new Error("Ammo load timeout (promise)")), timeoutMs))
-        ]);
-        return true;
-      }
-      return false;
-    } catch (e) {
-      console.warn("[Ammo] promise form failed:", e);
-      return false;
-    }
-  };
+async function loadAmmoWithTimeout(baseUrl, timeoutMs = 4000) {
+  // Config URLs
+  try {
+    pc.WasmModule.setConfig('Ammo', {
+      glueUrl: `${baseUrl}ammo.wasm.js`,
+      wasmUrl: `${baseUrl}ammo.wasm.wasm`,
+      fallbackUrl: `${baseUrl}ammo.js`
+    });
+  } catch (e) {
+    console.warn('[Ammo] setConfig failed (ignored):', e);
+  }
 
-  // Sinon, essaye l’API callback
-  const tryCallback = async () => {
-    let resolved = false;
-    try {
+  // 1) Tente API Promise
+  try {
+    const maybePromise = pc.WasmModule.getInstance('Ammo', `${baseUrl}ammo.wasm.js`);
+    if (maybePromise && typeof maybePromise.then === 'function') {
+      step('Ammo: waiting (promise API)…');
       await Promise.race([
-        new Promise((resolve, reject) => {
-          pc.WasmModule.getInstance("Ammo", () => {
-            resolved = true;
-            resolve();
-          });
-        }),
-        new Promise((_, rej) => setTimeout(() => rej(new Error("Ammo load timeout (callback)")), timeoutMs))
+        maybePromise,
+        new Promise((_, rej) => setTimeout(() => rej(new Error('Ammo load timeout (promise)')), timeoutMs))
       ]);
-      return resolved;
-    } catch (e) {
-      console.warn("[Ammo] callback form failed:", e);
-      return false;
+      step('Ammo: ready (promise API)');
+      return true;
     }
-  };
+  } catch (e) {
+    console.warn('[Ammo] promise API failed:', e);
+  }
 
-  const ok = (await tryPromise()) || (await tryCallback());
-  if (!ok) {
-    console.warn("[viewer] Ammo not available — physics disabled.");
-    return false;
+  // 2) Tente API callback
+  let resolved = false;
+  try {
+    step('Ammo: waiting (callback API)…');
+    await Promise.race([
+      new Promise((resolve) => pc.WasmModule.getInstance('Ammo', () => { resolved = true; resolve(); })),
+      new Promise((_, rej) => setTimeout(() => rej(new Error('Ammo load timeout (callback)')), timeoutMs))
+    ]);
+    if (resolved) {
+      step('Ammo: ready (callback API)');
+      return true;
+    }
+  } catch (e) {
+    console.warn('[Ammo] callback API failed:', e);
   }
-  return true;
+
+  console.warn('[viewer] Ammo not available — physics disabled.');
+  return false;
+}
+
+function safeGetEl(id, label) {
+  const el = document.getElementById(id);
+  if (!el) console.warn(`[viewer] Missing DOM #${id} (${label})`);
+  return el;
 }
 
 /* -------------------------------------------
    Initialisation principale
 -------------------------------------------- */
 export async function initializeViewer(config, instanceId) {
-  if (viewerInitialized) return;
+  if (viewerInitialized) { console.warn('[viewer] initializeViewer called twice — ignored'); return; }
+  step('A: initializeViewer begin', { instanceId });
 
   // ---- Lecture config ----
   const mobile = isMobileUA();
@@ -153,7 +158,7 @@ export async function initializeViewer(config, instanceId) {
   glbUrl = (config.glb_url !== undefined) ? config.glb_url : null;
   presentoirUrl = (config.presentoir_url !== undefined) ? config.presentoir_url : null;
 
-  color_bg_hex = config.canvas_background !== undefined ? config.canvas_background : "#FFFFFF";
+  color_bg_hex = config.canvas_background !== undefined ? config.canvas_background : '#FFFFFF';
   espace_expo_bool = config.espace_expo_bool !== undefined ? !!config.espace_expo_bool : false;
   color_bg = hexToRgbaArray(color_bg_hex);
 
@@ -181,36 +186,40 @@ export async function initializeViewer(config, instanceId) {
     idleRestoreDelay = Math.max(120, parseInt(config.idleRestoreDelayMs, 10) || idleRestoreDelay);
   }
 
-  // Physique
-  if (config.ammoBaseUrl) ammoBaseUrl = String(config.ammoBaseUrl).endsWith("/") ? config.ammoBaseUrl : (config.ammoBaseUrl + "/");
-  physicsEnabled = config.usePhysics === false ? false : true; // par défaut true
+  // Physique (souhait)
+  if (config.ammoBaseUrl) ammoBaseUrl = String(config.ammoBaseUrl).endsWith('/') ? config.ammoBaseUrl : (config.ammoBaseUrl + '/');
+  wantPhysics = config.usePhysics === false ? false : true; // par défaut true
   const freeFly = !!config.freeFly; // si true => pas de gravité
   gravityVec = freeFly ? new pc.Vec3(0, 0, 0) : new pc.Vec3(0, -9.81, 0);
 
   // ---- Canvas / DOM ----
-  const canvasId = "canvas-" + instanceId;
-  const progressDialog = document.getElementById("progress-dialog-" + instanceId);
-  const viewerContainer = document.getElementById("viewer-container-" + instanceId);
+  const canvasId = 'canvas-' + instanceId;
+  const progressId = 'progress-dialog-' + instanceId;
+  const containerId = 'viewer-container-' + instanceId;
+  const progressDialog = safeGetEl(progressId, 'progress');
+  const viewerContainer = safeGetEl(containerId, 'container');
+  if (!viewerContainer) throw new Error('Viewer container not found');
 
   const old = document.getElementById(canvasId);
   if (old) old.remove();
 
-  const canvas = document.createElement("canvas");
+  const canvas = document.createElement('canvas');
   canvas.id = canvasId;
-  canvas.className = "ply-canvas";
-  canvas.style.width = "100%";
-  canvas.style.height = "100%";
-  canvas.setAttribute("tabindex", "0");
-  viewerContainer.insertBefore(canvas, progressDialog);
+  canvas.className = 'ply-canvas';
+  canvas.style.width = '100%';
+  canvas.style.height = '100%';
+  canvas.setAttribute('tabindex', '0');
+  if (progressDialog) viewerContainer.insertBefore(canvas, progressDialog);
+  else viewerContainer.appendChild(canvas);
 
   // Interaction UI de base (prévenir scroll)
-  canvas.style.touchAction = "none";
-  canvas.style.webkitTouchCallout = "none";
-  canvas.addEventListener("gesturestart", (e) => e.preventDefault());
-  canvas.addEventListener("gesturechange", (e) => e.preventDefault());
-  canvas.addEventListener("gestureend", (e) => e.preventDefault());
-  canvas.addEventListener("dblclick", (e) => e.preventDefault());
-  canvas.addEventListener("wheel", (e) => e.preventDefault(), { passive: false });
+  canvas.style.touchAction = 'none';
+  canvas.style.webkitTouchCallout = 'none';
+  canvas.addEventListener('gesturestart', (e) => e.preventDefault());
+  canvas.addEventListener('gesturechange', (e) => e.preventDefault());
+  canvas.addEventListener('gestureend', (e) => e.preventDefault());
+  canvas.addEventListener('dblclick', (e) => e.preventDefault());
+  canvas.addEventListener('wheel', (e) => e.preventDefault(), { passive: false });
 
   // Focus au survol pour capter le clavier
   let isPointerOverCanvas = false;
@@ -219,43 +228,32 @@ export async function initializeViewer(config, instanceId) {
   const onPointerLeave = () => { isPointerOverCanvas = false; if (document.activeElement === canvas) canvas.blur(); };
   const onCanvasBlur   = () => { isPointerOverCanvas = false; };
 
-  canvas.addEventListener("pointerenter", onPointerEnter);
-  canvas.addEventListener("pointerleave", onPointerLeave);
-  canvas.addEventListener("mouseenter", onPointerEnter);
-  canvas.addEventListener("mouseleave", onPointerLeave);
-  canvas.addEventListener("mousedown", focusCanvas);
-  canvas.addEventListener("touchstart", focusCanvas, { passive: true });
-  canvas.addEventListener("blur", onCanvasBlur);
+  canvas.addEventListener('pointerenter', onPointerEnter);
+  canvas.addEventListener('pointerleave', onPointerLeave);
+  canvas.addEventListener('mouseenter', onPointerEnter);
+  canvas.addEventListener('mouseleave', onPointerLeave);
+  canvas.addEventListener('mousedown', focusCanvas);
+  canvas.addEventListener('touchstart', focusCanvas, { passive: true });
+  canvas.addEventListener('blur', onCanvasBlur);
 
   // Empêche les touches scroll pendant survol
-  const scrollKeys = new Set(["ArrowUp","ArrowDown","ArrowLeft","ArrowRight","PageUp","PageDown","Home","End"," ","Space","Spacebar"]);
+  const scrollKeys = new Set(['ArrowUp','ArrowDown','ArrowLeft','ArrowRight','PageUp','PageDown','Home','End',' ','Space','Spacebar']);
   const onKeyDownCapture = (e) => { if (!isPointerOverCanvas) return; if (scrollKeys.has(e.key) || scrollKeys.has(e.code)) e.preventDefault(); };
-  window.addEventListener("keydown", onKeyDownCapture, true);
+  window.addEventListener('keydown', onKeyDownCapture, true);
 
-  progressDialog.style.display = "block";
+  if (progressDialog) progressDialog.style.display = 'block';
 
   // ---- Import PlayCanvas ----
   if (!pc) {
-    pc = await import("https://esm.run/playcanvas");
-    window.pc = pc; // debug
-  }
-
-  // ---- Charge Ammo si activé ----
-  if (physicsEnabled) {
-    try {
-      const ok = await loadAmmoOrFallback(ammoBaseUrl, mobile ? 5000 : 3500);
-      physicsEnabled = !!ok;
-    } catch (e) {
-      console.warn("[viewer_pr_env] Ammo load exception, physics disabled:", e);
-      physicsEnabled = false;
-    }
+    step('B: importing PlayCanvas…');
+    pc = await import('https://esm.run/playcanvas');
+    window.pc = pc; // debug convenience
+    step('B+: PlayCanvas imported');
   }
 
-  // ---- Crée l’Application ----
-  const device = await pc.createGraphicsDevice(canvas, {
-    deviceTypes: ["webgl2", "webgl1"],
-    antialias: false
-  });
+  // ---- Crée l’Application (démarrage non-bloquant) ----
+  step('C: createGraphicsDevice');
+  const device = await pc.createGraphicsDevice(canvas, { deviceTypes: ['webgl2', 'webgl1'], antialias: false });
   device.maxPixelRatio = Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio);
 
   const opts = new pc.AppOptions();
@@ -277,10 +275,25 @@ export async function initializeViewer(config, instanceId) {
   app = new pc.Application(canvas, opts);
   app.setCanvasFillMode(pc.FILLMODE_NONE);
   app.setCanvasResolution(pc.RESOLUTION_AUTO);
-
-  // Gravité
   app.scene.gravity = gravityVec || new pc.Vec3(0, -9.81, 0);
 
+  // Démarrer la boucle tout de suite (rendu garanti)
+  step('D: app.start()');
+  app.start();
+  step('D+: app started');
+
+  // Caméra fallback — toujours visible même si Ammo KO
+  step('E: create fallback camera');
+  cameraEntity = new pc.Entity('camera');
+  cameraEntity.addComponent('camera', {
+    clearColor: new pc.Color(color_bg),
+    nearClip: 0.03,
+    farClip: 500
+  });
+  cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+  app.root.addChild(cameraEntity);
+  cameraEntity.lookAt(new pc.Vec3(0,1,0));
+
   // Resize observé (debounce)
   resizeObserver = new ResizeObserver((entries) => {
     if (!entries || !entries.length) return;
@@ -291,68 +304,74 @@ export async function initializeViewer(config, instanceId) {
   });
   resizeObserver.observe(viewerContainer);
 
-  window.addEventListener("resize", () => {
+  window.addEventListener('resize', () => {
     if (resizeTimeout) clearTimeout(resizeTimeout);
     resizeTimeout = setTimeout(() => {
       app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
     }, 60);
   });
 
-  app.on("destroy", () => {
+  app.on('destroy', () => {
     try { resizeObserver.disconnect(); } catch {}
     if (opts.keyboard && opts.keyboard.detach) opts.keyboard.detach();
-    window.removeEventListener("keydown", onKeyDownCapture, true);
-
-    canvas.removeEventListener("pointerenter", onPointerEnter);
-    canvas.removeEventListener("pointerleave", onPointerLeave);
-    canvas.removeEventListener("mouseenter", onPointerEnter);
-    canvas.removeEventListener("mouseleave", onPointerLeave);
-    canvas.removeEventListener("mousedown", focusCanvas);
-    canvas.removeEventListener("touchstart", focusCanvas);
-    canvas.removeEventListener("blur", onCanvasBlur);
+    window.removeEventListener('keydown', onKeyDownCapture, true);
+
+    canvas.removeEventListener('pointerenter', onPointerEnter);
+    canvas.removeEventListener('pointerleave', onPointerLeave);
+    canvas.removeEventListener('mouseenter', onPointerEnter);
+    canvas.removeEventListener('mouseleave', onPointerLeave);
+    canvas.removeEventListener('mousedown', focusCanvas);
+    canvas.removeEventListener('touchstart', focusCanvas);
+    canvas.removeEventListener('blur', onCanvasBlur);
   });
 
-  // ---- Assets (SOG + GLB) ----
+  // ---- Charger assets SOG + GLB (tolérant) ----
   const assets = [];
   let sogAsset = null, glbAsset = null;
 
   if (sogUrl) {
-    sogAsset = new pc.Asset("gsplat", "gsplat", { url: sogUrl });
+    sogAsset = new pc.Asset('gsplat', 'gsplat', { url: sogUrl });
     app.assets.add(sogAsset); assets.push(sogAsset);
   }
   if (glbUrl) {
-    glbAsset = new pc.Asset("glb", "container", { url: glbUrl });
+    glbAsset = new pc.Asset('glb', 'container', { url: glbUrl });
     app.assets.add(glbAsset); assets.push(glbAsset);
   }
 
-  // Charge les assets requis avant de créer la scène
-  await new Promise((resolve, reject) => {
+  step('F: requesting assets', { sog: !!sogUrl, glb: !!glbUrl });
+
+  await new Promise((resolve) => {
+    if (!assets.length) return resolve();
+
     const loader = new pc.AssetListLoader(assets, app.assets);
-    loader.load(() => resolve());
-    loader.on('error', reject);
+    let done = false;
+    const finish = (label) => { if (!done) { done = true; step('F+: assets loaded (' + label + ')'); resolve(); } };
+
+    loader.on('error', (e) => { console.warn('[viewer] Asset load error:', e); finish('with errors'); });
+    loader.load(() => finish('ok'));
+
+    // garde-fou timeout
+    setTimeout(() => { if (!done) { console.warn('[viewer] Asset load timeout — continuing'); finish('timeout'); } }, 10000);
   });
 
-  // Démarrer la boucle update
-  console.log("[viewer] before app.start()");
-  app.start();
-  console.log("[viewer] START OK");
-  progressDialog.style.display = "none";
-  console.log("[viewer] progress hidden");
+  if (progressDialog) { progressDialog.style.display = 'none'; step('G: progress hidden'); }
 
   // ---- Crée le modèle GSplat (optionnel) ----
   if (sogAsset) {
-    modelEntity = new pc.Entity("model");
-    modelEntity.addComponent("gsplat", { asset: sogAsset });
+    modelEntity = new pc.Entity('model');
+    modelEntity.addComponent('gsplat', { asset: sogAsset });
     app.root.addChild(modelEntity);
+    step('H: gsplat entity created');
   }
 
   // ---- Instancier le GLB d’environnement ----
   envEntity = glbAsset && glbAsset.resource ? glbAsset.resource.instantiateRenderEntity() : null;
   if (envEntity) {
-    envEntity.name = "ENV_GLTF";
+    envEntity.name = 'ENV_GLTF';
     app.root.addChild(envEntity);
+    step('I: env GLB instanced');
   } else {
-    console.warn("[viewer_pr_env] Aucun GLB d’environnement — collisions physiques inutilisables.");
+    console.warn('[viewer] No environment GLB — physics will be skipped.');
   }
 
   // ---- Matériau "fond uni" si pas d'espace expo ----
@@ -368,74 +387,49 @@ export async function initializeViewer(config, instanceId) {
         for (const mi of node.render.meshInstances) mi.material = matSol;
       }
     });
+    step('I+: env recolored (flat)');
   }
 
-  // ---- Physique : colliders "mesh" statiques sur l’environnement ----
-  if (physicsEnabled && envEntity) {
-    const addStaticMeshCollider = (e) => {
-      if (e.render && !e.collision) {
-        e.addComponent('collision', { type: 'mesh' });
-      }
-      if (!e.rigidbody) {
-        e.addComponent('rigidbody', { type: 'static', friction: 0.6, restitution: 0.0 });
-      } else if (e.rigidbody && e.rigidbody.type !== 'static') {
-        // force static pour le décor
-        e.rigidbody.type = 'static';
+  // ---- Physique : chargement Ammo en parallèle, colliders après 1ère frame ----
+  let physicsReady = false;
+  if (wantPhysics) {
+    (async () => {
+      try {
+        const ok = await loadAmmoWithTimeout(ammoBaseUrl, isMobileUA() ? 5000 : 3500).catch(() => false);
+        if (!ok) { step('P: Ammo unavailable — rendering without physics'); return; }
+
+        // Pose des colliders mesh après 1ère frame pour garantir meshInstances
+        if (envEntity) {
+          app.once('postrender', () => {
+            const applyStaticMesh = (e) => {
+              if (e.render && !e.collision) {
+                try { e.addComponent('collision', { type: 'mesh' }); } catch (err) { console.warn('[phys] add collision failed:', err); }
+              }
+              if (!e.rigidbody) {
+                try { e.addComponent('rigidbody', { type: 'static', friction: 0.6, restitution: 0.0 }); } catch (err) { console.warn('[phys] add rigidbody failed:', err); }
+              } else if (e.rigidbody && e.rigidbody.type !== 'static') {
+                e.rigidbody.type = 'static';
+              }
+            };
+            const stack=[envEntity];
+            while (stack.length){ const n=stack.pop(); applyStaticMesh(n); n.children?.forEach(c=>stack.push(c)); }
+            step('P+: static mesh colliders ready');
+          });
+        }
+
+        // Crée Player capsule et reparent caméra
+        createPlayerCapsuleAndAttachCamera(app, config);
+        physicsReady = true;
+        step('Q: physics ON (player created)');
+      } catch (e) {
+        console.warn('[phys] init failed:', e);
       }
-    };
-    traverse(envEntity, addStaticMeshCollider);
-  }
-
-  // ---- Caméra + Player capsule ----
-  cameraEntity = new pc.Entity("camera");
-  cameraEntity.addComponent("camera", {
-    clearColor: new pc.Color(color_bg),
-    nearClip: 0.03,
-    farClip: 500,
-    // viewport: peut être défini si besoin
-  });
-
-  if (physicsEnabled) {
-    // Player (rigidbody capsule) — porteur de la caméra
-    playerEntity = new pc.Entity("Player");
-    const capsuleRadius = config.capsuleRadius !== undefined ? parseFloat(config.capsuleRadius) : 0.30;
-    const capsuleHeight = config.capsuleHeight !== undefined ? parseFloat(config.capsuleHeight) : 1.60;
-
-    playerEntity.addComponent('collision', {
-      type: 'capsule',
-      radius: capsuleRadius,
-      height: capsuleHeight
-    });
-    playerEntity.addComponent('rigidbody', {
-      type: 'dynamic',
-      mass: 70,
-      friction: 0.45,
-      restitution: 0.0,
-      linearDamping: 0.15,
-      angularDamping: 0.999
-    });
-    // Bloquer la rotation pour éviter le roulis
-    playerEntity.rigidbody.angularFactor = new pc.Vec3(0, 0, 0);
-
-    // Spawn
-    playerEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
-    app.root.addChild(playerEntity);
-
-    // Caméra en enfant (yeux)
-    const eyes = config.eyesOffsetY !== undefined ? parseFloat(config.eyesOffsetY) : Math.max(0.1, capsuleHeight * 0.9);
-    cameraEntity.setPosition(0, eyes, 0);
-    playerEntity.addChild(cameraEntity);
+    })();
   } else {
-    // Pas de physique : on place simplement la caméra dans la scène (pas de contrôle ici)
-    cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
-    app.root.addChild(cameraEntity);
+    step('P: physics disabled by config (usePhysics=false)');
   }
 
-  // Regarder vers le modèle si présent, sinon vers l’origine
-  const lookTarget = modelEntity ? modelEntity.getPosition() : new pc.Vec3(0, 1, 0);
-  cameraEntity.lookAt(lookTarget);
-
-  // Taille initiale
+  // Ajuster taille initiale
   app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
 
   // DPR dynamique : réduit pendant interaction
@@ -453,30 +447,77 @@ export async function initializeViewer(config, instanceId) {
       setDpr(Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio));
     }, idleRestoreDelay);
   };
-
-  const interactionEvents = ["mousedown", "mousemove", "mouseup", "wheel", "touchstart", "touchmove", "keydown"];
-  interactionEvents.forEach((ev) => canvas.addEventListener(ev, bumpInteraction, { passive: true }));
+  ['mousedown', 'mousemove', 'mouseup', 'wheel', 'touchstart', 'touchmove', 'keydown']
+    .forEach((ev) => canvas.addEventListener(ev, bumpInteraction, { passive: true }));
 
   viewerInitialized = true;
+  step('Z: initializeViewer done', { physicsRequested: wantPhysics });
+}
+
+/* -------------------------------------------
+   Helpers: création Player capsule + cam
+-------------------------------------------- */
+function createPlayerCapsuleAndAttachCamera(app, config) {
+  // Si déjà présent, ne pas recréer
+  if (playerEntity && playerEntity.rigidbody) { step('Q+: player already exists'); return; }
+
+  playerEntity = new pc.Entity('Player');
+  const capsuleRadius = config.capsuleRadius !== undefined ? parseFloat(config.capsuleRadius) : 0.30;
+  const capsuleHeight = config.capsuleHeight !== undefined ? parseFloat(config.capsuleHeight) : 1.60;
+
+  try { playerEntity.addComponent('collision', { type: 'capsule', radius: capsuleRadius, height: capsuleHeight }); }
+  catch (e) { console.warn('[phys] add capsule collision failed:', e); }
+
+  try {
+    playerEntity.addComponent('rigidbody', {
+      type: 'dynamic',
+      mass: 70,
+      friction: 0.45,
+      restitution: 0.0,
+      linearDamping: 0.15,
+      angularDamping: 0.999
+    });
+    playerEntity.rigidbody.angularFactor = new pc.Vec3(0, 0, 0); // éviter roulis
+  } catch (e) { console.warn('[phys] add rigidbody failed:', e); }
 
-  // Logs utiles
-  console.log("[VIEWER] physics:", physicsEnabled, "env:", !!envEntity, "sog:", !!modelEntity);
+  // Spawn
+  playerEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+  app.root.addChild(playerEntity);
+
+  // Caméra -> enfant Player (yeux)
+  const eyes = config.eyesOffsetY !== undefined ? parseFloat(config.eyesOffsetY) : Math.max(0.1, capsuleHeight * 0.9);
+  try {
+    cameraEntity.reparent(playerEntity);
+    cameraEntity.setLocalPosition(0, eyes, 0);
+    cameraEntity.setLocalEulerAngles(0, 0, 0);
+  } catch (e) { console.warn('[phys] camera reparent failed:', e); }
+
+  // Gravité selon freeFly
+  const freeFly = !!config.freeFly;
+  app.scene.gravity = freeFly ? new pc.Vec3(0,0,0) : new pc.Vec3(0,-9.81,0);
 }
 
 /* -------------------------------------------
    API helper : repositionner caméra/joueur
 -------------------------------------------- */
 export function resetViewerCamera(x, y, z) {
-  if (!app || !cameraEntity) return;
+  if (!app || !cameraEntity) { console.warn('[viewer] resetViewerCamera: app/camera missing'); return; }
   const nx = (x !== undefined) ? parseFloat(x) : chosenCameraX;
   const ny = (y !== undefined) ? parseFloat(y) : chosenCameraY;
   const nz = (z !== undefined) ? parseFloat(z) : chosenCameraZ;
 
   if (playerEntity && playerEntity.rigidbody) {
-    playerEntity.rigidbody.teleport(nx, ny, nz, playerEntity.getRotation());
-    playerEntity.rigidbody.linearVelocity = pc.Vec3.ZERO.clone();
-    playerEntity.rigidbody.angularVelocity = pc.Vec3.ZERO.clone();
+    try {
+      playerEntity.rigidbody.teleport(nx, ny, nz, playerEntity.getRotation());
+      playerEntity.rigidbody.linearVelocity = pc.Vec3.ZERO.clone();
+      playerEntity.rigidbody.angularVelocity = pc.Vec3.ZERO.clone();
+      step('resetViewerCamera: teleported player', { nx, ny, nz });
+    } catch (e) {
+      console.warn('[viewer] teleport failed, fallback to camera setPosition:', e);
+      cameraEntity.setPosition(nx, ny, nz);
+    }
   } else {
     cameraEntity.setPosition(nx, ny, nz);
+    step('resetViewerCamera: camera moved (no player)', { nx, ny, nz });
   }
 }