Costruire dati di adiacenza del triangolo

Dato un elenco di indici triangolari, come si fa esattamente a convertirlo in un elenco di indici con adiacenza per uno shader di geometria?

Si noti che qui stiamo parlando rigorosamente di indici - i vertici sono presenti, ma ci concentreremo esclusivamente sugli indici, perché possiamo usarli per abbinare vertici duplicati senza dover entrare in confronti a virgola mobile e epsilon - che il lavoro ha già fatto.

So che per ogni dato triangolo nell'elenco, gli indici {0, 1}, {1, 2} e {2, 0} (o {n, n + 1}, {n + 1, n + 2}, { n + 2, n} se preferisci) ne formano i bordi; l'elenco degli indici è ben formato e rispetta correttamente l'ordine degli avvolgimenti.

So che per ogni dato bordo, possiamo cercare nell'intero elenco un altro triangolo che utilizza due di quegli indici, e il terzo indice di quel triangolo è quello da usare per completare il triangolo adiacente per quel bordo.

So che nella lista di adiacenza ogni triangolo originale è rappresentato da 6 indici, gli indici originali vanno negli slot 0, 2, 4; i nuovi indici per completare l'adiacenza vanno negli slot 1, 3, 5. L'indice da completare per il bordo {0, 1} va nello slot 1, l'indice da completare per il bordo {1, 2} va nello slot 3, l'indice per completare per il bordo {2, 1} va nello slot 5.

Che cosa ho provato?

Ho provato a forzarlo brutalmente, e sì, funzionerà, ma sto cercando un approccio più elegante.

Ho provato il costruttore di edge list di Eric Lengyel, ma (1) non sembra rispettare l'ordine originale del triangolo, (2) non sembra rispettare l'ordine degli avvolgimenti, (3) è chiaro come il fango dove andare il prossimo dopo aver creato la lista dei bordi e (4) ho il sospetto di un codice di esempio che presenti errori così evidenti come "triangleIndex" contro "faceIndex" - l'autore ha persino compilato il codice, non importa se eseguito verificarlo?

Quindi - qualche suggerimento o puntatore da qui in poi?

Vorrei provare a utilizzare una tabella hash per questo (ad esempio, std::unordered_mapse sei in C ++). Costruisci una tabella hash che mappa da un mezzo bordo (espresso come una coppia di indici, in ordine) al terzo indice del triangolo a cui appartiene il mezzo bordo.

Questo può essere creato semplicemente ripetendo l'elenco dei triangoli e aggiungendo i tre semigordi di ciascun triangolo alla tabella hash. Se il tuo indice iniziale avesse una coppia di triangoli adiacenti, (0, 1, 2, 2, 1, 3), finiresti con una tabella hash contenente:

(0, 1) -> 2
(1, 2) -> 0
(2, 0) -> 1
(2, 1) -> 3
(1, 3) -> 2
(3, 2) -> 1

Si noti che i bordi (1, 2) e (2, 1) appaiono entrambi nella tabella, che rappresentano i due lati del bordo e che puntano al terzo vertice di ciascuno dei due triangoli.

Quindi, per creare i dati di adiacenza tutto ciò che devi fare è scorrere nuovamente sull'elenco dei triangoli e interrogare i bordi di ciascun triangolo con l'avvolgimento opposto. Pertanto, durante l'elaborazione del triangolo (0, 1, 2) si interrogano i bordi (1, 0), (2, 1) e (0, 2). Questo troverà il vertice opposto di ciascun bordo, se esiste.

Guarda la struttura dei dati half-edge .

L'idea è approssimativamente che si memorizza un elenco di metà bordi , ad esempio la metà di un bordo particolare attaccato a una faccia particolare. Questa struttura quindi memorizza anche le informazioni sul mezzo bordo corrispondente per la faccia adiacente.

La struttura dei dati fa domande su connettività, adiacenza e così via molto efficienti. Esistono algoritmi per generare i dati in modo efficiente, sebbene non necessariamente "runtime di gioco" in modo efficiente (probabilmente vorrai farlo offline nella tua pipeline di risorse).

Vedi anche questi post sul blog . Credo che la struttura e gli algoritmi siano anche nel rilevamento delle collisioni in tempo reale, ma non ricordo per certo e non ne ho una copia in ufficio.