Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,404 +1,642 @@
-// ctrl_camera_rigidbody_fps.js
+// ctrl_camera_pr_env.js
 // ============================================================================
-// Contrôle caméra pour la version "physique" (Ammo) avec player capsule dynamique.
-// - À attacher sur l'entité **Player** (rigidbody capsule) créée par viewer_pr_env.js
-// - La caméra doit être **enfant** de Player (hauteur des yeux). Le script gère:
-//   * Souris / Touch : yaw (Player) + pitch (Camera enfant)
-//   * Clavier : ZQSD/WSAD/Flèches + E/Space (monter) + A/Ctrl (descendre) + Shift (dash)
-//   * Molette / Pinch : avancer/reculer (dolly) en ajustant la vélocité
-//   * Modes : Free-fly (gravité nulle) ou Grounded (gravité, jump)
-// - Fonctionne aussi si les attributs ne sont pas renseignés: auto-détection Player/Camera
+// FREE CAMERA (sans orbite) + COLLISION "FIRST-PERSON" style PlayCanvas
+// - Souris : rotation libre (FPS)
+// - ZQSD / Flèches : déplacement local (avant/arrière & strafe)
+// - Molette / Pinch : dolly (avance/recul le long du regard)
+// - Collisions : Capsule (caméra) vs AABBs dérivés des meshes sous focusEntity
+// - Step offset (monte les marches) + Snap down (redescend sur le sol)
+// - Pas d'auto-spawn : la position JSON est respectée strictement
 // ============================================================================
 
-/*
-  UTILISATION
-  ----------
-  1) Ajoute ce fichier en ScriptAsset sur l'app.
-  2) Sur l'entité Player (capsule), ajoute un ScriptComponent et crée "fpController".
-     - cameraChild: (optionnel) référence vers ta caméra enfant. Si vide, pris 1er child avec component "camera".
-  3) (Optionnel) Ajoute aussi fpInputMouse, fpInputTouch, fpInputKeyboard sur la même entité (Player).
-     Sinon fpController attache des listeners par défaut (mais séparer reste plus propre).
+var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public pour compat viewer
 
-  NB: Si tu utilises le viewer fourni, la caméra est déjà enfant de Player.
-*/
-
-var FPC = pc.createScript('fpController');
+// ======================== Attributs ===========================
+// Look
+FreeCamera.attributes.add('inertiaFactor', { type: 'number', default: 0.10, title: 'Inertia (rotation)' });
+FreeCamera.attributes.add('pitchAngleMin', { type: 'number', default: -89, title: 'Pitch Min (deg)' });
+FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title: 'Pitch Max (deg)' });
 
-// ----------------------- Attributs -----------------------
-FPC.attributes.add('cameraChild', { type: 'entity', title: 'Camera (child of Player)' });
-FPC.attributes.add('freeFly', { type: 'boolean', default: true, title: 'Free Fly (no gravity)' });
+// Sol mini (filet de sécurité)
+FreeCamera.attributes.add('minY', { type: 'number', default: -10, title: 'Minimum camera Y' });
 
 // Vitesse (m/s)
-FPC.attributes.add('moveSpeed', { type: 'number', default: 2.2, title: 'Move Speed' });
-FPC.attributes.add('strafeSpeed', { type: 'number', default: 2.2, title: 'Strafe Speed' });
-FPC.attributes.add('verticalSpeed', { type: 'number', default: 2.0, title: 'Vertical Speed (free-fly)'});
-FPC.attributes.add('dashMultiplier', { type: 'number', default: 1.8, title: 'Shift Dash Multiplier' });
-FPC.attributes.add('maxVelocity', { type: 'number', default: 6.5, title: 'Max Linear Velocity (clamp)' });
-
-// Saut (grounded)
-FPC.attributes.add('jumpImpulse', { type: 'number', default: 4.6, title: 'Jump Impulse (grounded)' });
-FPC.attributes.add('groundCheckOffset', { type: 'number', default: 0.05, title: 'Ground Check Extra (m)' });
-FPC.attributes.add('groundMaxSlopeDeg', { type: 'number', default: 55, title: 'Ground Max Slope (deg)' });
-
-// Look
-FPC.attributes.add('lookSensitivity', { type: 'number', default: 0.27, title: 'Mouse/Touch Look Sensitivity' });
-FPC.attributes.add('invertY', { type: 'boolean', default: false, title: 'Invert Y' });
-FPC.attributes.add('pitchMin', { type: 'number', default: -85, title: 'Pitch Min (deg)' });
-FPC.attributes.add('pitchMax', { type: 'number', default: 85, title: 'Pitch Max (deg)' });
-FPC.attributes.add('smoothing', { type: 'number', default: 0.18, title: 'Velocity Lerp (0..1s)'});
-
-// Dolly / Pinch
-FPC.attributes.add('wheelFactor', { type: 'number', default: 0.9, title: 'Wheel Factor (m per notch)'});
-FPC.attributes.add('pinchFactor', { type: 'number', default: 0.02, title: 'Pinch Factor'});
-
-// Debug
-FPC.attributes.add('debugRays', { type: 'boolean', default: false, title: 'Debug Ground Raycasts (console)'});
-
-// ----------------------- Helpers -----------------------
-function clamp(v, a, b){ return Math.max(a, Math.min(b, v)); }
-function toRad(deg){ return deg * pc.math.DEG_TO_RAD; }
-function horiz(v){ return new pc.Vec3(v.x, 0, v.z); }
-
-// ----------------------- Lifecycle -----------------------
-FPC.prototype.initialize = function(){
-    this.app.mouse && this.app.mouse.disableContextMenu();
-
-    // Trouver la caméra enfant si non liée
-    if (!this.cameraChild) {
-        var found = null;
-        for (var i=0;i<this.entity.children.length;i++){
-            var c = this.entity.children[i];
-            if (c.camera) { found = c; break; }
+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.2, title: 'Mouse/Pinch Dolly Speed' });
+
+// Capsule caméra
+FreeCamera.attributes.add('capsuleRadius',  { type: 'number', default: 0.30, title: 'Capsule Radius (m)' });
+FreeCamera.attributes.add('capsuleHeight',  { type: 'number', default: 1.60, title: 'Capsule Height (m) — yeux à ~0.9m au-dessus du centre' });
+FreeCamera.attributes.add('collisionEps',   { type: 'number', default: 0.0005, title: 'Collision Epsilon' });
+
+// Mouvement "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' });
+
+// 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('snapDownMax',  { type: 'number', default: 0.60, title: 'Max snap-down (m)' });
+FreeCamera.attributes.add('enableGroundSnap', { type: 'boolean', default: true, title: 'Enable ground snap' });
+
+// AABBs (construction "indoor-safe")
+FreeCamera.attributes.add('inflateBias',   { type: 'number', default: 0.0,  title: 'Extra inflate AABB (m)' });
+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%)' });
+
+// BBox globale optionnelle (filet)
+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' });
+FreeCamera.attributes.add('Ymax', { type: 'number', default:  Infinity, title: 'BBox Ymax' });
+FreeCamera.attributes.add('Zmin', { type: 'number', default: -Infinity, title: 'BBox Zmin' });
+FreeCamera.attributes.add('Zmax', { type: 'number', default:  Infinity, title: 'BBox Zmax' });
+
+// Compat (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)' });
+FreeCamera.attributes.add('distanceMin',  { type: 'number', default:  0.1,  title: 'Compat: Distance Min (unused)' });
+
+// ======================== Helpers ===========================
+function vAdd(a,b){ return new pc.Vec3(a.x+b.x,a.y+b.y,a.z+b.z); }
+function vSub(a,b){ return new pc.Vec3(a.x-b.x,a.y-b.y,a.z-b.z); }
+function vScale(v,s){ return new pc.Vec3(v.x*s,v.y*s,v.z*s); }
+function vLen(v){ return Math.sqrt(v.x*v.x+v.y*v.y+v.z*v.z); }
+function vDot(a,b){ return a.x*b.x+a.y*b.y+a.z*b.z; }
+function vNorm(v){ var l=vLen(v)||1; return new pc.Vec3(v.x/l,v.y/l,v.z/l); }
+function clamp(v,a,b){ return Math.max(a, Math.min(b,v)); }
+
+// Capsule util: point bas et point haut (segment) centrés sur p
+function capsuleSegment(p, height, radius) {
+    // Capsule vertical : segment longueur (height - 2*radius), clampée >= 0
+    var seg = Math.max(0, height - 2*radius);
+    var half = seg * 0.5;
+    return {
+        a: new pc.Vec3(p.x, p.y - half, p.z),
+        b: new pc.Vec3(p.x, p.y + half, p.z),
+        len: seg
+    };
+}
+
+// Distance point-segment au cube AABB (renvoie penetration > 0 si intersecte)
+function capsuleVsAabbPenetration(center, height, radius, aabb, outPush) {
+    // approx : on projette les extrémités de la capsule et on prend le pire cas
+    var seg = capsuleSegment(center, height, radius);
+    // Trouver le point du segment le plus proche de l'AABB (on fait binaire en échantillonnant)
+    // Optimisation simple: on teste 3 points: a, b et milieu
+    var pts = [seg.a, seg.b, new pc.Vec3((seg.a.x+seg.b.x)/2,(seg.a.y+seg.b.y)/2,(seg.a.z+seg.b.z)/2)];
+
+    var amin = aabb.getMin();
+    var amax = aabb.getMax();
+    var eps = 1e-9;
+
+    var bestPen = 0;
+    var bestPush = null;
+
+    for (var i=0;i<pts.length;i++){
+        var p = pts[i];
+
+        var cx = clamp(p.x, amin.x, amax.x);
+        var cy = clamp(p.y, amin.y, amax.y);
+        var cz = clamp(p.z, amin.z, amax.z);
+
+        var dx = p.x - cx, dy = p.y - cy, dz = p.z - cz;
+        var d2 = dx*dx + dy*dy + dz*dz;
+        var d = Math.sqrt(Math.max(d2, eps));
+        var pen = radius - d;
+
+        if (pen > bestPen) {
+            if (d > 1e-6) {
+                bestPush = new pc.Vec3(dx/d * pen, dy/d * pen, dz/d * pen);
+            } else {
+                // si coïncident, pousse le long de l'axe le plus proche
+                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) bestPush = new pc.Vec3((Math.abs(p.x - amin.x) < Math.abs(amax.x - p.x) ? -1:1)*pen,0,0);
+                else if (ey <= ex && ey <= ez) bestPush = new pc.Vec3(0,(Math.abs(p.y - amin.y) < Math.abs(amax.y - p.y) ? -1:1)*pen,0);
+                else bestPush = new pc.Vec3(0,0,(Math.abs(p.z - amin.z) < Math.abs(amax.z - p.z) ? -1:1)*pen);
+            }
+            bestPen = pen;
         }
-        this.cameraChild = found || null;
     }
 
-    // État yaw/pitch depuis rotations actuelles
-    var cam = this.cameraChild || this.entity; // fallback
-    var qCam = cam.getRotation();
-    var f = new pc.Vec3(); qCam.transformVector(pc.Vec3.FORWARD, f);
+    if (bestPen > 0 && outPush) outPush.copy(bestPush);
+    return bestPen;
+}
+
+// ======================== Getters pitch/yaw ===========================
+Object.defineProperty(FreeCamera.prototype, 'pitch', {
+    get: function () { return this._targetPitch; },
+    set: function (v) { this._targetPitch = pc.math.clamp(v, this.pitchAngleMin, this.pitchAngleMax); }
+});
+Object.defineProperty(FreeCamera.prototype, 'yaw', {
+    get: function () { return this._targetYaw; },
+    set: function (v) { this._targetYaw = v; }
+});
+
+// ======================== Init ===========================
+FreeCamera.prototype.initialize = function () {
+    // angles init
+    var q = this.entity.getRotation();
+    var f = new pc.Vec3(); q.transformVector(pc.Vec3.FORWARD, f);
 
-    // yaw sur Player, pitch sur Camera
     this._yaw = Math.atan2(f.x, f.z) * pc.math.RAD_TO_DEG;
     var yawQuat = new pc.Quat().setFromEulerAngles(0, -this._yaw, 0);
-    var noYawQ  = new pc.Quat().mul2(yawQuat, qCam);
+    var noYawQ  = new pc.Quat().mul2(yawQuat, q);
     var fNoYaw  = new pc.Vec3(); noYawQ.transformVector(pc.Vec3.FORWARD, fNoYaw);
-    this._pitch = clamp(Math.atan2(-fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG, this.pitchMin, this.pitchMax);
+    this._pitch = pc.math.clamp(Math.atan2(-fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG, this.pitchAngleMin, this.pitchAngleMax);
+
+    this._targetYaw = this._yaw;
+    this._targetPitch = this._pitch;
+    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
+
+    // état partagé
+    this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
+    this.state = this.app.systems.script.app.freeCamState;
+
+    // Construire les colliders depuis focusEntity (GLB environnement)
+    this._buildAabbsFromFocus();
+
+    // Clamp très léger au spawn (sans déplacement “loin”)
+    var p0 = this.entity.getPosition().clone();
+    var p1 = this._resolveCapsuleCollisions(p0, this.maxResolveIters);
+    if (vLen(vSub(p1,p0)) > this.capsuleRadius * 0.25) {
+        // limite la correction pour ne PAS expulser hors bâtiment
+        var dir = vSub(p1,p0); var L = vLen(dir)||1;
+        p1 = vAdd(p0, vScale(dir, (this.capsuleRadius*0.25)/L));
+    }
+    this._clampBBoxMinY(p1);
+    this.entity.setPosition(p1);
 
-    // Inputs accumulés
-    this._wish = new pc.Vec3(0,0,0); // input axes
-    this._wishLook = new pc.Vec2(0,0); // dx, dy
+    // Aspect ratio
+    var self = this;
+    this._onResize = function(){ self._checkAspectRatio(); };
+    window.addEventListener('resize', this._onResize, false);
+    this._checkAspectRatio();
+};
 
-    // Touch state
-    this._touchLookActive = false;
-    this._lastTouchDist = 0;
+FreeCamera.prototype.update = function (dt) {
+    // rotation lissée
+    var t = this.inertiaFactor === 0 ? 1 : Math.min(dt / this.inertiaFactor, 1);
+    this._yaw   = pc.math.lerp(this._yaw,   this._targetYaw,   t);
+    this._pitch = pc.math.lerp(this._pitch, this._targetPitch, t);
+    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
+
+    // maintien propre (au cas où)
+    var pos = this.entity.getPosition().clone();
+    pos = this._resolveCapsuleCollisions(pos, this.maxResolveIters);
+    this._clampBBoxMinY(pos);
+    this.entity.setPosition(pos);
+};
 
-    // Grounded cache
-    this._isGrounded = false;
+FreeCamera.prototype._checkAspectRatio = function () {
+    var gd = this.app.graphicsDevice;
+    if (!gd) return;
+    this.entity.camera.horizontalFov = (gd.height > gd.width);
+};
 
-    // Pointer lock (optionnel) — simple clic gauche
-    var self = this;
-    if (this.app.mouse) {
-        this.app.mouse.on(pc.EVENT_MOUSEDOWN, function(e){
-            if (e.button === pc.MOUSEBUTTON_LEFT && document.activeElement === self.app.graphicsDevice.canvas) {
-                if (self.app.graphicsDevice.canvas.requestPointerLock) {
-                    self.app.graphicsDevice.canvas.requestPointerLock();
-                }
+// ======================== Build colliders ===========================
+FreeCamera.prototype._buildAabbsFromFocus = function () {
+    this._colliders = [];
+    this._worldAabb = null;
+    this._useCollision = false;
+
+    var root = this.focusEntity;
+    if (!root) return;
+
+    // 1) collecter
+    var boxes = [];
+    var stack = [root];
+    while (stack.length) {
+        var e = stack.pop();
+        var rc = e.render;
+        if (rc && rc.meshInstances && rc.meshInstances.length) {
+            for (var i=0;i<rc.meshInstances.length;i++){
+                var bb = rc.meshInstances[i].aabb;
+                boxes.push(new pc.BoundingBox(bb.center.clone(), bb.halfExtents.clone()));
             }
-        }, this);
+        }
+        var ch = e.children;
+        if (ch && ch.length) for (var j=0;j<ch.length;j++) stack.push(ch[j]);
+    }
+    if (boxes.length === 0) return;
+
+    // 2) monde
+    var world = boxes[0].clone();
+    for (var k=1;k<boxes.length;k++) world.add(boxes[k]);
+
+    // 3) filtrer quasi-global
+    var frac = pc.math.clamp(this.globalCullFrac, 0, 0.49);
+    var wh = world.halfExtents;
+    var filtered = [];
+    for (var m=0;m<boxes.length;m++){
+        var h = boxes[m].halfExtents;
+        var nearGlobal = (h.x >= wh.x*(1-frac)) && (h.y >= wh.y*(1-frac)) && (h.z >= wh.z*(1-frac));
+        if (!nearGlobal) filtered.push(boxes[m]);
     }
 
-    // Listeners de base si pas d'inputs dédiés
-    this._attachDefaultListeners();
-
-    // Clamp pitch & appliquer orientation initiale
-    this._applyOrientationImmediate();
-};
+    // 4) merge strict
+    var merged = this._mergeAabbs(filtered, Math.max(0, this.mergeGap||0));
 
-FPC.prototype._attachDefaultListeners = function(){
-    var self = this;
-    if (this.app.mouse){
-        this._onMouseMove = function(e){ if (document.pointerLockElement !== self.app.graphicsDevice.canvas) return; self._wishLook.x += e.dx; self._wishLook.y += e.dy; };
-        this._onWheel = function(e){ self._dollyByWheel(e.wheelDelta); e.event.preventDefault(); };
-        this.app.mouse.on(pc.EVENT_MOUSEMOVE, this._onMouseMove, this);
-        this.app.mouse.on(pc.EVENT_MOUSEWHEEL, this._onWheel, this);
-    }
-    if (this.app.touch){
-        this._onTStart = this._touchStart.bind(this);
-        this._onTMove  = this._touchMove.bind(this);
-        this._onTEnd   = this._touchEnd.bind(this);
-        this.app.touch.on(pc.EVENT_TOUCHSTART, this._onTStart, this);
-        this.app.touch.on(pc.EVENT_TOUCHMOVE,  this._onTMove,  this);
-        this.app.touch.on(pc.EVENT_TOUCHEND,   this._onTEnd,   this);
-        this.app.touch.on(pc.EVENT_TOUCHCANCEL,this._onTEnd,   this);
+    // 5) petit gonflage
+    var inflate = Math.max(0, this.inflateBias||0);
+    for (var n=0;n<merged.length;n++){
+        merged[n].halfExtents.add(new pc.Vec3(inflate, inflate, inflate));
     }
 
-    if (this.app.keyboard){
-        this._kb = this.app.keyboard;
+    // 6) enregistrer
+    if (merged.length>0) {
+        for (var t=0;t<merged.length;t++) this._colliders.push({ aabb: merged[t] });
+        this._worldAabb = world;
+        this._useCollision = true;
     }
+
+  console.log('[FREE-CAM] colliders:', boxes.length);
 };
 
-FPC.prototype._detachDefaultListeners = function(){
-    if (this.app.mouse && this._onMouseMove){
-        this.app.mouse.off(pc.EVENT_MOUSEMOVE, this._onMouseMove, this);
-        this.app.mouse.off(pc.EVENT_MOUSEWHEEL, this._onWheel, this);
+FreeCamera.prototype._mergeAabbs = function (boxes, gap) {
+    if (!boxes || boxes.length<=1) return boxes.slice();
+    var out = boxes.slice();
+    var tol = Math.max(0, gap||0);
+    var changed = true;
+
+    function overlap(a,b,t){
+        var amin=a.getMin(), amax=a.getMax();
+        var bmin=b.getMin(), bmax=b.getMax();
+        return !(
+            amax.x < bmin.x - t || amin.x > bmax.x + t ||
+            amax.y < bmin.y - t || amin.y > bmax.y + t ||
+            amax.z < bmin.z - t || amin.z > bmax.z + t
+        );
     }
-    if (this.app.touch && this._onTStart){
-        this.app.touch.off(pc.EVENT_TOUCHSTART, this._onTStart, this);
-        this.app.touch.off(pc.EVENT_TOUCHMOVE,  this._onTMove,  this);
-        this.app.touch.off(pc.EVENT_TOUCHEND,   this._onTEnd,   this);
-        this.app.touch.off(pc.EVENT_TOUCHCANCEL,this._onTEnd,   this);
+
+    while (changed){
+        changed=false;
+        var next=[], used=new Array(out.length).fill(false);
+        for (var i=0;i<out.length;i++){
+            if (used[i]) continue;
+            var acc = out[i];
+            for (var j=i+1;j<out.length;j++){
+                if (used[j]) continue;
+                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=new pc.Vec3(Math.abs(nMax.x-c.x), Math.abs(nMax.y-c.y), Math.abs(nMax.z-c.z));
+                    acc = new pc.BoundingBox(c,h);
+                    used[j]=true; changed=true;
+                }
+            }
+            used[i]=true; next.push(acc);
+        }
+        out=next;
     }
+    return out;
 };
 
-FPC.prototype._applyOrientationImmediate = function(){
-    // Player: yaw
-    this.entity.setLocalEulerAngles(0, this._yaw, 0);
-    // Camera (pitch)
-    var cam = this.cameraChild || this.entity;
-    cam.setLocalEulerAngles(this._pitch, 0, 0);
+// ======================== BBox globale + minY ===========================
+FreeCamera.prototype._bboxEnabled = function () {
+    return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
 };
+FreeCamera.prototype._clampBBoxMinY = function (p) {
+    if (p.y < this.minY) p.y = this.minY;
+    if (!this._bboxEnabled()) return;
+    p.x = clamp(p.x, this.Xmin, this.Xmax);
+    p.y = clamp(p.y, Math.max(this.Ymin, this.minY), this.Ymax);
+    p.z = clamp(p.z, this.Zmin, this.Zmax);
+};
+
+// ======================== Capsule vs AABBs : resolve ===========================
+FreeCamera.prototype._resolveCapsuleCollisions = function (pos, maxIters) {
+    if (!this._useCollision) return pos.clone();
 
-// ----------------------- Update -----------------------
-FPC.prototype.update = function(dt){
-    // 1) Lire inputs clavier et former le vecteur d'intention
-    var kb = this._kb;
-    var fwdAxis = 0, strAxis = 0, upAxis = 0, dash = 0;
-    if (kb) {
-        // Avant/arrière — support ZQSD/WSAD/Flèches
-        fwdAxis = ((kb.isPressed(pc.KEY_UP) || kb.isPressed(pc.KEY_W) || kb.isPressed(pc.KEY_Z)) ? 1 : 0)
-                + ((kb.isPressed(pc.KEY_DOWN) || kb.isPressed(pc.KEY_S)) ? -1 : 0);
-        // Strafe
-        strAxis = ((kb.isPressed(pc.KEY_RIGHT) || kb.isPressed(pc.KEY_D)) ? 1 : 0)
-                + ((kb.isPressed(pc.KEY_LEFT)  || kb.isPressed(pc.KEY_AZERTY ? pc.KEY_Q : pc.KEY_A)) ? -1 : 0);
-        // Monter/descendre
-        upAxis  = ((kb.isPressed(pc.KEY_E) || kb.isPressed(pc.KEY_SPACE)) ? 1 : 0)
-                + ((kb.isPressed(pc.KEY_C) || kb.isPressed(pc.KEY_X) || kb.isPressed(pc.KEY_CTRL)) ? -1 : 0);
-        dash   = kb.isPressed(pc.KEY_SHIFT) ? 1 : 0;
-
-        // Jump (impulsion unique) si grounded & mode grounded
-        if (!this.freeFly && (kb.wasPressed(pc.KEY_SPACE) || kb.wasPressed(pc.KEY_E))) {
-            if (this._isGrounded && this.entity.rigidbody) {
-                var vel = this.entity.rigidbody.linearVelocity.clone();
-                vel.y = 0; // reset ascendante
-                this.entity.rigidbody.linearVelocity = vel;
-                this.entity.rigidbody.applyImpulse(0, this.jumpImpulse, 0);
+    var p = pos.clone();
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight); // clamp min
+    var eps = Math.max(1e-7, this.collisionEps);
+
+    if (!this._colliders || this._colliders.length===0) return p;
+
+    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;
+            var push = new pc.Vec3();
+            var pen = capsuleVsAabbPenetration(p, H, R, aabb, push);
+            if (pen > eps) {
+                p.add(push);
+                moved = true;
             }
         }
+        if (!moved) break;
     }
+    return p;
+};
 
-    // 2) Yaw/pitch depuis souris/touch accumulé
-    if (this._wishLook.x !== 0 || this._wishLook.y !== 0){
-        var sens = this.lookSensitivity;
-        var dx = this._wishLook.x * sens;
-        var dy = this._wishLook.y * (this.invertY ? 1 : -1) * sens;
-        this._wishLook.set(0,0);
-
-        this._yaw += dx;
-        this._pitch = clamp(this._pitch + dy, this.pitchMin, this.pitchMax);
-        this.entity.setLocalEulerAngles(0, this._yaw, 0);
-        (this.cameraChild || this.entity).setLocalEulerAngles(this._pitch, 0, 0);
-    }
+// ======================== Mvt principal : swept + step + snap ===========================
+FreeCamera.prototype._moveSwept = function (from, delta) {
+    if (!this._useCollision) return vAdd(from, delta);
 
-    // 3) Mouvement (physique): calcule la vélocité cible
-    var body = this.entity.rigidbody;
-    if (!body) return;
+    var maxStep = Math.max(0.01, this.maxStepDistance||0.2);
+    var dist = vLen(delta);
+    if (dist <= maxStep) return this._moveStep(from, delta);
 
-    // Base directions (horizontales) dans l'espace Player
-    var forward = this.entity.forward.clone(); forward.y = 0; if (forward.lengthSq()>1e-8) forward.normalize();
-    var right   = this.entity.right.clone();   right.y = 0;   if (right.lengthSq()>1e-8)   right.normalize();
+    var steps = Math.ceil(dist / maxStep);
+    var step = vScale(delta, 1/steps);
+    var cur = from.clone();
+    for (var i=0;i<steps;i++) cur = this._moveStep(cur, step);
+    return cur;
+};
 
-    var speedMul = 1 + dash * (this.dashMultiplier - 1);
-    var wish = new pc.Vec3(0,0,0);
-    wish.add(forward.mulScalar(fwdAxis  * this.moveSpeed   * speedMul));
-    wish.add(right  .mulScalar(strAxis  * this.strafeSpeed * speedMul));
+FreeCamera.prototype._moveStep = function (from, delta) {
+    // A) tentative directe
+    var target = vAdd(from, delta);
+    var after  = this._resolveCapsuleCollisions(target, this.maxResolveIters);
+    var collided = (vLen(vSub(after, target)) > 0);
 
-    // Free-fly: composante verticale contrôlée
-    var curVel = body.linearVelocity.clone();
-    if (this.freeFly) {
-        wish.y = upAxis * this.verticalSpeed * speedMul;
-    } else {
-        // Grounded: conserve Y (gravité). On autorise une légère descente via C si tu veux, mais en général 0.
-        wish.y = curVel.y;
+    if (!collided) {
+        if (this.enableGroundSnap) after = this._snapDown(after);
+        return after;
     }
 
-    // 4) Ground check (pour info + jump)
-    this._isGrounded = this._checkGrounded();
-
-    // 5) Lerp la vélocité pour un feeling doux
-    var lerpT = 1 - Math.exp(-dt / Math.max(0.001, this.smoothing));
-    var target = wish;
+    // B) slide (supprimer la composante contre la "normale" approx)
+    var n = this._estimateNormal(after);
+    if (n) {
+        var desire = delta.clone();
+        // projeter le déplacement sur le plan perpendiculaire à n
+        var slide = vSub(desire, vScale(n, vDot(desire, n)));
+        var slideTarget = vAdd(from, slide);
+        var slideAfter  = this._resolveCapsuleCollisions(slideTarget, this.maxResolveIters);
+
+        // C) step-up si slide insuffisant
+        if (vLen(vSub(slideAfter, slideTarget)) > 0) {
+            var stepped = this._tryStepUp(from, desire);
+            if (stepped) {
+                if (this.enableGroundSnap) stepped = this._snapDown(stepped);
+                return stepped;
+            }
+        }
 
-    // Clamp vitesse max (sécurité)
-    var maxV = Math.max(0.1, this.maxVelocity);
-    if (this.freeFly) {
-        if (target.length() > maxV) target.normalize().mulScalar(maxV);
-    } else {
-        // clamp horizontal uniquement
-        var hv = new pc.Vec3(target.x, 0, target.z);
-        if (hv.length() > maxV) hv.normalize().mulScalar(maxV);
-        target = new pc.Vec3(hv.x, target.y, hv.z);
+        if (this.enableGroundSnap) slideAfter = this._snapDown(slideAfter);
+        return slideAfter;
     }
 
-    var out = new pc.Vec3(
-        pc.math.lerp(curVel.x, target.x, lerpT),
-        pc.math.lerp(curVel.y, target.y, lerpT),
-        pc.math.lerp(curVel.z, target.z, lerpT)
-    );
-
-    body.linearVelocity = out;
+    if (this.enableGroundSnap) after = this._snapDown(after);
+    return after;
 };
 
-// ----------------------- Ground detection -----------------------
-FPC.prototype._checkGrounded = function(){
-    if (this.freeFly || !this.entity || !this.entity.rigidbody) return false;
+// Normale approx via micro-probes
+FreeCamera.prototype._estimateNormal = function (p) {
+    if (!this._colliders) return null;
+    var probe = 0.02;
+    var base = this._resolveCapsuleCollisions(p, this.maxResolveIters);
+    var nx = this._resolveCapsuleCollisions(new pc.Vec3(p.x+probe,p.y,p.z), this.maxResolveIters);
+    var px = this._resolveCapsuleCollisions(new pc.Vec3(p.x-probe,p.y,p.z), this.maxResolveIters);
+    var ny = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y+probe,p.z), this.maxResolveIters);
+    var py = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y-probe,p.z), this.maxResolveIters);
+    var nz = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y,p.z+probe), this.maxResolveIters);
+    var pz = this._resolveCapsuleCollisions(new pc.Vec3(p.x,p.y,p.z-probe), this.maxResolveIters);
+
+    function d(a,b){ return vLen(vSub(a,b)); }
+    var dx = d(nx,base) - d(px,base);
+    var dy = d(ny,base) - d(py,base);
+    var dz = d(nz,base) - d(pz,base);
+    var n  = new pc.Vec3(dx,dy,dz);
+    var L = vLen(n);
+    if (L < 1e-5) return null;
+    return vScale(n, 1/L);
+};
 
-    // Capsule dims: essaye de récupérer depuis Collision component
-    var col = this.entity.collision;
-    var radius = 0.3, height = 1.6;
-    if (col && col.type === 'capsule') { radius = col.radius; height = col.height; }
+// Step-up : monter une marche (jusqu'à stepHeight)
+FreeCamera.prototype._tryStepUp = function (from, wishDelta) {
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight);
+    var eps = Math.max(1e-4, this.collisionEps);
+    var maxH = Math.max(0, this.stepHeight || 0.35);
+    var ahead = Math.max(0.05, this.stepAhead || 0.20);
+
+    var horiz = new pc.Vec3(wishDelta.x, 0, wishDelta.z);
+    var hLen = vLen(horiz);
+    if (hLen < 1e-6) return null;
+    horiz = vScale(horiz, 1/hLen);
+
+    // on avance un peu, on monte, puis on applique le delta complet
+    var probe = vAdd(from, vScale(horiz, Math.min(hLen, ahead)));
+    // tester plusieurs hauteurs jusqu'à maxH
+    var trials = 3;
+    for (var i=1;i<=trials;i++){
+        var up = maxH * (i/trials);
+        var raised = new pc.Vec3(probe.x, probe.y + up, probe.z);
+        raised = this._resolveCapsuleCollisions(raised, this.maxResolveIters);
+        var stepped = this._resolveCapsuleCollisions(vAdd(raised, wishDelta), this.maxResolveIters);
+
+        // validé si on a gagné horizontalement
+        if (vLen(vSub(stepped, raised)) > 0.02) return stepped;
+    }
+    return null;
+};
 
-    var origin = this.entity.getPosition().clone();
-    var start = origin.clone();
-    var extra = Math.max(0.01, this.groundCheckOffset);
-    var end   = origin.clone();
+// Snap-down : redéposer sur le sol si on flotte un peu (descente d'escalier)
+FreeCamera.prototype._snapDown = function (p) {
+    var R = Math.max(0, this.capsuleRadius);
+    var H = Math.max(2*R, this.capsuleHeight);
+    var maxDown = Math.max(0, this.snapDownMax || 0.6);
+
+    // On descend par petits incréments pour “chercher” le sol
+    var steps = 4;
+    var step = maxDown / steps;
+    var cur = p.clone();
+    for (var i=0;i<steps;i++){
+        var down = new pc.Vec3(cur.x, cur.y - step, cur.z);
+        var resolved = this._resolveCapsuleCollisions(down, this.maxResolveIters);
+        if (vLen(vSub(resolved, down)) > 0) {
+            // on a tapé quelque chose : remonter légèrement et arrêter
+            return this._resolveCapsuleCollisions(new pc.Vec3(resolved.x, resolved.y + 0.01, resolved.z), this.maxResolveIters);
+        }
+        cur.copy(down);
+    }
+    return p;
+};
 
-    // Rayon part un peu au dessous du bas de la capsule vers le bas
-    var bottom = origin.y - Math.max(radius, (height*0.5 - radius));
-    start.y = bottom + 0.05;
-    end.y   = bottom - (0.25 + extra);
+// ===================== INPUT SOURIS =====================
+var FreeCameraInputMouse = pc.createScript('orbitCameraInputMouse');
+FreeCameraInputMouse.attributes.add('lookSensitivity', { type: 'number', default: 0.3, title: 'Look Sensitivity' });
+FreeCameraInputMouse.attributes.add('wheelSensitivity',{ type: 'number', default: 1.0, title: 'Wheel Sensitivity' });
 
-    var result = this.app.systems.rigidbody.raycastFirst(start, end);
+FreeCameraInputMouse.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.last = new pc.Vec2();
+    this.isLooking = false;
 
-    if (this.debugRays) {
-        console.log('[FPC] ray:', start, '->', end, 'hit=', !!result);
+    if (this.app.mouse) {
+        this.app.mouse.on(pc.EVENT_MOUSEDOWN,  this.onMouseDown,  this);
+        this.app.mouse.on(pc.EVENT_MOUSEUP,    this.onMouseUp,    this);
+        this.app.mouse.on(pc.EVENT_MOUSEMOVE,  this.onMouseMove,  this);
+        this.app.mouse.on(pc.EVENT_MOUSEWHEEL, this.onMouseWheel, this);
+        this.app.mouse.disableContextMenu();
     }
+    var self = this;
+    this._onOut = function(){ self.isLooking = false; };
+    window.addEventListener('mouseout', this._onOut, false);
+
+    this.on('destroy', () => {
+        if (this.app.mouse) {
+            this.app.mouse.off(pc.EVENT_MOUSEDOWN,  this.onMouseDown,  this);
+            this.app.mouse.off(pc.EVENT_MOUSEUP,    this.onMouseUp,    this);
+            this.app.mouse.off(pc.EVENT_MOUSEMOVE,  this.onMouseMove,  this);
+            this.app.mouse.off(pc.EVENT_MOUSEWHEEL, this.onMouseWheel, this);
+        }
+        window.removeEventListener('mouseout', this._onOut, false);
+    });
+};
 
-    if (!result) return false;
+FreeCameraInputMouse.prototype.onMouseDown = function (e) {
+    this.isLooking = true;
+    this.last.set(e.x, e.y);
+};
+
+FreeCameraInputMouse.prototype.onMouseUp = function () {
+    this.isLooking = false;
+};
 
-    // Vérifier pente (angle avec la normale)
-    var n = result.normal || new pc.Vec3(0,1,0);
-    var slope = Math.acos(clamp(n.y, -1, 1)) * pc.math.RAD_TO_DEG; // approx: normal.y = cos(angle)
-    return slope <= this.groundMaxSlopeDeg;
+FreeCameraInputMouse.prototype.onMouseMove = function (e) {
+    if (!this.isLooking || !this.freeCam) return;
+    var sens = this.lookSensitivity;
+    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);
 };
 
-// ----------------------- Dolly (wheel/pinch) -----------------------
-FPC.prototype._dollyByWheel = function(delta){
-    var body = this.entity.rigidbody; if (!body) return;
-    var fwd = this.entity.forward.clone();
-    if (fwd.lengthSq()>1e-8) fwd.normalize();
-    var amt = -delta * this.wheelFactor * 0.02; // scale doux
-
-    var cur = body.linearVelocity.clone();
-    var add = fwd.mulScalar(amt);
-    cur.add(add);
-    body.linearVelocity = cur;
+FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
+    if (!this.freeCam) return;
+    var cam = this.entity;
+    var move = -e.wheelDelta * this.wheelSensitivity * this.freeCam.dollySpeed * 0.05;
+    var fwd = cam.forward.clone(); if (fwd.lengthSq()>1e-8) fwd.normalize();
+
+    var from = cam.getPosition().clone();
+    var to   = from.clone().add(fwd.mulScalar(move));
+    var next = this.freeCam._moveSwept(from, to.sub(from));
+    this.freeCam._clampBBoxMinY(next);
+    cam.setPosition(next);
+
+    e.event.preventDefault();
 };
 
-FPC.prototype._dollyByPinchDelta = function(d){
-    var body = this.entity.rigidbody; if (!body) return;
-    var fwd = this.entity.forward.clone();
-    if (fwd.lengthSq()>1e-8) fwd.normalize();
-    var amt = d * this.pinchFactor * this.moveSpeed;
+// ===================== INPUT TOUCH =====================
+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' });
+
+FreeCameraInputTouch.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.last = new pc.Vec2();
+    this.isLooking = false;
+    this.lastPinch = 0;
+
+    if (this.app.touch) {
+        this.app.touch.on(pc.EVENT_TOUCHSTART,  this.onTouchStartEndCancel, this);
+        this.app.touch.on(pc.EVENT_TOUCHEND,    this.onTouchStartEndCancel, this);
+        this.app.touch.on(pc.EVENT_TOUCHCANCEL, this.onTouchStartEndCancel, this);
+        this.app.touch.on(pc.EVENT_TOUCHMOVE,   this.onTouchMove, this);
+    }
 
-    var cur = body.linearVelocity.clone();
-    var add = fwd.mulScalar(amt);
-    body.linearVelocity = cur.add(add);
+    this.on('destroy', () => {
+        if (this.app.touch) {
+            this.app.touch.off(pc.EVENT_TOUCHSTART,  this.onTouchStartEndCancel, this);
+            this.app.touch.off(pc.EVENT_TOUCHEND,    this.onTouchStartEndCancel, this);
+            this.app.touch.off(pc.EVENT_TOUCHCANCEL, this.onTouchStartEndCancel, this);
+            this.app.touch.off(pc.EVENT_TOUCHMOVE,   this.onTouchMove, this);
+        }
+    });
 };
 
-// ----------------------- Touch handlers -----------------------
-FPC.prototype._touchStart = function(e){
+FreeCameraInputTouch.prototype.onTouchStartEndCancel = function (e) {
     var t = e.touches;
     if (t.length === 1) {
-        this._touchLookActive = true;
-        this._lastTouch = new pc.Vec2(t[0].x, t[0].y);
+        this.isLooking = (e.event.type === 'touchstart');
+        this.last.set(t[0].x, t[0].y);
     } else if (t.length === 2) {
         var dx = t[0].x - t[1].x, dy = t[0].y - t[1].y;
-        this._lastTouchDist = Math.sqrt(dx*dx + dy*dy);
-        this._touchLookActive = false;
+        this.lastPinch = Math.sqrt(dx*dx + dy*dy);
     } else {
-        this._touchLookActive = false;
+        this.isLooking = false;
     }
 };
 
-FPC.prototype._touchMove = function(e){
+FreeCameraInputTouch.prototype.onTouchMove = function (e) {
     var t = e.touches;
-    if (t.length === 1 && this._touchLookActive) {
-        var dx = t[0].x - this._lastTouch.x;
-        var dy = t[0].y - this._lastTouch.y;
-        this._wishLook.x += dx;
-        this._wishLook.y += dy;
-        this._lastTouch.set(t[0].x, t[0].y);
+    if (!this.freeCam) return;
+
+    if (t.length === 1 && this.isLooking) {
+        var s = this.lookSensitivity;
+        var dx = t[0].x - this.last.x, dy = t[0].y - this.last.y;
+        this.freeCam.yaw   = this.freeCam.yaw   - dx * s;
+        this.freeCam.pitch = this.freeCam.pitch - dy * s;
+        this.last.set(t[0].x, t[0].y);
     } else if (t.length === 2) {
         var dx = t[0].x - t[1].x, dy = t[0].y - t[1].y;
         var dist = Math.sqrt(dx*dx + dy*dy);
-        var delta = dist - this._lastTouchDist; this._lastTouchDist = dist;
-        this._dollyByPinchDelta(delta);
+        var delta = dist - this.lastPinch; this.lastPinch = dist;
+
+        var cam = this.entity;
+        var fwd = cam.forward.clone(); if (fwd.lengthSq()>1e-8) fwd.normalize();
+        var from = cam.getPosition().clone();
+        var to   = from.clone().add(fwd.mulScalar(delta * this.pinchDollyFactor * this.freeCam.dollySpeed));
+        var next = this.freeCam._moveSwept(from, to.sub(from));
+        this.freeCam._clampBBoxMinY(next);
+        cam.setPosition(next);
     }
 };
 
-FPC.prototype._touchEnd = function(){
-    this._touchLookActive = false;
-};
+// ===================== INPUT CLAVIER =====================
+var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
+FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused, future)' });
 
-FPC.prototype.onDestroy = function(){
-    this._detachDefaultListeners();
+FreeCameraInputKeyboard.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.kb = this.app.keyboard || null;
 };
 
-// ----------------------- Inputs dédiés (optionnels) -----------------------
-// Si tu préfères séparer, tu peux ajouter ces scripts sur Player. Ils pilotent fpController.
+FreeCameraInputKeyboard.prototype.update = function (dt) {
+    if (!this.freeCam || !this.kb) return;
 
-var FPMouse = pc.createScript('fpInputMouse');
-FPMouse.attributes.add('sensitivity', { type: 'number', default: 0.27 });
-FPMouse.prototype.initialize = function(){
-    this.ctrl = this.entity.script && this.entity.script.fpController;
-    if (!this.ctrl || !this.app.mouse) return;
-    this.app.mouse.disableContextMenu();
-    var self = this;
-    this._onMove = function(e){ if (document.pointerLockElement !== self.app.graphicsDevice.canvas) return; self.ctrl._wishLook.x += e.dx * (self.sensitivity / self.ctrl.lookSensitivity); self.ctrl._wishLook.y += e.dy * (self.sensitivity / self.ctrl.lookSensitivity); };
-    this._onWheel = function(e){ self.ctrl._dollyByWheel(e.wheelDelta); e.event.preventDefault(); };
-    this.app.mouse.on(pc.EVENT_MOUSEMOVE, this._onMove, this);
-    this.app.mouse.on(pc.EVENT_MOUSEWHEEL, this._onWheel, this);
-    this.on('destroy', ()=>{
-        this.app.mouse.off(pc.EVENT_MOUSEMOVE, this._onMove, this);
-        this.app.mouse.off(pc.EVENT_MOUSEWHEEL, this._onWheel, this);
-    });
-};
+    var fwd  = (this.kb.isPressed(pc.KEY_UP)    || this.kb.isPressed(pc.KEY_Z)) ?  1 :
+               (this.kb.isPressed(pc.KEY_DOWN)  || this.kb.isPressed(pc.KEY_S)) ? -1 : 0;
 
-var FPTouch = pc.createScript('fpInputTouch');
-FPTouch.attributes.add('lookSensitivity', { type: 'number', default: 0.5 });
-FPTouch.attributes.add('pinchFactor', { type: 'number', default: 0.02 });
-FPTouch.prototype.initialize = function(){
-    this.ctrl = this.entity.script && this.entity.script.fpController;
-    if (!this.ctrl || !this.app.touch) return;
-    this._onTStart = (e)=>{ this.ctrl._touchStart(e); };
-    this._onTMove  = (e)=>{ this.ctrl._touchMove(e); };
-    this._onTEnd   = (e)=>{ this.ctrl._touchEnd(e); };
-    this.app.touch.on(pc.EVENT_TOUCHSTART, this._onTStart, this);
-    this.app.touch.on(pc.EVENT_TOUCHMOVE,  this._onTMove,  this);
-    this.app.touch.on(pc.EVENT_TOUCHEND,   this._onTEnd,   this);
-    this.app.touch.on(pc.EVENT_TOUCHCANCEL,this._onTEnd,   this);
-    this.on('destroy', ()=>{
-        this.app.touch.off(pc.EVENT_TOUCHSTART, this._onTStart, this);
-        this.app.touch.off(pc.EVENT_TOUCHMOVE,  this._onTMove,  this);
-        this.app.touch.off(pc.EVENT_TOUCHEND,   this._onTEnd,   this);
-        this.app.touch.off(pc.EVENT_TOUCHCANCEL,this._onTEnd,   this);
-    });
-};
+    var strf = (this.kb.isPressed(pc.KEY_RIGHT) || this.kb.isPressed(pc.KEY_D)) ?  1 :
+               (this.kb.isPressed(pc.KEY_LEFT)  || this.kb.isPressed(pc.KEY_Q)) ? -1 : 0;
 
-var FPKeyboard = pc.createScript('fpInputKeyboard');
-FPKeyboard.prototype.initialize = function(){
-    this.ctrl = this.entity.script && this.entity.script.fpController;
-    this.kb = this.app.keyboard || null;
-};
-FPKeyboard.prototype.update = function(){ /* lues directement par fpController */ };
+    if (fwd !== 0 || strf !== 0) {
+        var cam = this.entity;
+        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();
 
-// ----------------------- API publique -----------------------
-FPC.prototype.setFreeFly = function(enabled){
-    this.freeFly = !!enabled;
-    if (this.freeFly) {
-        // Conseil: mets aussi app.scene.gravity = (0,0,0) côté viewer si besoin
+        var delta = new pc.Vec3()
+            .add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt))
+            .add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
+
+        var next = this.freeCam._moveSwept(from, delta);
+        this.freeCam._clampBBoxMinY(next);
+        cam.setPosition(next);
     }
-};
 
-FPC.prototype.getFreeFly = function(){ return !!this.freeFly; };
+    // Rotation 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);
+        var pitchDir = (this.kb.isPressed(pc.KEY_UP)   ? 1 : 0) - (this.kb.isPressed(pc.KEY_DOWN)  ? 1 : 0);
+        var yawSpeed = 120, pitchSpeed = 90;
+        if (yawDir   !== 0) this.freeCam.yaw   = this.freeCam.yaw   + yawDir   * yawSpeed   * dt;
+        if (pitchDir !== 0) this.freeCam.pitch = this.freeCam.pitch + pitchDir * pitchSpeed * dt;
+    }
+};