Strutturare una finestra Glut

Obiettivo

Abbiamo detto che una finestra creata da Glut e' "monolitica" cioe' gestita come un pezzo unico:

• per ogni tipo di evento al piu' una sola callback attiva su tutta l'area della finestra
• in particolare una sola funzione di ridisegnamento (display callback)
• per ogni bottone del mouse al piu' un menu' pop-up (con eventuale gerarchia di sottomenu')

Non e' possibile strutturare la finestra in sotto-aree indipendenti, cioe' ciascuna con sua funzione di ridisegnamento, sue callback per gli eventi, suoi menu' pop-up, diversi da quelli delle altre sotto-aree.
Pero' si puo' simulare.

Strutturazione simulata

La struttura della finestra in sotto-aree e' gestita interamente dal programmatore, ad "insaputa" di Glut.

Esempio: finestra divisa verticalmente in due parti uguali

  +-----------------+        +--------+--------+
  |                 |        |        |        | 
  |                 |        |        |        |
  |    finestra     |h       |  area1 | area2  |h
  |                 |        |        |        |
  |                 |        |        |        |
  +-----------------+        +--------+--------+
           w                     w/2     w/2

Un diverso comportamento per area1 e area2 si simula sfruttando il fatto che e' possibile cambiare dinamicamente la viewport, le callback registrate e i menu'.

• il diverso ridisegnamento si simula cambiando la viewport di OpenGL a run-time mentre si disegna
• diverse callback per lo stesso evento si simulano cambiando la callback a run-time a seconda della posizione corrente del mouse
• diversi menu' pop-up si simulano attaccando al bottone del mouse un menu' diverso a seconda della posizione corrente del mouse

Disegnamento differenziato

La finestra ha sempre un'unica display callback, la quale

1. pulisce tutta la finestra
2. per ciascuna sotto-area:
   • restringe la viewport all'estensione della sotto-area
   • disegna la scena della sotto-area con viewport ristretta
3. ripristina la viewport a tutta finestra
4. scambia front e back buffer

Ottenere la viewport corrente

La viewport e' sempre mantenuta a tutta finestra tranne al passo 2. La viewport e' parte dello stato di OpenGL e si legge con

• glGetIntegerv(GL_VIEWPORT,wp);

Assegnare una viewport ristretta

1. Calcolare il punto di aggancio e le dimensioni della sotto-area. Per il punto di aggancio ricordare che per OpenGL y=0 in basso.
   Nell'esempio di prima: area1 = (wp[0],wp[1],wp[3]/2,wp[4]), area2 = (wp[3]/2,wp[1],wp[3]/2,wp[4])
2. Assegnare la nuova viewport con glViewport

   Disegnare nella viewport ristretta

   Esattamente come disegnare in una viewport normale. Occorre: assegnare matrici projection e modelview, impostare attributi, definire primitive.

   Ripristinare la viewport precedente

   Richiamare glViewport con i valori salvati nell'array wp.

   Callback e menu' differenziati

   Idea

   Cambiare la callback o il menu' al volo quando il puntatore del mouse passa da una sotto-area all'altra.

   Come si fa

   Si registra come motion callback e come passive potion callback una funzione f(int x, int y) che esegua le seguenti operazioni:

   • Verifica a quale area appartiene la posizione corrente del mouse (x,y)
     Nell'esempio appartiene ad area1 se x<w/2 e ad area2 altrimenti, dove w e' la larghezza della viewport globale (l'intera finestra).

   • Per ciascun tipo di evento XXXX considerato nel programma, registra con glXXXXFunc la funzione callback desiderata per l'area in questione.
     Se nell'area l'evento XXXX non prevede callback, registra la funzione nulla NULL

   • Per ciascun bottone del mouse considerato nel programma per menu' pop-up:

     • stacca il menu' correntemente associato al tasto con glDetachMenu
     • se l'area prevede menu' per quel tasto, attacca il menu' desiderato con glAttachMenu

   Staccare e attaccare menu' mentre questi sono in uso (cioe' visibili ovvero "popped-up") provoca errore. Per evitare questo, occorre disabilitare motion e passive motion callback mentre i menu' sono in uso.
   A tale scopo si registra come menu status callback una funzione g(int s, int x, int y) che:

   • se lo stato s e' GLUT_MENU_IN_USE disabilita le motion e passive motion callback (registrando per esse la funzione nulla NULL)
   • se lo stato s e' GLUT_MENU_NOT_IN_USE abilita le motion e passive motion callback (registrando per esse la funzione f di cui sopra)

   Primitive raster in OpenGL

   Esistono due formati grafici:

   • formato vector = specificato con punti e geometrie in uno spazio di coordinate "astratto" indipendente dall'immagine
   • formato raster = specificato come matrice di pixel pronta da copiare nell'immagine

   Le primitive OpenGL viste finora (definite come liste di vertici tra glBegin e glEnd) sono vector. I vertici sono dati in spazio di coordinate di modellazione.
   Le primitive vector subiscono una serie di trasformazioni e alla fine vengono tradotte in formato vector per essere disegnate.
   L'accuratezza di definizione delle primitive vector e' virtualmente infinita (limite la precisione floating point di macchina). L'accuratezza di definizione dell'immagine raster che viene fuori dipende dalla dimensione della viewport (piu' grande = piu' accurata).

   OpenGL ha anche primitive raster.
   Le primitive raster sono matrici che vengono disegnate sulla finestra di output cosi' come sono (un elemento della matrice = un pixel) senza sottostare alla serie trasformazioni in cui incorrono le primitive vector.
   L'accuratezza di definizione e' fissata, limitata dalle dimensioni della matrice (numero di righe e colonne).

   Classificazione

   A seconda del valore contenuto nella matrice per ogni pixel, le primitive raster si differenziano in bitmap e pixmap.

   Bitmap

   Il valore memorizzato per ogni pixel e' binario (1 bit):

   • 1 = il pixel viene colorato con il colore corrente
   • 0 = il pixel viene lasciato invariato

   Esempi di bitmap sono quelle per le font dei caratteri.

   Pixmap

   Il valore memorizzato per ogni pixel e' un colore, che puo' essere specificato in vari modi:

   • GL_LUMINANCE = un singolo valore inteso come tono di grigio
   • GL_RGB = una terna di valori RGB (red, green, blue)
   • GL_LUMINANCE_ALPHA = una coppia di valori che rappresentano tono di grigio e trasparenza (alpha)
   • GL_RGBA = una quadrupla di valori RGBA (red, green, blue, alpha) dove alpha = trasparenza
   • altri...
   Ciascun valore pu' essere espresso mediante vari tipi numerici:
   • GL_UNSIGNED_BYTE o GL_BYTE = intero a 8 bit
   • GL_UNSIGNED_SHORT o GL_SHORT = intero a 16 bit
   • GL_UNSIGNED_INT o GL_INT = intero a 32 bit
   • GL_FLOAT = numero reale
   Un numero maggiore di bit allarga la gamma di colori. Es: con 8 bit posso avere 256 valori distinti, con 16 posso averne 65536 ecc.

   Memorizzazione

   E' compito del programmatore memorizzare la bitmap/pixmap in una struttura dati opportuna che OpenGL possa "capire".

   La bitmap o pixmap deve essere memorizzata in un array unidimensionale dove:

   • i singoli elementi dell'array contengono i valori per i pixel
   • la sequenza degli elementi nell'array corrisponde ad una visita per righe della matrice

     Esempio: matrice 5 righe e 3 colonne

     +---+---+---+---+---+
     | 0 | 1 | 2 | 3 | 4 |
     +---+---+---+---+---+
     | 5 | 6 | 7 | 8 | 9 |
     +---+---+---+---+---+
     | 10| 11| 12| 13| 14|
     +---+---+---+---+---+
     

     diventa array di 15 elementi in fila

     +---+---+---+---+---+---+---+--
     | 0 | 1 | 2 | 3 | 4 | 5 | 6 | ....
     +---+---+---+---+---+---+---+--
     

     L'elemento di posto (i,j) nella matrice si trova alla posizione i+w*j nell'array dove w e' il numero di colorre (larghezza).

   Consideriamo per esempio una pixmap con valori RGB:

   • Struttura dati per il singolo pixel

     struct OnePixel
     {  unsigned int r, g, b;  };
     

     Struttura dati per pixmap di dimensioni larga w pixel ed alta h pixel

        struct OnePixel * pixels;
     

     dove pixels e' un array dinamico da allocare a dimensione w*h e poi riempire con i valori.

   Disegno di primitive raster

   Il disegno di una primitiva raster e' influenzato da due variabili di stato OpenGL:

   • raster position = il punto di aggancio dove disegnare una primitiva raster.
     Il punto di aggancio e' dato in coordinate di modellazione cioe' lo stesso sistema di coordinate in cui sono dati i vertici delle primitive vector. Come per i vertici, le coordinate della raster position sono soggette a tutta la catena di trasformazioni.
     Si assegna con la funzione glRasterPos che esiste in varie versioni, come glVertex.

   • pixel zoom = i fattori di scala (sx,sy) con cui disegnare le primitive raster.
     Si assegna con la funzione glPixelZoom(float sx, float sy).
     Con fattori (1,1) un elemento della bitmap/pixmap diventa un pixel su schermo, con fattori (2,2) un elemento della bitmap/pixmap diventa 2x2 pixel su schermo ecc. Fattori negativi capovolgono l'immagine, fattori non interi causano approssimazione.
     Il punto di aggancio resta invariato (e' sempre la raster position corrente).

   In genere prima di disegnare primitive raster e' necessario chiamare

   • glStorei(GLPACK_ALIGNMENT,1);
   per impedire ad OpenGL di arrotondare sempre a 4 byte (default) la lunghezza delle righe della matrice in cui e' contenuta la bitmap/pixmap.

   Disegno, e non solo, di pixmap

   E' possibile

   • leggere una pixmap (copiarla da frame buffer a memoria del programma)
   • disegnare una pixmap (copiarla da memoria del programma a frame buffer)
   • "ridisegnare" una pixmap (copiarla da un'area del frame buffer ad un'altra senza passare da memoria del programma)

   Per leggere: glReadPixels(x, y, w, h, formato, tipo, pixels)

   • x,y = punto di aggancio dell'area di frame buffer da leggere
   • w,h = larghezza ed altezza dell'area
   • formato = che informazioni memorizzare per ogni pixel letto (GL_RGB, GL_RGBA...)
   • tipo = che tipo numerico usare per memorizzarle (GL_UNSIGNED_BYTE, GL_UNSIGNED_INT,...)
   • pixels = l'array dove scrivere le informazioni lette (deve essere abbastanza grande)

   Per disegnare: glDrawPixels(w, h, formato, tipo, pixels)

   • il punto di aggancio e' la raster position corrente
   • gli altri parametri sono come in glReadPixels solo che le informazioni sono gia' memorizzate (non da memorizzare) e l'array viene letto (non scritto)

   Per copiare: glCopyPixels(x, y, w, h, GL_COLOR)

   • i primi quattro parametri sono come in glReadPixels
   • l'ultimo specifica in quale buffer eseguire la copia (per noi sempre il color buffer)

   Disegno di bitmap

   Le bitmap sono state progettate allo scopo principale di disegnare font di caratteri. Percio' il disegno di una bitmap prevede:

   • possibilita' di posizionare il punto di aggancio della bitmap un po' spostato rispetto alla raster position corrente, per es. se il punto di aggancio e' sulla linea del testo, alcuni caratteri sporgono inferiormente (f,g,p,q)
   • possibilita' di spostare automaticamente la raster position dopo aver disegnato la bitmap (passare direttamente alla posizione dove andra' disegnato prossimo carattere)

   glBitmap(w, h, x0, y0, x1, y1, pixels)

   • w,h = larghezza ed altezza della matrice
   • x0,y0 = valori che, sottratti dalla posizione raster corrente, danno il punto di aggancio per disegnare la bitmap
   • x1,y1 = valori che, sommati alla posizione raster corrente, danno la nuova posizione raster dopo aver disegnato
   • pixels = l'array contenente la bitmap

   Per scrivere con glBitmap uno dovrebbe prima definire bitmap per tutte le lettere dell'alfabeto. Glut offre bitmap gia' definite per alcune font e una funzione piu' comoda per disegnare caratteri.

   glutBitmapCharacter(font, carattere);

   • font = una costante simbolica di Glut corrispondente a tipo e dimensione, es: GLUT_BITMAP_8_BY_13
   • carattere = il carattere da scrivere
   Il carattere viene disegnato trattando automaticamente il caso di carattere che sporge in basso rispetto alla raster position, e spostando gia' la raster position sulla posizione per il prossimo carattere.

   Esempio di funzione che scrive una stringa a partire dalla posizione raster corrente:

   void displayString(char * s)
   {
     int i;
     for (i=0; s[i]!='\0'; i++)
       glutBitmapCharacter(GLUT_BITMAP_8_BY_13, s[i]);
   }