Update index.js

index.js

@@ -284,7 +284,7 @@
     const camera = new SPLAT.Camera();
     const controls = new SPLAT.OrbitControls(camera, canvas);
     
-    // Store the controls instance if needed.
+    // Store the controls and camera instances.
     controlsInstance = controls;
     cameraInstance = camera;
 
@@ -293,25 +293,46 @@
     controls.minZoom = minZoom;
     controls.minAngle = minAngle;
     controls.maxAngle = maxAngle;
-    // Pass the new azimuth limits to the controls (for reference, though the library doesn’t natively use them)
+    // Pass the new azimuth limits to the controls (for reference)
     controls.minAzimuth = minAzimuth;
     controls.maxAzimuth = maxAzimuth;
     
-    // Monkey patch the update method to clamp horizontal (azimuth) rotation.
-    // We assume that camera.rotation is a Quaternion that can be converted to Euler angles.
-    // The azimuth (horizontal rotation) is assumed to be the Y component in Euler angles.
+    // --- Monkey Patch: Throttled Damping on Azimuth Rotation ---
+    let throttleCounter = 0;
+    const throttleDelta = 2; // Apply azimuth clamping every 2 frames.
     const { Quaternion } = SPLAT;
     const originalUpdate = controls.update.bind(controls);
     controls.update = () => {
       originalUpdate();
-      // Convert current rotation to Euler angles.
+      throttleCounter++;
+      if (throttleCounter % throttleDelta !== 0) return;
+      
+      // If azimuth limits are not effectively set, skip extra work.
+      if (minAzimuth <= -360 && maxAzimuth >= 360) return;
+      
+      const minAzimuthRad = (minAzimuth * Math.PI) / 180;
+      const maxAzimuthRad = (maxAzimuth * Math.PI) / 180;
+      const threshold = 0.2; // threshold (in radians) for damping
+
+      // Convert the current camera rotation (Quaternion) to Euler angles.
       let euler = camera.rotation.toEuler();
-      // Convert the azimuth limits from degrees to radians.
-      let minAzimuthRad = (minAzimuth * Math.PI) / 180;
-      let maxAzimuthRad = (maxAzimuth * Math.PI) / 180;
-      // Clamp the horizontal angle (euler.y).
-      euler.y = Math.min(Math.max(euler.y, minAzimuthRad), maxAzimuthRad);
-      // Update the camera rotation based on the clamped Euler.
+
+      // Compute the clamped target for azimuth (assumed on Y axis).
+      const clampedY = Math.min(Math.max(euler.y, minAzimuthRad), maxAzimuthRad);
+
+      // Compute damping factor when near the limits.
+      let damping = 1; // default: no damping
+      if (euler.y < minAzimuthRad + threshold) {
+        damping = (euler.y - minAzimuthRad) / threshold;
+      } else if (euler.y > maxAzimuthRad - threshold) {
+        damping = (maxAzimuthRad - euler.y) / threshold;
+      }
+      damping = Math.max(0, Math.min(1, damping));
+
+      // Blend current azimuth with the clamped target.
+      euler.y = damping * euler.y + (1 - damping) * clampedY;
+
+      // Update the camera rotation with the modified Euler angles.
       camera.rotation = Quaternion.FromEuler(euler);
     };
 
@@ -319,11 +340,6 @@
     initialCameraRotation = camera.rotation.clone();
 
     canvas.style.background = "#FEFEFD";
-    controls.maxZoom = maxZoom;
-    controls.minZoom = minZoom;
-    controls.minAngle = minAngle;
-    controls.maxAngle = maxAngle;
-
     controls.update();
 
     try {