OpenGL Libreria grafica composta da circa 150 comandi. Realizzata in vari linguaggi (noi useremo quella in C). Sviluppato dalla Silicon Graphics. Originariamente si chiamava IRIS GL. Ora è gestito da un comitato indipendente che controlla e modifica lo standard. Disponibile gratuitamente su molte piattaforme (Windows e UNIX). Pensato per essere hardware-independent. Per ottenere questo scopo, non contiene comandi per gestire le finestre. OpenGL

Struttura OpenGL OpenGL è una “rendering library”. Non ci sono strutture predefinite come in PHIGS, lavora in “immediate mode”. Per costruire oggetti complessi e modificarli si usano librerie costruite sopra OpenGL (Es. OpenInventor). OpenGL usa un insieme di primitive abbastanza ridotto. Inoltre non scrive direttamente sullo schermo ma accede ad un framebuffer. OpenGL è una state-machine. Le variabili di stato guidano il rendering. OpenGL

Pipeline Grafica Lo schema di esecuzione di un programma OpenGL è il seguente: OpenGL

Librerie OpenGL

Primo Esempio main() { OpenAWindow(); glClearColor(0.0, 0.0, 0.0, 0.0); glClear(GL_COLOR_BUFFER_BIT); glColor3f(1.0, 1.0, 1.0); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); glBegin(GL_POLYGON); glVertex3f(0.25, -0.25, 0.0); glVertex3f(0.75, 0.25, 0.0); glVertex3f(0.75, 0.75, 0.0); glVertex3f(0.25, 0.75, 0.0); glEnd(); glFlush; KeepTheWindow(); } OpenGL

Convenzioni Tutti i comandi hanno il prefisso gl e seguono le stesse regole di Java. Es: glClearColor. Costanti e variabili di stato sono scritte tutte in maiuscolo, iniziano con GL_ e le parole sono separate da ‘_’. Es: GL_COLOR_BUFFER_BIT. I tipi in OpenGL hanno dei nomi interni che incominciano per GL, del tipo: GLbyte, GLshort, GLint, GLfloat, GLdouble OpenGL

Sintassi Molti comandi finiscono con 2 suffissi (es.: glVertex2f() ). Il primo (2) denota il numero di argomenti, mentre il secondo (f) denota il tipo (float). I tipi ammessi sono: b 8-bit integer ub 8-bit unsigned integer s 16-bit integer us 16-bit unsigned integer i 32-bit integer ui 32-bit unsigned integer f 32-bit floating-point d 64-bit floating-point Alcuni comandi possono prevedere un terzo suffisso (v) per indicare che si applicano a vettori. OpenGL

GLUT GLUT = OpenGL Utility Toolkit Gestisce: creazione di finestre, unità di input (mouse e tastiera), menu, solidi, ecc ... Disponibile su molte piattaforme (UNIX, Windows, Mac), permette di scrivere codice portabile. Adatto ad applicazioni “semplici”. Per applicazioni complete meglio usare i comandi del sistema operativo specifico. OpenGL

Struttura GLUT gestisce completamente il funzionamento del programma, ma demanda ad openGL la generazione dell’immagine. Le funzioni principali sono: glutInit glutInitDisplayMode glutInitWindowPosition glutInitWindowSize glutCreateWindow glutMainLoop glutDisplayFunc glutPostRedisplay OpenGL

Esempio (1) int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (500, 500); glutCreateWindow (“hello”); init(); glutDisplayFunc(display); glutMainLoop(); return 0; } OpenGL

Esempio (2) void init(void) { glClearColor(0.0, 0.0, 0.0, 0.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); } void display( void ) { glClear(GL_COLOR_BUFFER_BIT); glColor3f (1.0, 1.0, 1.0); glBegin(GL_POLYGON); glVertex3f(0.25, 0.25, 0.0); glVertex3f(0.75, 0.25, 0.0); glVertex3f(0.25, 0.25, 0.0); glVertex3f(0.25, 0.25, 0.0); glEnd(); glFlush(); OpenGL

Colore in OpenGL Il colore viene (normalmente) specificato nel formato RGBA, dove A sta per Alpha che specifica la trasparenza del pixel (tenuta in considerazione se siamo in modalità Blending). Il colore è una variabile di stato, un disegno viene fatto nel colore attivo. OpenGL

Buffers OpenGL mantiene in memoria almeno 4 buffers: Tipo Identificativo Color buffer GL_COLOR_BUFFER_BIT Depth buffer GL_DEPTH_BUFFER_BIT Accumulation buffer GL_ACCUM_BUFFER_BIT Stencil buffer GL_STENCIL_BUFFER_BIT Nel Color buffer vengono memorizzate le immagini. Il Depth buffer serve per l’eliminazione delle parti nascoste. Lo Stencil buffer serve per restringere il disegno e l’Accumulation buffer per area di lavoro. OpenGL

Inizializzazione Buffers glClearColor setta il colore RGBA da usare per l’operazione di glClear del Color Buffer. glClearDepth setta il valore di profondità da usare per l’operazione di glClear del Depth Buffer. glClear inizializza il buffer (o i buffers) che contengono usando il propri clear values correnti. OpenGL

Primitive La primitiva fondamentale è la lista di vertici, che viene usati per diversi oggetti grafici: Punti: GL_POINTS Linee: GL_LINES, GL_LINE_STRIP,GL_LINE_LOOP Quadrilateri: GL_QUADS, GL_QUAD_STRIP Poligoni: GL_POLYGON Triangoli: GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN Le liste di vertici sono racchiuse tra: glBegin(<NomePrimitiva>); ….. glEnd(); OpenGL

Disegno Primitive Ogni primitiva viene disegnata in modo diverso. GL_POINTS Solo i vertici GL_LINES Le linee da 0 ad 1, da 2 a 3, etc GL_POLYGON Il poligono pieno GL_TRIANGLES I triangoli pieni formati dai vertici 0-2, 3-5, etc... GL_LINE_STRIP La spezzata (non chiusa) che congiunge i vertici in ordine GL_LINE_LOOP La spezzata (chiusa) che congiunge i vertici in ordine OpenGL

Disegno Primitive (2) GL_QUADS I quadrilateri pieni formati dai vertici 0-3, 4-7, etc... GL_QUAD_STRIP I quadrilateri pieni formati dai vertici 0-3, 2-5, 4-7 etc... GL_TRIANGLE_STRIP I triangoli pieni formati dai vertici 0-2, 1-3, 2-4 etc... GL_TRIANGLE_FAN I triangoli pieni formati dai vertici 012, 023, 034 etc... OpenGL

Disegno Primitive (3) OpenGL

glPolygonMode(Glenum face, Glenum mode); Poligoni Si possono modificare gli stili di disegno di un poligono con il comando: glPolygonMode(Glenum face, Glenum mode); face specifica a quale faccia (davanti GL_FRONT, dietro GL_BACK, entrambe GL_FRONT_AND_BACK) si applica il mode, il quale vale GL_POINT, GL_LINE o GL_FILL (default). Convenzionalmente la faccia front vede i vertici in senso antiorario, ma si può modificare. Ad ogni vertice possiamo associare una normale (usata nel rendering) con glNormal(); OpenGL

Disegno OpenGL è pensato per un’architettura hardware con pipeline. Per questo motivo, i comandi vengono memorizzati in un buffer ed eseguiti quando il buffer è pieno e la CPU è disponibile. Per forzare il disegno abbiamo 2 comandi: glFlush(); Forza l’esecuzione dei comandi dati. termina immediatamente glFinish(); Forza l’esecuzione dei comandi dati e termina solo dopo la loro esecuzione OpenGL

Visualizzazione in OpenGL

Specifica Vista La proiezione è definita da 2 matrici: GL_MODELVIEW: Porta gli oggetti in coordinate di vista. Analoga alla View Orientation, ma più generale. GL_PROJECTION: Porta il volume di vista nel volume canonico (Qui x, y, z tra -1 ed 1). Analoga alla View Mapping. Quale matrice viene modificata è un valore di stato. Modificato con glMatrixMode(); OpenGL

Operazioni su Matrici Operazioni fondamentali sono: glMatrixMode(mode) Sceglie la matrice da modificare GL_PROJECTION o GL_MODELVIEW glLoadIdentity() Inizializza all’identità glLoadMatrix(matrice) Carica una matrice 4x4 glMultMatrix(matrice) moltiplica, a destra, la matrice corrente per la matrice specificata OpenGL

Modelview Matrix Modifica il disegno in modo che si possa applicare la matrice di proiezione. Contiene il risultato di comporre un numero anche molto alto di trasformazioni. In ogni momento memorizza la trasformazione necessaria a portare l’oggetto corrente in coordinate di vista. OpenGL

Matrici Trasformazione Le matrici di trasformazione vengono definite con i comandi: glTranslate*(x, y, z); Trasla di (x, y, z) glRotate*(angle, x, y, z); Ruota di angle (antiorario) rispetto alla retta da (x,y,z) all’origine glScale*(x, y, z); Scala sui tre assi Non esiste la trasformazione di shearing, ma si può inizializzare una matrice con 16 valori qualunque usando glLoadMatrix. OpenGL

Coordinate di vista Per portarsi in coordinate di vista possiamo usare le trasformazioni viste oppure usare il comando gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz) che porta in coordinate di vista partendo dalla situazione con l’osservatore in (eyex, eyey,eyez), il centro dell’immagine in (centerx,centery,centerz) ed il View up vector = (upx,upy,upz). Impone che il View Plane Normal sia la congiungente l’osservatore con il centro dell’immagine. OpenGL

Composizione Trasformazioni Le matrici si compongono sempre in modalità POSTCONCATENATE. Per rimpiazzare bisogna dare prima il comando glLoadIdentity(); Bisogna scrivere le trasformazioni in ordine inverso a quello in cui vengono applicate. Le oprazioni si applicano sempre alla matrice corrente. Le matrici possono essere modificate durante l’esecuzione. OpenGL

Esempio main () { glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(-1.0, -1.0, 0.0); glRotatef(90.0, 0.0, 0.0, 1.0); glBegin(GL_POLYGON); glVertex3f(1.0, 1.0, 0.0); glVertex3f(2.0, 1.0, 0.0); glVertex3f(1.0, 2.0, 0.0); glEnd(); glFlush(); } OpenGL

Matrice di Proiezione Bisogna modificare la matrice GL_PROJECTION Assume che la trasformazione collegata alla matrice GL_MODELVIEW porti il sistema di vista a coincidere con gli assi coordinato (WC = VRC) e che il piano di proiezione sia diventato z = -d, cioè perpendicolare all’asse z e sulle z negative. OpenGL

Proiezioni Prospettiche Proiezioni prospettiche. Il comando fondamentale è glFrustum(left, right, bottom, top, near, far) che definisce una matrice di proiezione dando i clipping planes (near e far) e la finestra (sul piano near). Alternativa usando la libreria GLU: gluPerspective(fovy, aspect, near, far) Fornisce l’angolo di apertura sul piano xz (fovy), il rapporto della finestra w/h (aspect) il front ed il back plane. OpenGL

Proiezioni Prospettiche (2) OpenGL

Proiezioni Parallele Proiezioni parallele. Il comando fondamentale è glOrtho(left, right, bottom, top, near, far) che definisce una matrice di proiezione dando i clipping planes (near e far) e la finestra (su uno qualunque dei piani). OpenGL

Viewport Il viewport si definisce con il comando: glViewport(x, y, width, height); se non viene definito, per default si prende x=0, y=0 e width ed height uguali alla dimensione della finestra. Per non distorcere l’immagine bisogna che width ed height siano nello stesso rapporto della larghezza ed altezza della finestra sul piano. Può essere usato per avere più immagini nella stessa finestra. Ognuna occupa una parte. OpenGL

Operazioni su Matrici OpenGL mantiene le matrici in degli stacks. Uno stack per la GL_MODELVIEW (dimensione almeno 32) ed uno per la GL_PROJECTION. Le trasformazioni si applicano alla matrice top dello stack corrente. Molto utili per memorizzare alcune matrici che devono essere applicate a più primitive. Operazioni sugli stack sono: glPushMatrix() duplica la matrice affiorante e la inserisce in testa glPopMatrix() elimina la matrice affiorante. OpenGL

Esempio void disegna_bicicletta () { Posizionati nell’origine del modello, disegna il telaio; glPushMatrix(); glTranslatef(40,0,30); disegna prima ruota; glPopMatrix(); glTranslatef(40,0,-30); disegna seconda ruota; OpenGL

Eliminazione Parti Nascoste Per default, OpenGL non elimina le parti nascoste, ma disegna gli oggetti nell’ordine in cui li incontra. Per eliminare le parti nascoste bisogna dare il comando: glEnable(GL_DEPTH_TEST); che rende attivo il Depth Buffer. Prima di usare il buffer bisogna però inizializzarlo con: glClear(GL_DEPTH_BUFFER_BIT); NOTA: Il comando glEnable si applica a tutte le variabili di stato booleane. OpenGL

Animazioni (1) L’uso maggiore di OpenGL non è per generare immagini, ma per fare delle animazioni. Le animazioni richiedono di disegnare sullo schermo molte immagini in sequenza ad un ritmo di (possibilmente) almeno 30 al secondo. Esempio: apri finestra; for (i=0, i < massimo, i++) { pulisci la finestra; disegna immagine; aspetta fino ad (i+1)/30 secondi; } OpenGL

Animazioni (2) Problemi: 1) Si nota che lo schermo viene pulito 2) Si vede mentre l’immagine viene disegnata. 3) L’immagine non è stabile poiché lo schermo viene continuamente aggiornato OpenGL

Double Buffering (1) Risolve (parzialmente) il problema dello sfarfallio (flickering) con la seguente tecnica: 1) Usa un secondo buffer dove viene effettuato il disegno. 2) Sostituisci il secondo buffer al primo solo dopo che è stato completamente disegnato. OpenGL

Double Buffering (2) In OpenGL il double buffering viene gestito da GLUT (o dal sistema operativo). In GLUT abbiamo i comandi: glutInitDisplayMode(GLUT_DOUBLE) Dichiara che si useranno due buffers. Il primo viene presentato sullo schermo, mentre il disegno verrà fatto sul secondo. glutSwapBuffers() Scambia i due buffers, presentando il second sullo schermo. OpenGL

Esempio (1) int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB); glutInitWindowSize (250, 250); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutIdleFunc(spinDisplay); glutMainLoop(); return 0; } OpenGL

Esempio (2) #include <GL/glut.h> #include <stdlib.h> static GLfloat spin = 0.0; void display(void) { glClear(GL_COLOR_BUFFER_BIT); glPushMatrix(); glRotatef(spin, 0.0, 0.0, 1.0); glColor3f(1.0, 1.0, 1.0); glRectf(-25.0, -25.0, 25.0, 25.0); glPopMatrix(); glutSwapBuffers(); } void spinDisplay(void) { spin = spin + 2.0; if (spin > 360.0) spin = spin - 360.0; glutPostRedisplay(); } void init(void) { glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_FLAT); } OpenGL

Eliminazione parti nascoste OpenGL ha built-in le procedure per l’eliminazione delle parti nascoste. Bisogna solo renderle attive. Questo richiede almeno 3 passi: 1) glutInitDisplayMode(GLUT_DEPTH | ……); Inizializza la finestra predisponendola per fare il controllo sulla profondità che elimina le parti nascoste 2) glEnable(GL_DEPTH_TEST); Abilita (in OpenGL) il controllo sulla profondità 3) glClearDepth(); Sceglie il valore (tra 0 ed 1) di clear della profondità (per default vale 1). 4) glClear(GL_DEPTH_BUFFER_BIT); Inizializza il buffer che mantiene le informazioni sulla profondità OpenGL

Illuminazione Per definire l’illuminazione in OpenGL bisogna fare diversi passi: 1) Definire dei solidi, fornendo la normale uscente da ogni vertice; 2) Creare, selezionare e posizionare le sorgenti di luce; 3) Creare e selezionare un modello d’illuminazione; 4) Definire le proprietà dei materiali presenti nella scena. OpenGL

Tipi di Luce In OpenGL ci sono tre tipi di luce, ognuna con un proprio colore: 1) Ambiente; Luce dispersa dalla riflessione sulle superfici tale che non ha una direzione, ma illumina uniformemente tutti gli oggetti. 2) Diffusa; Luce che colpisce un oggetto e viene diffusa in tutte le direzioni 3) Speculare; Luce che colpisce un oggetto e viene diffusa principalmente in una direzione OpenGL

Attivazione Illuminazione Per default l’illuminazione non e’ attiva. Per renderla attiva bisogna dare i comandi: 1) glEnable(GL_LIGHTING); Attiva l’illuminazione. 2) glEnable(GL_LIGHT0); Accende la luce 0. Necessario se no le luci non illuminano la scena. Quando e’ attiva l’illuminazione il modello di disegno deve essere GL_SMOOTH, quindi bisogna dare il comando glShadeModel(GL_SMOOTH); OpenGL

Definizione Normali Le normali uscenti dai vertici servono per calcolare quanta luce colpisce il vertice. Tutte le primitive glut solide (non wire) hanno già definite queste normali. Se non sono definite, si aggiungono nel comando glBegin(GL_POLYGON); glNormal3f(0.0 ,0.0, 1.0); glVertex3f(0.25, -0.25, 0.0); glNormal3f(0.0 ,0.0, 1.0); glVertex3f(0.75, 0.25, 0.0); glNormal3f(0.0 ,0.0, 1.0); glVertex3f(0.75, 0.75, 0.0); glNormal3f(0.0 ,0.0, 1.0); glVertex3f(0.25, 0.75, 0.0); glEnd(); OpenGL

Creazione Sorgenti Luce Specificate con il comando glLightfv(Glenum light, Glenum pname, TYPE *param) dove light e’ il nome della luce (GL_LIGHT0 .. GL_LIGHT7 in molte implementazioni), pname e’ il parametro da settare e param un vettore di valori da assegnare al pname. I parametri più importanti sono: GL_AMBIENT GL_DIFFUSE GL_SPECULAR definiscono le caratteristiche della luce GL_POSITION GL_SPOT_DIRECTION definiscono posizione (direzione se all’infinito) e orientamento (solo se al finito) della luce. OpenGL

Scelta del Modello Specifica le caratteristiche del modello di illuminazione da usare per la visualizzazione (rendering) della scena. Comando: glLightModelfv(Glenum pname, TYPE *param) dove pname e’ il parametro da settare e param un vettore di valori da assegnare al pname. Per ora useremo sempre il modello di default. Vedremo meglio le caratteristiche più avanti nel corso. OpenGL

Proprietà dei Materiali Bisogna definire come gli oggetti presenti nella scena reagiscono alla luce. Specificato con il comando: glMaterialfv(Glenum face, Glenum pname, TYPE *param) dove face e’ la faccia (front, back o entrambe), pname e’ il parametro da settare e param un vettore di valori da assegnare al pname. I parametri più importanti sono: GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_SHININESS GL_EMISSION che definiscono il comportamento del materiale quando viene illuminato. OpenGL

Effetti Avanzati OpenGL può generare i seguenti effetti: 1) Oggetti trasparenti. 2) Blending di immagini 3) Antialiasing 4) Nebbia (visibilità limitata) 5) Texture mapping (incluso mipmapping) OpenGL

Buffers Il framebuffer di OpenGL e’ composto in realtà da un insieme di buffers, che sono: 1) Color buffers (almeno 2, spesso di più per la visione stereo). 2) Depth buffer 3) Stencil buffer Usato per “ritagliare” aree dello schermo 4) Accumulation buffer Accumula i risultati per effetti speciali come Motion Blur, simulare il fuoco, ombre, ... OpenGL

Primitive non Piane OpenGL permette di disegnare: 1) Poligoni non semplici Attraverso la tessellazione 2) Quadriche Tutte le superfici esprimibili con equazioni quadratiche in 2 variabili (sfere, cilindri, dischi,..) 3) Curve parametriche e Superfici parametriche Supporto per le curve e superfici parametriche di Bezier e NURBS OpenGL

Selezione e Feedback OpenGL permette di selezionare e fare il picking degli oggetti sullo schermo fornendo le primitive necessarie Inoltre e’ possibile interrogare OpenGL per controllare le coordinate (trasformate) ed il colore (dopo l’illuminazione) degli oggetti. OpenGL