OpenGl

[Luc@s]

Dove trovo guide e tutorial sulle OpenGl, possibilmente in it?????


Tnk

[maxithron]

http://www.multiplayer.it/itaprogaming/docs&tuts/opengl/opengl.asp

[verloc]

http://nehe.gamedev.net/

in particolare scaricati questo .chm

http://nehe.gamedev.net/files/resources/nehe_opengl_chm.zip

Ovviamente devi studiare...non è roba che si impara in 5 minuti.

per l'italiano ...andiamo male :)

[EDIT]
Cacchio non mi ero accorto che sopra ti avevano dato il link a quello in italiano :eek:

[Argosoft]

wow! :sbavvv:

bellissima guida!!! un Grazie a Verloc e a Maxithron!!!!!!!!!!

[maxithron]

Originariamente inviato da verloc

[EDIT]
Cacchio non mi ero accorto che sopra ti avevano dato il link a quello in italiano :eek:


:asd: :asd:

[gokan]

Ciao ragazzi, ho rispolverato il tread per discutere un pò di OpenGl :)
Ho iniziato da qualche tempo il corso di Sist. Operativi e finalmente ho intrapreso lo studio del C.
Girovagando per la rete ho trovato i famosi tutorials di Nehe in italiano ed avendo visto che lo stesso autore degli articoli pensa che anche un novello di C/C++ può seguire il suo corso, ho pensato di perderci qualche oretta la sera in maniera hobbistica :)
Ho preso il primo tutorials ed ho dato una buona lettura, devo dire che diverse cose le ho seguite bene, altre un pò meno.
Ad esempio ho non poche difficoltà con queste funzioni:
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Prototipo di funzione di WndProc
int WINAPI WinMain( HINSTANCE hInstance, // Istanza
HINSTANCE hPrevInstance, // Istanza precedente
LPSTR lpCmdLine, // Parametri della linea di comando
int nCmdShow)

Da quanto ho capito, questo sono riferimenti puri alle win32.
Un'altra cosa, questo sorgenteè scritto in C++ non C,vero?

[cionci]

WinMain è la funzione corrispondente al main nei programmi per Windows (il cosidetto entry point)...

WndProc è la funzione che processa i messaggi ricevuti da una certa finestra...

Chiaramente è tutta roba Windows...

[Elysium]

se posso consigliare...non in it ma ottima.

http://www.opengl.org/documentation/red_book_1.0/

e

http://www.opengl.org/documentation/blue_book_1.0/

Buon divertimento :)

[P4ge83]

Queste sono dispense che ci hanno dato per l'università...per iniziare vanno + che bene

http://www3.csr.unibo.it/~lazzaro/Metodi%20Numerici%20per%20la%20Grafica%20I/

[gokan]

Grazie ad entrambi per i link :)
Trovo le guide di Nehe abbordabili, come già detto mi sono trovato più spaesato nelle parti di codice dove si fa accesso diretto alle API win32 di windows.
Grazie

[anx721]

Prova ad usare la libreria glut che mette a disposizione di chi programma in opengl delle funzioni sempli semplici con cui costruire una finestra windows, gestire gli eventi del mouse e della tastiera, costruire un menu contestuale, senza usare le api di windows. Bastano poche righe per mettere su una finestra senza preoccuparti di nulla. Se vuoi solo studiare opengl e bene usarla, se poi vuoi imparare anche le api di win è un altro discorso.

Esempio, definisci un main cosi:

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(disegna);
glutReshapeFunc(aggiorna);
glutKeyboardFunc(tastiera);
glutIdleFunc(animazione);
glutMainLoop();
return 0;
}


dove disegna è la funzione che effettua il disegno; aggirna è la funzione da invocare se l'utente ridimensiona la finestra, tastiera è la funzione da invocare se l'utente preme un tasto, ecc ecc... In questo modo bastano le tre righe:

glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);

per creare la finestra.

[gokan]

Grazie Anx721, mi hai già aiutato in passato (ti ricordi le grammatiche?) :) Grazie per l'esempio chiarificatore, oltre al fattore semplicità, usando Glut, si sfrutta la multipiattaforma che può essere utile in tutti i casi...Dimmi un'altra cosa, per curiosità, usando Glut, al posto delle dirette chiamate alle api windows, si ottengono delle prestazioni inferiori?

[anx721]

Non penso che si diminuiscano le prestazioni, anche perche penso che le glut siano implementate con le api stesse. Servono propio a fornire al programmatore un'interfaccia piu semplice per costruire una finiestra. Oltre queste agevolazioni, offrono anche altre funzioni utili.

[gokan]

Sto facendo qualche prova, mettendo assieme il tutorial di Nehe, le guide suggerite p4ge83 ed il reedbook. Voglio aprire una finestra e disegnare un triangolo ed un quadrato leggermente spostato a destra.
# include <windows.h>
# include <stdlib.h>
# include <gl/glut.h>
# include <gl/gl.h>
# include <gl/glu.h>

void disegna (void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Pulisce lo schermo e il Depth Buffer

glLoadIdentity(); // Resetta la View
glBegin(GL_TRIANGLES); // Disegna usando i triangoli
glVertex3f( 0.0f, 0.2f, 0.0f); // Sopra
glVertex3f(-0.2f,-0.2f, 0.0f); // Sotto a sinistra
glVertex3f( 0.2f,-0.2f, 0.0f); // Sotto a destra
glEnd(); // Finito di disegnare il triangolo
glTranslatef(3.0f,0.0f,0.0f); // Si muove a destra di 3 Unità
glBegin(GL_QUADS); // Disegna un quadrato
glVertex3f(-0.5f, 0.5f, 0.0f); // Sopra a sinistra
glVertex3f( 0.5f, 0.5f, 0.0f); // Sopra a destra
glVertex3f( 0.5f,-0.5f, 0.0f); // Sotto a destra
glVertex3f(-0.5f,-0.5f, 0.0f); // Sotto a sinistra
glEnd();

glFlush();

}

void myinit (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity ( ); // Resetta la Modelview Matrix corrente
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

}

void main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE| GLUT_RGB);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,150);
glutCreateWindow("Primo tentativo");
glutDisplayFunc(disegna);
myinit();
glutMainLoop();
}
Purtroppo mi viene disegnato solo il triangolo e per di più la funzione glTranslatef è come se non funzionasse, mi date qualche chiarimento?

[anx721]

Il problema è che il quadrato lo trasli troppo e va a finirie fuori dalla finestra...

prova a sostituire

glTranslatef(3.0f,0.0f,0.0f);

con

glTranslatef(0.75f,0.0f,0.0f);

Ci vuole un po di dimistichezza rendersi conto delle dimensioni e del sistema di coordinate.

[gokan]

Hai ragione :)
Grazie

[gokan]

Devo dire che mi sta divertendo parecchio l'uso dell'OpenGL accopiato con le Glut, operazioni come mettere il fullscreen od interagire con tastiera e mouse sono molto semplici :)
Adesso ho un problema, volevo fare roteare attorno all'asse Y un triangolo ed attorno all'asse X un quadrato:

void disegna(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Pulisce lo schermo e il Depth Buffer
glLoadIdentity(); // Resetta la Modelview Matrix corrente
glTranslatef(-1.5f,0.0f,-6.0f); // Si muove a Sinistra di 1.5 Unità e Dentro lo schermo di 6.0 Unità
glRotatef(rtri,0.0f,1.0f,0.0f); // Ruota il triangolo sull'asse Y ( NUOVA )
glBegin(GL_TRIANGLES); // Inizia a disegnare il triangolo
glColor3f(1.0f,0.0f,0.0f);
glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(-1.0f,-1.0f, 0.0f);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f( 1.0f,-1.0f, 0.0f);
glEnd(); // Finisce di disegnare il triangolo
glLoadIdentity(); // Resetta la Modelview Matrix corrente
glTranslatef(1.5f,0.0f,-6.0f); // Si muove a Destra di 1.5 Unità e Dentro lo schermo di 6.0 Unità
glRotatef(rquad,1.0f,0.0f,0.0f); // Ruota il quadrato sull'asse X ( NUOVA )
glColor3f(0.5f,0.5f,1.0f);
glBegin(GL_QUADS); // Disegna un quadrato
glVertex3f(-1.0f, 1.0f, 0.0f);
glVertex3f( 1.0f, 1.0f, 0.0f);
glVertex3f( 1.0f,-1.0f, 0.0f);
glVertex3f(-1.0f,-1.0f, 0.0f);
glEnd(); // Finisce di disegnare il quadrato
rtri+=0.2f; // Incrementa la variabile di rotazione per il triangolo ( NUOVA )
rquad-=0.15f;
glFlush();
}
dove rtri, rquad sono di tipo Gfloat e servono per l'angolo di rotazione del triangolo e quadrato. Il problema è che le due figure non mi ruotano...Strano perchè questo è alla fin fine il codice ricopiato dell'esempio di Nehe. Io nel mio caso ho solo diminuito qualche valore...C'è qualche accortezza particolare nell'usare questa funzione glRotatef? Spero di non sbagliare qualcosa nelle altre parti del programma, altrimenti posto tutto il codice

[anx721]

Probabilmente il problema deriva da come sono realizzate le animazioni sul tutorial del Nehe, che costruisce le finestre a mano, e penso che riachiami in qualche modo la funzione di disegno. Un modo semplice e pulito di realizzare le animazioni è di incrementare le variabili che guidano l'animazione (come rtri) non nella funzione disegna, ma in un'altra funzione, che puoi ad esempio chiamare animazione. L'importante è che dici che la funzione animazione è quella che deve esser continuamente richiamata per realizzre l'animazione appunto, e lo fai con l'istruzione:

glutIdleFunc(animazione);

quindi animazione sarà qlcosa del tipo:

void animazione(){
rtri+=0.2f;
rquad-=0.15f;
}

e togli quelle istruzioni dalla funzione disegna.

Non so a cosa serva l'istruzione glFlush(), io pero le funzioni disegna le terminavo sempre con:

glutSwapBuffers ();

Ciao.

[gokan]

Grazie ancora per i tuoi suggerimenti.
La funzione glutIdleFunc(animazione); la devo chiamare all'interno della funzione disegna prima di glFlush vero?
Purtroppo non mi da i risultati sperati se la posiziono in quel posto.
Se invece la metto nel main, prima di chimare glutMainLoop , mi taglia a metà il triangolo :confused:

[anx721]

Va proprio nel main prima di glutMainLoop, come era indicato nel primo esempio che ti ho inviato. prova magari a postare il codice, ciao.

[gokan]

Vado con il codice allora:

# include <windows.h>
# include <stdlib.h>
# include <gl/glut.h>
# include <gl/gl.h>
# include <gl/glu.h>

GLfloat rtri; // Angolo per il triangolo ( NUOVA )
GLfloat rquad; // Angolo per il quadrato ( NUOVA )

void rotazione(void)
{
rtri+=0.2f;
rquad-=0.15f;
}
void disegna (void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();
glTranslatef(-0.5f,0.0f,-1.0f); // Muove a sinistra di 1.5 unità e dentro lo schermo di 1.0 unità
glRotatef(rtri,0.0f,1.0f,0.0f); // Ruota il triangolo sull'asse Y ( NUOVA )
glBegin(GL_TRIANGLES); // Disegna usando i triangoli
glColor3f(0.0,1.0,0.0);
glVertex3f( 0.0f, 0.4f, 0.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(-0.4f,-0.4f, 0.0f);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f( 0.4f,-0.4f, 0.0f);
glEnd(); // Finisce di disegnare il triangolo
glLoadIdentity(); // Resetta la Modelview Matrix corrente per ripristinare la situazione dopo la rotazione del triang.

glTranslatef(0.4f,0.0f,0.0f); // Muove a destra di 1 unità
glRotatef(rquad,0.5f,0.0f,0.0f); // Ruota il quadrato sull'asse X ( NUOVA )

glBegin(GL_QUADS); // Disegna un quadrato
glVertex3f(-0.4f, 0.4f, 0.0f); // Superiore sinistro
glVertex3f( 0.4f, 0.4f, 0.0f); // Superiore destro
glVertex3f( 0.4f,-0.4f, 0.0f); // Inferiore destro
glVertex3f(-0.4f,-0.4f, 0.0f); // Inferiore sinistro
glEnd(); // Finisce di disegnare il quadrato

glFlush();

}
void main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_SINGLE| GLUT_RGB);
glutInitWindowSize(800,600);
glutInitWindowPosition(100,150);
glutCreateWindow("Prove con OpenGL");
glutDisplayFunc(disegna);
glutIdleFunc(rotazione); //dovrebbe richiamare l'animazione
glutMainLoop();
}

Come ti ho già detto, il triangolo viene tagliato a metà, mentre il quadrato rimane immobile.
Grazie ancora

[anx721]

Allora, ci sono alcuni errori; innanzitutto mi sono scordato di dirti che ogni ramo di esecuzione della funzione indicata come argomento di glutIdleFunction (in questo caso rotazione), deve terminare con la chiamata glutPostRedisplay che invoca la funzione di disegno; inoltre devi usare il doppio buffering se no si vede male.

Inoltre per annullare traslazioni/rotazioni prima di disegnare il quadrato non si usa chiamare la loadIdentity; devi invece utilizzare le chiamate glPushMatrix() e glPopMatrix(). In pratica una qualsiasi trasformazione viene modellata attraverso una matrice; quando aggiungi una traformazione non si fa altro che moltiplicare la matrice corrente per quella che rappresenta la tua trasformazione. Allora se vuoi fare una rotazione per disegnare una figura e poi eliminare tale rotazione, devi memorizzarti la matrice corrente, creare una nuova matrice ottenuta moltiplicando la matrice corrente per la matrice che rappresenta la rotazione, disegnare la tua figura, e poi riprisinare la vechia matrice. Cio puo essere fatto automaticamente in quanto opengl mette a disposizione uno stack di matrici. Con glPushMatrix() si inserisce nello stack una nuova matrice identica a quella corrente; quindi fai le traformazioni che ti pare, quando non ti servono piu e vuoi ripristinare la situazione che c'era prima delle trasformazioni, basta fare: glPopMatrix che eleimina la matrice in cima allo stack cosi che quella precedente ritorna ad essere quella attiva. Questo è un meccanismo molto potente ed utilissimo nel caso di animazioni complesse di oggetti gerarchici.


Con queste modifiche il tutto funziona, tranne il fatto che vedrai una cosa strana sul triangolo mentre ruota. Ciò dipende che esiste un piano, oltre il quale gli oggetti non sono visibili; nel tuo caso mi sembra che tale piano coinceda col piano z = 0, cioè il piano verticale passante per l'origine. Mentre il triangolo ruota attorno all'asse y va per meta dietro questo piano, quindi riesci a vedere solo la meta che è davanti... C'è un'opportuna funzione che si puo invocare per stabilire la posizione di questi piani, ora non ricordo perche sono un po di mesi che non tocco opengl, comunque il codice aggiustato è :



# include <windows.h>
# include <stdlib.h>
# include <gl/glut.h>
# include <gl/gl.h>
# include <gl/glu.h>

GLfloat rtri = 0; // Angolo per il triangolo ( NUOVA )
GLfloat rquad = 0; // Angolo per il quadrato ( NUOVA )

void rotazione(void)
{
rtri+=0.1;

rquad-=0.5;
glutPostRedisplay();
}
void disegna (void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();


glPushMatrix();

glTranslatef(-0.5f,0.0f,-1.0f); // Muove a sinistra di 1.5 unità e dentro lo schermo di 1.0 unità
glRotatef(rtri,0.0f,1.0f,0.0f); // Ruota il triangolo sull'asse Y ( NUOVA )
glBegin(GL_TRIANGLES); // Disegna usando i triangoli
glColor3f(0.0,1.0,0.0);
glVertex3f( 0.0f, 0.4f, -0.0f);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(-0.4f,-0.4f, -0.0f);
glColor3f(0.0f,0.0f,1.0f);
glVertex3f( 0.4f,-0.4f, -0.0f);
glEnd(); // Finisce di disegnare il triangolo
//glLoadIdentity(); // Resetta la Modelview Matrix corrente per ripristinare la situazione dopo la rotazione del triang.
glPopMatrix();

glPushMatrix();
glTranslatef(0.4f,0.0f,0.0f); // Muove a destra di 1 unità
glRotatef(rquad,0.5f,0.0f,0.0f); // Ruota il quadrato sull'asse X ( NUOVA )

glBegin(GL_QUADS); // Disegna un quadrato
glVertex3f(-0.4f, 0.4f, 0.0f); // Superiore sinistro
glVertex3f( 0.4f, 0.4f, 0.0f); // Superiore destro
glVertex3f( 0.4f,-0.4f, 0.0f); // Inferiore destro
glVertex3f(-0.4f,-0.4f, 0.0f); // Inferiore sinistro
glEnd(); // Finisce di disegnare il quadrato
glPopMatrix();
glutSwapBuffers();
//glFlush();
}


int main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGB);
glutInitWindowSize(800,600);
glutInitWindowPosition(0, 0);
glutCreateWindow("Prove con OpenGL");
glutDisplayFunc(disegna);
glutIdleFunc(rotazione); //dovrebbe richiamare l'animazione

glutMainLoop();
return 0;
}




A titolo di esempio, nei miei programmi ho una funzione aggiorna de tipo:

void aggiorna (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective(65.0, (GLfloat) w/(GLfloat) h, 0.10, 100.0);
glMatrixMode(GL_MODELVIEW);
}

e quindi nel main:

glutReshapeFunc(aggiorna);

Attraverso la chiamata gluPerspective si possono impostare i piani di cui ti parlavo.

[marcus81]

Vedo che ti stai immergendo profondamente nel C:D

[gokan]

Esatto, faccio due cose buone cosi :sofico:
Ritorniamo al problema, la situazione si è un pò complicata, se non faccio uso della funzione glutIdleFunc(animazione); effettivamente la rotazione del triangolo rende male...
Ho provato allora ad applicarla, ottenendo una perfetta rotazione del triangolo (anche se ho dovuto aumentare un pò gluPerspective( 100.0 , (GLfloat) w/(GLfloat) h, 0.10, 100.0); per ottenere un punto di vista migliore). Purtroppo il quadrato è scomparso dalla finestra :confused:

Grazie :)

[anx721]

Allora, risolvi in questo modo: nella funzione disegna, subito dopo l'istruzione loadIdentity, usi l'istruzione gluLookAt() che prende tre parametri:

1: il punto di vista: cioè il punto in cui si trova lo spettarore che guarda;
2: il centro di proiezione, cioè il punto del piano in cui avviene la proezione della scena;
3: il vettore che indica qual è il verso del 'su e del giù'

Nel tu o caso prova ad aggiungere:


void disegna (void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();
gluLookAt ( 0.0, 0.0, 1.0,
0.0, 0.0, -1.0,
0.0, 1.0, 0.0);


In questa maniera ti posizioni nel punto 0,0,1 e il disegno sarà proiettato sul piano verticale che passa per z=-1. Se ad esempio utilizzi come primo argomento 0.0, 0.0, 20 ti posizioni sul punto 0 0 20, qundi vedra il disegno piu piccolo perche ti sei allontanato; l'importante è che il disegno si trovi tra i due punti dati come argomenti della gluLookAt, se no esce fuori dall'area visibile,

Ciao.

[anx721]

Per renderti meglio conto del funzionamenteo della gluLookAt, puoi usare una variabli che esprima la coordinata z dello spettatore e far variare tale coordinata alla pressione di un tasto della tastiera. per fare questo definisci una variabile globale zView:

GLfloat zView = 1.0

poi scrivi la gluLookAt in modo parametrico rispetto a zView:


gluLookAt ( 0.0, 0.0, zView,
0.0, 0.0, -1.0,
0.0, 1.0, 0.0);


quindi una funzione tastiera:


void tastiera(unsigned char key, int x, int y)
{
switch (key) {
case 'Z':
zView = zView + 0.2;
break;
case 'z':
zView = zView - 0.2;
break;
}
}



In questo modo premendo Z maiuscolo la coordinata z dello spettatore aumenta, ovvero il punto di vista si allontanta dalla scena e vedrai la scena rimpicciolirsi; se premi z minuscolo lo spettatore si vvicina sempre di piu alla scena; quando z diventea -1 (come al zeta del punto di proiezione) si ha l'effetto di girarsi a guardare la scena da dietro.

Per far funzionare il tutto bisogna dire a opegl che tastiera è lafunzione da richiamare quando si preme un tasto dalla tastiera, quindi aggiungi nel main:

glutKeyboardFunc(tastiera);

e il gioco è fatto!

[gokan]

Quante funzioni sto conoscendo, nel giro di poco tempo..speriamo che riesco ad utilizzarle bene quando mi serviranno!!
Devo provare a fare queste cose anche per gli ogetti 3D.
Un'altra curiosità, ho creato una funzione tipo questa:
void tastiera(unsigned char key,int x, int y)
{
switch (key){
case 'f': glutFullScreen(); break;
case 'g': glutDestroyWindow(0); break;
default : glutReshapeWindow(800,600); break;
}
poi richiamata nel main da glutKeyboardFunc.
Il problema è che se richiamo la distruzione della finestra (l'unica che ho aperto) quando sono in
modalità fullscreen tutto è ok, se però faccio lo stesso lavoro in modalità finestra, ottengo la chiusura
del programma per un errore. Forse non ho capito bene quale valore devo dare in pasto a glutDestroyWindow(int win),
a dire la verità, la guida dice che win=Identifier of GLUT window to destroy

Grazie, i tuoi esempi sono sempre molto azzeccati e chiari. Qual'è stata la tua fonte per imparare ad usare OpenGL? Hai creato qualcosa di particolare?

[anx721]

Allora, la glutDestroyWindow vuole come argomento l'intero che rappresenta la finestra da distruggere, che in questo caso è la finestra del programma openGL. Quando nel main chiami gluCreateWindow, questa funzione restituisce un indice intero che identifica proprio la finestra che è stata creata; quindi memorizzati questo indice in una variabile globale in modo da pasarlo poi a glutDestroyWindow. Non so se basta questo a far funzionare il tutto perchè non ho masi usato la funzione di distruzione per terminare il programma, io usavo l'ìstruzione:

exit(0);

per farlo terminare.

Per imparare openGL ho letto vari tutorial che ci sono online, e poi i vari libri in pdf che ci sono sul sito ufficiale delle opengl, oltre a un manuale di riferimento per glut. Il tutto per realizzare un progetto per l'esame di grafica in cui, assiema ad un mio compagno, abbiamo realizzato una scena tridimensionale ispirata al cartone grande mazinga, di cui puoi vedere uno screen shot nell'immagine in allegato,

Ciao.

[anx721]

allegato

[gokan]

Bella la scena, vuoi dire che avete creato un ambiente dove fare muovere quel robot? :eek:

Per quanto riguarda glutDestroyWindow(int win), forse è meglio utilizzare semplicemente exit(0), questo non potrebbe bastare nel caso avessi più finestre e volessi chiuderne solo una...
comunque a me basta exit(0) :D

Io sto usando le guide di Nehe come riferimento (almeno principale), siccome Nehe non fa uso di Glut, mi aiuto un pò con il redbook, Glut reference e poco con il bluebook. Il mio manuale di riferimento è comunque l' anx721, lo conosci :sofico: ?

[anx721]

Veramente sono un po arrugginito di opengl... anche se si possono fare delle belle cose, soprattutto quando inizi a mettere su texture e luci... comuqnue i tutorial possono servire per iniziare, poi se vuoi fare cose migliori devi leggerti i testi. Nella mia scena si vede mazinga che esce dal sotterraneo, si posiziona sulla pista, inizia a correre e prende il volo scomparendo tra le nuvole :sofico:

[gokan]

glBegin(GL_TRIANGLES) // Disegna usando i triangoli
glVertex3f( 0.0f, 1.0f, 0.0f); // Sopra
glVertex3f(-1.0f,-1.0f, 0.0f); // Sotto a sinistra
glVertex3f( 1.0f,-1.0f, 0.0f); // Sotto a destra
glEnd();

Mi è sorto un dubbio, non mi ero accorto bene come venissero disegnate le figure. In pratica glVertex disegna
un punto nello spazio Il primo punto (sopra) viene disegnato di un'unità spostato in alto nell'asse Y.
Nel tracciare il punto 2 (sotto a sinistra), si va a sinistra e si scende, per il terzo, si fa un passo a
destra ed uno in basso.
La domanda è, ogni volta che viene tracciato un punto, l'origine degli assi vengono spostati (cioè, il centro
cambia nell'ultimo punto tracciato) oppure si parte dall'ultimo punto descritto?
Nell'ultimo caso, se in un ipotetico asse cartesiano (X ed Y, tralasciamo Z sempre a zero) teniamo traccia
dei singoli punti: A(0,1) B(-1,0) C(1,-1), il triangolo disegnato è del seguente tipo (vedi allegato).
Ciao

[anx721]

Non si parte dall'ultimo punto, ma neanche gli assi vengono spostati; le coordinate sono coordinate assolute e no nrelative ai punti precedentemente disegnati. Solo rotazioni/traslazioni/sclaamenti danno l'effetto di un cambiamento del sistema di riferimento.

[gokan]

Come faccio a capire che quei punti mi danno allora un triangolo equilatero come questo, ci sarà un modo?

[anx721]

Originariamente inviato da gokan
Come faccio a capire che quei punti mi danno allora un triangolo equilatero come questo, ci sarà un modo?

Non ho capito la domanda

[gokan]

Tu hai detto che le coordinate dei punti sono assolute, cioè posso rappresentare ogni singolo punto nell'asse cartesiano. Se questo è vero, come mai il triangolo ottenuto disegnandomi a mano i punti è diverso da quello che ottengo facendolo con openGL? hai visto l'allegato di due risposte fà?
Ciao

[anx721]

Il disegno che riporti in quell'allegato è ciò che ottieni con i punti indicati nei vertici? Se questo è il caso, probabilemtne ci sono delle trasformazioni che influenzano il disegno.

[gokan]

Ecco, volevo sentire questo!!
Di sicuro c'è qualche trasformazione che rende il triangolo bello e buono. Rigiro la domanda allora, come devo modificare questa parte di codice affinchè io possa rappresentare il triangolo nell'allegato di nome "tri"?
glBegin(GL_TRIANGLES) // Disegna usando i triangoli
glVertex3f( x.0f, x.0f, 0.0f); // Sopra
glVertex3f(x.0f,x.0f, 0.0f); // Sotto a sinistra
glVertex3f( x.0f,x.0f, 0.0f); // Sotto a destra
glEnd();

Grazie ancora per la pazienza :)

[anx721]

Le coordinate indicate nei vertici del triangolo in quella figura non corrispondono alla figura stessa; per ottenere quel triangolo devi fare:


glBegin(GL_TRIANGLES) // Disegna usando i triangoli
glVertex3f( 0.0f, 1.0f, 0.0f); // Sopra
glVertex3f(-1.0f,x.0f, 0.0f); // Sotto a sinistra
glVertex3f( 1.0f,-1.0f, 0.0f); // Sotto a destra
glEnd();