XGRIDSDocs

Ontwikkelgids voor het renderen van afbeeldingen met hoge resolutie

De LCC Unity SDK ondersteunt het renderen van afbeeldingen met hoge resolutie, dat wil zeggen het renderen van scèneafbeeldingen die de weergaveresolutie overschrijden. Wanneer de weergaveresolutie bijvoorbeeld 1920×1080 is, kan de LCC Unity SDK nog steeds afbeeldingen van 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) en andere resoluties renderen en genereren. Zodra afbeeldingen van verschillende resoluties zijn gerenderd, kunnen ze worden gebruikt om high-definition afbeeldingen en high-definition video's te produceren. Hieronder wordt aan de hand van een voorbeeld van het renderen van een 4K-afbeelding en het opslaan ervan als JPG beschreven hoe je het renderen van afbeeldingen met hoge resolutie volledig implementeert.

Stap 1: De scène en GameObjects aanmaken

Maak een gloednieuwe scène aan in Unity. Unity maakt standaard Main Camera en Directional Light aan.

Main Camera instellen

Selecteer Main Camera in het Hiërarchie-venster en stel de eigenschappen in het Inspector-venster in zoals hieronder wordt weergegeven.

Stel de eigenschappen van Main Camera in

Stel de eigenschappen van Main Camera in

LCCManager aanmaken

Klik met de rechtermuisknop op een leeg gebied in het Hiërarchie-venster, selecteer Create Empty in het pop-upmenu om een leeg GameObject aan te maken, geef het de naam LCCManager, normaliseer de Transform en voeg het LCCManager-script eraan toe via Component toevoegen.

Maak het LCCManager-GameObject aan en voeg het LCCManager-script toe

Maak het LCCManager-GameObject aan en voeg het LCCManager-script toe

LCCRenderer aanmaken

Klik met de rechtermuisknop op een leeg gebied in het Hiërarchie-venster, selecteer Create Empty om een leeg GameObject aan te maken, geef het de naam LCCRenderer en stel de Transform in op Rotation.x = -90 en Scale.x = -1.

Maak LCCRenderer aan en stel de Transform in

Maak LCCRenderer aan en stel de Transform in (Rotation.x = -90, Scale.x = -1)

Opmerking:

De Transform-instellingen van het LCCRenderer-GameObject (Rotation.x = -90, Scale.x = -1) lijnen het uit met het coördinatensysteem van de LCC-gegevens. Zie "Coördinatensysteem van LCC-gegevens" in LCC Unity SDK Introductie voor meer informatie over de uitlijning van het coördinatensysteem.

Stap 2: Het script voor rendering met hoge resolutie schrijven

Maak een nieuw C#-script aan met de naam HDRecord.cs met de volgende 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] Gestart, gegevens worden geladen...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

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

    private void onComplete()
    {
        Debug.Log("[HDRecord] Laden voltooid, 4K-opnamemodus wordt ingeschakeld...");

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

    private IEnumerator CaptureFrame()
    {
        // Wacht enige tijd om ervoor te zorgen dat de camera de scène op 4K-resolutie heeft gerenderd
        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-afbeelding opgeslagen: {filePath} ({jpgData.Length / 1024}KB)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Opnamemodus uitgeschakeld, normale rendering hersteld.");
    }
}

Opmerking:

  • De opnamemodus moet worden ingeschakeld nadat de LCC-scène is geladen, dus SetRecordMode(true, ...) wordt aangeroepen in de onComplete-callback.
  • Nadat de opnamemodus is geactiveerd, rendert de SDK op een vaste resolutie en verticale FOV. Het wordt aanbevolen om een paar frames/seconden te wachten voordat je het frame vastlegt, om ervoor te zorgen dat de scène op de doelresolutie is gerenderd.
  • Roep na het vastleggen SetRecordMode(false, ...) aan om de normale rendering te herstellen.
  • De bestandsnaam van het script moet overeenkomen met de klassenaam (HDRecord.cs komt overeen met class HDRecord), anders kan het niet aan een GameObject worden toegevoegd.
  • HD_WIDTH en HD_HEIGHT in het voorbeeld bepalen de uitvoerresolutie en kunnen indien nodig worden gewijzigd naar 2K (2560×1440), 1080p (1920×1080), 720P (1280×720), enzovoort; OUTPUT_DIR is de uitvoermap — wijzig deze naar een pad waarop je schrijfrechten hebt.

Stap 3: Het script toevoegen en eigenschappen instellen

  1. Voeg het HDRecord.cs-script toe aan het LCCManager-GameObject in het Hiërarchie-venster.
  2. Sleep in het Inspector-venster het LCCManager-GameObject naar de eigenschap Manager van het script.
  3. Vul het LCC-bestandspad in bij de eigenschap File Path van het script.
  4. Andere eigenschappen (zoals Camera) kunnen vrij worden geconfigureerd; wanneer ze leeg blijven, gebruikt het script automatisch Camera.main.
Voeg het HDRecord-script toe en stel de eigenschappen in

Voeg het HDRecord-script toe en stel de eigenschappen in de Inspector in

Stap 4: Uitvoeren

Klik op de knop Play in het Game-venster. Nadat de gegevens zijn geladen, activeert het script de 4K-opnamemodus, legt het één frame vast en slaat het dit op als JPG-afbeelding in de uitvoermap.

In dit voorbeeld wordt de afbeelding op 4K gerenderd en vervolgens rechtstreeks als JPG-afbeelding opgeslagen. Als je het wilt opslaan als high-definition video, kun je de continu vastgelegde afbeeldingen met hoge resolutie via videocodering coderen tot een high-definition video.

Belangrijkste stappen

De belangrijkste stappen voor het implementeren van het renderen van afbeeldingen met hoge resolutie:

  1. Stel de hoofdrendercamera in via SetMainCamera en laad de LCC-gegevens met Renderer.Load().
  2. Activeer nadat de scène is geladen (in de onComplete-callback) de opnamemodus via SetRecordMode(true, renderSize, verticalFov) en geef de doelresolutie en verticale FOV op.
  3. Render de camera naar de doelresolutie via RenderTexture, lees de pixels terug met Texture2D.ReadPixels en codeer ze tot een afbeelding om op te slaan.
  4. Herstel na het vastleggen de normale rendering via SetRecordMode(false, ...).

Opmerkingen bij het renderen van afbeeldingen met hoge resolutie

  • Alleen ondersteund op pc/Mac. SetRecordMode is alleen effectief op pc/Mac-platformen.
  • De brandpuntsafstand van de camera is vast in de opnamemodus. Nadat de opnamemodus is geactiveerd, rendert de SDK met de doorgegeven vaste resolutie en verticale FOV en verandert deze niet meer mee met de Camera-component.
  • Herstel de normale rendering op tijd. Roep nadat het vastleggen of opnemen is voltooid SetRecordMode(false, ...) aan om de normale resolutie te herstellen; anders blijft de daaropvolgende rendering de opnameresolutie gebruiken.
  • Let op de videogeheugen- en geheugenoverhead. Hoe hoger de resolutie, hoe groter het videogeheugen/geheugen dat door RenderTexture en Texture2D wordt ingenomen. Rendering met hoge resolutie wordt aanbevolen op krachtige computerapparaten.

Opnamegerelateerde API

De LCC Unity SDK biedt via LCCManager de API voor de opnamemodus. Deze moet worden aangeroepen nadat de LCC-scène is geladen (dat wil zeggen in de onComplete-callback).

SetRecordMode

// Retourwaarde: void
public void SetRecordMode(bool isRecord, Vector2 renderSize, float verticalFov)

Stelt de opnamemodus in. In de opnamemodus gebruikt de rendering een vaste resolutie en FOV, wat geschikt is voor het opnemen van high-definition afbeeldingen en video's.

ParameterTypeBeschrijving
isRecordboolOf de opnamemodus moet worden geactiveerd
renderSizeVector2Opnameresolutie (breedte × hoogte), zoals (3840, 2160)
verticalFovfloatVerticale FOV (gezichtsveld)

Gebruiksvoorbeeld:

// Ga naar de 4K-opnamemodus
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Beëindig de opname en herstel de normale rendering
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Opmerkingen:

  • Alleen ondersteund op pc/Mac.
  • In de opnamemodus is de brandpuntsafstand van de camera vast en verandert deze niet mee met de Camera-component.
  • Roep nadat de opname is beëindigd SetRecordMode(false, ...) aan om de normale rendering te herstellen.
  • Moet worden aangeroepen nadat de LCC-scène is geladen.