Rotate object always at same speed on screen, no matter camera distance?

Question

I am rotating a globe like XCOM's hologlobe,

I rotate it using Quaternion.RotateTowards(Quaternion from, Quaternion to, float maxDegreesDelta).

I found a good value for maxDegreesDelta, in my case it is 5.0f.

There is a limit on how close or far the camera can be, let's assume clos is 1.0f and far is 2.0f.

I want to be able to zoom into the globe, but obviously when I do, it rotates a bit too fast then.

When zoomed out, rotation speed is satisfying:

When zoomed in, rotation is too fast, making it more difficult to manipulate:

And the problem is even more evident as game view size gets bigger, i.e. fullscreen.

Using Mathf.Lerp and Mathf.InverseLerp, I've tried to make maxDegreesDelta and mouse delta proportional to the distance the camera is but it's hardly convincing.

Note: I rotate the globe, not the camera.

Question:

How can I ensure object rotates at same speed on screen, no matter how close or far camera is ?

Code:

(assumes there is a sphere of radius 0.5 at Vector3.zero and camera is positioned at Vector3.back)

using UnityEngine;
using UnityEngine.InputSystem;

namespace Test2
{
    public class GeoScapeController : MonoBehaviour
    {
        #region Public

        public Transform TargetObject;

        public Camera TargetCamera;

        [Range(0.01f, 1.0f)]
        public float Sensitivity;

        public bool Smooth;

        public float ZoomDistanceMin;

        public float ZoomDistanceMax;

        #endregion

        #region Private

        [SerializeField]
        [HideInInspector]
        private Quaternion TargetRotation;

        [SerializeField]
        [HideInInspector]
        private int ZoomLevel;

        [SerializeField]
        [HideInInspector]
        private int ZoomLevels;

        [SerializeField]
        [HideInInspector]
        private Vector3 ZoomVector;

        [SerializeField]
        [HideInInspector]
        private Vector3 ZoomVelocity;

        private void Reset()
        {
            Sensitivity = 0.05f;
            Smooth = true;

            ZoomDistanceMin = 0.625F;
            ZoomDistanceMax = 1.25F;
            ZoomLevels = 10;
        }

        private void Start()
        {
            TargetRotation = Quaternion.LookRotation(TargetObject.forward, TargetObject.up);
            ZoomVector = TargetCamera.transform.position;
        }

        private void Update()
        {
            var mouse = Mouse.current;
            var delta = mouse.delta.ReadValue();
            var scale = new Vector4(-1.0f, +1.0f, +1.0f);

            var x = mouse.leftButton.isPressed ? delta.y * scale.y * Sensitivity : 0.0f;
            var y = mouse.leftButton.isPressed ? delta.x * scale.x * Sensitivity : 0.0f;
            var z = mouse.middleButton.isPressed ? delta.x * scale.z * Sensitivity : 0.0f;
            var r = Quaternion.AngleAxis(x, Vector3.right) *
                    Quaternion.AngleAxis(y, Vector3.up) *
                    Quaternion.AngleAxis(z, Vector3.forward);

            if (Smooth) // hopefully, quaternion limits won't be crossed !
            {
                TargetRotation = Quaternion.RotateTowards(TargetRotation, r * TargetRotation, 2.5f);

                TargetObject.rotation = Quaternion.Slerp(TargetObject.rotation, TargetRotation, Time.deltaTime * 5.0f);
            }
            else
            {
                TargetObject.rotation = TargetRotation = r * TargetRotation;
            }

            var wheel = (int) mouse.scroll.ReadValue().y / 120;
            if (wheel != 0)
            {
                ZoomLevel = Mathf.Clamp(ZoomLevel + wheel, 0, ZoomLevels);
                var lerp1 = Mathf.InverseLerp(ZoomLevels, 0, ZoomLevel);
                var lerp2 = Mathf.Lerp(ZoomDistanceMin, ZoomDistanceMax, lerp1);
                ZoomVector = Vector3.back * lerp2;
            }

            TargetCamera.transform.position = Smooth
                ? Vector3.SmoothDamp(TargetCamera.transform.position, ZoomVector, ref ZoomVelocity, 0.3f)
                : ZoomVector;
        }

        #endregion
    }
}

Answer 1

This is my solution, Google Earth like control with smooth animation (or not), when zoomed in it is user friendly and slows panning down.

The only thing I am not satisfied about is the quaternion slerp, at these defaults there won't be any sudden jumps but I would have loved to understand how to sub-interpolate quaternions so it works even when rotating very fast.

Also the other thing is speed is different when at fullscreen but it should be reasonably easy to address that.

Right now however it is quite satisfying.

Feel free to improve and sharing improvements are welcome !

using UnityEngine;
using UnityEngine.InputSystem;

namespace Test2
{
    public class GeoScapeController : MonoBehaviour
    {
        #region Public

        public Transform Target;

        public Camera Camera;

        [Range(0.01f, 1.0f)]
        public float MouseSensitivity = 0.01f;

        public bool Smooth = true;

        [Range(0.1f, 90.0f)]
        public float RotationMaxDelta = 5.0f;

        [Range(0.1f, 90.0f)]
        public float RotationSpeed = 5.0f;

        [Range(2, 100)]
        public int ZoomGrain = 20;

        [Range(1, 100)]
        public float ZoomSpeed = 20.0f;

        [Range(1.0f, 100.0f)]
        public float ZoomMin = 10.0f;

        [Range(1.0f, 100.0f)]
        public float ZoomMax = 60.0f;

        #endregion

        #region Private

        [SerializeField]
        [HideInInspector]
        private Quaternion Rotation;

        [SerializeField]
        [HideInInspector]
        private float Zoom;

        [SerializeField]
        [HideInInspector]
        private int ZoomSlot;

        [SerializeField]
        [HideInInspector]
        private float ZoomVelocity;

        private void Start()
        {
            Rotation = Quaternion.LookRotation(Target.forward, Target.up);
        }

        private void Update()
        {
            var mouse = Mouse.current;

            var position = mouse.position.ReadValue();
            if (position.x >= 0.0f && position.y >= 0.0f && position.x < Screen.width && position.y < Screen.height)
            {
                var d = mouse.delta.ReadValue();
                var n = new Vector3(-1.0f, +1.0f, +1.0f);
                var m = Zoom / ZoomMax * RotationMaxDelta;
                var s = MouseSensitivity * m;
                var x = mouse.leftButton.isPressed ? d.y * n.y * s : 0.0f;
                var y = mouse.leftButton.isPressed ? d.x * n.x * s : 0.0f;
                var z = mouse.middleButton.isPressed ? d.x * n.z * s : 0.0f;
                var r = Quaternion.AngleAxis(x, Vector3.right) *
                        Quaternion.AngleAxis(y, Vector3.up) *
                        Quaternion.AngleAxis(z, Vector3.forward);

                Rotation = Smooth
                    ? Quaternion.RotateTowards(Rotation, r * Rotation, m)
                    : r * Rotation;

                var wheel = (int) mouse.scroll.ReadValue().y / 120;
                ZoomSlot = Mathf.Clamp(ZoomSlot + wheel, 1, ZoomGrain);

                var lerp = Mathf.InverseLerp(1, ZoomGrain, ZoomSlot);
                Zoom = Mathf.Lerp(ZoomMax, ZoomMin, lerp);
            }

            Target.rotation = Smooth
                ? Quaternion.Slerp(Target.rotation, Rotation, Time.deltaTime * RotationSpeed)
                : Rotation;

            Camera.fieldOfView = Smooth
                ? Mathf.SmoothDamp(Camera.fieldOfView, Zoom, ref ZoomVelocity, Time.deltaTime * ZoomSpeed)
                : Zoom;
        }

        #endregion
    }
}

Previously this zoom level used to be very difficult to navigate, now it's much better:

Answer 2

Here's an alternative approach: scale your mouse delta down if you zoom in and up if you zoom out. Now my math is a bit rusty, so I am not 100% sure, but I think if you just lerp between whatever speed that "looks" right at max and min zoom, you should achieve something that looks right all the way.