Is there a better way to calculate the direction of a rolling ball in order to make the camera follow it?

Question

Currently I'm using a normalized rb velocity to get the x and z velocity directions in order to compare it with eulerAngles of the camera in order to tell the camera which way to spin. But I'm doing this inside a bunch of nested if statements and it just feels.... wrong. For actually following the ball I just have parent child relationships with Player -> RotatorObject -> Camera, so rotating the RotatorObject rotates around the center of the player.

Here is an example of what I'm currently doing.

// Velocity direction of the ball
Vector3 VelNormed = Vector3.Normalize(rb.velocity);
xVelNormed = VelNormed.x;
zVelNormed = VelNormed.z;

// Current CameraRotationObject angle
yEuler = transform.eulerAngles.y;
zEuler = transform.eulerAngles.z;

// If Moving forwards.
        if (zVelNormed >= 0.5)
        {
            // If camera is within hoped for range. (270 is camera = perfectly forwards)
            if (yEuler >= 260 && yEuler <= 280)
            {
                // Move camera to the right.
                if (yEuler >= 260 && yEuler <= 270)
                {
                    // Rotate camera right
                    transform.Rotate(0, (speed * Time.deltaTime) * 1, 0);
                }
                else if (yEuler <= 280 && yEuler >= 270)
                {
                    // Rotate camera left
                    transform.Rotate(0, (speed * Time.deltaTime) * -1, 0);
                }
                else
                {

                }
            }
            
        }
        // If Moving backwards.
        else if (zVelNormed <= -0.5)
        {
                    //etc.
        }

Like I said before, using all of these if statements like this makes me feel like a monster! IE. I'm almost sure I'm doing this the old computer programming for dummies way

Answer 1

First of all the eulerAngles are very rarely what you want to use

When you read the .eulerAngles property, Unity converts the Quaternion's internal representation of the rotation to Euler angles. Because, there is more than one way to represent any given rotation using Euler angles, the values you read back out may be quite different from the values you assigned. This can cause confusion if you are trying to gradually increment the values to produce animation.

Why do you actually need to make the camera spin at all? It sounds to me like your main issue actually origins in the camera being somewhere nested as child below the rolling ball.

You should rather extract the camera into scene root level and make it follow the ball via code like e.g.

public class CameraFollow : MonoBehaviour
{
    // Interpolation factors for the position and rotation
    [Range(0, 1)] public float moveInterpolationFactor = 5f;
    [Range(0, 1)] public float rotateInterpolationFactor = 5f;

    // The target this object shall follow 
    [SerializeField] Rigidbody targetObject;

    // Positional offset in the movement direction of the target object
    // e.g. (0,0, -1) will keep the camera 1 world space unit behind the move direction
    public Vector3 positionOffset = new Vector3(0, 0.25f, -1);

    private Vector3 targetPosition;
    private Quaternion targetRotation;

    private void Awake ()
    {
        if(!targetObject) return;

        UpdateTargetValues();
    }

    private void UpdateTargetValues ()
    {
        targetPosition = targetObject.position + targetObject.rotation * positionOffset;
        targetRotation = Quaternion.LookRotation(targetObject.velocity);
    }

    private void LateUpdate ()
    {
        // If there is no target stay where you are
        if(!targetObject) return;

        // Get the move velocity since we want to follow based 
        // on the move direction, not the objects orientation
        var velocity = targetObject.velocity;

        // If not moving simply continue moving to the last set position
        // otherwise update the target values
        if(velocity.sqrMagnitude > 0)
        {
            UpdateTargetValues ();
        }

        transform.position = Vector3.Slerp(transform.position, targetPosition, moveInterpolationFactor * Time.deltaTime);
        transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, rotateInterpolationFactor * Time.deltaTime);
    }

    public void SetTarget(Rigidbody target)
    {
        targetObject = target;

        if(!targetObject) return;

        UpdateTargetValues ();
    }
}