Przewodnik mieszanego renderowania wielu scen

Mieszane renderowanie wielu scen oznacza tworzenie wielu scen LCC jednocześnie i mieszanie ich renderowania w czasie rzeczywistym, aby osiągnąć poprawne okluzje i mieszanie. Aby niezależnie sterować każdą sceną LCC biorącą udział w renderowaniu, musisz utworzyć wiele Rendererów i dołączyć każdy Renderer do niezależnego GameObject, tak aby Transform każdej sceny LCC można było sterować niezależnie.

Krok 1: Utwórz scenę i GameObjects

Utwórz zupełnie nową scenę w Unity. Unity domyślnie tworzy Kamerę główną i Światło kierunkowe.

Utwórz LCCManager

Kliknij prawym przyciskiem myszy pusty obszar w oknie Hierarchia, wybierz Utwórz pusty z menu podręcznego, aby utworzyć pusty GameObject, nazwij go LCCManager, znormalizuj jego Transform i dodaj do niego skrypt LCCManager przez Dodaj komponent.

Utwórz GameObject LCCManager i dodaj skrypt LCCManager

Utwórz LCCRenderer01

Kliknij prawym przyciskiem myszy pusty obszar w oknie Hierarchia, wybierz Utwórz pusty, aby utworzyć pusty GameObject, nazwij go LCCRenderer01 i ustaw jego Transform na Rotation.x = -90 i Scale.x = -1.

Utwórz LCCRenderer01 i ustaw jego Transform (Rotation.x = -90, Scale.x = -1)

Utwórz LCCRenderer02

W ten sam sposób utwórz kolejny pusty GameObject, nazwij go LCCRenderer02 i również ustaw jego Transform na Rotation.x = -90 i Scale.x = -1.

Utwórz LCCRenderer02 i ustaw jego Transform (Rotation.x = -90, Scale.x = -1)

Uwaga:

Ustawienia Transform GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) wyrównują go z układem współrzędnych danych LCC. Szczegóły wyrównania układu współrzędnych znajdziesz w sekcji „Układ współrzędnych danych LCC" w Wprowadzenie do Unity SDK.

Krok 2: Napisz skrypt renderowania wielu scen

Utwórz nowy skrypt C# o nazwie MultiRenderer.cs z następującym kodem:

using LCCCore;
using UnityEngine;

public class MultiRenderer : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath01;
    public Transform m_transform01;

    public string m_FilePath02;
    public Transform m_transform02;

    private LCCCore.Renderer m_renderer01;
    private LCCCore.Renderer m_renderer02;

    private int m_currentFileIndex = 0;

    void Start()
    {
        m_manager.SetPlatformType(PlatformType.PC);
        // Przełącz w tryb MultiRender, aby umożliwić jednoczesną aktywność i mieszanie wielu Rendererów
        m_manager.SwitchRenderPass(ActiveRenderMode.MultiRender);

        Debug.Log("Uruchomiono ");
        m_renderer01 = m_manager.GetRender(m_transform01);
        m_renderer02 = m_manager.GetRender(m_transform02);
        m_currentFileIndex = 0;
        m_renderer01.Load(m_FilePath01, onProgress, onComplete);
        m_currentFileIndex = 1;
        m_renderer02.Load(m_FilePath02, onProgress, onComplete);
    }

    private void onProgress(float _progress)
    {
        Debug.Log($"[LCCRenderer] plik {m_currentFileIndex} postęp ładowania: {_progress:P1}");
    }

    private void onComplete()
    {
        Debug.Log($"[LCCRenderer] plik {m_currentFileIndex} załadowany");
    }
}

Krok 3: Dołącz skrypt i skonfiguruj właściwości

1. Dołącz skrypt MultiRenderer.cs do GameObject LCCManager w oknie Hierarchia.
2. W oknie Inspektor przypisz odniesienia i ścieżki zgodnie z tabelą poniżej:

Skonfiguruj odniesienia i ścieżki danych skryptu MultiRenderer w Inspektorze

Krok 4: Uruchom

Kliknij przycisk Odtwórz w oknie Gra, a zobaczysz dwie sceny LCC renderowane i mieszane jednocześnie. Zmień wartości Transform GameObject LCCRenderer01 lub LCCRenderer02, a każda renderowana scena zaktualizuje się w czasie rzeczywistym.

Dwie sceny LCC renderowane i mieszane jednocześnie po uruchomieniu

Kluczowe punkty

Istnieją dwa kluczowe punkty tworzenia mieszanego renderowania wielu scen LCC:

1. Przełącz w tryb MultiRender: użyj m_manager.SwitchRenderPass(ActiveRenderMode.MultiRender);, aby umożliwić mieszanie wielu scen LCC. Domyślny jest tryb SingleRender, który nie pozwala na mieszanie wielu scen LCC.
2. Dołącz każdy Renderer do niezależnego GameObject: użyj GetRender(Transform), aby powiązać każdy Renderer z niezależnym GameObject, tak aby Transform każdej sceny LCC można było sterować niezależnie.