Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,18 +1,27 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// FREE CAMERA + COLLISION ROBUSTE (sans Ammo) — version "indoor safe"
-// Respecte la position initiale (JSON). Ne spawne à l’intérieur que si nécessaire.
+// FREE CAMERA + COLLISION INDOOR-SAFE (sans Ammo) avec STEP OFFSET (escaliers)
+// - Souris : look
+// - ZQSD / Flèches : déplacement local
+// - 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
 // ============================================================================
 
-var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera"
+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' });
@@ -25,15 +34,21 @@ 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 (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)' });
-FreeCamera.attributes.add('globalCullFrac', { type: 'number', default: 0.08, title: 'Cull near-global AABBs (0.08=8%)' });
+// Indoor-safe colliders
+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 = chevauchement réel seulement)' });
+FreeCamera.attributes.add('globalCullFrac',{ type: 'number', default: 0.08, title: 'Cull near-global AABBs (0.08=8%)' });
+
+// Step offset / Ground snap (escaliers)
+FreeCamera.attributes.add('stepHeight',   { type: 'number', default: 0.35, title: 'Max step-up height (m)' });
+FreeCamera.attributes.add('stepAhead',    { type: 'number', default: 0.20, title: 'Probe distance ahead for step (m)' });
+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 (seulement si la position initiale est invalide)
-FreeCamera.attributes.add('autoSpawnInside', { type: 'boolean', default: false, title: 'Auto-spawn inside if needed' });
+// Spawn auto si nécessaire seulement
+FreeCamera.attributes.add('autoSpawnInside', { type: 'boolean', default: true, title: 'Auto-spawn inside if needed' });
 
-// Bounding Box globale optionnelle (Xmin..Zmax)
+// 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' });
 FreeCamera.attributes.add('Ymin', { type: 'number', default: -Infinity, title: 'BBox Ymin' });
@@ -48,6 +63,18 @@ 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 ===========================
+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);
+}
+
 // ======================== Initialisation ===========================
 Object.defineProperty(FreeCamera.prototype, 'pitch', {
     get: function () { return this._targetPitch; },
@@ -77,13 +104,12 @@ FreeCamera.prototype.initialize = function () {
     // colliders
     this._buildIndoorSafeColliders();
 
-    // ======== respecter la position initiale, ne spawner dedans que si nécessaire ========
+    // 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
+            this._spawnInside();
         } else {
-            // juste assainir si on spawn légèrement intersecté
             var safe = this._resolveCollisions(start, this.maxResolveIters);
             this._clampPosition(safe);
             this.entity.setPosition(safe);
@@ -104,7 +130,7 @@ FreeCamera.prototype.update = function (dt) {
     this._pitch = pc.math.lerp(this._pitch, this._targetPitch, t);
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    // petit “reclamp”
+    // maintien propre (au cas où)
     var pos = this.entity.getPosition().clone();
     pos = this._resolveCollisions(pos, this.maxResolveIters);
     this._clampPosition(pos);
@@ -180,7 +206,7 @@ FreeCamera.prototype._buildIndoorSafeColliders = function () {
     }
 };
 
-// Merge strict
+// Merge strict (gap==0 => chevauchement seulement)
 FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
     if (!boxes || boxes.length <= 1) return boxes.slice();
     var out = boxes.slice();
@@ -241,8 +267,7 @@ FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
     return out;
 };
 
-// ======================== SPAWN INTÉRIEUR (optionnel) ===========================
-// décide si on doit "forcer" un spawn intérieur
+// ======================== SPAWN / VALIDATION POSITION ===========================
 FreeCamera.prototype._shouldAutoSpawn = function (pos) {
     if (!this._useCollision || !this._worldAabb) return false;
 
@@ -252,20 +277,20 @@ FreeCamera.prototype._shouldAutoSpawn = function (pos) {
     var wmin = this._worldAabb.getMin();
     var wmax = this._worldAabb.getMax();
 
-    // 1) hors monde (avec marge du rayon)
+    // 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
+    // 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)
+    // trop en dessous/au dessus
     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)
+    // forte intersection initiale
     var resolved = this._resolveCollisions(pos, this.maxResolveIters);
     var move = resolved.clone().sub(pos).length();
     if (move > R * 0.5) return true;
@@ -273,7 +298,6 @@ FreeCamera.prototype._shouldAutoSpawn = function (pos) {
     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;
@@ -287,7 +311,6 @@ FreeCamera.prototype._highestYUnderXZ = function (x, z, eps) {
     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;
 
@@ -323,31 +346,143 @@ FreeCamera.prototype._clampPosition = function (p) {
     p.z = pc.math.clamp(p.z, this.Zmin, this.Zmax);
 };
 
-// ======================== Mouvement swept + résolution =====================
-FreeCamera.prototype._moveSweptTo = function (from, to) {
-    if (!this._useCollision) return to.clone();
+// ======================== 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 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;
-    }
+    var total = desiredDelta.clone();
+    var dist = length(total);
+    if (dist <= maxStep) return this._moveStep(from, total);
 
     var steps = Math.ceil(dist / maxStep);
-    var stepVec = delta.divScalar(steps);
+    var stepVec = vec3Scale(total, 1/steps);
     var cur = from.clone();
-
     for (var i = 0; i < steps; i++) {
-        cur.add(stepVec);
-        cur = this._resolveCollisions(cur, this.maxResolveIters);
+        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);
+
+    // 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;
+    }
+
+    // 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;
+    }
+
+    // pas de normale estimable (rare) : accepte la position résolue
+    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);
+};
+
+// 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;
+};
+
+// 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 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;
+};
+
+// ======================== Résolution collision sphère/AABB =====================
+// Déplace et “expulse” si p (centre sphère) intersecte un AABB.
 FreeCamera.prototype._resolveCollisions = function (pos, maxIters) {
     if (!this._useCollision) return pos.clone();
 
@@ -451,7 +586,7 @@ FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
 
     var from = cam.getPosition().clone();
     var to   = from.clone().add(forward.mulScalar(move));
-    var next = this.freeCam._moveSweptTo(from, to);
+    var next = this.freeCam._moveWithCollisions(from, to.sub(from));
     this.freeCam._clampPosition(next);
     cam.setPosition(next);
 
@@ -517,7 +652,7 @@ FreeCameraInputTouch.prototype.onTouchMove = function (e) {
         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);
+        var next = this.freeCam._moveWithCollisions(from, to.sub(from));
         this.freeCam._clampPosition(next);
         cam.setPosition(next);
     }
@@ -551,8 +686,7 @@ FreeCameraInputKeyboard.prototype.update = function (dt) {
             .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);
+        var next = this.freeCam._moveWithCollisions(from, delta);
         this.freeCam._clampPosition(next);
         cam.setPosition(next);
     }