如何使用多个枚举（两个枚举）来控制对象同时旋转的两个轴？

Question

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Rotate : MonoBehaviour
{
    public enum Axistorotate { Back, Down, Forward, Left, Right, Up, Zero };
    public Vector3[] vectorAxises = new Vector3[7];

    public Axistorotate[] myAxis;
    public float angle;
    public float speed;

    private bool stopRotation = true;

    // Start is called before the first frame update
    void Start()
    {
        vectorAxises[0] = Vector3.back;
        vectorAxises[1] = Vector3.down;
        vectorAxises[2] = Vector3.forward;
        vectorAxises[3] = Vector3.left;
        vectorAxises[4] = Vector3.right;
        vectorAxises[5] = Vector3.up;
        vectorAxises[6] = Vector3.zero;

        StartCoroutine(RotateObject());
    }

    public Vector3 GetAxis(Axistorotate axis)
    {
        return vectorAxises[(int)axis];
    }

    // Update is called once per frame
    void Update()
    {
        if(Input.GetKeyDown(KeyCode.S))
        {
            stopRotation = false;
        }

        if (Input.GetKeyDown(KeyCode.C) && stopRotation == false)
        {
            stopRotation = true;
            StartCoroutine(RotateObject());
        }
    }

    IEnumerator RotateObject()
    {
        while (stopRotation == true)
        {
            for (int i = 0; i < myAxis.Length; i++)
            {
                transform.Rotate(GetAxis(myAxis[i]), angle);
            }
            yield return new WaitForSeconds(speed);
        }
    }
}

For some reason while the game is running and I'm changing one of the enums to forward or back or down each time it's rotating another direction. If I'm starting when both enums on back states and then changing one of them to down it looks like it's rotating to the left or right and then when changing back to back it's not rotating like it was when they were both set to back.

How can I update the vectorAxises array in real time while the game is running to show in the Inspector the current axis state for example : vectorAxises[0] -> 1, 0, -1 ..... vectorAxises[7] -> 0,-1, 0 I want that when I'm changing one of the enums that it will show it on the vectorAxises.

Maybe I need to create another vectorAxises array one for each enum ?

And maybe when doing two myAxis it's changing the same one the same angle so it's not realy two enums that change individual axis ?

Answer 1

Use Quaternions for multiple rotations at the same time:

Quaternion rotationQuaternion = Quaternion.identity;
for (int i = 0; i < myAxis.Length; i++)
{
    rotationQuaternion *= Quaternion.AngleAxis(angle, GetAxis(myAxis[i]));
}
transform.rotation *= rotationQuaternion;

It should fix your problem with wrong rotations

Answer 2

transform.Rotate has an optional parameter

relativeTo
Determines whether to rotate the GameObject either locally to the GameObject or relative to the Scene in world space.

which by default is Space.Self .

So your

transform.Rotate(GetAxis(myAxis[i]), angle);

is always done in the local coordinate system of the GameObject. This local system is rotated along with the GameObject so the local transform.up , transform.forward etc axis change all the time.

---

Instead make it rotate around world axis

transform.Rotate(GetAxis(myAxis[i]), angle, Space.World);

---

How can I update the vectorAxises array in real time while the game is running to show in the Inspector the current axis state

This should already be the case. Or do you mean you want to see the currently "selected" value. You should use Debugging and Breakpoints for that. Since you do

for (int i = 0; i < myAxis.Length; i++)
{
    transform.Rotate(GetAxis(myAxis[i]), angle);
}

without any further yield return the object will directly "jump" into the new rotation and in the inspector you would always only see the last GetAxis(myAxis[i]) .

If you are looking for a smooth rotation then checkout Dest's answer slightly modified you could eg let the object rotate within 1 second

while (stopRotation == true)
{
    // calculate the target rotation
    Quaternion rotationQuaternion = Quaternion.identity;
    for (int i = 0; i < myAxis.Length; i++)
    {
        rotationQuaternion *= Quaternion.AngleAxis(angle, GetAxis(myAxis[i]));
    }

    // before starting to rotate store initial and target rotation
    var initialRotation = transform.rotation;
    var targetRotation = initialRotation * rotationQuaternion;

    // could also get this from the Inspector e.g.
    var rotationDuration = 1;

    // Do a smooth rotation from the initial to target rotation
    // within the defined rotationDuration 
    var timePassed = 0f;
    do
    {
        // additionally ease-in and -out the rotation
        var lerpFactor = Mathf.SmoothStep(0, 1, timePassed / rotationDuration);
        transform.rotation = Quaternion.Slerp(initialRotation, targetRotation, lerpFactor);

        timePassed += Time.deltaTime;

        // let this state be rendered
        yield return null;
    } while(timePassed < rotationDuration);

    // if you still want the pause 
    yield return new WaitForSeconds(speed);
}

---

Just out of curiosity: Why even use an enum here? Couldn't you directly iterate through the vectorAxises index instead and only add those entries you will be using?