OpenGL e Glut

Ruoli di OpenGL e di Glut

OpenGL e' una libreria grafica. Fornisce strumenti per "disegnare" una scena in una finestra.

Assume di avere a disposizione una finestra in cui disegnare, ma non e' in grado di procurarsene una ne' di gestire l'interazione dell'utente con la finestra.

Glut e' una libreria creata per colmare questa lacuna. Crea finestre in cui OpenGL possa disegnare e gestisce l'interazione con l'utente su tali finestre.

Glut NON e' una libreria per interfacce grafiche. Non fornisce dispositivi di interazione sofisticati (bottoni, campi di testo, ecc.).

Una finestra creata da Glut e' "monolitica", non c'e' possibilita' di darle una struttura creando sottocomponenti/sottofinestre (pannelli, bottoni, ecc., come nelle librerie per interfacce grafiche).

Una finestra Glut prevede un certo numero di eventi che possono essere catturati associandovi delle funzioni callback. La funzione callback associata ad un certo tipo di evento scattera' automaticamente al verificarsi di quell'evento sulla finestra. Una callback e' associata a tutta la finestra, non c'e' possibilita' di associare callback diverse a zone diverse della finestra (appunto perche' la finestra e' monolitica).

Inoltre Glut prevede la possibilita' di associare un menu' pop-up alla finestra, che appare quando l'utente preme il mouse all'interno della finestra. Anche qui un solo menu' pop-up e' associato a tutta la finestra, non c'e' possibilita' di associare menu' diversi a zone diverse della finestra (la finestra e' monolitica). Il menu' puo' essere gerarchico, cioe' avere sotto-menu'.
Nota: in realta' si possono avere tanti menu' quanti i tasti del mouse.

Il tipico programma

Un programma OpenGL+Glut consiste in:

• main contenente codice Glut per compiere:

  • inizializzazione
  • creazione delle finestre (almeno una)
  • registrazione di callback per gli eventi di interesse nelle finestre (almeno la callback di "ridisegnamento")
  • eventuale creazione di menu' (e sottomenu') con relative callback
  • innesco del "main loop"

• un insieme di funzioni callback che contengono codice scritto dal programmatore (compreso il codice OpenGL) e sono registrate (nel main) per scattare in corrispondenza di eventi nelle finestre o all'attivazione dei menu' (e dei sottomenu').

Il main

Inizializzazione

glutInit(int * argc, char ** argv);

Chiamata con gli stessi argomenti con cui il programma e' invocato da command line.

Creazione delle finestre

Per ciascuna finestra che si vuole creare bisogna chiamare:

• glutInitDisplayMode(unsigned int);

  Stabilisce i requisiti della finestra da creare. I requisiti (in argomento) sono espressi da una lista di costanti intere messe in OR bit-a-bit. Tipiche richieste sono:

  • GLUT_DOUBLE: chiediamo double buffer
  • GLUT_RGB: chiediamo un color buffer in modalita' di colore RGB
  • GLUT_DEPTH: chiediamo lo z-buffer, che serve per l'eliminazione delle superifici nascoste in scene 3D
  Esempio:
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

• glutInitWindowSize(int dimX, int dimY);

  (Opzionale) Stabilisce le dimensioni della finestra da creare (larghezza e altezza in pixel). E' solo un suggerimento, puo' essere ignorata dal window system.

• glutInitWindowPosition(int x0, int y0);

  (Opzionale) Stabilisce la posizione (riferita all'intero schermo) della finestra da creare. E' solo un suggerimento, puo' essere ignorata dal window system.

• int glutCreateWindow(char * label);

  Crea la finestra e ritorna un identificatore intero per tale finestra. La stringa label comparira' sulla barra del titolo della finestra (e' solo un suggerimento, puo' essere ignorata dal window system). La finestra creata non viene ancora resa visibile.

Registrazione di callback per gli eventi

Per ciascuna finestra e' necessario registrare almeno la display callback, che scatta quando la finestra diventa visibile (la prima volta, oppure dopo essere stata parzialmente o totalmente nascosta). Tale callback contiene il codice OpenGL necessario a disegnare la scena.
Sulle callback torneremo dopo.

• Per registrare la callback (nel main): glutDisplayFunc(f);

• Il tipo della funzione f (definita a parte) deve essere: void f (void)

Definizione di menu' e loro callback

Su questo torneremo dopo.

Main loop

A questo punto e' tutto predisposto, ma non appare ancora nulla su shermo.

glutMainLoop();

Rende visibile la finestra ed innesca il ciclo principale di gestione degli eventi. Questo e' un ciclo senza fine, interamente gestito da Glut, che ad ogni giro:

• attende un evento a cui sia stata associata una callback
• attiva la callback corrispondente

Il main loop non termina mai. Va chiamato come ultima istruzione del main, dopo avere registrato le callback. Il programma puo' terminare solo eseguendo exit all'interno di una funzione callback.

Callback

Eventi/callback previsti da Glut:

• Display: scatta quando la finestra e' resa visibile per la prima volta oppure torna ad essere visibile dopo essere stata (parzialmente) coperta da un'altra o dopo essere stata iconificata.
• Reshape: scatta quando la finestra cambia dimensioni, tipicamente per intervento dell'utente.
• Keyboard: scatta quando l'utente preme un carattere della tastiera avendo il focus sulla finestra (solo i caratteri "scrivibili", sono esclusi i tasti speciali).
• Special: scatta quando l'utente preme un tasto speciale (tasti funzione, frecce, ecc.) avendo il focus sulla finestra.
• Mouse: scatta quando l'utente preme o rilascia un bottone del mouse con il puntatore dentro la finestra.
• MouseMotion: scatta quando l'utente muove il mouse all'interno della finestra, con uno dei bottoni premuto.
• PassiveMotion: scatta quando l'utente muove il mouse all'interno della finestra, senza nessun bottone premuto.
• Entry: scatta quando il mouse entra od esce dalla finestra.
• Idle: scatta "continuamente", cioe' ad ogni giro del main loop, serve per creare animazioni. Per esempio: sposta l'oggetto e lo ridisegna (essendo chiamata continuamente, produce l'immagine di un oggetto in movimento).
• Visibility: scatta quando lo stato della finestra passa da visibile a non visibile o viceversa, tipicamente usata per disattivare l'animazione quando la finestra non e' visibile.
• Timer: scatta dopo un certo numero di millisecondi.
• MenuStatus: scatta quando un menu' pop-up e' attivato o disattivato, tipicamente usata per sospendere l'animazione mentre l'utente sta interagendo con il menu'.

Le funzioni da usare come callback devono essere scritte dal programmatore prevedendo certi parametri come argomenti. Il numero, tipo e significato degli argomenti dipendono dal tipo di evento. Per esempio:

• la display callback non ha argomenti
• la mouse callback ha come argomenti la posizione (x,y) del puntatore del mouse nella finestra e uno stato che indica se il mouse e' stato premuto o rilasciato

Sia XXXXX il nome di un evento Glut (vedere lista precedente):

• glutXXXXXFunc(f); registra la funzione f come callback di quell'evento
• glutXXXXXFunc(NULL); de-registra la callback precedentemente registrata per quell'evento

Callback relative al disegno OpenGL

Display callback

Funzione senza argomenti, di tipo: void f(void)

Chiamata da Glut quando e' necessario ridisegnare la finestra. Contiene il codice OpenGL che ridisegna la scena.

Si puo' chiamare anche da programma mediante istruzione appostita, per ridisegnare la scena dopo aver cambiato qualcosa.

• Per associare f alla finestra come display callback (nel main):
  glutDisplayFunc(f);

• Per chiamarla da programma (dopo averla associata come display callback):
  glutPostRedisplay();

Di norma tutto il codice OpenGL trova posto nella display callback. Non mettere codice OpenGL dentro altre callback. Se una callback deve ridisegnare la scena (es. idle callback per animazione) lo deve fare chiamando glutPostRedisplay(); (vedere anche dopo).

Tipicamente il corpo della display callback contiene:

• Abilitazioni delle funzionalita' OpenGL (glEnable)

  Alcune funzioni OpenGL computazionalmente costose non sono abilitate, le abilita il programmatore solo se servono per la scena che vuole disegnare. Per esempio:

  • glEnable(GL_DEPTH_TEST); abilita l'eliminazione delle superfici nascoste (serve solo per scene 3D)
  • glEnable(GL_LIGHTING); abilita l'illuminazione (solo per scene illuminate)
  • glEnable(GL_LIGHTi); con i=0,1,2... abilita l'i-esima luce (dipende da quante luci vogliamo)

• Pulizia del foglio (glClear)

  Si cancella il contenuto dei buffer dove si andra' a disegnare. L'argomento e' una lista di costanti intere messe in OR bit-a-bit. Per esempio:

  • glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BIT); pulisce color buffer e depth buffer

• Trasformazione di proiezione

  Stabilisce quale parte della scena viene inquadrata per produrre l'immagine (volume di vista). In OpenGL e' gestita da una matrice 4x4 chiamata projection matrix. La trasformazione di default, rappresentata dalla matrice identita', corrisponde ad una proiezione ortografica che ha come volume di vista il cubo con diagonale (-1,-1,-1)-(1,1,1).

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  Sulle trasformazioni di proiezione torneremo dopo.

• Trasformazione di vista

  Stabilisce la posizione del punto di vista da cui guardiamo la scena. In OpenGL e' gestita da una matrice 4x4 chiamata modelview. La trasformazione di default, rappresentata dalla matrice identita', mette il punto di vista in (0,0,0) e rivolto verso la direzione negativa dell'asse z.

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  Sulle trasformazioni di vista torneremo dopo.

  Notare che, nel caso di trasformazioni di proiezione e di vista di default, il punto di vista sta al centro del volume di vista, cioe' una parte della scena inquadrata rimane dietro le spalle dell'osservatore. Questo e' permesso in proiezione ortografica: di fatto, non importa dove sta il punto di vista, la scena e' comunque proiettata con raggi visuali paralleli tra loro. Diverso sarebbe se la proiezione fosse prospettica. Ci torneremo.

• Assegnazione degli attributi e chiamata delle primitive.

  Prima di chiamare una primitiva occorre "preparare il terreno" assegnando il valore desiderato a tutti gli attributi rilevanti.

  • glPointSize(float); stabilisce la grandezza del marchio usato per disegnare i punti, per default 1.0
  • glLineWidth(float); stabilisce lo spessore del tratto usato per disegnare le linee, per default 1.0
  • glPolygonMode(unsigned int, unsigned int); stabilisce il modo di tracciamento dei poligoni.
    Il primo argomento e' la faccia (ogni poligono ha due facce): essere GL_FRONT, GL_BACK, oppure GL_FRONT_AND_BACK.
    Il secondo argomento e' il modo: GL_FILL = pieno (default), GL_LINE = solo i lati, oppure GL_POINT = solo i vertici
  • glColor in assenza di illuminazione, stabilisce il colore. Ha varie forme a seconda di come si vogliono passare i parametri (vedere il manuale)

  Sotto l'influsso degli attributi appena assegnati, si puo' chiamare la primitiva specificando il tipo e la lista dei vertici.

  glBegin(int tipo_primitiva);
  ...
  glEnd();
  

  dove tra la coppia glBegin,glEnd trovano posto i vertici. Per specificare un vertice si usa glVertex che ha varie forme a seconda di come si vogliono passare i parametri (vedere il manuale).

• Scambio di front e back buffer

  Essendo la finestra double buffer, il disegno finora e' stato tracciato nel back buffer, ora lo portiamo nel front buffer perche' sia reso visibile sullo schermo.

  glFlush();
  glutSwapBuffers();

Reshape callback

Funzione con due argomenti, di tipo: void f(int, int)

Chiamata da Glut quando la finestra cambia dimensioni. Gli argomenti sono generati automaticamente e sono le nuove dimensioni in pixel della finestra (larghezza, altezza).

Per associare f alla finestra come reshape callback (nel main):
glutReshapeFunc(f);

La parte di finestra in cui OpenGL disegna e' chiamata viewport. Per default (cioe' se non viene registrata una reshape callback), Glut mantiene sempre la viewport coincidente con tutta la finestra.
Questo significa che se sto disegnando un quadrato in una finestra quadrata e l'utente deforma la finestra rendendola rettangolare, il mio quadrato diventera' un rettangolo (si altera la "aspect ratio").
Il programmatore puo' registrare una reshape callback che eviti questo problema imponendo a OpenGL di disegnare sempre in una sottoparte quadrata della finestra (mantenimento della "aspect ratio").

Tipicamente il corpo della reshape callback contiene:

• Assegnazione della viewport

  glViewport(x0, y0, w, h);

  Gli argomenti (interi, espressi in pixel) specificano le coordinate (x0,y0) dell'angolo in basso a sinistra della viewport e le sue dimensioni larghezza, altezza (w,h).
  Glut intende le coordinate della finestra con l'origine in basso a sinistra.

• Ridisegnamento

  Ottenuto chiamando glutPostRedisplay();

Nota sulle altre callback

Le uniche funzioni callback che contengono codice OpenGL sono la display callback e la reshape callback (per il cambiamento della viewport). Non mettere codice OpenGL nelle altre funzioni callback.

Il corpo di funzione callback di solito contiene:

• Cambio di stato del programma

  A seconda di che cosa e' successo (leggibile nei parametri che Glut passa alla callback) il programma cambia il valore di alcune sue variabili interne.
  In particolare puo' cambiare il valore di variabili globali che sono usate nella display callback (es: lo spessore di linea corrente).

• Ridisegnamento

  Se occorre (cioe' se sono cambiate delle variabili usate nella display callback) ridisegna la scena chiamando glutPostRedisplay();

Callback relative alla tastiera

Keyboard callback

Funzione con tre argomenti, di tipo: void f(unsigned char c, int x, int y)

Chiamata da Glut quando l'utente preme un carattere stampabile della tastiera. Gli argomenti, generati automaticamente, sono

• c = il carattere premuto
• (x,y) = la posizione del mouse nel momento in cui e' stato premuto (in pixel)

Per associare f alla finestra come keyboard callback (nel main):
glutKeyboardFunc(f);

Special callback

Funzione con tre argomenti, di tipo: void f(int k, int x, int y)

Chiamata da Glut quando l'utente preme un tasto speciale (non stampabile) della tastiera. Gli argomenti, generati automaticamente, sono

• k = il codice ASCII del tasto premuto (Glut ha una serie di #define per i codici ASCII dei tasti speciali)
• (x,y) = la posizione del mouse

Per associare f alla finestra come special callback (nel main):
glutSpecialFunc(f);

Callback relative al mouse

Mouse callback

Funzione con quattro argomenti, di tipo: void f(int b, int s, int x, int y)

Chiamata da Glut quando l'utente preme o rilascia un bottone del mouse. Gli argomenti, generati automaticamente, sono

• b = il numero del bottone: GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o GLUT_RIGHT_BUTTON
• s = il suo stato (premuto o rilasciato): GLUT_DOWN o GLUT_UP
• (x,y) = la posizione del mouse

Per associare f alla finestra come mouse function:
glutMouseFunc(f);

Motion e Passive Motion callback

Funzioni a due argomenti, di tipo: void f(int x, int y)

Chiamate da Glut quando l'utente muove il mouse tenendo il bottone rispettivamente premuto o rilasciato. L'argomento e' la posizione (x,y) del mouse.

Per associare f alla finestra come motion o passive motion callback:
glutMotionFunc(f); oppure glutPassiveMotionFunc(f);

Entry callback

Funzione a un solo argomento, di tipo: void f(int s)

Chiamata da Glut quando il mouse entra od esce dalla finestra. L'argomento e' lo stato attuale: GLUT_ENTERED o GLUT_LEFT.

Per associare f alla finestra come entry callback:
glutEntryFunc(f);

Callback relative all'animazione

Idle callback

Funzione senza argomenti, di tipo: void f(void)

Chiamata da Glut "continuamente", cioe' ad ogni giro del main loop.

Per associare f alla finestra come idle callback:
glutIdleFunc(f);

Visibility callback

Funzione a un solo argomento, di tipo: void f(int s)

Chiamata da Glut quando lo stato della finestra passa da visibile a invisibile o viceversa. L'argomento e' lo stato attuale: GLUT_VISIBLE o GLUT_NOT_VISIBLE.

Tipicamente usata per togliere la idle callback quando la finestra non e' visibile e rimetterla quando torna visibile. Per togliere la idle callback: glutIdleFunc(NULL);

Per associare f alla finestra come visibility callback:
glutVisibilityFunc(f);

Timer callback

Funzione a un solo argomento, di tipo: void f(int v)

Chiamata da Glut dopo un tempo stabilito a partire da quando la funzione viene registrata come timer callback. Anche il valore di v e' stabilito al momento della registrazione.

Per associare f alla finestra come timer callback:
glutTimerFunc(k,f,v);

• k = tempo dopo il quale deve essere chiamata f (in millisecondi)
• v = valore che sara' passato da Glut a f quando la chiamera'

Menu'

Glut permette di regitrare un menu' pop-up gerarchico (anche detto "a cascata") associato ad bottone del mouse in una finestra.

• Pop-up: menu' che appare sovrapposto alla finestra quando premo un tasto del mouse sullo sfondo della finestra, e scompare quando rilascio il bottone. Seleziono le voci scorrendo con il mouse premuto.
• A cascata: ad una voce di un menu' puo' essere associato un sottomenu' che appare quando scorro con il mouse su quella voce.

Costruzione del menu' della finestra

La gerarchia di menu' e' rappresentata da un albero. La radice e' il menu' principale che appare cliccando con il mouse sulla finestra (con il bottone prestabilito). Se una voce di menu' chiama un sottomenu', il sottomenu' e' figlio del menu' che lo chiama (il quale puo' essere sottomenu' di un altro). Le foglie sono menu' che non ne chiamano altri.

La gerarchia si costruisce "dal basso" iniziando dalle foglie.

• glutCreateMenu crea un menu' (senza voci e "staccato" dalla gerarchia")
• glutAddMenuEntry aggiunge una voce (voce "ordinaria") a un menu'
• glutAddSubMenu aggiunge una voce che invoca un sottomenu' (collega un menu' alla gerarchia rendendolo figlio/sottomenu' di un altro)
• glutAttachMenu collega il menu' (quello a radice della gerarchia) ad un tasto del mouse

Per una finestra si possono avere fino a tre gerarchie di menu', ciascuna con la radice collegata a un diverso bottone del mouse.

Creazione

int glutCreateMenu(f);

Crea un menu' (finora senza alcuna voce) avente la funzione f come callback. Ritorna un identificatore per il menu'. Il menu' appena creato diventa il menu' corrente, tutte le successive istruzioni di manipolazione di menu' si riferiscono al menu' corrente.

La funzione f e' incaricata di eseguire le azioni corrispondenti alle varie voci.
E' una funzione a un argomento del tipo: void f (int i)
Quando l'utente selezionera' la voce i-esima del menu', Glut chiamera' automaticamente la funzione f con argomento i.

Tipicamente il corpo di f contiene uno switch a seconda del valore di i.
Valgono le considerazioni fatte per le altre callback: non mettere codice OpenGL nel corpo di f!

Aggiunta di voci "ordinarie"

void glutAddMenuEntry(char * label, int v);

Aggiunge una voce al menu' corrente.

• label = la stringa che apparira' sulla voce di menu'
• v = il valore che Glut passera' alla callback del menu' quando l'utente selezionera' quella voce

Collegamento di sottomenu'

void glutAddSubMenu(char * label, int m);

Aggiunge al menu' corrente una voce che invoca un altro menu' (sottomenu'). Il sottomenu' apparira' quando l'utente scorrera' col mouse su quella voce.

• label = la stringa che apparira' sulla voce di menu'
• m = l'identificatore ritornato da glutCreateMenu quando e' stato creato il sottomenu'

Per il menu' radice

void glutAttachMenu(int b);

Callback per i menu'

E' buona norma disattivare funzioni costose (es. animazione) mentre l'utente sta interagendo con un menu' pop-up. La Menu Status callback e' chiamata da Glut quando attiva o disattiva un menu' pop-up.

La menu' callback e' una funzione a tre argomenti, di tipo:
void f(int s, int x, int y)

• s = lo stato attuale: GLUT_MENU_IN_USE se qualche menu' e' popped-up, GLUT_MENU_NOT_IN_USE altrimenti
• (x,y) = posizione del mouse quando il menu' e' stato invocato o rilasciato

Altre funzioni utili per i menu'

Ne citiamo solo alcune:

• int glutGetMenu(void); ritorna il menu' corrente.
• glutSetMenu(int m); assegna il menu' corrente.
• glutDetachMenu(int b); sgancia il menu' attaccato al bottone b del mouse.