informatica grafica opengl1 l libreria grafica composta da circa 150 comandi. realizzata in vari...

OpenGL 1Informatica Grafica

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.


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.


Pipeline Grafica

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


Librerie


Primo Esempiomain() { 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();

}


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


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 integers 16-bit integer us 16-bit unsigned integeri 32-bit integer ui 32-bit unsigned integerf 32-bit floating-point d 64-bit floating-point

Alcuni comandi possono prevedere un terzo suffisso (v) per indicare che si applicano a vettori.


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.


Struttura

GLUT gestisce completamente il funzionamento del programma, ma demanda ad openGL la generazione dell’immagine.

Le funzioni principali sono:

glutInit glutInitDisplayModeglutInitWindowPosition glutInitWindowSizeglutCreateWindow glutMainLoopglutDisplayFunc glutPostRedisplay


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;

}


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();

}


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.


Buffers

OpenGL mantiene in memoria almeno 4 buffers:

Tipo IdentificativoColor 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.


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.


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();


Disegno Primitive

Ogni primitiva viene disegnata in modo diverso.GL_POINTS Solo i verticiGL_LINES Le linee da 0 ad 1, da 2 a 3, etcGL_POLYGON Il poligono pienoGL_TRIANGLES I triangoli pieni formati dai

vertici 0-2, 3-5, etc...GL_LINE_STRIP La spezzata (non chiusa) che

congiunge i vertici in ordineGL_LINE_LOOP La spezzata (chiusa) che

congiunge i vertici in ordine


Disegno Primitive (2)

GL_QUADS I quadrilateri pieni formati daivertici 0-3, 4-7, etc...

GL_QUAD_STRIP I quadrilateri pieni formati daivertici 0-3, 2-5, 4-7 etc...

GL_TRIANGLE_STRIP I triangoli pieni formati daivertici 0-2, 1-3, 2-4 etc...

GL_TRIANGLE_FAN I triangoli pieni formati daivertici 012, 023, 034 etc...


Disegno Primitive (3)


PoligoniSi 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();


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


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();


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 4x4glMultMatrix(matrice) moltiplica, a destra, la

matrice corrente per la matrice specificata


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.


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 assiNon esiste la trasformazione di shearing, ma si può inizializzare una matrice con 16 valori qualunque usando glLoadMatrix.


Coordinate di vista Per portarsi in coordinate di vista possiamo usare

le trasformazioni viste oppure usare il comandogluLookAt( 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.


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.


Esempiomain () {

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();

}


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.


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.


Proiezioni Prospettiche (2)


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).


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.


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 testaglPopMatrix() elimina la matrice affiorante.


Esempio

void disegna_bicicletta () {Posizionati nell’origine del modello,disegna il telaio;glPushMatrix();

glTranslatef(40,0,30);disegna prima ruota;

glPopMatrix();glPushMatrix();

glTranslatef(40,0,-30);disegna seconda ruota;

glPopMatrix();


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.


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;

}


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


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.


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.


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; }


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); }


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à


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.


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


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);


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();


Creazione Sorgenti Luce Specificate con il comandoglLightfv(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 luceGL_POSITION GL_SPOT_DIRECTION

definiscono posizione (direzione se all’infinito) e orientamento (solo se al finito) della luce.


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.


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_SPECULARGL_SHININESS GL_EMISSION

che definiscono il comportamento del materiale quando viene illuminato.


Effetti Avanzati

OpenGL può generare i seguenti effetti:

1) Oggetti trasparenti.2) Blending di immagini3) Antialiasing4) Nebbia (visibilità limitata)5) Texture mapping (incluso mipmapping)


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 buffer3) Stencil buffer

Usato per “ritagliare” aree dello schermo4) Accumulation buffer

Accumula i risultati per effetti speciali come Motion Blur, simulare il fuoco, ombre, ...


Primitive non Piane

OpenGL permette di disegnare:1) Poligoni non semplici

Attraverso la tessellazione2) Quadriche

Tutte le superfici esprimibili con equazioni quadratiche in 2 variabili (sfere, cilindri, dischi,..)

3) Curve parametriche e Superfici parametricheSupporto per le curve e superfici parametriche di Bezier e NURBS


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.

informatica grafica opengl1 l libreria grafica composta da circa 150 comandi. realizzata in vari...

Documents