Newsgroup: it.comp.programmare.win32
Titolo: il mio problema con le OpenGL

Ciao ragazzi,
Io ho un problema che mi perseguita gia' da molto tempo e spero che 
qualcuno di voi mi possa aiutare una volta per tutte. Fino ad ora non 
sono riuscito a trovare qualcuno che mi aiutasse forse a causa 
dell'implementazione non usuale del nostro engine.
Premetto quindi che noi usiamo coordinate normalizzate per le dimensioni 
x,y della viewport in maniera tale da rendere il processo di rendering 
indipendente dalla grandezza della viewport reale finale e facciamo 
normalizzare la z (w-buffering) direttamente dalla matrice di proiezione 
grazie alle coordinate omogenee.
Prima di esporre il mio problema vorrei pero' che mi chiariste due dubbi 
:
1) OpenGL lavora di default con coordinate normalizzate? Se no come 
faccio a dirgli che gli sto passando coordinate normalizzate e che quindi 
io voglia alla fine della proiezione avere i risultati moltiplicati per 
la grandezza della viewport passati per glviewport (che tra l'altro e' 
una cosa che gia' fa e che quindi ho sempre dato per scontato).
2) OpenGL usa operazioni destrose sulle matrici? Ovvero pone i valori 
x,y,z,w in una colonna a destra della matrice da usare per l'operazione?
3) io uso glloadmatrixf (o qualcosa del genere) per caricare una matrice 
di proiezione nostra...glFrustum non riesco a farla funzionare...non 
riesco a capire che valori mettere e sia che metta valori normalizzati 
che no sul video non si vede una mazza.
Ecco il mio problema: 
Come ho gia' detto utilizzo OpenGL ed il seguente codice per impostare la 
matrice
di proiezione :
	glMatrixMode(GL_PROJECTION);
	projection[0]  = viewport->w;
	projection[5]  = viewport->h;
	projection[10] = viewport->Q;
	projection[14] = viewport->QZn;
	glLoadMatrixf(projection);
	glViewport(viewport->x, (480 - viewport->height) - viewport->y, 
viewport->width, viewport->height);
	glDepthRange(viewport->hither, viewport->yon); (a proposito 
glDepthRange permette di ricevere anche 0 come primo parametro?)
dove w = alla viewing distance (dal calcolo cot(FoVw/2) = viewing 
distance * 2 / width (= 2 ricordiamoci della viewport normalizzata)
h = w (stesso procedimento di sopra)
q = zmax / (zmax * zmin)
qzn = q * zmin.
Per chi lo ha gia' capito in pratica si tratta della matrice di 
proiezione spiegate nel tutor delle d3d tenendo conto che lavoro su una 
viewport normalizzata di dimensione 2 x 2 (in pratica i valori reali 
della viewport vanno da -1 a 1 sia in orizzontale che in verticale 
trovando il centro alla posizione 0,0).
hither = 0.1 e yon = 15.
Premettendo che tengo scontato che le Opengl moltiplichino implicitamente 
il risultato della proiezione per i valori reali della viewport settati 
in glViewport (ma non ho capito se questo e' vero e come procedere nel 
caso in cui non si voglia che le opengl moltiplichino il valore 
risultante dalla proiezione di x e y per la grandezza della viewport 
settata), e che non ho capito se glDepthRange come Zmin vuole 0 o la zmin 
effettivamente utilizzata, la proiezione mi risulta essere funzionante, 
ma imprecisa!
A questo ho dato un'occhiata alla funzione GLfrustum..peggio che andar di 
notte..non ho capito che parametri passare e in che formato. Dato che con 
qualsiasi usi come parametri sullo schermo non vedo nulla ho provato ad 
utilizzare direttamente la matrice delle OpenGL spiegata nell'MSDN :
-
| 2 * znear 				-
| ------------    0   A     0	|
|right - left				|
| 					|
|    0       2 * znear		|
|            ___________ B    0	|	
|            top - bottom		|
|    0          0        C   D	|
|    0          0       -1    1	|
-					-
dove		right + left  		top + bottom
      	A=	____________     	B=	---------------
    		right - left    		top - bottom 
	- far + near     	- 2 far * near
C=    	-------------      D=  ________________
      	far - near           far - near
tenendo conto che la viewport e' normalizzata, nella matrice l'elemento 
1,1 diverrebbe
2 * znear (o 2 * viewdistance), stesso dicasi per la 2,2. Mentre:
A = 0.
B = 0.
Quello che sembra differente e' invece il calcolo di Z e di W 
(naturalmente tengo presente che secondo me e' scontata la divisione per 
w implicita, senza contare che mi e' venuto il dubbio che le operazioni 
fossero destrose visto che l'elemento 4,3 e' messo a -1)...
eppure nemmeno con questa matrice cavo un ragno dal buco..pleeease help 
me!!
Concludo dicendo che le proiezioni funzionano solo con la matrice delle 
D3D ma che non sono precise..cio' l'ho scoperto facendo un esempio simile 
:
ho una sfera di raggio 2 posizionata alla posizione 0,0,0 è un FOV di 
90gradi. nella costruzione del frustum con il FOV di 90 gradi i limiti in 
x e y corrispondono esattamente al valore attuale in z.
quindi, se sposto la sfera alle coordinate 0,0,2 per scomparire 
completamente dallo schermo bastarebbe piazzarla alla posizione 4,0,2. 
Invece, purtroppo, ancora vedo un pezzettino di sfera!!!!!!
E' sto impazzendo dietro a quest'errore! Con glFrustum non sono riuscito 
a vedere nulla e con la matrice esplicita delle OGL peggio che mai!!! che 
FACCIO!?!??!??!?!?!??!
-- 
http://gpi.eden.it/
 il primo sito ITALIANO dedicato allo sviluppo di 
videogiochi.

