Guida alla configurazione dei parametri di prestazioni di rendering

Panoramica

Per adattarsi a dispositivi con diversi livelli di prestazioni, l'LCC Unity SDK fornisce diversi parametri di configurazione delle prestazioni di rendering. Sono distribuiti sulla classe LCCManager e sulla classe Renderer, coinvolgendo principalmente i seguenti metodi:

Nota:

Tra i parametri sopra, le unità dei metodi relativi al conteggio degli Splat (SetMaxBufferSplat, SetFullRenderSplat, SetMaxRenderSplats) sono tutte in decine di migliaia, cioè valore passato × 10000 = conteggio effettivo degli Splat.

Nota:

SetMaxBufferSplat imposta lo spazio massimo del buffer di memoria CPU e memoria video GPU disponibile per il rendering, mentre SetMaxRenderSplats imposta il numero di primitive Splat renderizzate su schermo durante il rendering a blocchi in streaming. Pertanto, se il valore impostato da SetMaxRenderSplats supera il valore impostato da SetMaxBufferSplat, verrà troncato.

Modalità di rendering dell'SDK

Per adattarsi a vari dati e piattaforme, l'SDK dispone di 3 modalità di rendering principali. Comprendere le modalità di rendering è il prerequisito per impostare correttamente i parametri di prestazioni, perché parametri diversi hanno effetto solo in modalità specifiche.

• Modalità SingleRender (predefinita): usata principalmente su PC/Mac. Questa modalità non consente di creare più Renderer, il che significa che può essere renderizzata una sola scena LCC alla volta. Quando il volume dei dati è piccolo e soddisfa i requisiti, i dati verranno renderizzati completamente (vengono caricati tutti i dati LOD0, nessun cambio dinamico di LOD, migliore qualità di rendering); quando le primitive Splat LOD0 superano la quantità totale che può essere renderizzata completamente, i dati verranno renderizzati a blocchi, usando un meccanismo di rendering streaming LOD dinamico in fase di esecuzione per adattarsi al rendering di scene molto grandi.
• Modalità MultiRender: usata principalmente su PC/Mac. Questa modalità consente il rendering misto in tempo reale di più scene LCC; tutti i dati della scena verranno renderizzati a blocchi usando il meccanismo LOD dinamico.
• Percorso di rendering a blocchi: sulle piattaforme Mobile (iOS / Android), VR (Pico 4 / Quest 3), così come sulle origini dati HTTP su PC/Mac, viene usato il percorso di rendering a blocchi, impiegando il meccanismo LOD dinamico.

Relazione tra le tre modalità di rendering dell'SDK e i percorsi di rendering completo / a blocchi

Rendering completo vs rendering a blocchi:

• Rendering completo: carica e renderizza tutti i dati LOD0 in una volta sola, migliore qualità dell'immagine, abilitato solo nella modalità SingleRender PC/Mac quando il volume dei dati LOD0 soddisfa le condizioni.
• Rendering a blocchi: carica dinamicamente i dati del livello LOD in base al frustum della camera di rendering, controlla il numero di Splat su schermo e si adatta agli ambienti hardware con memoria video e prestazioni limitate.

Valori predefiniti dell'SDK

I valori predefiniti, i valori minimi consentiti e i valori massimi consentiti per ogni piattaforma sono i seguenti (unità: decine di migliaia):

Strategia di configurazione per PC/Mac

Per PC/Mac, si consiglia di configurare i parametri secondo i seguenti livelli di qualità (unità del conteggio degli Splat: decine di migliaia):

Note sul cambio di livello in fase di esecuzione

• Quando passi tra i livelli Medio / Alto / Molto alto, puoi lasciare invariato il Buffer globale, e la logica di gestione è molto semplice: devi solo impostare la soglia del rendering completo, il conteggio del rendering su schermo e StartLOD.
• Quando passi tra i livelli Molto basso / Basso e gli altri livelli, la situazione è più complessa: poiché il Buffer globale potrebbe essere già allocato, devi prima distruggere il Buffer globale originale e poi crearne uno nuovo. Questa operazione richiede di eliminare tutti i Renderer con Dispose() e di rilasciare il Buffer, quindi di riacquisire il Renderer tramite GetRender().
• Raccomandazione attuale: imposta il livello predefinito su Alto; quando cambi livello, lascia invariato il Buffer globale, ma gestisci comunque il passaggio tra rendering completo/a blocchi.

Note

1. SetMaxBufferSplat() deve essere impostato all'inizio, idealmente prima di GetRender(). Se imposti questo valore dopo che la scena è già in esecuzione, devi eliminare tutti i Renderer con Dispose() e poi riacquisire il Renderer affinché abbia effetto.
2. SetFullRenderSplat() è efficace solo per la modalità SingleRender PC/Mac e deve essere impostato prima di Load().
3. SetMaxRenderSplats() si applica a tutto il rendering a blocchi e può essere impostato in qualsiasi momento, ma deve essere successivo a SetMaxBufferSplat() (se quel metodo viene chiamato).

API per le prestazioni di rendering

SetMaxBufferSplat

// Valore restituito: void
public void SetMaxBufferSplat(int _count)

Imposta la capacità massima del Buffer GPU (conteggio degli Splat). Nel percorso RenderCore (MultiRender / SingleRender a blocchi), determina la dimensione del Buffer globale condiviso; nella modalità SingleRender Full Load, viene allocata in base al volume effettivo dei dati e non fa riferimento a questo valore. Allocata una sola volta e non può essere modificata dinamicamente.

Esempio di utilizzo:

lccManager.SetMaxBufferSplat(3000); // 30 milioni di punti (predefinito PC/Mac)
lccManager.SetMaxBufferSplat(4450); // 44,5 milioni di punti (massimo PC/Mac)

Descrizione:

• L'unità è "decine di migliaia"; valore passato × 10000 = conteggio effettivo degli Splat.
• Deve essere chiamato prima di qualsiasi Renderer.Load(), altrimenti restituisce un errore.
• Deve prima chiamare SetPlatformType.
• Maggiore è la capacità, maggiore è l'uso della memoria video; imposta secondo necessità.
• Limiti di piattaforma: PC/Mac 44,5 milioni, Android/iOS 6 milioni, VR 2 milioni; minimo 1 milione.
• Valori predefiniti: PC/Mac 30 milioni, Android/iOS 3 milioni, VR 1 milione.

SetFullRenderSplat

// Valore restituito: void
public void SetFullRenderSplat(int _count)

Imposta la soglia del conteggio degli Splat tra rendering completo e rendering a blocchi nella modalità SingleRender PC/Mac. Quando il conteggio degli Splat LOD0 dei dati è inferiore a questo valore, viene usato il percorso di rendering completo (Buffer GPU dedicato); altrimenti viene usato il percorso di rendering a blocchi.

Esempio di utilizzo:

lccManager.SetFullRenderSplat(2500); // 25 milioni di punti

Descrizione:

• L'unità è "decine di migliaia".
• Supportato solo sulle piattaforme PC/Mac; la chiamata su altre piattaforme restituisce direttamente un errore.
• Deve essere chiamato prima di qualsiasi Renderer.Load().
• Deve prima chiamare SetPlatformType.
• Intervallo di valori [100, 4450] (cioè da 1 milione a 44,5 milioni).

SetMaxRenderSplats

// Valore restituito: void
public void SetMaxRenderSplats(int _count)

Imposta il numero massimo di Splat renderizzati su schermo per fotogramma nel rendering a blocchi. Può essere chiamato dinamicamente dopo Load(), ed è limitato dal limite superiore impostato da SetMaxBufferSplat. La chiamata nella modalità SingleRender a rendering completo non ha effetto (registra un avviso e restituisce direttamente).

Esempio di utilizzo:

lccManager.SetMaxRenderSplats(2000); // 20 milioni di punti

Descrizione:

• L'unità è "decine di migliaia"; valore passato × 10000 = conteggio effettivo degli Splat.
• Può essere regolato dinamicamente in fase di esecuzione.
• Non deve superare il limite superiore di capacità impostato da SetMaxBufferSplat (se superato, viene limitato automaticamente e registra un avviso).
• La regolazione in fase di esecuzione non è supportata nella modalità SingleRender a rendering completo.

SetStartLod

// Valore restituito: void
public void SetStartLod(int lod)

Imposta il punto iniziale di espansione LOD (a base 0). 0 significa il più fine; maggiore è il numero, più grossolano è il livello. Questo metodo ha effetto in fase di esecuzione e deve essere chiamato dopo Load().

Esempio di utilizzo:

lccManager.SetStartLod(0);

Descrizione:

• Efficace solo per il rendering a blocchi, intervallo [0, 10], limitato automaticamente se superato.
• Il limite superiore effettivo è limitato da totalLevels dei dati.
• L'SDK ha effetto immediatamente dopo la chiamata.

SetDetailLevel

// Valore restituito: void
public void SetDetailLevel(float sse)

Imposta il livello di dettaglio del rendering, usato per regolare con precisione la precisione di rendering. Maggiore è il valore, più fine è il rendering e maggiore è il costo delle prestazioni.

Esempio di utilizzo:

lccManager.SetDetailLevel(50f); // Precisione media

Descrizione:

• Questo parametro è usato per regolare con precisione il dettaglio della scena, si applica solo al rendering a blocchi, il predefinito è 40, intervallo [1, 100], limitato automaticamente se superato.
• Usa una mappatura logaritmica: l'intervallo dei valori bassi è sensibile ai cambiamenti, mentre l'intervallo dei valori alti cambia dolcemente.
• Può essere regolato dinamicamente in fase di esecuzione.

SetRenderAll

// Valore restituito: void
public void SetRenderAll(bool _renderAll)

Un metodo della classe Renderer. Imposta se questo Renderer forza il rendering completo e deve essere chiamato prima di Load(). Usato solo per la modalità SingleRender PC/Mac: in fase di esecuzione confronta il volume dei dati LOD0 con il limite superiore di 44,5 milioni; se LOD0 < 44,5 milioni, i dati completi LOD0 vengono usati direttamente per il rendering; se LOD0 > 44,5 milioni, questa impostazione è inefficace (limitata dal GBuffer massimo di Unity) e viene usato invece il rendering a blocchi.

Esempio di utilizzo:

renderer.SetRenderAll(true);
renderer.Load(filePath, null, () => Debug.Log("Caricamento completo"));

Descrizione:

• Supportato solo sulle piattaforme PC/Mac; la chiamata su mobile / VR registra un avviso e restituisce.
• L'impostazione ha effetto sulla successiva chiamata di Load() e non influisce sul dataset attualmente caricato.
• Può essere usato insieme alla proprietà IsRenderAll per interrogare lo stato corrente.