Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -6,22 +6,17 @@
 // - Molette / Pinch : dolly
 // - Collisions : sphère (caméra) vs AABBs du GLB (focusEntity)
 // - Mouvement "swept" + slide sur murs + step-up/step-down pour escaliers
-// - Placement initial : respecte la config; auto-spawn inside seulement si nécessaire
+// - 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)' });
-
-// Limites de pitch
 FreeCamera.attributes.add('pitchAngleMin', { type: 'number', default: -89, title: 'Pitch Min (deg)' });
 FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title: 'Pitch Max (deg)' });
-
-// minY (altitude min du point CAMÉRA)
 FreeCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum camera Y' });
 
-// Vitesses
 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' });
@@ -45,9 +40,6 @@ FreeCamera.attributes.add('stepAhead',    { type: 'number', default: 0.20, title
 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' });
 
-// Spawn auto si nécessaire seulement
-FreeCamera.attributes.add('autoSpawnInside', { type: 'boolean', default: true, title: 'Auto-spawn inside if needed' });
-
 // 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' });
@@ -63,476 +55,400 @@ FreeCamera.attributes.add('yawAngleMin',  { type: 'number', default: -360, title
 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 internes ===========================
+// ======================== 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){ // enlève la composante selon 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);
-}
+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); }
+  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
+  get: function () { return this._targetYaw; },
+  set: function (v) { this._targetYaw = v; } // yaw libre
 });
 
 FreeCamera.prototype.initialize = function () {
-    // angles init
-    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();
-
-    // Respecter la position initiale; ne spawner dedans que si nécessaire
-    if (this.autoSpawnInside && this._useCollision) {
-        var start = this.entity.getPosition().clone();
-        if (this._shouldAutoSpawn(start)) {
-            this._spawnInside();
-        } else {
-            var safe = this._resolveCollisions(start, this.maxResolveIters);
-            this._clampPosition(safe);
-            this.entity.setPosition(safe);
-        }
-    }
-
-    // aspect
-    var self = this;
-    this._onResize = function(){ self._checkAspectRatio(); };
-    window.addEventListener('resize', this._onResize, false);
-    this._checkAspectRatio();
+  // 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) {
-    // rotation inertielle
-    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);
-
-    // maintien propre (au cas où)
-    var pos = this.entity.getPosition().clone();
-    pos = this._resolveCollisions(pos, this.maxResolveIters);
-    this._clampPosition(pos);
-    this.entity.setPosition(pos);
+  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);
+  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]);
+  }
+  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]);
+  }
+
+  // 4) Merge strict
+  var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap || 0));
+
+  // 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));
+  }
+
+  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._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]);
-    }
-    if (boxes.length === 0) return;
-
-    // 2) AABB monde (non gonflée)
-    var world = boxes[0].clone();
-    for (var j = 1; j < boxes.length; j++) world.add(boxes[j]);
-
-    // 3) Filtrer les AABBs "quasi globales" (anti-coquille)
-    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]);
-    }
-
-    // 4) Merge strict (chevauchement réel uniquement)
-    var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap || 0));
-
-    // 5) Petit gonflage (epsilon), pas du rayon
-    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));
-    }
-
-    // 6) 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;
-    } else {
-        this._colliders = [];
-        this._useCollision = false;
-        console.warn('[orbitCamera] Aucun collider utile trouvé (désactivation des collisions)');
-    }
+    console.warn('[orbitCamera] Aucun collider utile trouvé (désactivation des collisions)');
+  }
 };
 
-// Merge strict (gap==0 => chevauchement seulement)
 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
-        );
-    }
-
-    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 ===========================
-FreeCamera.prototype._shouldAutoSpawn = function (pos) {
-    if (!this._useCollision || !this._worldAabb) return false;
-
-    var R = Math.max(0, this.collisionRadius);
-    var eps = Math.max(1e-4, this.collisionEpsilon);
-
-    var wmin = this._worldAabb.getMin();
-    var wmax = this._worldAabb.getMax();
-
-    // hors monde (avec marge du rayon)
-    if (pos.x < wmin.x + R + eps || pos.x > wmax.x - R - eps) return true;
-    if (pos.z < wmin.z + R + eps || pos.z > wmax.z - R - eps) return true;
-    if (pos.y < wmin.y - eps || pos.y > wmax.y + eps) return true;
-
-    // pas de "sol" sous ce XZ
-    var bestY = this._highestYUnderXZ(pos.x, pos.z, eps);
-    if (bestY === -Infinity) return true;
-
-    // trop en dessous/au dessus
-    if (pos.y < bestY - 2.0) return true;
-    if (pos.y > wmax.y + 0.5) return true;
-
-    // forte intersection initiale
-    var resolved = this._resolveCollisions(pos, this.maxResolveIters);
-    var move = resolved.clone().sub(pos).length();
-    if (move > R * 0.5) return true;
-
-    return false;
-};
-
-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;
+  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
+    );
+  }
+
+  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);
     }
-    return bestY;
+    out = next;
+  }
+  return out;
 };
 
-FreeCamera.prototype._spawnInside = function () {
-    if (!this._useCollision || !this._worldAabb) return;
-
-    var R = Math.max(0, this.collisionRadius);
-    var eps = Math.max(1e-4, this.collisionEpsilon);
-
-    var world = this._worldAabb;
-    var c = world.center;
-    var min = world.getMin(), max = world.getMax();
-
-    var x = pc.math.clamp(c.x, min.x + R + eps, max.x - R - eps);
-    var z = pc.math.clamp(c.z, min.z + R + eps, max.z - R - eps);
-
-    var bestY = this._highestYUnderXZ(x, z, eps);
-    var y = (bestY > -Infinity) ? (bestY + R + 0.03) : Math.max(this.minY, (min.y + max.y) * 0.5);
-
-    var target = new pc.Vec3(x, y, z);
-    target = this._resolveCollisions(target, this.maxResolveIters);
-    this._clampPosition(target);
-    this.entity.setPosition(target);
-};
+// ======================== 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);
+  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);
+  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) {
-    // 1) tentative pure sans collision si désactivées
-    if (!this._useCollision) return from.clone().add(desiredDelta);
-
-    // 2) swept: divise en petits pas
-    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;
+  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;
 };
 
-// Un "pas" unique avec slide + step-up + snap-down
 FreeCamera.prototype._moveStep = function (from, delta) {
-    var target = vec3Add(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);
+  // a) tentative simple
+  var after = this._resolveCollisions(target, this.maxResolveIters);
+  var movedVec = vec3Sub(after, target);
+  var movedLen = length(movedVec);
 
-    // si aucune collision, on snap-down optionnel
-    if (movedLen === 0) {
-        if (this.enableGroundSnap) after = this._snapDown(after);
-        return after;
+  if (movedLen === 0) {
+    if (this.enableGroundSnap) after = this._snapDown(after);
+    return after;
+  }
+
+  // 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;
+      }
     }
 
-    // b) collision détectée → slide (supprime la composante dans la normale estimée)
-    var n = this._estimateCollisionNormal(after); // approx par rapport aux AABB proches
-    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 le slide ne suffit pas (test petite marche)
-        if (length(vec3Sub(slideAfter, slideTarget)) !== 0) {
-            var stepped = this._tryStepUp(from, desire);
-            if (stepped) {
-                if (this.enableGroundSnap) stepped = this._snapDown(stepped);
-                return stepped;
-            }
-        }
-
-        if (this.enableGroundSnap) slideAfter = this._snapDown(slideAfter);
-        return slideAfter;
-    }
+    if (this.enableGroundSnap) slideAfter = this._snapDown(slideAfter);
+    return slideAfter;
+  }
 
-    // pas de normale estimable (rare) : accepte la position résolue
-    if (this.enableGroundSnap) after = this._snapDown(after);
-    return after;
+  if (this.enableGroundSnap) after = this._snapDown(after);
+  return after;
 };
 
-// Estimation grossière d’une normale de collision autour de "p"
 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);
+  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);
 };
 
-// Step-up : essaie de monter une marche jusqu’à stepHeight
 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);
-
-    // direction de déplacement horizontal
-    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);
-
-    // point de test un peu devant
-    var probeXZ = vec3Add(from, vec3Scale(horiz, Math.min(hLen, ahead)));
-    var bestY = this._highestYUnderXZ(probeXZ.x, probeXZ.z, eps);
-
-    if (bestY === -Infinity) return null; // rien pour se poser
-
-    // si la marche est à maxH au-dessus de la position actuelle → tenter un step
-    var curY = from.y;
-    var desiredY = bestY + R + 0.02; // poser sur la marche
-    var up = desiredY - curY;
-
-    if (up > 0 && up <= maxH + 1e-4) {
-        // tenter : monter puis appliquer le delta complet
-        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);
-        // valider si on a bien avancé
-        if (length(vec3Sub(stepped, raised)) > 0.01) return stepped;
-    }
-
-    return null;
+  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;
 };
 
-// Ground snap : colle vers le sol si on est en l’air (descente d’escaliers)
 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);
-
-    var bestY = this._highestYUnderXZ(p.x, p.z, eps);
-    if (bestY === -Infinity) return 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);
+
+  var bestY = this._highestYUnderXZ(p.x, p.z, eps);
+  if (bestY === -Infinity) return p;
+
+  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;
+};
 
-    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);
+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 p;
+  }
+  return bestY;
 };
 
-// ======================== Résolution collision sphère/AABB =====================
-// Déplace et “expulse” si p (centre sphère) intersecte un AABB.
+// ======================== 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();
-
-            // Point le plus proche sur l'AABB
-            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 {
-                    // pousser selon l'axe le plus "proche"
-                    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 (!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 (!moved) break;
+        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;
+  }
 
-    return p;
+  return p;
 };
 
 // ===================== INPUT SOURIS =====================
@@ -541,56 +457,56 @@ FreeCameraInputMouse.attributes.add('lookSensitivity', { type: 'number', default
 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;
-
+  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.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();
+      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);
     }
-    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);
-    });
+    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);
+  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();
+  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 =====================
@@ -599,63 +515,63 @@ FreeCameraInputTouch.attributes.add('lookSensitivity',  { type: 'number', defaul
 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;
-
+  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.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.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);
     }
-    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;
-    }
+  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);
-    }
+  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 =====================
@@ -663,40 +579,40 @@ var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
 FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused)' });
 
 FreeCameraInputKeyboard.prototype.initialize = function () {
-    this.freeCam = this.entity.script.orbitCamera;
-    this.kb = this.app.keyboard || null;
+  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)) ?  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;
+  if (!this.freeCam || !this.kb) return;
 
-    if (fwd !== 0 || strf !== 0) {
-        var cam = this.entity;
-        var from = cam.getPosition().clone();
+  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;
 
-        var forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
-        var right   = cam.right.clone();   if (right.lengthSq()   > 1e-8) right.normalize();
+  if (fwd !== 0 || strf !== 0) {
+    var cam = this.entity;
+    var from = cam.getPosition().clone();
 
-        var delta = new pc.Vec3()
-            .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
-            .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
+    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 next = this.freeCam._moveWithCollisions(from, delta);
-        this.freeCam._clampPosition(next);
-        cam.setPosition(next);
-    }
+    var delta = new pc.Vec3()
+      .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
+      .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
 
-    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;
-    }
+    var next = this.freeCam._moveWithCollisions(from, delta);
+    this.freeCam._clampPosition(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;
+  }
 };