Flight Around!

GAMEPLAY

Come si gioca?

Geometria 3D e vista

Le trasformazioni Window-Viewport sono gestite automaticamente dalla libreria. Nel progetto è stato necessario settare la Viewport tramite la chiamata glViewPort, la quale setta il numero corretto di pixel nel Frame Buffer.

Le coordinate dell'occhio sono moltiplicate con la matrice GL_PROJECTION che definisce il volume di vista (frustum) e come i dati dei vertici sono proiettati. Gli oggetti vengono visualizzati in proiezione prospettica, settando i prametri con la funzione gluPerspective. In tal modo viene effettuato il Clipping 3D rispetto al Volume di Vista.

Le trasformazioni di modellazione hanno l'obiettivo di ricavare le coordinate mondo di un particolare oggetto/vertice ed agiscono sulla matrice GL_MODELVIEW. Solitamente sono composta dalle chiamate glScale, glRotate e glTranslate, nell'ordine specificato, e comprese tra un glPushMatrix e glPopMatrix (per non intaccare lo stato dello stack dopo la trasformazione) per circoscrivere la trasformazione di modellazione all'oggetto desiderato.

Le coordinate dopo il clipping vengono normalizzate e infine passate al processo di rasterizzazione della pipeline di OpenGL. Viene usata la funzione glViewport() per definire il rettangolo dell'area di rendering dell'immagine finale.
Per muovere la telecamera la matrice GL_MODELVIEW viene moltiplicata con una o più matrici di trasformazione. Nel progetto sono stati usati glTranslate e glRotate.

          
              glViewport(0, 0, scrW, scrH); 
              glMatrixMode(GL_PROJECTION); 
              glLoadIdentity(); 
              gluPerspective(70, ((float) scrW) / scrH, 0.01, 10000); 
              glMatrixMode(GL_MODELVIEW);
              glLoadIdentity();
              setCamera(); // cambia parametri a seconda del tipo di camera selezionata 
          
        

Illuminazione

E' presente una luce direzionale in modo da rappresentare la luce del sole. Tale luce è stata settata usando la funzione glLightfv. A seconda del tipo di mesh la luce si comporta in modo diverso; ciò è dovuto all'abilitazione del ColorMaterial che permette il settaggio dei parametri del materiale di ogni singola mesh. Il modello di illuminazione usato è quello di Phong composto da tre componenti: ambiente, riflessione diffusa e speculare. Tali componenti sono i parametri che si settano per definire un materiale.



Di seguito è mostrato il codice utilizzato nel modulo Ship.cpp per settare i valori delle tre componenti dette in precedenza:

                  
                      float mat_ambient[3] ={ 1.0f, 1.0f, 0.06625f };
                      float mat_diffuse[3] ={ 0.18275f, 1.0f, 0.22525f};
                      float mat_specular[3] ={1.0f, 1.0f, 0.346435f };
                      glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
                      glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
                      glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
                      float shine = 0.21794872;
                      glMaterialf(GL_FRONT, GL_SHININESS, 128 * shine );
                      glEnable(GL_COLOR_MATERIAL); //Abilita colore sulla mesh               
                    
                      // [.... RENDER DELLA MESH] 

                      glDisable(GL_COLOR_MATERIAL); 

                    
                

Mesh poligonali e Texture Mapping

I modelli 3D nel gioco sono:

• Ship, sul quale è stata fatta una pre-elaborazione attraverso Blender per separare i componenti del modello iniziale e applicare trasformazioni e texture sui singoli componenti ottenuti (ad esempio l'elica)
• Moneta
• Deserto
• Cubo

La classe Mesh.cpp si preoccupa del reperimento dei dati da file .obj esterni tramite la funzione LoadFromObj e della renderizzazione tramite le differenti tecniche NxF(Flat Shading) NxV (Gouraud Shading) attivabili mediante F3.

Ambiente

Il cielo è stato realizzato con una tecnica chiamata cubemapping, ovvero un metodo di mappatura dell'ambiente che utilizza le sei facce di un cubo come forma della mappa. Per ognuna delle 6 facce viene utilizza una diversa texture. Il test di profondità viene disabilitato quando si renderizza lo skybox per far sì che esso venga disegnato sempre dietro qualsiasi mesh presente sulla scena.

Testo e grafica 2d

In basso a destra è presente la minimappa al fine di aiutare il giocatore a capire dove si trova all'interno dello spazio di gioco. Questa minimappa è formata da un insieme di geometrie 2D. L'area in cui ci si può muovere è formata da un quadrato rosso, mentra la ship è indicata da un'immagine 2D della navicella, i cubi e le monete sono rispettivamente di colore verde e giallo. A seconda dell'altezza dalle monete o dai cubi la dimensione dei cerchi nella mappa varia in modo da capire a quale altezza di trova l'oggetto rispetto all'altezza della ship.
Le posizioni di tutti gli elementi nella minimappa sono proporziali alle loro posizioni effettive nello spazio di gioco. In particolare, le posizioni (x,y) della minimappa rispecchiano le posizioni (x,z) del mondo di gioco. In altre parole, è come se ci fosse una telecamera che guarda costantemente la scena dall'alto ed ecco perchè si è deciso di implementare il meccanismo descritto prima relativa alla distanza ship/moneta oppure ship/cubo. Per quanto il testo, viene creata una texture attraverso la funzione TTF_RenderText specificando gli opportuni paramentri come il testo, il colore e il font (che viene caricato attraverso la funzione TTF_OpenFont). Tale texture viene poi applicata a un quadrato 2D.

                
                    void RenderTextCoord(string message, SDL_Color color, int x, int y, TTF_Font *font);
                
              

Premendo F11 viene i mostrato il pannello per il debug. Attraverso tale pannello è possibile vedere le configurazioni attive.

Riflessione

E' stata anche testa la riflessione del drone su una superficie, sfruttando l'Alpha Blending e lo Stencil Buffer di OpenGL. La ship viene ridisegnata nuovamente ma capovolta su una superficie che raffigura il mare.

Conclusioni e sviluppi futuri

Nonostante il lavoro svolto fosse incentrato sulla grafica, è stato necessario implementare anche un minimo di logica per rendere il tutto più interessante e coinvolgente. Una delle difficoltà maggiori è stata nel capire come ragionasse OpenGL nelle trasformazioni, il loro ordine e la loro esecuzione. Un esempio di sviluppo futuro è stato abbozzato attraverso la beta version che dovrà tenere conto dei conflitti con gli altri oggetti presenti nella scena.