Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,618 +1,482 @@
-// ctrl_camera_pr_env.js
-// ============================================================================
-// FREE CAMERA + COLLISION INDOOR-SAFE (sans Ammo) avec STEP OFFSET (escaliers)
-// - Souris : look
-// - ZQSD / Flèches : déplacement local
-// - Molette / Pinch : dolly
-// - Collisions : sphère (caméra) vs AABBs du GLB (focusEntity)
-// - Mouvement "swept" + slide sur murs + step-up/step-down pour escaliers
-// - AUCUN AUTOSPAWN : la position initiale est celle fournie par la config
-// ============================================================================
-
-var FreeCamera = pc.createScript('orbitCamera'); // garder ce nom pour compat viewer
-
-// ======================== Attributs ===========================
-FreeCamera.attributes.add('inertiaFactor', { type: 'number', default: 0.12, 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)' });
-FreeCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum camera Y' });
-
-FreeCamera.attributes.add('moveSpeed',   { type: 'number', default: 2.2, title: 'Move Speed' });
-FreeCamera.attributes.add('strafeSpeed', { type: 'number', default: 2.2, title: 'Strafe Speed' });
-FreeCamera.attributes.add('dollySpeed',  { type: 'number', default: 2.0, title: 'Mouse/Pinch Dolly Speed' });
-
-// Collision (caméra sphère)
-FreeCamera.attributes.add('collisionRadius',  { type: 'number', default: 0.30, title: 'Camera Sphere Radius' });
-FreeCamera.attributes.add('collisionEpsilon', { type: 'number', default: 0.0005, title: 'Collision Epsilon' });
-
-// Mouvement "swept"
-FreeCamera.attributes.add('maxStepDistance', { type: 'number', default: 0.20, title: 'Max step distance (swept move)' });
-FreeCamera.attributes.add('maxResolveIters', { type: 'number', default: 6, title: 'Max resolve iterations per step' });
-
-// Indoor-safe colliders
-FreeCamera.attributes.add('inflateBias',   { type: 'number', default: 0.0,  title: 'Extra inflate (m, tiny)' });
-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.08, title: 'Cull near-global AABBs (0.08=8%)' });
-
-// Step offset / Ground snap (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('stepDownMax',  { type: 'number', default: 0.60, title: 'Max snap-down (m)' });
-FreeCamera.attributes.add('enableGroundSnap', { type: 'boolean', default: true, title: 'Enable ground snap' });
-
-// BBox globale optionnelle (Xmin..Zmax)
-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 (gardées 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)' });
-
-// ======================== Helpers ===========================
-function vec3Sub(a, b) { return new pc.Vec3(a.x-b.x, a.y-b.y, a.z-b.z); }
-function vec3Add(a, b) { return new pc.Vec3(a.x+b.x, a.y+b.y, a.z+b.z); }
-function vec3Scale(a, s){ return new pc.Vec3(a.x*s, a.y*s, a.z*s); }
-function length(v) { return Math.sqrt(v.x*v.x + v.y*v.y + v.z*v.z); }
-function dot(a, b){ return a.x*b.x + a.y*b.y + a.z*b.z; }
-function normalize(v){ var l=length(v)||1; return new pc.Vec3(v.x/l, v.y/l, v.z/l); }
-function projectOnPlane(v, n){ var d = dot(v, n); return new pc.Vec3(v.x - d*n.x, v.y - d*n.y, v.z - d*n.z); }
-
-// ======================== Initialisation ===========================
-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; } // yaw libre
-});
-
-FreeCamera.prototype.initialize = function () {
-  // Marqueur pour le viewer : c’est bien une free-cam
-  this.isFreeCamera = true;
-
-  // angles init depuis l’orientation actuelle
-  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 yawQ    = new pc.Quat().setFromEulerAngles(0, -this._yaw, 0);
-  var noYawQ  = new pc.Quat().mul2(yawQ, 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);
-
-  // état partagé
-  this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
-  this.state = this.app.systems.script.app.freeCamState;
-
-  // Colliders
-  this._buildIndoorSafeColliders();
-
-  // Respect total de la position JSON :
-  // On fait UNIQUEMENT une micro-résolution si on spawn *déjà* interpenetré (mais sans "sauter" loin).
-  var start = this.entity.getPosition().clone();
-  var resolved = this._resolveCollisions(start, this.maxResolveIters);
-  var delta = resolved.clone().sub(start);
-  if (delta.length() > this.collisionRadius * 0.25) {
-    // Si la correction est énorme, on préfère limiter à 25% du rayon pour éviter de sortir du bâtiment.
-    var lim = delta.normalize().mulScalar(this.collisionRadius * 0.25);
-    resolved = start.clone().add(lim);
-  }
-  this._clampPosition(resolved);
-  this.entity.setPosition(resolved);
-
-  // aspect
-  var self = this;
-  this._onResize = function(){ self._checkAspectRatio(); };
-  window.addEventListener('resize', this._onResize, false);
-  this._checkAspectRatio();
-};
-
-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._resolveCollisions(pos, this.maxResolveIters);
-  this._clampPosition(pos);
-  this.entity.setPosition(pos);
-};
-
-FreeCamera.prototype._checkAspectRatio = function () {
-  var gd = this.app.graphicsDevice;
-  if (!gd) return;
-  this.entity.camera.horizontalFov = (gd.height > gd.width);
-};
-
-// ======================== Colliders indoor-safe ===========================
-FreeCamera.prototype._buildIndoorSafeColliders = function () {
-  this._colliders = [];
-  this._worldAabb = null;
-  this._useCollision = false;
-
-  if (!this.focusEntity) return;
-
-  // 1) Collecter toutes les AABBs world des meshInstances
-  var boxes = [];
-  var stack = [this.focusEntity];
-  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 a = rc.meshInstances[i].aabb;
-        boxes.push(new pc.BoundingBox(a.center.clone(), a.halfExtents.clone()));
-      }
-    }
-    var ch = e.children;
-    if (ch && ch.length) for (var c = 0; c < ch.length; c++) stack.push(ch[c]);
+// viewer_pr_env.js
+// ==============================
+
+/* -------------------------------------------
+   Utils
+-------------------------------------------- */
+
+async function loadImageAsTexture(url, app) {
+  return new Promise((resolve, reject) => {
+    const img = new window.Image();
+    img.crossOrigin = "anonymous";
+    img.onload = function () {
+      const tex = new pc.Texture(app.graphicsDevice, {
+        width: img.width,
+        height: img.height,
+        format: pc.PIXELFORMAT_R8_G8_B8_A8
+      });
+      tex.setSource(img);
+      resolve(tex);
+    };
+    img.onerror = reject;
+    img.src = url;
+  });
+}
+
+// Patch global Image -> force CORS
+(function () {
+  const OriginalImage = window.Image;
+  window.Image = function (...args) {
+    const img = new OriginalImage(...args);
+    img.crossOrigin = "anonymous";
+    return img;
+  };
+})();
+
+function hexToRgbaArray(hex) {
+  try {
+    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 [
+      ((num >> 24) & 0xff) / 255,
+      ((num >> 16) & 0xff) / 255,
+      ((num >> 8) & 0xff) / 255,
+      (num & 0xff) / 255
+    ];
+  } catch (e) {
+    console.warn("hexToRgbaArray error:", e);
+    return [1, 1, 1, 1];
   }
-  if (boxes.length === 0) return;
-
-  // 2) AABB monde
-  var world = boxes[0].clone();
-  for (var j = 1; j < boxes.length; j++) world.add(boxes[j]);
-
-  // 3) Filtrer les AABBs quasi globales
-  var frac = pc.math.clamp(this.globalCullFrac, 0, 0.49);
-  var wh = world.halfExtents;
-  var filtered = [];
-  for (var k = 0; k < boxes.length; k++) {
-    var h = boxes[k].halfExtents;
-    var nearGlobal =
-      (h.x >= wh.x * (1 - frac)) &&
-      (h.y >= wh.y * (1 - frac)) &&
-      (h.z >= wh.z * (1 - frac));
-    if (!nearGlobal) filtered.push(boxes[k]);
+}
+
+// Parcours récursif d'une hiérarchie d'entités
+function traverse(entity, callback) {
+  callback(entity);
+  if (entity.children) {
+    entity.children.forEach((child) => traverse(child, callback));
   }
+}
 
-  // 4) Merge strict
-  var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap || 0));
+/* -------------------------------------------
+   Chargement unique de ctrl_camera_pr_env.js
+-------------------------------------------- */
 
-  // 5) Petit gonflage
-  var inflate = Math.max(0, this.inflateBias || 0);
-  for (var m = 0; m < merged.length; m++) {
-    merged[m].halfExtents.add(new pc.Vec3(inflate, inflate, inflate));
+async function ensureOrbitScriptsLoaded() {
+  if (window.__PLY_ORBIT_LOADED__) return;
+  if (window.__PLY_ORBIT_LOADING__) {
+    await window.__PLY_ORBIT_LOADING__;
+    return;
   }
 
-  if (merged.length > 0) {
-    for (var t = 0; t < merged.length; t++) this._colliders.push({ aabb: merged[t] });
-    this._worldAabb = world;
-    this._useCollision = true;
-  } else {
-    this._colliders = [];
-    this._useCollision = false;
-    console.warn('[orbitCamera] Aucun collider utile trouvé (désactivation des collisions)');
-  }
-};
-
-FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
-  if (!boxes || boxes.length <= 1) return boxes.slice();
-  var out = boxes.slice();
-  var changed = true;
-  var tol = Math.max(0, gap || 0);
-
-  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
-    );
-  }
+  window.__PLY_ORBIT_LOADING__ = new Promise((resolve, reject) => {
+    const s = document.createElement("script");
+    // Script caméra libre + collisions (garde le nom public "orbitCamera")
+    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 script", e);
+      reject(e);
+    };
+    document.head.appendChild(s);
+  });
 
-  while (changed) {
-    changed = false;
-    var next = [];
-    var 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 nCenter = nMin.clone().add(nMax).mulScalar(0.5);
-          var nHalf = new pc.Vec3(
-            Math.abs(nMax.x - nCenter.x),
-            Math.abs(nMax.y - nCenter.y),
-            Math.abs(nMax.z - nCenter.z)
-          );
-
-          acc = new pc.BoundingBox(nCenter, nHalf);
-          used[j] = true;
-          changed = true;
-        }
-      }
-      used[i] = true;
-      next.push(acc);
-    }
-    out = next;
-  }
-  return out;
-};
-
-// ======================== SPAWN / VALIDATION POSITION : SUPPRIMÉ ===========================
-
-// ======================== Contraintes génériques ===========================
-FreeCamera.prototype._bboxEnabled = function () {
-  return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
-};
-FreeCamera.prototype._clampPosition = function (p) {
-  if (p.y < this.minY) p.y = this.minY;
-  if (!this._bboxEnabled()) return;
-  p.x = pc.math.clamp(p.x, this.Xmin, this.Xmax);
-  p.y = pc.math.clamp(p.y, Math.max(this.Ymin, this.minY), this.Ymax);
-  p.z = pc.math.clamp(p.z, this.Zmin, this.Zmax);
-};
-
-// ======================== MOUVEMENT PRINCIPAL ===========================
-FreeCamera.prototype._moveWithCollisions = function (from, desiredDelta) {
-  if (!this._useCollision) return from.clone().add(desiredDelta);
-
-  var maxStep = Math.max(0.01, this.maxStepDistance || 0.2);
-  var total = desiredDelta.clone();
-  var dist = length(total);
-  if (dist <= maxStep) return this._moveStep(from, total);
-
-  var steps = Math.ceil(dist / maxStep);
-  var stepVec = vec3Scale(total, 1/steps);
-  var cur = from.clone();
-  for (var i = 0; i < steps; i++) cur = this._moveStep(cur, stepVec);
-  return cur;
-};
-
-FreeCamera.prototype._moveStep = function (from, delta) {
-  var target = vec3Add(from, delta);
-
-  // a) tentative simple
-  var after = this._resolveCollisions(target, this.maxResolveIters);
-  var movedVec = vec3Sub(after, target);
-  var movedLen = length(movedVec);
-
-  if (movedLen === 0) {
-    if (this.enableGroundSnap) after = this._snapDown(after);
-    return after;
+  await window.__PLY_ORBIT_LOADING__;
+}
+
+/* -------------------------------------------
+   State (par module = par instance importée)
+-------------------------------------------- */
+
+let pc;
+export let app = null;
+let cameraEntity = null;
+let modelEntity = null; // gsplat principal (oeuvre)
+let envEntity = null;   // GLB d'environnement / présentoir
+let viewerInitialized = false;
+let resizeObserver = null;
+
+// paramètres courants de l'instance
+let chosenCameraX, chosenCameraY, chosenCameraZ;
+let distanceMin, minAngle, maxAngle, minAzimuth, maxAzimuth, minY;
+let modelX, modelY, modelZ, modelScale, modelRotationX, modelRotationY, modelRotationZ;
+let presentoirScaleX, presentoirScaleY, presentoirScaleZ;
+let sogsUrl, glbUrl;
+let color_bg_hex, color_bg, espace_expo_bool;
+
+/* -------------------------------------------
+   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");
+  minAzimuth = config.minAzimuth !== undefined ? parseFloat(config.minAzimuth) : -360;
+  maxAzimuth = config.maxAzimuth !== undefined ? parseFloat(config.maxAzimuth) : 360;
+  minY = config.minY !== undefined ? parseFloat(config.minY) : 0;
+
+  modelX = config.modelX !== undefined ? parseFloat(config.modelX) : 0;
+  modelY = config.modelY !== undefined ? parseFloat(config.modelY) : 0;
+  modelZ = config.modelZ !== undefined ? parseFloat(config.modelZ) : 0;
+  modelScale = config.modelScale !== undefined ? parseFloat(config.modelScale) : 1;
+  modelRotationX = config.modelRotationX !== undefined ? parseFloat(config.modelRotationX) : 0;
+  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;
+
+  const cameraX = config.cameraX !== undefined ? parseFloat(config.cameraX) : 0;
+  const cameraY = config.cameraY !== undefined ? parseFloat(config.cameraY) : 2;
+  const cameraZ = config.cameraZ !== undefined ? parseFloat(config.cameraZ) : 5;
+
+  const cameraXPhone = config.cameraXPhone !== undefined ? parseFloat(config.cameraXPhone) : cameraX;
+  const cameraYPhone = config.cameraYPhone !== undefined ? parseFloat(config.cameraYPhone) : cameraY;
+  const cameraZPhone = config.cameraZPhone !== undefined ? parseFloat(config.cameraZPhone) : cameraZ * 1.5;
+
+  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);
+
+  chosenCameraX = isMobile ? cameraXPhone : cameraX;
+  chosenCameraY = isMobile ? cameraYPhone : cameraY;
+  chosenCameraZ = isMobile ? cameraZPhone : cameraZ;
+
+  // --- Prépare le canvas unique à cette instance ---
+  const canvasId = "canvas-" + instanceId;
+  const progressDialog = document.getElementById("progress-dialog-" + instanceId);
+  const viewerContainer = document.getElementById("viewer-container-" + instanceId);
+
+  const old = document.getElementById(canvasId);
+  if (old) old.remove();
+
+  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);
+
+  // interactions de base (éviter scroll/gestes par défaut sur le canvas)
+  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(
+    "touchstart",
+    (e) => {
+      if (e.touches.length > 1) e.preventDefault();
+    },
+    { passive: false }
+  );
+  canvas.addEventListener(
+    "wheel",
+    (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" ]);
+  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; };
+
+  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("blur", onCanvasBlur);
+
+  const onKeyDownCapture = (e) => {
+    if (!isPointerOverCanvas) return;
+    if (scrollKeys.has(e.key) || scrollKeys.has(e.code)) e.preventDefault();
+  };
+  window.addEventListener("keydown", onKeyDownCapture, true);
+
+  progressDialog.style.display = "block";
+
+  // --- 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
   }
 
-  // b) slide
-  var n = this._estimateCollisionNormal(after);
-  if (n) {
-    var desire = delta.clone();
-    var slideDelta = projectOnPlane(desire, n);
-    var slideTarget = vec3Add(from, slideDelta);
-    var slideAfter = this._resolveCollisions(slideTarget, this.maxResolveIters);
-
-    // c) step-up si slide insuffisant
-    if (length(vec3Sub(slideAfter, slideTarget)) !== 0) {
-      var stepped = this._tryStepUp(from, desire);
-      if (stepped) {
-        if (this.enableGroundSnap) stepped = this._snapDown(stepped);
-        return stepped;
-      }
-    }
+  // --- Crée l'Application ---
+  const device = await pc.createGraphicsDevice(canvas, {
+    deviceTypes: ["webgl2"],
+    glslangUrl: "https://playcanvas.vercel.app/static/lib/glslang/glslang.js",
+    twgslUrl: "https://playcanvas.vercel.app/static/lib/twgsl/twgsl.js",
+    antialias: false
+  });
+  device.maxPixelRatio = Math.min(window.devicePixelRatio, 2);
+
+  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.componentSystems = [
+    pc.RenderComponentSystem,
+    pc.CameraComponentSystem,
+    pc.LightComponentSystem,
+    pc.ScriptComponentSystem,
+    pc.GSplatComponentSystem,
+    pc.CollisionComponentSystem,
+    pc.RigidbodyComponentSystem
+  ];
+  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);
+
+  resizeObserver = new ResizeObserver((entries) => {
+    entries.forEach((entry) => {
+      app.resizeCanvas(entry.contentRect.width, entry.contentRect.height);
+    });
+  });
+  resizeObserver.observe(viewerContainer);
+
+  window.addEventListener("resize", () =>
+    app.resizeCanvas(viewerContainer.clientWidth, viewerContainer.clientHeight)
+  );
+
+  // Nettoyage complet
+  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);
+  });
 
-    if (this.enableGroundSnap) slideAfter = this._snapDown(slideAfter);
-    return slideAfter;
-  }
+  // --- 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 });
 
-  if (this.enableGroundSnap) after = this._snapDown(after);
-  return after;
-};
-
-FreeCamera.prototype._estimateCollisionNormal = function (p) {
-  if (!this._colliders) return null;
-  var probe = 0.02;
-  var base = this._resolveCollisions(p, this.maxResolveIters);
-  var nx = this._resolveCollisions(new pc.Vec3(p.x+probe, p.y, p.z), this.maxResolveIters);
-  var px = this._resolveCollisions(new pc.Vec3(p.x-probe, p.y, p.z), this.maxResolveIters);
-  var ny = this._resolveCollisions(new pc.Vec3(p.x, p.y+probe, p.z), this.maxResolveIters);
-  var py = this._resolveCollisions(new pc.Vec3(p.x, p.y-probe, p.z), this.maxResolveIters);
-  var nz = this._resolveCollisions(new pc.Vec3(p.x, p.y, p.z+probe), this.maxResolveIters);
-  var pz = this._resolveCollisions(new pc.Vec3(p.x, p.y, p.z-probe), this.maxResolveIters);
-
-  var dx = length(vec3Sub(nx, base)) - length(vec3Sub(px, base));
-  var dy = length(vec3Sub(ny, base)) - length(vec3Sub(py, base));
-  var dz = length(vec3Sub(nz, base)) - length(vec3Sub(pz, base));
-  var n = new pc.Vec3(dx, dy, dz);
-  var L = length(n);
-  if (L < 1e-5) return null;
-  return vec3Scale(n, 1/L);
-};
-
-FreeCamera.prototype._tryStepUp = function (from, wishDelta) {
-  var R = Math.max(0, this.collisionRadius);
-  var eps = Math.max(1e-4, this.collisionEpsilon);
-  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 = length(horiz);
-  if (hLen < 1e-6) return null;
-  horiz = vec3Scale(horiz, 1/hLen);
-
-  var probeXZ = vec3Add(from, vec3Scale(horiz, Math.min(hLen, ahead)));
-  var bestY = this._highestYUnderXZ(probeXZ.x, probeXZ.z, eps);
-  if (bestY === -Infinity) return null;
-
-  var curY = from.y;
-  var desiredY = bestY + R + 0.02;
-  var up = desiredY - curY;
-
-  if (up > 0 && up <= maxH + 1e-4) {
-    var raised = new pc.Vec3(from.x, curY + up, from.z);
-    raised = this._resolveCollisions(raised, this.maxResolveIters);
-    var stepped = this._resolveCollisions(vec3Add(raised, wishDelta), this.maxResolveIters);
-    if (length(vec3Sub(stepped, raised)) > 0.01) return stepped;
-  }
-  return null;
-};
+  for (const k in assets) app.assets.add(assets[k]);
 
-FreeCamera.prototype._snapDown = function (p) {
-  var R = Math.max(0, this.collisionRadius);
-  var eps = Math.max(1e-4, this.collisionEpsilon);
-  var maxDown = Math.max(0, this.stepDownMax || 0.6);
+  const loader = new pc.AssetListLoader(Object.values(assets), app.assets);
 
-  var bestY = this._highestYUnderXZ(p.x, p.z, eps);
-  if (bestY === -Infinity) return p;
+  // Assure le chargement unique des scripts de caméra
+  await ensureOrbitScriptsLoaded();
 
-  var floorY = bestY + R + 0.01;
-  if (p.y - floorY > 0 && p.y - floorY <= maxDown) {
-    var snapped = new pc.Vec3(p.x, floorY, p.z);
-    return this._resolveCollisions(snapped, this.maxResolveIters);
-  }
-  return p;
-};
-
-FreeCamera.prototype._highestYUnderXZ = function (x, z, eps) {
-  var bestY = -Infinity;
-  if (!this._colliders) return bestY;
-  for (var i = 0; i < this._colliders.length; i++) {
-    var aabb = this._colliders[i].aabb;
-    var amin = aabb.getMin(), amax = aabb.getMax();
-    if (x >= amin.x - eps && x <= amax.x + eps && z >= amin.z - eps && z <= amax.z + eps) {
-      if (amax.y > bestY) bestY = amax.y;
-    }
-  }
-  return bestY;
-};
-
-// ======================== Résolution sphère/AABB ===========================
-FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
-  if (!this._useCollision) return pos.clone();
-
-  var p = pos.clone();
-  var R = Math.max(0, this.collisionRadius);
-  var eps = Math.max(1e-7, this.collisionEpsilon);
-
-  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 amin = aabb.getMin(); var amax = aabb.getMax();
-
-      var cx = pc.math.clamp(p.x, amin.x, amax.x);
-      var cy = pc.math.clamp(p.y, amin.y, amax.y);
-      var cz = pc.math.clamp(p.z, amin.z, amax.z);
-
-      var dx = p.x - cx, dy = p.y - cy, dz = p.z - cz;
-      var distSq = dx*dx + dy*dy + dz*dz;
-
-      if (distSq < (R*R)) {
-        var dist = Math.sqrt(Math.max(distSq, 1e-12));
-        var pen = R - dist + eps;
-
-        if (dist > 1e-6) {
-          p.x += (dx / dist) * pen;
-          p.y += (dy / dist) * pen;
-          p.z += (dz / dist) * 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) p.x += (Math.abs(p.x - amin.x) < Math.abs(amax.x - p.x) ? -pen : pen);
-          else if (ey <= ex && ey <= ez) p.y += (Math.abs(p.y - amin.y) < Math.abs(amax.y - p.y) ? -pen : pen);
-          else p.z += (Math.abs(p.z - amin.z) < Math.abs(amax.z - p.z) ? -pen : pen);
-        }
-        moved = true;
-      }
-    }
-    if (!moved) break;
-  }
+  loader.load(() => {
+    app.start();
+    progressDialog.style.display = "none";
 
-  return p;
-};
-
-// ===================== INPUT SOURIS =====================
-var FreeCameraInputMouse = pc.createScript('orbitCameraInputMouse');
-FreeCameraInputMouse.attributes.add('lookSensitivity', { type: 'number', default: 0.3, title: 'Look Sensitivity' });
-FreeCameraInputMouse.attributes.add('wheelSensitivity',{ type: 'number', default: 1.0, title: 'Wheel Sensitivity' });
-
-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);
+    // --- 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);
     }
-    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 s = this.lookSensitivity;
-  this.freeCam.yaw   = this.freeCam.yaw   - e.dx * s;
-  this.freeCam.pitch = this.freeCam.pitch - e.dy * s;
-  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 forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
-
-  var from = cam.getPosition().clone();
-  var to   = from.clone().add(forward.mulScalar(move));
-  var next = this.freeCam._moveWithCollisions(from, to.sub(from));
-  this.freeCam._clampPosition(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);
+
+    // --- 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
+      });
+
+      // Position/rotation/échelle (adaptables)
+      envEntity.setLocalPosition(0, 0, 0);
+      envEntity.setLocalEulerAngles(0, 0, 0);
+      envEntity.setLocalScale(presentoirScaleX, presentoirScaleY, presentoirScaleZ);
+
+      app.root.addChild(envEntity);
     }
+
+    // Entité qui sert d'ancrage visuel (lookAt) : l'oeuvre si dispo, sinon l'env
+    const focusVisual = modelEntity || envEntity;
+
+    // Racine de collision pour la free cam : l'environnement GLB de préférence
+    const collisionRoot = envEntity || modelEntity || null;
+
+    // --- 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");
+
+    // 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,
+
+      // Inertie/angles (pitch clampé), yaw libre
+      inertiaFactor: 0.2,
+      pitchAngleMax: maxAngle,
+      pitchAngleMin: minAngle,
+
+      // Compat (ignorés par le free cam, mais gardés pour ne pas casser la config)
+      distanceMin: distanceMin,
+      yawAngleMax: maxAzimuth,
+      yawAngleMin: minAzimuth,
+      frameOnStart: false,
+
+      // Contraintes position
+      minY: minY
+    };
+
+    // 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 */ });
+      }
+    } catch (e) { /* optional */ }
+
+    viewerInitialized = true;
   });
-};
-
-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 forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
-    var from = cam.getPosition().clone();
-    var to   = from.clone().add(forward.mulScalar(delta * this.pinchDollyFactor * this.freeCam.dollySpeed));
-    var next = this.freeCam._moveWithCollisions(from, to.sub(from));
-    this.freeCam._clampPosition(next);
-    cam.setPosition(next);
-  }
-};
+}
 
-// ===================== INPUT CLAVIER =====================
-var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
-FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused)' });
+/* -------------------------------------------
+   Reset caméra (API)
+-------------------------------------------- */
 
-FreeCameraInputKeyboard.prototype.initialize = function () {
-  this.freeCam = this.entity.script.orbitCamera;
-  this.kb = this.app.keyboard || null;
-};
+export function resetViewerCamera() {
+  try {
+    if (!cameraEntity || !app) return;
 
-FreeCameraInputKeyboard.prototype.update = function (dt) {
-  if (!this.freeCam || !this.kb) 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);
 
-  var fwd  = (this.kb.isPressed(pc.KEY_UP)    || this.kb.isPressed(pc.KEY_Z)) ?  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)) ? -1 : 0;
+    const orbitCam = cameraEntity.script && cameraEntity.script.orbitCamera;
+    if (!orbitCam) return;
 
-  if (fwd !== 0 || strf !== 0) {
-    var cam = this.entity;
-    var from = cam.getPosition().clone();
+    const tempEnt = new pc.Entity();
+    tempEnt.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+    tempEnt.lookAt(targetPos);
 
-    var forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
-    var right   = cam.right.clone();   if (right.lengthSq()   > 1e-8) right.normalize();
+    const dist = new pc.Vec3()
+      .sub2(new pc.Vec3(chosenCameraX, chosenCameraY, chosenCameraZ), targetPos)
+      .length();
 
-    var delta = new pc.Vec3()
-      .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
-      .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
+    cameraEntity.setPosition(chosenCameraX, chosenCameraY, chosenCameraZ);
+    cameraEntity.lookAt(targetPos);
 
-    var next = this.freeCam._moveWithCollisions(from, delta);
-    this.freeCam._clampPosition(next);
-    cam.setPosition(next);
-  }
+    // 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);
+    }
 
-  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;
+    // Recalcule yaw/pitch cibles pour aligner l'orientation
+    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);
   }
-};
+}