Update deplacement_dans_env/viewer_pr_env.js

deplacement_dans_env/viewer_pr_env.js

@@ -1,10 +1,11 @@
-// viewer_pr_env.js
+// viewer.js
 // ==============================
 
 /* -------------------------------------------
    Utils
 -------------------------------------------- */
 
+// (Conservé pour compat, même si .sog n'en a pas besoin)
 async function loadImageAsTexture(url, app) {
   return new Promise((resolve, reject) => {
     const img = new window.Image();
@@ -72,7 +73,7 @@ async function ensureOrbitScriptsLoaded() {
 
   window.__PLY_ORBIT_LOADING__ = new Promise((resolve, reject) => {
     const s = document.createElement("script");
-    // Script caméra libre + collisions (garde le nom public "orbitCamera")
+    // IMPORTANT : charger le script free-camera + collisions (pas l'ancienne orbit-camera)
     s.src = "https://mikafil-viewer-sgos.static.hf.space/deplacement_dans_env/ctrl_camera_pr_env.js";
     s.async = true;
     s.onload = () => {
@@ -80,7 +81,7 @@ async function ensureOrbitScriptsLoaded() {
       resolve();
     };
     s.onerror = (e) => {
-      console.error("[viewer.js] Failed to load orbit-camera script", e);
+      console.error("[viewer.js] Failed to load ctrl_camera_pr_env.js", e);
       reject(e);
     };
     document.head.appendChild(s);
@@ -96,41 +97,54 @@ async function ensureOrbitScriptsLoaded() {
 let pc;
 export let app = null;
 let cameraEntity = null;
-let modelEntity = null; // gsplat principal (oeuvre)
-let envEntity = null;   // GLB d'environnement / présentoir
+let modelEntity = null;
+let envEntity = null;          // <<< GLB instancié (focusEntity collisions)
 let viewerInitialized = false;
 let resizeObserver = null;
+let resizeTimeout = null;
 
 // paramètres courants de l'instance
 let chosenCameraX, chosenCameraY, chosenCameraZ;
-let distanceMin, minAngle, maxAngle, minAzimuth, maxAzimuth, minY;
+let minZoom, maxZoom, minAngle, maxAngle, minAzimuth, maxAzimuth, minY;
 let modelX, modelY, modelZ, modelScale, modelRotationX, modelRotationY, modelRotationZ;
 let presentoirScaleX, presentoirScaleY, presentoirScaleZ;
-let sogsUrl, glbUrl;
+let sogUrl, glbUrl, presentoirUrl;
 let color_bg_hex, color_bg, espace_expo_bool;
 
+// perf dynamique
+let maxDevicePixelRatio = 1.75;   // plafond par défaut (configurable)
+let interactDpr = 1.0;            // DPR pendant interaction
+let idleRestoreDelay = 350;       // ms avant de restaurer le DPR
+let idleTimer = null;
+
 /* -------------------------------------------
    Initialisation
 -------------------------------------------- */
 
 export async function initializeViewer(config, instanceId) {
-  // une seule initialisation par import
   if (viewerInitialized) return;
 
   const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
   const isMobile = isIOS || /Android/i.test(navigator.userAgent);
 
   // --- Configuration ---
-  sogsUrl = config.sogs_json_url || null;
-  glbUrl = config.glb_url || null;
-
-  // rétro-compat minZoom => distanceMin (conservé pour compat mais non utilisé par la free cam)
-  distanceMin = config.minZoom !== undefined
-    ? parseFloat(config.minZoom)
-    : (config.distanceMin !== undefined ? parseFloat(config.distanceMin) : 1);
-
-  minAngle = parseFloat(config.minAngle ?? "-45");
-  maxAngle = parseFloat(config.maxAngle ?? "90");
+  // Nouveau format .sog (et compat si seul sogs_json_url est présent)
+  sogUrl = config.sog_url || config.sogs_json_url;
+
+  glbUrl =
+    config.glb_url !== undefined
+      ? config.glb_url
+      : "https://huggingface.co/datasets/MikaFil/viewer_gs/resolve/main/ressources/espace_expo/sol_blanc_2.glb";
+
+  presentoirUrl =
+    config.presentoir_url !== undefined
+      ? config.presentoir_url
+      : "https://huggingface.co/datasets/MikaFil/viewer_gs/resolve/main/ressources/espace_expo/sol_blanc_2.glb";
+
+  minZoom = parseFloat(config.minZoom || "1");
+  maxZoom = parseFloat(config.maxZoom || "20");
+  minAngle = parseFloat(config.minAngle || "-2000");
+  maxAngle = parseFloat(config.maxAngle || "2000");
   minAzimuth = config.minAzimuth !== undefined ? parseFloat(config.minAzimuth) : -360;
   maxAzimuth = config.maxAzimuth !== undefined ? parseFloat(config.maxAzimuth) : 360;
   minY = config.minY !== undefined ? parseFloat(config.minY) : 0;
@@ -143,10 +157,9 @@ export async function initializeViewer(config, instanceId) {
   modelRotationY = config.modelRotationY !== undefined ? parseFloat(config.modelRotationY) : 0;
   modelRotationZ = config.modelRotationZ !== undefined ? parseFloat(config.modelRotationZ) : 0;
 
-  // défauts à 1 (et non 0) pour éviter l'invisibilité si manquants
-  presentoirScaleX = config.presentoirScaleX !== undefined ? parseFloat(config.presentoirScaleX) : 1;
-  presentoirScaleY = config.presentoirScaleY !== undefined ? parseFloat(config.presentoirScaleY) : 1;
-  presentoirScaleZ = config.presentoirScaleZ !== undefined ? parseFloat(config.presentoirScaleZ) : 1;
+  presentoirScaleX = config.presentoirScaleX !== undefined ? parseFloat(config.presentoirScaleX) : 0;
+  presentoirScaleY = config.presentoirScaleY !== undefined ? parseFloat(config.presentoirScaleY) : 0;
+  presentoirScaleZ = config.presentoirScaleZ !== undefined ? parseFloat(config.presentoirScaleZ) : 0;
 
   const cameraX = config.cameraX !== undefined ? parseFloat(config.cameraX) : 0;
   const cameraY = config.cameraY !== undefined ? parseFloat(config.cameraY) : 2;
@@ -164,6 +177,17 @@ export async function initializeViewer(config, instanceId) {
   chosenCameraY = isMobile ? cameraYPhone : cameraY;
   chosenCameraZ = isMobile ? cameraZPhone : cameraZ;
 
+  // Options perf configurables
+  if (config.maxDevicePixelRatio !== undefined) {
+    maxDevicePixelRatio = Math.max(0.75, parseFloat(config.maxDevicePixelRatio) || maxDevicePixelRatio);
+  }
+  if (config.interactionPixelRatio !== undefined) {
+    interactDpr = Math.max(0.75, parseFloat(config.interactionPixelRatio) || interactDpr);
+  }
+  if (config.idleRestoreDelayMs !== undefined) {
+    idleRestoreDelay = Math.max(120, parseInt(config.idleRestoreDelayMs, 10) || idleRestoreDelay);
+  }
+
   // --- Prépare le canvas unique à cette instance ---
   const canvasId = "canvas-" + instanceId;
   const progressDialog = document.getElementById("progress-dialog-" + instanceId);
@@ -180,7 +204,7 @@ export async function initializeViewer(config, instanceId) {
   canvas.setAttribute("tabindex", "0");
   viewerContainer.insertBefore(canvas, progressDialog);
 
-  // interactions de base (éviter scroll/gestes par défaut sur le canvas)
+  // interactions de base
   canvas.style.touchAction = "none";
   canvas.style.webkitTouchCallout = "none";
   canvas.addEventListener("gesturestart", (e) => e.preventDefault());
@@ -196,33 +220,60 @@ export async function initializeViewer(config, instanceId) {
   );
   canvas.addEventListener(
     "wheel",
-    (e) => { e.preventDefault(); },
+    (e) => {
+      e.preventDefault();
+    },
     { passive: false }
   );
 
   // Bloque le scroll page uniquement quand le pointeur est sur le canvas
-  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"
+  ]);
   let isPointerOverCanvas = false;
   const focusCanvas = () => canvas.focus({ preventScroll: true });
 
-  const onPointerEnter = () => { isPointerOverCanvas = true; focusCanvas(); };
+  const onPointerEnter = () => {
+    isPointerOverCanvas = true;
+    focusCanvas();
+  };
   const onPointerLeave = () => {
     isPointerOverCanvas = false;
     if (document.activeElement === canvas) canvas.blur();
   };
-  const onCanvasBlur = () => { isPointerOverCanvas = false; };
+  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: false });
+  canvas.addEventListener(
+    "touchstart",
+    () => {
+      focusCanvas();
+    },
+    { passive: false }
+  );
   canvas.addEventListener("blur", onCanvasBlur);
 
   const onKeyDownCapture = (e) => {
     if (!isPointerOverCanvas) return;
-    if (scrollKeys.has(e.key) || scrollKeys.has(e.code)) e.preventDefault();
+    if (scrollKeys.has(e.key) || scrollKeys.has(e.code)) {
+      e.preventDefault();
+    }
   };
   window.addEventListener("keydown", onKeyDownCapture, true);
 
@@ -231,7 +282,7 @@ export async function initializeViewer(config, instanceId) {
   // --- Charge PlayCanvas lib ESM (une par module/instance) ---
   if (!pc) {
     pc = await import("https://esm.run/playcanvas");
-    window.pc = pc; // utile pour tooltips.js et debug
+    window.pc = pc; // utiles pour tooltips.js
   }
 
   // --- Crée l'Application ---
@@ -241,13 +292,15 @@ export async function initializeViewer(config, instanceId) {
     twgslUrl: "https://playcanvas.vercel.app/static/lib/twgsl/twgsl.js",
     antialias: false
   });
-  device.maxPixelRatio = Math.min(window.devicePixelRatio, 2);
+
+  // Cap DPR pour limiter le coût CPU/GPU
+  device.maxPixelRatio = Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio);
 
   const opts = new pc.AppOptions();
   opts.graphicsDevice = device;
   opts.mouse = new pc.Mouse(canvas);
   opts.touch = new pc.TouchDevice(canvas);
-  opts.keyboard = new pc.Keyboard(canvas); // scoping clavier au canvas
+  opts.keyboard = new pc.Keyboard(canvas);
   opts.componentSystems = [
     pc.RenderComponentSystem,
     pc.CameraComponentSystem,
@@ -257,26 +310,35 @@ export async function initializeViewer(config, instanceId) {
     pc.CollisionComponentSystem,
     pc.RigidbodyComponentSystem
   ];
+  // GSplatHandler gère nativement les .sog
   opts.resourceHandlers = [pc.TextureHandler, pc.ContainerHandler, pc.ScriptHandler, pc.GSplatHandler];
 
   app = new pc.Application(canvas, opts);
   app.setCanvasFillMode(pc.FILLMODE_NONE);
   app.setCanvasResolution(pc.RESOLUTION_AUTO);
 
+  // --- Debounce resize (moins de rafales) ---
   resizeObserver = new ResizeObserver((entries) => {
-    entries.forEach((entry) => {
-      app.resizeCanvas(entry.contentRect.width, entry.contentRect.height);
-    });
+    if (!entries || !entries.length) return;
+    if (resizeTimeout) clearTimeout(resizeTimeout);
+    resizeTimeout = setTimeout(() => {
+      app.resizeCanvas(entries[0].contentRect.width, entries[0].contentRect.height);
+    }, 60);
   });
   resizeObserver.observe(viewerContainer);
 
-  window.addEventListener("resize", () =>
-    app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight)
-  );
+  window.addEventListener("resize", () => {
+    if (resizeTimeout) clearTimeout(resizeTimeout);
+    resizeTimeout = setTimeout(() => {
+      app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
+    }, 60);
+  });
 
   // Nettoyage complet
   app.on("destroy", () => {
-    try { resizeObserver.disconnect(); } catch {}
+    try {
+      resizeObserver.disconnect();
+    } catch {}
     if (opts.keyboard && opts.keyboard.detach) opts.keyboard.detach();
     window.removeEventListener("keydown", onKeyDownCapture, true);
 
@@ -289,139 +351,175 @@ export async function initializeViewer(config, instanceId) {
     canvas.removeEventListener("blur", onCanvasBlur);
   });
 
-  // --- Enregistre les assets (SAUF orbit script : chargé globalement) ---
-  const assets = {};
-  if (sogsUrl) assets.sogs = new pc.Asset("gsplat", "gsplat", { url: sogsUrl });
-  if (glbUrl)  assets.env  = new pc.Asset("env",   "container", { url: glbUrl });
-
-  for (const k in assets) app.assets.add(assets[k]);
+  // --- Enregistre et charge les assets en 1 phase pour SOG + GLB (focusEntity prêt avant la caméra) ---
+  const sogAsset = new pc.Asset("gsplat", "gsplat", { url: sogUrl });
+  const glbAsset = new pc.Asset("glb", "container", { url: glbUrl });
+  app.assets.add(sogAsset);
+  app.assets.add(glbAsset);
 
-  const loader = new pc.AssetListLoader(Object.values(assets), app.assets);
-
-  // Assure le chargement unique des scripts de caméra
+  // Assure la free-cam + collisions
   await ensureOrbitScriptsLoaded();
 
-  loader.load(() => {
-    app.start();
-    progressDialog.style.display = "none";
-
-    // --- Modèle principal (gsplat) ---
-    if (assets.sogs) {
-      modelEntity = new pc.Entity("model");
-      modelEntity.addComponent("gsplat", { asset: assets.sogs });
-      modelEntity.setLocalPosition(modelX, modelY, modelZ);
-      modelEntity.setLocalEulerAngles(modelRotationX, modelRotationY, modelRotationZ);
-      modelEntity.setLocalScale(modelScale, modelScale, modelScale);
-      app.root.addChild(modelEntity);
-    }
-
-    // --- GLB Environnement / Présentoir (optionnel) ---
-    if (assets.env && assets.env.resource) {
-      const container = assets.env.resource; // pc.ContainerResource
-      envEntity = container.instantiateRenderEntity({
-        castShadows: false,
-        receiveShadows: true
-      });
+  // ---------- CHARGEMENT SOG + GLB AVANT CREATION CAMERA ----------
+  await new Promise((resolve, reject) => {
+    const loader = new pc.AssetListLoader([sogAsset, glbAsset], app.assets);
+    loader.load(() => resolve());
+    loader.on('error', reject);
+  });
 
-      // Position/rotation/échelle (adaptables)
-      envEntity.setLocalPosition(0, 0, 0);
-      envEntity.setLocalEulerAngles(0, 0, 0);
-      envEntity.setLocalScale(presentoirScaleX, presentoirScaleY, presentoirScaleZ);
+  app.start(); // démarre l'update loop dès que possible
+  progressDialog.style.display = "none";
+
+  // --- Modèle principal (GSplat via .sog) ---
+  modelEntity = new pc.Entity("model");
+  modelEntity.addComponent("gsplat", { asset: sogAsset });
+  modelEntity.setLocalPosition(modelX, modelY, modelZ);
+  modelEntity.setLocalEulerAngles(modelRotationX, modelRotationY, modelRotationZ);
+  modelEntity.setLocalScale(modelScale, modelScale, modelScale);
+  app.root.addChild(modelEntity);
+
+  // --- Instancier le GLB d’environnement (collision) ---
+  envEntity = glbAsset.resource ? glbAsset.resource.instantiateRenderEntity() : null;
+  if (envEntity) {
+    envEntity.name = "ENV_GLTF";
+    app.root.addChild(envEntity);
+    // NOTE : évite de changer l'échelle ici, sauf si nécessaire. Si tu DOIS :
+    // envEntity.setLocalScale(1,1,1); // garde l'échelle d'import cohérente
+  } else {
+    console.warn("[viewer.js] GLB resource missing: collisions will fallback on GSplat (aucun mesh).");
+  }
 
-      app.root.addChild(envEntity);
+  // --- Caméra + scripts d’input (free-cam nommée 'orbitCamera' pour compat) ---
+  cameraEntity = new pc.Entity("camera");
+  cameraEntity.addComponent("camera", {
+    clearColor: new pc.Color(color_bg),
+    nearClip: 0.001,
+    farClip: 100
+  });
+  cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+  cameraEntity.lookAt(modelEntity.getPosition());
+  cameraEntity.addComponent("script");
+
+  // >>> focusEntity = GLB en priorité (sinon fallback gsplat) <<<
+  cameraEntity.script.create("orbitCamera", {
+    attributes: {
+      focusEntity: envEntity || modelEntity,
+      // Attributs hérités pour compat, mais seront interprétés par la free-cam
+      inertiaFactor: 0.2,
+      distanceMax: maxZoom,
+      distanceMin: minZoom,
+      pitchAngleMax: maxAngle,
+      pitchAngleMin: minAngle,
+      yawAngleMax: maxAzimuth,
+      yawAngleMin: minAzimuth,
+      minY: minY,
+      frameOnStart: false
+    }
+  });
+  cameraEntity.script.create("orbitCameraInputMouse");
+  cameraEntity.script.create("orbitCameraInputTouch");
+  cameraEntity.script.create("orbitCameraInputKeyboard", {
+    attributes: {
+      forwardSpeed: 1.2,
+      strafeSpeed: 1.2
     }
+  });
+  app.root.addChild(cameraEntity);
 
-    // Entité qui sert d'ancrage visuel (lookAt) : l'oeuvre si dispo, sinon l'env
-    const focusVisual = modelEntity || envEntity;
+  // Taille initiale
+  app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
 
-    // Racine de collision pour la free cam : l'environnement GLB de préférence
-    const collisionRoot = envEntity || modelEntity || null;
+  // IMPORTANT : si la free-cam est active, ne pas "forcer" un reset d'orbite.
+  app.once("update", () => resetViewerCamera());
 
-    // --- Caméra + scripts d’input (free cam + collisions) ---
-    cameraEntity = new pc.Entity("camera");
-    cameraEntity.addComponent("camera", {
-      clearColor: new pc.Color(color_bg[0], color_bg[1], color_bg[2], color_bg[3]),
-      nearClip: 0.001,
-      farClip: 100
-    });
-    cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
-    if (focusVisual) cameraEntity.lookAt(focusVisual.getPosition());
-    cameraEntity.addComponent("script");
+  // ---------- Perf dynamique : DPR temporairement réduit pendant interaction ----------
+  const setDpr = (val) => {
+    const clamped = Math.max(0.5, Math.min(val, maxDevicePixelRatio));
+    if (app.graphicsDevice.maxPixelRatio !== clamped) {
+      app.graphicsDevice.maxPixelRatio = clamped;
+      app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
+    }
+  };
 
-    // Prépare les attributs : les champs inconnus sont ignorés par le script
-    const orbitAttrs = {
-      // Collision root : active le blocage contre le GLB
-      focusEntity: collisionRoot || undefined,
+  const bumpInteraction = () => {
+    setDpr(interactDpr);
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      setDpr(Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio));
+    }, idleRestoreDelay);
+  };
 
-      // Inertie/angles (pitch clampé), yaw libre
-      inertiaFactor: 0.2,
-      pitchAngleMax: maxAngle,
-      pitchAngleMin: minAngle,
+  const interactionEvents = ["mousedown", "mousemove", "mouseup", "wheel", "touchstart", "touchmove", "keydown"];
+  interactionEvents.forEach((ev) => {
+    canvas.addEventListener(ev, bumpInteraction, { passive: true });
+  });
 
-      // Compat (ignorés par le free cam, mais gardés pour ne pas casser la config)
-      distanceMin: distanceMin,
-      yawAngleMax: maxAzimuth,
-      yawAngleMin: minAzimuth,
-      frameOnStart: false,
+  // ---------- CHARGEMENT DIFFÉRÉ : présentoir et tooltips ----------
+  setTimeout(async () => {
+    try {
+      const presentoirAsset = new pc.Asset("presentoir", "container", { url: presentoirUrl });
+      app.assets.add(presentoirAsset);
+      await new Promise((resolve) => {
+        const loader2 = new pc.AssetListLoader([presentoirAsset], app.assets);
+        loader2.load(() => resolve());
+      });
 
-      // Contraintes position
-      minY: minY
-    };
+      const presentoirEntity =
+        presentoirAsset.resource ? presentoirAsset.resource.instantiateRenderEntity() : null;
+      if (presentoirEntity) {
+        presentoirEntity.setLocalScale(presentoirScaleX, presentoirScaleY, presentoirScaleZ);
+        app.root.addChild(presentoirEntity);
+      }
 
-    // Injecte la BBox uniquement si présente dans le config (évite Infinity explicite)
-    const maybeNum = (v) => (v === undefined || v === null || v === "" ? undefined : parseFloat(v));
-    const Xmin = maybeNum(config.Xmin);
-    const Xmax = maybeNum(config.Xmax);
-    const Ymin = maybeNum(config.Ymin);
-    const Ymax = maybeNum(config.Ymax);
-    const Zmin = maybeNum(config.Zmin);
-    const Zmax = maybeNum(config.Zmax);
-
-    if (Xmin !== undefined) orbitAttrs.Xmin = Xmin;
-    if (Xmax !== undefined) orbitAttrs.Xmax = Xmax;
-    if (Ymin !== undefined) orbitAttrs.Ymin = Ymin;
-    if (Ymax !== undefined) orbitAttrs.Ymax = Ymax;
-    if (Zmin !== undefined) orbitAttrs.Zmin = Zmin;
-    if (Zmax !== undefined) orbitAttrs.Zmax = Zmax;
-
-    // Paramètres collision optionnels depuis la config (sinon valeurs par défaut du script)
-    if (config.collisionRadius !== undefined)    orbitAttrs.collisionRadius = parseFloat(config.collisionRadius);
-    if (config.collisionEpsilon !== undefined)   orbitAttrs.collisionEpsilon = parseFloat(config.collisionEpsilon);
-    if (config.moveSpeed !== undefined)          orbitAttrs.moveSpeed = parseFloat(config.moveSpeed);
-    if (config.strafeSpeed !== undefined)        orbitAttrs.strafeSpeed = parseFloat(config.strafeSpeed);
-    if (config.dollySpeed !== undefined)         orbitAttrs.dollySpeed = parseFloat(config.dollySpeed);
-
-    cameraEntity.script.create("orbitCamera", { attributes: orbitAttrs });
-    cameraEntity.script.create("orbitCameraInputMouse");
-    cameraEntity.script.create("orbitCameraInputTouch");
-    cameraEntity.script.create("orbitCameraInputKeyboard", { attributes: { acceleration: 1.0 } });
-    app.root.addChild(cameraEntity);
-
-    app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
-
-    // Reset caméra une fois la première frame prête
-    app.once("update", () => resetViewerCamera());
-
-    // --- Tooltips (optionnels) ---
-    try {
-      if (config.tooltips_url) {
-        import("./tooltips.js")
-          .then((tooltipsModule) => {
-            tooltipsModule.initializeTooltips({
-              app,
-              cameraEntity,
-              modelEntity: focusVisual,
-              tooltipsUrl: config.tooltips_url,
-              defaultVisible: !!config.showTooltipsDefault,
-              moveDuration: config.tooltipMoveDuration || 0.6
-            });
-          })
-          .catch(() => { /* optional */ });
+      // Si pas d'espace expo : recolore GLB & présentoir pour fond uni
+      if (!espace_expo_bool) {
+        const matSol = new pc.StandardMaterial();
+        matSol.blendType = pc.BLEND_NONE;
+        matSol.emissive = new pc.Color(color_bg);
+        matSol.emissiveIntensity = 1;
+        matSol.useLighting = false;
+        matSol.update();
+
+        if (presentoirEntity) {
+          traverse(presentoirEntity, (node) => {
+            if (node.render && node.render.meshInstances) {
+              for (const mi of node.render.meshInstances) mi.material = matSol;
+            }
+          });
+        }
+
+        if (envEntity) {
+          traverse(envEntity, (node) => {
+            if (node.render && node.render.meshInstances) {
+              for (const mi of node.render.meshInstances) mi.material = matSol;
+            }
+          });
+        }
       }
-    } catch (e) { /* optional */ }
 
-    viewerInitialized = true;
-  });
+      // Tooltips (optionnels)
+      try {
+        if (config.tooltips_url) {
+          import("./tooltips.js")
+            .then((tooltipsModule) => {
+              tooltipsModule.initializeTooltips({
+                app,
+                cameraEntity,
+                modelEntity,
+                tooltipsUrl: config.tooltips_url,
+                defaultVisible: !!config.showTooltipsDefault,
+                moveDuration: config.tooltipMoveDuration || 0.6
+              });
+            })
+            .catch(() => { /* optional */ });
+        }
+      } catch (e) { /* optional */ }
+    } catch (e) {
+      console.warn("[viewer.js] Deferred assets load failed:", e);
+    }
+  }, 0);
+
+  viewerInitialized = true;
 }
 
 /* -------------------------------------------
@@ -430,34 +528,43 @@ export async function initializeViewer(config, instanceId) {
 
 export function resetViewerCamera() {
   try {
-    if (!cameraEntity || !app) return;
-
-    // cible visuelle : gsplat prioritaire, sinon glb, sinon (0,0,0)
-    const targetEntity = modelEntity || envEntity;
-    const targetPos = targetEntity ? targetEntity.getPosition().clone() : new pc.Vec3(0, 0, 0);
+    if (!cameraEntity || !modelEntity || !app) return;
+    const camScript = cameraEntity.script && cameraEntity.script.orbitCamera;
+    if (!camScript) return;
+
+    const modelPos = modelEntity.getPosition();
+
+    // Si c'est une FREE-CAM (notre script), ne pas toucher à des champs d'orbite.
+    // On se contente éventuellement de réaligner le regard.
+    const looksLikeOrbit =
+      ("pivotPoint" in camScript) ||
+      ("_distance" in camScript) ||
+      ("_updatePosition" in camScript);
+
+    if (!looksLikeOrbit) {
+      // Free camera : juste orienter vers le modèle si souhaité
+      cameraEntity.lookAt(modelPos);
+      return;
+    }
 
-    const orbitCam = cameraEntity.script && cameraEntity.script.orbitCamera;
-    if (!orbitCam) return;
+    // --- Cas d'une vraie orbit-camera (compat héritée) ---
+    const orbitCam = camScript;
 
     const tempEnt = new pc.Entity();
     tempEnt.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
-    tempEnt.lookAt(targetPos);
+    tempEnt.lookAt(modelPos);
 
     const dist = new pc.Vec3()
-      .sub2(new pc.Vec3(chosenCameraX, chosenCameraY, chosenCameraZ), targetPos)
+      .sub2(new pc.Vec3(chosenCameraX, chosenCameraY, chosenCameraZ), modelPos)
       .length();
 
     cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
-    cameraEntity.lookAt(targetPos);
+    cameraEntity.lookAt(modelPos);
 
-    // Ces champs existent dans la version "orbit" historique ; notre free cam les ignore,
-    // mais on conserve l'initialisation pour compat.
-    if (orbitCam) {
-      orbitCam._targetDistance = Math.max(distanceMin, dist);
-      orbitCam._distance = Math.max(distanceMin, dist);
-    }
+    orbitCam.pivotPoint = modelPos.clone();
+    orbitCam._targetDistance = dist;
+    orbitCam._distance = dist;
 
-    // Recalcule yaw/pitch cibles pour aligner l'orientation
     const rot = tempEnt.getRotation();
     const fwd = new pc.Vec3();
     rot.transformVector(pc.Vec3.FORWARD, fwd);