Accelerate rotation from 0 to x angle in x seconds in Unity

Question

This is more of a math question than a coding question. I would like to reach for example an rotation angle of 90 in 1 second while speed is accelerating at constant value. My current version takes 1.4 seconds to reach the desired rotation angle, and it should reach it in 1 second. I believe that the reason for that is that it currently accelerates to speed of 90 in 1 second and not to rotation angle of 90. Since I am not that good in math, I have no idea how I need to adjust the acceleration calculation. I am unable to find any solution to this.

NOTE: I need to adjust the rotation angles manually, I am not able to use any existing functions, like for example transform.Rotate(), since in my complete version the rotation direction can change at any time and the rotation also has deceleration value.

This is a very simplified version of what I have (it only rotates the z axis to one direction and runs once on start):

private float accelerationInSeconds = 1;
private float targetAngle = 90f;

private float speed = 0;
private float axis = 1;
private bool rotate = true;
private float acceleration;

void Start() {
    // Calculate acceleration (this calculation should be changed)
    acceleration = targetAngle / accelerationInSeconds;
}
 
void Update() {
    if (rotate) {
        // Accelerate
        speed += axis * (acceleration * Time.deltaTime);
 
        // Calculate next rotation position
        Vector3 rotationVector = transform.rotation.eulerAngles;
        rotationVector.z += speed * Time.deltaTime;
 
        // Rotate object
        transform.rotation = Quaternion.Euler(rotationVector);
 
        // Check if rotation has gone over the target angle
        if (rotationVector.z >= targetAngle) {
            rotationVector.z = targetAngle;
            speed = 0;
            rotate = false;
        }
    }
}

Thanks in advance for anyone who can help!

EDIT: Modified code to be more efficient. I can't use RotateTowards() since in my complete code I need to clamp the rotation between targetAngle and negative targetAngle. Hopefully this code is more efficient and performance friendly. But I still have not found a solution for my original math related question, which was the whole point of this question.

private float accelerationInSeconds = 1;
private float targetAngle = 90f;

private float speed = 0;
private float angle = 0;
private float axis = 1;
private bool rotate = true;
private float acceleration;

void Start() {
    // Calculate acceleration (this calculation should be changed)
    acceleration = targetAngle / accelerationInSeconds;
}

void Update() {
    if (rotate) {
        // Accelerate
        speed += axis * (acceleration * Time.deltaTime);

        // Calculate next rotation position
        angle += speed * Time.deltaTime;

        // Check if rotation has gone over the target angle
        if (angle >= targetAngle) {
            angle = targetAngle;
            speed = 0;
            rotate = false;
        }

        // Rotate object
        transform.rotation = Quaternion.AngleAxis(angle, Vector3.forward);
    }
}

Answer 1

As was suggested before I would use a Coroutine. Coroutines are like temporary Update methods and often easier to control and maintain than doing stuff directly in Update.

// Flag to avoid concurrent routines
private bool isRotating;

public void Rotate(float targetAngle, float duration)
{
    if(! isRotating) StartCoroutine (RotateRoutine(targetAngle, duration));
}

private IEnumerator RotateRoutine (float targetAngle, float duration)
{
    // Just to be sure
    if(isRotating) yield break;

    // block concurrent routines
    isRotating = true;

    // Pre-calculate the start and end rotation
    var start = transform.rotation;
    var end = Quaternion.Euler(0, 0, targetAngle);

    var timePassed = 0f;
    while(timePassed < duration)
    {
        // This value will grow linear from 0 to 1 in exactly "duration" seconds
        var x = timePassed / duration;

        // TODO!
        var y = MAGIC;

        // Interpolate between the start and end rotation using given factor "y"
        transform.rotation = Quaternion.Lerp(start, end, y);


        // "pause" the routine here, render this frame
        // and continue from here in the next frame
        yield return null;

        // Increase by the time passed since last frame
        timePassed += Time.deltaTime;
    }

    // To be sure to end with clean values
    transform.rotation = end;

    // Allow next routine
    isRotating = false;
}

So what do we have to fill in for MAGIC?

Basically it can be any mathematical function that maps given input 0 to 1 to 0 to 1.

There are multiple possibilities.

1. What you currently ask for is a linear growing speed. That means the resulting movement shall be quadratic! So we already know the Formular

    var y = a * x * x + b;
   

   We further know from your code that speed always starts from 0 -> b = 0. And the last step is pretty straight forward:

   What value do we have to fill in so y goes from 0 to 1 at the same time that x goes from 0 to 1?

    1 = a * 1 * 1 + 0;
   

   => a = 1!

   So in your case it is simply

    var y = x * x;
   

2. If you also want ease-out you could also simply use Mathf.Smoothstep which automatically adds ease-in and ease-out

    var y = Mathf.SmoothStep(0, 1, x);
   

3. To make it even easier to control you could use an AnimationCurve and adjust the movement curve exactly to your needs in the Inspector

    [SerializeField] private AnimationCurve curve;
   

   The curve editor already comes with some preset curves like e.g. linear, logarithmic, exponential and eased-in/-out grow from 0 to 1!

   And then use AnimationCurve.Evaluate to get the value (y) in the routine for a given input time (x).

    var y = curve.Evaluate(x);
   

Answer 2

I finally figured it out, thanks to Math section in StackExchange.

So the simple answer is this:

acceleration = 2 * targetAngle / Mathf.Pow(accelerationInSeconds, 2);