Problème d'implémentation de shader GLSL

Version imprimable

Voilà, j'essaie de me mettre à la programmation openGL, et malheureusement code::blocks n'arrête pas de me crier dessus... :'( si quelqu'un pouvait me dire ce qui cloche dans ce code source, ça serait sympa...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#include "glext.h"
 
int main ( int argc, char** argv )
{
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 16,
                                           SDL_HWSURFACE|SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
 
    // création du cell-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    glDeleteShader(fragmentShader);
    glDeleteShader(vertexShader);
    fragmentShader = 0;
    vertexShader = 0;
 
 
    // FAIRE QQCH ICI
 
 
 
 
    // program main loop
    bool done = false;
    while (!done)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            // check for messages
            switch (event.type)
            {
                // exit if the window is closed
            case SDL_QUIT:
                done = true;
                break;
 
                // check for keypresses
            case SDL_KEYDOWN:
                {
                    // exit if ESCAPE is pressed
                    if (event.key.keysym.sym == SDLK_ESCAPE)
                        done = true;
                    break;
                }
            } // end switch
        } // end of message processing
 
 
    }
    // all is well ;)
    printf("Exited cleanly\n");
    return 0;
 
}

Je suppose que c'est un problème évident mais j'arrive pas à le résoudre... :D

Et voici les injures de code::blocks :

"Error, GL_VERTEX_SHADER was not declared in this scope."

Cette erreur est présent une fois pour chaque élément : GL_VERTEX_SHADER, GL_FRAGMENT_SHADER, glCreateShader(), glDeleteShader()...

Je comprend bien ce que veux dire "not defined in this scope" mais je vois pas pourquoi... j'ai zappé un préfixe ou quelque-chose dans le genre ?? Je suis perdu, toute aide est là bienvenue !!

Merci d'avance

22/11/2007, 17h08
Marco17

Bon en faite, le problème semble reglé, les shaders s'utiliseraient apparamment avec <glew.h> qui n'était pas inclus...

D'ailleurs, je n'y comprends plus grand chose au fonctionnement d'OpgenGL,
quelqu'un serait t-il capable de me résumer très brièvement dans quelles conditions on utilise :

gl.h
glu.h
glew.h
et glut.h tant qu'on y est... ^^

J'arrive pas vraiment à trouver le "point de départ" on va dire, pour utiliser OpenGL...

Merci d'avance.
22/11/2007, 17h40
shenron666

tu devrais te renseigner sur... les extensions OpenGL
car tu arrive dans le domaine des extensions
et GLEW est une bibliothèque qui facilite l'utilisation des extensions

pour utiliser les extensions, il faut
1 - tester si elle est supportée
2 - demander à pouvoir y accéder
ensuite seulement tu peux les exploiter

de plus, normalement, les extensions se terminent en ARB ou EXT ou ATI ou NV bref avec une dénomination du standard de l'extension
souvent on se limite aux extensions ARB et EXT qui ont étés approuvées par le consortium OpenGL pour ne pas être trop restreint à un matériel spécifique

pour répondre à ta question "dans quelles conditions on utilise" :
- gl.h : fichier d'inclusion principal d'opengl nécessaire pour utiliser opengl et plus généralement toutes les fonctions de bases (hors extension) commençant par gl... (glVertex par exemple)
- glu.h : fichier d'inclusion des outils opengl, à inclure si tu utilises les fonctions commançant pas glu... (gluPerspective par exemple)
- glut.h : fichier d'inclusion de la GLUT, bibliothèque de fenêtrage pour opengl facilitant la création de fenêtre permettant d'utiliser opengl, les fonctions de la GLUT commencent par glut... (glutCreateWindow par exemple)
- glew.h : fichier d'inclusion de GLEW, bibliothèque facilitant l'accès à tout ce qui touche aux extensions opengl

pour revenir à GLUT, dans ton code exemple tu inclus la SDL
ce sont en gros deux bibliothèques équivalentes, tu peux choisir l'une OU l'autre pour gérer ta fenêtre (et tout l'aspect système) de opengl
23/11/2007, 13h57
Marco17

Merci beaucoup pour la réponse ! :)

Il faut en effet que je me renseigne sur Glew.h parce-que, je peux pas inclure à la fois glew et glu/gl... dans mon fichier, glew doit le faire tout seul non ? Mais quoi qu'il en soit dans mon code source quand j'essaie d'utiliser gluPerspective(); Code::blocks m'insulte en me disant que c'est pas défini... -_-' alors que toutes les autres fontion gl*** fonctionnent très bien...

Bref, que du bonheur !
23/11/2007, 15h23
shenron666
glew n'inclus pas glu à ma connaissance
dans un programme opengl simple basé sur SDL + Glew j'ai :
Code:

1 2 3 #include <SDL/SDL.h> #include <GL/glew.h> #include <GL/GLU.h>
ainsi que les bibliothèques nécessaires

et code::blocks ne rale pas ;)

edit : bien faire attention à inclure glew.h en premier car ce qui est sûr c'est que glew.h inclus gl.h
glu.h arrive après

Bah, apparamment j'ai réglé le problème de gluPerspective... j'avais pas linké glew32.lib... Et forcément avec ça marche mieux ^^ Par contre, je comprend toujours pas comment marche ce programme... -_-'

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
 
 
#include <GL/glew.h>
#include <textfile.h>
 
 
void Display();
float angle=0;
 
int main ( int argc, char** argv )
{
 
 
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 16,
                                           SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
 
 
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
 
    // Propriété de l'affichage
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    glClearColor(0.0f,0.0f,0.0f,0.5f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
 
    glDepthFunc(GL_LEQUAL);
 
    glViewport(0,0,800,600);
    gluPerspective(45.0,800.0/600.0,1.0,100.0); // Angle de la caméra, clipping entre 1 et 100 (pas à partir de 0,
    glMatrixMode(GL_MODELVIEW);                 // sinon on perd toute la précision du z-buffer)
 
 
/* SHADERS QUI FONT SYSTEMATIQUEMENT PLANTER AVEC RETURN = 3... ?
 //création et importation des fichiers du cel-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    char *vs = textFileRead("toon.vert");
    char *fs = textFileRead("toon.frag");
 
    const char *vv=vs;
    const char *ff=fs;
 
    glShaderSource(vertexShader, 1, &vv,NULL);
    glShaderSource(fragmentShader, 1, &ff,NULL);
 
    free(vs);free(fs);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    GLuint program;
    program = glCreateProgram();
 
    glAttachShader(program,vertexShader);
    glAttachShader(program,fragmentShader);
 
    glLinkProgram(program);
    glUseProgram(program);*/
 
 
 
    // program main loop
    bool Running = true;
    while (Running)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            if (event.type==SDL_QUIT){Running = false ;}
        }
 
        Display();
        if (angle>=360){angle=0;}
        angle++;
    }
    return 0;
 
}
 
 
 
 
// DISPLAY QUI FAIT "FUIR" LE CUBE
void Display()
{
	glClearColor(0,0,0,0); // selectionne la couleur noire (qui est celle par défaut)
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glRotatef(angle, 1,0,0);
	glRotatef(angle, 0,1,0);
	glRotatef(angle, 0,0,1);
	gluLookAt(4,3,3,0,0,0,0,1,0);
	glBegin(GL_QUADS);
	glColor3d(1,0,0);
	glVertex3i(1,1,1);
	glVertex3i(1,-1,1);
	glVertex3i(-1,-1,1);
	glVertex3i(-1,1,1);
 
	glColor3d(0,1,0);
	glVertex3i(1,1,-1);
	glVertex3i(1,-1,-1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,1,-1);
 
	glColor3d(0,0,1);
	glVertex3i(1,1,1);
	glVertex3i(1,-1,1);
	glVertex3i(1,-1,-1);
	glVertex3i(1,1,-1);
 
	glColor3d(0,1,1);
	glVertex3i(-1,1,1);
	glVertex3i(-1,-1,1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,1,-1);
 
	glColor3d(1,1,0);
	glVertex3i(-1,1,-1);
	glVertex3i(-1,1,1);
	glVertex3i(1,1,1);
	glVertex3i(1,1,-1);
 
	glColor3d(1,0,1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,-1,1);
	glVertex3i(1,-1,1);
	glVertex3i(1,-1,-1);
 
	glEnd();
 
	SDL_GL_SwapBuffers( );
 
}

Alors, voilà les problèmes qui persistent sont :
1) tout le bloc concernant les shaders qui fait planter le programme avec un return de 3... Je ne sais pas comment interpréter celà.
2) je comprend mal dans quel ordre faire les opérations concernant l'affichage du cube, tel que c'est là, il semble effectivement tourner sur les 3 axes, mais il fuit, et sort de l'écran assez rapidement

Si quelqu'un peut m'éclaircir là dessus, je serais ravi... En attendant, je suis rapartit direction GoogleLand ^^

Bon en fait, avec un peu de recherche j'ai peut être réussi à intégrer les Shaders au programme, il ne plante plus, mais n'affiche même plus le cube "fuyant"...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
 
 
#include <GL/glew.h>
#include <textfile.h>
 
 
void Display();
float angle=0;
 
int main ( int argc, char** argv )
{
 
 
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 16,
                                           SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
 
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
 
//INITIALISATION glew
    glewInit();
 
//création et importation des fichiers du cel-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    char *vs = textFileRead("toon.vert");
    char *fs = textFileRead("toon.frag");
 
    const char *vv=vs;
    const char *ff=fs;
 
    glShaderSource(vertexShader, 1, &vv,NULL);
    glShaderSource(fragmentShader, 1, &ff,NULL);
 
    free(vs);free(fs);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    GLuint program;
    program = glCreateProgram();
 
    glAttachShader(program,vertexShader);
    glAttachShader(program,fragmentShader);
 
    glLinkProgram(program);
    glUseProgram(program);
 
// Initialisation d'OpenGL
 
	glEnable(GL_LIGHTING);
	glEnable(GL_SMOOTH);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    glClearColor(0.0f,0.0f,0.0f,0.5f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
 
    glDepthFunc(GL_LEQUAL);
 
    glViewport(0,0,800,600);
    gluPerspective(45.0,800.0/600.0,1.0,100.0); // Angle de la caméra, clipping entre 1 et 100 (pas à partir de 0,
    glMatrixMode(GL_MODELVIEW);
	glEnable(GL_LIGHT0);
 
 
 
 
 
 
    // program main loop
    bool Running = true;
    while (Running)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            if (event.type==SDL_QUIT){Running = false ;}
        }
 
        Display();
        if (angle>=360){angle=0;}
        angle++;
    }
    return 0;
 
}
 
 
 
 
 
void Display()
{
	glClearColor(0,0,0,0); // selectionne la couleur noire (qui est celle par défaut)
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glRotatef(angle, 1,0,0);
	glRotatef(angle, 0,1,0);
	glRotatef(angle, 0,0,1);
	gluLookAt(4,3,3,0,0,0,0,1,0);
	glBegin(GL_QUADS);
	glColor3d(1,0,0);
	glVertex3i(1,1,1);
	glVertex3i(1,-1,1);
	glVertex3i(-1,-1,1);
	glVertex3i(-1,1,1);
 
	glColor3d(0,1,0);
	glVertex3i(1,1,-1);
	glVertex3i(1,-1,-1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,1,-1);
 
	glColor3d(0,0,1);
	glVertex3i(1,1,1);
	glVertex3i(1,-1,1);
	glVertex3i(1,-1,-1);
	glVertex3i(1,1,-1);
 
	glColor3d(0,1,1);
	glVertex3i(-1,1,1);
	glVertex3i(-1,-1,1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,1,-1);
 
	glColor3d(1,1,0);
	glVertex3i(-1,1,-1);
	glVertex3i(-1,1,1);
	glVertex3i(1,1,1);
	glVertex3i(1,1,-1);
 
	glColor3d(1,0,1);
	glVertex3i(-1,-1,-1);
	glVertex3i(-1,-1,1);
	glVertex3i(1,-1,1);
	glVertex3i(1,-1,-1);
 
	glEnd();
 
	SDL_GL_SwapBuffers( );
 
}

Voilà, je pige toujours pas pourquois le cube ne s'affiche plus du tout, et pourquoi dans la version précédente il fuyait...

23/11/2007, 19h11
shenron666
Citation:

Envoyé par Marco17

Bah, apparamment j'ai réglé le problème de gluPerspective... j'avais pas linké glew32.lib... Et forcément avec ça marche mieux ^^

euh... glew32.lib et glu n'ont rien à voir l'un avec l'autre
le problème ne venait pas de gluPerspective si tu l'as résolu en liant glew
relis mon post t'expliquant qui fait quoi

après dans ton programme, il y a une grosse erreur : tu ne vérifie pas si les shaders sont supportés par ta carte
le problème venait visiblement du fait que tu n'initialisais pas glew

si le problème vient du shader lui même, je ne saurai pas te dire où
d'autant plus que le shader est contenu dans 2 fichiers :
toon.vert
toon.frag

pour ton problème de "fuite", je te conseille comme première solution d'utiliser du Pampers... :yaisse2:

seconde solution, dans Display() :
Code:

1 2 3 4 5 6 glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glRotatef(angle, 1,0,0); glRotatef(angle, 0,1,0); glRotatef(angle, 0,0,1); gluLookAt(4,3,3,0,0,0,0,1,0);
grosse erreur de mettre des glRotate avant le gluLookAt
décales donc le gluLookAt avant les glRotate et ton problème sera résolu car dans l'état les glRotate influent sur gluLookAt et font tourner la "caméra"

Me revoilà, alors maintenant, j'ai réussi à afficher une pyramide (oui j'en avait marre des cubes... ^^) qui tourne sur elle même avec le code de shader décommenté qui ne fait rien planter, par contre, le fond de la fenetre est grise, et la pyramide noire si bien, que, ne voyant qu'une silhouette, je ne sais pas si le shader fait bien son boulot... j'ai essayé de mettre de la couleur sur la pyramide, mais apparamment ça ne marche pas... Alors je me demande si j'ai crée les polygones dans le bon sens et si j'ai pas oublié une autre option quelconque pour les couleurs ? Oo

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
 
 
#include <GL/glew.h>
#include <textfile.h>
 
 
void Display();
float angle=0;
 
int main ( int argc, char** argv )
{
 
 
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 16,
                                           SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
 
//INITIALISATION glew
    glewInit();
 
//création et importation des fichiers du cel-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    char *vs = textFileRead("toon.vert");
    char *fs = textFileRead("toon.frag");
 
    const char *vv=vs;
    const char *ff=fs;
 
    glShaderSource(vertexShader, 1, &vv,NULL);
    glShaderSource(fragmentShader, 1, &ff,NULL);
 
    free(vs);free(fs);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    GLuint program;
    program = glCreateProgram();
 
    glAttachShader(program,vertexShader);
    glAttachShader(program,fragmentShader);
 
    glLinkProgram(program);
    glUseProgram(program);
 
// Initialisation d'OpenGL
 
	glEnable(GL_LIGHTING);
	glShadeModel(GL_SMOOTH);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    glClearColor(0.0f,0.0f,0.0f,0.5f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
 
    glDepthFunc(GL_LEQUAL);
 
    glViewport(0,0,800,600);
    gluPerspective(45.0,800.0/600.0,1.0,100.0); // Angle de la caméra, clipping entre 1 et 100 (pas à partir de 0,
    glMatrixMode(GL_MODELVIEW);
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);
 
 
 
 
 
 
    // program main loop
    bool Running = true;
    while (Running)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            if (event.type==SDL_QUIT){Running = false ;}
        }
 
        Display();
        if (angle>=360){angle=0;}
        angle++;
    }
    return 0;
 
}
 
 
 
 
 
void Display()
{
    glClearColor(0.5f,0.5f,0.5f,0.5f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();                // Reinitialise la vue
    glTranslatef(-1.5f,0.0f,-6.0f);  // Se deplace vers la gauche vers l'interieur de l'ecran
    glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
    glBegin(GL_TRIANGLES);
    gluLookAt(5,0,10,0,0,0,0,1,0);
 
 
 
	glBegin(GL_TRIANGLES);
        glColor3f(1,0,0);
        glVertex3i(0,2,0);
        glColor3f(1,0,0);
        glVertex3i(1,-1,1);
        glColor3f(1,0,0);
        glVertex3i(1,-1,-1);
 
        glColor3f(0,1,0);
        glVertex3i(0,2,0);
        glVertex3i(1,-1,1);
        glVertex3i(-1,-1,1);
 
        glColor3f(0,0,1);
        glVertex3i(0,2,0);
        glVertex3i(-1,-1,1);
        glVertex3i(-1,-1,-1);
 
        glVertex3i(0,2,0);
        glVertex3i(1,-1,-1);
        glVertex3i(-1,-1,-1);
 
        glVertex3i(-1,-1,-1);
        glVertex3i(-1,-1,1);
        glVertex3i(1,-1,1);
 
        glVertex3i(1,-1,1);
        glVertex3i(1,-1,-1);
        glVertex3i(-1,-1,-1);
 
	glEnd();
 
	SDL_GL_SwapBuffers( );
 
}

Et donc glu.h est bel et bien inclus par glew visiblement parce-que je n'ai plus d'erreurs venant de là... :p

Je suis encore sur mon problème, visiblement je n'arrive toujours pas à faire tourner quoi que ce soit sur place, ce qui fait que ça fonctionnait tout à l'heure est une erreur de copier collé qui à donné ça :
Code:

1 2 3 4 5 6 7 8 glClearColor(0.5f,0.5f,0.5f,0.5f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); // Reinitialise la vue glTranslatef(-1.5f,0.0f,-6.0f); // Se deplace vers la gauche vers l'interieur de l'ecran glRotatef(angle,0.0f,1.0f,0.0f); // Tourne la pyramide sur son axe Y glBegin(GL_TRIANGLES); gluLookAt(5,0,10,0,0,0,0,1,0);
Je ne sais absolument pas pourquoi cette ligne qui n'a rien à faire ici, me permet d'avoir une rotation "sur place" mais sans cette ligne, pas moyen d'y parvenir... Que'est-ce qui ne va pas d'après-vous ? Si quelqu'un à une idée...:roll:

24/11/2007, 10h23
shenron666

je vois 2 fois glBegin(GL_TIRANGLES) dans ton code :aie:

qui plus est, gluLookAt ne peux pas être appelé entre un glBegin et un glEnd, ça génère une erreur et la commande n'est pas exécutée

pour ton shader, sans le code on ne peux pas t'aider ;)

Ok, pas de problème je balance le code en intégralité ^^ Pour la redondance du glBegin(GL_TRIANGLES); c'est justement pour ça que je postait... Enfait, avec cette redondance totalement involontaire la pyramide tournait bien en face de la caméra et sans... bah elle fuit... :P C'est pour ça que je n'y comprend rien :s

Alors voilà le code dans son intégralité (à la base c'est un code pour m'entrainer, alors l'absence des tests de réussite pour les fonctions shader est volontaire... Ma carte les supportant de toute façon..)

main.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
 
 
#include <GL/glew.h>
#include <textfile.h>
 
 
void Display();
float angle=0;
 
int main ( int argc, char** argv )
{
 
 
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 32,
                                           SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
 
//INITIALISATION glew
    glewInit();
 
//création et importation des fichiers du cel-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    char *vs = textFileRead("toon.vert");
    char *fs = textFileRead("toon.frag");
 
    const char *vv=vs;
    const char *ff=fs;
 
    glShaderSource(vertexShader, 1, &vv,NULL);
    glShaderSource(fragmentShader, 1, &ff,NULL);
 
    free(vs);free(fs);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    GLuint program;
    program = glCreateProgram();
 
    glAttachShader(program,vertexShader);
    glAttachShader(program,fragmentShader);
 
    glLinkProgram(program);
 
// Initialisation d'OpenGL
 
	glEnable(GL_LIGHTING);
	glShadeModel(GL_SMOOTH);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    glClearColor(0.0f,0.0f,0.0f,0.0f);
    glClearDepth(1.0f);
    glEnable(GL_DEPTH_TEST);
 
    glDepthFunc(GL_LEQUAL);
 
    glViewport(0,0,800,600);
    gluPerspective(45.0,800.0/600.0,1.0,100.0); // Angle de la caméra, clipping entre 1 et 100 (pas à partir de 0,
    glMatrixMode(GL_MODELVIEW);
	glEnable(GL_LIGHT0);
 
 
 
 
 
 
    // program main loop
    bool Running = true;
    while (Running)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            if (event.type==SDL_QUIT){Running = false ;}
        }
 
//SHADER .
        glUseProgram(program);
        glEnable (GL_CULL_FACE);
        glFrontFace (GL_CW);
 
        // Draw front-facing polygons as filled using toon shader
        glPolygonMode (GL_FRONT, GL_FILL);
        glDepthFunc (GL_LESS);
        glCullFace (GL_BACK);
 
        Display();
 
        glUseProgram(0);
 
        // Draw back-facing polygons as black lines using standard OpenGL
        glLineWidth (5.0f);
        glPolygonMode (GL_BACK, GL_LINE);
        glDepthFunc (GL_LEQUAL);
        glCullFace (GL_FRONT);
        glColor3f (0.0f, 0.0f, 0.0f);
        Display();
 
        glLineWidth (1.0f);
        //glDepthFunc (GL_LESS);
        //glPolygonMode (GL_BACK, GL_FILL);
 
 
        if (angle>=360){angle=0;}
        angle++;
    }
    return 0;
 
}
 
 
 
 
 
void Display()
{
    glMatrixMode(GL_MODELVIEW);
    glClearColor(0.5f,0.5f,0.5f,0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();              // Reinitialise la vue
    glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
    gluLookAt(0,0.3,10,0,0,0,0,1,0);
 
//Les 4 faces de la pyramide
	glBegin(GL_TRIANGLES);
        glVertex3i(0,2,0);
        glVertex3i(1,-1,1);
        glVertex3i(1,-1,-1);
 
        glVertex3i(0,2,0);
        glVertex3i(-1,-1,1);
        glVertex3i(1,-1,1);
 
        glVertex3i(0,2,0);
        glVertex3i(-1,-1,-1);
        glVertex3i(-1,-1,1);
 
        glVertex3i(0,2,0);
        glVertex3i(1,-1,-1);
        glVertex3i(-1,-1,-1);
	glEnd();
 
//Base de la pyramide
    glBegin(GL_QUADS);
        glVertex3i(-1,-1,-1);
        glVertex3i(-1,-1,1);
        glVertex3i(1,-1,1);
        glVertex3i(1,-1,-1);
	glEnd();
 
	SDL_GL_SwapBuffers( );
 
}

toon.frag

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//
// Fragment shader for cartoon-style shading
//
// Author: Philip Rideout
//
// Copyright (c) 2004 3Dlabs Inc. Ltd.
//
// See 3Dlabs-License.txt for license information
//
 
uniform vec3 DiffuseColor;
uniform vec3 PhongColor;
uniform float Edge;
uniform float Phong;
varying vec3 Normal;
 
void main (void)
{
	vec3 color = DiffuseColor;
	float f = dot(vec3(0,0,1),Normal);
	if (abs(f) < Edge)
		color = vec3(0);
	if (f > Phong)
		color = PhongColor;
 
	gl_FragColor = vec4(color, 1);
}

toon.vert

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//
// Vertex shader for cartoon-style shading
//
// Author: Philip Rideout
//
// Copyright (c) 2004 3Dlabs Inc. Ltd.
//
// See 3Dlabs-License.txt for license information
//
 
varying vec3 Normal;
 
void main(void)
{
	Normal = normalize(gl_NormalMatrix * gl_Normal);
	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

(je précise que ces deux fichiers de GLSL sont les exemples fournis avec le logiciel Shader Designer de Typhoon.)

textfile.h

Code:

1
2
3
4
5
6
7
8
9
10
// textfile.h: interface for reading and writing text files
// www.lighthouse3d.com
//
// You may use these functions freely.
// they are provided as is, and no warranties, either implicit,
// or explicit are given
//////////////////////////////////////////////////////////////////////
 
char *textFileRead(char *fn);
int textFileWrite(char *fn, char *s);

(ce dernier est également tiré d'un tutoriel d'internet)

24/11/2007, 17h35
Marco17

1 pièce(s) jointe(s)

Je post aussi un screen pour montrer ce que j'obtiens...
Les deux images sont en réalité affichées l'une après l'autre très rapidement ce qui donne un effet de grillage et on voit la pyramide à moitié transparente tourner autour de la caméra (elle passe devant la caméra du bord droit vers le bord gauche de la fenêtre...)
24/11/2007, 21h50
shenron666

Citation:

Envoyé par Marco17

Ok, pas de problème je balance le code en intégralité ^^ Pour la redondance du glBegin(GL_TRIANGLES); c'est justement pour ça que je postait... Enfait, avec cette redondance totalement involontaire la pyramide tournait bien en face de la caméra et sans... bah elle fuit... :P C'est pour ça que je n'y comprend rien :s

si tu ne lis pas mes réponses je vais me facher :cry:

Citation:

Envoyé par shenron666

grosse erreur de mettre des glRotate avant le gluLookAt
décales donc le gluLookAt avant les glRotate et ton problème sera résolu car dans l'état les glRotate influent sur gluLookAt et font tourner la "caméra"

pour les shaders je regarde mais comme je ne suis pas spécialement calé en glsl il va me faloir un peu de temps ;)

:oops: Merci, de me le rappeller, en fait je l'avais pris en compte, d'ailleurs pendant un temps le problème etait résolu puis, comme j'ai par la suite réutilisé des bouts de code à droite à gauche j'ai du coller un truc avec le gluLookAt derrière par dessus la précédente correction... :s Donc effectivement ça c'est résolu... Merci beaucoup ! La pyramide reste bien sur place, et j'ai réussi aussi à enlever le phénomène de clignotement qui était dû si je me souvient bien au fait que j'appelle deux fois Display(), et qu'il y a un SDL_GL_SwapBuffers() dans chaque...

Donc dans l'état actuel du problème, j'ai une pyramide qui tourne sur place au centre de mon champ de vision, par contre... Là ou je ne comprend rien maintenant c'est le problème de couleurs... :/ J'ai une pyramide dont les arrêtes devraient me semble t-il être en noir et les faces colorées en rouge et en fait j'ai les arrêtes blanches et les faces noires...

Je repost le code tel qu'il est maintenant, dans l'espoir que quelqu'un pourra m'expliquer ce qui bugge...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#ifdef __cplusplus
    #include <cstdlib>
#else
    #include <stdlib.h>
#endif
#ifdef __APPLE__
#include <SDL/SDL.h>
#else
#include <SDL.h>
#endif
 
 
#include <GL/glew.h>
#include <textfile.h>
 
 
void Display();
float angle=0;
 
int main ( int argc, char** argv )
{
 
 
    // initialize SDL video
    if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
    {
        printf( "Unable to init SDL: %s\n", SDL_GetError() );
        return 1;
    }
 
    // make sure SDL cleans up before exit
    atexit(SDL_Quit);
 
    // create a new window
    SDL_Surface* openGLContext = SDL_SetVideoMode(640, 480, 32,
                                           SDL_OPENGL);
    if ( !openGLContext )
    {
        printf("Unable to set 640x480 video: %s\n", SDL_GetError());
        return 1;
    }
 
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
 
//INITIALISATION glew
    glewInit();
 
//création et importation des fichiers du cel-shading
    GLuint fragmentShader;
    GLuint vertexShader;
    vertexShader = glCreateShader(GL_VERTEX_SHADER);
	fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
 
    char *vs = textFileRead("toon.vert");
    char *fs = textFileRead("toon.frag");
 
    const char *vv=vs;
    const char *ff=fs;
 
    glShaderSource(vertexShader, 1, &vv,NULL);
    glShaderSource(fragmentShader, 1, &ff,NULL);
 
    free(vs);free(fs);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    GLuint program;
    program = glCreateProgram();
 
    glAttachShader(program,vertexShader);
    glAttachShader(program,fragmentShader);
 
 
    glLinkProgram(program);
 
// Initialisation d'OpenGL
 
	glEnable(GL_LIGHTING);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
	glEnable(GL_LIGHT0);
    //glClearColor(0.0f,0.0f,0.0f,0.0f);
    //glClearDepth(1.0f);
    //glEnable(GL_DEPTH_TEST);
 
    //glDepthFunc(GL_LEQUAL);
 
    glViewport(0,0,800,600);
    gluPerspective(45.0,800.0/600.0,1.0,100.0); // Angle de la caméra, clipping entre 1 et 100 (pas à partir de 0,
    glMatrixMode(GL_MODELVIEW);
 
 
    // program main loop
    bool Running = true;
    while (Running)
    {
        // message processing loop
        SDL_Event event;
        while (SDL_PollEvent(&event))
        {
            if (event.type==SDL_QUIT){Running = false ;}
        }
 
 
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glClearColor(0.5,0.5,0.5,0.5);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();// Reinitialise la vue
        gluLookAt(0,0,10,0,0,0,0,1,0);
        glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
 
 
// Draw front-facing polygons as filled using toon shader
        glUseProgram(program);
        glClearDepth( 1.0);
        glEnable (GL_CULL_FACE);
        glFrontFace (GL_CW);
        glPolygonMode (GL_FRONT, GL_FILL);
        glDepthFunc (GL_LESS);
        glCullFace (GL_BACK);
        glColor3f(1,0,0);
        Display();
 
// Draw back-facing polygons as black lines using standard OpenGL
        glUseProgram(0);
        glLineWidth (5.0f);
        glPolygonMode (GL_BACK,GL_LINE);
        glDepthFunc (GL_LEQUAL);
        glCullFace (GL_FRONT);
        glColor3f (0.0f, 0.0f, 0.0f);
        Display();
 
        glLineWidth (1.0f);
        glDepthFunc (GL_LESS);
        glPolygonMode (GL_BACK, GL_FILL);
        glDisable(GL_CULL_FACE);
        glFrontFace(GL_CCW);
 
 
//Increment angle value, and swap buffers
        if (angle>=360){angle=0;}
        angle++;
        SDL_GL_SwapBuffers( );
    }
    return 0;
 
}
 
 
 
 
 
void Display()
{
    glBegin( GL_TRIANGLES );
 
	 glVertex3f( 0.0, 1.0, 0.0);
	 glVertex3f(-1.0,-1.0, 1.0);
	 glVertex3f( 1.0,-1.0, 1.0);
 
	 glVertex3f( 0.0, 1.0, 0.0);
	 glVertex3f( 1.0,-1.0, 1.0);
	 glVertex3f( 1.0,-1.0, -1.0);
 
	 glVertex3f( 0.0, 1.0, 0.0);
	 glVertex3f( 1.0,-1.0, -1.0);
	 glVertex3f(-1.0,-1.0, -1.0);
 
	 glVertex3f( 0.0, 1.0, 0.0);
	 glVertex3f(-1.0,-1.0,-1.0);
	 glVertex3f(-1.0,-1.0, 1.0);
 
     glEnd();
 
     glBegin( GL_QUADS );
 
	 glVertex3f( 1.0,-1.0,-1.0);
	 glVertex3f( 1.0,-1.0, 1.0);
	 glVertex3f(-1.0,-1.0, 1.0);
	 glVertex3f(-1.0,-1.0,-1.0);
 
     glEnd();
}

24/11/2007, 23h26
shenron666

vu la cature d'écran que tu as posté, tes faces semblent inversées
j'ai l'impression qu'on voit l'intérieur de ta pyramide
pas certain que ça soit la source de ton probème mais on ne sait jamais
25/11/2007, 01h43
Marco17

En fait, c'est ce que je me disait aussi alors j'ai changé de pyramide dans mon code j'en ai chopé une sur internet :P Les faces sont correctement écrites maintenant :)

Ca y est, j'ai finalement tout résolu ou presque... En fait, mon problème de couleurs est dû au fait que je ne sais pas encore gérer les lumières en OpenGL :aie: donc forcément sans lumières ou avec des lumières mal gérées, et bah j'ai une pyramide qui est telle qu'elle est... Donc j'ai juste une dernière petite question... :mouarf:

Quelqu'un connaît-il un bon tutoriel ou un bon cours sur les lumières d'OpenGL ?

PS : Merci encore pour toutes tes réponses Shenron666
25/11/2007, 09h53
shenron666

en cherchant sur le net tu trouveras quelques tutos en anglais principalement sur l'éclairage opengl
sur developpez, il y a les articles de nehe qui ont étés traduits :
Les filtres et l'éclairage

sinon globalement, la première chose que tu auras à faire pour gérer l'éclairage, sera d'ajouter des normales aux sommets de ta pyramide
ensuite il faudra :
- créer une lumière (voir la doc de glLightfv)
- activer cette lumière avec glEnable
- activer l'éclairage avec glEnable(GL_LIGHTING)
25/11/2007, 11h34
Marco17

Ok, merci bien, je vais me documenter là dessus ! :P