Servizio di transizione della scena - MRTK2

Questa estensione semplifica l'attività di dissolvenza di una scena, la visualizzazione di un indicatore di stato, il caricamento di una scena e la dissolvenza.

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 del profilo

Usare l'indicatore di stato predefinito

Se selezionato, il prefab indicatore di stato predefinito verrà utilizzato 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.

Usa colore 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 dissolvenza

Controlla il colore dell'effetto 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 dissolvenza in dissolvenza

Controlli a cui le fotocamere avranno un effetto di dissolvenza applicato. Questa impostazione può essere modificata in fase di esecuzione tramite la proprietà del FadeTargets servizio.

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

Timeout dissolvenza/dissolvenza nel tempo

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

Fotocamera tipo fader

Classe ICameraFader da utilizzare per applicare un effetto 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 ritaglio. Un altro approccio potrebbe essere quello di usare un sistema di post-effetti.

Uso dell'estensione

Per usare il servizio di transizione, passare attività eseguite mentre la fotocamera è in dissolvenza.

Uso delle attività del sistema della scena

Nella maggior parte dei casi si usano le 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 specificare 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 . Questo può assumere la forma di una schermata iniziale, un indicatore di caricamento tagalong 3D o qualsiasi altro elemento che fornisca feedback sullo stato di avanzamento della transizione.

Se UseDefaultProgressIndicator è archiviato nel profilo SceneTransitionService, all'avvio di una transizione verrà creata un'istanza di un indicatore di stato. Per la durata della transizione, è possibile accedere alle proprietà e Message di Progress questo indicatore tramite i metodi e SetProgressMessage di SetProgressValue tale servizio.

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 un indicatore di stato personalizzato tramite l'argomento facoltativo progressIndicator . Verrà eseguito l'override dell'indicatore di stato predefinito.