XGRIDSDocs

Przewodnik renderowania obrazów wysokiej rozdzielczości

LCC Unity SDK obsługuje renderowanie obrazów wysokiej rozdzielczości, to znaczy renderowanie obrazów sceny przekraczających rozdzielczość wyświetlacza. Na przykład, gdy rozdzielczość wyświetlacza wynosi 1920×1080, LCC Unity SDK nadal może renderować i generować obrazy o rozdzielczości 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) i inne. Po wyrenderowaniu obrazów o różnych rozdzielczościach można je wykorzystać do tworzenia obrazów i filmów wysokiej jakości. Poniżej na przykładzie renderowania obrazu 4K i zapisywania go jako JPG opisano kompletne kroki implementacji renderowania obrazów wysokiej rozdzielczości.

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.

Skonfiguruj Kamerę główną

Wybierz Kamerę główną w oknie Hierarchia i ustaw jej właściwości w oknie Inspektor, jak pokazano poniżej.

Ustaw właściwości Kamery głównej

Ustaw właściwości Kamery głównej

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 GameObject LCCManager i dodaj skrypt LCCManager

Utwórz LCCRenderer

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

Utwórz LCCRenderer i ustaw jego Transform

Utwórz LCCRenderer 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 wysokiej rozdzielczości

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

using System.IO;
using System.Collections;
using LCCCore;
using UnityEngine;

public class HDRecord : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;
    public Camera m_camera;

    private LCCCore.Renderer m_renderer;

    private const int HD_WIDTH = 3840;
    private const int HD_HEIGHT = 2160;
    private const string OUTPUT_DIR = @"G:\output";

    void Start()
    {
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);

        if (m_camera == null)
            m_camera = Camera.main;

        m_manager.SetMainCamera(m_camera);

        Debug.Log("[HDRecord] Uruchomiono, ładowanie danych...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

    private void onProgress(float _progress)
    {
        Debug.Log($"[HDRecord] Postęp ładowania: {_progress:P1}");
    }

    private void onComplete()
    {
        Debug.Log("[HDRecord] Ładowanie zakończone, włączanie trybu nagrywania 4K...");

        float verticalFov = m_camera.fieldOfView;
        m_manager.SetRecordMode(true, new Vector2(HD_WIDTH, HD_HEIGHT), verticalFov);
        StartCoroutine(CaptureFrame());
    }

    private IEnumerator CaptureFrame()
    {
        // Odczekaj chwilę, aby upewnić się, że kamera zakończyła renderowanie sceny w rozdzielczości 4K
        yield return new WaitForSeconds(10);

        RenderTexture tempRT = RenderTexture.GetTemporary(HD_WIDTH, HD_HEIGHT, 24);
        RenderTexture preTarget = m_camera.targetTexture;
        Rect preRect = m_camera.rect;

        m_camera.targetTexture = tempRT;
        m_camera.rect = new Rect(0, 0, 1, 1);

        yield return new WaitForEndOfFrame();
        yield return new WaitForEndOfFrame();
        yield return new WaitForEndOfFrame();

        RenderTexture.active = tempRT;
        Texture2D tex = new Texture2D(HD_WIDTH, HD_HEIGHT, TextureFormat.RGB24, false);
        tex.ReadPixels(new Rect(0, 0, HD_WIDTH, HD_HEIGHT), 0, 0);
        tex.Apply();
        RenderTexture.active = null;

        m_camera.rect = preRect;
        m_camera.targetTexture = preTarget;
        RenderTexture.ReleaseTemporary(tempRT);

        byte[] jpgData = tex.EncodeToJPG(95);
        Destroy(tex);

        if (!Directory.Exists(OUTPUT_DIR))
            Directory.CreateDirectory(OUTPUT_DIR);

        string timestamp = System.DateTime.Now.ToString("yyyyMMdd_HHmmss");
        string filePath = Path.Combine(OUTPUT_DIR, $"HD4K_{timestamp}.jpg");
        File.WriteAllBytes(filePath, jpgData);

        Debug.Log($"[HDRecord] Zapisano obraz 4K: {filePath} ({jpgData.Length / 1024} KB)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Tryb nagrywania wyłączony, przywrócono normalne renderowanie.");
    }
}

Uwaga:

  • Tryb nagrywania musi być włączony po zakończeniu ładowania sceny LCC, więc SetRecordMode(true, ...) jest wywoływane w wywołaniu zwrotnym onComplete.
  • Po wejściu w tryb nagrywania SDK renderuje w stałej rozdzielczości i pionowym FOV. Zaleca się odczekanie kilku klatek/sekund przed przechwyceniem klatki, aby upewnić się, że scena zakończyła renderowanie w docelowej rozdzielczości.
  • Po przechwyceniu wywołaj SetRecordMode(false, ...), aby przywrócić normalne renderowanie.
  • Nazwa pliku skryptu musi być zgodna z nazwą klasy (HDRecord.cs odpowiada class HDRecord), w przeciwnym razie nie można go dołączyć do GameObject.
  • HD_WIDTH i HD_HEIGHT w przykładzie określają rozdzielczość wyjściową i można je zmienić na 2K (2560×1440), 1080p (1920×1080), 720P (1280×720) i tak dalej w zależności od potrzeb; OUTPUT_DIR to katalog wyjściowy — zmień go na ścieżkę, do której masz uprawnienia zapisu.

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

  1. Dołącz skrypt HDRecord.cs do GameObject LCCManager w oknie Hierarchia.
  2. W oknie Inspektor przeciągnij GameObject LCCManager na właściwość Manager skryptu.
  3. Wpisz ścieżkę pliku LCC we właściwości File Path skryptu.
  4. Pozostałe właściwości (takie jak Camera) można skonfigurować dowolnie; gdy pozostają puste, skrypt automatycznie używa Camera.main.
Dołącz skrypt HDRecord i ustaw jego właściwości

Dołącz skrypt HDRecord i ustaw jego właściwości w Inspektorze

Krok 4: Uruchom

Kliknij przycisk Odtwórz w oknie Gra. Po zakończeniu ładowania danych skrypt wchodzi w tryb nagrywania 4K, przechwytuje jedną klatkę i zapisuje ją jako obraz JPG do katalogu wyjściowego.

W tym przykładzie obraz jest renderowany w 4K, a następnie zapisywany bezpośrednio jako obraz JPG. Jeśli chcesz zapisać go jako film wysokiej jakości, możesz zakodować ciągle przechwytywane obrazy wysokiej rozdzielczości w film wysokiej jakości przez kodowanie wideo.

Kluczowe kroki

Kluczowe kroki implementacji renderowania obrazów wysokiej rozdzielczości:

  1. Ustaw główną kamerę renderującą przez SetMainCamera i załaduj dane LCC za pomocą Renderer.Load().
  2. Po zakończeniu ładowania sceny (w wywołaniu zwrotnym onComplete) wejdź w tryb nagrywania przez SetRecordMode(true, renderSize, verticalFov) i określ docelową rozdzielczość oraz pionowy FOV.
  3. Renderuj kamerę do docelowej rozdzielczości przez RenderTexture, odczytaj piksele z powrotem za pomocą Texture2D.ReadPixels i zakoduj je do obrazu, aby zapisać.
  4. Po przechwyceniu przywróć normalne renderowanie przez SetRecordMode(false, ...).

Uwagi dotyczące renderowania obrazów wysokiej rozdzielczości

  • Obsługiwane tylko na PC/Mac. SetRecordMode działa tylko na platformach PC/Mac.
  • Ogniskowa kamery jest stała w trybie nagrywania. Po wejściu w tryb nagrywania SDK renderuje z przekazaną stałą rozdzielczością i pionowym FOV i nie zmienia się już wraz z komponentem Camera.
  • Przywróć normalne renderowanie w odpowiednim czasie. Po zakończeniu przechwytywania lub nagrywania wywołaj SetRecordMode(false, ...), aby przywrócić normalną rozdzielczość; w przeciwnym razie kolejne renderowanie będzie nadal używać rozdzielczości nagrywania.
  • Obserwuj narzut pamięci wideo i pamięci. Im wyższa rozdzielczość, tym większa pamięć wideo/pamięć zajmowana przez RenderTexture i Texture2D. Renderowanie wysokiej rozdzielczości jest zalecane na wydajnych urządzeniach komputerowych.

API powiązane z nagrywaniem

LCC Unity SDK udostępnia API trybu nagrywania przez LCCManager. Musi być wywoływane po zakończeniu ładowania sceny LCC (czyli w wywołaniu zwrotnym onComplete).

SetRecordMode

// Wartość zwracana: void
public void SetRecordMode(bool isRecord, Vector2 renderSize, float verticalFov)

Ustawia tryb nagrywania. W trybie nagrywania renderowanie używa stałej rozdzielczości i FOV, co jest odpowiednie do nagrywania obrazów i filmów wysokiej jakości.

ParametrTypOpis
isRecordboolCzy wejść w tryb nagrywania
renderSizeVector2Rozdzielczość nagrywania (szerokość × wysokość), np. (3840, 2160)
verticalFovfloatPionowy FOV (pole widzenia)

Przykład użycia:

// Wejdź w tryb nagrywania 4K
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Zakończ nagrywanie i przywróć normalne renderowanie
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Uwagi:

  • Obsługiwane tylko na PC/Mac.
  • W trybie nagrywania ogniskowa kamery jest stała i nie zmienia się wraz z komponentem Camera.
  • Po zakończeniu nagrywania wywołaj SetRecordMode(false, ...), aby przywrócić normalne renderowanie.
  • Musi być wywoływane po zakończeniu ładowania sceny LCC.