Update orbit-camera.js

orbit-camera.js

@@ -1,6 +1,8 @@
+// orbit-camera.js (fixed to clamp world Y at minY, with debug logs)
+
+///////////////////////////////////////////////////////////////////////////////
+//                             Orbit Camera Script                           //
 ///////////////////////////////////////////////////////////////////////////////
-//                             Orbit Camera Script  qui marche presque                          //
-////////////////////////////////////////////////////////////////////////////////
 
 var OrbitCamera = pc.createScript('orbitCamera');
 
@@ -11,7 +13,6 @@ OrbitCamera.attributes.add('pitchAngleMax', { type: 'number', default: 90, title
 OrbitCamera.attributes.add('pitchAngleMin', { type: 'number', default: 0, title: 'Pitch Angle Min (degrees)' });
 OrbitCamera.attributes.add('yawAngleMax', { type: 'number', default: 360, title: 'Yaw Angle Max (degrees)' });
 OrbitCamera.attributes.add('yawAngleMin', { type: 'number', default: -360, title: 'Yaw Angle Min (degrees)' });
-// NEW: Added minY attribute to define the minimum allowed Y value for the camera.
 OrbitCamera.attributes.add('minY', { type: 'number', default: 0, title: 'Minimum Y', description: 'Minimum Y value for the camera during orbiting or translation' });
 
 OrbitCamera.attributes.add('inertiaFactor', {
@@ -34,9 +35,7 @@ OrbitCamera.attributes.add('frameOnStart', {
     description: 'Frames the entity or scene at the start of the application."'
 });
 
-
 // Property to get and set the distance between the pivot point and camera
-// Clamped between this.distanceMin and this.distanceMax
 Object.defineProperty(OrbitCamera.prototype, 'distance', {
     get: function () {
         return this._targetDistance;
@@ -56,11 +55,7 @@ Object.defineProperty(OrbitCamera.prototype, 'orthoHeight', {
     }
 });
 
-
 // Property to get and set the pitch (in degrees) of the camera around the pivot.
-// The pitch value is clamped between pitchAngleMin and pitchAngleMax.
-// With your JSON (minAngle: -90, maxAngle: 0), the allowed pitch will be from -90 (overhead)
-// to 0 (horizontal).
 Object.defineProperty(OrbitCamera.prototype, 'pitch', {
     get: function () {
         return this._targetPitch;
@@ -70,7 +65,6 @@ Object.defineProperty(OrbitCamera.prototype, 'pitch', {
     }
 });
 
-
 // Property to get and set the yaw (in degrees) of the camera around the pivot.
 Object.defineProperty(OrbitCamera.prototype, 'yaw', {
     get: function () {
@@ -81,7 +75,6 @@ Object.defineProperty(OrbitCamera.prototype, 'yaw', {
     }
 });
 
-
 // Property to get and set the world position of the pivot point that the camera orbits around.
 Object.defineProperty(OrbitCamera.prototype, 'pivotPoint', {
     get: function () {
@@ -92,10 +85,8 @@ Object.defineProperty(OrbitCamera.prototype, 'pivotPoint', {
     }
 });
 
-
 // Moves the camera to look at an entity and all its children so they are all in view.
 OrbitCamera.prototype.focus = function (focusEntity) {
-    // Calculate a bounding box that encompasses all models to frame in the camera view.
     this._buildAabb(focusEntity);
     var halfExtents = this._modelsAabb.halfExtents;
     var radius = Math.max(halfExtents.x, Math.max(halfExtents.y, halfExtents.z));
@@ -106,7 +97,6 @@ OrbitCamera.prototype.focus = function (focusEntity) {
 
 OrbitCamera.distanceBetween = new pc.Vec3();
 
-// Set the camera position to a world position and look at a world position.
 OrbitCamera.prototype.resetAndLookAtPoint = function (resetPoint, lookAtPoint) {
     this.pivotPoint.copy(lookAtPoint);
     this.entity.setPosition(resetPoint);
@@ -148,9 +138,8 @@ OrbitCamera.prototype.resetToPosition = function (position, lookAtPoint) {
     this._updatePosition();
 };
 
-
 ////////////////////////////////////////////////////////////////////////////////
-//                          Private Methods                                 //
+//                          Private Methods                                   //
 ////////////////////////////////////////////////////////////////////////////////
 
 OrbitCamera.prototype.initialize = function () {
@@ -168,7 +157,6 @@ OrbitCamera.prototype.initialize = function () {
     this._pivotPoint.copy(this._modelsAabb.center);
     var cameraQuat = this.entity.getRotation();
     this._yaw = this._calcYaw(cameraQuat);
-    // Compute pitch and clamp it immediately.
     this._pitch = this._clampPitchAngle(this._calcPitch(cameraQuat, this._yaw));
     this.entity.setLocalEulerAngles(this._pitch, this._yaw, 0);
     this._distance = 0;
@@ -229,7 +217,7 @@ OrbitCamera.prototype._updatePosition = function () {
     position.copy(this.entity.forward);
     position.mulScalar(-this._distance);
     position.add(this.pivotPoint);
-    // NEW: Clamp the camera's Y position so it never goes below the specified minY value.
+    // Clamp camera's Y position so it never goes below minY (after all rotations)
     position.y = Math.max(position.y, this.minY);
     this.entity.setPosition(position);
 };
@@ -292,10 +280,6 @@ OrbitCamera.prototype._clampDistance = function (distance) {
     return Math.max(distance, this.distanceMin);
 };
 
-
-// ----- FIXED PITCH CLAMPING -----
-// Clamp the pitch between pitchAngleMin and pitchAngleMax so that with your JSON values
-// (minAngle: -90, maxAngle: 0) the allowed pitch is between -90 (overhead) and 0 (horizontal).
 OrbitCamera.prototype._clampPitchAngle = function (pitch) {
     return pc.math.clamp(pitch, this.pitchAngleMin, this.pitchAngleMax);
 };
@@ -307,10 +291,6 @@ OrbitCamera.prototype._clampYawAngle = function (yaw) {
 OrbitCamera.quatWithoutYaw = new pc.Quat();
 OrbitCamera.yawOffset = new pc.Quat();
 
-// ----- REVISED PITCH CALCULATION -----
-// Modify _calcPitch so that horizontal (looking straight ahead) returns 0,
-// and looking overhead returns -90.
-// This change ensures that with JSON (minAngle: -90, maxAngle: 0) the allowed pitch is strictly between -90 and 0.
 OrbitCamera.prototype._calcPitch = function (quat, yaw) {
     var quatWithoutYaw = OrbitCamera.quatWithoutYaw;
     var yawOffset = OrbitCamera.yawOffset;
@@ -318,13 +298,9 @@ OrbitCamera.prototype._calcPitch = function (quat, yaw) {
     quatWithoutYaw.mul2(yawOffset, quat);
     var transformedForward = new pc.Vec3();
     quatWithoutYaw.transformVector(pc.Vec3.FORWARD, transformedForward);
-    // Here we swap the sign of the computed angle so that:
-    // - When the camera is horizontal, transformedForward.y is 0 and the result is 0.
-    // - When the camera is overhead, transformedForward.y is negative and the result is -90.
     return Math.atan2(-transformedForward.y, -transformedForward.z) * pc.math.RAD_TO_DEG;
 };
 
-
 ////////////////////////////////////////////////////////////////////////////////
 //                       Orbit Camera Mouse Input Script                      //
 ////////////////////////////////////////////////////////////////////////////////
@@ -406,15 +382,65 @@ OrbitCameraInputMouse.prototype.onMouseUp = function (event) {
             break;
     }
 };
+
+// ---------- PATCHED: orbit suppression at minY (mouse) ---------------
 OrbitCameraInputMouse.prototype.onMouseMove = function (event) {
     if (this.lookButtonDown) {
-        this.orbitCamera.pitch -= event.dy * this.orbitSensitivity;
-        this.orbitCamera.yaw   -= event.dx * this.orbitSensitivity;
+        var sens = this.orbitSensitivity;
+        var deltaPitch = event.dy * sens;
+        var deltaYaw = event.dx * sens;
+
+        var currPitch = this.orbitCamera.pitch;
+        var currYaw = this.orbitCamera.yaw;
+        var currDist = this.orbitCamera.distance;
+        var currPivot = this.orbitCamera.pivotPoint.clone();
+
+        // Compute the world position before the change
+        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;
+
+        // Compute the world position after applying the vertical delta
+        var proposedPitch = currPitch - deltaPitch;
+        var testQuat = new pc.Quat();
+        testQuat.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 isAtMinY = preY <= minY + 1e-4;
+        var wouldGoBelow = proposedY < minY - 1e-4;
+        var suppressed = false;
+
+        // Only suppress if going *further* below minY (upward)
+        if (wouldGoBelow && (proposedY < preY)) {
+            // Suppress vertical, allow horizontal (yaw)
+            this.orbitCamera.yaw = currYaw - deltaYaw;
+            suppressed = true;
+        } else {
+            this.orbitCamera.pitch = proposedPitch;
+            this.orbitCamera.yaw = currYaw - deltaYaw;
+        }
+
+        console.log(
+            '[Mouse] currentY=', preY.toFixed(3),
+            'proposedY=', proposedY.toFixed(3),
+            'minY=', minY,
+            'deltaX=', event.dx,
+            'deltaY=', event.dy,
+            'isAtMinY=', isAtMinY,
+            'suppressedVertical=', suppressed
+        );
     } else if (this.panButtonDown) {
         this.pan(new pc.Vec2(event.x, event.y));
     }
     this.lastPoint.set(event.x, event.y);
 };
+// ---------------------------------------------------------------------
+
 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);
@@ -428,7 +454,6 @@ OrbitCameraInputMouse.prototype.onMouseOut = function (event) {
     this.panButtonDown = false;
 };
 
-
 ////////////////////////////////////////////////////////////////////////////////
 //                       Orbit Camera Touch Input Script                      //
 ////////////////////////////////////////////////////////////////////////////////
@@ -504,13 +529,59 @@ OrbitCameraInputTouch.prototype.pan = function (midPoint) {
     }
 };
 OrbitCameraInputTouch.pinchMidPoint = new pc.Vec2();
+
+// ---------- PATCHED: orbit suppression at minY (touch) ---------------
 OrbitCameraInputTouch.prototype.onTouchMove = function (event) {
     var pinchMidPoint = OrbitCameraInputTouch.pinchMidPoint;
     var touches = event.touches;
     if (touches.length === 1) {
         var touch = touches[0];
-        this.orbitCamera.pitch -= (touch.y - this.lastTouchPoint.y) * this.orbitSensitivity;
-        this.orbitCamera.yaw   -= (touch.x - this.lastTouchPoint.x) * this.orbitSensitivity;
+        var sens = this.orbitSensitivity;
+        var deltaPitch = (touch.y - this.lastTouchPoint.y) * sens;
+        var deltaYaw = (touch.x - this.lastTouchPoint.x) * sens;
+
+        var currPitch = this.orbitCamera.pitch;
+        var currYaw = this.orbitCamera.yaw;
+        var currDist = this.orbitCamera.distance;
+        var currPivot = this.orbitCamera.pivotPoint.clone();
+
+        // Compute the world position before the change
+        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;
+
+        // Compute the world position after applying the vertical delta
+        var proposedPitch = currPitch - deltaPitch;
+        var testQuat = new pc.Quat();
+        testQuat.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 isAtMinY = preY <= minY + 1e-4;
+        var wouldGoBelow = proposedY < minY - 1e-4;
+        var suppressed = false;
+
+        if (wouldGoBelow && (proposedY < preY)) {
+            // Suppress vertical, allow horizontal (yaw)
+            this.orbitCamera.yaw = currYaw - deltaYaw;
+            suppressed = true;
+        } else {
+            this.orbitCamera.pitch = proposedPitch;
+            this.orbitCamera.yaw = currYaw - deltaYaw;
+        }
+        console.log(
+            '[Touch] currentY=', preY.toFixed(3),
+            'proposedY=', proposedY.toFixed(3),
+            'minY=', minY,
+            'deltaX=', (touch.x - this.lastTouchPoint.x),
+            'deltaY=', (touch.y - this.lastTouchPoint.y),
+            'isAtMinY=', isAtMinY,
+            'suppressedVertical=', suppressed
+        );
         this.lastTouchPoint.set(touch.x, touch.y);
     } else if (touches.length === 2) {
         var currentPinchDistance = this.getPinchDistance(touches[0], touches[1]);
@@ -521,4 +592,5 @@ OrbitCameraInputTouch.prototype.onTouchMove = function (event) {
         this.pan(pinchMidPoint);
         this.lastPinchMidPoint.copy(pinchMidPoint);
     }
-};
+};
+// ---------------------------------------------------------------------