Guida allo sviluppo del rendering di immagini ad alta risoluzione

L'LCC Unity SDK supporta il rendering di immagini ad alta risoluzione, ovvero il rendering di immagini di scena che superano la risoluzione di visualizzazione. Ad esempio, quando la risoluzione di visualizzazione è 1920×1080, l'LCC Unity SDK può comunque renderizzare e generare immagini a 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) e altre risoluzioni. Una volta renderizzate immagini di varie risoluzioni, queste possono essere usate per produrre immagini e video ad alta definizione. Di seguito viene usato un esempio di rendering di un'immagine 4K e del suo salvataggio come JPG per descrivere i passaggi completi per implementare il rendering di immagini ad alta risoluzione.

Passaggio 1: crea la scena e i GameObject

Crea una scena completamente nuova in Unity. Unity crea Camera principale e Luce direzionale per impostazione predefinita.

Configura la Camera principale

Seleziona Camera principale nella finestra Gerarchia e imposta le sue proprietà nella finestra Inspector come mostrato di seguito.

Imposta le proprietà della Camera principale

Crea LCCManager

Fai clic con il pulsante destro su un'area vuota nella finestra Gerarchia, seleziona Crea vuoto dal menu a comparsa per creare un GameObject vuoto, assegna il nome LCCManager, normalizza il suo Transform e aggiungi lo script LCCManager tramite Aggiungi componente.

Crea il GameObject LCCManager e aggiungi lo script LCCManager

Crea LCCRenderer

Fai clic con il pulsante destro su un'area vuota nella finestra Gerarchia, seleziona Crea vuoto per creare un GameObject vuoto, assegna il nome LCCRenderer e imposta il suo Transform su Rotation.x = -90 e Scale.x = -1.

Crea LCCRenderer e imposta il suo Transform (Rotation.x = -90, Scale.x = -1)

Nota:
Le impostazioni Transform del GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) lo allineano al sistema di coordinate dei dati LCC. Per i dettagli sull'allineamento del sistema di coordinate, vedi "Sistema di coordinate dei dati LCC" in Introduzione all'Unity SDK.

Passaggio 2: scrivi lo script di rendering ad alta risoluzione

Crea un nuovo script C# denominato HDRecord.cs con il seguente codice:

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] Avviato, caricamento dati in corso...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

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

    private void onComplete()
    {
        Debug.Log("[HDRecord] Caricamento completato, attivazione modalità di registrazione 4K...");

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

    private IEnumerator CaptureFrame()
    {
        // Attendi un po' di tempo per assicurarti che la camera abbia terminato il rendering della scena alla risoluzione 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] Immagine 4K salvata: {filePath} ({jpgData.Length / 1024}KB)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Modalità di registrazione disattivata, ripristinato il rendering normale.");
    }
}

Nota:
La modalità di registrazione deve essere attivata dopo che la scena LCC ha terminato il caricamento, quindi SetRecordMode(true, ...) viene chiamato nel callback onComplete.
Dopo essere entrata in modalità di registrazione, l'SDK renderizza a una risoluzione e un FOV verticale fissi. Si consiglia di attendere alcuni fotogrammi/secondi prima di acquisire il fotogramma, per assicurarsi che la scena abbia terminato il rendering alla risoluzione di destinazione.
Dopo l'acquisizione, chiama SetRecordMode(false, ...) per ripristinare il rendering normale.
Il nome del file dello script deve corrispondere al nome della classe (HDRecord.cs corrisponde a class HDRecord), altrimenti non può essere associato a un GameObject.
HD_WIDTH e HD_HEIGHT nell'esempio determinano la risoluzione di output e possono essere modificati in 2K (2560×1440), 1080p (1920×1080), 720P (1280×720) e così via secondo necessità; OUTPUT_DIR è la directory di output — modificala con un percorso per cui disponi dei permessi di scrittura.

Passaggio 3: associa lo script e imposta le proprietà

Associa lo script HDRecord.cs al GameObject LCCManager nella finestra Gerarchia.
Nella finestra Inspector, trascina il GameObject LCCManager sulla proprietà Manager dello script.
Inserisci il percorso del file LCC nella proprietà File Path dello script.
Le altre proprietà (come Camera) possono essere configurate liberamente; quando vengono lasciate vuote, lo script usa automaticamente Camera.main.

Associa lo script HDRecord e imposta le sue proprietà nell'Inspector

Passaggio 4: esegui

Fai clic sul pulsante Play nella finestra Game. Dopo il completamento del caricamento dei dati, lo script entra in modalità di registrazione 4K, acquisisce un fotogramma e lo salva come immagine JPG nella directory di output.

In questo esempio, l'immagine viene renderizzata a 4K e poi salvata direttamente come immagine JPG. Se desideri salvarla come video ad alta definizione, puoi codificare le immagini ad alta risoluzione acquisite in modo continuo in un video ad alta definizione tramite la codifica video.

Punti chiave

I passaggi chiave per implementare il rendering di immagini ad alta risoluzione:

Imposta la camera di rendering principale tramite SetMainCamera e carica i dati LCC con Renderer.Load().
Dopo che la scena ha terminato il caricamento (nel callback onComplete), entra in modalità di registrazione tramite SetRecordMode(true, renderSize, verticalFov) e specifica la risoluzione di destinazione e il FOV verticale.
Renderizza la camera alla risoluzione di destinazione tramite RenderTexture, rileggi i pixel con Texture2D.ReadPixels e codificali in un'immagine da salvare.
Dopo l'acquisizione, ripristina il rendering normale tramite SetRecordMode(false, ...).

Note sul rendering di immagini ad alta risoluzione

Supportato solo su PC/Mac. SetRecordMode è efficace solo sulle piattaforme PC/Mac.
La lunghezza focale della camera è fissa in modalità di registrazione. Dopo essere entrata in modalità di registrazione, l'SDK renderizza con la risoluzione e il FOV verticale fissi passati, e non cambia più in base al componente Camera.
Ripristina il rendering normale in tempo utile. Al termine dell'acquisizione o della registrazione, chiama SetRecordMode(false, ...) per ripristinare la risoluzione normale; in caso contrario, il rendering successivo continuerà a usare la risoluzione di registrazione.
Attenzione all'overhead di memoria video e memoria. Maggiore è la risoluzione, maggiore è la memoria video/memoria occupata da RenderTexture e Texture2D. Il rendering ad alta risoluzione è consigliato su dispositivi ad alte prestazioni.

API relative alla registrazione

L'LCC Unity SDK fornisce l'API per la modalità di registrazione tramite LCCManager. Deve essere chiamata dopo che la scena LCC ha terminato il caricamento (ovvero nel callback onComplete).

SetRecordMode

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

Imposta la modalità di registrazione. In modalità di registrazione, il rendering usa una risoluzione e un FOV fissi, adatti alla registrazione di immagini e video ad alta definizione.

Parametro	Tipo	Descrizione
`isRecord`	`bool`	Indica se entrare in modalità di registrazione
`renderSize`	`Vector2`	Risoluzione di registrazione (larghezza × altezza), ad esempio `(3840, 2160)`
`verticalFov`	`float`	FOV verticale (campo visivo)

Esempio di utilizzo:

// Entra in modalità di registrazione 4K
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Termina la registrazione e ripristina il rendering normale
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Note:

Supportato solo su PC/Mac.
In modalità di registrazione la lunghezza focale della camera è fissa e non cambia in base al componente Camera.
Al termine della registrazione, chiama SetRecordMode(false, ...) per ripristinare il rendering normale.
Deve essere chiamata dopo che la scena LCC ha terminato il caricamento.