Camminare in una scena 3DGS: supporto delle collisioni

LCC4Unreal supporta il caricamento dinamico dei dati di collisione, così i personaggi possono muoversi e interagire liberamente nel mondo 3DGS.

Prerequisiti

Le collisioni si basano sul file di collisione distribuito con i dati, e i requisiti differiscono per formato:

Per .lcc e .lcc2, il plugin controlla il file di collisione distribuito nell'ordine collision.lci → collision.bin → data/mesh/*.ply, e registra un avviso e disabilita le collisioni quando nessuno di essi esiste.

I formati a file singolo (.sog / .spz / .ply) non contengono dati di collisione di tipo nativo. L'edizione Pro può derivare automaticamente la mesh di collisione dalle gaussiane, vedere Generazione automatica della collisione per i modelli a file singolo; nell'edizione gratuita occorre montare la collisione manualmente.

Dopo il caricamento dei dati, usare HaveValidCollisionData() per verificare se i dati correnti contengono dati di collisione utilizzabili.

Nota: collision.lci richiede l'esportazione da LCC Studio v1.6.1 o superiore; i dati esportati dalle versioni precedenti usano collision.bin.

Meccanismo di caricamento

I dati di collisione sono memorizzati in blocchi spaziali esattamente come i dati di rendering. Il plugin non carica tutte le collisioni in una volta: carica solo i blocchi entro una certa distanza dalla camera e li scambia dentro e fuori dinamicamente al movimento della camera.

La posizione della camera cambia
      │
      ▼
Calcolo dell'insieme di blocchi di collisione da caricare nell'estensione
      │
      ▼
Confronto con l'insieme precedente ── uguale ──▶ salta, non fa nulla
      │ diverso
      ▼
Carica i nuovi blocchi → li passa al sistema fisico per il baking → genera i corpi di collisione

Alcuni punti di implementazione:

• L'estensione di caricamento è controllata da Max Load Collision Distance(m), e le aree oltre quella distanza non hanno collisioni
• Il primo caricamento è sincrono, il che evita che il personaggio cada attraverso il terreno prima che le collisioni siano pronte; ogni aggiornamento successivo è asincrono e non blocca il thread principale
• Gli aggiornamenti sono limitati in frequenza, quindi le collisioni non vengono ricostruite a ogni fotogramma mentre la camera si muove in continuo
• Gli aggiornamenti vengono saltati quando l'insieme dei blocchi visibili non cambia, quindi piccoli movimenti sul posto non innescano una ricostruzione
• Per il calcolo viene usata solo la camera principale, e SceneCapture non partecipa al caricamento delle collisioni

Vantaggi

• L'uso della memoria dipende solo dall'estensione di caricamento, non dalla dimensione totale dei dati, quindi le collisioni funzionano anche per grandi scene
• Il numero di corpi di collisione che il sistema fisico deve elaborare resta sotto controllo e non rallenta la fisica al crescere della scena

Costi e mitigazioni

Caricare tutte le collisioni in una volta

La maggior parte dei costi elencati sopra deriva dallo scambio dei blocchi dentro e fuori a runtime. Quando le dimensioni della scena sono contenute e la memoria lo consente, aumentare Max Load Collision Distance(m) a sufficienza per coprire l'intera scena, così che tutte le collisioni vengano costruite in un solo passaggio durante il caricamento dei dati.

Lo scambio a runtime dei blocchi di collisione scompare, e nessuno dei problemi precedenti si verifica: caduta attraverso il terreno, collisioni mancanti dopo un teletrasporto, scatti durante il movimento e ricostruzioni ripetute della navigazione. Questo è consigliato in particolare quando si usa il sistema di navigazione.

Il costo è un tempo di caricamento più lungo all'avvio e un uso di memoria fisso pari alle collisioni dell'intera scena. Per valutare se è praticabile, controllare Collision Data Usage in stat xgrids e verificare che l'uso di memoria dopo un caricamento completo sia accettabile.

Abilitazione

LCCComponent->SetLCCCollisionEnable(true);

Oppure spuntare bEnableCollision nel pannello Details.

Abilitazione delle collisioni LCC nel pannello Details

Collisioni dinamiche di un personaggio in una scena LCC

Verifica

Usare le impostazioni della modalità di visualizzazione e selezionare player collision o visibility collision per osservare se le collisioni sono abilitate.

Verifica dei corpi di collisione con la modalità player collision o visibility collision

Proprietà correlate

Configurazione dello stato di abilitazione delle collisioni e della distanza massima di caricamento

Generazione automatica della collisione per i modelli a file singolo

Funzionalità dell'edizione Pro. I modelli a file singolo (.ply / .spz / .sog) non contengono dati di collisione di tipo nativo. Il plugin deriva la mesh di collisione dalle gaussiane stesse e la memorizza nella cache come <nome>.collision.ply accanto al modello, così che in seguito venga caricata e riutilizzata tramite il percorso di collisione PLY già esistente.

È una funzionalità dell'edizione Pro: viene generata solo dopo la registrazione di un App Key, vedere Edizioni e licenze. Senza licenza la mesh di collisione non viene generata e occorre montarla manualmente secondo l'alternativa manuale senza generazione automatica.

Passaggi

1. Selezionare bEnableCollision nel pannello del LCC Actor.
2. Caricare il modello a file singolo (.ply / .spz / .sog).
3. Il primo caricamento passa allo stato Generating e genera la mesh di collisione sul momento, con un tempo da pochi secondi a qualche minuto in base al volume dei dati; al termine passa a Loaded e scrive <nome>.collision.ply accanto al modello.
4. Caricando di nuovo lo stesso modello, se il file di cache esiste si passa direttamente a Loaded e la generazione viene saltata.

Con le collisioni abilitate, al primo caricamento di un modello a file singolo un avviso in basso a destra indica che la mesh di collisione è in generazione

Lo stato della generazione e della collisione può essere interrogato con GetCollisionState() oppure rimanendo in ascolto dell'evento OnCollisionStateChanged; per i valori, vedere ULCCComponentBase - Query dello stato.

Suggerimento: per evitare la generazione a runtime, basta distribuire o pacchettizzare il <nome>.collision.ply già generato insieme al modello; a runtime, se la cache viene rilevata, viene riutilizzata direttamente.

Suggerimento: generando la collisione in un gioco pacchettizzato non c'è alcun avviso di UI integrato; per avvisare il giocatore che «la collisione è in generazione», rimanere in ascolto dello stato Generating di OnCollisionStateChanged e mostrarlo per conto proprio.

Suggerimento: se la generazione fallisce, si passa allo stato Failed; il motivo preciso è nell'Output Log, e si può riprovare disabilitando e riabilitando le collisioni. Per riprovare il processo di generazione, eliminare prima il file di cache .collision.ply accanto al modello.

Alternativa manuale senza generazione automatica

Se si vuole controllare completamente la forma della collisione, o i dati non sono adatti a derivarla, si può anche lasciare disattivata la generazione automatica e montare la collisione per conto proprio nella scena:

• Blocking Volume: usare i blocking volume del motore per costruire terreno, pareti e altre aree che devono bloccare. Adatto a forme regolari e l'opzione più economica
• Mesh approssimata: posizionare una mesh che corrisponde alla forma del 3DGS e abilitarne le collisioni. Adatto a scene con forme complesse. Questa mesh può riutilizzare la mesh proxy cambiandone il preset di collisione in blocco

Questi due approcci manuali non utilizzano il meccanismo di caricamento delle collisioni LCC, quindi non sono influenzati da CollisionLoadMaxDistance e non vengono scambiati dentro e fuori al movimento della camera.

Aree di ritaglio della collisione

La collisione può essere ritagliata insieme ai volumi di taglio e ai piani di sezione, così che l'estensione della collisione resti uguale all'immagine renderizzata. Per impostazione predefinita, i volumi di taglio influiscono solo sul rendering: l'immagine dell'area tagliata scompare, ma la collisione resta e il personaggio urta contro un muro invisibile. Abilitando il ritaglio della collisione, la collisione viene rimossa anche all'interno dell'area tagliata.

Passaggi

1. Aggiungere e configurare un volume di taglio o un piano di sezione sul LCC Actor secondo Modifica della scena e verificare che l'immagine renderizzata venga tagliata come previsto.
2. Selezionare Abilita collisione (bEnableCollision) nel pannello del LCC Actor.
3. Selezionare Ritaglio della collisione nel pannello; la collisione viene ritagliata subito secondo il volume di taglio, e nell'area tagliata non vengono più generati corpi di collisione.

L'immagine seguente confronta, con la modalità di visualizzazione «visibility collision», il contorno di collisione prima e dopo l'abilitazione del ritaglio della collisione. Quando è disattivato, la collisione copre l'intera area:

Senza selezionare «Ritaglio della collisione»: il contorno di collisione copre l'intera area

Una volta abilitato, la collisione all'interno del volume di taglio viene rimossa anch'essa, come il rendering:

Con «Ritaglio della collisione» selezionato: la collisione all'interno dell'area tagliata viene rimossa anch'essa

Suggerimento: il ritaglio della collisione richiede di abilitare prima la collisione, e funziona anche con la collisione generata automaticamente per i modelli a file singolo.

Query dello stato della collisione ed eventi

È possibile interrogare lo stato corrente della collisione, oppure rimanere in ascolto delle sue variazioni di stato, per logiche come «collocare il personaggio solo quando la collisione è pronta» o «mostrare l'avanzamento durante la generazione»:

• GetCollisionState() restituisce lo stato corrente: NoCollision (disattivata o nessun modello) / Generating (il modello a file singolo sta generando la mesh di collisione) / Loading (la collisione vicina alla camera è in caricamento / baking) / Loaded (la collisione vicina alla camera è pronta) / Failed (non è possibile fornirla).
• L'evento OnCollisionStateChanged viene inviato quando lo stato cambia, cosa che permette di abilitare il movimento del personaggio dopo Loaded, oppure di mostrare un avviso durante Generating.

Per l'interfaccia completa e le convenzioni d'uso, vedere ULCCComponentBase - Query dello stato.

Suggerimento: Loaded significa che la collisione vicina alla camera è pronta, non che l'intero modello abbia collisione; la collisione continua a essere caricata in streaming al movimento della camera. Quando serve solo «non attraversare il terreno sotto i piedi», basta attendere Loaded; per la collisione in lontananza, aumentare la distanza di caricamento.

Note

• Una volta abilitate le collisioni, il LineTrace di Unreal Engine può essere usato per i test dei raggi contro i corpi di collisione, e anche l'estensione del test è limitata dall'estensione di caricamento
• La memoria usata dai dati di collisione è visibile in Collision Data Usage di stat xgrids, il costo degli aggiornamenti in Update Collision, e il significato delle voci in Parametri di prestazione