Service de transition de scène — MRTK2

Cette extension simplifie l’activité de l’effacement d’une scène, de l’affichage d’un indicateur de progression, du chargement d’une scène, puis de l’effacement de nouveau.

Les opérations de scène sont pilotées par le service SceneSystem, mais toute opération basée sur une tâche peut être utilisée pour piloter une transition.

Activation de l’extension

Pour activer l’extension, ouvrez votre profil RegisteredServiceProvider. Cliquez sur Inscrire un nouveau fournisseur de services pour ajouter une nouvelle configuration. Dans le champ Type de composant, sélectionnez SceneTransitionService. Dans le champ Profil de configuration, sélectionnez le profil de transition de scène par défaut inclus avec l’extension.

Options de profil

Utiliser l’indicateur de progression par défaut

Si cette option est activée, le préfabriqué d’indicateur de progression par défaut est utilisé lorsqu’aucun objet indicateur de progression n’est fourni lors de l’appel DoSceneTransition. Si un objet indicateur de progression est fourni, la valeur par défaut est ignorée.

Utiliser la couleur de fondu

Si cette option est activée, le service de transition applique un fondu pendant votre transition. Ce paramètre peut être modifié au moment de l’exécution via la propriété du UseFadeColor service.

Couleur de fondu

Contrôle la couleur de l’effet de fondu. Alpha est ignoré. Ce paramètre peut être modifié au moment de l’exécution avant une transition via la propriété du FadeColor service.

Fondu des cibles

Contrôle les caméras auxquelles un effet de fondu est appliqué. Ce paramètre peut être modifié au moment de l’exécution via la propriété du FadeTargets service.

Temps de fondu/fondu dans le temps

Paramètres par défaut pour la durée d’un fondu lors de l’entrée/sortie d’une transition. Ces paramètres peuvent être modifiés au moment de l’exécution via les propriétés et FadeInTime du FadeOutTime service.

Type de fader de l’appareil photo

Classe ICameraFader à utiliser pour appliquer un effet de fondu aux caméras. La classe par défaut CameraFaderQuad instancie un quad avec un matériau transparent devant la caméra cible près du plan de clip. Une autre approche peut consister à utiliser un système de post-effets.

Utilisation de l’extension

Vous utilisez le service de transition en transmettant les tâches exécutées pendant que la caméra est éteinte.

Utilisation des tâches système de scène

Dans la plupart des cas, vous utiliserez les tâches fournies par le service SceneSystem :

private async void TransitionToScene()
{
    IMixedRealitySceneSystem sceneSystem = MixedRealityToolkit.Instance.GetService<IMixedRealitySceneSystem>();
    ISceneTransitionService transition = MixedRealityToolkit.Instance.GetService<ISceneTransitionService>();

    // Fades out
    // Runs LoadContent task
    // Fades back in
    await transition.DoSceneTransition(
            () => sceneSystem.LoadContent("TestScene1")
        );
}

Utilisation de tâches personnalisées

Dans d’autres cas, vous pouvez effectuer une transition sans charger réellement de scène :

private async void TransitionToScene()
{
    ISceneTransitionService transition = MixedRealityToolkit.Instance.GetService<ISceneTransitionService>();

    // Fades out
    // Resets scene
    // Fades back in
    await transition.DoSceneTransition(
            () => ResetScene()
        );
}

private async Task ResetScene()
{
    // Go through all enemies in the current scene and move them back to starting positions
}

Vous pouvez également charger une scène sans utiliser le service SceneSystem :

private async void TransitionToScene()
{
    ISceneTransitionService transition = MixedRealityToolkit.Instance.GetService<ISceneTransitionService>();

    // Fades out
    // Loads scene using Unity's scene manager
    // Fades back in
    await transition.DoSceneTransition(
            () => LoadScene("TestScene1")
        );
}

private async Task LoadScene(string sceneName)
{
    AsyncOperation asyncOp = SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);
    while (!asyncOp.isDone)
    {
        await Task.Yield();
    }
}

Utilisation de plusieurs tâches

Vous pouvez également fournir plusieurs tâches, qui seront exécutées dans l’ordre :

private async void TransitionToScene()
{
    IMixedRealitySceneSystem sceneSystem = MixedRealityToolkit.Instance.GetService<IMixedRealitySceneSystem>();
    ISceneTransitionService transition = MixedRealityToolkit.Instance.GetService<ISceneTransitionService>();

    // Fades out
    // Sets time scale to 0
    // Fades out audio to 0
    // Loads TestScene1
    // Fades in audio to 1
    // Sets time scale to 1
    // Fades back in
    await transition.DoSceneTransition(
            () => SetTimescale(0f),
            () => FadeAudio(0f, 1f),
            () => sceneSystem.LoadContent("TestScene1"),
            () => FadeAudio(1f, 1f),
            () => SetTimescale(1f)
        );
}

private async Task SetTimescale(float targetTime)
{
    Time.timeScale = targetTime;
    await Task.Yield();
}

private async Task FadeAudio(float targetVolume, float duration)
{
    float startTime = Time.realtimeSinceStartup;
    float startVolume = AudioListener.volume;
    while (Time.realtimeSinceStartup < startTime + duration)
    {
        AudioListener.volume = Mathf.Lerp(startVolume, targetVolume, Time.realtimeSinceStartup - startTime / duration);
        await Task.Yield();
       }
       AudioListener.volume = targetVolume;
}

Utilisation de l’indicateur de progression

Un indicateur de progression est tout ce qui implémente l’interface IProgressIndicator . Cela peut prendre la forme d’un écran de démarrage, d’un indicateur de chargement tagalong 3D ou de tout autre élément qui fournit des commentaires sur la progression de la transition.

Si UseDefaultProgressIndicator est activé dans le profil SceneTransitionService, un indicateur de progression est instancié au début d’une transition. Pendant la durée de la transition, les propriétés et Message de Progress cet indicateur sont accessibles via les méthodes et SetProgressMessage de SetProgressValue ce service.

private async void TransitionToScene()
{
    IMixedRealitySceneSystem sceneSystem = MixedRealityToolkit.Instance.GetService<IMixedRealitySceneSystem>();
    ISceneTransitionService transition = MixedRealityToolkit.Instance.GetService<ISceneTransitionService>();

    ListenToSceneTransition(sceneSystem, transition);

    await transition.DoSceneTransition(
            () => sceneSystem.LoadContent("TestScene1")
        );
}

private async void ListenToSceneTransition(IMixedRealitySceneSystem sceneSystem, ISceneTransitionService transition)
{
    transition.SetProgressMessage("Starting transition...");

    while (transition.TransitionInProgress)
    {
        if (sceneSystem.SceneOperationInProgress)
        {
            transition.SetProgressMessage("Loading scene...");
            transition.SetProgressValue(sceneSystem.SceneOperationProgress);
        }
        else
        {
            transition.SetProgressMessage("Finished loading scene...");
            transition.SetProgressValue(1);
        }

        await Task.Yield();
    }
}

En cas d’appel DoSceneTransition , vous pouvez également fournir votre propre indicateur de progression via l’argument facultatif progressIndicator . Cela remplacera l’indicateur de progression par défaut.