Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,13 +1,12 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// FREE CAMERA + COLLISION ROBUSTE (type FPS léger) pour PlayCanvas (sans Ammo)
-// - Souris : rotation (look around)
-// - ZQSD / Flèches : déplacement local (avant/arrière & strafe)
-// - Molette / Pinch : dolly (avance/recul le long du regard)
-// - Collisions : sphère (caméra) vs AABBs "épaissies & fusionnées" du GLB (focusEntity)
-// - Déplacements "swept" (sous-division en pas) pour éviter le tunneling
-// - minY + BBox globale optionnelle (Xmin..Zmax) restent actives
-// - Conserve les noms publics "orbitCamera*" pour compatibilité avec l'existant
+// FREE CAMERA + COLLISION ROBUSTE (sans Ammo) — version "indoor safe"
+// - Souris : look
+// - ZQSD/Flèches : déplacement local
+// - Molette/Pinch : dolly avant/arrière
+// - Collisions : sphère (caméra) vs AABBs NON fusionnées (ou très peu),
+//   avec filtrage des AABBs "quasi globales" (évite de bloquer toute la pièce)
+// - Mouvement "swept" (sous-division) pour éviter le tunneling
 // ============================================================================
 
 var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera"
@@ -22,24 +21,30 @@ FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title
 // minY (altitude min du point CAMÉRA)
 FreeCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum camera Y' });
 
-// Vitesse de déplacement (m/s)
+// 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' });
 
 // 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.001, title: 'Collision Epsilon' });
+FreeCamera.attributes.add('collisionEpsilon', { type: 'number', default: 0.0005, title: 'Collision Epsilon' });
 
-// Sous-division du déplacement (swept)
+// 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' });
 
 // Construction des colliders
-FreeCamera.attributes.add('mergeGap',   { type: 'number', default: 0.03, title: 'Merge AABBs gap tolerance (m)' });
-FreeCamera.attributes.add('inflateBias',{ type: 'number', default: 0.02, title: 'Extra inflate beyond radius (m)' });
+// IMPORTANT: garder très petit; on n'"épaissit" plus agressivement pour l'indoor
+FreeCamera.attributes.add('inflateBias', { type: 'number', default: 0.0, title: 'Extra inflate (m, tiny)' });
+// On ne merge presque pas : uniquement si recouvrement réel (tolérance numérique)
+FreeCamera.attributes.add('mergeGap',   { type: 'number', default: 0.0, title: 'Merge AABBs gap (0 = pas de gap)' });
 
-// Bounding Box globale (active si Xmin<Xmax etc.)
+// Filtrage "anti-coquille" : on supprime toute AABB dont la taille est trop proche de l’AABB monde
+// Par axe: if halfExtents >= worldHalfExtents * (1 - globalCullFrac) => on la considère "quasi globale".
+FreeCamera.attributes.add('globalCullFrac', { type: 'number', default: 0.08, title: 'Cull near-global AABBs (0.08=8%)' });
+
+// Bounding Box 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' });
@@ -47,7 +52,7 @@ FreeCamera.attributes.add('Ymax', { type: 'number', default:  Infinity, title: '
 FreeCamera.attributes.add('Zmin', { type: 'number', default: -Infinity, title: 'BBox Zmin' });
 FreeCamera.attributes.add('Zmax', { type: 'number', default:  Infinity, title: 'BBox Zmax' });
 
-// Compat (certaines non utilisées, gardées pour le viewer)
+// 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)' });
@@ -61,43 +66,35 @@ Object.defineProperty(FreeCamera.prototype, 'pitch', {
 });
 Object.defineProperty(FreeCamera.prototype, 'yaw', {
     get: function () { return this._targetYaw; },
-    set: function (v) { this._targetYaw = v; } // yaw libre (pas de clamp)
+    set: function (v) { this._targetYaw = v; } // yaw libre
 });
 
 FreeCamera.prototype.initialize = function () {
-    // angles init depuis l'orientation actuelle
+    // angles init
     var q = this.entity.getRotation();
-    var f = new pc.Vec3();
-    q.transformVector(pc.Vec3.FORWARD, f);
-
+    var f = new pc.Vec3(); q.transformVector(pc.Vec3.FORWARD, f);
     this._yaw   = Math.atan2(f.x, f.z) * pc.math.RAD_TO_DEG;
-    var yawQuat = new pc.Quat().setFromEulerAngles(0, -this._yaw, 0);
-    var noYawQ  = new pc.Quat().mul2(yawQuat, q);
-    var fNoYaw  = new pc.Vec3();
-    noYawQ.transformVector(pc.Vec3.FORWARD, fNoYaw);
-    this._pitch = Math.atan2(-fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
-    this._pitch = pc.math.clamp(this._pitch, this.pitchAngleMin, this.pitchAngleMax);
-
-    this._targetYaw   = this._yaw;
-    this._targetPitch = this._pitch;
-
-    // Appliquer orientation immédiatement
+    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);
 
-    // Etat input partagé
+    // état partagé
     this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
     this.state = this.app.systems.script.app.freeCamState;
 
-    // Construire colliders robustes depuis le GLB (focusEntity)
-    this._buildRobustColliders();
+    // colliders
+    this._buildIndoorSafeColliders(); // <= clé de la correction
 
-    // S’assure que la position courante respecte collisions + minY + bbox
+    // Forcer une passe de résolution initiale (si on spawn “dans” un mur)
     var p = this.entity.getPosition().clone();
-    p = this._moveSweptTo(p, p); // passe par le résolveur même si delta nul
+    p = this._moveSweptTo(p, p);
     this._clampPosition(p);
     this.entity.setPosition(p);
 
-    // Aspect ratio (comme avant)
+    // aspect
     var self = this;
     this._onResize = function(){ self._checkAspectRatio(); };
     window.addEventListener('resize', this._onResize, false);
@@ -105,13 +102,13 @@ FreeCamera.prototype.initialize = function () {
 };
 
 FreeCamera.prototype.update = function (dt) {
-    // Rotation inertielle
+    // 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);
 
-    // Recadrage léger
+    // petit “reclamp”
     var pos = this.entity.getPosition().clone();
     pos = this._resolveCollisions(pos, this.maxResolveIters);
     this._clampPosition(pos);
@@ -124,66 +121,84 @@ FreeCamera.prototype._checkAspectRatio = function () {
     this.entity.camera.horizontalFov = (gd.height > gd.width);
 };
 
-// ======================== Colliders robustes ===========================
-FreeCamera.prototype._buildRobustColliders = function () {
-    this._colliders = [];       // { aabb: BoundingBox }
-    this._worldAabb = null;     // BoundingBox globale du décor (utile debug / clamp)
+// ======================== Colliders indoor-safe ===========================
+FreeCamera.prototype._buildIndoorSafeColliders = function () {
+    this._colliders = [];
+    this._worldAabb = null;
+    this._useCollision = false;
 
     if (!this.focusEntity) return;
 
-    // 1) Récupère toutes les AABBs world des meshInstances du GLB
-    var tmp = [];
+    // 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 aabb = rc.meshInstances[i].aabb;
-                // clone
-                tmp.push(new pc.BoundingBox(aabb.center.clone(), aabb.halfExtents.clone()));
+                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 (tmp.length === 0) return;
-
-    // 2) Gonfle chaque AABB du rayon de la caméra + biais
-    var inflate = Math.max(0, this.collisionRadius) + Math.max(0, this.inflateBias);
-    for (var k = 0; k < tmp.length; k++) {
-        var bb = tmp[k];
-        bb.halfExtents.add(new pc.Vec3(inflate, inflate, inflate));
+    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); // max 49% de tolérance
+    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]);
     }
 
-    // 3) Fusionne les AABBs qui se touchent/quasi-se touchent (mergeGap)
-    var merged = this._mergeAabbs(tmp, this.mergeGap);
+    // 4) Optionnel : petit merge *strict* (uniquement si chevauchement réel)
+    var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap || 0));
 
-    // 4) Enregistre
+    // 5) Gonfler très légèrement (epsilon), pas du rayon complet — le rayon est traité par la résolution
+    var inflate = Math.max(0, this.inflateBias || 0);
     for (var m = 0; m < merged.length; m++) {
-        this._colliders.push({ aabb: merged[m] });
-        if (!this._worldAabb) {
-            this._worldAabb = new pc.BoundingBox(merged[m].center.clone(), merged[m].halfExtents.clone());
-        } else {
-            this._worldAabb.add(merged[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 {
+        // Aucun collider utile après filtrage : on désactive les collisions pour ne pas bloquer
+        this._colliders = [];
+        this._useCollision = false;
+        console.warn('[orbitCamera] Aucun collider utile trouvé (désactivation des collisions)');
     }
 };
 
-// Fusion simple O(n^2) jusqu’à stabilisation
+// Merge strict (gap==0 => uniquement si chevauchement)
 FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
+    if (!boxes || boxes.length <= 1) return boxes.slice();
     var out = boxes.slice();
     var changed = true;
-    var g = Math.max(0, gap || 0);
+    var tol = Math.max(0, gap || 0);
 
-    function overlapsOrTouches(a, b, tol) {
+    function overlap(a, b, t) {
         var amin = a.getMin(), amax = a.getMax();
         var bmin = b.getMin(), bmax = b.getMax();
         return !(
-            amax.x < bmin.x - tol || amin.x > bmax.x + tol ||
-            amax.y < bmin.y - tol || amin.y > bmax.y + tol ||
-            amax.z < bmin.z - tol || amin.z > bmax.z + tol
+            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
         );
     }
 
@@ -195,43 +210,25 @@ FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
         for (var i = 0; i < out.length; i++) {
             if (used[i]) continue;
             var acc = out[i];
-            var mergedAny = false;
-
             for (var j = i + 1; j < out.length; j++) {
                 if (used[j]) continue;
-                if (overlapsOrTouches(acc, out[j], g)) {
-                    // fusion : créer une nouvelle AABB couvrant acc et out[j]
-                    var accMin = acc.getMin(), accMax = acc.getMax();
+                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(accMin.x, bMin.x),
-                        Math.min(accMin.y, bMin.y),
-                        Math.min(accMin.z, bMin.z)
-                    );
-                    var nMax = new pc.Vec3(
-                        Math.max(accMax.x, bMax.x),
-                        Math.max(accMax.y, bMax.y),
-                        Math.max(accMax.z, bMax.z)
-                    );
-
-                    var nCenter = nMin.clone().add(nMax).mulScalar(0.5);
-                    var nHalf = nMax.clone().sub(nCenter).abs();
-                    acc = new pc.BoundingBox(nCenter, nHalf);
-
+                    var nMin = new pc.Vec3(Math.min(aMin.x, bMin.x), Math.min(aMin.y, bMin.y), Math.min(aMin.z, bMin.z));
+                    var nMax = new pc.Vec3(Math.max(aMax.x, bMax.x), Math.max(aMax.y, bMax.y), Math.max(aMax.z, bMax.z));
+                    var c = nMin.clone().add(nMax).mulScalar(0.5);
+                    var h = nMax.clone().sub(c).abs();
+                    acc = new pc.BoundingBox(c, h);
                     used[j] = true;
-                    mergedAny = true;
                     changed = true;
                 }
             }
-
             used[i] = true;
             next.push(acc);
         }
-
         out = next;
     }
-
     return out;
 };
 
@@ -241,18 +238,17 @@ FreeCamera.prototype._bboxEnabled = function () {
 };
 
 FreeCamera.prototype._clampPosition = function (p) {
-    // minY prioritaire
     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 swept + résolution =====================
-// Déplace "de -> to" par petits pas pour éviter le tunneling.
 FreeCamera.prototype._moveSweptTo = function (from, to) {
+    if (!this._useCollision) return to.clone(); // collisions désactivées => pas de blocage
+
     var maxStep = Math.max(0.01, this.maxStepDistance || 0.2);
     var delta = to.clone().sub(from);
     var dist = delta.length();
@@ -274,9 +270,11 @@ FreeCamera.prototype._moveSweptTo = function (from, to) {
     return cur;
 };
 
-// Résolution itérative sphère (caméra) vs AABBs "épaissies"
 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;
@@ -287,11 +285,9 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
 
         for (var i = 0; i < this._colliders.length; i++) {
             var aabb = this._colliders[i].aabb;
+            var min = aabb.getMin(); var max = aabb.getMax();
 
-            // Point le plus proche de p sur l'AABB
-            var min = aabb.getMin();
-            var max = aabb.getMax();
-
+            // Calcul du point le plus proche
             var cx = pc.math.clamp(p.x, min.x, max.x);
             var cy = pc.math.clamp(p.y, min.y, max.y);
             var cz = pc.math.clamp(p.z, min.z, max.z);
@@ -299,56 +295,23 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
             var dx = p.x - cx, dy = p.y - cy, dz = p.z - cz;
             var distSq = dx*dx + dy*dy + dz*dz;
 
-            // Comme les AABBs sont déjà "épaissies" du rayon, ici on traite une sphère ~ de rayon ~0
-            // => il suffit de sortir du volume (point dans AABB élargie)
-            if (distSq < eps*eps && // p quasi dedans et très proche
-                (p.x > min.x - eps && p.x < max.x + eps &&
-                 p.y > min.y - eps && p.y < max.y + eps &&
-                 p.z > min.z - eps && p.z < max.z + eps)) {
-
-                // Choisir l'axe de moindre déplacement pour sortir
-                var ex = Math.min(Math.abs(p.x - min.x), Math.abs(max.x - p.x));
-                var ey = Math.min(Math.abs(p.y - min.y), Math.abs(max.y - p.y));
-                var ez = Math.min(Math.abs(p.z - min.z), Math.abs(max.z - p.z));
-
-                if (ex <= ey && ex <= ez) {
-                    // pousser sur X
-                    if (Math.abs(p.x - min.x) < Math.abs(max.x - p.x)) p.x = min.x - eps; else p.x = max.x + eps;
-                } else if (ey <= ex && ey <= ez) {
-                    // pousser sur Y (gère bord/nez de marche)
-                    if (Math.abs(p.y - min.y) < Math.abs(max.y - p.y)) p.y = Math.max(this.minY, min.y - eps); else p.y = max.y + eps;
-                } else {
-                    // pousser sur Z
-                    if (Math.abs(p.z - min.z) < Math.abs(max.z - p.z)) p.z = min.z - eps; else p.z = max.z + eps;
-                }
-                moved = true;
-                continue;
-            }
+            // Collision sphère vs AABB (AABB non "gonflée" au rayon ; on le traite ici)
+            if (distSq < (R*R)) {
+                var dist = Math.sqrt(Math.max(distSq, 1e-12));
+                var pen = R - dist + eps;
 
-            // Cas général : p dans l'AABB "épaissie" (ou très proche) -> projeter vers l'extérieur
-            var inside =
-                (p.x > min.x - eps && p.x < max.x + eps &&
-                 p.y > min.y - eps && p.y < max.y + eps &&
-                 p.z > min.z - eps && p.z < max.z + eps);
-
-            if (inside) {
-                var dxMin = Math.abs(p.x - min.x), dxMax = Math.abs(max.x - p.x);
-                var dyMin = Math.abs(p.y - min.y), dyMax = Math.abs(max.y - p.y);
-                var dzMin = Math.abs(p.z - min.z), dzMax = Math.abs(max.z - p.z);
-
-                var ax = Math.min(dxMin, dxMax);
-                var ay = Math.min(dyMin, dyMax);
-                var az = Math.min(dzMin, dzMax);
-
-                if (ax <= ay && ax <= az) {
-                    // sortir par X
-                    if (dxMin < dxMax) p.x = min.x - eps; else p.x = max.x + eps;
-                } else if (ay <= ax && ay <= az) {
-                    // sortir par Y
-                    if (dyMin < dyMax) p.y = Math.max(this.minY, min.y - eps); else p.y = max.y + eps;
+                if (dist > 1e-6) {
+                    p.x += (dx / dist) * pen;
+                    p.y += (dy / dist) * pen;
+                    p.z += (dz / dist) * pen;
                 } else {
-                    // sortir par Z
-                    if (dzMin < dzMax) p.z = min.z - eps; else p.z = max.z + eps;
+                    // au même point : pousse vers l'axe de plus faible sortie
+                    var ex = Math.min(Math.abs(p.x - min.x), Math.abs(max.x - p.x));
+                    var ey = Math.min(Math.abs(p.y - min.y), Math.abs(max.y - p.y));
+                    var ez = Math.min(Math.abs(p.z - min.z), Math.abs(max.z - p.z));
+                    if (ex <= ey && ex <= ez) p.x += (Math.abs(p.x - min.x) < Math.abs(max.x - p.x) ? -pen : pen);
+                    else if (ey <= ex && ey <= ez) p.y += (Math.abs(p.y - min.y) < Math.abs(max.y - p.y) ? -pen : pen);
+                    else p.z += (Math.abs(p.z - min.z) < Math.abs(max.z - p.z) ? -pen : pen);
                 }
                 moved = true;
             }
@@ -360,13 +323,13 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
     return p;
 };
 
-// ===================== INPUT SOURIS (rotation + molette dolly) =====================
-var FreeCameraInputMouse = pc.createScript('orbitCameraInputMouse'); // garder le nom
+// ===================== 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; // instance FreeCamera
+    this.freeCam = this.entity.script.orbitCamera;
     this.last = new pc.Vec2();
     this.isLooking = false;
 
@@ -392,31 +355,25 @@ FreeCameraInputMouse.prototype.initialize = function () {
     });
 };
 
-FreeCameraInputMouse.prototype.onMouseDown = function (e) {
-    this.isLooking = true;
-    this.last.set(e.x, e.y);
-};
-
-FreeCameraInputMouse.prototype.onMouseUp = function () { this.isLooking = false; };
+FreeCameraInputMouse.prototype.onMouseDown = function (e) { this.isLooking = true; this.last.set(e.x, e.y); };
+FreeCameraInputMouse.prototype.onMouseUp   = function () { this.isLooking = false; };
 
 FreeCameraInputMouse.prototype.onMouseMove = function (e) {
     if (!this.isLooking || !this.freeCam) return;
-    var sens = this.lookSensitivity;
-    this.freeCam.yaw   = this.freeCam.yaw   - e.dx * sens;
-    this.freeCam.pitch = this.freeCam.pitch - e.dy * sens;
+    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._moveSweptTo(from, to);
     this.freeCam._clampPosition(next);
     cam.setPosition(next);
@@ -424,10 +381,10 @@ FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
     e.event.preventDefault();
 };
 
-// ===================== INPUT TOUCH (look + pinch dolly) =====================
+// ===================== 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.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;
@@ -441,7 +398,6 @@ FreeCameraInputTouch.prototype.initialize = function () {
         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);
@@ -458,8 +414,7 @@ FreeCameraInputTouch.prototype.onTouchStartEndCancel = function (e) {
         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;
-        var dy = t[0].y - t[1].y;
+        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;
@@ -471,37 +426,29 @@ FreeCameraInputTouch.prototype.onTouchMove = function (e) {
     if (!this.freeCam) return;
 
     if (t.length === 1 && this.isLooking) {
-        var sens = this.lookSensitivity;
-        var dx = t[0].x - this.last.x;
-        var dy = t[0].y - this.last.y;
-
-        this.freeCam.yaw   = this.freeCam.yaw   - dx * sens;
-        this.freeCam.pitch = this.freeCam.pitch - dy * sens;
-
+        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) {
-        // Pinch dolly
-        var dx = t[0].x - t[1].x;
-        var dy = t[0].y - t[1].y;
+        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 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._moveSweptTo(from, to);
         this.freeCam._clampPosition(next);
         cam.setPosition(next);
     }
 };
 
-// ===================== INPUT CLAVIER (ZQSD + flèches) =====================
+// ===================== INPUT CLAVIER =====================
 var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
-
-FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused, future)' });
+FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused)' });
 
 FreeCameraInputKeyboard.prototype.initialize = function () {
     this.freeCam = this.entity.script.orbitCamera;
@@ -511,10 +458,8 @@ FreeCameraInputKeyboard.prototype.initialize = function () {
 FreeCameraInputKeyboard.prototype.update = function (dt) {
     if (!this.freeCam || !this.kb) return;
 
-    // Déplacements : flèches OU ZQSD (AZERTY)
     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;
 
@@ -522,12 +467,12 @@ FreeCameraInputKeyboard.prototype.update = function (dt) {
         var cam = this.entity;
         var from = cam.getPosition().clone();
 
-        var forward = cam.forward.clone();  if (forward.lengthSq()  > 1e-8) forward.normalize();
-        var right   = cam.right.clone();    if (right.lengthSq()    > 1e-8) right.normalize();
+        var forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
+        var right   = cam.right.clone();   if (right.lengthSq()   > 1e-8) right.normalize();
 
-        var delta = new pc.Vec3();
-        delta.add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt));
-        delta.add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
+        var delta = new pc.Vec3()
+            .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
+            .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
 
         var to = from.clone().add(delta);
         var next = this.freeCam._moveSweptTo(from, to);
@@ -535,14 +480,11 @@ FreeCameraInputKeyboard.prototype.update = function (dt) {
         cam.setPosition(next);
     }
 
-    // Rotation au clavier (Shift + flèches)
     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); // ← CCW / → CW
-        var pitchDir = (this.kb.isPressed(pc.KEY_UP)   ? 1 : 0) - (this.kb.isPressed(pc.KEY_DOWN)  ? 1 : 0); // ↑ up / ↓ down
-
-        var yawSpeed   = 120; // deg/s
-        var pitchSpeed =  90; // deg/s
+        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;
     }