Serviço de transição de cenários – MRTK2

Esta extensão simplifica o negócio de desvanecer uma cena, apresentar um indicador de progresso, carregar uma cena e voltar a desaparecer.

As operações de cenário são impulsionadas pelo serviço SceneSystem, mas qualquer operação baseada em tarefas pode ser utilizada para conduzir uma transição.

Ativar a extensão

Para ativar a extensão, abra o perfil RegisteredServiceProvider. Clique em Registar um novo Fornecedor de Serviços para adicionar uma nova configuração. No campo Tipo de Componente, selecione CenaTransitionService. No campo Perfil de Configuração, selecione o perfil de transição de cenário predefinido incluído com a extensão.

Opções de perfil

Utilizar indicador de progresso predefinido

Se selecionada, a pré-base do indicador de progresso predefinida será utilizada quando não for fornecido nenhum objeto de indicador de progresso ao chamar DoSceneTransition. Se for fornecido um objeto de indicador de progresso, a predefinição será ignorada.

Utilizar cor de desvanecimento

Se estiver selecionado, o serviço de transição aplicará um desvanecimento durante a transição. Esta definição pode ser alterada no runtime através da propriedade do UseFadeColor serviço.

Cor de desvanecimento

Controla a cor do efeito de desvanecimento. Alfa é ignorado. Esta definição pode ser alterada no runtime antes de uma transição através da propriedade do FadeColor serviço.

Destinos de desvanecimento

Controla quais as câmaras que terão um efeito de desvanecimento aplicado às mesmas. Esta definição pode ser alterada no runtime através da propriedade do FadeTargets serviço.

Definições	Câmaras De Destino
Principal	Aplica o efeito de desvanecimento à câmara principal.
IU	Aplica o efeito de desvanecimento às câmaras na camada de IU. (Não afeta a IU de sobreposição)
Todos	Aplica-se às câmaras principais e de IU.
Personalizado	Aplica-se a um conjunto personalizado de câmaras fornecido através de SetCustomFadeTargetCameras

Tempo de desvanecimento/desvanecimento no tempo

Predefinições para a duração de um desvanecimento ao entrar/sair de uma transição. Estas definições podem ser alteradas no runtime através das propriedades e FadeInTime do FadeOutTime serviço.

Tipo de desvanecimento da câmara

Que ICameraFader classe utilizar para aplicar um efeito de desvanecimento às câmaras. A classe predefinida CameraFaderQuad instancia um quad com um material transparente em frente à câmara de destino perto do plano de recorte. Outra abordagem pode ser utilizar um sistema de efeitos pós-efeitos.

Utilizar a extensão

Pode utilizar o serviço de transição ao transmitir Tarefas que são executadas enquanto a câmara está desvanecida.

Utilizar tarefas do sistema de cenários

Na maioria dos casos, irá utilizar Tarefas fornecidas pelo serviço 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")
        );
}

Utilizar tarefas personalizadas

Noutros casos, poderá querer efetuar uma transição sem realmente carregar uma cena:

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
}

Em alternativa, poderá querer carregar uma cena sem utilizar o serviço 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();
    }
}

Utilizar várias tarefas

Também pode fornecer várias tarefas, que serão executadas por ordem:

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

Utilizar o indicador de progresso

Um indicador de progresso é tudo o que implementa a IProgressIndicator interface. Isto pode assumir a forma de um ecrã inicial, um indicador de carregamento 3D tagalong ou qualquer outra coisa que forneça feedback sobre o progresso da transição.

Se UseDefaultProgressIndicator for verificado no perfil SceneTransitionService, será instanciado um indicador de progresso quando uma transição começar. Durante a transição, as propriedades e deste indicador Progress podem ser acedidas através dos métodos e SetProgressMessage desse SetProgressValue serviço.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();
    }
}

Em alternativa, ao chamar DoSceneTransition , pode fornecer o seu próprio indicador de progresso através do argumento opcional progressIndicator . Isto substituirá o indicador de progresso predefinido.