Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,27 +1,18 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
 // 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
+// Respecte la position initiale (JSON). Ne spawne à l’intérieur que si nécessaire.
 // ============================================================================
 
 var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera"
 
 // ======================== 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' });
@@ -34,13 +25,14 @@ FreeCamera.attributes.add('collisionEpsilon', { type: 'number', default: 0.0005,
 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
+// Construction des colliders (indoor-safe)
 FreeCamera.attributes.add('inflateBias', { type: 'number', default: 0.0, title: 'Extra inflate (m, tiny)' });
 FreeCamera.attributes.add('mergeGap',   { type: 'number', default: 0.0, title: 'Merge AABBs gap (0 = pas de gap)' });
-
-// Filtrage "anti-coquille"
 FreeCamera.attributes.add('globalCullFrac', { type: 'number', default: 0.08, title: 'Cull near-global AABBs (0.08=8%)' });
 
+// Spawn auto (seulement si la position initiale est invalide)
+FreeCamera.attributes.add('autoSpawnInside', { type: 'boolean', default: true, title: 'Auto-spawn inside if needed' });
+
 // 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' });
@@ -85,11 +77,18 @@ FreeCamera.prototype.initialize = function () {
     // colliders
     this._buildIndoorSafeColliders();
 
-    // Forcer une passe de résolution initiale
-    var p = this.entity.getPosition().clone();
-    p = this._moveSweptTo(p, p);
-    this._clampPosition(p);
-    this.entity.setPosition(p);
+    // ======== 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(); // place au centre + pose sur sol
+        } else {
+            // juste assainir si on spawn légèrement intersecté
+            var safe = this._resolveCollisions(start, this.maxResolveIters);
+            this._clampPosition(safe);
+            this.entity.setPosition(safe);
+        }
+    }
 
     // aspect
     var self = this;
@@ -160,7 +159,7 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
         if (!nearGlobal) filtered.push(boxes[k]);
     }
 
-    // 4) Merge strict (chevauchement réel uniquement, gap ~ 0)
+    // 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
@@ -181,7 +180,7 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
     }
 };
 
-// Merge strict (gap==0 => uniquement si chevauchement)
+// Merge strict
 FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
     if (!boxes || boxes.length <= 1) return boxes.slice();
     var out = boxes.slice();
@@ -223,8 +222,6 @@ FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
                         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),
@@ -244,6 +241,75 @@ FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
     return out;
 };
 
+// ======================== SPAWN INTÉRIEUR (optionnel) ===========================
+// décide si on doit "forcer" un spawn intérieur
+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();
+
+    // 1) 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;
+
+    // 2) pas de "sol" sous ce XZ
+    var bestY = this._highestYUnderXZ(pos.x, pos.z, eps);
+    if (bestY === -Infinity) return true;
+
+    // 3) si on est très en dessous du sol (ou bien au-dessus du plafond)
+    if (pos.y < bestY - 2.0) return true;
+    if (pos.y > wmax.y + 0.5) return true;
+
+    // 4) si on intersecte déjà fortement un collider (la résolution bouge beaucoup)
+    var resolved = this._resolveCollisions(pos, this.maxResolveIters);
+    var move = resolved.clone().sub(pos).length();
+    if (move > R * 0.5) return true;
+
+    return false;
+};
+
+// calcule le maxY des AABBs couvrant (x,z) — "sol" approximé
+FreeCamera.prototype._highestYUnderXZ = function (x, z, eps) {
+    var bestY = -Infinity;
+    if (!this._colliders) return bestY;
+    for (var i = 0; i < this._colliders.length; i++) {
+        var aabb = this._colliders[i].aabb;
+        var amin = aabb.getMin(), amax = aabb.getMax();
+        if (x >= amin.x - eps && x <= amax.x + eps && z >= amin.z - eps && z <= amax.z + eps) {
+            if (amax.y > bestY) bestY = amax.y;
+        }
+    }
+    return bestY;
+};
+
+// place la caméra à l’intérieur: centre XZ, “drop” sur le sol/marche sous ce XZ
+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);
+};
+
 // ======================== Contraintes génériques ===========================
 FreeCamera.prototype._bboxEnabled = function () {
     return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
@@ -297,12 +363,12 @@ 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();
+            var amin = aabb.getMin(); var amax = aabb.getMax();
 
             // 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);
+            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;
@@ -317,12 +383,12 @@ FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
                     p.z += (dz / dist) * pen;
                 } else {
                     // 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));
-                    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);
+                    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;
             }