OpenGL, pan e zoom

[Given]

Salve ragazzi, dovrei implementare lo zoom e il pan della camera in una scena 3d tramite mouse. Il problema nel pan sorge quando l'eye presenta componenti non nulle su x e y e quando l'up è diverso da 0 1 0. Nello zoom invece faccio così:

void motionfunc(int x, int y){

const int dx = x - oldX;
const int dy = y - oldY;

if ( mouseLeft ){
if ( Shift ){
eyex -= eyex/100*dx;
eyey -= eyey/100*dx;
eyez -= eyez/100*dx;
}
}
oldX = x;
oldY = y;
}

Il problema è che quando lo zoom è molto ravicinato la scena fa una strana rotzione. Non so se mi sono spiegato bene, si accettano suggerimenti e, se li avete, anche codici in c

[Given]

Nessuno? Avanti, chi mi sarà di aiuto determinerà chi sono i migliori tra ingegneri informatici e informatici

[Mithrandir]

ehm...sparo a caso, senza aver letto con troppa attenzione.
problemi d'approssimazione?

[Given]

Mithrandir81 ha scritto gio, 13 aprile 2006 alle 13:09
ehm...sparo a caso, senza aver letto con troppa attenzione.
problemi d'approssimazione?

In che senso?

[vaitrafra]

Given ha scritto mer, 12 aprile 2006 alle 22:41
Salve ragazzi, dovrei implementare lo zoom e il pan della camera in una scena 3d tramite mouse. Il problema nel pan sorge quando l'eye presenta componenti non nulle su x e y e quando l'up è diverso da 0 1 0. Nello zoom invece faccio così:

void motionfunc(int x, int y){

const int dx = x - oldX;
const int dy = y - oldY;

if ( mouseLeft ){
if ( Shift ){
eyex -= eyex/100*dx;
eyey -= eyey/100*dx;
eyez -= eyez/100*dx;
}
}
oldX = x;
oldY = y;
}

Il problema è che quando lo zoom è molto ravicinato la scena fa una strana rotzione. Non so se mi sono spiegato bene, si accettano suggerimenti e, se li avete, anche codici in c

Premetto che io di opengl non ne so niente, men che meno di programmazione di librerie 3d.

Però mi viene da pensare che forse dovresti calcolare la quantità di pan in relazione alla distanza dal fuoco della telecamera.

poi magari lo fai già, io sinceramente non ho capito cosa sia eyex,y,x

[Given]

Aragorn ha scritto gio, 13 aprile 2006 alle 14:37

Given ha scritto mer, 12 aprile 2006 alle 22:41
Salve ragazzi, dovrei implementare lo zoom e il pan della camera in una scena 3d tramite mouse. Il problema nel pan sorge quando l'eye presenta componenti non nulle su x e y e quando l'up è diverso da 0 1 0. Nello zoom invece faccio così:

void motionfunc(int x, int y){

const int dx = x - oldX;

if ( mouseLeft ){
if ( Shift ){
eyex -= eyex/100*dx;
eyey -= eyey/100*dx;
eyez -= eyez/100*dx;
}
}
oldX = x;
}

Il problema è che quando lo zoom è molto ravicinato la scena fa una strana rotzione. Non so se mi sono spiegato bene, si accettano suggerimenti e, se li avete, anche codici in c

Premetto che io di opengl non ne so niente, men che meno di programmazione di librerie 3d.

Però mi viene da pensare che forse dovresti calcolare la quantità di pan in relazione alla distanza dal fuoco della telecamera.

poi magari lo fai già, io sinceramente non ho capito cosa sia eyex,y,x

La x e y indicano la posizione attuale del mouse, facendo la differenza con oldX e oldy ottengo lo spostamento effettuato lugo gli assi. Eyex, eyey ed eyez indicano la posizione dell'occhio, cioè dell'osservatore

[Given]

Vi posto il testo originale per maggior chiarezza:

Zoomare interattivamente col mouse, tenendo premuto il tasto shift (drag verso destra lungo x: zoom in; drag verso sinistra lungo x; zoom out. Il drag lungo l’asse y non ha effetto)

Pan della camera col mouse, tenendo premuto il tasto CTRL (sia Eye che View devono essere traslati di un vettore parallelo al viewing plane e le cui componenti, nel viewing plane, sono date dalle quantità di drag lungo x e y)

[wedra]

non ho letto i codce, ma nello zoom il problema dela rotazione potrebbe derivare dal "gimbal-lock" (lo conosco solo in inglese, il nome )però potrei dire una grossa vaccata

Comunque, dai una googlata al gimbal lock

[Cherno]

Forse dovresti anche postare il codice di come gestisci la camera...sia perspective che worldview.
Così è difficile aiutarti

[Given]

Non so cosa vi possa servire esattamente, per questo vi metto un po' di funzioni:

void reshape(int w, int h){

int i, j;

glViewport(0,0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 200.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

void display(void){

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

//Le componenti della camera vengono lette da file
gluLookAt(eyex, eyey, eyez, viewx, viewy, viewz, upx, upy, upz);

glEnable( GL_LIGHTING );

disegnaScena(GL_RENDER);

glFlush();
glutSwapBuffers();

}

[Cherno]

ah ok
usi le glut...ci darò un occhio domani che ora debbo scappà!


edit: comunque succede la rotazione strana perchè quando fai lo zoom ti ritrovi che il viewZ diventa minore dell'eyeZ e quindi la camera si ribalta.

Cerca su siti come NeHe come gestire la camera e vedrai che risolverai i tuoi problemi

[Given]

Cherno ha scritto gio, 13 aprile 2006 alle 21:17

edit: comunque succede la rotazione strana perchè quando fai lo zoom ti ritrovi che il viewZ diventa minore dell'eyeZ e quindi la camera si ribalta.

E' vero, avevo considerato il mio sistema centrato nell'origine e quindi con le componenti view tutte a zero. Ho risolto mettendo questo:

eyex -= (eyex-viewx)/100*dx;
eyey -= (eyey-viewy)/100*dx;
eyez -= (eyez-viewz)/100*dx;

In tal modo si sposta perfettamente lungo il vettore che va da eye a view. Ora mi manca da sistemare il pan

[Cherno]

che problema hai con il pan?

[Given]

Lo so gestire solo nel caso ho ad esempio Eye 0 0 120 e Up 0 1 0. Con le altre combinazioni naturalmente si muove in diagonale o cose simili

if ( mouseLeft ){
if ( Control ){

viewx-=dx;
eyex-=dx;
viewy+=dy;
eyey+=dy;

}
}

Per ovviare a ciò avevo pensato a questo:

if ( upx != 0.0 ){
viewx+=dy;
eyex+=dy;
}

if ( upy != 0.0 ){
viewy+=dy;
eyey+=dy;
}

if ( upz != 0.0 ){

viewz+=dy;
eyez+=dy;
}

Però in questo modo riesco ad ottenere solo lo spostamento alto-basso

[Cherno]

Hai dato un occhio ai tutorial di nehe?
La gestione della camera non è così banale.

qui: http://nehe.gamedev.net/lesson.asp?index =02
L'ultimo tutorial penso faccia al caso tuo
Puoi studiare come fa a gestire la camera.

[Given]

Ho controllato, purtroppo non sembra servire alla mia causa

[Edward Gein]

Devi trovare il vettore normale all'up e la direzione dello "sguardo" (vettore view - vettore eye), tramite il prodotto vettoriale. Es., in vettori:

d = view - eye
asse = d ^ up

Dove ^ simboleggia appunto il prodotto vettoriale.

Devi effettuare lo spostamento lungo quel vettore.
Il pan in verticale, in caso ti servisse, è banale: ti sposti lungo il vettore up.

[Given]

Edward Gein ha scritto sab, 15 aprile 2006 alle 21:34
Devi trovare il vettore normale all'up e la direzione dello "sguardo" (vettore view - vettore eye), tramite il prodotto vettoriale. Es., in vettori:

d = view - eye
asse = d ^ up

Dove ^ simboleggia appunto il prodotto vettoriale.

Devi effettuare lo spostamento lungo quel vettore.
Il pan in verticale, in caso ti servisse, è banale: ti sposti lungo il vettore up.

E' vero E pensare che per implemetare la trackball effettivamente mi calcolavo esattamente gli stessi vettori. Grazie

[Given]

Visto che mi siete stati di aiuto, vi chiedo un'altra cosa. Devo posizionare la mia telecamera in modo che la mia scena 3d sia al centro della finestra. Per fare ciò mi calcolo la bounding sphere, e mi posiziono il view nel suo centro e l'eye ad una distanza uguale al raggio della mia sfera per il sin( fov/2 ), in cui fov è l'angolo che passo al gluPerspective. Facendo in tal modo posiziono la mia scena correttamente in base all'altezza della mia finestra.
Quello che non riesco a fare è invece posizionare la scena rispetto alla lunghezza

[Edward Gein]

Given ha scritto dom, 16 aprile 2006 alle 17:05
Visto che mi siete stati di aiuto, vi chiedo un'altra cosa. Devo posizionare la mia telecamera in modo che la mia scena 3d sia al centro della finestra. Per fare ciò mi calcolo la bounding sphere, e mi posiziono il view nel suo centro e l'eye ad una distanza uguale al raggio della mia sfera per il sin( fov/2 ), in cui fov è l'angolo che passo al gluPerspective. Facendo in tal modo posiziono la mia scena correttamente in base all'altezza della mia finestra.
Quello che non riesco a fare è invece posizionare la scena rispetto alla lunghezza

Intendi che la scena compare al centro rispetto all'altezza della finestra, ma non alla larghezza? Chessò, un po' più a destra o un po' più a sinistra?

[Given]

Edward Gein ha scritto dom, 16 aprile 2006 alle 22:58

Given ha scritto dom, 16 aprile 2006 alle 17:05
Visto che mi siete stati di aiuto, vi chiedo un'altra cosa. Devo posizionare la mia telecamera in modo che la mia scena 3d sia al centro della finestra. Per fare ciò mi calcolo la bounding sphere, e mi posiziono il view nel suo centro e l'eye ad una distanza uguale al raggio della mia sfera per il sin( fov/2 ), in cui fov è l'angolo che passo al gluPerspective. Facendo in tal modo posiziono la mia scena correttamente in base all'altezza della mia finestra.
Quello che non riesco a fare è invece posizionare la scena rispetto alla lunghezza

Intendi che la scena compare al centro rispetto all'altezza della finestra, ma non alla larghezza? Chessò, un po' più a destra o un po' più a sinistra?

Nel senso che nel caso in cui la mia finestra abbia una larghezza minore dell'altezza, allora vorrei che la mia scena si vedesse totalmente. Ti mostro due foto d'esempio:

640x480: mi va bene così, la scena si vede tutta


480x640: il problema che voglio risolvere, la scena non si vede tutta, la mia sfera si dovrebbe vedere più piccola in modo da entrarci in larghezza


Naturalmente io non so a priori la dimensione della mia finestra

[Cherno]

Ma ti fa quel difetto quando ridimensioni la finestra o quando parte subito l'applicazione con già la risoluzione settata a 480*640?

Magari sbagli qualcosa nell'inizializzazione del viewport.
La dimensione della finestra devi sapere per calcolarlo correttamente.

[Given]

Quelle sono le finestre appena partono. Naturalmente la dimensione della finestra la conosco perchè me la leggo da un file ma non posso deciderla io, altrimenti mi mettevo nel caso altezza>larghezza e aggiravo il problema

[Cherno]

Ok, quindi tu le leggi..

Senti una cosa, ma tu puoi usare una visuale in prospettiva oppure devi usare per forza una visuale ortografica?

Se puoi usare una vista in prospettiva non usare la glFrustum ma usa la gluPerspective

La sintassi è gluPerspective(FOV,aspect_ratio,near,far )

Quindi ti calcoli l'aspect ratio: aspect_ratio=larghezzaFinestra/altezzaFi nestra;
stabilisci il fov e bon...ti fai i calcoli solo sul bounding sphere e posizioni la camera.

edit: a quanto pare usi già la gluPerspective....sicuro che calcoli bene l'aspect ratio che gli passi?
Perchè dalla foto che hai postato sembra che la scena sia proiettata su un piano di 640x480 punti nonostante la finestra abbia un'altra risoluzione

[Given]

Faccio così:

void reshape(int w, int h){

glViewport(0,0, (GLsizei) w, (GLsizei) h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();

gluPerspective( 45.0, ((GLfloat)w/h), 1.0, 300.0 );
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}

Non vedo come possa essere sbagliato
Non è che deve essere richiamata anche in qualche altro punto?