Serviço de transição de cena — MRTK2

Essa extensão simplifica o negócio de desvanecer uma cena, exibir um indicador de progresso, carregar uma cena e, em seguida, desaparecer novamente.

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

Habilitando a extensão

Para habilitar a extensão, abra o perfil RegisteredServiceProvider. Clique em Registrar um novo Provedor de Serviços para adicionar uma nova configuração. No campo Tipo de 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

Usar o indicador de progresso padrão

Se for verificado, o prefab do indicador de progresso padrão será usado quando nenhum objeto de indicador de progresso for fornecido ao chamar DoSceneTransition. Se um objeto de indicador de progresso for fornecido, o padrão será ignorado.

Usar cor de fade

Se marcado, o serviço de transição aplicará um fade durante a transição. Essa configuração pode ser alterada em runtime por meio da propriedade do UseFadeColor serviço.

Cor de esmaecimento

Controla a cor do efeito fade. Alfa é ignorado. Essa configuração pode ser alterada em runtime antes de uma transição por meio da propriedade do FadeColor serviço.

Esmaecer destinos

Controla quais câmeras terão um efeito fade aplicado a elas. Essa configuração pode ser alterada em runtime por meio da propriedade do FadeTargets serviço.

Configuração	Câmeras de destino
Principal	Aplica o efeito fade à câmera main.
Interface do usuário	Aplica o efeito fade às câmeras na camada de interface do usuário. (Não afeta a interface do usuário de sobreposição)
Tudo	Aplica-se a main e câmeras de interface do usuário.
Personalizado	Aplica-se a um conjunto personalizado de câmeras fornecido por meio de SetCustomFadeTargetCameras

Esmaecer o tempo/esmaecer no tempo

Configurações padrão para a duração de um fade ao entrar/sair de uma transição. Essas configurações podem ser alteradas em runtime por meio das propriedades e FadeInTime do FadeOutTime serviço.

Tipo de fader de câmera

Qual ICameraFader classe usar para aplicar um efeito fade às câmeras. A classe padrão CameraFaderQuad cria uma instância de um quadriciclo com um material transparente na frente da câmera de destino perto do plano de clipe. Outra abordagem pode ser usar um sistema pós-efeitos.

Usar a extensão

Você usa o serviço de transição passando Tarefas executadas enquanto a câmera está desbotada.

Usando tarefas do sistema de cena

Na maioria dos casos, você usará 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

Em outros casos, talvez você queira executar 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 talvez você queira carregar uma cena sem usar 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

Você também pode fornecer várias tarefas, que serão executadas na 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. Isso pode assumir a forma de uma tela inicial, um indicador de carregamento 3D tagalong ou qualquer outra coisa que forneça comentários sobre o progresso da transição.

Se UseDefaultProgressIndicator for verificado no perfil SceneTransitionService, um indicador de progresso será instanciado quando uma transição for iniciada. Durante a transição, as propriedades e desse indicador Progress podem ser acessadas por meio dos métodos e SetProgressMessage desse SetProgressValueMessage serviço.

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

Como alternativa, ao chamar DoSceneTransition , você pode fornecer seu próprio indicador de progresso por meio do argumento opcional progressIndicator . Isso substituirá o indicador de progresso padrão.