NOTA! Questo sito utilizza i cookie e tecnologie simili.

Se non si modificano le impostazioni del browser, l'utente accetta. Per saperne di piu'

Approvo

JOGL, Java e OpenGL, le basi: origine, traslazione, colori, vertici, punti; tutorial

 

Questo è un tutorial davvero basilare dedicato all’operazione di traslazione del “cursore 3D virtuale” e alla definizione dei vertici per creare primitive geometriche in punti ben precisi dell’universo 3D in JOGL.

 

Per i nostri esempi utilizziamo l’applicazione JOGL di base messa a disposizione da NetBeans, per cui per prima cosa apriamo il programma e creiamo un nuovo progetto scegliendo, come tipo, JOGL Application (in un precedente tutorial ho mostrato come configurare le librerie JOGL per NetBeans).

 

 

L’applicazione base inserisce, all’interno del metodo display, le istruzioni per visualizzare un triangolo e un quadrato colorati, ma noi vogliamo esaminare in questa puntata primitive ancora più elementari, per cui cancelliamo il codice dalla riga 96 alla riga 117 per inserire in questo punto il nuovo codice (per visualizzare i numeri di riga, selezionare Show Line Numbers all’interno del menù View).

 

Tutorial-JOGL-Origine-Traslazione-Points-01

Stiamo invece lasciando, alla riga 94, un’istruzione di traslazione del cursore virtuale della scena.

Il cursore virtuale definisce un punto all’interno dell’universo virtuale di JOGL, per cui inserendo adesso un’istruzione per definire un vertice, tale vertice verrebbe posizionato proprio nell’ultima posizione impostata; attenzione, perché con Translate non definiamo la posizione, ma un vettore di spostamento dalla posizione originale a quella nuova.

 

In particolare, l’origine del sistema di riferimento dell’universo virtuale si ha alle coordinate 0.0, 0.0, 0.0; un’operazione di traslazione del cursore 3D, con glTranslate, sposta il cursore nella nuova posizione determinata da 0+x, 0+y e 0+z, la somma vettoriale membro a membro per intenderci; una successiva operazione di traslazione sposterà il cursore dalla posizione appena assunta a quella ottenuta sommando le componenti x, y e z membro a membro, e così via.

 

Per riportare il cursore 3D nell’origine, si utilizza l’istruzione glLoadIdentity, la matrice identità; nel codice dell’esempio, quest’istruzione è presente alla riga 91 ed è seguita, alla riga 94, da Translate con valori -1.5 per X, 0 per Y (che nell’universo virtuale è il vettore verticale, per intenderci) e -6 per Z; su quest’ultima caratteristica vale la pena soffermarci.

 

All’atto della creazione della scena 3D, la telecamera/osservatore, cioè il nostro punto di vista, viene posizionata nell’origine del sistema di riferimento, alle coordinate 0.0, 0.0 e 0.0.

 

In questo momento, l’asse X rappresenta l’asse che va da sinistra a destra, assumendo valori negativi per i punti a sinistra (quindi -1.5 è alla nostra sinistra) e positivi a destra; l’asse Y rappresenta invece l’asse verticale, con valori positivi in alto e negativi in basso; l’asse Z, infine, rappresenta un asse perpendicolare al piano della telecamera, quindi un asse per così dire uscente dallo schermo, ed in particolare si hanno valori positivi verso noi, cioè uscendo dallo schermo, e negativi andando invece verso lo schermo, in profondità.

 

Traslando il cursore in posizione Z -6.0, lo stiamo posizionando di fronte a noi, ad una distanza di 6 unità da noi, in modo da renderlo ben visibile; lasciando 0 non vedremmo invece nulla, perché coincide con la nostra posizione Z.

 

Tornando alla famosa riga 94, a questo punto abbiamo spostato il cursore 3D nel punto -1.5, 0.0, -6.0, il che significa che un vertice disegnato adesso verrà posizionato proprio in quel punto… bene, facciamolo, inserendo una primitiva geometrica di tipo Point.

 

Per inserire una primitiva geometrica dobbiamo dire a OpenGL che stiamo entrando in una sotto-procedura di disegno, ed in particolare che intendiamo disegnare dei punti, per cui scriviamo:

 

gl.glBegin(GL.GL_POINTS);

 

questo blocco dovrà essere chiuso, terminata la procedura di disegno, da un’istruzione particolare, ossia:

 

gl.glEnd();

 

Le istruzioni racchiuse tra queste righe ci serviranno a definire posizione, colore e, in generale, aspetto dei punti.

 

Un punto ha una dimensione unitaria e spesso è difficile vederlo con le impostazioni di default, per cui OpenGL mette a disposizione l’istruzione glPointSize per renderizzare il punto come un cerchietto; come prima istruzione subito dopo Begin scriviamo quindi:

 

gl.glPointSize(10.0f);

 

Per impostare il colore del nostro vertice, utilizziamo l’istruzione glColor3f, che prende in input tre valori float nel range 0.0 – 1.0, che specificano i contributi di colore dei tre canali RGB, rosso verde blu, per cui ad esempio 0 0 0 è il nero, 1 1 1 è il bianco, 1 0 0 è il rosso puro e così via… scriviamo quindi, ad esempio:

 

gl.glColor3f(1.0f, 0.0f, 0.0f);

 

con la f che serve a specificare, ovviamente, che stiamo inserendo valori float, non double.

 

A questo punto definiamo il vertice con l’istruzione glVertex3f, che prende in input tre valori float per specificare le coordinate X, Y e Z.

 

Questa istruzione viene utilizzata, in generale, per determinare un vertice nell’universo virtuale; se utilizzata all’interno di un blocco GL_POINTS, come nel nostro caso, determinerà un punto isolato, mentre se utilizzata all’interno di GL_LINE determinerà un estremo di un segmento, e così via…

 

Attenzione, perché scrivere adesso

 

gl.glVertex3f(0.0f, 0.0f, 0.0f);

 

non posizionerà il nostro punto nell’origine del sistema di riferimento, e questo perché il cursore virtuale 3D si trova, come detto più volte, in -1.5, 0.0, -6.0. Scriviamo questa istruzione ed eseguiamo l’applicazione per avere una conferma di quanto appena detto…

 

… ma attenzione, perché una cosa non funzionerà (l’ho fatto di proposito proprio per farvelo notare): la dimensione del punto è sempre unitaria, praticamente invisibile.

 

Ciò è dovuto al fatto che, come descritto nelle specifiche di OpenGL, pointSize va utilizzato al di fuori di un blocco begin-end, per cui spostiamo quell’istruzione appena prima glBegin ed eseguiamo nuovamente il tutto.

 

Il punto assumerà una forma quadrata per via di alcune impostazioni… per migliorarne l’aspetto, tra point size e begin scriviamo:

 

gl.glEnable(GL.GL_POINT_SMOOTH);

 

che serve ad abilitare l’anti-aliasing, il filtro antiscalettatura, per tutti i punti disegnati da qui in avanti.

 

Adesso torniamo all’interno del blocco begin-end per effettuare un’altra operazione.

 

Subito dopo la definizione di questo primo vertice-punto, scriviamo:

 

gl.glColor3f(0.0f, 1.0f, 1.0f);

gl.glVertex3f(1.5f, 0.0f, 0.0f);

 

Con la prima istruzione stiamo quindi definendo il nuovo colore da applicare a tutti gli oggetti che verranno disegnati da quella riga in poi, quindi ciano; togliendo questa riga, anche il nuovo vertice verrà colorato di rosso, perché prima abbiamo definito quel colore.

 

Con la seconda istruzione, stiamo aggiungendo un vettore di spostamento di 1.5 unità in positivo lungo l’asse X, cioè verso destra – visto che siamo nell’origine – e lo stiamo aggiungendo alla posizione precedente nella quale si trovava il 3D Cursor, ossia -1.5, 0.0, -6.0; effettuando una somma elemento per elemento, abbiamo che la posizione di questo nuovo punto, di colore ciano, sarà 0.0f (per via di -1.5f + 1.5f), 0.0f -6.0f, ossia proprio di fronte a noi, al centro del pannello… provare per credere.

 

Per questo tutorial ci fermiamo qui, in un altro vedremo come definire primitive geometriche di base come segmenti, line_strip e line_loop.

 

Altri articoli...

 
Vai all'inizio della pagina