Re: OpenGl e scheda grafica

Messaggioda vict85 » 28/11/2012, 15:32

Quando premi un tasto, informi la cpu che l'hai premuto, quindi lei manderà alla gpu le conseguenti modifiche della scena che verranno applicate non appena la gpu riterrà di doverlo fare. Non per niente, non sempre nei giochi si ha una risposta istantanea dei tasti.
vict85
Moderatore
Moderatore
 
Messaggio: 3833 di 19253
Iscritto il: 16/01/2008, 00:13
Località: Berlin

Re: OpenGl e scheda grafica

Messaggioda apatriarca » 28/11/2012, 16:20

Per prima cosa la gestione degli input da tastiera o da qualsiasi altra fonte non fa parte delle OpenGL. Normalmente si gestiscono gli input da tastiera e mouse attraverso il GUI toolkit usato per creare il context OpenGL (GLUT, SDL, Qt, Win32, GTK, wxWidgets, GLFW...). Non è detto che tali toolkit facciano usato di callback per la gestione di tali input e anche quando lo fanno, non fanno uso di interrupt hardware. Se tali interrupt vengono usati, è il sistema operativo a gestirli e a renderli disponibili attraverso la loro API.
apatriarca
Moderatore
Moderatore
 
Messaggio: 2470 di 10435
Iscritto il: 08/12/2008, 20:37
Località: Madrid

Re: OpenGl: scheda grafica (Terminato) e Buffers

Messaggioda hee136 » 02/12/2012, 23:06

Non capisco come funzionino i buffers (o meglio il single buffer).

Codice:
Codice:

#include <GL/glut.h>    // Header File For The GLUT Library
#include <GL/gl.h>   // Header File For The OpenGL32 Library
#include <GL/glu.h>   // Header File For The GLu32 Library
#include <unistd.h>     // Header file for sleeping.

/* The number of our GLUT window */
int window;

void keyb(unsigned char key, int x, int y) {
   printf("Tasto premuto: %c \n", key);
   //Colori di sfondo   
   if(key == 'r') {
      printf("Imposto il colore rosso... \n");
      glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
   }
   else if(key == 'g') {
      printf("Imposto il colore verde... \n");
      glClearColor(0.0f, 1.0f, 0.0f, 0.0f);
   }
   else if(key == 'b') {
      printf("Imposto il colore blu... \n");
      glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
   }
   //Disegno: imposto il colore
   else if(key == '1') {
      printf("Applico il colore ... \n");
      glClear(GL_COLOR_BUFFER_BIT);
   }
   //Disegno: faccio lo swap
   else if(key == '2') {
      printf("Swappo i buffers ... \n");
      glutSwapBuffers();
   }

}

int main(int argc, char **argv)

  glutInit(&argc, argv); 
  glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  glutInitWindowSize(640, 480); 
  glutInitWindowPosition(0, 0); 
  window = glutCreateWindow("My first opengl app..."); 

  glutKeyboardFunc(&keyb);

  glutMainLoop(); 

  return 1;
}



Codice:
Output:

Tasto premuto: g
Imposto il colore verde...

Tasto premuto: 1
Applico il colore ...

Tasto premuto: 2
Swappo i buffers ...


Non capisco come mai col buffer singolo il colore di sfondo viene impostato quando premo il tasto 2 e non quando premo il tasto 1. Col buffer singolo dovrei avere un unico buffer e quindi il colore dovrebbe essere visualizzato non appena lo applico senza alcuno swap.
hee136
Junior Member
Junior Member
 
Messaggio: 222 di 344
Iscritto il: 26/05/2008, 20:31

Re: OpenGl: scheda grafica (Terminato) e Buffers

Messaggioda hee136 » 03/12/2012, 08:52

Credo di aver capito che l'errore sia sempre il solito.
La glClearColor non applica il colore di sfondo ma dice alla GPU: "appena puoi applica questo colore". Ma la GPU non esegue immediatamente. Se dopo eseguo la glutSwapBuffers (o la glFlush), allora queste forzano la GPU ad eseguire immediatamente l'azione che gli ho detto.
Nel caso di buffer doppio ci vuole la prima. Mentre con buffer singolo basta la seconda.
hee136
Junior Member
Junior Member
 
Messaggio: 223 di 344
Iscritto il: 26/05/2008, 20:31

Re: OpenGl: scheda grafica (Terminato) e Buffers

Messaggioda apatriarca » 03/12/2012, 11:21

Di fatto si usa sempre almeno il double buffering. Alcune applicazioni usano addirittura il triple buffering in cui l'applicazione non deve aspettare lo swap dei buffer prima di iniziare a disegnare una nuova scena. Nei casi in cui si faccia utilizzo della sincronia verticale (lo swap avviene quando il monitor decide di ripartire da capo nella visualizzazione del frame*) questa attesa potrebbe essere di alcuni millisecondi. A 60 Hz l'attesa può essere anche di 16 ms se la scena disegnata è molto semplice.

In ogni caso hai capito quale fosse il problema. Non c'è alcuna garanzia che i comandi che hai inviato alle OpenGL vengano eseguiti se non chiami glFlush (o una qualche altra funzione come glutSwapBuffer che chiama al suo interno glFlush).

* Nel caso dei vecchi monitor CRT, la scena viene disegnata una riga per volta e quando il raggio arriva alla fine dello schermo riparte da capo. Lo swap con la sincronia verticale avveniva quando questo si spostava dall'ultima riga alla prima. In questo modo non si avevano fastidiosi tagli orizzontali nella scena (soprattutto quando questa era molto dinamica). Il termine sincronia verticale deriva proprio da questo discorso. Nel caso dei monitor LCD non so in cosa consista esattamente, ma l'idea è più o meno la stessa. Evita che ci siano due immagini diverse mischiate sul monitor.
apatriarca
Moderatore
Moderatore
 
Messaggio: 2472 di 10435
Iscritto il: 08/12/2008, 20:37
Località: Madrid

Re: OpenGl: scheda grafica, buffers (Terminato) e glNormal

Messaggioda hee136 » 07/12/2012, 12:25

Grazie per le risposte :) Sto procedendo con le lezioni.

Ho trovato un problema con la normale definita dalla glNormal. Non capisco perchè mi chiede le coordinate del vettore normale da assegnare al vertice.
Data una superficie la direzione della normale è fissata (perpendicolare alla superficie). Posso far variare solo modulo e verso. Quindi anzichè chiedermi le tre coordinate non dovrebbe chiedermi solo questi ultimi due?
hee136
Junior Member
Junior Member
 
Messaggio: 224 di 344
Iscritto il: 26/05/2008, 20:31

Re: OpenGl: scheda grafica, buffers (Terminato) e glNormal

Messaggioda apatriarca » 07/12/2012, 12:36

Il problema è che tu non hai una superficie (ad esempio un triangolo), ma un vertice. Un vertice non definisce una superficie e quindi la direzione normale in quel punto non è ben definita. Il motivo per cui è utile/necessario definire una direzione normale per ogni vertice è per calcolare l'effetto che una sorgente luminosa ha sul quel punto. Nelle OpenGL "vecchie" infatti, l'effetto della luce viene calcolato solo nei vertici e poi viene interpolato all'interno di triangoli (o più generalmente poligoni).

Ricordati comunque che nella maggior parte dei casi la mesh è solo una approssimazione di quello che si vorrebbe disegnare e la normale nei vertici di tale mesh è normalmente presa come la normale sulla superficie che si vuole approssimare o attraverso una interpolazione (a volte pesata) tra le normale dei triangoli contenenti tale vertice (esistono diversi metodo con effetti diversi).
apatriarca
Moderatore
Moderatore
 
Messaggio: 2481 di 10435
Iscritto il: 08/12/2008, 20:37
Località: Madrid

Re: OpenGl: scheda grafica, buffers (Terminato) e glNormal

Messaggioda hee136 » 07/12/2012, 15:38

apatriarca ha scritto:Il problema è che tu non hai una superficie (ad esempio un triangolo), ma un vertice. Un vertice non definisce una superficie e quindi la direzione normale in quel punto non è ben definita. Il motivo per cui è utile/necessario definire una direzione normale per ogni vertice è per calcolare l'effetto che una sorgente luminosa ha sul quel punto. Nelle OpenGL "vecchie" infatti, l'effetto della luce viene calcolato solo nei vertici e poi viene interpolato all'interno di triangoli (o più generalmente poligoni).
(...)


Quindi la glNormal mi permette anche di definire "vettori normali" che non sono matematicamente perpendicolari?
Non viene segnalato nessun errore?

La normale definita con la glNormal non ha altri effetti? Ha effetto solo sulla luce e sulla mesh?

Codice:

Disegno un triangolo.

// glNormal(0, 0, 1); <------ Esempio di normale corretta

glNormal(1, 1, 1); <------ Normale errata

glVertex(0, 0, 0);
glVertex(1, 0, 0);
glVertex(0, 1, 0);



Un'ultima cosa: secondo come è stato scritto lo pseudo-codice sopra, la glNormal si applica solo al vertice sotto e non agli altri?
hee136
Junior Member
Junior Member
 
Messaggio: 225 di 344
Iscritto il: 26/05/2008, 20:31

Re: OpenGl: scheda grafica, buffers (Terminato) e glNormal

Messaggioda apatriarca » 07/12/2012, 16:06

glNormal si applica a tutti i vertici che seguono la chiamata fino alla successiva chiamata a glNormal. Setta cioè un qualche tipo di stato all'interno delle OpenGL. Nel tuo caso quindi, (1,1,1) sarà la normale a tutti i vertici successivi. Puoi settare il valore che preferisci, non deve avere necessariamente legare con la geometria, ma ha poco senso fare diversamente. glNormal puoi chiamarlo prima di ogni vertice per settare normali differenti ai tre vertici del triangolo (viene usato per far apparire l'oggetto più liscio in quanto parte della nostra capacità di percepire le forme è legata all'ombreggiatura.
apatriarca
Moderatore
Moderatore
 
Messaggio: 2482 di 10435
Iscritto il: 08/12/2008, 20:37
Località: Madrid

Precedente

Torna a Informatica

Chi c’è in linea

Visitano il forum: Nessuno e 1 ospite