Guide de développement du rendu d'images haute résolution

Le LCC Unity SDK prend en charge le rendu d'images haute résolution, c'est-à-dire le rendu d'images de scène qui dépassent la résolution d'affichage. Par exemple, lorsque la résolution d'affichage est de 1920×1080, le LCC Unity SDK peut toujours rendre et générer des images de 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) et d'autres résolutions. Une fois les images de différentes résolutions rendues, elles peuvent être utilisées pour produire des images haute définition et des vidéos haute définition. Ce qui suit utilise l'exemple du rendu d'une image 4K et de son enregistrement en JPG pour décrire les étapes complètes de mise en œuvre du rendu d'images haute résolution.

Étape 1 : Créer la scène et les GameObjects

Créez une toute nouvelle scène dans Unity. Unity crée Caméra principale et Lumière directionnelle par défaut.

Configurer la Caméra principale

Sélectionnez Caméra principale dans la fenêtre Hiérarchie, et définissez ses propriétés dans la fenêtre Inspecteur comme illustré ci-dessous.

Définir les propriétés de la Caméra principale

Créer LCCManager

Faites un clic droit dans une zone vide de la fenêtre Hiérarchie, sélectionnez Créer vide dans le menu contextuel pour créer un GameObject vide, nommez-le LCCManager, normalisez son Transform, et ajoutez-y le script LCCManager via Ajouter un composant.

Créer le GameObject LCCManager et ajouter le script LCCManager

Créer LCCRenderer

Faites un clic droit dans une zone vide de la fenêtre Hiérarchie, sélectionnez Créer vide pour créer un GameObject vide, nommez-le LCCRenderer, et définissez son Transform sur Rotation.x = -90 et Scale.x = -1.

Créer LCCRenderer et définir son Transform (Rotation.x = -90, Scale.x = -1)

Remarque :
Les réglages de Transform du GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) l'alignent avec le système de coordonnées des données LCC. Pour plus de détails sur l'alignement du système de coordonnées, voir « Système de coordonnées des données LCC » dans Introduction au SDK Unity.

Étape 2 : Écrire le script de rendu haute résolution

Créez un nouveau script C# nommé HDRecord.cs avec le code suivant :

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] Démarrage, chargement des données...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

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

    private void onComplete()
    {
        Debug.Log("[HDRecord] Chargement terminé, activation du mode d'enregistrement 4K...");

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

    private IEnumerator CaptureFrame()
    {
        // Attendre un certain temps pour s'assurer que la caméra a fini de rendre la scène à la résolution 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] Image 4K enregistrée : {filePath} ({jpgData.Length / 1024}Ko)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Mode d'enregistrement désactivé, rendu normal restauré.");
    }
}

Remarque :
Le mode d'enregistrement doit être activé après la fin du chargement de la scène LCC, donc SetRecordMode(true, ...) est appelé dans le callback onComplete.
Après être entré en mode d'enregistrement, le SDK rend à une résolution et un FOV vertical fixes. Il est recommandé d'attendre quelques images/secondes avant de capturer l'image pour s'assurer que la scène a fini de rendre à la résolution cible.
Après la capture, appelez SetRecordMode(false, ...) pour restaurer le rendu normal.
Le nom du fichier de script doit correspondre au nom de la classe (HDRecord.cs correspond à class HDRecord), sinon il ne peut pas être attaché à un GameObject.
HD_WIDTH et HD_HEIGHT dans l'exemple déterminent la résolution de sortie et peuvent être changés en 2K (2560×1440), 1080p (1920×1080), 720P (1280×720), etc. selon les besoins ; OUTPUT_DIR est le répertoire de sortie — changez-le vers un chemin où vous disposez d'une autorisation d'écriture.

Étape 3 : Attacher le script et définir les propriétés

Attachez le script HDRecord.cs au GameObject LCCManager dans la fenêtre Hiérarchie.
Dans la fenêtre Inspecteur, faites glisser le GameObject LCCManager sur la propriété Manager du script.
Renseignez le chemin du fichier LCC dans la propriété File Path du script.
Les autres propriétés (telles que Camera) peuvent être configurées librement ; lorsqu'elles sont laissées vides, le script utilise automatiquement Camera.main.

Attacher le script HDRecord et définir ses propriétés dans l'Inspecteur

Étape 4 : Exécuter

Cliquez sur le bouton Play dans la fenêtre Jeu. Après la fin du chargement des données, le script entre en mode d'enregistrement 4K, capture une image et l'enregistre en tant qu'image JPG dans le répertoire de sortie.

Dans cet exemple, l'image est rendue en 4K puis enregistrée directement en tant qu'image JPG. Si vous souhaitez l'enregistrer en tant que vidéo haute définition, vous pouvez encoder les images haute résolution capturées en continu en une vidéo haute définition via l'encodage vidéo.

Étapes clés

Les étapes clés pour mettre en œuvre le rendu d'images haute résolution :

Définissez la caméra de rendu principale via SetMainCamera, et chargez les données LCC avec Renderer.Load().
Après la fin du chargement de la scène (dans le callback onComplete), entrez en mode d'enregistrement via SetRecordMode(true, renderSize, verticalFov) et spécifiez la résolution cible et le FOV vertical.
Rendez la caméra à la résolution cible via RenderTexture, relisez les pixels avec Texture2D.ReadPixels, et encodez-les en image à enregistrer.
Après la capture, restaurez le rendu normal via SetRecordMode(false, ...).

Remarques sur le rendu d'images haute résolution

Pris en charge uniquement sur PC/Mac. SetRecordMode n'est efficace que sur les plateformes PC/Mac.
La distance focale de la caméra est fixe en mode d'enregistrement. Après être entré en mode d'enregistrement, le SDK rend avec la résolution et le FOV vertical fixes transmis, et ne change plus avec le composant Camera.
Restaurez le rendu normal à temps. Après la fin de la capture ou de l'enregistrement, appelez SetRecordMode(false, ...) pour restaurer la résolution normale ; sinon le rendu ultérieur continuera d'utiliser la résolution d'enregistrement.
Surveillez le surcoût de mémoire vidéo et de mémoire. Plus la résolution est élevée, plus la mémoire vidéo/mémoire occupée par RenderTexture et Texture2D est importante. Le rendu haute résolution est recommandé sur les appareils informatiques haute performance.

API liée à l'enregistrement

Le LCC Unity SDK fournit l'API du mode d'enregistrement via LCCManager. Elle doit être appelée après la fin du chargement de la scène LCC (c'est-à-dire dans le callback onComplete).

SetRecordMode

// Valeur de retour : void
public void SetRecordMode(bool isRecord, Vector2 renderSize, float verticalFov)

Définit le mode d'enregistrement. En mode d'enregistrement, le rendu utilise une résolution et un FOV fixes, ce qui convient à l'enregistrement d'images et de vidéos haute définition.

Paramètre	Type	Description
`isRecord`	`bool`	S'il faut entrer en mode d'enregistrement
`renderSize`	`Vector2`	Résolution d'enregistrement (largeur × hauteur), telle que `(3840, 2160)`
`verticalFov`	`float`	FOV vertical (champ de vision)

Exemple d'utilisation :

// Entrer en mode d'enregistrement 4K
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Terminer l'enregistrement et restaurer le rendu normal
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Remarques :

Pris en charge uniquement sur PC/Mac.
En mode d'enregistrement, la distance focale de la caméra est fixe et ne change pas avec le composant Camera.
Après la fin de l'enregistrement, appelez SetRecordMode(false, ...) pour restaurer le rendu normal.
Doit être appelé après la fin du chargement de la scène LCC.