utilisation GLSL -- HeLP!

Version imprimable

Voir 40 message(s) de cette discussion en une page

Hello à tous!

Voici mon problème, peut-être une âme charitable saura-t-elle m'aider.
Je test un moteur de rendu C++/GLUT/GLEW/OpenGL pour un petit jeu que je veux commencer. Pour ça je veux rajouter les shaders GLSL.

J'ai créer une classe de shader qui charge, active, désactive, et se charge de la communication openGl<-->shader. Tout ça avec un errorlog pour suivre ce qui se passe.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class CShader
{
public:
// Sauvegarde le l’objet OpenGL identifiant le programme
    GLhandleARB ShaderProg;
    bool isOK;
 
    // Chargement des fichiers textes contenant le code GLSL
    char* _Load(const char* szFilename);
 
    CShader();
    CShader (char* vscript, char* fscript);
    ~CShader();
 
    // Activation du shader
    void Enable();
    // Deactivation du shader
    void Disable();
    // Récupération de l’identifiant d’une variable uniform
    unsigned int Uniform(const char* szNameVar) const;
    // Récupération de l’identifiant d’une variable d’attribut
    unsigned int Attrib(const char* szNameVar) const;
};

Mon problème:
J'ai les scriptes pour un vertex et fragment shaders basiquissimes qui sont: ouverts, compilés, attaché au prog et le prog lié sans problème. Pas de message d'erreur dans ce processus. 8-)

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
CShader::CShader (char* vscript, char* fscript)
{
    ShaderProg = 0;
    isOK = false;
 
    GLhandleARB v, f;
 
    v = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
	f = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
	ShaderProg = glCreateProgramObjectARB();
 
    errorLog="GLSL:";
 
    FILE *fp;
    GLcharARB *shader_string;
    GLint str_length, maxLength;
    GLcharARB *pInfoLog;
    GLint isCompiled = GL_FALSE, isLinked = GL_FALSE;
 
    // open the file of shader source code
    if((fp=fopen(vscript, "r")) == NULL) {
     errorLog += "failed to load vertex script.";
     } else {
     errorLog  += "vertex script open. ";
 
    // allocate memory for program string and load it.
    shader_string = (GLcharARB*) malloc(sizeof(GLcharARB) * 65536);
    str_length = (GLint) fread(shader_string, 1, 65536, fp);
    fclose(fp);
 
    glShaderSourceARB(v, 1, (const GLcharARB**)&shader_string, &str_length);
    free(shader_string);
 
    glCompileShaderARB(v);
 
    // get compile state information
    glGetObjectParameterivARB(v, GL_OBJECT_COMPILE_STATUS_ARB, &isCompiled);
 
    if (!isCompiled) {
        errorLog += "error compiling vertex script.";
        glGetObjectParameterivARB(v, GL_OBJECT_INFO_LOG_LENGTH_ARB, &maxLength);
        pInfoLog = (GLcharARB *) malloc(maxLength * sizeof(GLcharARB));
        glGetInfoLogARB(v, maxLength, &str_length, pInfoLog);
        errorLog += pInfoLog;
        free(pInfoLog);
    } else {
       errorLog += "compiled. ";
       glAttachObjectARB(ShaderProg, v);
       errorLog += "attached. ";
      // glDeleteObjectARB(v);
 
       // à ce point le vertex shader est ok, on continue avec le fragment shader
 
       if((fp=fopen(fscript, "r")) == NULL) {
        errorLog += "failed to load fragment script.";
        } else {
        errorLog  += "fragment script open. ";
        // allocate memory for program string and load it.
        shader_string = (GLcharARB*) malloc(sizeof(GLcharARB) * 65536);
        str_length = (GLint) fread(shader_string, 1, 65536, fp);
        fclose(fp);
 
        glShaderSourceARB(f, 1, (const GLcharARB**)&shader_string, &str_length);
        free(shader_string);
 
        glCompileShaderARB(f);
 
        // get compile state information
        isCompiled = GL_FALSE;
        glGetObjectParameterivARB(f, GL_OBJECT_COMPILE_STATUS_ARB, &isCompiled);
 
        if (!isCompiled) {
        errorLog += "error compiling fragment script.";
        glGetObjectParameterivARB(f, GL_OBJECT_INFO_LOG_LENGTH_ARB, &maxLength);
        pInfoLog = (GLcharARB *) malloc(maxLength * sizeof(GLcharARB));
        glGetInfoLogARB(f, maxLength, &str_length, pInfoLog);
        errorLog += pInfoLog;
        free(pInfoLog);
        } else {
        errorLog += "compiled. ";
        glAttachObjectARB(ShaderProg, f);
        errorLog += "attached. ";
       // glDeleteObjectARB(f);
        isOK = true;
        }
 
        }
    }
   }
 
   if(isOK){
	glLinkProgramARB(ShaderProg);
	glGetObjectParameterivARB(ShaderProg, GL_OBJECT_LINK_STATUS_ARB, &isLinked);
 
    if(!isLinked)
    {
    errorLog += "error linking program. ";
    glGetObjectParameterivARB(ShaderProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, &maxLength);
    pInfoLog = (GLcharARB *) malloc(maxLength * sizeof(GLcharARB));
    glGetInfoLogARB(ShaderProg, maxLength, &str_length, pInfoLog);
    errorLog += pInfoLog;
    free(pInfoLog);
    isOK = false;
    } else
     errorLog += "Program linked.";
 
   }
};

L'horreur commence quand je veux m'en servir. Dans ma fonction de display, j'ai beau utiliser glUseProgramObjectARB(monShaderProgram) ... rien ne se passe et le rendu de mes objets n'est pas modifié. :aie:

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
void Scene::renderScene(void) {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glPushMatrix();
 
	glRotatef(angle,0.0,1.0,0.0);
 
 
//	glColor3f(baseColor.r,baseColor.g,baseColor.b);
 
    // fog
    //glEnable(GL_FOG);
 
    // rendering des meshs
 
    glEnable(GL_LIGHTING);
    glColor3f(1.0,1.0,1.0);
 
    glDisable( GL_TEXTURE_2D );
 
    shader[0].Enable(); // <--- active le shaderprog
 
    floor.render(zoom*100); //fait un rendu en triangle de l'objet
 
    mesh.render(zoom*1000);//fait un rendu en triangle de l'objet
 
	glPopMatrix();
	angle++;
 
    // texte
	glDisable( GL_TEXTURE_2D );
	glDisable(GL_LIGHTING);
    glDisable(GL_DEPTH_TEST);
 
	setOrthographicProjection();
	glPushMatrix();
	glLoadIdentity();
 
 
    glColor3f(1.0,1.0,1.0);
    char s[260] ;
 
    s[0] = '\0';
    strcat(s, errorLog.c_str());
    renderBitmapString(5,110,0,GLUT_BITMAP_HELVETICA_10,s);
 
	renderBitmap(0,0,h-100,100,70, 1);
 
	glPopMatrix();
	resetPerspectiveProjection() ;
    glEnable( GL_TEXTURE_2D );
    glEnable(GL_LIGHTING);
    glEnable(GL_DEPTH_TEST);
 
	glutSwapBuffers();
};

Que faire... ?? Heeeeeelp, donc!
Merci d'avance pour le coup de main. :lol:

03/07/2007, 13h44
Laurent Gomila

Une bonne chose à faire pour commencer serait de vérifier les erreurs (glGetError) après chaque appel OpenGL.
04/07/2007, 09h58
filoo

Suite des tests... pas mieux

Merci Laurent de ta réponse rapide !

J'ai poursuivit les tests selon ton conseil, un appel à glGetError après chaque appel OpenGL ... et pas une seule erreur dans tout le programme. 8O

Quelqu'un aurait-il une idée pour faire marcher ce bazaar?

Merci d'avance!

PS: je rame là...
04/07/2007, 10h08
filoo

1 pièce(s) jointe(s)

screenshot

Je joint même un screenshot de ce que ça donne sans ... et malheureusement avec, l'appel au shaders...

Pour l'inspiration...

http://www.developpez.net/forums/att...1&d=1183536448
04/07/2007, 10h18
Laurent Gomila

Et le shader il ressemble à quoi ?

les shaders

J'ai testé avec le plus basique possible...

Le vertex shader simple
Code:

1 2 3 4 5 6 void main() { vec4 p; gl_Position = gl_ModelViewProjectionMatrix * p; }
Le fragment shader simple
Code:

1 2 3 4 5 void main() { gl_FragColor = vec4(0.0,0.8,0.0,1.0); }

04/07/2007, 10h47
Laurent Gomila
Citation:
Code:

1 2 3 4 5 void main() { vec4 p; gl_Position = gl_ModelViewProjectionMatrix * p; }
C'est quoi p ? Si tu veux un code minimal écris plutôt ceci :
Code:

1 2 3 4 void main() { gl_Position = ftransform(); }
Rien à dire par contre en ce qui concerne le fragment shader.
04/07/2007, 11h00
filoo

oups...

Citation:

C'est quoi p ? Si tu veux un code minimal écris plutôt ceci :

euh...:oops:, sais pas ce que c'est que ce p... issu d'un tutorial et décrit comme code minimal...

J'ai testé avec ce nouveau code de vertex shader... pas mieux. Rien ne bouge.
04/07/2007, 11h04
filoo

bloqué... encore...

Laurent, as-tu une idée d'où mon code peut bloquer?

Parce que là, je ne vois pas. Avec ce frag shader les fragments devrait être affichés de couleur unie... et surtout pas éclairé ni rendu avec cet espèce de flat shading de base...

Ca veut dire que mon program shader n'est pas prit en compte et qu'il n'est pas intégré dans le pipeline à la place de celui par défaut...

Aaaaarg... OpenGL c'est beau, c'est grand, c'est surement puissant... mais le codeur que je suis est tout petit quand ça marche pas... :cry:
04/07/2007, 12h25
bafman

on peut voir comment tu enable les shader ?

Ton vertex shader en effet il faut faire glPosition = ftransform(), ou soit, si tu ne souhaites pas utiliser la fonction, c'est gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

Sinon, je comprends pas, mais tu sembles utiliser des fonctions plus anciennes, moi perso je ferai ça. D'abord dans ta fonction d'initialisation :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 // Création des objets GLuint vertexShader, fragmentShader; vertexShader = glCreateShader (GL_VERTEX_SHADER); fragmentShader = glCreateShader (GL_FRAGMENT_SHADER); // Ensuite tu récupères les sources de tes vertex et fragment shader sous la // forme d'une chaîne de caractère de type const char * glShaderSource (vertexShader, 1, &vertexSource, NULL); glShaderSource (fragmentShader, 1, &fragmentSource, NULL); // Compilation des shaders glCompileShader (vertexShader); glCompileShader (fragmentShader); // Création du programme GLuint programShader; programShader = glCreateProgram(); // On attache les shaders au programme glAttachShader (programShader, vertexShader); glAttachShader (programShader, fragmentShader); // On link le programme glLinkProgram (programShader);
Dans ta fonction de dessin :

Citation:

glUseProgram (programShader);

Tu n'as aucune variable uniform à spécifier, donc ce n'est pas très dur.

NB : n'oublie pas de tout nettoyer à la fin du programme.

comment j'enable les shaders...

Voilà comment je fais...
Après avoir crée la fenêtre GLUT
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 GLenum err = glewInit(); if (GLEW_OK != err) { exit(1); // Problem: glewInit failed, something is seriously wrong } // GLSL shaders if (GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader && GL_ARB_shader_objects) glARBshaders = true; else { exit(1); } if (glewIsSupported("GL_VERSION_2_0")) glVersion2 = false; else glVersion2 = true;
Puis, en début de program à la création de ma scène, je crée une nouvelle instance de shader. (selon la class et la fonction d'initialisation ci-dessus)

CShader shader("chemin vers le code vertex", "chemin vers le code frag");

// cette fonction lit le fichier, le joint comme source ARB, le compile puis l'attach au program créé et finalement link le program.

dans la fonction display:

shader.enable(); // = glUseProgramARB(ShaderProg)
mesh.render();
shader.disable(); // = glUseProgramARB (0)

Voilà. Est-ce que j'oublie quelque chose dans l'histoire?

04/07/2007, 12h49
filoo

troubleshooting

J'ai même testé la valeur du handle au shader program avant glUseProgramARB...

la valeur est supérieur à 0, donc valide. (dans l'exemple elle vaut 3).

Je résume les tests:
1. GLEW s'initialise ok.
2. les objets, vertex et frag shaders sont supportés par ma carte graphique et GLEW, pas d'erreur.
3. les vertex et frag shaders sont lu, compilés, attaché au prog qui est linké sans erreur.
4. le handle du prog est valide.
5. dans tout ce processus jusqu'à l'affichage, pas d'erreur OpenGL.

... :( consternation... bug mystique ou élément manquant?
04/07/2007, 12h52
Bakura

Et en faisant ce que j'ai dit plus haut ? Et question conne mais... ta carte graphique supporte les shaders ?
04/07/2007, 13h11
filoo

Merci Bakura...

J'ai remplacé ma function d'initilisation des shaders par la tienne...
Ca roule, pas d'erreur.

Mais toujours rien ne s'affiche.

Et oui, ma carte graphique accepte les shaders. (GForce 6200)

Une autre idée?

Bizarre... As-tu bien vérifié que les chaînes de caractères que tu passent à la fonction contiennent bien tes vertex et fragment shaders (mais si ça te sors pas d'erreur logiquement c'est bon)...

Essaye avec cette classe toute simple :

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
class Cube
{
 
	public:
		Cube ()
		{
			// Création des shaders
			vertexShader = glCreateShader (GL_VERTEX_SHADER);
			fragmentShader = glCreateShader (GL_FRAGMENT_SHADER);
 
			// Ouvre tes fichiers vertex et fragment shaders sous la    
                        //forme d'une string
 
			const char * t1 = vertexSource.c_str();
			const char * t2 = fragmentSource.c_str();
 
			glShaderSource (vertexShader, 1, &t1, NULL);
			glShaderSource (fragmentShader, 1, &t2, NULL);
 
			// Compilation des shaders
			glCompileShader (vertexShader);
			glCompileShader (fragmentShader);
 
			GLint valid;
			glGetShaderiv (fragmentShader, GL_COMPILE_STATUS, &valid);
 
			if (!valid)
				std::cerr << "false";
 
                        glGetShaderiv (vertexShader, GL_COMPILE_STATUS, &valid);
                         if (!valid)
                               std::cerr << "false";
 
			program = glCreateProgram();
 
			glAttachShader (program, vertexShader);
			glAttachShader (program, fragmentShader);
 
			glLinkProgram (program);
		}
 
		~Cube ()
		{
			glDeleteShader (vertexShader);
			glDeleteShader (fragmentShader);
			glDeleteProgram (program);
		}
 
	void Draw ()
	{	
		glUseProgram (program);
 
	glBegin(GL_QUADS);			
         // Devant
	 glNormal3f (0.0f, -0.0f, 1.0f);
         glVertex3f (-0.5, -0.5, 0.5);
         glVertex3f (0.5, -0.5, 0.5);
         glVertex3f (0.5, 0.5, 0.5);
         glVertex3f (-0.5, 0.5, 0.5);
 
         // Derrière
         glNormal3f (0.0f, 0.0f, -1.0f);
         glVertex3f (-0.5, -0.5, -0.5);
         glVertex3f (-0.5, 0.5, -0.5);
         glVertex3f (0.5, 0.5, -0.5);
         glVertex3f (0.5, -0.5, -0.5);
 
         // Haut
         glNormal3f (0.0f, 1.0f, 0.0f);
         glVertex3f (-0.5, 0.5, -0.5);
         glVertex3f (-0.5, 0.5,  0.5);
         glVertex3f (0.5, 0.5, 0.5);
         glVertex3f (0.5, 0.5, -0.5);
 
         // Bas
         glNormal3f (0.0f, -1.0f, 0.0f);
         glVertex3f (-0.5, -0.5, -0.5);
         glVertex3f (0.5, -0.5, -0.5);
         glVertex3f (0.5, -0.5, 0.5);
         glVertex3f (-0.5, -0.5, 0.5);
 
         // Droite
         glNormal3f (1.0f, 0.0f, 0.0f);
         glVertex3f (0.5, -0.5, -0.5);
         glVertex3f (0.5, 0.5, -0.5);
         glVertex3f (0.5, 0.5, 0.5);
         glVertex3f (0.5, -0.5, 0.5);
 
         // Gauche
         glNormal3f (-1.0f, 0.0f, 0.0f);
         glVertex3f (-0.5, -0.5, -0.5);
         glVertex3f (-0.5, -0.5, 0.5);
         glVertex3f (-0.5, 0.5, 0.5);
         glVertex3f (-0.5, 0.5, -0.5);
	glEnd ();
		}
 
	public:
		GLuint vertexShader;
		GLuint fragmentShader;
 
		GLuint program;
};

EDIT : copie tout ça dans un fichier, par exemple Cube.hpp, et test directement. Chez moi en tout cas ça marche bien.

04/07/2007, 14h32
bafman

heu... si ton enable ne fait qu'un glUseProgram mais pas de glEnable, forcement, ca ne va pas utiliser les shader :?
04/07/2007, 15h17
Laurent Gomila

glEnable avec quel paramètre ? Moi j'en n'ai pas dans mon code.
04/07/2007, 15h25
bafman

pof pof pof... derriere toi, un singe à trois têtes :mouarf:
en fait, pas besoin de glEnable pour les shader, c'est pour les vertex/fragment program qu'il faut en mettre :oops:
05/07/2007, 00h27
Yno
Citation:

Envoyé par Bakura

Sinon, je comprends pas, mais tu sembles utiliser des fonctions plus anciennes,

C'est pour les versions plus anciennes de GLEW. Je crois que les notations avec "ObjectARB" font parti de "l'ancienne implémentation".

Citation:

Mais toujours rien ne s'affiche.

Avec un tel pixel shader, ce n'est pas très étonnant :aie:

Essaies plutôt ce duo :
Code:

1 2 3 4 5 6 // vertex shader void main(void) { gl_FrontColor = gl_Color; gl_Position = ftransform(); }
Code:

1 2 3 4 5 // pixel shader void main(void) { gl_FragColor = gl_Color; }
Mais sinon : quel résultat obtiens-tu exactement ? As-tu activé le lighting ?

Voir 40 message(s) de cette discussion en une page