C'è un modo in cui si potrebbe piegare un oggetto, come un cilindro o un piano usando OpenGL?

Sono un principiante di OpenGL (sto usando OpenGL ES 2.0, se questo è importante, anche se sospetto, la matematica conta di più in questo caso, quindi è in qualche modo indipendente dalla versione), capisco le basi: tradurre, ruotare, trasformazioni di matrice, ecc. Mi chiedevo se esiste una tecnica che ti consente di cambiare effettivamente la geometria dei tuoi oggetti (in questo caso piegandoli)?

Qualsiasi link, tutorial o altri riferimenti sono i benvenuti!

Quello che dovresti fare per "piegare" un oggetto è applicare una combinazione appropriata di traslazione / rotazione / ridimensionamento solo a qualche sottoinsieme dei vertici dell'oggetto in questione - probabilmente ponderando di conseguenza tale trasformazione.

Per fare questo è un aspetto piacevole richiederà l'uso di più vertici di quanto potrebbe essere altrimenti strettamente necessario per descrivere la mesh originale. Ad esempio, un semplice cilindro può avere solo vertici alle due estremità, ma se vuoi che quel cilindro si pieghi nel mezzo, avrai bisogno anche di vertici.

Se tutto ciò che ti interessa è una deformazione una tantum specifica di forme molto semplici (come il tuo piano di cui sopra), probabilmente potresti semplicemente farlo manualmente. Ad esempio, decidere l '"asse di piega" per il piano e calcolare le trasformazioni appropriate per ogni fila di vertici del piano per ottenere la rotazione appropriata attorno a quell'asse di piegatura in base alla loro distanza da esso, quindi applicarlo alla geometria (possibilmente sul CPU come sarebbe la più semplice, almeno inizialmente). Ma una tale tecnica non si ridimensionerebbe bene e sarebbe molto noiosa.

Poiché può essere così ingombrante capire correttamente come ponderare una trasformazione per ogni singolo vertice in un set per ottenere la deformazione desiderata (specialmente per oggetti più pratici e complicati), molti giochi usano una tecnica chiamata animazione scheletrica . Ad un livello elevato questo comporta l'associazione di un insieme separato di geometria (lo "scheletro") alla tua mesh. Quella geometria rappresenta le ossa del tuo oggetto e tu definisci (spesso negli strumenti di modellazione) una mappatura tra i vertici del modello reale e le ossa dello scheletro - quali ossa sono associate a ciascun vertice e quanto quell'osso influisce sulla deformazione di quel vertice. Quindi lo scheletro viene animato direttamente e l'animazione viene trasferita al modello reale tramite la relazione tra le ossa e i loro vertici.

Tipicamente in questa tecnica, la mappatura tra scheletro e mesh reale è definita al momento della produzione degli asset. Le animazioni possono anche essere costruite in seguito, oppure possono essere costruite in modo procedurale in fase di esecuzione. L'applicazione delle trasformazioni di animazione alla mesh reale avviene in fase di esecuzione. Generalmente non vengono generati nuovi vertici in fase di runtime, il che significa che l'intervallo di deformazioni di bell'aspetto è implicitamente fissato nella mesh quando viene creato originariamente.

In teoria, si potrebbe anche applicare la tassellatura e la suddivisione alla mesh in fase di esecuzione in base all'analisi delle trasformazioni nell'animazione, e quindi produrre i vertici appropriati per creare un'animazione che non era necessariamente pianificata. Non sono a conoscenza, sbrigativamente, di alcun documento su questo argomento.

Guarda anche:

• http://www.opengl.org/wiki/Skeletal_Animation su web.archive.org
• http://content.gpwiki.org/index.php/OpenGL:Tutorials:Basic_Bones_System su web.archive.org

Per l'effettiva matematica della deformazione, questo può diventare molto complicato, perché non inizi qui? .

Ora parlerò di come puoi applicarlo, supponendo che tu abbia già ottenuto la matematica su come farai giù le tue deformazioni.

2 modi:

1) Ogni fotogramma, visita ogni vertice nel modello di cilindro e sfalsalo in qualche modo.

2) Offset i vertici nello shader di vertice durante il rendering. OpenGL ES 2.0 supporta shader di vertici. Quindi sei fortunato, in un certo senso.

Vuoi deformare l'oggetto così come appare sullo schermo o vuoi deformare l'oggetto in modo che ogni oggetto nel gioco sappia che è stato deformato?

Se deformi l'oggetto nel vertex shader, ciò accade solo immediatamente prima della visualizzazione / rasterizzazione , quindi questo significa che nessuno degli oggetti di gioco saprà della deformazione . Questo va bene se stai semplicemente facendo uno screen saver, o se le deformazioni sono così piccole che non hanno alcun impatto sulla forma collidibile dell'oggetto.

Quando deformi la geometria nel vertex shader, i vertici originali del modello in realtà non si muovono ( sembrano solo muoversi ).

Deformazione nello shader di vertici

deformata:

deforme

Questo è dal capitolo 6 del tutorial cg , (programma n. 14).

Il codice shader per produrre questa deformazione è qualcosa di simile

// choose a displacement amount
float displacement = scaleFactor * 0.5 * sin(position.y * frequency * time) + 1 ;

// displace it in the direction of the normal
float4 displacementDirection = float4(normal.x, normal.y, normal.z, 0) ;

// move the vertex
float4 newPosition = position + displacement * displacementDirection ;

// transform (as normal)
oPosition = mul(modelViewProj, newPosition) ;

Quindi puoi vedere, questo accade A DESTRA PRIMA della visualizzazione (lo shader di vertice accade sulla GPU) quindi il codice CPU non ha praticamente modo di accedere alla posizione del vertice trasformato (ci sono modi per inviare dati dalla GPU alla CPU (principalmente tramite texture) ma noi non ci andrò).

Quello che stai cercando di ottenere è fondamentalmente un sottoinsieme del tema della deformazione della mesh. Ma dal momento che sei un mendicante, temo che questo tipo di informazioni potrebbe essere un po 'troppo strano per ora. Cercherò di stabilire le nozioni di base però.

Per fare ciò avrai bisogno di due cose:

1. La tua mesh deve avere abbastanza vertici da trasformare. Ad esempio, se è un piano, devi assicurarti che sia effettivamente creato come una sorta di griglia, con molti vertici che puoi deformare. Stessa cosa con un cilindro. Potrebbe essere possibile raggiungere questo obiettivo in fase di esecuzione con tassellatura, ma non so molto sull'argomento.
2. È necessario utilizzare uno shader di vertice per deformare i vertici. Fondamentalmente lo shader di vertice si occupa di calcolare la posizione trasformata finale di ciascun vertice, in modo da poter cogliere l'occasione per applicare eventuali deformazioni ad essi.

Non sono sicuro di quanto sarà utile, ma dai un'occhiata a questa risorsa OpenGL, poiché sembra essere proprio il tipo di cosa di cui hai bisogno:

http://www.ozone3d.net/tutorials/mesh_deformer_p3.php#part_3

Screenshot da quel link:

modificare

Ho appena visto la risposta di Josh e sono d'accordo, l'animazione scheletrica è anche un modo molto elegante per incapsulare questo problema, specialmente quando le tue deformazioni iniziano a diventare più complesse e più difficili da rappresentare matematicamente.

Ricorda, tuttavia, entrambi i punti sopra riportati si applicano comunque: puoi solo deformare i vertici, quindi ovviamente devono esistere in primo luogo, motivo per cui la tua mesh deve avere una discreta quantità di densità di vertici. E di solito è lo shader di vertice che guida l'animazione scheletrica e fa la fusione dei vertici e così via.

E a proposito, puoi fare anche questi sulla CPU, ma al giorno d'oggi è di solito un'opzione migliore per farli sulla GPU, motivo per cui metto l'accento sullo shader di vertici e dovresti esaminarlo. A livello di programmazione non è poi tanto più difficile che farlo con la CPU.