FREQUENTLY ASKED QUESTIONS
==========================
I LABORATORIO DI GRAFICA INTERATTIVA  -  31 ottobre 2002
====================================

1) Le costanti OpenGL (tipo GL_POINTS, GL_LINES...)
sono interi, quindi se si vuole mettere in una variabile il
tipo di primitiva corrente, questo va dichiarato come int.

2) E' diverso GL_POINTS o GL_LINES (tipi di primitive da mettere
in glBegin) e GL_POINT o GL_LINE (tipi di modalita' di disegno
per i poligoni da mettere in glPolygonMode).
Se si mette quello sbagliato (es. GL_LINE in glBegin) il codice
viene compilato senza protestare ma in esecuzione non succede
quello che si vorrebbe.

3) Le componenti Red Green Blue di colore sono numeri tra 0 e 1.
Numeri >1 vengono troncati a 1. Quindi glColor3f(50.0,100.0,200.0)
e glColor3f(1.0,1.0,1.0) danno lo stesso risultato!

4) Il primo parametro della funzione da usare come Keyboard
callback di Glut non e' char ma unsigned char, se si mette solo
char non compila (era un errore sulle note, adesso corretto).

5) Le configurazioni di vertici non adatte per certe primitive
corrispondono a casi in cui vengono figure intrecciate. Es.
con GL_QUAD_STRIP e la configurazione di vertici data (vertici
in cerchio) venivano dei quadrilateri intrecciati, mentre OpenGL
tratta correttamente solo poligoni semplici e convessi. 

6) Per impostare il point size premendo prima il tasto P e poi
un numero: Bisogna tenere in una variabile l'ultimo carattere
premuto. Se il carattere corrente e' una cifra in [1..9] e
l'ultimo era P allora si assegna il point size.

7) I point size gestiti da OpenGL sono una gamma limitata. Valori
piu' grandi del massimo consentito vengono troncati. Ne segue che
accettare point size espressi da numeri di una sola cifra e'
ragionevole.

8) Polygon stipple. Innanzi tutto (analogo per line stipple) occorre 
abilitare glEnable(GL_POLYGON_STIPPLE); poi assegnare il pattern
con glPolygonStipple(pattern); dove pattern e' pensato come una
matrice 32x32 di bit, ma implementato come un array di 128 byte
(tipo C unsigned char): unsigned char pattern[128];
infatti 128x8 = 32x32 bit.
Il contenuto di pattern va assegnato un byte alla volta tenendo
presente che quelli sono 8 pixel.
Per esempio il seguente codice costruisce una trama a righe 
verticali:
 for (i=0; i<128; i++) 
 {  pattern[i] = 0x99; /* binario 10011001 */  }
E il seguente una trama a righe diagonali:
 for (j=0; j<32; j++)
 for (i=0; i<4; i++) /* 4 byte = 32 bit */
 {  switch (j%4)
    {  case 0: pattern[j*4+i] = 0x99; /* 10011001 */ break;
       case 1: pattern[j*4+i] = 0xCC; /* 11001100 */ break;
       case 2: pattern[j*4+i] = 0x66; /* 01100110 */ break;
       case 3: pattern[j*4+i] = 0x33; /* 00110011 */ break;
    }
 }