Entwicklungsanleitung für hochauflösendes Bild-Rendering

Das LCC Unity SDK unterstützt hochauflösendes Bild-Rendering, also das Rendern von Szenenbildern, die die Anzeigeauflösung überschreiten. Wenn die Anzeigeauflösung beispielsweise 1920×1080 beträgt, kann das LCC Unity SDK dennoch Bilder mit 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) und anderen Auflösungen rendern und erzeugen. Sobald Bilder verschiedener Auflösungen gerendert sind, können sie zur Erstellung hochauflösender Bilder und hochauflösender Videos verwendet werden. Im Folgenden wird anhand eines Beispiels, bei dem ein 4K-Bild gerendert und als JPG gespeichert wird, der vollständige Ablauf zur Implementierung des hochauflösenden Bild-Renderings beschrieben.

Schritt 1: Szene und GameObjects erstellen

Erstellen Sie eine brandneue Szene in Unity. Unity erstellt standardmäßig Hauptkamera und Richtungslicht.

Hauptkamera einrichten

Wählen Sie die Hauptkamera im Fenster Hierarchie aus und legen Sie deren Eigenschaften im Fenster Inspektor wie unten dargestellt fest.

Die Eigenschaften der Hauptkamera festlegen

LCCManager erstellen

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Fensters Hierarchie, wählen Sie im Popup-Menü Leeres GameObject erstellen, um ein leeres GameObject zu erstellen, benennen Sie es LCCManager, normalisieren Sie dessen Transform und fügen Sie über Komponente hinzufügen das Skript LCCManager hinzu.

Das GameObject LCCManager erstellen und das Skript LCCManager hinzufügen

LCCRenderer erstellen

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Fensters Hierarchie, wählen Sie Leeres GameObject erstellen, um ein leeres GameObject zu erstellen, benennen Sie es LCCRenderer und setzen Sie dessen Transform auf Rotation.x = -90 und Scale.x = -1.

LCCRenderer erstellen und dessen Transform festlegen (Rotation.x = -90, Scale.x = -1)

Hinweis:

Die Transform-Einstellungen des GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) richten es am LCC-Daten-Koordinatensystem aus. Details zur Ausrichtung am Koordinatensystem finden Sie unter „LCC-Daten-Koordinatensystem“ in Einführung in das Unity SDK.

Schritt 2: Das hochauflösende Rendering-Skript schreiben

Erstellen Sie ein neues C#-Skript namens HDRecord.cs mit folgendem Code:

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] Gestartet, Daten werden geladen...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

    private void onProgress(float _progress)
    {
        Debug.Log($"[HDRecord] Ladefortschritt: {_progress:P1}");
    }

    private void onComplete()
    {
        Debug.Log("[HDRecord] Laden abgeschlossen, 4K-Aufnahmemodus wird aktiviert...");

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

    private IEnumerator CaptureFrame()
    {
        // Einige Zeit warten, um sicherzustellen, dass die Kamera die Szene in 4K-Auflösung fertig gerendert hat
        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] 4K-Bild gespeichert: {filePath} ({jpgData.Length / 1024} KB)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Aufnahmemodus deaktiviert, normales Rendering wiederhergestellt.");
    }
}

Hinweis:

• Der Aufnahmemodus muss nach Abschluss des Ladens der LCC-Szene aktiviert werden; daher wird SetRecordMode(true, ...) im Callback onComplete aufgerufen.
• Nach dem Wechsel in den Aufnahmemodus rendert das SDK mit einer festen Auflösung und einem festen vertikalen FOV. Es wird empfohlen, vor der Frame-Aufnahme einige Frames/Sekunden zu warten, um sicherzustellen, dass die Szene in der Zielauflösung fertig gerendert ist.
• Rufen Sie nach der Aufnahme SetRecordMode(false, ...) auf, um das normale Rendering wiederherzustellen.
• Der Skriptdateiname muss mit dem Klassennamen übereinstimmen (HDRecord.cs entspricht class HDRecord), andernfalls kann es nicht an ein GameObject angehängt werden.
• HD_WIDTH und HD_HEIGHT im Beispiel bestimmen die Ausgabeauflösung und können nach Bedarf auf 2K (2560×1440), 1080p (1920×1080), 720P (1280×720) usw. geändert werden; OUTPUT_DIR ist das Ausgabeverzeichnis – ändern Sie es in einen Pfad, auf den Sie Schreibrechte haben.

Schritt 3: Das Skript anhängen und Eigenschaften festlegen

1. Hängen Sie das Skript HDRecord.cs im Fenster Hierarchie an das GameObject LCCManager.
2. Ziehen Sie im Fenster Inspektor das GameObject LCCManager auf die Eigenschaft Manager des Skripts.
3. Tragen Sie den LCC-Dateipfad in die Eigenschaft File Path des Skripts ein.
4. Weitere Eigenschaften (z. B. Camera) können frei konfiguriert werden; wenn sie leer bleiben, verwendet das Skript automatisch Camera.main.

Das HDRecord-Skript anhängen und dessen Eigenschaften im Inspektor festlegen

Schritt 4: Ausführen

Klicken Sie im Fenster Spiel auf die Schaltfläche Play. Nach Abschluss des Datenladens wechselt das Skript in den 4K-Aufnahmemodus, nimmt einen Frame auf und speichert ihn als JPG-Bild im Ausgabeverzeichnis.

In diesem Beispiel wird das Bild in 4K gerendert und anschließend direkt als JPG-Bild gespeichert. Wenn Sie es als hochauflösendes Video speichern möchten, können Sie die kontinuierlich aufgenommenen hochauflösenden Bilder per Videokodierung in ein hochauflösendes Video kodieren.

Schlüsselschritte

Die Schlüsselschritte zur Implementierung des hochauflösenden Bild-Renderings:

1. Die Haupt-Rendering-Kamera über SetMainCamera festlegen und die LCC-Daten mit Renderer.Load() laden.
2. Nach Abschluss des Ladens der Szene (im Callback onComplete) über SetRecordMode(true, renderSize, verticalFov) in den Aufnahmemodus wechseln und die Zielauflösung sowie das vertikale FOV angeben.
3. Die Kamera über RenderTexture auf die Zielauflösung rendern, die Pixel mit Texture2D.ReadPixels zurücklesen und sie zum Speichern in ein Bild kodieren.
4. Nach der Aufnahme das normale Rendering über SetRecordMode(false, ...) wiederherstellen.

Hinweise zum hochauflösenden Bild-Rendering

• Nur auf PC/Mac unterstützt. SetRecordMode ist nur auf PC/Mac-Plattformen wirksam.
• Die Kamerabrennweite ist im Aufnahmemodus festgelegt. Nach dem Wechsel in den Aufnahmemodus rendert das SDK mit der übergebenen festen Auflösung und dem festen vertikalen FOV und ändert sich nicht mehr mit der Camera-Komponente.
• Das normale Rendering rechtzeitig wiederherstellen. Rufen Sie nach Abschluss der Aufnahme SetRecordMode(false, ...) auf, um die normale Auflösung wiederherzustellen; andernfalls verwendet das nachfolgende Rendering weiterhin die Aufnahmeauflösung.
• Grafikspeicher- und Arbeitsspeicher-Overhead beachten. Je höher die Auflösung, desto mehr Grafikspeicher/Arbeitsspeicher belegen RenderTexture und Texture2D. Hochauflösendes Rendering wird auf leistungsstarken Computergeräten empfohlen.

Aufnahmebezogene API

Das LCC Unity SDK stellt die Aufnahmemodus-API über LCCManager bereit. Sie muss nach Abschluss des Ladens der LCC-Szene (d. h. im Callback onComplete) aufgerufen werden.

SetRecordMode

// Rückgabewert: void
public void SetRecordMode(bool isRecord, Vector2 renderSize, float verticalFov)

Legt den Aufnahmemodus fest. Im Aufnahmemodus verwendet das Rendering eine feste Auflösung und ein festes FOV, was sich für die Aufnahme hochauflösender Bilder und Videos eignet.

Verwendungsbeispiel:

// In den 4K-Aufnahmemodus wechseln
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Aufnahme beenden und normales Rendering wiederherstellen
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Hinweise:

• Nur auf PC/Mac unterstützt.
• Im Aufnahmemodus ist die Kamerabrennweite festgelegt und ändert sich nicht mit der Camera-Komponente.
• Rufen Sie nach Ende der Aufnahme SetRecordMode(false, ...) auf, um das normale Rendering wiederherzustellen.
• Muss nach Abschluss des Ladens der LCC-Szene aufgerufen werden.