Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,19 +1,21 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// FREE CAMERA (sans orbite) pour PlayCanvas
-// - Souris : rotation sur place (comme Shift+flèches auparavant)
+// FREE CAMERA + COLLISION STATIQUE (type FPS léger) pour PlayCanvas
+// - Souris : rotation sur place
 // - ZQSD / Flèches : déplacement local (avant/arrière & strafe)
 // - Molette : dolly (avance/recul le long du regard)
-// - Bounding Box + minY : contraintes sur la POSITION caméra uniquement
-// - AUCUNE logique d’orbite (pas de pivot, pas de distance d’orbite)
+// - "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
 // ============================================================================
 
-var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera" pour compat viewer
+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 (conseil: -89..89 si vue libre)
+// 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)' });
 
@@ -25,7 +27,11 @@ FreeCamera.attributes.add('moveSpeed',   { type: 'number', default: 2.0, title:
 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' });
 
-// Bounding Box (active si Xmin<Xmax etc.)
+// 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' });
+
+// Bounding Box globale (active si Xmin<Xmax etc.)
 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' });
@@ -33,8 +39,8 @@ 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 (ignorés mais laissés pour ne pas casser le viewer existant)
-FreeCamera.attributes.add('focusEntity',  { type: 'entity', title: 'Compat: Focus Entity (unused)' });
+// Compat (certaines non utilisées, 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)' });
 FreeCamera.attributes.add('yawAngleMax',  { type: 'number', default:  360, title: 'Compat: Yaw Max (unused)' });
@@ -56,9 +62,7 @@ FreeCamera.prototype.initialize = function () {
     var f = new pc.Vec3();
     q.transformVector(pc.Vec3.FORWARD, f);
 
-    // Convention PlayCanvas: setLocalEulerAngles(pitch, yaw, 0)
     this._yaw   = Math.atan2(f.x, f.z) * pc.math.RAD_TO_DEG;
-    // retirer le yaw pour extraire un pitch cohérent
     var yawQuat = new pc.Quat().setFromEulerAngles(0, -this._yaw, 0);
     var noYawQ  = new pc.Quat().mul2(yawQuat, q);
     var fNoYaw  = new pc.Vec3();
@@ -72,20 +76,27 @@ FreeCamera.prototype.initialize = function () {
     // Appliquer orientation immédiatement
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    // Etat input (partagé par scripts d’input)
+    // Etat input partagé (conservé)
     this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
-    this.state = this.app.systems.script.app.freeCamState; // pointeur commun
-
-    // S’assure que la position courante respecte minY + bbox
-    var p = this.entity.getPosition().clone();
-    this._clampPosition(p);
-    this.entity.setPosition(p);
+    this.state = this.app.systems.script.app.freeCamState;
 
-    // Aspect ratio (comme avant)
+    // 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);
+    }
+
+    // S’assure que la position courante respecte minY + bbox + collision (si déjà dans un mur)
+    var p = this.entity.getPosition().clone();
+    p = this._resolveCollisions(p, /*maxIters*/ 4);
+    this._clampPosition(p);
+    this.entity.setPosition(p);
 };
 
 FreeCamera.prototype.update = function (dt) {
@@ -95,8 +106,10 @@ FreeCamera.prototype.update = function (dt) {
     this._pitch = pc.math.lerp(this._pitch, this._targetPitch, t);
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    // Déplacements clavier (gérés dans Keyboard, mais on reclampe chaque frame)
+    // Reclamp soft chaque frame (utile si minY / bbox)
     var pos = this.entity.getPosition().clone();
+    // En cas de dérive numérique, resserrer contre les colliders
+    pos = this._resolveCollisions(pos, /*maxIters*/ 1);
     this._clampPosition(pos);
     this.entity.setPosition(pos);
 };
@@ -107,6 +120,35 @@ 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();
+    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 });
+            }
+        }
+
+        // Parcours enfants
+        var ch = e.children;
+        if (ch && ch.length) {
+            for (var c = 0; c < ch.length; c++) stack.push(ch[c]);
+        }
+    }
+};
+
 // ======================== Contraintes ===========================
 FreeCamera.prototype._bboxEnabled = function () {
     return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
@@ -122,6 +164,73 @@ 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);
+
+    if (!this._colliders || this._colliders.length === 0 || R === 0) {
+        return pos;
+    }
+
+    for (var iter = 0; iter < (maxIters || 1); 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
+            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 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;
+                } 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;
+                }
+            }
+        }
+
+        if (!moved) break;
+    }
+
+    return pos;
+};
+
 // ===================== INPUT SOURIS (rotation + molette dolly) =====================
 var FreeCameraInputMouse = pc.createScript('orbitCameraInputMouse'); // garder le nom
 FreeCameraInputMouse.attributes.add('lookSensitivity', { type: 'number', default: 0.3, title: 'Look Sensitivity' });
@@ -155,7 +264,6 @@ FreeCameraInputMouse.prototype.initialize = function () {
 };
 
 FreeCameraInputMouse.prototype.onMouseDown = function (e) {
-    // Bouton gauche/milieu/droit -> tous = "look"
     this.isLooking = true;
     this.last.set(e.x, e.y);
 };
@@ -168,12 +276,11 @@ FreeCameraInputMouse.prototype.onMouseMove = function (e) {
     if (!this.isLooking || !this.freeCam) return;
     var sens = this.lookSensitivity;
 
-    // Souris = même logique que "Shift + flèches" (rotation sur place)
-    var deltaYaw   = (e.dx) * sens;  // droite => +dx => on veut TURN RIGHT (CW) => yaw diminue
-    var deltaPitch = (e.dy) * sens;  // haut => dy<0 => look up => pitch augmente => pitch -= deltaPitch
+    var deltaYaw   = (e.dx) * sens;
+    var deltaPitch = (e.dy) * sens;
 
-    this.freeCam.yaw   = this.freeCam.yaw   - deltaYaw;   // yaw libre
-    this.freeCam.pitch = this.freeCam.pitch - deltaPitch; // pitch clampé
+    this.freeCam.yaw   = this.freeCam.yaw   - deltaYaw;
+    this.freeCam.pitch = this.freeCam.pitch - deltaPitch;
 
     this.last.set(e.x, e.y);
 };
@@ -187,13 +294,17 @@ FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
     var forward = cam.forward.clone().normalize().mulScalar(move);
 
     var pos = cam.getPosition().clone().add(forward);
+
+    // ===== collision + contraintes =====
+    pos = this.freeCam._resolveCollisions(pos, /*maxIters*/ 3);
     this.freeCam._clampPosition(pos);
+
     cam.setPosition(pos);
 
     e.event.preventDefault();
 };
 
-// ===================== INPUT TOUCH (optionnel : look + pinch dolly simple) =====================
+// ===================== INPUT TOUCH (look + pinch dolly) =====================
 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' });
@@ -259,7 +370,11 @@ FreeCameraInputTouch.prototype.onTouchMove = function (e) {
         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);
+
         cam.setPosition(pos);
     }
 };
@@ -294,17 +409,19 @@ FreeCameraInputKeyboard.prototype.update = function (dt) {
         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);
+
         cam.setPosition(pos);
     }
 
-    // Rotation au clavier (Shift + flèches) — conservée
+    // 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
 
-        // Même logique que la souris : rotation sur place
         var yawSpeed   = 120; // deg/s
         var pitchSpeed =  90; // deg/s
         if (yawDir   !== 0) this.freeCam.yaw   = this.freeCam.yaw   + yawDir   * yawSpeed   * dt;