Introduzione

Benvenuti sulla pagina del progetto Teapot Designer!
Il progetto è nato con l'intenzione di sperimentare con le librerie Vulkan al fine di sviluppare un progetto per il corso di Geometria Computazionale.
Il risultato è stato un programma in grado di partire dalla classica Utah Teapot, uno dei modelli standard utilizzati nella computer graphics, e crearne una versione in grado di soddisfare determinate proprietà geometriche. Successivamente è possibile modificarne ulteriormente l'aspetto in modo da creare la propria teiera personalizzata.
In conclusione abbiamo aggiunto anche la possibilità di esportare la propria teiera per aprirla in altri programmi di modellazione 3D.

Superfici di Bézier

Alla base della teoria utilizzata per lo sviluppo del programma ci sono le superfici di Bézier che sono prodotti tensoriali di curve di Bézier e, grazie alle loro proprietà, sono largamente utilizzate nell'ambito della computer grafica.

Una superficie di Bézier costituisce un'applicazione definita sul quadrato unitario del piano \((u,v)\) a valori in \(\mathbb{E^3}\); si studia poi come questa applicazione si comporta intervenendo sul suo \(bigrado(m,n)\) con \(m,n \ge 1\).
Il bigrado dipende dal grado \(m\) e \(n\) delle curve di Bézier di cui la superficie è prodotto tensoriale.

Si ottiene una griglia combinatoria che modella il poliedro di controllo, il quale identifica la superficie di Bézier. La griglia è un oggetto combinatorio ben diverso dal poliedro stesso. Ad ogni quadrato della griglia corrisponde un quadrilatero sghembo del poliedro e con la rappresentazione combinatoria della griglia è possibile individuare quali altri quadrilateri sghembi sono adiacenti ad esso tramite l'osservazione delle adiacenze dei quadrati nella griglia stessa.

\(P_{i,j}\) sono i punti del poliedro di controllo di dimensioni \((m+1)(n+1)\).
Ogni punto della superficie è in funzione di due parametri e dei punti del poliedro.
La rappresentazione matematica, che utilizza i polinomi di Bernstein, del generico punto di una superficie \((m+1)(n+1)\) è data da: $$P(u,v) = \sum_{i=0}^m \sum_{j=0}^n B_i^m(u) B_j^n(v) p_{i,j}$$ \(u\) e \(v\) sono parametri compresi tra 0 e 1, \(B_i^m\) e \(B_j^n\) sono i polinomi di Bernstein e \(p_{i,j}\) sono i punti del poliedro.

Prima di parlare del prodotto tensoriale ci soffermiamo sul concetto di interpolazione bilineare in relazione ad una superficie di Bézier con \(bigrado(1,1)\): si tratta di adattare una superficie tra 4 punti distinti.
I vertici del quadrato unitario definiscono un tetraedro di controllo e siano \(b_{0,0},b_{0,1},b_{1,0},b_{1,1}\) 4 punti distinti, immagini in \(\mathbb{E^3}\) dei vertici; l'insime dei punti in \(\mathbb{E^3}\) della forma: $$b(u,v) = \sum_{i=0}^1 \sum_{j=0}^1 B_i^1 B_j^1 b_{i,j} = (1 − u)[(1 − v)b_{0,0} + vb_{0,1}] + u[(1 − v)b_{1,0} + vb_{1,1}] $$ è un paraboloide iperbolico passante per i quattro punti \(b_{i,j}\). Esso rappresenta la superficie di Bézier di \(bigrado(1,1)\) relativa al poliedro di controllo definito dai \(b_{i,j}\). L'applicazione a valori in \(\mathbb{E^3}\) basata sulle formule date è lineare sia in \(u\) che in \(v\) ed interpola a partire dai punti dati. La superficie generata viene detta interpolante bilineare e può essere visto come una mappa del quadrato unitario \(0 \le u,v \le 1\) nel piano \((u,v)\); si dice dunque che il quadrato unitario è il dominio dell'interpolante e la superficie è il suo range.
A rette parallele agli assi nel dominio corrispondono curve nel range, queste sono dette curve isoparametriche.
Per valutare l'interpolante bilineare si possono usare due passi distinti che ricorrono anche al momento dell'interpolazione nel prodotto tensoriale nel caso di superfici con \(bigrado(m,n)\):
si calcolano dei punti intermedi parametrizzando due lati del poliedro corrispondenti a \(v=0,v=1\) oppure \(u=0,u=1\) (alla fine si ottengono i medesimi risultati).
I due lati scelti (nel nostro caso abbiamo posto \(u=0,u=1\)) vengono trattati come se fossero curve di Bézier di grado \(1\) sull’intervallo \([0, 1]\); da qui otteniamo: $$ b_{0,0}^{0,1} = (1 − v)b_{0,0} + vb_{0,1} $$ $$ b_{1,0}^{0,1} = (1 − v)b_{1,0} + vb_{1,1} $$ In seguito, se si fissa \(v\) ad un valore dato, si parametrizzano le curve aventi come punti iniziali e finali quelli ottenuti dalle due equazioni date sopra: $$ b(u,v) = b_{0,0}^{1,1} = (1-u)b_{0,0}^{0,1} + ub_{1,0}^{0,1} $$ L'interpolazione lineare in questione è anche una mappa affine e, dato che l'interpolazione lineare viene applicata sia lungo la direzione \(u\) che lungo la direzione \(v\), nello specifico abbiamo una mappa biaffine per interpolazioni bilineari. La superficie di Bézier così ottenuta è anche un foglio semplice.
Nel caso di una superficie di Bézier \(bigrado(m,n)\), si può generalizzare quanto detto precedentemente attraverso un'applicazione ripetitiva dell'interpolazione lineare espressa dall'algoritmo ricorsivo di de Casteljau per le superfici che permette di creare una rete di controllo, anche detta rete di Beziér.
All'interno di questa rete si formano dei quadrilateri dentro i quali, in maniera ricorsiva, si vanno a individuare punti che formano nuovi quadrilateri i quali diminuiscono in numero ad ogni iterazione sino a convergere ad un quadrilatero formato da un unico punto che rappresenta il valore cercato. Questo vale nel caso in cui si abbia \(m=n\), altrimenti si troverà un segmento che individua una curva di Beziér e da li sarà necessario trovare il punto unico ricercato utilizzando l'algoritmo ricorsivo di de Casteljau per le curve.
I punti intermedi sono calcolati dall'algoritmo, per \(i = 0,...,m − r\) e \(j = 0,..., n − s\) e con \(r = 1,..., m\) e \(s = 1,..., n\), nel seguente modo: $$ b_{i,j}^{r,s} = (1 − u)[(1 − v)b_{i,j}^{r-1,s-1}(u,v) + vb_{i,j+1}^{r-1,s-1}(u,v)] + u[(1 − v)b_{i+1,j}^{r-1,s-1}(u,v) + vb_{i+1,j+1}^{r-1,s-1}(u,v)] $$ Si assume che \(b_{i,j}^{0,0}(u,v)=b_{i,j}\) e che \(b_{0,0}^{m,n}(u,v)=b(u,v)\) che è il valore del generico punto che stiamo cercando. Adesso vogliamo formalizzare il concetto di prodotto tensoriale per descrivere matematicamente una superficie: questa è ottenuta dal movimento dei punti di controllo di una curva di Bèzier lungo altre curve.
Per prima cosa si assume che la curva in movimento sia una curva di Bézier di grado costante \(m\); questa curva è determinata da una serie di punti di controllo e ogni punto originale si muove nello spazio lungo una curva. Le curve lungo le quali si muovono i punti di controllo si assume che siano tutte curve di Bézier dello stesso grado.
I punti della prima curva di grado \(m\) sono dati da: $$ b^m(u) = \sum_{i=0}^{m} b_i B_i^m (u) $$ Ogni punto \(b_i\) si trova lungo una curva di Bézier di grado \(n\): $$ b_i = b_i(v) = \sum_{j=0}^n b_{i,j} B_j^n (v) $$ Combinando le due equazioni abbiamo: $$b^{m,n}(u,v) = \sum_{i=0}^m \sum_{j=0}^n b_{i,j} B_i^m(u) B_j^n(v)$$ Equazione che ci permette di trovare il generico punto di una superficie di Bézier come già anticipato a inizio sezione.

Condizioni di continuità

Dato che la complessità di una superficie di Bézier cresce con l'aumento del numero dei punti di controllo che vanno a costituire il poliedro di controllo, le teiere generate dal programma sono ottenute attraverso l'incollamento di diverse superfici, anche dette patches, di Beziér.
Un aumento dei punti, oltre che a portare ad un aumento del grado delle superfici, porterebbe anche ad un aumento considerevole delle capacità computazionali richieste al programma per generare le varie superfici.
Nel nostro caso sono state impiegate in totale 28 patches per generare una singola teiera ed ogni patch è una superficie bicubica, dunque con \(bigrado(3,3)\), per un totale di \(4 \ast 4\ = 16\) punti di controllo per patch.

L'incollamento di superfici di grado minore risulta quindi necessario per ridurre la complessità totale richiesta per la generazione di una teiera; inoltre l'incollamento viene eseguito seguendo opportune condizioni di continuità (selezionabili manualmente dall'utente in base alle sue necessità) le quali ci permettono di generare le diverse parti della teiera (corpo, manico, becco e coperchio) dando l'impressione che queste siano effettivamente formate da un unico foglio con un grado di complessità maggiore.

Vediamo adesso nel dettaglio quali sono queste condizioni di continuità che vengono garantite al momento dell'incollamento delle patches:

• Con il vincolo di continuità \(C0\) si assicura che due superfici contigue condividano lo stesso bordo. Non essendoci controlli sulle derivate lungo il bordo, in prossimità dell'incollamento è possibile la formazione di punti angolosi.
  Supponendo di avere due superfici da incollare lungo i bordi in corrispondenza di \(u=0\) e \(u=1\), al variare di \(v\), deve valere che: $$ P(1,v) = Q(0,v) $$ Dove \(P(u,v)\) e \(Q(u,v)\) sono rispettivamente i punti della prima patch e quelli della patch successiva.
  

• Con il vincolo di continuità \(C1\) si assicura che per due superfici contigue valga quanto detto per il vincolo \(C0\) ed inoltre il valore della derivata prima, fatta rispetto ad \(u\) oppure a \(v\) a seconda dei casi, lungo il bordo sia lo stesso per entrambe le patch, eliminando la presenza di punti angolosi.
  Supponendo di trovarci ancora nel caso precedentemente descritto, deve valere che: $$ {{\partial P} \over {\partial u}} (1,v) = {{\partial Q} \over {\partial u}} (0,v) $$
  

• Con il vincolo di continuità \(C2\) si assicura che per due superfici contigue valga quanto detto per il vincolo \(C1\) e \(C0\) ed inoltre il valore della derivata prima, fatta rispetto ad \(u\) oppure a \(v\) a seconda dei casi, lungo il bordo sia lo stesso per entrambe le patch, garantendo la stessa "curvatura".
  Supponendo di trovarci ancora nel caso precedentemente descritto, deve valere che: $$ {{\partial^2 P} \over {\partial u^2}} (1,v) = {{\partial^2 Q} \over {\partial u^2}} (0,v) $$

Quanto detto vale per i punti \(P\) con \(u=1\) e per i punti \(Q\) con \(u=0\) ma, anche nel caso di patches contigue lungo i bordi per cui vale \(v=1\) nella prima patch e \(v=0\) nella seconda, si ha necessità di eseguire gli stessi controlli per i vincoli di continuità con l'unica differenza che le derivate parziali vengono effettuate rispetto a \(v\) anzi che \(u\).
Per questo motivo, in seguito, la trattazione esaminerà solo il caso di patches da incollare lungo i bordi in corrispondenza di \(u=0\) e \(u=1\).

Il vincolo di continuità \(C0\) viene sempre garantito e rispettato al momento della costruzione di ogni teiera, facendo coincidere i punti di controllo delle patches adiacenti tra loro sia in orizzontale che in verticale.

Le superfici di Bézier godono della proprietà per cui i valori delle derivate lungo i bordi dipendono dai punti di controllo vicini ai bordi stessi:
la derivata prima dipende dal punto lungo il bordo e dal punto precedente o successivo, a seconda di quale bordo si stia prendendo in cosiderazione;
la derivata seconda dipende dal punto lungo il bordo e dai due punti precedenti o successivi, a seconda di quale bordo si stia prendendo in cosiderazione.
Vediamo adesso come vengono determinate le condizioni di continuità per i casi \(C1\) e \(C2\):

• \(C1\):
  questa condizione garantisce che la variazione del piano tangente alla superficie formata dall'incollamento di due patch sia continua lungo i bordi che sono a contatto.
  Deve valere: $$ {{\partial P} \over {\partial u}} (u,v) = {{\partial Q} \over {\partial u}} (u,v) $$ con: $$ {{\partial P} \over {\partial u}} (u,v) = m \sum_{i=0}^{m-1} B_i^{m-1}(u) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{1,0}(P_{i,j})$$ $$ {{\partial Q} \over {\partial u}} (u,v) = m \sum_{i=0}^{m-1} B_i^{m-1}(u) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{1,0}(Q_{i,j}) $$ \(\Delta^{1,0}\) è l'operatore di forward difference e, in relazione a un generico punto \(P_{i,j}\), vale: $$\Delta^{1,0}(P_{i,j}) = P_{i+1,j} - P_{i,j}$$ Inoltre per le proprietà di interpolazione agli estremi delle curve di Bézier, la derivata prima nei punti iniziali e finali vale: $$ {{\partial P} \over {\partial u}} (1,v) = m \sum_{j=0}^{n} B_j^n(v) \Delta^{1,0}(P_{m-1,j}) $$ $$ {{\partial Q} \over {\partial u}} (0,v) = m \sum_{j=0}^{n} B_j^n(v) \Delta^{1,0}(Q_{0,j}) $$ Deve allora valere \(\forall v \in [0,1]\): $$ m \sum_{j=0}^{n} B_j^n(v) \Delta^{1,0}(P_{m-1,j}) = m \sum_{j=0}^{n} B_j^n(v) \Delta^{1,0}(Q_{0,j}) $$ Il che si riduce a verificare che \(\forall j = 0,...,n\) valga: $$ \Delta^{1,0}(P_{m-1,j}) = \Delta^{1,0}(Q_{0,j}) \iff P_{m,j} - P_{m-1,j} = Q_{1,j} - Q_{0,j} $$ Dato che per \(C0\) deve valere che \(P_{m,j} = Q_{0,j}\), si ha che: $$ P_{m,j} = Q_{0,j} = \frac{Q_{1,j} + P_{m-1,j}}{2} $$ Dunque i punti devono essere collineari e il punto di giunzione deve essere equidistante dai suoi vicini.
  

• \(C2\):
  Deve valere: $$ {{\partial^2 P} \over {\partial u^2}} (u,v) = {{\partial^2 Q} \over {\partial u^2}} (u,v) $$ con: $$ {{\partial^2 P} \over {\partial u^2}} (u,v) = m(m-1) \sum_{i=0}^{m-2} B_i^{m-2}(u) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(P_{i,j})$$ $$ {{\partial^2 Q} \over {\partial u^2}} (u,v) = m(m-1) \sum_{i=0}^{m-2} B_i^{m-2}(u) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(Q_{i,j}) $$ \(\Delta^{2,0}\) è l'operatore di forward difference iterato e, in relazione a un generico punto \(P_{i,j}\), vale: $$\Delta^{i,0}(P_{i,j}) = \Delta^{i-1,0}(P_{i+1,j}) - \Delta^{i-1,0}(P_{i,j}) \implies \Delta^{2,0}(P_{i,j}) = \Delta^{1,0}(P_{i+1,j}) - \Delta^{1,0}(P_{i,j}) = (P_{i+2,j} - P_{i+1,j}) - (P_{i+1,j} - P_{i,j}) = P_{i+2,j} - 2P_{i+1,j} + P_{i,j} $$ Ora possiamo ricavare i valori delle derivate seconde agli estremi: $$ {{\partial^2 P} \over {\partial u^2}} (1,v) = m(m-1) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(P_{m-2,j}) = m(m-1) \sum_{j=0}^{n} B_j^{n}(v) (P_{m,j} - 2P_{m-1,j} + P_{m-2,j}) $$ $$ {{\partial^2 Q} \over {\partial u^2}} (0,v) = m(m-1) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(Q_{0,j}) = m(m-1) \sum_{j=0}^{n} B_j^{n}(v) (Q_{2,j} - 2Q_{1,j} + Q_{0,j}) $$ Deve allora valere \(\forall v \in [0,1]\): $$ m(m-1) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(P_{m-2,j}) = m(m-1) \sum_{j=0}^{n} B_j^{n}(v) \Delta^{2,0}(Q_{0,j}) $$ Il che si riduce a verificare che \(\forall j = 0,...,n\) valga: $$ P_{m,j} - 2P_{m-1,j} + P_{m-2,j} = Q_{2,j} - 2Q_{1,j} + Q_{0,j} $$ Dato che per \(C0\) deve valere che \(P_{m,j} = Q_{0,j}\) e per \(C1\) deve valere che \(2Q_{0,j} = Q_{1,j} + P_{m-1,j}\), si ha che: $$ Q_{2,j} - P_{m-2,j} = 4(Q_{1,j} - Q_{0,j}) = 4(P_{m,j} - P_{m-1,j}) = 4 \Delta^{1,0}(Q_{0,j}) = 4 \Delta^{1,0}(P_{m-1,j}) $$

Da queste equazioni sono stati ricavati gli algoritmi usati per la generazione delle teiere e la propagazione delle varie modifiche applicabili sempre nel rispetto dei vincoli di continuità.

Vulkan

Il progetto è stato interamente realizzato utilizzando C++ come linguaggio di programmazione, wxwidgets come libreria per la creazione dell'interfaccia grafica e Vulkan come libreria grafica per disegnare su schermo le teiere 3D.
Vulkan è una API grafica a basso livello che è stata sviluppata recentemente per sostituire OpenGl nel campo della grafica per il tempo reale e, rispetto a quest'ultima, permette di avere performance migliori e un controllo più fine sull'intera pipeline (la "sequenza di operazioni") usata dalla GPU (la scheda video) per effettuare il rendering.
Tali migliorie hanno un costo: una maggiore complessità d'uso della libreria. Nell'immagine che segue si può vedere in modo semplificato quali siano le fasi della pipeline grafica che Vulkan fornisce per poter disegnare e renderizzare un'immagine:

Vulkan permette di disegnare su schermo superfici 3D "solide", linee e punti. Per disegnare le superfici è necessario passare sequenze di punti che identificano dei triangoli; le schede video infatti lavorano principalmente su triangoli, tutte le operazioni geometriche vengono eseguite in parallelo e per questo hanno bisogno di matrici per effettuare le varie trasformazioni.
Nel nostro caso specifico le teiere sono formate da \(28\) patches di Beziér e per ogni patch, tramite le equazioni Bernstein, vengono generati \(20 \ast 20 = 400\) punti. Questi punti vengono presi \(4\) alla volta andando così a formare un quad che viene spezzato, lungo la diagonale, in due triangoli con due punti in comune.
Alla scheda video vengono passati in seguito un array di tutti i singoli vertici distinti l'uno dall'altro (il quale va a formare il vertex buffer mostrato nell'immagine sopra) e un array di indici (l'index buffer dell'immagine sopra) che indicizzano i singoli vertici. Questo array di indici è ottenuto dalla suddivisione, introdotta sopra, in quad e poi in triangoli di ogni patch. Questo permette alla scheda video di leggere \(3\) vertici alla volta e di generare da questi un triangolo che insieme a tutti gli altri triangoli vanno a formare il modello 3D finale che è possibile vedere su schermo. Il fatto che i triangoli sono collegati dai punti in comune ci permette di avere una forma geometrica continua, senza "buchi" e all'aumentare dei punti è possibile avere forme geometriche sempre più smussate che fanno notare di meno la triangolarizzazione che sta alla base della loro creazione.

Vediamo ora nel dettaglio come vulkan ci permette di disegnare su schermo le superfici 3D. All'inizio bisogna creare una serie di risorse di base che verranno utilizzate da Vulkan per effettuare tutte le operazioni in seguito:

• Si inizializza la libreria;

• si crea una superficie (una finestra) sulla quale effettuare la presentazione delle immagini generate;

• si interrogano i device fisici (le schede video) presenti sul pc per sceglierne, tra quelli che supportano Vulkan, il più adatto al rendering che si deve effettuare;

• da questo device scelto se ne crea una istanza logica sulla quale viene allocata una struttura dati (detta command pool) sulla quale verranno eseguiti i comandi diretti alla scheda video (ottenuti tramite i command buffers) i quali comunicano come e cosa disegnare;

• si inizializza una struttura dati chiamata swap chain che mette a disposizione delle code e una serie di immagini su cui andare a disegnare l'immagine finale che poi vedremo presentata su schermo;

• ad ogni immagine fornita dalla swap chain viene associata una struttura dati chiamata image view che ci permette di definire quali sono le modalità di utilizzo dell'immagine e quali parti di questa ne sono soggette;

• viene creato il render pass che ci permette di specificare degli "attachments", che ci forniscono le tipologie dei layout delle immagini su cui si va a disegnare durante l'esecuzione di una derteminata pipeline. Nel nostro caso abbiamo un attachment che definisce il colore e uno che definisce la profondità di ciò che si va a disegnare;

• infine, dato che in Vulkan non si ha accesso diretto ad un'immagine, a tutte le immagini fornite dalla swap chain viene collegato una struttura dati chiamata frame buffer. Questo viene legato ad un determinato render pass e quindi ai suoi attachments e utilizza le image view della swap chain come attachment per la scrittura dei colori e un'altra image view come attachment per la scrittura della profondità.

Ora che abbiamo definito i passaggi di base possiamo passare a vedere come viene creata una pipeline specifica al disegno delle teire, ma prima introduciamo una parte fondamentale di ogni pipeline: gli shaders.
Gli shaders sono parti programmabili della pipeline grafica eseguita dalla scheda video. In pratica sono dei "programmi" che vengono scritti in un linguaggio simile al C, nel nostro caso il GLSL, e vengono eseguiti in una specifica sequenza che vediamo esemplificata nell'immagine sottostante:

Le fasi colorate in verde non sono modificabili e la loro implementazione dipende dalla scheda video, le altre fasi invece sono programmabili tramite appunto l'utilizzo degli shaders. Nel nostro caso vengono utilizzati un vertex shader per realizzare le trasformazioni geometriche agendo sui singoli vertici e un fragment shader per definire l'aspetto finale e il colore dell'immagine che viene disengata su schermo.

Vediamo ora nei dettagli la pipeline implementata:

• Utilizzando algoritmi basati sulle equazioni riportate nei primi due paragrafi della teoria vengono generate le coordinate di tutti i vertici che vanno a comporre la teriera e, tramite questi vertici, si vanno a riempire gli array di vertici e indici di cui abbiamo già trattato.

• Questi array non sono direttamente manipolabili dalla scheda video e quindi devono essere copiati dentro strutture dati specifiche di Vulkan, i vertex e index buffers, che vengono poi passate alla scheda video permettendo di manipolarne i dati attraverso l'utilizzo degli shaders;

• vengono creati i descriptor set layout che ci permettono di definire come determinate risorse vadano messe insieme in un descriptor set (i dettagli li vediamo più avanti);

• vengono preparate le pipeline, queste vengono collegate: agli shader, al descriptor set layout, alle informazioni sulle strutture dati usate per definire i vertici, alle informazioni su come trattare il blending dei colori, alle informazioni su come definire i test di profondità sugli oggetti da disegare,alle informazioni sulle modalità di disegno e tante altre ancora. Nel nostro caso abbiamo due pipeline: una che disegna i triangoli delle teiere e una che disegna, in wireframe, rette composte da due punti per volta per rappresentare i piani su cui giacciono i punti di controllo delle teiere;

• viene allocata una pool per definire la quantità di descriptors da utilizzare nei descriptor set. I descriptor descrivono tipologie di risorse che vengono passate agli shaders e sulle quali questi possono lavorare. Nel nostro caso abbiamo un descriptor di tipo uniform buffer: si tratta di una struttura dati multiuso dentro cui è possibile passare array di byte. Noi andremo ad inserire dentro un uniform buffer i dati relativi alle trasformazioni da applicare ai vertici della teiera per farli muovere a run time. Queste trasformazioni verranno poi applicate dagli shader sulla GPU per ottener il disegno finale;

• dopo aver definito il layout del generico descriptor set, ora che abbiamo creato una pool per allocare un certo numero e una certa tipologia di descriptor, possiamo passare a creare i descriptor set stessi. Si tratta di insieme di risorse leggibili dagli shader utilizzati al momento della creazione dei command buffers;

• ora che tutte le tipologie di strutture dati e risorse necessarie sono state definite, si passa a creare i command buffers che verranno inviati alla scheda video per dirgli cosa disegnare. Viene creato un command buffer per disegnare su ogni immagine fornita dalla swap chain tramite il collegamento al frame buffer specifico dell'immagine.
  Un command buffer può essere associato a più render pass e per ogni render pass vengono collegati al command buffer i descriptor sets che identificano le risorse che verranno utilizzate dagli shaders nella pipeline di rendering. Viene poi collegata la pipeline, la quale contiene la sequenza di shaders da utilizzare, e infine vengono collegati i vertex buffer e gli index buffer che rappresentano i vertici su cui andiamo ad effettuare le varie operazioni per il rendering;

• definiamo ora le trasformazioni da applicare ai vertici nello spazio, in modo da generare la scena 3D che è possibile vedere su schermo. Per fare ciò si costruisce una matrice chiamata mvp: model view projection. Questa è ottenuta tramite l'applicazione di trasformazioni con la moltiplicazione di matrici nel seguente ordine: \(projection \ast view \ast model\).
  Sono tutte matrici \(4 \ast 4\); la matrice \(model\) definisce le traformazioni da applicare ai vertici dell'oggetto 3D da disegnare. Nel nostro caso viene utilizzata per definire le rotazioni delle teiere nello spazio.
  La matrice \(view\) è utilizzata per definire la posizione dalla quale si osserva la scena e ci permette di specificare quale degli assi cartesiani viene utilizzato come asse verticale. Nel nostro caso si utilizza l'asse \(y\).
  La matrice \(projection\) viene utilizzata per definire il tipo di proiezione applicata per rappresentare su un piano bidimensionale una scena tridimensionale. Nel nostro caso si applica un proiezione prospettica con aspect ratio dato dal rapporto tra larghezza e altezza della finestra su cui si va a disegnare.
  Inoltre vengono specificate le distanze, dall'osservatore, dei piani near e far del view frustum della camera che sta osservando la scena.
  La posizione di ogni vertice viene infine calcolata dal vertex shader in questo modo: $$ gl\_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0); $$ dove \(gl\_Position\) è un vettore di \(4\) elementi;

• possiamo finalmente disegnare l'immagine finale attraverso un ciclo di rendering. Questo ciclo è implementato attraverso un timer che ogni \(3\) millisecondi aggiorna l'uniform buffer passato agli shaders inserendoci dentro le versioni aggiornate delle matrici \(model, view, projection\) e poi esegue il rendering vero e proprio;

• il rendering avviene infine acquisendo un'immagine inutilizzata dalla swap chain e passando il command buffer legato a tale immagine dentro una coda fornita dalla swap chain. Il command buffer verrà poi eseguito dalla GPU e l'immagine generata verrà scritta su quella fornita dalla swap chain. Tale immagine, attraverso opportune strutture dati verrà infine messa in coda dalla swap chain per poi essere mostrata su schermo al momento del prossimo refresh.

Avvio

L'applicazione è composta da una singola finestra suddivisa in due sottofinestre principali: la più grande occupa la parte destra e si occupa di presentare la teiera generata dal programma. La sottofinestra di sinistra invece mostra tutti i parametri con cui è possibile modificare la teiera. E' presente inoltre una barra dei menù posta in alto.

All'avvio l'applicazione presenterà la teiera base su cui sarà già possibile effettuare modifiche.
La teiera è composta da 4 parti principali: CORPO, MANICO, BECCO e COPERCHIO. Ciascuno è costituito da un numero specifico di patches che a loro volta possono essere viste come suddivise ad anelli. Indichiamo come anelli i gruppi di punti di controllo contigui che si trovano alla stessa altezza, ovvero allo stesso valore di v lungo le patches incollate tra loro di uno specifico componente della teiera.
Specificheremo più avanti il numero di patches e anelli per ognuno dei 4 compomenti principali.

Barra dei menù e creazione nuova teiera

Nella barra è presente un singolo menù contenente tre bottoni: New, Save e Quit.
Scegliendo New verrà aperta una finestra dedicata alla creazione di una nuova teiera.

Da questa finestra si possono scegliere le proprietà che desideriamo applicare alla teiera.
Per il corpo sono possibili 3 modalità di costruzione: TopDown, Center o BottomUp.
Ogni componente della teiera, infatti, è costruito seguendo gli anelli che lo compongono e in base alla modalità di costruzione è possibile ottenere risultati diversi che garantiscano la classe di continuità scelta.
L'altra proprietà che è possibile scegliere per il corpo è appunto la classe di continuità che caratterizzerà l'attaccatura tra le patches. E' possibile scegliere tra le classi \(C0\), \(C1\) e \(C2\).
Per manico, becco e coperchio sono disponibili le stesse opzioni, a differenza della modalità di costruzione Center non presente.

E' possibile infine attivare o mantenere disattivato il Debug. Se attivato l'applicazione controllerà che le proprietà richieste siano tutte soddisfatte. In particolare il controllo effettuato può essere di 3 livelli, equivalenti alle classi \(C0\), \(C1\) e \(C2\). Il livello sarà scelto in automatico dall'applicazione e sarà equivalente alla classe più alta selezionata dall'utente. Su ogni componente poi verrà effettuato il controllo del livello selezionato. L'opzione debug stamperà quindi un messaggio di errore dove le proprietà non saranno rispettate, indicando anche il componente e le patches dove sono state violate.
L'attivazione di questa funzionalità causa però un rallentamento generale dell'applicazione.

Premere infine OK per chiudere la finestra e generare la teiera.

Il primo dei restanti due pulsanti, Save, permette di salvare il modello che abbiamo creato nella cartella del progetto, per poterlo successivamente utilizzare con altri programmi di modellazione 3D.
Con Quit invece l'applicazione verrà chiusa.

Scorciatoie da tastiera

Nell'applicazione è possibile utilizzare delle combinazioni di tasti.

Con CTRL + N è possibile aprire velocemente la finestra per la creazione di una nuova teiera.

Con CTRL + S la teiera modellata viene salvata.

Utilizzando invece la combinazione CTRL + frecce direzionali

è possibile ruotare e inclinare la teiera manualmente.

Modificare la teiera

Come indicato all'inizio del manuale, la sottofinestra di sinistra si occupa di mostrare tutte le modifiche che si possono apportare a runtime alla teiera.
Nei restanti paragrafi verranno illustrate tutte le opzioni disponibili e verranno specificate alcune informazioni precedentemente fornite dove necessario.
Nota bene: è possibile, apportando determinate modifiche, realizzare una teiera con alcune imperfezioni, come ad esempio una scorretta integrazione del becco nel corpo della teiera. Per questi casi è necessaria l'attenzione dell'utente per correggere il modello.

I primi elementi disponili sono un insieme di bottoni.

Con il primo, "Reset Values", vengono azzerate tutte le modifiche applicate alla teiera e viene quindi ricostruita la teiera con le proprietà scelte nel momento della creazione.
Premendo il secondo pulsante, "Hide Control Points", è possibile nascondere il wireframe che rappresenta i control points utilizzati per costruire la teiera.
Utilizzando "Show Original" viene mostrata la teiera originale, la Utah Teapot, sulla quale il progetto si è basato. In questo modo è possibile vedere la differenza tra la teiera originale e le modifiche applicate. Non è possibile applicare modifiche direttamente sulla teiera originale.
Infine, con il pulsante "Rotate", è possibile far ruotare automaticamente la teiera su se stessa.

Gestione scalature e attaccature di manico e becco

Al di sotto dell'insieme di bottoni sono presenti une serie di sliders con cui è possibile apportare in modo immediato tutte le altre personalizzazioni inserite nel progetto.
Ogni gruppo di sliders è identificato da un'etichetta che indica la parte del corpo su cui verranno effettuate le modifiche e, dove presenti, altre informazioni generali sulla componente da modificare.
Ogni slider poi ha una sua etichetta specificante l'azione che verrà compiuta oppure il punto esatto su cui verrà applicata la modifica. Indica inoltre il valore che sarà utilizzato dall'applicazione.
Per utilizzare gli slider è sufficiente muovere il cursore utilizzando il mouse.

Lo slider "Height", posto sotto l'etichetta "Teapot Scale", serve modificare l'altezza del corpo della teiera (incluso il coperchio).

Sotto "Handle Extra" sono presenti alcuni slider per la modifica della dimensione del manico e dell'altezza delle attaccature dello stesso lungo il corpo.
"Scale" modifica la dimensione del manico.
"Move Base" cambia l'altezza dell'attaccatura in basso del manico sul corpo.
"Move Top" invece modifica l'attaccatura della parte superiore del manico.

In "Spout Extra" sono disponibili le stesse opzioni appena illustrate per il manico ma applicate al becco. E' presente quindi uno slider per scalare la dimensione del becco e un secondo per gestire l'altezza del becco lungo il corpo.

Modificare il corpo della teiera

Il corpo della teiera è composto da una griglia di 4 patches orizzontali e 3 patches verticali, ciascuna composta da 4x4 control points.
Analizzando il corpo in direzione verticale, pensando alla forma stessa della teiera, possiamo quindi trattarlo come composto da 12 anelli di control points. Gli anelli di congiunzione tra le patches però sono in realtà lo stesso anello ed è quindi possibile generare i valori su di essi un'unica volta. In questo modo possiamo ridurre il numero di anelli che compongono il corpo a 10 anelli.

La costruzione di questo componente è implementata proprio utilizzando questa astrazione e considerando ogni anello come l'insieme dei punti di controllo che genera un cerchio.La costruzione può essere effettuata con 3 modalità: TopDown, Center e BottomUp. Nella prima si parte dall'anello più alto del corpo per poi costruire in ordine tutti gli anelli sottostanti. In BottomUp, invece, il procedimento è lo stesso ma partendo dal basso e proseguendo verso l'alto. Con la modalità Center si parte dagli anelli centrali per poi costruire gli anelli superiori e inferiori.
Come detto nei paragrafi precedenti, è possibile scegliere tra 3 classi di incollamento tra le patches: \(C0\), \(C1\) e \(C2\).Grazie alla costruzione ad anelli della teiera l'applicazione genera i valori dei control points dell'anello successivo in modo tale da rispettare le proprietà richieste dalla classe di incollamento. Ogni anello inoltre rispetta sempre le proprietà \(C2\) in quanto genera un cerchio, composto dall'incollamento di 4 curve di Bézier.

Con le combinazioni di classe di incollamento e modalità di costruzione è possibile ottenere differenti corpi di base, da poter poi personalizzare a piacimento come illustrato nel seguito del manuale. Con i prossimi sliders, infatti, sarà possibile modificare il diametro di ogni anello, o quasi: a seconda delle scelte di costruzione effettuate alcuni anelli non saranno direttamente modificabili perchè saranno costruiti direttamente dall'applicazione utilizzando gli altri anelli come parametro e in modo da rispettare le proprietà.

Vediamo ora un esempio di interfaccia grafica per un corpo costruito in modalità Center e con classe di incollamento \(C1\).

La prima cosa visualizzata è l'etichetta "Body", seguita dalle informazioni riguardanti la modalità di costruzione e la classe applicata.
Idealmente il corpo della teiera può essere visto come composto da un colletto, "Rim", e il corpo, "Body", il primo composto dal primo blocco di patches, quindi 4 anelli, e il secondo composto dalle patches restanti, 8 anelli. Come detto in precedenza però gli anelli di congiunzione vengono visti come fusi in un singolo anello, risultano quindi disponibili per effettuare modifiche 4 anelli per il colletto e 6 per il corpo.
Gli sliders presentano ciascuno un'etichetta indicante Rim o Body e l'anello a cui è collegato. Indipendentemente dalla modalità di costruzione le etichette presentano sempre gli anelli in ordine a partire da quello posto più in alto. E' inoltre visualizzato il diametro dell'anello.

Come è possibile vedere nell'esempio in figura, gli sliders relativi al terzo anello del colletto e al quarto del corpo non sono presenti e non sono quindi modificabili direttamente ma vengono generati partendo dagli anelli circostanti. In particolare in questo caso in cui è stata scelta la modalità Center, l'anello mancante del colletto è dipendente dall'ultimo anello del colletto stesso e dal primo anello del corpo. Il quarto anello del corpo invece dipende dal secondo e dal terzo anello di Body.

Manico, Becco e Coperchio

Manico, Becco e Coperchio sono costruiti e gestiti con la stessa logica utilizzata per la costruzione del corpo. Verrà ora descritto il numero di patches e di anelli di ognuno di essi. Non sarà invece presentata l'interfaccia grafica relativa in quanto identica a quella illustrata per il corpo.

Il manico è composto da una griglia 2x2 di patches, per un totale di 8 anelli, 7 considerando come un unico anello quello che collega le due patches. In questo caso però, gli anelli generano delle curve circolari che non rispettano la condizione di incollamento \(C2\) come avveniva per il corpo, ma solo la condizione \(C1\). Questo perché tali cerchi sono ottenuti dall'incollamento di due curve solamente, il che non è sufficiente per ottenere una curva chiusa come un cerchio mantenendo il vincolo \(C2\). Tale classe di continuità \(C2\), qualora venga scelta dall'utente al momento della creazione della teiera, viene infatti utilizzata per l'incollamento delle curve trasversali agli anelli. In questo caso, anche se le patches sono solo 2, le proprietà imposte dalla classe \(C2\) sono rispettate in quanto le due patches sono collegate solamente lungo un lato. A differenza del corpo, non è presente la modalità di costruzione Center a causa del numero ridotto di patches.
Il primo anello rappresenta l'attaccatura superiore del manico sul corpo. La posizione è calcolata a seconda delle dimensioni del corpo. L'ultimo anello corrisponde invece all'attaccatura inferiore.

Il becco è formato come il manico da una griglia 2x2 di patches. L'ordine degli anelli in questo caso non è in direzione verticale partendo dall'alto ma è rappresentato dalla distanza presente dal corpo. Il primo anello quindi è quello che rappresenta l'attaccatura del becco al corpo mentre l'ultimo rappresenta la punta del becco. Anche in questo caso la posizione del primo anello è calcolata in base alle dimensioni del corpo.

Il coperchio è formato da una griglia 4x2 di patches, mantiene quindi il numero di 7 anelli. In realtà in questo caso si è deciso di rendere l'ultimo anello del coperchio, quello più vicino al body, automaticamente equivalente al primo anello del colletto e non è quindi disponibile per la modifica.

Download

Per eseguire l'applicazione è necessario possedere un pc con sistema operativo Windows e con supporto alle librerie Vulkan.
Se i requisiti minimi sono rispettati è sufficiente scaricare la cartella compressa corretta in base alla versione del sistema operativo che si sta utilizzando:

Successivamente estrarre la cartella ed eseguire "TeapotDesigner.exe".
Tutto il necessario per la corretta esecuzione del programma è incluso nella cartella e non è necessaria l'installazione.