Servizio di transizione della scena - MRTK2

Questa estensione semplifica l'attività di sbiadire una scena, visualizzando un indicatore di stato, caricando una scena, quindi sbiadando.

Le operazioni della scena sono guidate dal servizio SceneSystem, ma qualsiasi operazione basata su attività può essere usata per eseguire una transizione.

Abilitazione dell'estensione

Per abilitare l'estensione, aprire il profilo RegisteredServiceProvider. Fare clic su Registra un nuovo provider di servizi per aggiungere una nuova configurazione. Nel campo Tipo componente selezionare SceneTransitionService. Nel campo Profilo di configurazione selezionare il profilo di transizione della scena predefinito incluso nell'estensione.

Opzioni profilo

Usare l'indicatore di stato predefinito

Se selezionato, il prefab dell'indicatore di stato predefinito verrà usato quando non viene fornito alcun oggetto indicatore di stato quando viene chiamato DoSceneTransition. Se viene fornito un oggetto indicatore di stato, il valore predefinito verrà ignorato.

Usare il colore di dissolvenza

Se selezionata, il servizio di transizione applicherà una dissolvenza durante la transizione. Questa impostazione può essere modificata in fase di esecuzione tramite la proprietà del UseFadeColor servizio.

Colore di fade

Controlla il colore dell'effetto di dissolvenza. Alfa viene ignorato. Questa impostazione può essere modificata in fase di esecuzione prima di una transizione tramite la proprietà del FadeColor servizio.

Destinazioni di fade

Controlla quali telecamere avranno un effetto di dissolvenza applicato a loro. Questa impostazione può essere modificata in fase di esecuzione tramite la proprietà del FadeTargets servizio.

Impostazione	Telecamere mirate
Principale	Applica l'effetto di dissolvenza alla fotocamera principale.
Interfaccia utente	Applica l'effetto di dissolvenza alle fotocamere sul livello dell'interfaccia utente. (Non influisce sull'interfaccia utente di sovrapposizione)
Tutti	Si applica alle fotocamere principali e dell'interfaccia utente.
Personalizzato	Si applica a un set personalizzato di telecamere fornite tramite SetCustomFadeTargetCameras

Fade out time/fade in time

Impostazioni predefinite per la durata di una dissolvenza durante l'immissione o l'uscita da una transizione. Queste impostazioni possono essere modificate in fase di FadeOutTime esecuzione tramite le proprietà e FadeInTime del servizio.

Tipo di fader della fotocamera

Classe ICameraFader da usare per applicare un effetto di dissolvenza alle fotocamere. La classe predefinita CameraFaderQuad crea un'istanza di un quad con un materiale trasparente davanti alla fotocamera di destinazione vicino al piano di clip. Un altro approccio potrebbe essere quello di usare un sistema post effetti.

Uso dell'estensione

Si usa il servizio di transizione passando attività eseguite mentre la fotocamera viene disattivata.

Uso delle attività del sistema della scena

Nella maggior parte dei casi si usano attività fornite dal servizio 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")
        );
}

Uso di attività personalizzate

In altri casi è possibile eseguire una transizione senza caricare effettivamente una scena:

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
}

In alternativa, è possibile caricare una scena senza usare il servizio 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();
    }
}

Uso di più attività

È anche possibile fornire più attività, che verranno eseguite in ordine:

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;
}

Uso dell'indicatore di stato

Un indicatore di stato è qualsiasi elemento che implementa l'interfaccia IProgressIndicator . Ciò può assumere la forma di una schermata iniziale, un indicatore di caricamento tagalong 3D o qualsiasi altro elemento che fornisce commenti e suggerimenti sullo stato di avanzamento della transizione.

Se UseDefaultProgressIndicator viene archiviato nel profilo SceneTransitionService, verrà creata un'istanza di un indicatore di stato quando inizia una transizione. Per la durata della transizione, è possibile accedere alle proprietà e all'indicatore Progress tramite i metodi e SetProgressMessage del servizioSetProgressValue.Message

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();
    }
}

In alternativa, quando si chiama DoSceneTransition è possibile fornire il proprio indicatore di avanzamento tramite l'argomento facoltativo progressIndicator . Verrà eseguito l'override dell'indicatore di stato predefinito.