Update deplacement_dans_env/viewer_pr_env.js

deplacement_dans_env/viewer_pr_env.js

@@ -1,8 +1,11 @@
-// viewer.js
+// viewer_pr_env.js
 // ==============================
+// Version intégrant le contrôleur caméra en local (pas de <script src=...>)
+// + Fix "sortie du monde" : clamp dans la worldAabb et pas de culling de boîtes quasi-globales
+// + Logs détaillés
 
 /* -------------------------------------------
-   Utils
+   Utils communs
 -------------------------------------------- */
 
 // (Conservé pour compat, même si .sog n'en a pas besoin)
@@ -60,34 +63,654 @@ function traverse(entity, callback) {
   }
 }
 
+// Helpers math pour le script caméra
+function vAdd(a,b){ return new pc.Vec3(a.x+b.x,a.y+b.y,a.z+b.z); }
+function vSub(a,b){ return new pc.Vec3(a.x-b.x,a.y-b.y,a.z-b.z); }
+function vScale(v,s){ return new pc.Vec3(v.x*s,v.y*s,v.z*s); }
+function vLen(v){ return Math.sqrt(v.x*v.x+v.y*v.y+v.z*v.z); }
+function vDot(a,b){ return a.x*b.x+a.y*b.y+a.z*b.z; }
+function clamp(v,a,b){ return Math.max(a, Math.min(b,v)); }
+
 /* -------------------------------------------
-   Chargement unique de ctrl_camera_pr_env.js
+   Scripts caméra intégrés (ex-ctrl_camera_pr_env.js)
+   — collisions capsule vs AABBs + cage monde
 -------------------------------------------- */
+function registerFreeCamScripts() {
+  if (window.__PLY_FREECAM_REG__) return;
+  window.__PLY_FREECAM_REG__ = true;
+
+  // ctrl_camera_pr_env.js — corrigé
+
+  var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public pour compat viewer
+
+  // ======================== Attributs ===========================
+  // Look
+  FreeCamera.attributes.add('inertiaFactor', { type: 'number', default: 0.10, title: 'Inertia (rotation)' });
+  FreeCamera.attributes.add('pitchAngleMin', { type: 'number', default: -89, title: 'Pitch Min (deg)' });
+  FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title: 'Pitch Max (deg)' });
+
+  // Sol mini (filet de sécurité)
+  FreeCamera.attributes.add('minY', { type: 'number', default: -10, title: 'Minimum camera Y' });
+
+  // Vitesse (m/s)
+  FreeCamera.attributes.add('moveSpeed',   { type: 'number', default: 2.0, title: 'Move Speed' });
+  FreeCamera.attributes.add('strafeSpeed', { type: 'number', default: 2.0, title: 'Strafe Speed' });
+  FreeCamera.attributes.add('dollySpeed',  { type: 'number', default: 2.0, title: 'Mouse/Pinch Dolly Speed' });
+
+  // Capsule caméra
+  FreeCamera.attributes.add('capsuleRadius',  { type: 'number', default: 0.30, title: 'Capsule Radius (m)' });
+  FreeCamera.attributes.add('capsuleHeight',  { type: 'number', default: 1.60, title: 'Capsule Height (m) — yeux à ~0.9m au-dessus du centre' });
+  FreeCamera.attributes.add('collisionEps',   { type: 'number', default: 0.0005, title: 'Collision Epsilon' });
+
+  // Mouvement "swept"
+  FreeCamera.attributes.add('maxStepDistance', { type: 'number', default: 0.10, title: 'Max step distance (swept move)' }); // réduit (anti-tunnel)
+  FreeCamera.attributes.add('maxResolveIters', { type: 'number', default: 8,    title: 'Max resolve iterations per step' });
+
+  // Escaliers
+  FreeCamera.attributes.add('stepHeight',   { type: 'number', default: 0.35, title: 'Max step-up height (m)' });
+  FreeCamera.attributes.add('stepAhead',    { type: 'number', default: 0.20, title: 'Probe distance ahead for step (m)' });
+  FreeCamera.attributes.add('snapDownMax',  { type: 'number', default: 0.60, title: 'Max snap-down (m)' });
+  FreeCamera.attributes.add('enableGroundSnap', { type: 'boolean', default: true, title: 'Enable ground snap' });
+
+  // AABBs (construction "indoor-safe")
+  FreeCamera.attributes.add('inflateBias',   { type: 'number', default: 0.0,  title: 'Extra inflate AABB (m)' });
+  FreeCamera.attributes.add('mergeGap',      { type: 'number', default: 0.0,  title: 'Merge AABBs gap (0: chevauchement réel seulement)' });
+  FreeCamera.attributes.add('globalCullFrac',{ type: 'number', default: 0.0,  title: 'Cull near-global AABBs (désactivé)' }); // désactivé
+
+  // BBox globale optionnelle (filet additionnel)
+  FreeCamera.attributes.add('Xmin', { type: 'number', default: -Infinity, title: 'BBox Xmin' });
+  FreeCamera.attributes.add('Xmax', { type: 'number', default:  Infinity, title: 'BBox Xmax' });
+  FreeCamera.attributes.add('Ymin', { type: 'number', default: -Infinity, title: 'BBox Ymin' });
+  FreeCamera.attributes.add('Ymax', { type: 'number', default:  Infinity, title: 'BBox Ymax' });
+  FreeCamera.attributes.add('Zmin', { type: 'number', default: -Infinity, title: 'BBox Zmin' });
+  FreeCamera.attributes.add('Zmax', { type: 'number', default:  Infinity, title: 'BBox Zmax' });
+
+  // Compat (pour le viewer)
+  FreeCamera.attributes.add('focusEntity',  { type: 'entity', title: 'Collision Root (ENV GLB)' });
+  FreeCamera.attributes.add('frameOnStart', { type: 'boolean', default: false, title: 'Compat: Frame on Start (unused)' });
+  FreeCamera.attributes.add('yawAngleMin',  { type: 'number', default: -360, title: 'Compat: Yaw Min (unused)' });
+  FreeCamera.attributes.add('yawAngleMax',  { type: 'number', default:  360, title: 'Compat: Yaw Max (unused)' });
+  FreeCamera.attributes.add('distanceMin',  { type: 'number', default:  0.1,  title: 'Compat: Distance Min (unused)' });
+
+  // ======================== Capsule util ===========================
+  function capsuleSegment(p, height, radius) {
+    var seg = Math.max(0, height - 2*radius);
+    var half = seg * 0.5;
+    return { a: new pc.Vec3(p.x, p.y - half, p.z), b: new pc.Vec3(p.x, p.y + half, p.z), len: seg };
+  }
+
+  function capsuleVsAabbPenetration(center, height, radius, aabb, outPush) {
+    var seg = capsuleSegment(center, height, radius);
+    var pts = [seg.a, seg.b, new pc.Vec3((seg.a.x+seg.b.x)/2,(seg.a.y+seg.b.y)/2,(seg.a.z+seg.b.z)/2)];
+
+    var amin = aabb.getMin();
+    var amax = aabb.getMax();
+    var eps = 1e-9;
+
+    var bestPen = 0;
+    var bestPush = null;
+
+    for (var i=0;i<pts.length;i++){
+      var p = pts[i];
+      var cx = clamp(p.x, amin.x, amax.x);
+      var cy = clamp(p.y, amin.y, amax.y);
+      var cz = clamp(p.z, amin.z, amax.z);
+
+      var dx = p.x - cx, dy = p.y - cy, dz = p.z - cz;
+      var d2 = dx*dx + dy*dy + dz*dz;
+      var d = Math.sqrt(Math.max(d2, eps));
+      var pen = radius - d;
+
+      if (pen > bestPen) {
+        if (d > 1e-6) {
+          bestPush = new pc.Vec3(dx/d * pen, dy/d * pen, dz/d * pen);
+        } else {
+          var ex = Math.min(Math.abs(p.x - amin.x), Math.abs(amax.x - p.x));
+          var ey = Math.min(Math.abs(p.y - amin.y), Math.abs(amax.y - p.y));
+          var ez = Math.min(Math.abs(p.z - amin.z), Math.abs(amax.z - p.z));
+          if (ex <= ey && ex <= ez) bestPush = new pc.Vec3((Math.abs(p.x - amin.x) < Math.abs(amax.x - p.x) ? -1:1)*pen,0,0);
+          else if (ey <= ex && ey <= ez) bestPush = new pc.Vec3(0,(Math.abs(p.y - amin.y) < Math.abs(amax.y - p.y) ? -1:1)*pen,0);
+          else bestPush = new pc.Vec3(0,0,(Math.abs(p.z - amin.z) < Math.abs(amax.z - p.z) ? -1:1)*pen);
+        }
+        bestPen = pen;
+      }
+    }
 
-async function ensureOrbitScriptsLoaded() {
-  if (window.__PLY_ORBIT_LOADED__) return;
-  if (window.__PLY_ORBIT_LOADING__) {
-    await window.__PLY_ORBIT_LOADING__;
-    return;
+    if (bestPen > 0 && outPush) outPush.copy(bestPush);
+    return bestPen;
   }
 
-  window.__PLY_ORBIT_LOADING__ = new Promise((resolve, reject) => {
-    const s = document.createElement("script");
-    // 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 ctrl_camera_pr_env.js", e);
-      reject(e);
-    };
-    document.head.appendChild(s);
+  // ======================== Getters pitch/yaw ===========================
+  Object.defineProperty(FreeCamera.prototype, 'pitch', {
+    get: function () { return this._targetPitch; },
+    set: function (v) { this._targetPitch = pc.math.clamp(v, this.pitchAngleMin, this.pitchAngleMax); }
+  });
+  Object.defineProperty(FreeCamera.prototype, 'yaw', {
+    get: function () { return this._targetYaw; },
+    set: function (v) { this._targetYaw = v; }
   });
 
-  await window.__PLY_ORBIT_LOADING__;
+  // ======================== Init ===========================
+  FreeCamera.prototype.initialize = function () {
+    var q = this.entity.getRotation();
+    var f = new pc.Vec3(); q.transformVector(pc.Vec3.FORWARD, f);
+
+    this._yaw = Math.atan2(f.x, f.z) * pc.math.RAD_TO_DEG;
+    var yawQuat = new pc.Quat().setFromEulerAngles(0, -this._yaw, 0);
+    var noYawQ  = new pc.Quat().mul2(yawQuat, q);
+    var fNoYaw  = new pc.Vec3(); noYawQ.transformVector(pc.Vec3.FORWARD, fNoYaw);
+    this._pitch = pc.math.clamp(Math.atan2(-fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG, this.pitchAngleMin, this.pitchAngleMax);
+
+    this._targetYaw = this._yaw;
+    this._targetPitch = this._pitch;
+    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
+
+    this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
+    this.state = this.app.systems.script.app.freeCamState;
+
+    // Colliders + cage monde
+    this._buildAabbsFromFocus();
+
+    var p0 = this.entity.getPosition().clone();
+    var p1 = this._resolveCapsuleCollisions(p0, this.maxResolveIters);
+    if (vLen(vSub(p1,p0)) > this.capsuleRadius * 0.25) {
+      var dir = vSub(p1,p0); var L = vLen(dir)||1;
+      p1 = vAdd(p0, vScale(dir, (this.capsuleRadius*0.25)/L));
+    }
+    this._clampBBoxMinY(p1);
+    p1 = this._clampInsideWorld(p1);     // <<< clamp dans la cage
+    this.entity.setPosition(p1);
+
+    var self = this;
+    this._onResize = function(){ self._checkAspectRatio(); };
+    window.addEventListener('resize', this._onResize, false);
+    this._checkAspectRatio();
+
+    console.log('[FREE-CAM:init] pos=', p1);
+  };
+
+  FreeCamera.prototype.update = function (dt) {
+    var t = this.inertiaFactor === 0 ? 1 : Math.min(dt / this.inertiaFactor, 1);
+    this._yaw   = pc.math.lerp(this._yaw,   this._targetYaw,   t);
+    this._pitch = pc.math.lerp(this._pitch, this._targetPitch, t);
+    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
+
+    var pos = this.entity.getPosition().clone();
+    pos = this._resolveCapsuleCollisions(pos, this.maxResolveIters);
+    this._clampBBoxMinY(pos);
+    pos = this._clampInsideWorld(pos);   // <<< clamp dans la cage à chaque frame
+    this.entity.setPosition(pos);
+  };
+
+  FreeCamera.prototype._checkAspectRatio = function () {
+    var gd = this.app.graphicsDevice;
+    if (!gd) return;
+    this.entity.camera.horizontalFov = (gd.height > gd.width);
+  };
+
+  // ======================== Build colliders ===========================
+  FreeCamera.prototype._buildAabbsFromFocus = function () {
+    this._colliders = [];
+    this._worldAabb = null;
+    this._useCollision = false;
+    this._containMin = null;
+    this._containMax = null;
+
+    var root = this.focusEntity;
+    if (!root) {
+      console.warn('[FREE-CAM] focusEntity manquant — pas de collisions.');
+      return;
+    }
+
+    // Collecte des AABBs de mesh
+    var boxes = [];
+    var stack = [root];
+    while (stack.length) {
+      var e = stack.pop();
+      var rc = e.render;
+      if (rc && rc.meshInstances && rc.meshInstances.length) {
+        for (var i=0;i<rc.meshInstances.length;i++){
+          var bb = rc.meshInstances[i].aabb;
+          boxes.push(new pc.BoundingBox(bb.center.clone(), bb.halfExtents.clone()));
+        }
+      }
+      var ch = e.children;
+      if (ch && ch.length) for (var j=0;j<ch.length;j++) stack.push(ch[j]);
+    }
+    if (boxes.length === 0) {
+      console.warn('[FREE-CAM] Aucun meshInstance sous focusEntity — pas de collisions.');
+      return;
+    }
+
+    // Monde
+    var world = boxes[0].clone();
+    for (var k=1;k<boxes.length;k++) world.add(boxes[k]);
+
+    // Désactiver tout culling des quasi-globales : on garde tout
+    var filtered = boxes;
+
+    // Merge strict
+    var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap||0));
+
+    // Petit gonflage optionnel
+    var inflate = Math.max(0, this.inflateBias||0);
+    for (var n=0;n<merged.length;n++){
+      merged[n].halfExtents.add(new pc.Vec3(inflate, inflate, inflate));
+    }
+
+    // Enregistrer
+    if (merged.length>0) {
+      for (var t=0;t<merged.length;t++) this._colliders.push({ aabb: merged[t] });
+      this._worldAabb = world;
+      this._useCollision = true;
+
+      // Cage monde : world min/max moins le rayon pour éviter le clipping
+      var R = Math.max(0, this.capsuleRadius || 0.3);
+      var wmin = world.getMin().clone().add(new pc.Vec3(R, R, R));
+      var wmax = world.getMax().clone().sub(new pc.Vec3(R, R, R));
+      this._containMin = wmin;
+      this._containMax = wmax;
+    }
+
+    console.log('[FREE-CAM] colliders=', this._colliders.length, '(raw=', boxes.length, ')');
+    if (this._worldAabb) {
+      console.log('[FREE-CAM] worldAabb min=', this._worldAabb.getMin(), 'max=', this._worldAabb.getMax());
+      console.log('[FREE-CAM] contain box min=', this._containMin, 'max=', this._containMax);
+    }
+  };
+
+  FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
+    if (!boxes || boxes.length<=1) return boxes.slice();
+    var out = boxes.slice();
+    var tol = Math.max(0, gap||0);
+    var changed = true;
+
+    function overlap(a,b,t){
+      var amin=a.getMin(), amax=a.getMax();
+      var bmin=b.getMin(), bmax=b.getMax();
+      return !(
+        amax.x < bmin.x - t || amin.x > bmax.x + t ||
+        amax.y < bmin.y - t || amin.y > bmax.y + t ||
+        amax.z < bmin.z - t || amin.z > bmax.z + t
+      );
+    }
+
+    while (changed){
+      changed=false;
+      var next=[], used=new Array(out.length).fill(false);
+      for (var i=0;i<out.length;i++){
+        if (used[i]) continue;
+        var acc = out[i];
+        for (var j=i+1;j<out.length;j++){
+          if (used[j]) continue;
+          if (overlap(acc,out[j],tol)){
+            var aMin=acc.getMin(), aMax=acc.getMax();
+            var bMin=out[j].getMin(), bMax=out[j].getMax();
+            var nMin=new pc.Vec3(Math.min(aMin.x,bMin.x), Math.min(aMin.y,bMin.y), Math.min(aMin.z,bMin.z));
+            var nMax=new pc.Vec3(Math.max(aMax.x,bMax.x), Math.max(aMax.y,bMax.y), Math.max(aMax.z,bMax.z));
+            var c=nMin.clone().add(nMax).mulScalar(0.5);
+            var h=new pc.Vec3(Math.abs(nMax.x-c.x), Math.abs(nMax.y-c.y), Math.abs(nMax.z-c.z));
+            acc = new pc.BoundingBox(c,h);
+            used[j]=true; changed=true;
+          }
+        }
+        used[i]=true; next.push(acc);
+      }
+      out=next;
+    }
+    return out;
+  };
+
+  // ======================== BBox globale + minY ===========================
+  FreeCamera.prototype._bboxEnabled = function () {
+    return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
+  };
+  FreeCamera.prototype._clampBBoxMinY = function (p) {
+    if (p.y < this.minY) p.y = this.minY;
+    if (!this._bboxEnabled()) return;
+    p.x = clamp(p.x, this.Xmin, this.Xmax);
+    p.y = clamp(p.y, Math.max(this.Ymin, this.minY), this.Ymax);
+    p.z = clamp(p.z, this.Zmin, this.Zmax);
+  };
+
+  // >>> Cage monde : clamp interne <<<
+  FreeCamera.prototype._clampInsideWorld = function(p){
+    if (!this._containMin || !this._containMax) return p;
+    p.x = Math.max(this._containMin.x, Math.min(this._containMax.x, p.x));
+    p.y = Math.max(Math.max(this._containMin.y, this.minY), Math.min(this._containMax.y, p.y));
+    p.z = Math.max(this._containMin.z, Math.min(this._containMax.z, p.z));
+    return p;
+  };
+  FreeCamera.prototype._isOutsideWorld = function(p){
+    if (!this._containMin || !this._containMax) return false;
+    return (p.x < this._containMin.x || p.x > this._containMax.x ||
+            p.y < Math.max(this._containMin.y, this.minY) || p.y > this._containMax.y ||
+            p.z < this._containMin.z || p.z > this._containMax.z);
+  };
+
+  // ======================== Capsule vs AABBs : resolve ===========================
+  FreeCamera.prototype._resolveCapsuleCollisions = function (pos, maxIters) {
+    if (!this._useCollision) return pos.clone();
+
+    var p = pos.clone();
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight);
+    var eps = Math.max(1e-7, this.collisionEps);
+
+    if (!this._colliders || this._colliders.length===0) return p;
+
+    var iters = Math.max(1, maxIters||1);
+    for (var iter=0; iter<iters; iter++){
+      var moved = false;
+
+      for (var i=0;i<this._colliders.length;i++){
+        var aabb = this._colliders[i].aabb;
+        var push = new pc.Vec3();
+        var pen = capsuleVsAabbPenetration(p, H, R, aabb, push);
+        if (pen > eps) {
+          p.add(push);
+          moved = true;
+        }
+      }
+      if (!moved) break;
+    }
+    return p;
+  };
+
+  // ======================== Mvt principal : swept + step + snap ===========================
+  FreeCamera.prototype._moveSwept = function (from, delta) {
+    if (!this._useCollision) return vAdd(from, delta);
+
+    var maxStep = Math.max(0.01, this.maxStepDistance||0.1);
+    var dist = vLen(delta);
+    if (dist <= maxStep) return this._moveStep(from, delta);
+
+    var steps = Math.ceil(dist / maxStep);
+    var step = vScale(delta, 1/steps);
+    var cur = from.clone();
+    for (var i=0;i<steps;i++) cur = this._moveStep(cur, step);
+    return cur;
+  };
+
+  FreeCamera.prototype._moveStep = function (from, delta) {
+    var target = vAdd(from, delta);
+    var after  = this._resolveCapsuleCollisions(target, this.maxResolveIters);
+    var collided = (vLen(vSub(after, target)) > 0);
+
+    if (!collided) {
+      if (this.enableGroundSnap) after = this._snapDown(after);
+      after = this._clampInsideWorld(after); // <<< clamp
+      return after;
+    }
+
+    var n = this._estimateNormal(after);
+    if (n) {
+      var desire = delta.clone();
+      var slide = vSub(desire, vScale(n, vDot(desire, n)));
+      var slideTarget = vAdd(from, slide);
+      var slideAfter  = this._resolveCapsuleCollisions(slideTarget, this.maxResolveIters);
+
+      // Step-up si slide insuffisant
+      if (vLen(vSub(slideAfter, slideTarget)) > 0) {
+        var stepped = this._tryStepUp(from, desire);
+        if (stepped) {
+          if (this.enableGroundSnap) stepped = this._snapDown(stepped);
+          stepped = this._clampInsideWorld(stepped); // <<< clamp
+          return stepped;
+        }
+      }
+
+      if (this.enableGroundSnap) slideAfter = this._snapDown(slideAfter);
+      slideAfter = this._clampInsideWorld(slideAfter); // <<< clamp
+      return slideAfter;
+    }
+
+    if (this.enableGroundSnap) after = this._snapDown(after);
+    after = this._clampInsideWorld(after); // <<< clamp
+    return after;
+  };
+
+  // Normale approx via micro-probes
+  FreeCamera.prototype._estimateNormal = function (p) {
+    if (!this._colliders) return null;
+    var probe = 0.02;
+    var base = this._resolveCapsuleCollisions(p, this.maxResolveIters);
+    var nx = this._resolveCapsuleCollisions(new pc.Vec3(p.x+probe,p.y,p.z), this.maxResolveIters);
+    var px = this._resolveCapsuleCollisions(new pc.Vec3(p.x-probe,p.y,p.z), this.maxResolveIters);
+    var ny = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y+probe,p.z), this.maxResolveIters);
+    var py = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y-probe,p.z), this.maxResolveIters);
+    var nz = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y,p.z+probe), this.maxResolveIters);
+    var pz = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y,p.z-probe), this.maxResolveIters);
+
+    function d(a,b){ return vLen(vSub(a,b)); }
+    var dx = d(nx,base) - d(px,base);
+    var dy = d(ny,base) - d(py,base);
+    var dz = d(nz,base) - d(pz,base);
+    var n  = new pc.Vec3(dx,dy,dz);
+    var L = vLen(n);
+    if (L < 1e-5) return null;
+    return vScale(n, 1/L);
+  };
+
+  // Step-up : monter une marche (jusqu'à stepHeight)
+  FreeCamera.prototype._tryStepUp = function (from, wishDelta) {
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight);
+    var maxH = Math.max(0, this.stepHeight || 0.35);
+    var ahead = Math.max(0.05, this.stepAhead || 0.20);
+
+    var horiz = new pc.Vec3(wishDelta.x, 0, wishDelta.z);
+    var hLen = vLen(horiz);
+    if (hLen < 1e-6) return null;
+    horiz = vScale(horiz, 1/hLen);
+
+    var probe = vAdd(from, vScale(horiz, Math.min(hLen, ahead)));
+    var trials = 3;
+    for (var i=1;i<=trials;i++){
+      var up = maxH * (i/trials);
+      var raised = new pc.Vec3(probe.x, probe.y + up, probe.z);
+      raised = this._resolveCapsuleCollisions(raised, this.maxResolveIters);
+      var stepped = this._resolveCapsuleCollisions(vAdd(raised, wishDelta), this.maxResolveIters);
+
+      if (vLen(vSub(stepped, raised)) > 0.02) return stepped;
+    }
+    return null;
+  };
+
+  // Snap-down : redéposer sur le sol si on flotte un peu (descente d'escalier)
+  FreeCamera.prototype._snapDown = function (p) {
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight);
+    var maxDown = Math.max(0, this.snapDownMax || 0.6);
+
+    var steps = 4;
+    var step = maxDown / steps;
+    var cur = p.clone();
+    for (var i=0;i<steps;i++){
+      var down = new pc.Vec3(cur.x, cur.y - step, cur.z);
+      var resolved = this._resolveCapsuleCollisions(down, this.maxResolveIters);
+      if (vLen(vSub(resolved, down)) > 0) {
+        return this._resolveCapsuleCollisions(new pc.Vec3(resolved.x, resolved.y + 0.01, resolved.z), this.maxResolveIters);
+      }
+      cur.copy(down);
+    }
+    return p;
+  };
+
+  // ===================== INPUT SOURIS =====================
+  var FreeCameraInputMouse = pc.createScript('orbitCameraInputMouse');
+  FreeCameraInputMouse.attributes.add('lookSensitivity', { type: 'number', default: 0.28, title: 'Look Sensitivity' });
+  FreeCameraInputMouse.attributes.add('wheelSensitivity',{ type: 'number', default: 0.8, title: 'Wheel Sensitivity (anti-tunnel)' });
+
+  FreeCameraInputMouse.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.last = new pc.Vec2();
+    this.isLooking = false;
+
+    if (this.app.mouse) {
+      this.app.mouse.on(pc.EVENT_MOUSEDOWN,  this.onMouseDown,  this);
+      this.app.mouse.on(pc.EVENT_MOUSEUP,    this.onMouseUp,    this);
+      this.app.mouse.on(pc.EVENT_MOUSEMOVE,  this.onMouseMove,  this);
+      this.app.mouse.on(pc.EVENT_MOUSEWHEEL, this.onMouseWheel, this);
+      this.app.mouse.disableContextMenu();
+    }
+    var self = this;
+    this._onOut = function(){ self.isLooking = false; };
+    window.addEventListener('mouseout', this._onOut, false);
+
+    this.on('destroy', () => {
+      if (this.app.mouse) {
+        this.app.mouse.off(pc.EVENT_MOUSEDOWN,  this.onMouseDown,  this);
+        this.app.mouse.off(pc.EVENT_MOUSEUP,    this.onMouseUp,    this);
+        this.app.mouse.off(pc.EVENT_MOUSEMOVE,  this.onMouseMove,  this);
+        this.app.mouse.off(pc.EVENT_MOUSEWHEEL, this.onMouseWheel, this);
+      }
+      window.removeEventListener('mouseout', this._onOut, false);
+    });
+  };
+
+  FreeCameraInputMouse.prototype.onMouseDown = function (e) {
+    this.isLooking = true;
+    this.last.set(e.x, e.y);
+  };
+
+  FreeCameraInputMouse.prototype.onMouseUp = function () {
+    this.isLooking = false;
+  };
+
+  FreeCameraInputMouse.prototype.onMouseMove = function (e) {
+    if (!this.isLooking || !this.freeCam) return;
+    var sens = this.lookSensitivity;
+    this.freeCam.yaw   = this.freeCam.yaw   - e.dx * sens;
+    this.freeCam.pitch = this.freeCam.pitch - e.dy * sens;
+    this.last.set(e.x, e.y);
+  };
+
+  FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
+    if (!this.freeCam) return;
+    var cam = this.entity;
+    var move = -e.wheelDelta * this.wheelSensitivity * this.freeCam.dollySpeed * 0.05;
+    var fwd = cam.forward.clone(); if (fwd.lengthSq()>1e-8) fwd.normalize();
+    var from = cam.getPosition().clone();
+    var to   = from.clone().add(fwd.mulScalar(move));
+    var next = this.freeCam._moveSwept(from, to.sub(from));
+    this.freeCam._clampBBoxMinY(next);
+    next = this.freeCam._clampInsideWorld(next);
+    cam.setPosition(next);
+    e.event.preventDefault();
+  };
+
+  // ===================== INPUT TOUCH =====================
+  var FreeCameraInputTouch = pc.createScript('orbitCameraInputTouch');
+  FreeCameraInputTouch.attributes.add('lookSensitivity',  { type: 'number', default: 0.5, title: 'Look Sensitivity' });
+  FreeCameraInputTouch.attributes.add('pinchDollyFactor', { type: 'number', default: 0.02, title: 'Pinch Dolly Factor' });
+
+  FreeCameraInputTouch.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.last = new pc.Vec2();
+    this.isLooking = false;
+    this.lastPinch = 0;
+
+    if (this.app.touch) {
+      this.app.touch.on(pc.EVENT_TOUCHSTART,  this.onTouchStartEndCancel, this);
+      this.app.touch.on(pc.EVENT_TOUCHEND,    this.onTouchStartEndCancel, this);
+      this.app.touch.on(pc.EVENT_TOUCHCANCEL, this.onTouchStartEndCancel, this);
+      this.app.touch.on(pc.EVENT_TOUCHMOVE,   this.onTouchMove, this);
+    }
+
+    this.on('destroy', () => {
+      if (this.app.touch) {
+        this.app.touch.off(pc.EVENT_TOUCHSTART,  this.onTouchStartEndCancel, this);
+        this.app.touch.off(pc.EVENT_TOUCHEND,    this.onTouchStartEndCancel, this);
+        this.app.touch.off(pc.EVENT_TOUCHCANCEL, this.onTouchStartEndCancel, this);
+        this.app.touch.off(pc.EVENT_TOUCHMOVE,   this.onTouchMove, this);
+      }
+    });
+  };
+
+  FreeCameraInputTouch.prototype.onTouchStartEndCancel = function (e) {
+    var t = e.touches;
+    if (t.length === 1) {
+      this.isLooking = (e.event.type === 'touchstart');
+      this.last.set(t[0].x, t[0].y);
+    } else if (t.length === 2) {
+      var dx = t[0].x - t[1].x, dy = t[0].y - t[1].y;
+      this.lastPinch = Math.sqrt(dx*dx + dy*dy);
+    } else {
+      this.isLooking = false;
+    }
+  };
+
+  FreeCameraInputTouch.prototype.onTouchMove = function (e) {
+    var t = e.touches;
+    if (!this.freeCam) return;
+
+    if (t.length === 1 && this.isLooking) {
+      var s = this.lookSensitivity;
+      var dx = t[0].x - this.last.x, dy = t[0].y - this.last.y;
+      this.freeCam.yaw   = this.freeCam.yaw   - dx * s;
+      this.freeCam.pitch = this.freeCam.pitch - dy * s;
+      this.last.set(t[0].x, t[0].y);
+    } else if (t.length === 2) {
+      var dx = t[0].x - t[1].x, dy = t[0].y - t[1].y;
+      var dist = Math.sqrt(dx*dx + dy*dy);
+      var delta = dist - this.lastPinch; this.lastPinch = dist;
+
+      var cam = this.entity;
+      var fwd = cam.forward.clone(); if (fwd.lengthSq()>1e-8) fwd.normalize();
+      var from = cam.getPosition().clone();
+      var to   = from.clone().add(fwd.mulScalar(delta * this.pinchDollyFactor * this.freeCam.dollySpeed));
+      var next = this.freeCam._moveSwept(from, to.sub(from));
+      this.freeCam._clampBBoxMinY(next);
+      next = this.freeCam._clampInsideWorld(next);
+      cam.setPosition(next);
+    }
+  };
+
+  // ===================== INPUT CLAVIER =====================
+  var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
+  FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused, future)' });
+
+  FreeCameraInputKeyboard.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.kb = this.app.keyboard || null;
+  };
+
+  FreeCameraInputKeyboard.prototype.update = function (dt) {
+    if (!this.freeCam || !this.kb) return;
+
+    var fwd  = (this.kb.isPressed(pc.KEY_UP)    || this.kb.isPressed(pc.KEY_Z) || this.kb.isPressed(pc.KEY_W)) ?  1 :
+               (this.kb.isPressed(pc.KEY_DOWN)  || this.kb.isPressed(pc.KEY_S)) ? -1 : 0;
+
+    var strf = (this.kb.isPressed(pc.KEY_RIGHT) || this.kb.isPressed(pc.KEY_D)) ?  1 :
+               (this.kb.isPressed(pc.KEY_LEFT)  || this.kb.isPressed(pc.KEY_Q) || this.kb.isPressed(pc.KEY_A)) ? -1 : 0;
+
+    if (fwd !== 0 || strf !== 0) {
+      var cam = this.entity;
+      var from = cam.getPosition().clone();
+
+      var forward = cam.forward.clone(); if (forward.lengthSq()>1e-8) forward.normalize();
+      var right   = cam.right.clone();   if (right.lengthSq()>1e-8)   right.normalize();
+
+      var delta = new pc.Vec3()
+        .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
+        .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
+
+      var next = this.freeCam._moveSwept(from, delta);
+      this.freeCam._clampBBoxMinY(next);
+      next = this.freeCam._clampInsideWorld(next);
+      cam.setPosition(next);
+    }
+
+    var shift = this.kb.isPressed(pc.KEY_SHIFT);
+    if (shift) {
+      var yawDir   = (this.kb.isPressed(pc.KEY_LEFT) ? 1 : 0) - (this.kb.isPressed(pc.KEY_RIGHT) ? 1 : 0);
+      var pitchDir = (this.kb.isPressed(pc.KEY_UP)   ? 1 : 0) - (this.kb.isPressed(pc.KEY_DOWN)  ? 1 : 0);
+      var yawSpeed = 120, pitchSpeed = 90;
+      if (yawDir   !== 0) this.freeCam.yaw   = this.freeCam.yaw   + yawDir   * yawSpeed   * dt;
+      if (pitchDir !== 0) this.freeCam.pitch = this.freeCam.pitch + pitchDir * pitchSpeed * dt;
+    }
+  };
 }
 
 /* -------------------------------------------
@@ -127,19 +750,12 @@ export async function initializeViewer(config, instanceId) {
   const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
   const isMobile = isIOS || /Android/i.test(navigator.userAgent);
 
+  console.log(`[VIEWER] A: initializeViewer begin`, { instanceId });
+
   // --- Configuration ---
-  // 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";
+  glbUrl = config.glb_url ?? "https://huggingface.co/datasets/MikaFil/viewer_gs/resolve/main/ressources/espace_expo/sol_blanc_2.glb";
+  presentoirUrl = 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");
@@ -213,67 +829,38 @@ export async function initializeViewer(config, instanceId) {
   canvas.addEventListener("dblclick", (e) => e.preventDefault());
   canvas.addEventListener(
     "touchstart",
-    (e) => {
-      if (e.touches.length > 1) e.preventDefault();
-    },
+    (e) => { if (e.touches.length > 1) e.preventDefault(); },
     { passive: false }
   );
   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"
+    "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 onPointerLeave = () => {
-    isPointerOverCanvas = false;
-    if (document.activeElement === canvas) canvas.blur();
-  };
-  const onCanvasBlur = () => {
-    isPointerOverCanvas = false;
-  };
+  const onPointerEnter = () => { isPointerOverCanvas = true; focusCanvas(); };
+  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: 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);
 
@@ -282,8 +869,9 @@ 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; // utiles pour tooltips.js
+    window.pc = pc; // debug
   }
+  console.log('[VIEWER] PlayCanvas ESM chargé:', !!pc);
 
   // --- Crée l'Application ---
   const device = await pc.createGraphicsDevice(canvas, {
@@ -292,8 +880,6 @@ export async function initializeViewer(config, instanceId) {
     twgslUrl: "https://playcanvas.vercel.app/static/lib/twgsl/twgsl.js",
     antialias: false
   });
-
-  // Cap DPR pour limiter le coût CPU/GPU
   device.maxPixelRatio = Math.min(window.devicePixelRatio || 1, maxDevicePixelRatio);
 
   const opts = new pc.AppOptions();
@@ -334,11 +920,8 @@ export async function initializeViewer(config, instanceId) {
     }, 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);
 
@@ -357,18 +940,19 @@ export async function initializeViewer(config, instanceId) {
   app.assets.add(sogAsset);
   app.assets.add(glbAsset);
 
-  // Assure la free-cam + collisions
-  await ensureOrbitScriptsLoaded();
+  // >>> Scripts caméra en local (aucune requête réseau) <<<
+  registerFreeCamScripts();
 
   // ---------- 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);
+    loader.on('error', (e)=>{ console.error('[VIEWER] Asset load error:', e); reject(e); });
   });
 
   app.start(); // démarre l'update loop dès que possible
   progressDialog.style.display = "none";
+  console.log("[VIEWER] app.start OK — assets chargés");
 
   // --- Modèle principal (GSplat via .sog) ---
   modelEntity = new pc.Entity("model");
@@ -383,29 +967,31 @@ export async function initializeViewer(config, instanceId) {
   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
+    // Log du nombre de meshInstances pour vérifier la construction des colliders
+    let meshCount = 0;
+    traverse(envEntity, (node) => {
+      if (node.render && node.render.meshInstances) meshCount += node.render.meshInstances.length;
+    });
+    console.log("[VIEWER] env ready:", true, "meshInstances=", meshCount);
   } else {
-    console.warn("[viewer.js] GLB resource missing: collisions will fallback on GSplat (aucun mesh).");
+    console.warn("[VIEWER] GLB resource missing: collisions fallback sur GSplat (moins précis).");
   }
 
   // --- 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
+    nearClip: 0.02,
+    farClip: 250
   });
   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,
+      inertiaFactor: 0.18,
       distanceMax: maxZoom,
       distanceMin: minZoom,
       pitchAngleMax: maxAngle,
@@ -413,16 +999,22 @@ export async function initializeViewer(config, instanceId) {
       yawAngleMax: maxAzimuth,
       yawAngleMin: minAzimuth,
       minY: minY,
-      frameOnStart: false
+      frameOnStart: false,
+      capsuleRadius: 0.30,
+      capsuleHeight: 1.60,
+      maxStepDistance: 0.10,
+      maxResolveIters: 8,
+      globalCullFrac: 0.0 // désactivé
     }
   });
-  cameraEntity.script.create("orbitCameraInputMouse");
-  cameraEntity.script.create("orbitCameraInputTouch");
+  cameraEntity.script.create("orbitCameraInputMouse", {
+    attributes: { lookSensitivity: 0.28, wheelSensitivity: 0.8 }
+  });
+  cameraEntity.script.create("orbitCameraInputTouch", {
+    attributes: { lookSensitivity: 0.5, pinchDollyFactor: 0.02 }
+  });
   cameraEntity.script.create("orbitCameraInputKeyboard", {
-    attributes: {
-      forwardSpeed: 1.2,
-      strafeSpeed: 1.2
-    }
+    attributes: { acceleration: 1.0 }
   });
   app.root.addChild(cameraEntity);
 
@@ -454,72 +1046,8 @@ export async function initializeViewer(config, instanceId) {
     canvas.addEventListener(ev, bumpInteraction, { passive: true });
   });
 
-  // ---------- 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());
-      });
-
-      const presentoirEntity =
-        presentoirAsset.resource ? presentoirAsset.resource.instantiateRenderEntity() : null;
-      if (presentoirEntity) {
-        presentoirEntity.setLocalScale(presentoirScaleX, presentoirScaleY, presentoirScaleZ);
-        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;
-        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;
-            }
-          });
-        }
-      }
-
-      // 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;
+  console.log("[VIEWER] READY — physics=OFF (AABB), env=", !!envEntity, "sog=", !!modelEntity);
 }
 
 /* -------------------------------------------
@@ -534,55 +1062,8 @@ export function resetViewerCamera() {
 
     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);
-
-    const dist = new pc.Vec3()
-      .sub2(new pc.Vec3(chosenCameraX, chosenCameraY, chosenCameraZ), modelPos)
-      .length();
-
-    cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+    // Ici c'est une "free-cam", on ne remet pas une orbite : juste réaligner le regard
     cameraEntity.lookAt(modelPos);
-
-    orbitCam.pivotPoint = modelPos.clone();
-    orbitCam._targetDistance = dist;
-    orbitCam._distance = dist;
-
-    const rot = tempEnt.getRotation();
-    const fwd = new pc.Vec3();
-    rot.transformVector(pc.Vec3.FORWARD, fwd);
-
-    const yaw = Math.atan2(-fwd.x, -fwd.z) * pc.math.RAD_TO_DEG;
-    const yawQuat = new pc.Quat().setFromEulerAngles(0, -yaw, 0);
-    const rotNoYaw = new pc.Quat().mul2(yawQuat, rot);
-    const fNoYaw = new pc.Vec3();
-    rotNoYaw.transformVector(pc.Vec3.FORWARD, fNoYaw);
-    const pitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
-
-    orbitCam._targetYaw = yaw;
-    orbitCam._yaw = yaw;
-    orbitCam._targetPitch = pitch;
-    orbitCam._pitch = pitch;
-    if (orbitCam._updatePosition) orbitCam._updatePosition();
-
-    tempEnt.destroy();
   } catch (e) {
     console.error("[viewer.js] resetViewerCamera error:", e);
   }