Scenövergångstjänst – MRTK2

Det här tillägget förenklar arbetet med att ta bort en scen, visa en förloppsindikator, läsa in en scen och sedan tona in igen.

Scenåtgärder drivs av tjänsten SceneSystem, men alla aktivitetsbaserade åtgärder kan användas för att driva en övergång.

Aktivera tillägget

Om du vill aktivera tillägget öppnar du profilen RegisteredServiceProvider. Klicka på Registrera en ny tjänstleverantör för att lägga till en ny konfiguration. I fältet Komponenttyp väljer du SceneTransitionService. I fältet Konfigurationsprofil väljer du standardprofilen för scenövergång som ingår i tillägget.

Profilalternativ

Använd standardindikator för förlopp

Om den är markerad används standardförloppsindikatorns prefab när inget förloppsindikatorobjekt anges när du anropar DoSceneTransition. Om ett förloppsindikatorobjekt anges ignoreras standardinställningen.

Använd toningsfärg

Om det här alternativet är markerat kommer övergångstjänsten att använda en toning under övergången. Den här inställningen kan ändras vid körning via tjänstens UseFadeColor egenskap.

Tona färg

Styr toningseffektens färg. Alpha ignoreras. Den här inställningen kan ändras vid körning före en övergång via tjänstens FadeColor egenskap.

Tona mål

Kontrollerar vilka kameror som kommer att ha en toningseffekt som tillämpas på dem. Den här inställningen kan ändras vid körning via tjänstens FadeTargets egenskap.

Inställningen	Riktade kameror
Main	Tillämpar toningseffekt på huvudkameran.
UI	Tillämpar toningseffekt på kameror i användargränssnittsskiktet. (Påverkar inte överläggsgränssnittet)
Alla	Gäller för både huvudkameror och UI-kameror.
Anpassat	Gäller för en anpassad uppsättning kameror som tillhandahålls via SetCustomFadeTargetCameras

Tona ut tid/tona ut i tid

Standardinställningar för varaktigheten för en toning när du anger/avslutar en övergång. De här inställningarna kan ändras vid körning via tjänstens FadeOutTime och FadeInTime egenskaperna.

Kamera fader typ

Vilken klass som ICameraFader ska användas för att tillämpa en toningseffekt på kameror. CameraFaderQuad Standardklassen instansierar en quad med ett transparent material framför målkameran nära klippplanet. En annan metod kan vara att använda ett posteffektsystem.

Använda tillägget

Du använder övergångstjänsten genom att skicka uppgifter som körs medan kameran är urkopplad.

Använda scensystemuppgifter

I de flesta fall använder du uppgifter som tillhandahålls av tjänsten 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")
        );
}

Använda anpassade uppgifter

I andra fall kanske du vill utföra en övergång utan att faktiskt läsa in en scen:

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
}

Eller så kanske du vill läsa in en scen utan att använda tjänsten 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();
    }
}

Använda flera uppgifter

Du kan också ange flera uppgifter som ska köras i ordning:

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

Använda förloppsindikatorn

En förloppsindikator är allt som implementerar IProgressIndicator gränssnittet. Detta kan ha formen av en välkomstskärm, en 3D-tagalong-inläsningsindikator eller något annat som ger feedback om övergångsförloppet.

Om UseDefaultProgressIndicator kontrolleras i profilen SceneTransitionService instansieras en förloppsindikator när en övergång påbörjas. Under övergångens varaktighet kan den här indikatorns Progress och Message egenskaperna nås via tjänstens SetProgressValue och SetProgressMessage metoderna.

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

Du kan också ange en egen förloppsindikator via det valfria progressIndicator argumentet när du anroparDoSceneTransition. Detta åsidosätter standardindikatorn för förlopp.