Update orbit-camera.js

orbit-camera.js

@@ -34,9 +34,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 +54,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 +64,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 +74,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 +84,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 +96,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,7 +137,6 @@ OrbitCamera.prototype.resetToPosition = function (position, lookAtPoint) {
     this._updatePosition();
 };
 
-
 ////////////////////////////////////////////////////////////////////////////////
 //                          Private Methods                                 //
 ////////////////////////////////////////////////////////////////////////////////
@@ -168,7 +156,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 +216,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 the camera's Y position so it never goes below minY.
     position.y = Math.max(position.y, this.minY);
     this.entity.setPosition(position);
 };
@@ -292,12 +279,27 @@ 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).
+// ----- FIXED PITCH CLAMPING WITH minY RESPECT -----
 OrbitCamera.prototype._clampPitchAngle = function (pitch) {
-    return pc.math.clamp(pitch, this.pitchAngleMin, this.pitchAngleMax);
+    // Clamp between configured pitchAngleMin/Max first
+    var clamped = pc.math.clamp(pitch, this.pitchAngleMin, this.pitchAngleMax);
+
+    // Then ensure resulting world-space Y >= minY
+    // simulate forward vector
+    var yaw = this._targetYaw;
+    var quat = new pc.Quat().setFromEulerAngles(clamped, yaw, 0);
+    var forward = new pc.Vec3();
+    quat.transformVector(pc.Vec3.FORWARD, forward);
+    var simulatedY = this._pivotPoint.y - forward.y * this._targetDistance;
+    if (simulatedY < this.minY) {
+        // compute max pitch that just reaches minY: asin((pivotY-minY)/distance)
+        var ratio = (this._pivotPoint.y - this.minY) / this._targetDistance;
+        ratio = pc.math.clamp(ratio, -1, 1);
+        var angle = Math.asin(ratio) * pc.math.RAD_TO_DEG;
+        return pc.math.clamp(angle, this.pitchAngleMin, this.pitchAngleMax);
+    }
+
+    return clamped;
 };
 
 OrbitCamera.prototype._clampYawAngle = function (yaw) {
@@ -308,9 +310,6 @@ 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 +317,11 @@ 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                      //
 ////////////////////////////////////////////////////////////////////////////////
@@ -342,6 +339,7 @@ OrbitCameraInputMouse.attributes.add('distanceSensitivity', {
     title: 'Distance Sensitivity',
     description: 'How fast the camera moves in and out. Higher is faster'
 });
+
 OrbitCameraInputMouse.prototype.initialize = function () {
     this.orbitCamera = this.entity.script.orbitCamera;
     if (this.orbitCamera) {
@@ -365,9 +363,11 @@ OrbitCameraInputMouse.prototype.initialize = function () {
     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;
@@ -384,6 +384,7 @@ OrbitCameraInputMouse.prototype.pan = function (screenPoint) {
         this.orbitCamera.pivotPoint.y = minPivotY;
     }
 };
+
 OrbitCameraInputMouse.prototype.onMouseDown = function (event) {
     switch (event.button) {
         case pc.MOUSEBUTTON_LEFT:
@@ -406,15 +407,21 @@ OrbitCameraInputMouse.prototype.onMouseUp = function (event) {
             break;
     }
 };
+
 OrbitCameraInputMouse.prototype.onMouseMove = function (event) {
     if (this.lookButtonDown) {
-        this.orbitCamera.pitch -= event.dy * this.orbitSensitivity;
-        this.orbitCamera.yaw   -= event.dx * this.orbitSensitivity;
+        var delta = -event.dy * this.orbitSensitivity;
+        var camY = this.entity.getPosition().y;
+        // block further downward orbit when at minY
+        if (!(delta < 0 && camY <= this.orbitCamera.minY)) {
+            this.orbitCamera.pitch += delta;
+        }
     } 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);
@@ -423,6 +430,7 @@ OrbitCameraInputMouse.prototype.onMouseWheel = function (event) {
     }
     event.event.preventDefault();
 };
+
 OrbitCameraInputMouse.prototype.onMouseOut = function (event) {
     this.lookButtonDown = false;
     this.panButtonDown = false;
@@ -446,6 +454,7 @@ OrbitCameraInputTouch.attributes.add('distanceSensitivity', {
     title: 'Distance Sensitivity',
     description: 'How fast the camera moves in and out. Higher is faster'
 });
+
 OrbitCameraInputTouch.prototype.initialize = function () {
     this.orbitCamera = this.entity.script.orbitCamera;
     this.lastTouchPoint = new pc.Vec2();
@@ -464,6 +473,7 @@ OrbitCameraInputTouch.prototype.initialize = function () {
         });
     }
 };
+
 OrbitCameraInputTouch.prototype.getPinchDistance = function (pointA, pointB) {
     var dx = pointA.x - pointB.x;
     var dy = pointA.y - pointB.y;
@@ -484,9 +494,11 @@ OrbitCameraInputTouch.prototype.onTouchStartEndCancel = function (event) {
         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;
@@ -503,22 +515,28 @@ OrbitCameraInputTouch.prototype.pan = function (midPoint) {
         this.orbitCamera.pivotPoint.y = minPivotY;
     }
 };
+
 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];
-        this.orbitCamera.pitch -= (touch.y - this.lastTouchPoint.y) * this.orbitSensitivity;
-        this.orbitCamera.yaw   -= (touch.x - this.lastTouchPoint.x) * this.orbitSensitivity;
+        var dy = touch.y - this.lastTouchPoint.y;
+        var delta = -dy * this.orbitSensitivity;
+        var camY = this.entity.getPosition().y;
+        // block further downward orbit when at minY
+        if (!(delta < 0 && camY <= this.orbitCamera.minY)) {
+            this.orbitCamera.pitch += delta;
+        }
         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);
+        this.calcMidPoint(touches[0], touches[1], OrbitCameraInputTouch.pinchMidPoint);
+        this.pan(OrbitCameraInputTouch.pinchMidPoint);
+        this.lastPinchMidPoint.copy(OrbitCameraInputTouch.pinchMidPoint);
     }
-};
+};