//Essa é a função origem, Um controllador que deve ser trancado e executar uma árvore de ações que vão ramificando...
    //Minha intenção era pra ele esperar que todos os nodos fossem completos pra seguir a execução
    //Essa função é chamada por um botão na UI, usando a classe Button da unity mesmo, cadastrada no OnClick pelo Editor
     public async void PlayLevel()
    {
        if (!@lock)
        {
            @lock = true;

            SpriteSceneController sceneController = transform.GetChild(0).GetComponent<SpriteSceneController>();


            // Pra exemplificar, esse seria um uso que gostaria de fazer, embaixo segue a função CanvasController.Singleton.FadeOut()
            Task.WaitAll(CanvasController.Singleton.FadeOut(), cameraController.SetCameraContext(Context.INGAME, sceneController.LinkedVase));
            await CanvasController.Singleton.SwitchContext(Context.INGAME);

            sceneController.StartLevel();
            InputController.Singleton.Initialize(cameraController.MainCamera, sceneController.GetComponent<VaseRendererController>().GetTranslatedUVPosition);

            @lock = false;
        }
    }



    public async Task FadeOut()
    {
        switch (context)
        {
            case Context.INGAME:
            case Context.MAIN_MENU:
            case Context.LVL_SELECTION:
                Image[] fadeImages;
                SpriteAnimator[] animators;
                SplitFadeAndAnimation(GetComponentsInChildren<Image>(), out fadeImages, out animators);


                //Nesse contexto eu gostaria de disparar duas corrotinas "AsyncWaitFade" e "AsyncWaitAnimationOnAnimators"
                //Vou seguir só o caminho da AsyncWaitFade que é onde tranca, e é, em princípio, a mesma ideia da outra corrotina
                Task.WaitAll(AsyncWaitFade(fadeImages, false), AsyncWaitAnimationOnAnimators(animators, StringTable.FadeOut));

                break;
            case Context.FOCUS:
                await GetComponentInChildren<ScrollController>().SetActiveRoutine(false);
                //yield return GetComponentInChildren<ScrollController>().Close();
                break;
            case Context.OFF:
            default:
                await Task.CompletedTask;
                break;
        }

        SetContext(Context.OFF);

    }

    async Task AsyncWaitFade(Image[] images, bool fadeIn)
    {
        //Aqui que eu acho que estou errando, o que queria era "converter" a corrotina e uma task, pra poder usar o Task.WaitAll
        await FadeImagesRoutine(images, fadeIn);
    }



    // E essa aqui é a corrotina, que é só um fade nas imagens fornecidas.
    Enumerator FadeImagesRoutine(Image[] images, bool fadeIn)
    {
        if (images.Length > 0)
        {
            WaitForEndOfFrame wait = new WaitForEndOfFrame();
            AnimationCurve curve = AnimationCurve.EaseInOut(1f, 1f, 0f, 0f);
            float deltaScaler = 1f / 0.3f;
            float timer = 0;
            float eval;
            Color color;
            do
            {
                timer += Time.deltaTime * deltaScaler;
                eval = fadeIn ? curve.Evaluate(timer) : 1f - curve.Evaluate(timer);
                for (int i = 0; i < images.Length; i++)
                {
                    color = images[i].color;
                    color.a = eval;
                    images[i].color = color;
                }
                yield return new WaitForEndOfFrame();
            } while (timer < 1f);
        }
        else
        {
            yield return null;
        }
    }