Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,13 +1,13 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// FREE CAMERA + COLLISION STATIQUE (type FPS léger) pour PlayCanvas
-// - Souris : rotation sur place
+// 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 : dolly (avance/recul le long du regard)
-// - "focusEntity" sert de RACINE de collision (typiquement : ton envEntity GLB)
-// - Collision sphère (caméra) vs AABBs des meshInstances statiques du GLB
-// - minY + Bounding Box globale (Xmin..Zmax) restent actives (post-résolution)
-// - Pas de physique Ammo.js requise
+// - 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
 // ============================================================================
 
 var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera"
@@ -23,13 +23,21 @@ FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title
 FreeCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum camera Y' });
 
 // Vitesse de déplacement (m/s)
-FreeCamera.attributes.add('moveSpeed',   { type: 'number', default: 2.0, title: 'Move Speed' });
-FreeCamera.attributes.add('strafeSpeed', { type: 'number', default: 2.0, title: 'Strafe Speed' });
-FreeCamera.attributes.add('dollySpeed',  { type: 'number', default: 2.0, title: 'Mouse Wheel Dolly Speed' });
+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) — rayon et marge numérique
-FreeCamera.attributes.add('collisionRadius', { type: 'number', default: 0.25, title: 'Camera Sphere Radius' });
-FreeCamera.attributes.add('collisionEpsilon', { type: 'number', default: 0.0005, title: 'Collision Epsilon' });
+// 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' });
+
+// Sous-division du déplacement (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)' });
 
 // Bounding Box globale (active si Xmin<Xmax etc.)
 FreeCamera.attributes.add('Xmin', { type: 'number', default: -Infinity, title: 'BBox Xmin' });
@@ -44,7 +52,7 @@ FreeCamera.attributes.add('focusEntity',  { type: 'entity', title: 'Collision Ro
 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)' });
+FreeCamera.attributes.add('distanceMin',  { type: 'number', default:  0.1,  title: 'Compat: Distance Min (unused)' });
 
 // ======================== Initialisation ===========================
 Object.defineProperty(FreeCamera.prototype, 'pitch', {
@@ -76,27 +84,24 @@ FreeCamera.prototype.initialize = function () {
     // Appliquer orientation immédiatement
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    // Etat input partagé (conservé)
+    // Etat input partagé
     this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
     this.state = this.app.systems.script.app.freeCamState;
 
-    // Contrôles de fenêtre
-    var self = this;
-    this._onResize = function(){ self._checkAspectRatio(); };
-    window.addEventListener('resize', this._onResize, false);
-    this._checkAspectRatio();
-
-    // ====== COLLISIONS: construire la liste d'AABBs statiques à partir du focusEntity (ENV GLB) ======
-    this._colliders = []; // tableau d'objets { aabb: pc.BoundingBox }
-    if (this.focusEntity) {
-        this._buildStaticCollidersFromRoot(this.focusEntity);
-    }
+    // Construire colliders robustes depuis le GLB (focusEntity)
+    this._buildRobustColliders();
 
-    // S’assure que la position courante respecte minY + bbox + collision (si déjà dans un mur)
+    // S’assure que la position courante respecte collisions + minY + bbox
     var p = this.entity.getPosition().clone();
-    p = this._resolveCollisions(p, /*maxIters*/ 4);
+    p = this._moveSweptTo(p, p); // passe par le résolveur même si delta nul
     this._clampPosition(p);
     this.entity.setPosition(p);
+
+    // Aspect ratio (comme avant)
+    var self = this;
+    this._onResize = function(){ self._checkAspectRatio(); };
+    window.addEventListener('resize', this._onResize, false);
+    this._checkAspectRatio();
 };
 
 FreeCamera.prototype.update = function (dt) {
@@ -106,10 +111,9 @@ FreeCamera.prototype.update = function (dt) {
     this._pitch = pc.math.lerp(this._pitch, this._targetPitch, t);
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    // Reclamp soft chaque frame (utile si minY / bbox)
+    // Recadrage léger
     var pos = this.entity.getPosition().clone();
-    // En cas de dérive numérique, resserrer contre les colliders
-    pos = this._resolveCollisions(pos, /*maxIters*/ 1);
+    pos = this._resolveCollisions(pos, this.maxResolveIters);
     this._clampPosition(pos);
     this.entity.setPosition(pos);
 };
@@ -120,36 +124,118 @@ FreeCamera.prototype._checkAspectRatio = function () {
     this.entity.camera.horizontalFov = (gd.height > gd.width);
 };
 
-// ======================== Gestion des colliders (AABBs) ===========================
-FreeCamera.prototype._buildStaticCollidersFromRoot = function (root) {
-    var stack = [root];
-    var tempAabb = new pc.BoundingBox();
+// ======================== Colliders robustes ===========================
+FreeCamera.prototype._buildRobustColliders = function () {
+    this._colliders = [];       // { aabb: BoundingBox }
+    this._worldAabb = null;     // BoundingBox globale du décor (utile debug / clamp)
+
+    if (!this.focusEntity) return;
+
+    // 1) Récupère toutes les AABBs world des meshInstances du GLB
+    var tmp = [];
+    var stack = [this.focusEntity];
     while (stack.length) {
         var e = stack.pop();
-
-        // RenderComponent => récupérer les AABBs des meshInstances
         var rc = e.render;
         if (rc && rc.meshInstances && rc.meshInstances.length) {
             for (var i = 0; i < rc.meshInstances.length; i++) {
-                var mi = rc.meshInstances[i];
-                // s'assurer que l'AABB world est à jour (PlayCanvas le met à jour à la phase de culling,
-                // on le recalcule une fois via "getWorldTransform" si besoin)
-                var aabb = mi.aabb;
-                // Copier l'AABB (pour le figer) : center & halfExtents
-                var aabbCopy = new pc.BoundingBox(aabb.center.clone(), aabb.halfExtents.clone());
-                this._colliders.push({ aabb: aabbCopy });
+                var aabb = rc.meshInstances[i].aabb;
+                // clone
+                tmp.push(new pc.BoundingBox(aabb.center.clone(), aabb.halfExtents.clone()));
             }
         }
-
-        // Parcours enfants
         var ch = e.children;
-        if (ch && ch.length) {
-            for (var c = 0; c < ch.length; c++) stack.push(ch[c]);
+        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));
+    }
+
+    // 3) Fusionne les AABBs qui se touchent/quasi-se touchent (mergeGap)
+    var merged = this._mergeAabbs(tmp, this.mergeGap);
+
+    // 4) Enregistre
+    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]);
+        }
+    }
+};
+
+// Fusion simple O(n^2) jusqu’à stabilisation
+FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
+    var out = boxes.slice();
+    var changed = true;
+    var g = Math.max(0, gap || 0);
+
+    function overlapsOrTouches(a, b, tol) {
+        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
+        );
+    }
+
+    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];
+            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();
+                    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);
+
+                    used[j] = true;
+                    mergedAny = true;
+                    changed = true;
+                }
+            }
+
+            used[i] = true;
+            next.push(acc);
         }
+
+        out = next;
     }
+
+    return out;
 };
 
-// ======================== Contraintes ===========================
+// ======================== Contraintes génériques ===========================
 FreeCamera.prototype._bboxEnabled = function () {
     return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
 };
@@ -164,71 +250,114 @@ FreeCamera.prototype._clampPosition = function (p) {
     p.z = pc.math.clamp(p.z, this.Zmin, this.Zmax);
 };
 
-// ======================== Résolution collisions sphère vs AABB ====================
-// Renvoie une position corrigée en repoussant la sphère de la caméra hors des AABBs.
-// Simple "projection" itérative (plusieurs itérations pour empiler les corrections).
-FreeCamera.prototype._resolveCollisions = function (desiredPos, maxIters) {
-    var pos = desiredPos.clone();
-    var R = Math.max(0, this.collisionRadius);
-    var eps = Math.max(1e-7, this.collisionEpsilon);
+// ======================== Mouvement swept + résolution =====================
+// Déplace "de -> to" par petits pas pour éviter le tunneling.
+FreeCamera.prototype._moveSweptTo = function (from, to) {
+    var maxStep = Math.max(0.01, this.maxStepDistance || 0.2);
+    var delta = to.clone().sub(from);
+    var dist = delta.length();
+
+    if (dist <= maxStep) {
+        var p = from.clone().add(delta);
+        p = this._resolveCollisions(p, this.maxResolveIters);
+        return p;
+    }
 
-    if (!this._colliders || this._colliders.length === 0 || R === 0) {
-        return pos;
+    var steps = Math.ceil(dist / maxStep);
+    var stepVec = delta.divScalar(steps);
+    var cur = from.clone();
+
+    for (var i = 0; i < steps; i++) {
+        cur.add(stepVec);
+        cur = this._resolveCollisions(cur, this.maxResolveIters);
     }
+    return cur;
+};
+
+// Résolution itérative sphère (caméra) vs AABBs "épaissies"
+FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
+    var p = pos.clone();
+    var eps = Math.max(1e-7, this.collisionEpsilon);
+
+    if (!this._colliders || this._colliders.length === 0) return p;
 
-    for (var iter = 0; iter < (maxIters || 1); iter++) {
+    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;
 
-            // Trouver le point le plus proche sur l'AABB par rapport au centre de la sphère
+            // Point le plus proche de p sur l'AABB
             var min = aabb.getMin();
             var max = aabb.getMax();
 
-            var cx = pc.math.clamp(pos.x, min.x, max.x);
-            var cy = pc.math.clamp(pos.y, min.y, max.y);
-            var cz = pc.math.clamp(pos.z, min.z, max.z);
-
-            var dx = pos.x - cx;
-            var dy = pos.y - cy;
-            var dz = pos.z - cz;
+            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);
 
+            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 - eps)) {
-                // Collision : repousser la sphère en dehors
-                var dist = Math.sqrt(Math.max(distSq, 1e-12));
-                var pen  = R - dist;
-
-                if (dist > 1e-6) {
-                    // direction = depuis le point le plus proche vers le centre
-                    pos.x += (dx / dist) * (pen + eps);
-                    pos.y += (dy / dist) * (pen + eps);
-                    pos.z += (dz / dist) * (pen + eps);
-                    moved = true;
+            // 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 {
-                    // sphère centre exactement sur une arête/coin : pousser le long de l'axe de moindre pénétration
-                    var ex = Math.min(Math.abs(pos.x - min.x), Math.abs(max.x - pos.x));
-                    var ey = Math.min(Math.abs(pos.y - min.y), Math.abs(max.y - pos.y));
-                    var ez = Math.min(Math.abs(pos.z - min.z), Math.abs(max.z - pos.z));
-
-                    if (ex <= ey && ex <= ez) {
-                        pos.x += (pos.x - aabb.center.x >= 0 ? 1 : -1) * (pen + eps);
-                    } else if (ey <= ex && ey <= ez) {
-                        pos.y += (pos.y - aabb.center.y >= 0 ? 1 : -1) * (pen + eps);
-                    } else {
-                        pos.z += (pos.z - aabb.center.z >= 0 ? 1 : -1) * (pen + eps);
-                    }
-                    moved = true;
+                    // 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;
+            }
+
+            // 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;
+                } else {
+                    // sortir par Z
+                    if (dzMin < dzMax) p.z = min.z - eps; else p.z = max.z + eps;
+                }
+                moved = true;
             }
         }
 
         if (!moved) break;
     }
 
-    return pos;
+    return p;
 };
 
 // ===================== INPUT SOURIS (rotation + molette dolly) =====================
@@ -268,38 +397,29 @@ FreeCameraInputMouse.prototype.onMouseDown = function (e) {
     this.last.set(e.x, e.y);
 };
 
-FreeCameraInputMouse.prototype.onMouseUp = function () {
-    this.isLooking = false;
-};
+FreeCameraInputMouse.prototype.onMouseUp = function () { this.isLooking = false; };
 
 FreeCameraInputMouse.prototype.onMouseMove = function (e) {
     if (!this.isLooking || !this.freeCam) return;
     var sens = this.lookSensitivity;
-
-    var deltaYaw   = (e.dx) * sens;
-    var deltaPitch = (e.dy) * sens;
-
-    this.freeCam.yaw   = this.freeCam.yaw   - deltaYaw;
-    this.freeCam.pitch = this.freeCam.pitch - deltaPitch;
-
+    this.freeCam.yaw   = this.freeCam.yaw   - e.dx * sens;
+    this.freeCam.pitch = this.freeCam.pitch - e.dy * sens;
     this.last.set(e.x, e.y);
 };
 
 FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
     if (!this.freeCam) return;
 
-    // Dolly : avancer/reculer dans l'axe du regard
     var cam = this.entity;
-    var move = -e.wheelDelta * this.wheelSensitivity * this.freeCam.dollySpeed * 0.05; // échelle douce
-    var forward = cam.forward.clone().normalize().mulScalar(move);
+    var move = -e.wheelDelta * this.wheelSensitivity * this.freeCam.dollySpeed * 0.05;
+    var forward = cam.forward.clone(); if (forward.lengthSq() > 1e-8) forward.normalize();
 
-    var pos = cam.getPosition().clone().add(forward);
+    var from = cam.getPosition().clone();
+    var to   = from.clone().add(forward.mulScalar(move));
 
-    // ===== collision + contraintes =====
-    pos = this.freeCam._resolveCollisions(pos, /*maxIters*/ 3);
-    this.freeCam._clampPosition(pos);
-
-    cam.setPosition(pos);
+    var next = this.freeCam._moveSweptTo(from, to);
+    this.freeCam._clampPosition(next);
+    cam.setPosition(next);
 
     e.event.preventDefault();
 };
@@ -368,14 +488,13 @@ FreeCameraInputTouch.prototype.onTouchMove = function (e) {
         this.lastPinch = dist;
 
         var cam = this.entity;
-        var forward = cam.forward.clone().normalize().mulScalar(delta * this.pinchDollyFactor * this.freeCam.dollySpeed);
-        var pos = cam.getPosition().clone().add(forward);
-
-        // ===== collision + contraintes =====
-        pos = this.freeCam._resolveCollisions(pos, /*maxIters*/ 3);
-        this.freeCam._clampPosition(pos);
+        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));
 
-        cam.setPosition(pos);
+        var next = this.freeCam._moveSweptTo(from, to);
+        this.freeCam._clampPosition(next);
+        cam.setPosition(next);
     }
 };
 
@@ -401,19 +520,19 @@ FreeCameraInputKeyboard.prototype.update = function (dt) {
 
     if (fwd !== 0 || strf !== 0) {
         var cam = this.entity;
-        var pos = cam.getPosition().clone();
+        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();
 
-        pos.add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt));
-        pos.add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
-
-        // ===== collision + contraintes =====
-        pos = this.freeCam._resolveCollisions(pos, /*maxIters*/ 3);
-        this.freeCam._clampPosition(pos);
+        var delta = new pc.Vec3();
+        delta.add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt));
+        delta.add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
 
-        cam.setPosition(pos);
+        var to = from.clone().add(delta);
+        var next = this.freeCam._moveSweptTo(from, to);
+        this.freeCam._clampPosition(next);
+        cam.setPosition(next);
     }
 
     // Rotation au clavier (Shift + flèches)