Serviço de transição de cena

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

As operações de cena são conduzidas pelo serviço SceneSystem, mas qualquer operação baseada em tarefas pode ser usada para conduzir uma transição.

Habilitando a extensão

Para ativar a extensão, abra o perfil RegistroProvider. Clique em Registar um novo Fornecedor de Serviços para adicionar uma nova configuração. No campo Tipo Componente, selecione SceneTransitionService. No campo Perfil de Configuração, selecione o perfil de transição de cena padrão incluído com a extensão.

Opções de perfil

Utilize o indicador de progresso predefinido

Se for verificado, o pré-fabricado do indicador de progresso prefácio será utilizado quando não for fornecido nenhum objeto indicador de progresso quando ligar DoSceneTransition. se for fornecido um objeto indicador de progresso, o padrão será ignorado.

Use a cor de desvanecimento

Se for verificado, o serviço de transição aplicará um desvanecimento durante a sua transição. Esta definição pode ser alterada no tempo de execução através da propriedade do UseFadeColor serviço.

Cor de fade

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

Alvos de fade

Controles que câmaras terão um efeito de desvanecimento aplicado a elas. Esta definição pode ser alterada no tempo de execução através da propriedade do FadeTargets serviço.

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

Desvanecer o tempo / desvanecer-se no tempo

Definições predefinidoras durante a duração de um desvanecimento ao entrar/sair de uma transição. Estas definições podem ser alteradas no tempo de execução através das propriedades e propriedades do FadeOutTimeFadeInTime serviço.

Tipo de fader câmera

Que ICameraFader classe usar para aplicar um efeito de desvanecimento às câmaras. A classe padrão CameraFaderQuad instantaneaiza um quad com um material transparente na frente da câmara-alvo perto do plano de clipe. Outra abordagem poderia ser usar um sistema de efeitos pós-post.

Usando a extensão

Utiliza o serviço de transição passando tarefas que são executadas enquanto a câmara está desvanecida.

Usando tarefas do sistema de cena

Na maioria dos casos, 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")
        );
}

Usando tarefas personalizadas

Noutros casos, poderá querer realizar 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
}

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

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

Usando o indicador de progresso

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

Se UseDefaultProgressIndicator for verificado no perfil de SceneTransitionService, um indicador de progresso será instantaneamente instantâneo quando uma transição começar. Durante a transição, este indicador Progress e propriedades podem ser Message acedidos através desse serviço SetProgressValue e SetProgressMessage métodos.

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 ligar DoSceneTransition pode fornecer o seu próprio indicador de progresso através do argumento progressIndicator opcional. Isto irá sobrepor-se ao indicador de progresso predefinido.