Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -35,13 +35,10 @@ FreeCamera.attributes.add('maxStepDistance', { type: 'number', default: 0.20, ti
 FreeCamera.attributes.add('maxResolveIters', { type: 'number', default: 6, title: 'Max resolve iterations per step' });
 
 // Construction des colliders
-// 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)' });
 
-// 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".
+// Filtrage "anti-coquille"
 FreeCamera.attributes.add('globalCullFrac', { type: 'number', default: 0.08, title: 'Cull near-global AABBs (0.08=8%)' });
 
 // Bounding Box globale optionnelle (Xmin..Zmax)
@@ -86,9 +83,9 @@ FreeCamera.prototype.initialize = function () {
     this.state = this.app.systems.script.app.freeCamState;
 
     // colliders
-    this._buildIndoorSafeColliders(); // <= clé de la correction
+    this._buildIndoorSafeColliders();
 
-    // Forcer une passe de résolution initiale (si on spawn “dans” un mur)
+    // Forcer une passe de résolution initiale
     var p = this.entity.getPosition().clone();
     p = this._moveSweptTo(p, p);
     this._clampPosition(p);
@@ -151,7 +148,7 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
     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 frac = pc.math.clamp(this.globalCullFrac, 0, 0.49);
     var wh = world.halfExtents;
     var filtered = [];
     for (var k = 0; k < boxes.length; k++) {
@@ -163,10 +160,10 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
         if (!nearGlobal) filtered.push(boxes[k]);
     }
 
-    // 4) Optionnel : petit merge *strict* (uniquement si chevauchement réel)
+    // 4) Merge strict (chevauchement réel uniquement, gap ~ 0)
     var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap || 0));
 
-    // 5) Gonfler très légèrement (epsilon), pas du rayon complet — le rayon est traité par la résolution
+    // 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));
@@ -178,7 +175,6 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
         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)');
@@ -215,11 +211,27 @@ FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
                 if (overlap(acc, out[j], tol)) {
                     var aMin = acc.getMin(), aMax = acc.getMax();
                     var bMin = out[j].getMin(), bMax = out[j].getMax();
-                    var nMin = new pc.Vec3(Math.min(aMin.x, bMin.x), Math.min(aMin.y, bMin.y), Math.min(aMin.z, bMin.z));
-                    var nMax = new pc.Vec3(Math.max(aMax.x, bMax.x), Math.max(aMax.y, bMax.y), Math.max(aMax.z, bMax.z));
-                    var c = nMin.clone().add(nMax).mulScalar(0.5);
-                    var h = nMax.clone().sub(c).abs();
-                    acc = new pc.BoundingBox(c, h);
+
+                    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);
+
+                    // ❗️Pas de .abs() sur pc.Vec3 : calculer composante par composante
+                    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;
                 }
@@ -247,7 +259,7 @@ FreeCamera.prototype._clampPosition = function (p) {
 
 // ======================== Mouvement swept + résolution =====================
 FreeCamera.prototype._moveSweptTo = function (from, to) {
-    if (!this._useCollision) return to.clone(); // collisions désactivées => pas de blocage
+    if (!this._useCollision) return to.clone();
 
     var maxStep = Math.max(0.01, this.maxStepDistance || 0.2);
     var delta = to.clone().sub(from);
@@ -287,7 +299,7 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
             var aabb = this._colliders[i].aabb;
             var min = aabb.getMin(); var max = aabb.getMax();
 
-            // Calcul du point le plus proche
+            // Point le plus proche sur l'AABB
             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);
@@ -295,7 +307,6 @@ 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;
 
-            // 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;
@@ -305,7 +316,7 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
                     p.y += (dy / dist) * pen;
                     p.z += (dz / dist) * pen;
                 } else {
-                    // au même point : pousse vers l'axe de plus faible sortie
+                    // pousser selon l'axe le plus "proche"
                     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));