Update viewer.js

viewer.js

@@ -61,7 +61,7 @@ function traverse(entity, callback) {
 }
 
 /* -------------------------------------------
-   Chargement unique de orbit-camera.js
+   Chargement unique de ctrl_camera_pr_env.js
 -------------------------------------------- */
 
 async function ensureOrbitScriptsLoaded() {
@@ -73,14 +73,15 @@ async function ensureOrbitScriptsLoaded() {
 
   window.__PLY_ORBIT_LOADING__ = new Promise((resolve, reject) => {
     const s = document.createElement("script");
-    s.src = "https://mikafil-viewer-sgos.static.hf.space/orbit-camera.js";
+    // 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 = () => {
       window.__PLY_ORBIT_LOADED__ = true;
       resolve();
     };
     s.onerror = (e) => {
-      console.error("[viewer.js] Failed to load orbit-camera.js", e);
+      console.error("[viewer.js] Failed to load ctrl_camera_pr_env.js", e);
       reject(e);
     };
     document.head.appendChild(s);
@@ -97,6 +98,7 @@ let pc;
 export let app = null;
 let cameraEntity = null;
 let modelEntity = null;
+let envEntity = null;          // <<< GLB instancié (focusEntity collisions)
 let viewerInitialized = false;
 let resizeObserver = null;
 let resizeTimeout = null;
@@ -349,28 +351,23 @@ export async function initializeViewer(config, instanceId) {
     canvas.removeEventListener("blur", onCanvasBlur);
   });
 
-  // --- Enregistre les assets en 2 phases ---
-  // Phase 1 : .sog (priorité) ⇒ time-to-first-pixel
+  // --- 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 });
-  app.assets.add(sogAsset);
-
-  // Phase 2 (déférée) : glb + présentoir
   const glbAsset = new pc.Asset("glb", "container", { url: glbUrl });
-  const presentoirAsset = new pc.Asset("presentoir", "container", { url: presentoirUrl });
+  app.assets.add(sogAsset);
   app.assets.add(glbAsset);
-  app.assets.add(presentoirAsset);
 
-  // Assure orbit-camera.js (nécessaire pour les scripts d'input)
+  // Assure la free-cam + collisions
   await ensureOrbitScriptsLoaded();
 
-  // ---------- PHASE 1 : charger le .sog, démarrer tout de suite ----------
+  // ---------- CHARGEMENT SOG + GLB AVANT CREATION CAMERA ----------
   await new Promise((resolve, reject) => {
-    const loader1 = new pc.AssetListLoader([sogAsset], app.assets);
-    loader1.load(() => resolve());
-    loader1.on('error', reject);
+    const loader = new pc.AssetListLoader([sogAsset, glbAsset], app.assets);
+    loader.load(() => resolve());
+    loader.on('error', reject);
   });
 
-  app.start(); // démarre l'update loop le plus tôt possible
+  app.start(); // démarre l'update loop dès que possible
   progressDialog.style.display = "none";
 
   // --- Modèle principal (GSplat via .sog) ---
@@ -381,7 +378,18 @@ export async function initializeViewer(config, instanceId) {
   modelEntity.setLocalScale(modelScale, modelScale, modelScale);
   app.root.addChild(modelEntity);
 
-  // --- Caméra + scripts d’input ---
+  // --- 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).");
+  }
+
+  // --- 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),
@@ -392,9 +400,11 @@ export async function initializeViewer(config, instanceId) {
   cameraEntity.lookAt(modelEntity.getPosition());
   cameraEntity.addComponent("script");
 
+  // >>> focusEntity = GLB en priorité (sinon fallback gsplat) <<<
   cameraEntity.script.create("orbitCamera", {
     attributes: {
-      focusEntity: glbAsset,
+      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,
@@ -418,6 +428,8 @@ export async function initializeViewer(config, instanceId) {
 
   // Taille initiale
   app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
+
+  // IMPORTANT : si la free-cam est active, ne pas "forcer" un reset d'orbite.
   app.once("update", () => resetViewerCamera());
 
   // ---------- Perf dynamique : DPR temporairement réduit pendant interaction ----------
@@ -425,42 +437,33 @@ export async function initializeViewer(config, instanceId) {
     const clamped = Math.max(0.5, Math.min(val, maxDevicePixelRatio));
     if (app.graphicsDevice.maxPixelRatio !== clamped) {
       app.graphicsDevice.maxPixelRatio = clamped;
-      // Force un resize pour appliquer immédiatement
       app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight);
     }
   };
 
   const bumpInteraction = () => {
-    // baisse DPR pendant l'interaction
     setDpr(interactDpr);
     if (idleTimer) clearTimeout(idleTimer);
     idleTimer = setTimeout(() => {
-      // restaure DPR max quand l'utilisateur s'arrête
       setDpr(Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio));
     }, idleRestoreDelay);
   };
 
-  // Hooks d'interaction
   const interactionEvents = ["mousedown", "mousemove", "mouseup", "wheel", "touchstart", "touchmove", "keydown"];
   interactionEvents.forEach((ev) => {
     canvas.addEventListener(ev, bumpInteraction, { passive: true });
   });
 
-  // ---------- PHASE 2 (déférée) : charger sol/environnement et tooltips ----------
-  // On charge le reste sans bloquer l’affichage initial
+  // ---------- 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([glbAsset, presentoirAsset], app.assets);
+        const loader2 = new pc.AssetListLoader([presentoirAsset], app.assets);
         loader2.load(() => resolve());
       });
 
-      // Sol / environnement
-      const glbEntity = glbAsset.resource ? glbAsset.resource.instantiateRenderEntity() : null;
-      if (glbEntity) {
-        app.root.addChild(glbEntity);
-      }
-
       const presentoirEntity =
         presentoirAsset.resource ? presentoirAsset.resource.instantiateRenderEntity() : null;
       if (presentoirEntity) {
@@ -468,6 +471,7 @@ export async function initializeViewer(config, instanceId) {
         app.root.addChild(presentoirEntity);
       }
 
+      // 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;
@@ -484,19 +488,16 @@ export async function initializeViewer(config, instanceId) {
           });
         }
 
-        if (glbEntity) {
-          traverse(glbEntity, (node) => {
+        if (envEntity) {
+          traverse(envEntity, (node) => {
             if (node.render && node.render.meshInstances) {
               for (const mi of node.render.meshInstances) mi.material = matSol;
             }
           });
-
-          // ////// MODIFIE A LA MANO FAIRE GAFFE //////
-          glbEntity.setLocalScale(10, 10, 10);
         }
       }
 
-      // Tooltips (optionnels) — chargés après premier rendu
+      // Tooltips (optionnels)
       try {
         if (config.tooltips_url) {
           import("./tooltips.js")
@@ -528,10 +529,27 @@ export async function initializeViewer(config, instanceId) {
 export function resetViewerCamera() {
   try {
     if (!cameraEntity || !modelEntity || !app) return;
-    const orbitCam = cameraEntity.script.orbitCamera;
-    if (!orbitCam) 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;
+    }
+
+    // --- 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(modelPos);