XGRIDSDocumentación

Guía de desarrollo de renderizado de imágenes de alta resolución

El LCC Unity SDK admite el renderizado de imágenes de alta resolución, es decir, renderizar imágenes de escena que superan la resolución de pantalla. Por ejemplo, cuando la resolución de pantalla es 1920×1080, el LCC Unity SDK puede renderizar y generar imágenes de 3840×2160 (4K), 2560×1440 (2K), 1920×1080 (1080p), 1280×720 (720P) y otras resoluciones. Una vez renderizadas las imágenes de varias resoluciones, pueden usarse para producir imágenes de alta definición y vídeos de alta definición. A continuación se usa un ejemplo de renderizado de una imagen 4K y su guardado como JPG para describir los pasos completos para implementar el renderizado de imágenes de alta resolución.

Paso 1: Crear la escena y los GameObjects

Crea una escena completamente nueva en Unity. Unity crea Main Camera y Directional Light por defecto.

Configurar Main Camera

Selecciona Main Camera en la ventana Jerarquía y establece sus propiedades en la ventana Inspector como se muestra a continuación.

Establecer las propiedades de Main Camera

Establecer las propiedades de Main Camera

Crear LCCManager

Haz clic con el botón derecho en un área vacía de la ventana Jerarquía, selecciona Create Empty en el menú emergente para crear un GameObject vacío, nómbralo LCCManager, normaliza su Transform y añádele el script LCCManager mediante Agregar componente.

Crear el GameObject LCCManager y añadir el script LCCManager

Crear el GameObject LCCManager y añadir el script LCCManager

Crear LCCRenderer

Haz clic con el botón derecho en un área vacía de la ventana Jerarquía, selecciona Create Empty para crear un GameObject vacío, nómbralo LCCRenderer y establece su Transform como Rotation.x = -90 y Scale.x = -1.

Crear LCCRenderer y establecer su Transform

Crear LCCRenderer y establecer su Transform (Rotation.x = -90, Scale.x = -1)

Nota:

Los ajustes de Transform del GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) lo alinean con el sistema de coordenadas de los datos LCC. Para más detalles sobre la alineación del sistema de coordenadas, consulta "Sistema de coordenadas de los datos LCC" en Introducción al SDK de Unity.

Paso 2: Escribir el script de renderizado de alta resolución

Crea un nuevo script C# llamado HDRecord.cs con el siguiente código:

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] Iniciado, cargando datos...");
        m_renderer = m_manager.GetRender(this.transform);
        m_renderer.Load(m_FilePath, onProgress, onComplete);
    }

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

    private void onComplete()
    {
        Debug.Log("[HDRecord] Carga completa, activando el modo de grabación 4K...");

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

    private IEnumerator CaptureFrame()
    {
        // Espera un tiempo para asegurarte de que la cámara ha terminado de renderizar la escena a resolución 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] Imagen 4K guardada: {filePath} ({jpgData.Length / 1024}KB)");

        m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);
        Debug.Log("[HDRecord] Modo de grabación desactivado, renderizado normal restaurado.");
    }
}

Nota:

  • El modo de grabación debe activarse después de que la escena LCC termine de cargarse, por lo que SetRecordMode(true, ...) se llama en la devolución de llamada onComplete.
  • Después de entrar en el modo de grabación, el SDK renderiza con una resolución y un FOV vertical fijos. Se recomienda esperar unos fotogramas/segundos antes de capturar el fotograma para asegurarse de que la escena ha terminado de renderizarse a la resolución de destino.
  • Después de capturar, llama a SetRecordMode(false, ...) para restaurar el renderizado normal.
  • El nombre del archivo de script debe coincidir con el nombre de la clase (HDRecord.cs corresponde a class HDRecord), de lo contrario no puede adjuntarse a un GameObject.
  • HD_WIDTH y HD_HEIGHT en el ejemplo determinan la resolución de salida y pueden cambiarse a 2K (2560×1440), 1080p (1920×1080), 720P (1280×720), etc., según sea necesario; OUTPUT_DIR es el directorio de salida — cámbialo a una ruta donde tengas permiso de escritura.

Paso 3: Adjuntar el script y establecer propiedades

  1. Adjunta el script HDRecord.cs al GameObject LCCManager en la ventana Jerarquía.
  2. En la ventana Inspector, arrastra el GameObject LCCManager a la propiedad Manager del script.
  3. Rellena la ruta del archivo LCC en la propiedad File Path del script.
  4. Otras propiedades (como Camera) pueden configurarse libremente; cuando se dejan vacías, el script usa automáticamente Camera.main.
Adjuntar el script HDRecord y establecer sus propiedades

Adjuntar el script HDRecord y establecer sus propiedades en el Inspector

Paso 4: Ejecutar

Haz clic en el botón Play de la ventana Game. Después de que los datos terminen de cargarse, el script entra en el modo de grabación 4K, captura un fotograma y lo guarda como imagen JPG en el directorio de salida.

En este ejemplo, la imagen se renderiza a 4K y luego se guarda directamente como imagen JPG. Si quieres guardarla como vídeo de alta definición, puedes codificar las imágenes de alta resolución capturadas continuamente en un vídeo de alta definición mediante codificación de vídeo.

Pasos clave

Los pasos clave para implementar el renderizado de imágenes de alta resolución:

  1. Establece la cámara de renderizado principal mediante SetMainCamera y carga los datos LCC con Renderer.Load().
  2. Después de que la escena termine de cargarse (en la devolución de llamada onComplete), entra en el modo de grabación mediante SetRecordMode(true, renderSize, verticalFov) y especifica la resolución de destino y el FOV vertical.
  3. Renderiza la cámara a la resolución de destino mediante RenderTexture, lee de vuelta los píxeles con Texture2D.ReadPixels y codifícalos en una imagen para guardarla.
  4. Después de capturar, restaura el renderizado normal mediante SetRecordMode(false, ...).

Notas del renderizado de imágenes de alta resolución

  • Solo compatible con PC/Mac. SetRecordMode solo surte efecto en plataformas PC/Mac.
  • La distancia focal de la cámara es fija en el modo de grabación. Después de entrar en el modo de grabación, el SDK renderiza con la resolución y el FOV vertical fijos pasados, y ya no cambia con el componente Camera.
  • Restaura el renderizado normal a tiempo. Después de que la captura o grabación finalice, llama a SetRecordMode(false, ...) para restaurar la resolución normal; de lo contrario, el renderizado posterior seguirá usando la resolución de grabación.
  • Vigila el coste de memoria de vídeo y memoria. Cuanto mayor sea la resolución, mayor será la memoria de vídeo/memoria ocupada por RenderTexture y Texture2D. El renderizado de alta resolución se recomienda en dispositivos de equipo de alto rendimiento.

API relacionada con la grabación

El LCC Unity SDK proporciona la API del modo de grabación a través de LCCManager. Debe llamarse después de que la escena LCC termine de cargarse (es decir, en la devolución de llamada onComplete).

SetRecordMode

// Valor de retorno: void
public void SetRecordMode(bool isRecord, Vector2 renderSize, float verticalFov)

Establece el modo de grabación. En el modo de grabación, el renderizado usa una resolución y un FOV fijos, lo que es adecuado para grabar imágenes y vídeos de alta definición.

ParámetroTipoDescripción
isRecordboolSi se entra en el modo de grabación
renderSizeVector2Resolución de grabación (ancho × alto), como (3840, 2160)
verticalFovfloatFOV vertical (campo de visión)

Ejemplo de uso:

// Entra en el modo de grabación 4K
m_manager.SetRecordMode(true, new Vector2(3840, 2160), 60f);

// Finaliza la grabación y restaura el renderizado normal
m_manager.SetRecordMode(false, new Vector2(Screen.width, Screen.height), m_camera.fieldOfView);

Notas:

  • Solo compatible con PC/Mac.
  • En el modo de grabación, la distancia focal de la cámara es fija y no cambia con el componente Camera.
  • Después de que la grabación finalice, llama a SetRecordMode(false, ...) para restaurar el renderizado normal.
  • Debe llamarse después de que la escena LCC termine de cargarse.