Update orbit-camera.js

orbit-camera.js

@@ -124,7 +124,7 @@ OrbitCamera.prototype.initialize = function () {
     this._pivotPoint.copy(this._modelsAabb.center);
 
     var cameraQuat = this.entity.getRotation();
-    this._yaw = this._calcYaw(cameraQuat);                          // degrees
+    this._yaw = this._calcYaw(cameraQuat); // degrees
     this._pitch = this._clampPitchAngle(this._calcPitch(cameraQuat, this._yaw));
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
 
@@ -156,6 +156,9 @@ OrbitCamera.prototype.initialize = function () {
     this.on('destroy', function () {
         window.removeEventListener('resize', onWindowResize, false);
     });
+
+    // --- Logs init ---
+    console.log('[OrbitCam] init yaw=%s° pitch=%s° dist=%s', this._yaw.toFixed(2), this._pitch.toFixed(2), this._distance.toFixed(3));
 };
 
 OrbitCamera.prototype.update = function (dt) {
@@ -231,7 +234,7 @@ OrbitCamera.prototype._buildAabb = function (entity) {
 };
 
 OrbitCamera.prototype._calcYaw = function (quat) {
-    // FIX: return degrees (was effectively radians before)
+    // CORRECTION: renvoyer des DEGRÉS (pas des radians)
     var f = new pc.Vec3();
     quat.transformVector(pc.Vec3.FORWARD, f);
     return Math.atan2(-f.x, -f.z) * pc.math.RAD_TO_DEG;
@@ -549,17 +552,28 @@ var OrbitCameraInputKeyboard = pc.createScript('orbitCameraInputKeyboard');
  * - orbitDegreesPerSecond : vitesse d’orbite (deg/s) pour yaw/pitch
  * - zoomFactorPerSecond   : facteur de zoom (proportionnel à la distance) par seconde
  * - panUnitsPerSecond     : vitesse de pan (en unités monde = distance * facteur) par seconde
+ * - debugLogs             : activer les console.log de diagnostic
  */
 OrbitCameraInputKeyboard.attributes.add('orbitDegreesPerSecond', { type: 'number', default: 180, title: 'Orbit Degrees / s' });
 OrbitCameraInputKeyboard.attributes.add('zoomFactorPerSecond',   { type: 'number', default: 2.0, title: 'Zoom Factor / s' });
 OrbitCameraInputKeyboard.attributes.add('panUnitsPerSecond',     { type: 'number', default: 1.0, title: 'Pan (distance frac) / s' });
+OrbitCameraInputKeyboard.attributes.add('debugLogs',             { type: 'boolean', default: true, title: 'Enable Debug Logs' });
+
+OrbitCameraInputKeyboard.prototype._log = function () {
+    if (!this.debugLogs) return;
+    // eslint-disable-next-line no-console
+    console.log.apply(console, arguments);
+};
 
 OrbitCameraInputKeyboard.prototype.initialize = function () {
     this.orbitCamera = this.entity.script.orbitCamera;
 
-    // S’assure que le clavier est bien attaché (certains viewers ne l’initialisent pas)
+    // S’assure que le clavier est bien initialisé
     if (!this.app.keyboard) {
         this.app.keyboard = new pc.Keyboard(window);
+        this._log('[OrbitKB] app.keyboard was null -> created new pc.Keyboard(window)');
+    } else {
+        this._log('[OrbitKB] app.keyboard OK (already present)');
     }
 
     // Empêche le scroll de la page avec les flèches quand la scène a le focus
@@ -570,13 +584,34 @@ OrbitCameraInputKeyboard.prototype.initialize = function () {
         var key = e.key || '';
         if (key === 'ArrowUp' || key === 'ArrowDown' || key === 'ArrowLeft' || key === 'ArrowRight') {
             e.preventDefault();
+            if (self.debugLogs) console.log('[OrbitKB] preventDefault on', key);
         }
     };
     window.addEventListener('keydown', this._preventDefault, { passive: false });
 
+    // Petits logs sur keydown/keyup pour vérifier la réception des flèches
+    this._onKeyDown = function (e) {
+        if (!self.debugLogs) return;
+        console.log('[OrbitKB] keydown', e.key, 'code=', e.keyCode);
+    };
+    this._onKeyUp = function (e) {
+        if (!self.debugLogs) return;
+        console.log('[OrbitKB] keyup  ', e.key, 'code=', e.keyCode);
+    };
+    window.addEventListener('keydown', this._onKeyDown);
+    window.addEventListener('keyup', this._onKeyUp);
+
     this.on('destroy', function () {
         window.removeEventListener('keydown', self._preventDefault, { passive: false });
+        window.removeEventListener('keydown', self._onKeyDown);
+        window.removeEventListener('keyup', self._onKeyUp);
     });
+
+    this._log('[OrbitKB] init done. Camera start yaw=%s pitch=%s dist=%s',
+        this.orbitCamera ? this.orbitCamera.yaw : 'n/a',
+        this.orbitCamera ? this.orbitCamera.pitch : 'n/a',
+        this.orbitCamera ? this.orbitCamera.distance : 'n/a'
+    );
 };
 
 // Teste si un pitch proposé ferait passer la caméra sous minY (même logique que la souris)
@@ -622,11 +657,27 @@ OrbitCameraInputKeyboard.prototype._panSideways = function (delta) {
 
     if (resultingY >= minY - 1e-4) {
         cam.pivotPoint.add(worldDiff);
+        this._log('[OrbitKB] panSideways OK delta=%s -> pivot=(%s,%s,%s)',
+            delta.toFixed(3),
+            cam.pivotPoint.x.toFixed(3),
+            cam.pivotPoint.y.toFixed(3),
+            cam.pivotPoint.z.toFixed(3)
+        );
     } else {
         worldDiff.y = 0;
         proposedPivot = cam.pivotPoint.clone().add(worldDiff);
         resultingY = cam.worldCameraYForPivot(proposedPivot);
-        if (resultingY >= minY - 1e-4) cam.pivotPoint.add(worldDiff);
+        if (resultingY >= minY - 1e-4) {
+            cam.pivotPoint.add(worldDiff);
+            this._log('[OrbitKB] panSideways horizontal-only delta=%s -> pivot=(%s,%s,%s)',
+                delta.toFixed(3),
+                cam.pivotPoint.x.toFixed(3),
+                cam.pivotPoint.y.toFixed(3),
+                cam.pivotPoint.z.toFixed(3)
+            );
+        } else {
+            this._log('[OrbitKB] panSideways blocked by minY (delta=%s)', delta.toFixed(3));
+        }
     }
 };
 
@@ -637,6 +688,12 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
     var shift = kb.isPressed(pc.KEY_SHIFT);
     var cam = this.orbitCamera;
 
+    // log des états de touches quand quelque chose d'intéressant est enfoncé
+    if (this.debugLogs && (kb.isPressed(pc.KEY_UP) || kb.isPressed(pc.KEY_DOWN) || kb.isPressed(pc.KEY_LEFT) || kb.isPressed(pc.KEY_RIGHT))) {
+        console.log('[OrbitKB] pressed states: shift=%s up=%s down=%s left=%s right=%s',
+            !!shift, !!kb.isPressed(pc.KEY_UP), !!kb.isPressed(pc.KEY_DOWN), !!kb.isPressed(pc.KEY_LEFT), !!kb.isPressed(pc.KEY_RIGHT));
+    }
+
     // --------- Avec SHIFT : zoom & pan latéral ----------
     if (shift) {
         // Zoom (⇧+↑ / ⇧+↓) — proportionnel à la distance / orthoHeight
@@ -645,12 +702,18 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
 
             if (this.entity.camera.projection === pc.PROJECTION_PERSPECTIVE) {
                 var dz = k * dt * (cam.distance * 0.8);
+                var before = cam.distance;
                 if (kb.isPressed(pc.KEY_UP))   cam.distance = cam.distance - dz;
                 if (kb.isPressed(pc.KEY_DOWN)) cam.distance = cam.distance + dz;
+                this._log('[OrbitKB] SHIFT Zoom persp d:%s -> %s (dz=%s)',
+                    before.toFixed(3), cam.distance.toFixed(3), dz.toFixed(3));
             } else {
                 var dh = k * dt * (this.entity.camera.orthoHeight * 0.8);
+                var beforeH = this.entity.camera.orthoHeight;
                 if (kb.isPressed(pc.KEY_UP))   this.entity.camera.orthoHeight -= dh;
                 if (kb.isPressed(pc.KEY_DOWN)) this.entity.camera.orthoHeight += dh;
+                this._log('[OrbitKB] SHIFT Zoom ortho h:%s -> %s (dh=%s)',
+                    beforeH.toFixed(3), this.entity.camera.orthoHeight.toFixed(3), dh.toFixed(3));
             }
         }
 
@@ -658,6 +721,8 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
         if (kb.isPressed(pc.KEY_LEFT) || kb.isPressed(pc.KEY_RIGHT)) {
             var speed = this.panUnitsPerSecond * cam.distance; // unités/s
             var delta = speed * dt * (kb.isPressed(pc.KEY_LEFT) ? -1 : 1);
+            this._log('[OrbitKB] SHIFT Pan request delta=%s (speed=%s, dist=%s)',
+                delta.toFixed(3), speed.toFixed(3), cam.distance.toFixed(3));
             this._panSideways(delta);
         }
 
@@ -670,16 +735,23 @@ OrbitCameraInputKeyboard.prototype.update = function (dt) {
     // Pitch (↑/↓) — protège minY exactement comme la souris
     if (kb.isPressed(pc.KEY_UP) || kb.isPressed(pc.KEY_DOWN)) {
         var dir = kb.isPressed(pc.KEY_UP) ? -1 : 1; // ↑ = réduire le pitch (orbiter vers le nord)
-        var currPitch = cam.pitch;
-        var proposedPitch = currPitch + dir * orbitRate;
+        var beforePitch = cam.pitch;
+        var proposedPitch = beforePitch + dir * orbitRate;
 
         var test = this._wouldGoBelowMinYWithPitch(proposedPitch);
         if (!(test.wouldGoBelow && (test.proposedY < test.preY))) {
             cam.pitch = proposedPitch;
+            this._log('[OrbitKB] Orbit PITCH %s -> %s (rate=%s)', beforePitch.toFixed(3), cam.pitch.toFixed(3), orbitRate.toFixed(3));
+        } else {
+            this._log('[OrbitKB] Orbit PITCH blocked by minY (before=%s proposed=%s)', beforePitch.toFixed(3), proposedPitch.toFixed(3));
         }
     }
 
     // Yaw (←/→) — orbite horizontale
-    if (kb.isPressed(pc.KEY_LEFT))  cam.yaw = cam.yaw + orbitRate;  // vers la gauche
-    if (kb.isPressed(pc.KEY_RIGHT)) cam.yaw = cam.yaw - orbitRate;  // vers la droite
+    if (kb.isPressed(pc.KEY_LEFT) || kb.isPressed(pc.KEY_RIGHT)) {
+        var beforeYaw = cam.yaw;
+        if (kb.isPressed(pc.KEY_LEFT))  cam.yaw = cam.yaw + orbitRate;  // vers la gauche
+        if (kb.isPressed(pc.KEY_RIGHT)) cam.yaw = cam.yaw - orbitRate;  // vers la droite
+        this._log('[OrbitKB] Orbit YAW %s -> %s (rate=%s)', beforeYaw.toFixed(3), cam.yaw.toFixed(3), orbitRate.toFixed(3));
+    }
 };