Update deplacement_dans_env/ctrl_camera_pr_env.js

deplacement_dans_env/ctrl_camera_pr_env.js

@@ -1,714 +1,313 @@
 // ctrl_camera_pr_env.js
 // ============================================================================
-// ORBIT CAMERA + INPUTS (PlayCanvas) — bbox + rotation libre & sens corrigés
-// - Zoom : uniquement un minimum (pas de maxZoom)
-// - Bounding Box : clamp SEULEMENT la position caméra, jamais l'orientation
-// - Yaw : pas de clamp -> rotations illimitées (±2000° etc.)
-// - Pitch : clamp via min/max (configurable), minY préservé
+// FREE CAMERA (sans orbite) pour PlayCanvas
+// - Souris : rotation sur place (comme Shift+flèches auparavant)
+// - 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)
 // ============================================================================
 
-var OrbitCamera = pc.createScript('orbitCamera');
+var FreeCamera = pc.createScript('orbitCamera'); // garder le nom public "orbitCamera" pour compat viewer
 
-// ======================== Attributs Caméra ===========================
-OrbitCamera.attributes.add('distanceMin',   { type: 'number', default: 1,   title: 'Distance Min' });
+// ======================== Attributs ===========================
+FreeCamera.attributes.add('inertiaFactor', { type: 'number', default: 0.12, title: 'Inertia (rotation)' });
 
-OrbitCamera.attributes.add('pitchAngleMax', { type: 'number', default: 90,  title: 'Pitch Angle Max (degrees)' });
-OrbitCamera.attributes.add('pitchAngleMin', { type: 'number', default: 0,   title: 'Pitch Angle Min (degrees)' });
+// Limites de pitch (conseil: -89..89 si vue libre)
+FreeCamera.attributes.add('pitchAngleMin', { type: 'number', default: -89, title: 'Pitch Min (deg)' });
+FreeCamera.attributes.add('pitchAngleMax', { type: 'number', default:  89, title: 'Pitch Max (deg)' });
 
-// NB: gardés pour compat, mais non utilisés pour brider le yaw (rotation libre)
-OrbitCamera.attributes.add('yawAngleMax',   { type: 'number', default: 360,  title: 'Yaw Angle Max (unused clamp)' });
-OrbitCamera.attributes.add('yawAngleMin',   { type: 'number', default: -360, title: 'Yaw Angle Min (unused clamp)' });
+// minY (altitude min du point CAMÉRA)
+FreeCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum camera Y' });
 
-OrbitCamera.attributes.add('minY',          { type: 'number', default: 0,   title: 'Minimum Y (camera world Y)' });
+// Vitesse de déplacement (m/s)
+FreeCamera.attributes.add('moveSpeed',   { type: 'number', default: 2.0, title: 'Move Speed' });
+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' });
 
-OrbitCamera.attributes.add('inertiaFactor', { type: 'number', default: 0.2, title: 'Inertia Factor' });
-OrbitCamera.attributes.add('focusEntity',   { type: 'entity',               title: 'Focus Entity' });
-OrbitCamera.attributes.add('frameOnStart',  { type: 'boolean', default: true, title: 'Frame on Start' });
+// Bounding Box (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' });
+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' });
 
-// ---- Bounding Box (active si Xmin < Xmax, etc.) ----
-OrbitCamera.attributes.add('Xmin', { type: 'number', default: -Infinity, title: 'BBox Xmin' });
-OrbitCamera.attributes.add('Xmax', { type: 'number', default:  Infinity, title: 'BBox Xmax' });
-OrbitCamera.attributes.add('Ymin', { type: 'number', default: -Infinity, title: 'BBox Ymin' });
-OrbitCamera.attributes.add('Ymax', { type: 'number', default:  Infinity, title: 'BBox Ymax' });
-OrbitCamera.attributes.add('Zmin', { type: 'number', default: -Infinity, title: 'BBox Zmin' });
-OrbitCamera.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)' });
+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)' });
 
-// ======================== Propriétés ===========================
-Object.defineProperty(OrbitCamera.prototype, 'distance', {
-    get: function () { return this._targetDistance; },
-    set: function (value) { this._targetDistance = this._clampDistance(value); }
-});
-
-Object.defineProperty(OrbitCamera.prototype, 'orthoHeight', {
-    get: function () { return this.entity.camera.orthoHeight; },
-    set: function (value) { this.entity.camera.orthoHeight = Math.max(0, value); }
-});
-
-Object.defineProperty(OrbitCamera.prototype, 'pitch', {
+// ======================== Initialisation ===========================
+Object.defineProperty(FreeCamera.prototype, 'pitch', {
     get: function () { return this._targetPitch; },
-    set: function (value) { this._targetPitch = this._clampPitchAngle(value); }
+    set: function (v) { this._targetPitch = pc.math.clamp(v, this.pitchAngleMin, this.pitchAngleMax); }
 });
-
-Object.defineProperty(OrbitCamera.prototype, 'yaw', {
+Object.defineProperty(FreeCamera.prototype, 'yaw', {
     get: function () { return this._targetYaw; },
-    set: function (value) { 
-        // Yaw LIBRE : pas de clamp pour permettre ±2000°, etc.
-        this._targetYaw = value; 
-    }
-});
-
-Object.defineProperty(OrbitCamera.prototype, 'pivotPoint', {
-    get: function () { return this._pivotPoint; },
-    set: function (value) { this._pivotPoint.copy(value); }
+    set: function (v) { this._targetYaw = v; } // yaw libre (pas de clamp)
 });
 
-// ======================== API Publique ===========================
-OrbitCamera.prototype.focus = function (focusEntity) {
-    this._buildAabb(focusEntity);
-    var halfExtents = this._modelsAabb.halfExtents;
-    var radius = Math.max(halfExtents.x, Math.max(halfExtents.y, halfExtents.z));
-    // Distance initiale (pas de maxZoom)
-    this.distance = (radius * 1.5) / Math.sin(0.5 * this.entity.camera.fov * pc.math.DEG_TO_RAD);
-    this._removeInertia();
-    this._pivotPoint.copy(this._modelsAabb.center);
-};
-
-OrbitCamera.distanceBetween = new pc.Vec3();
-
-OrbitCamera.prototype.resetAndLookAtPoint = function (resetPoint, lookAtPoint) {
-    this.pivotPoint.copy(lookAtPoint);
-
-    this.entity.setPosition(resetPoint);
-    this.entity.lookAt(lookAtPoint);
-
-    var distance = OrbitCamera.distanceBetween;
-    distance.sub2(lookAtPoint, resetPoint);
-    this.distance = distance.length();
-
-    var cameraQuat = this.entity.getRotation();
-    this.yaw   = this._calcYaw(cameraQuat);
-    this.pitch = this._calcPitch(cameraQuat, this.yaw);
-
-    this._removeInertia();
-    this._updatePosition();
-};
-
-OrbitCamera.prototype.resetAndLookAtEntity = function (resetPoint, entity) {
-    this._buildAabb(entity);
-    this.resetAndLookAtPoint(resetPoint, this._modelsAabb.center);
-};
-
-OrbitCamera.prototype.reset = function (yaw, pitch, distance) {
-    this.pitch = pitch;
-    this.yaw = yaw;
-    this.distance = distance;
-    this._removeInertia();
-};
-
-OrbitCamera.prototype.resetToPosition = function (position, lookAtPoint) {
-    this.entity.setPosition(position);
-    this.entity.lookAt(lookAtPoint);
-    this._pivotPoint.copy(lookAtPoint);
+FreeCamera.prototype.initialize = function () {
+    // angles init depuis l'orientation actuelle
+    var q = this.entity.getRotation();
+    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();
+    noYawQ.transformVector(pc.Vec3.FORWARD, fNoYaw);
+    this._pitch = Math.atan2(-fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
+    this._pitch = pc.math.clamp(this._pitch, this.pitchAngleMin, this.pitchAngleMax);
+
+    this._targetYaw   = this._yaw;
+    this._targetPitch = this._pitch;
 
-    var distanceVec = new pc.Vec3();
-    distanceVec.sub2(position, lookAtPoint);
-    this._targetDistance = this._distance = Math.max(this.distanceMin, distanceVec.length());
+    // Appliquer orientation immédiatement
+    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
-    var cameraQuat = this.entity.getRotation();
-    this._targetYaw = this._yaw   = this._calcYaw(cameraQuat);
-    this._targetPitch = this._pitch = this._calcPitch(cameraQuat, this._yaw);
+    // Etat input (partagé par scripts d’input)
+    this.app.systems.script.app.freeCamState = this.app.systems.script.app.freeCamState || {};
+    this.state = this.app.systems.script.app.freeCamState; // pointeur commun
 
-    this._removeInertia();
-    this._updatePosition();
-};
+    // S’assure que la position courante respecte minY + bbox
+    var p = this.entity.getPosition().clone();
+    this._clampPosition(p);
+    this.entity.setPosition(p);
 
-// ==== Helper: cam Y si le pivot = 'pivot' (sert pour minY) ====
-OrbitCamera.prototype.worldCameraYForPivot = function(pivot) {
-    var quat = new pc.Quat();
-    quat.setFromEulerAngles(this._pitch, this._yaw, 0);
-    var forward = new pc.Vec3();
-    quat.transformVector(pc.Vec3.FORWARD, forward);
-    var camPos = pivot.clone();
-    camPos.add(forward.clone().scale(-this._distance));
-    return camPos.y;
-};
-
-// ======================== Privé ===========================
-OrbitCamera.prototype.initialize = function () {
+    // Aspect ratio (comme avant)
     var self = this;
-    var onWindowResize = function () { self._checkAspectRatio(); };
-    window.addEventListener('resize', onWindowResize, false);
+    this._onResize = function(){ self._checkAspectRatio(); };
+    window.addEventListener('resize', this._onResize, false);
     this._checkAspectRatio();
-
-    this._modelsAabb = new pc.BoundingBox();
-    this._buildAabb(this.focusEntity || this.app.root);
-
-    this.entity.lookAt(this._modelsAabb.center);
-    this._pivotPoint = new pc.Vec3();
-    this._pivotPoint.copy(this._modelsAabb.center);
-
-    var cameraQuat = this.entity.getRotation();
-    this._yaw = this._calcYaw(cameraQuat);
-    this._pitch = this._clampPitchAngle(this._calcPitch(cameraQuat, this._yaw));
-    this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
-
-    this._distance = 0;
-    this._targetYaw = this._yaw;
-    this._targetPitch = this._pitch;
-
-    if (this.frameOnStart) {
-        this.focus(this.focusEntity || this.app.root);
-    } else {
-        var distanceBetween = new pc.Vec3();
-        distanceBetween.sub2(this.entity.getPosition(), this._pivotPoint);
-        this._distance = this._clampDistance(distanceBetween.length());
-    }
-    this._targetDistance = this._distance;
-
-    // Listeners d’attributs
-    this.on('attr:distanceMin',   function () { this._distance = this._clampDistance(this._distance); });
-    this.on('attr:pitchAngleMin', function () { this._pitch = this._clampPitchAngle(this._pitch); });
-    this.on('attr:pitchAngleMax', function () { this._pitch = this._clampPitchAngle(this._pitch); });
-
-    this.on('attr:focusEntity', function (value) {
-        if (this.frameOnStart) { this.focus(value || this.app.root); }
-        else { this.resetAndLookAtEntity(this.entity.getPosition(), value || this.app.root); }
-    });
-
-    this.on('attr:frameOnStart', function (value) {
-        if (value) { this.focus(this.focusEntity || this.app.root); }
-    });
-
-    this.on('destroy', function () { window.removeEventListener('resize', onWindowResize, false); });
 };
 
-OrbitCamera.prototype.update = function (dt) {
+FreeCamera.prototype.update = function (dt) {
+    // Rotation inertielle
     var t = this.inertiaFactor === 0 ? 1 : Math.min(dt / this.inertiaFactor, 1);
-    this._distance = pc.math.lerp(this._distance, this._targetDistance, t);
-    this._yaw      = pc.math.lerp(this._yaw,      this._targetYaw,     t);
-    this._pitch    = pc.math.lerp(this._pitch,    this._targetPitch,   t);
-    this._updatePosition();
-};
-
-OrbitCamera.prototype._updatePosition = function () {
-    // 1) oriente la caméra
-    this.entity.setLocalPosition(0, 0, 0);
+    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);
 
-    // 2) calcule la position théorique en fonction du pivot et de la distance
-    var forward = this.entity.forward.clone(); // direction de visée
-    var desired = this._pivotPoint.clone().add(forward.clone().mulScalar(-this._distance));
-
-    // 3) applique minY (plan horizontal)
-    if (desired.y < this.minY) {
-        desired.y = this.minY;
-    }
-
-    // 4) contraint UNIQUEMENT la position caméra à la bbox
-    var clamped = desired.clone();
-    var wasClamped = this._applyBoundingBox(clamped); // true si clamp
-
-    // 5) place la caméra
-    this.entity.setPosition(clamped);
-
-    // 6) si clamp (bbox/minY), recalcule un pivot cohérent sur le même rayon
-    if (wasClamped || clamped.y !== desired.y) {
-        // pos = pivot - forward * distance  =>  pivot = pos + forward * distance
-        this._pivotPoint.copy(clamped.clone().add(forward.mulScalar(this._distance)));
-    }
-};
-
-OrbitCamera.prototype._removeInertia = function () {
-    this._yaw = this._targetYaw;
-    this._pitch = this._targetPitch;
-    this._distance = this._targetDistance;
-};
-
-OrbitCamera.prototype._checkAspectRatio = function () {
-    var height = this.app.graphicsDevice.height;
-    var width  = this.app.graphicsDevice.width;
-    this.entity.camera.horizontalFov = (height > width);
-};
-
-OrbitCamera.prototype._buildAabb = function (entity) {
-    var i, m, meshInstances = [];
-
-    var renders = entity.findComponents('render');
-    for (i = 0; i < renders.length; i++) {
-        var render = renders[i];
-        for (m = 0; m < render.meshInstances.length; m++) {
-            meshInstances.push(render.meshInstances[m]);
-        }
-    }
-
-    var models = entity.findComponents('model');
-    for (i = 0; i < models.length; i++) {
-        var model = models[i];
-        for (m = 0; m < model.meshInstances.length; m++) {
-            meshInstances.push(model.meshInstances[m]);
-        }
-    }
-
-    var gsplats = entity.findComponents('gsplat');
-    for (i = 0; i < gsplats.length; i++) {
-        var gsplat = gsplats[i];
-        var instance = gsplat.instance;
-        if (instance?.meshInstance) {
-            meshInstances.push(instance.meshInstance);
-        }
-    }
-
-    for (i = 0; i < meshInstances.length; i++) {
-        if (i === 0) this._modelsAabb.copy(meshInstances[i].aabb);
-        else this._modelsAabb.add(meshInstances[i].aabb);
-    }
+    // Déplacements clavier (gérés dans Keyboard, mais on reclampe chaque frame)
+    var pos = this.entity.getPosition().clone();
+    this._clampPosition(pos);
+    this.entity.setPosition(pos);
 };
 
-OrbitCamera.prototype._calcYaw = function (quat) {
-    var transformedForward = new pc.Vec3();
-    quat.transformVector(pc.Vec3.FORWARD, transformedForward);
-    // Convention: yaw croissant = rotation CCW vue de dessus
-    return Math.atan2(transformedForward.x, transformedForward.z) * pc.math.RAD_TO_DEG;
-};
-
-OrbitCamera.prototype._clampDistance = function (distance) {
-    return Math.max(distance, this.distanceMin);
-};
-
-OrbitCamera.prototype._clampPitchAngle = function (pitch) {
-    return pc.math.clamp(pitch, this.pitchAngleMin, this.pitchAngleMax);
-};
-
-// Yaw: pas de clamp (rotation libre)
-OrbitCamera.prototype._clampYawAngle = function (yaw) { return yaw; };
-
-OrbitCamera.quatWithoutYaw = new pc.Quat();
-OrbitCamera.yawOffset = new pc.Quat();
-
-OrbitCamera.prototype._calcPitch = function (quat, yaw) {
-    var quatWithoutYaw = OrbitCamera.quatWithoutYaw;
-    var yawOffset = OrbitCamera.yawOffset;
-    yawOffset.setFromEulerAngles(0, -yaw, 0);
-    quatWithoutYaw.mul2(yawOffset, quat);
-    var transformedForward = new pc.Vec3();
-    quatWithoutYaw.transformVector(pc.Vec3.FORWARD, transformedForward);
-    return Math.atan2(-transformedForward.y, -transformedForward.z) * pc.math.RAD_TO_DEG;
+FreeCamera.prototype._checkAspectRatio = function () {
+    var gd = this.app.graphicsDevice;
+    if (!gd) return;
+    this.entity.camera.horizontalFov = (gd.height > gd.width);
 };
 
-// -------- Helpers Bounding Box --------
-OrbitCamera.prototype._bboxEnabled = function () {
+// ======================== Contraintes ===========================
+FreeCamera.prototype._bboxEnabled = function () {
     return (this.Xmin < this.Xmax) && (this.Ymin < this.Ymax) && (this.Zmin < this.Zmax);
 };
 
-/** Clamp position caméra à la bbox. @returns {boolean} true si clamp appliqué */
-OrbitCamera.prototype._applyBoundingBox = function (v3) {
-    if (!this._bboxEnabled()) return false;
-    var clamped = false;
-    var nx = pc.math.clamp(v3.x, this.Xmin, this.Xmax);
-    var ny = pc.math.clamp(v3.y, this.Ymin, this.Ymax);
-    var nz = pc.math.clamp(v3.z, this.Zmin, this.Zmax);
-    if (nx !== v3.x || ny !== v3.y || nz !== v3.z) clamped = true;
-    v3.x = nx; v3.y = ny; v3.z = nz;
-    return clamped;
-};
+FreeCamera.prototype._clampPosition = function (p) {
+    // minY prioritaire
+    if (p.y < this.minY) p.y = this.minY;
+    if (!this._bboxEnabled()) return;
 
-// ===================== Orbit Camera Input Mouse ========================
-var OrbitCameraInputMouse = pc.createScript('orbitCameraInputMouse');
-OrbitCameraInputMouse.attributes.add('orbitSensitivity',    { type: 'number', default: 0.3, title: 'Orbit Sensitivity' });
-OrbitCameraInputMouse.attributes.add('distanceSensitivity', { type: 'number', default: 0.4, title: 'Distance Sensitivity' });
+    p.x = pc.math.clamp(p.x, this.Xmin, this.Xmax);
+    p.y = pc.math.clamp(p.y, Math.max(this.Ymin, this.minY), this.Ymax);
+    p.z = pc.math.clamp(p.z, this.Zmin, this.Zmax);
+};
 
-OrbitCameraInputMouse.prototype.initialize = function () {
-    this.orbitCamera = this.entity.script.orbitCamera;
+// ===================== 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' });
+FreeCameraInputMouse.attributes.add('wheelSensitivity',{ type: 'number', default: 1.0, title: 'Wheel Sensitivity' });
 
-    if (this.orbitCamera) {
-        var self = this;
-        var onMouseOut = function () { self.onMouseOut(); };
+FreeCameraInputMouse.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera; // instance FreeCamera
+    this.last = new pc.Vec2();
+    this.isLooking = false;
 
+    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);
-        window.addEventListener('mouseout', onMouseOut, false);
+        this.app.mouse.disableContextMenu();
+    }
+    var self = this;
+    this._onOut = function(){ self.isLooking = false; };
+    window.addEventListener('mouseout', this._onOut, false);
 
-        this.on('destroy', function () {
+    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', onMouseOut, false);
-        });
-    }
-
-    this.app.mouse.disableContextMenu();
-
-    this.lookButtonDown = false;
-    this.panButtonDown  = false;
-    this.lastPoint = new pc.Vec2();
-};
-
-OrbitCameraInputMouse.fromWorldPoint = new pc.Vec3();
-OrbitCameraInputMouse.toWorldPoint   = new pc.Vec3();
-OrbitCameraInputMouse.worldDiff      = new pc.Vec3();
-
-OrbitCameraInputMouse.prototype.pan = function (screenPoint) {
-    var fromWorldPoint = OrbitCameraInputMouse.fromWorldPoint;
-    var toWorldPoint   = OrbitCameraInputMouse.toWorldPoint;
-    var worldDiff      = OrbitCameraInputMouse.worldDiff;
-
-    var camera   = this.entity.camera;
-    var distance = this.orbitCamera.distance;
-
-    camera.screenToWorld(screenPoint.x, screenPoint.y, distance, fromWorldPoint);
-    camera.screenToWorld(this.lastPoint.x, this.lastPoint.y, distance, toWorldPoint);
-
-    worldDiff.sub2(toWorldPoint, fromWorldPoint);
-
-    // minY via test sur la position caméra résultante
-    var proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-    var camY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
-
-    if (camY >= this.orbitCamera.minY - 1e-4) {
-        this.orbitCamera.pivotPoint.copy(proposedPivot);
-    } else {
-        worldDiff.y = 0;
-        proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-        camY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
-        if (camY >= this.orbitCamera.minY - 1e-4) {
-            this.orbitCamera.pivotPoint.copy(proposedPivot);
         }
-    }
+        window.removeEventListener('mouseout', this._onOut, false);
+    });
 };
 
-OrbitCameraInputMouse.prototype.onMouseDown = function (event) {
-    switch (event.button) {
-        case pc.MOUSEBUTTON_LEFT:   this.panButtonDown  = true; break;
-        case pc.MOUSEBUTTON_MIDDLE:
-        case pc.MOUSEBUTTON_RIGHT:  this.lookButtonDown = true; break;
-    }
+FreeCameraInputMouse.prototype.onMouseDown = function (e) {
+    // Bouton gauche/milieu/droit -> tous = "look"
+    this.isLooking = true;
+    this.last.set(e.x, e.y);
 };
 
-OrbitCameraInputMouse.prototype.onMouseUp = function (event) {
-    switch (event.button) {
-        case pc.MOUSEBUTTON_LEFT:   this.panButtonDown  = false; break;
-        case pc.MOUSEBUTTON_MIDDLE:
-        case pc.MOUSEBUTTON_RIGHT:  this.lookButtonDown = false; break;
-    }
+FreeCameraInputMouse.prototype.onMouseUp = function () {
+    this.isLooking = false;
 };
 
-OrbitCameraInputMouse.prototype.onMouseMove = function (event) {
-    if (this.lookButtonDown) {
-        var sens = this.orbitSensitivity;
-
-        // Souris : droite => orbite à droite ; gauche => orbite à gauche
-        var deltaYaw   = event.dx * sens;
-        // Pitch : dy<0 (monte) => pitch augmente (look up)
-        var deltaPitch = event.dy * sens;
-
-        var currPitch = this.orbitCamera.pitch;
-        var currYaw   = this.orbitCamera.yaw;
-        var currDist  = this.orbitCamera.distance;
-        var currPivot = this.orbitCamera.pivotPoint.clone();
-
-        var camQuat = new pc.Quat();
-        camQuat.setFromEulerAngles(currPitch, currYaw, 0);
-        var forward = new pc.Vec3();
-        camQuat.transformVector(pc.Vec3.FORWARD, forward);
-        var preY = currPivot.y + (-forward.y) * currDist;
-
-        // Conventions:
-        // - Yaw: +deltaYaw = tourner gauche (CCW). On veut "drag droite => tourner droite (CW)" -> yaw -= deltaYaw
-        // - Pitch: "drag haut (dy<0) => look up" -> pitch -= deltaPitch (car deltaPitch<0)
-        var proposedPitch = currPitch - deltaPitch;
-        var proposedYaw   = currYaw   - deltaYaw;
-
-        // Vérif minY pour pitch uniquement (comme avant)
-        var testQuat = new pc.Quat().setFromEulerAngles(proposedPitch, currYaw, 0);
-        var testForward = new pc.Vec3(); testQuat.transformVector(pc.Vec3.FORWARD, testForward);
-        var proposedY = currPivot.y + (-testForward.y) * currDist;
-
-        var minY = this.orbitCamera.minY;
-        var wouldGoBelow = proposedY < minY - 1e-4;
-
-        if (!(wouldGoBelow && (proposedY < preY))) {
-            this.orbitCamera.pitch = proposedPitch;
-        }
-        // Yaw toujours libre
-        this.orbitCamera.yaw = proposedYaw;
+FreeCameraInputMouse.prototype.onMouseMove = function (e) {
+    if (!this.isLooking || !this.freeCam) return;
+    var sens = this.lookSensitivity;
 
-    } else if (this.panButtonDown) {
-        this.pan(new pc.Vec2(event.x, event.y));
-    }
+    // 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
 
-    this.lastPoint.set(event.x, event.y);
-};
+    this.freeCam.yaw   = this.freeCam.yaw   - deltaYaw;   // yaw libre
+    this.freeCam.pitch = this.freeCam.pitch - deltaPitch; // pitch clampé
 
-OrbitCameraInputMouse.prototype.onMouseWheel = function (event) {
-    if (this.entity.camera.projection === pc.PROJECTION_PERSPECTIVE) {
-        this.orbitCamera.distance -= event.wheelDelta * this.distanceSensitivity * (this.orbitCamera.distance * 0.1);
-    } else {
-        this.orbitCamera.orthoHeight -= event.wheelDelta * this.distanceSensitivity * (this.orbitCamera.orthoHeight * 0.1);
-    }
-    event.event.preventDefault();
+    this.last.set(e.x, e.y);
 };
 
-OrbitCameraInputMouse.prototype.onMouseOut = function () {
-    this.lookButtonDown = false;
-    this.panButtonDown  = false;
+FreeCameraInputMouse.prototype.onMouseWheel = function (e) {
+    if (!this.freeCam) return;
+
+    // Dolly : avancer/reculer dans l'axe du regard
+    var cam = this.entity;
+    var move = -e.wheelDelta * this.wheelSensitivity * this.freeCam.dollySpeed * 0.05; // échelle douce
+    var forward = cam.forward.clone().normalize().mulScalar(move);
+
+    var pos = cam.getPosition().clone().add(forward);
+    this.freeCam._clampPosition(pos);
+    cam.setPosition(pos);
+
+    e.event.preventDefault();
 };
 
-// =================== Orbit Camera Input Touch ========================
-var OrbitCameraInputTouch = pc.createScript('orbitCameraInputTouch');
-OrbitCameraInputTouch.attributes.add('orbitSensitivity',    { type: 'number', default: 0.6, title: 'Orbit Sensitivity' });
-OrbitCameraInputTouch.attributes.add('distanceSensitivity', { type: 'number', default: 0.5, title: 'Distance Sensitivity' });
+// ===================== INPUT TOUCH (optionnel : look + pinch dolly simple) =====================
+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' });
 
-OrbitCameraInputTouch.prototype.initialize = function () {
-    this.orbitCamera = this.entity.script.orbitCamera;
-    this.lastTouchPoint    = new pc.Vec2();
-    this.lastPinchMidPoint = new pc.Vec2();
-    this.lastPinchDistance = 0;
+FreeCameraInputTouch.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.last = new pc.Vec2();
+    this.isLooking = false;
+    this.lastPinch = 0;
 
-    if (this.orbitCamera && this.app.touch) {
+    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);
+    }
 
-        this.on('destroy', function () {
+    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);
-        });
-    }
-};
-
-OrbitCameraInputTouch.prototype.getPinchDistance = function (pointA, pointB) {
-    var dx = pointA.x - pointB.x;
-    var dy = pointA.y - pointB.y;
-    return Math.sqrt((dx * dx) + (dy * dy));
-};
-
-OrbitCameraInputTouch.prototype.calcMidPoint = function (pointA, pointB, result) {
-    result.set(pointB.x - pointA.x, pointB.y - pointA.y);
-    result.mulScalar(0.5);
-    result.x += pointA.x;
-    result.y += pointA.y;
-};
-
-OrbitCameraInputTouch.prototype.onTouchStartEndCancel = function (event) {
-    var touches = event.touches;
-    if (touches.length === 1) {
-        this.lastTouchPoint.set(touches[0].x, touches[0].y);
-    } else if (touches.length === 2) {
-        this.lastPinchDistance = this.getPinchDistance(touches[0], touches[1]);
-        this.calcMidPoint(touches[0], touches[1], this.lastPinchMidPoint);
-    }
+        }
+    });
 };
 
-OrbitCameraInputTouch.fromWorldPoint = new pc.Vec3();
-OrbitCameraInputTouch.toWorldPoint   = new pc.Vec3();
-OrbitCameraInputTouch.worldDiff      = new pc.Vec3();
-
-OrbitCameraInputTouch.prototype.pan = function (midPoint) {
-    var fromWorldPoint = OrbitCameraInputTouch.fromWorldPoint;
-    var toWorldPoint   = OrbitCameraInputTouch.toWorldPoint;
-    var worldDiff      = OrbitCameraInputTouch.worldDiff;
-
-    var camera   = this.entity.camera;
-    var distance = this.orbitCamera.distance;
-
-    camera.screenToWorld(midPoint.x, midPoint.y, distance, fromWorldPoint);
-    camera.screenToWorld(this.lastPinchMidPoint.x, this.lastPinchMidPoint.y, distance, toWorldPoint);
-
-    worldDiff.sub2(toWorldPoint, fromWorldPoint);
-
-    var proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-    var minY = this.orbitCamera.minY;
-    var resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
-
-    if (resultingY >= minY - 1e-4) {
-        this.orbitCamera.pivotPoint.copy(proposedPivot);
+FreeCameraInputTouch.prototype.onTouchStartEndCancel = function (e) {
+    var t = e.touches;
+    if (t.length === 1) {
+        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;
+        var dy = t[0].y - t[1].y;
+        this.lastPinch = Math.sqrt(dx*dx + dy*dy);
     } else {
-        worldDiff.y = 0;
-        proposedPivot = this.orbitCamera.pivotPoint.clone().add(worldDiff);
-        resultingY = this.orbitCamera.worldCameraYForPivot(proposedPivot);
-        if (resultingY >= minY - 1e-4) {
-            this.orbitCamera.pivotPoint.copy(proposedPivot);
-        }
+        this.isLooking = false;
     }
 };
 
-OrbitCameraInputTouch.pinchMidPoint = new pc.Vec2();
-
-OrbitCameraInputTouch.prototype.onTouchMove = function (event) {
-    var pinchMidPoint = OrbitCameraInputTouch.pinchMidPoint;
-    var touches = event.touches;
-
-    if (touches.length === 1) {
-        var touch = touches[0];
-        var sens = this.orbitSensitivity;
-
-        var deltaYaw   = (touch.x - this.lastTouchPoint.x) * sens;
-        var deltaPitch = (touch.y - this.lastTouchPoint.y) * sens;
-
-        var currPitch = this.orbitCamera.pitch;
-        var currYaw   = this.orbitCamera.yaw;
-        var currDist  = this.orbitCamera.distance;
-        var currPivot = this.orbitCamera.pivotPoint.clone();
-
-        var camQuat = new pc.Quat().setFromEulerAngles(currPitch, currYaw, 0);
-        var forward = new pc.Vec3(); camQuat.transformVector(pc.Vec3.FORWARD, forward);
-        var preY = currPivot.y + (-forward.y) * currDist;
-
-        // mêmes conventions que souris
-        var proposedPitch = currPitch - deltaPitch;
-        var proposedYaw   = currYaw   - deltaYaw;
-
-        var testQuat = new pc.Quat().setFromEulerAngles(proposedPitch, currYaw, 0);
-        var testForward = new pc.Vec3(); testQuat.transformVector(pc.Vec3.FORWARD, testForward);
-        var proposedY = currPivot.y + (-testForward.y) * currDist;
-
-        var minY = this.orbitCamera.minY;
-        var wouldGoBelow = proposedY < minY - 1e-4;
-
-        if (!(wouldGoBelow && (proposedY < preY))) {
-            this.orbitCamera.pitch = proposedPitch;
-        }
-        this.orbitCamera.yaw = proposedYaw;
-
-        this.lastTouchPoint.set(touch.x, touch.y);
-    } else if (touches.length === 2) {
-        var currentPinchDistance  = this.getPinchDistance(touches[0], touches[1]);
-        var diffInPinchDistance   = currentPinchDistance - this.lastPinchDistance;
-        this.lastPinchDistance    = currentPinchDistance;
-
-        this.orbitCamera.distance -= (diffInPinchDistance * this.distanceSensitivity * 0.1) * (this.orbitCamera.distance * 0.1);
-
-        this.calcMidPoint(touches[0], touches[1], pinchMidPoint);
-        this.pan(pinchMidPoint);
-        this.lastPinchMidPoint.copy(pinchMidPoint);
+FreeCameraInputTouch.prototype.onTouchMove = function (e) {
+    var t = e.touches;
+    if (!this.freeCam) return;
+
+    if (t.length === 1 && this.isLooking) {
+        var sens = this.lookSensitivity;
+        var dx = t[0].x - this.last.x;
+        var dy = t[0].y - this.last.y;
+
+        this.freeCam.yaw   = this.freeCam.yaw   - dx * sens;
+        this.freeCam.pitch = this.freeCam.pitch - dy * sens;
+
+        this.last.set(t[0].x, t[0].y);
+    } else if (t.length === 2) {
+        // Pinch dolly
+        var dx = t[0].x - t[1].x;
+        var dy = t[0].y - t[1].y;
+        var dist = Math.sqrt(dx*dx + dy*dy);
+        var delta = dist - this.lastPinch;
+        this.lastPinch = dist;
+
+        var cam = this.entity;
+        var forward = cam.forward.clone().normalize().mulScalar(delta * this.pinchDollyFactor * this.freeCam.dollySpeed);
+        var pos = cam.getPosition().clone().add(forward);
+        this.freeCam._clampPosition(pos);
+        cam.setPosition(pos);
     }
 };
 
-// =================== Orbit Camera Input Keyboard ========================
-// Flèches : déplacement avant/arrière & droite/gauche (repère caméra, 3D)
-// Ctrl+flèches : orbiter autour du pivot (sens conforme ← CCW / → CW)
-// Maj+flèches : rotation libre sur place (pas de limites yaw/pitch)
-var OrbitCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
-
-// Vitesses (relatives à la distance)
-OrbitCameraInputKeyboard.attributes.add('forwardSpeed', { type: 'number', default: 1.8, title: 'Forward Speed (rel. to distance)' });
-OrbitCameraInputKeyboard.attributes.add('strafeSpeed',  { type: 'number', default: 1.8, title: 'Strafe Speed (rel. to distance)' });
-
-// Réglages d’orbite / rotation
-OrbitCameraInputKeyboard.attributes.add('orbitPitchSpeedDeg',  { type: 'number', default: 90,  title: 'Orbit Pitch Speed (deg/s) [Ctrl+Up/Down]' });
-OrbitCameraInputKeyboard.attributes.add('orbitYawSpeedDeg',    { type: 'number', default: 120, title: 'Orbit Yaw Speed (deg/s) [Ctrl+Left/Right]' });
-OrbitCameraInputKeyboard.attributes.add('rotatePitchSpeedDeg', { type: 'number', default: 90,  title: 'Self Rotate Pitch (deg/s) [Shift+Up/Down]' });
-OrbitCameraInputKeyboard.attributes.add('rotateYawSpeedDeg',   { type: 'number', default: 120, title: 'Self Rotate Yaw (deg/s) [Shift+Left/Right]' });
-
-OrbitCameraInputKeyboard.prototype.initialize = function () {
-    this.orbitCamera = this.entity.script.orbitCamera;
-    this.keyboard = this.app.keyboard || null;
-};
-
-OrbitCameraInputKeyboard.prototype.update = function (dt) {
-    if (!this.orbitCamera || !this.keyboard) return;
-
-    var up = this.keyboard.isPressed(pc.KEY_UP);
-    var dn = this.keyboard.isPressed(pc.KEY_DOWN);
-    var lt = this.keyboard.isPressed(pc.KEY_LEFT);
-    var rt = this.keyboard.isPressed(pc.KEY_RIGHT);
-
-    var shift = this.keyboard.isPressed(pc.KEY_SHIFT);
-    var ctrl  = this.keyboard.isPressed(pc.KEY_CONTROL);
+// ===================== INPUT CLAVIER (ZQSD + flèches) =====================
+var FreeCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
 
-    // -------- Ctrl + flèches : ORBIT autour du pivot --------
-    if (ctrl && (up || dn || lt || rt)) {
-        // Convention : ← = CCW => yaw augmente ; → = CW => yaw diminue
-        var yawDirLeftRight = (lt ? 1 : 0) - (rt ? 1 : 0); // ← +1, → -1
-        var pitchDirUpDown  = (up ? 1 : 0) - (dn ? 1 : 0); // ↑ +1, ↓ -1
+FreeCameraInputKeyboard.attributes.add('acceleration', { type: 'number', default: 1.0, title: 'Accel (unused, future)' });
 
-        if (yawDirLeftRight !== 0) {
-            this.orbitCamera.yaw = this.orbitCamera.yaw + yawDirLeftRight * this.orbitYawSpeedDeg * dt;
-        }
-
-        if (pitchDirUpDown !== 0) {
-            var currPitch = this.orbitCamera.pitch;
-            var currYaw   = this.orbitCamera.yaw;
-            var currDist  = this.orbitCamera.distance;
-            var currPivot = this.orbitCamera.pivotPoint.clone();
-
-            var camQuat = new pc.Quat().setFromEulerAngles(currPitch, currYaw, 0);
-            var forward = new pc.Vec3(); camQuat.transformVector(pc.Vec3.FORWARD, forward);
-            var preY = currPivot.y + (-forward.y) * currDist;
-
-            var testPitch = currPitch + pitchDirUpDown * this.orbitPitchSpeedDeg * dt;
-            var testQuat  = new pc.Quat().setFromEulerAngles(testPitch, currYaw, 0);
-            var testForward = new pc.Vec3(); testQuat.transformVector(pc.Vec3.FORWARD, testForward);
-            var proposedY = currPivot.y + (-testForward.y) * currDist;
-
-            var minY = this.orbitCamera.minY;
-            var wouldGoBelow = proposedY < minY - 1e-4;
+FreeCameraInputKeyboard.prototype.initialize = function () {
+    this.freeCam = this.entity.script.orbitCamera;
+    this.kb = this.app.keyboard || null;
+};
 
-            if (!(wouldGoBelow && (proposedY < preY))) {
-                this.orbitCamera.pitch = testPitch;
-            }
-        }
-        return;
-    }
+FreeCameraInputKeyboard.prototype.update = function (dt) {
+    if (!this.freeCam || !this.kb) return;
 
-    // -------- Maj + flèches : ROTATION SUR PLACE --------
-    if (shift && (up || dn || lt || rt)) {
-        var yawDirR   = (lt ? 1 : 0) - (rt ? 1 : 0); // ← +1 (CCW), → -1 (CW)
-        var pitchDirR = (up ? 1 : 0) - (dn ? 1 : 0); // ↑ +1, ↓ -1
+    // Déplacements : flèches OU ZQSD (AZERTY)
+    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 camPos = this.entity.getPosition().clone();
-        var dist   = this.orbitCamera._distance;
+    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;
 
-        // bypass clamps pour rotation libre
-        this.orbitCamera._yaw   += yawDirR   * this.rotateYawSpeedDeg   * dt;
-        this.orbitCamera._pitch += pitchDirR * this.rotatePitchSpeedDeg * dt;
-        this.orbitCamera._targetYaw   = this.orbitCamera._yaw;
-        this.orbitCamera._targetPitch = this.orbitCamera._pitch;
+    if (fwd !== 0 || strf !== 0) {
+        var cam = this.entity;
+        var pos = cam.getPosition().clone();
 
-        // Recalcule le pivot pour garder la même position de caméra
-        var q = new pc.Quat().setFromEulerAngles(this.orbitCamera._pitch, this.orbitCamera._yaw, 0);
-        var forward = new pc.Vec3(); q.transformVector(pc.Vec3.FORWARD, forward);
-        var newPivot = camPos.clone().add(forward.clone().mulScalar(dist));
-        this.orbitCamera._pivotPoint.copy(newPivot);
+        var forward = cam.forward.clone();  if (forward.lengthSq()  > 1e-8) forward.normalize();
+        var right   = cam.right.clone();    if (right.lengthSq()    > 1e-8) right.normalize();
 
-        this.orbitCamera._removeInertia();
-        this.orbitCamera._updatePosition();
-        this.entity.setPosition(camPos);
+        pos.add(forward.mulScalar(fwd  * this.freeCam.moveSpeed   * dt));
+        pos.add(right  .mulScalar(strf * this.freeCam.strafeSpeed * dt));
 
-        return;
+        this.freeCam._clampPosition(pos);
+        cam.setPosition(pos);
     }
 
-    // -------- Flèches seules : DÉPLACEMENT REPÈRE CAMÉRA --------
-    var moveForward = (up ? 1 : 0) - (dn ? 1 : 0);
-    var moveRight   = (rt ? 1 : 0) - (lt ? 1 : 0);
-    if (moveForward === 0 && moveRight === 0) return;
-
-    var fwd = this.entity.forward.clone();
-    var right = this.entity.right.clone();
-    if (fwd.lengthSq()   > 1e-8) fwd.normalize();
-    if (right.lengthSq() > 1e-8) right.normalize();
-
-    var camDist = Math.max(0.1, this.orbitCamera._distance);
-    var speedF = this.forwardSpeed * camDist;
-    var speedR = this.strafeSpeed  * camDist;
-
-    var delta = new pc.Vec3();
-    if (moveForward !== 0) delta.add(fwd.mulScalar(moveForward * speedF * dt));
-    if (moveRight   !== 0) delta.add(right.mulScalar(moveRight   * speedR * dt));
-
-    if (delta.lengthSq() > 0) {
-        // Respect minY (camY_new = camY_cur + delta.y)
-        var currCamY = this.orbitCamera.worldCameraYForPivot(this.orbitCamera._pivotPoint);
-        var minY = this.orbitCamera.minY;
-        if (currCamY + delta.y < minY) {
-            delta.y = minY - currCamY;
-        }
-        this.orbitCamera._pivotPoint.add(delta);
+    // Rotation au clavier (Shift + flèches) — conservée
+    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;
+        if (pitchDir !== 0) this.freeCam.pitch = this.freeCam.pitch + pitchDir * pitchSpeed * dt;
     }
 };