Problème d'implémentation de shader GLSL

**Marco17** · 22/11/2007, 15h31

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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...

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

**Marco17** · 22/11/2007, 17h08

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.

**shenron666** · 22/11/2007, 17h40

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

**Marco17** · 23/11/2007, 13h57

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 !

**shenron666** · 23/11/2007, 15h23

glew n'inclus pas glu à ma connaissance
dans un programme opengl simple basé sur SDL + Glew j'ai :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

**Marco17** · 23/11/2007, 17h08

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ^^

Problème d'implémentation de shader GLSL

OpenGL

Vue hybride

Discussions similaires

Partager

Partager