[C++] Starting OpenGL

[Tommy_2]

Ebbene si, nonostanta abbia detto che volevo iniziare con casa microsoft ho puntato su openGL Purtroppo la mia scheda video non mi permette di giocare con openGL4.3 ma con il 3.3 (fa nulla, come inizio credo vada bene). Ora girando sulla wiki ufficiale sono arrivato a questo sito:
http://openglbook.com/the-book/chapt...tting-started/
Ho scaricato:
FreeGLUT
GLEW
DevIL (non ancora installato)
Ho installato i primi due seguendo questo ordine (trovando una guida online):
messo i file include di freeglut e glew in "C:\Program Files (x86)\Windows Kits\8.0\Include\um\gl"
messo i file lib di freeglut e glew in "C:\Program Files (x86)\Windows Kits\8.0\Lib\win8\um\x86"
Anche se forse non ce n'era bisogno
Ho creato un progetto e linkato le librerie in modo da non avere problemi.
Ora la domanda è quella guida a quanto ho capito fa compilare i progetti in C e non C++. Infatti sempre sullo stesso sito ho trovato questo:
http://openglbook.com/setting-up-ope...t-in-visual-c/
Infatti se seguo quella guida va tutto bene. (usando un codice openGL 3.3)
Se invece non tocco nulla e metto solo il warning as error ed error level a 4, quando tento di compilare ho il seguente warning/error:

main.cpp(104): error C2220: avviso utilizzato come errore - nessun file 'object' generato
c:\program files (x86)\windows kits\8.0\include\um\gl\freeglut_std.h(610): warning C4505: 'glutCreateMenu_ATEXIT_HACK': funzione locale senza riferimenti rimossa

Il codice è preso da qui
Ora se avete delle bibbie da consigliarmi sono tutto occhi. ALtrimenti vedrò di continuare con questo e disattivare i warning as error

EDIT: Inoltre quanto è utile usare un livello 4 invece del 3? Essendo quest'ultimo a darmi quel warning

[devilheart]

Mai mettere i warning come errori. Quel warning dice solo che quella funzione è inutile perché non è mai chiamata e salta fuori perché la funzione è definita nell'header (anziché solo dichiarata)

[Tommy_2]

Mai mettere i warning come errori. Quel warning dice solo che quella funzione è inutile perché non è mai chiamata e salta fuori perché la funzione è definita nell'header (anziché solo dichiarata)

Capito. Quindi togliamo i warning come errori, mi conviene lasciare il livello degli avvisi a 3 o a 4?

[devilheart]

puoi tenerli a 4, ma ignora quelli che si riferiscono a roba non tua (o manda un repot all'upstream)

[Tommy_2]

puoi tenerli a 4, ma ignora quelli che si riferiscono a roba non tua (o manda un repot all'upstream)

Perfetto.
Ultima richiesta. Esiste una bibbia sull'OpenGL 4 dalle basi fino agli angoli più oscuri per il C++? A quanto pare la guida che ho trovato io è per il C...

[CorralX]

Perfetto.
Ultima richiesta. Esiste una bibbia sull'OpenGL 4 dalle basi fino agli angoli più oscuri per il C++? A quanto pare la guida che ho trovato io è per il C...

La bibbia esiste e si chiama OpenGL Superbible, che copre ogni buco (quasi) dell'api, con esempi in C/C++.
Ed è un libro consigliatissimo tra l'altro.

[Tommy_2]

La bibbia esiste e si chiama OpenGL Superbible, che copre ogni buco (quasi) dell'api, con esempi in C/C++.
Ed è un libro consigliatissimo tra l'altro.

Perfetto. 5a edizione e ricopre OpenGL3.3

[CorralX]

Perfetto. 5a edizione e ricopre OpenGL3.3

Ti consiglierei la quarta edizione se riesci a reperirla
In alcuni punti è fatta meglio e parla nello specifico di OpenGL, mentre nella quinta fanno riferimento ad un loro toolkit, che astrae un pò le cose e non vanno in profondità.
Quindi andrei di quarta per imparare, e con la quinta vedere i cambiamenti introdotti da OpenGL 3.+

[devilheart]

Con la rimozione della pipeline fissa le cose da sapere di opengl sono davvero poche. La maggior parte del lavoro ora si fa coi shader

[Tommy_2]

Ti consiglierei la quarta edizione se riesci a reperirla
In alcuni punti è fatta meglio e parla nello specifico di OpenGL, mentre nella quinta fanno riferimento ad un loro toolkit, che astrae un pò le cose e non vanno in profondità.
Quindi andrei di quarta per imparare, e con la quinta vedere i cambiamenti introdotti da OpenGL 3.+

Ok, procurato anche la quarta edizione

Con la rimozione della pipeline fissa le cose da sapere di opengl sono davvero poche. La maggior parte del lavoro ora si fa coi shader

Consigli comunque di leggere OpenGL SuperBible?

[devilheart]

Ok, procurato anche la quarta edizione

Consigli comunque di leggere OpenGL SuperBible?

Può essere utile ma sappi che buona parte della prima sezione non è applicabile, o meglio, è applicabile solo se scrivi codice per la versione 2 o precedenti

[Tommy_2]

Può essere utile ma sappi che buona parte della prima sezione non è applicabile, o meglio, è applicabile solo se scrivi codice per la versione 2 o precedenti

Ah capisco... per ora sto leggendo questo libro, è interessante.
Un libro/guida che sia moderna che spieghi veramente bene gli shader e quelle poche cose da sapere?

[Tommy_2]

Sto seguendo un po' la bibbia 4a ed. E vorrei chiedervi se ho capito bene l'esempio del quadrato che rimbalza quando raggiunge la finestra, che mi sta dando un po' di problemi concettualmente parlando
Il programma deve disegnare un quadrato che si muova in una direzione, quando raggiunge l'estremità della finestra creata deve rimbalzare nella direzione opposta. La finestra può essere ridimensionata. Ridimensionando il quadrato deve restare un quadrato (poi parleremo anche di questo). Ora vi posto il codice sorgente:

Spoiler:

#include <windows.h>#include <gl/glew.h>
#include <gl/freeglut.h>


// Initial square position and size
GLfloat x = 0.0f;
GLfloat y = 0.0f;
GLfloat rsize = 25;


// Step size in x and y directions
// (number of pixels to move each time)
GLfloat xstep = 1.0f;
GLfloat ystep = 1.0f;


// Keep track of windows changing width and height
GLfloat windowWidth;
GLfloat windowHeight;


///////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
        // Clear the window with current clearing color
        glClear(GL_COLOR_BUFFER_BIT);


        // Set current drawing color to red
        //         R     G     B
        glColor3f(1.0f, 0.0f, 0.0f);


        // Draw a filled rectangle with current color
        glRectf(x, y, x + rsize, y - rsize);


        // Flush drawing commands and swap
        glutSwapBuffers();
}


///////////////////////////////////////////////////////////
// Called by GLUT library when idle (window not being
// resized or moved)
void TimerFunction(int value)
{
        // Reverse direction when you reach left or right edge
        if(x > windowWidth-rsize || x < -windowWidth)
                xstep = -xstep;


        // Reverse direction when you reach top or bottom edge
        if(y > windowHeight || y < -windowHeight + rsize)
                ystep = -ystep;


        // Actually move the square
        x += xstep;
        y += ystep;


        // Check bounds. This is in case the window is made
        // smaller while the rectangle is bouncing and the 
        // rectangle suddenly finds itself outside the new
        // clipping volume
        if(x > (windowWidth-rsize + xstep))
                x = windowWidth-rsize-1;
        else if(x < -(windowWidth + xstep))
                x = -windowWidth -1;


        if(y > (windowHeight + ystep))
                y = windowHeight-1; 
        else if(y < -(windowHeight - rsize + ystep))
                y = -windowHeight + rsize - 1;






        // Redraw the scene with new coordinates
        glutPostRedisplay();
        glutTimerFunc(33,TimerFunction, 1);
}




///////////////////////////////////////////////////////////
// Setup the rendering state
void SetupRC(void)
{
        // Set clear color to blue
        glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
}




///////////////////////////////////////////////////////////
// Called by GLUT library when the window has chanaged size
void ChangeSize(int w, int h)
{
        GLfloat aspectRatio;


        // Prevent a divide by zero
        if(h == 0)
        h = 1;


        // Set Viewport to window dimensions
        glViewport(0, 0, w, h);


        // Reset coordinate system
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();


        // Establish clipping volume (left, right, bottom, top, near, far)
        aspectRatio = (GLfloat)w / (GLfloat)h;
        if (w <= h) 
        {
                windowWidth = 100;
                windowHeight = 100 / aspectRatio;
                glOrtho (-100.0, 100.0, -windowHeight, windowHeight, 1.0, -1.0);
        }
        else 
        {
                windowWidth = 100 * aspectRatio;
                windowHeight = 100;
                glOrtho (-windowWidth, windowWidth, -100.0, 100.0, 1.0, -1.0);
        }


        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
}


///////////////////////////////////////////////////////////
// Main program entry point
int main(int argc, char* argv[])
{
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
        glutInitWindowSize(800,600);
        glutCreateWindow("Bounce");
        glutDisplayFunc(RenderScene);
        glutReshapeFunc(ChangeSize);
        glutTimerFunc(33, TimerFunction, 1);


        SetupRC();


        glutMainLoop();


        return 0;
}

Ora io avrei pensato che quando x1 avrebbe raggiunto il valore prossimo a 800 (la grandezza della finestra in pixel) allora si fa il cambio di direzione, ma non è così. Ditemi se sbaglio, da come ho capito io ho una finestra (800x600) al cui interno poi c'è un piano cartesiano (immaginario) di grandezza (100,100,1) con origine al centro della finestra. Per questo motivo coordinata 100 equivale all'estremo della finestra e non 800 come pensavo.

[CorralX]

Sto seguendo un po' la bibbia 4a ed. E vorrei chiedervi se ho capito bene l'esempio del quadrato che rimbalza quando raggiunge la finestra, che mi sta dando un po' di problemi concettualmente parlando
Il programma deve disegnare un quadrato che si muova in una direzione, quando raggiunge l'estremità della finestra creata deve rimbalzare nella direzione opposta. La finestra può essere ridimensionata. Ridimensionando il quadrato deve restare un quadrato (poi parleremo anche di questo). Ora vi posto il codice sorgente:

Spoiler:

#include <windows.h>#include <gl/glew.h>
#include <gl/freeglut.h>


// Initial square position and size
GLfloat x = 0.0f;
GLfloat y = 0.0f;
GLfloat rsize = 25;


// Step size in x and y directions
// (number of pixels to move each time)
GLfloat xstep = 1.0f;
GLfloat ystep = 1.0f;


// Keep track of windows changing width and height
GLfloat windowWidth;
GLfloat windowHeight;


///////////////////////////////////////////////////////////
// Called to draw scene
void RenderScene(void)
{
        // Clear the window with current clearing color
        glClear(GL_COLOR_BUFFER_BIT);


        // Set current drawing color to red
        //         R     G     B
        glColor3f(1.0f, 0.0f, 0.0f);


        // Draw a filled rectangle with current color
        glRectf(x, y, x + rsize, y - rsize);


        // Flush drawing commands and swap
        glutSwapBuffers();
}


///////////////////////////////////////////////////////////
// Called by GLUT library when idle (window not being
// resized or moved)
void TimerFunction(int value)
{
        // Reverse direction when you reach left or right edge
        if(x > windowWidth-rsize || x < -windowWidth)
                xstep = -xstep;


        // Reverse direction when you reach top or bottom edge
        if(y > windowHeight || y < -windowHeight + rsize)
                ystep = -ystep;


        // Actually move the square
        x += xstep;
        y += ystep;


        // Check bounds. This is in case the window is made
        // smaller while the rectangle is bouncing and the 
        // rectangle suddenly finds itself outside the new
        // clipping volume
        if(x > (windowWidth-rsize + xstep))
                x = windowWidth-rsize-1;
        else if(x < -(windowWidth + xstep))
                x = -windowWidth -1;


        if(y > (windowHeight + ystep))
                y = windowHeight-1; 
        else if(y < -(windowHeight - rsize + ystep))
                y = -windowHeight + rsize - 1;






        // Redraw the scene with new coordinates
        glutPostRedisplay();
        glutTimerFunc(33,TimerFunction, 1);
}




///////////////////////////////////////////////////////////
// Setup the rendering state
void SetupRC(void)
{
        // Set clear color to blue
        glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
}




///////////////////////////////////////////////////////////
// Called by GLUT library when the window has chanaged size
void ChangeSize(int w, int h)
{
        GLfloat aspectRatio;


        // Prevent a divide by zero
        if(h == 0)
        h = 1;


        // Set Viewport to window dimensions
        glViewport(0, 0, w, h);


        // Reset coordinate system
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();


        // Establish clipping volume (left, right, bottom, top, near, far)
        aspectRatio = (GLfloat)w / (GLfloat)h;
        if (w <= h) 
        {
                windowWidth = 100;
                windowHeight = 100 / aspectRatio;
                glOrtho (-100.0, 100.0, -windowHeight, windowHeight, 1.0, -1.0);
        }
        else 
        {
                windowWidth = 100 * aspectRatio;
                windowHeight = 100;
                glOrtho (-windowWidth, windowWidth, -100.0, 100.0, 1.0, -1.0);
        }


        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
}


///////////////////////////////////////////////////////////
// Main program entry point
int main(int argc, char* argv[])
{
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);
        glutInitWindowSize(800,600);
        glutCreateWindow("Bounce");
        glutDisplayFunc(RenderScene);
        glutReshapeFunc(ChangeSize);
        glutTimerFunc(33, TimerFunction, 1);


        SetupRC();


        glutMainLoop();


        return 0;
}

Ora io avrei pensato che quando x1 avrebbe raggiunto il valore prossimo a 800 (la grandezza della finestra in pixel) allora si fa il cambio di direzione, ma non è così. Ditemi se sbaglio, da come ho capito io ho una finestra (800x600) al cui interno poi c'è un piano cartesiano (immaginario) di grandezza (100,100,1) con origine al centro della finestra. Per questo motivo coordinata 100 equivale all'estremo della finestra e non 800 come pensavo.

Stai utilizzando una proiezione ortogonale a cui dici che stai inquadrando in finestra da -100.0 a +100.0.
Quindi devi controllare quando il quadrato raggiunge quelle coordinate, e raggiungerà quindi anche il bordo della finestra.
Il problema qui è la coerenza degli spazi in cui fai i conti.
Se fai i conti e usi la posizione in world space, controlli (-100, 100), se fai i conti e usi la posizione in screen space, usi (0, 800).
E tutti un problema di decidere in che modo fare le cose.
Attualmente stai facendo un 2D "finto", con una proiezione ortografica, ma i conti sono tutti in 3D in world space.

Questi è uno dei problemi maggiori per chi si avvicina.
Capire in quale spazio si sta lavorando e rimanere coerenti.
In futuri troverai un sacco di space diversi, world space, object space, camera space, screen space, clip space, tangent space, light space.
Dovrai imparare a litigarci, ed esprimere le coordinate nel modo corretto (ed eventualmente convertirle)

[Tommy_2]

Stai utilizzando una proiezione ortogonale a cui dici che stai inquadrando in finestra da -100.0 a +100.0.
Quindi devi controllare quando il quadrato raggiunge quelle coordinate, e raggiungerà quindi anche il bordo della finestra.
Il problema qui è la coerenza degli spazi in cui fai i conti.
Se fai i conti e usi la posizione in world space, controlli (-100, 100), se fai i conti e usi la posizione in screen space, usi (0, 800).
E tutti un problema di decidere in che modo fare le cose.
Attualmente stai facendo un 2D "finto", con una proiezione ortografica, ma i conti sono tutti in 3D in world space.

Questi è uno dei problemi maggiori per chi si avvicina.
Capire in quale spazio si sta lavorando e rimanere coerenti.
In futuri troverai un sacco di space diversi, world space, object space, camera space, screen space, clip space, tangent space, light space.
Dovrai imparare a litigarci, ed esprimere le coordinate nel modo corretto (ed eventualmente convertirle)

Ecco, è un macello Il mio cervello era bloccato al solo screen space, ma noto che ci sono milioni di spazi con cui "divertirsi"
Continuerò a seguire la bibbia e finita quella vedrò di trovare una guida più profonda sul 3D Userò ancora questo thread andando avanti con la bibbia, per chiedere delucidazioni ed altro