utilisation GLSL -- HeLP!

**filoo** · 03/07/2007, 11h48

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 :

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

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

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

**Laurent Gomila** · 03/07/2007, 13h44

Une bonne chose à faire pour commencer serait de vérifier les erreurs (glGetError) après chaque appel OpenGL.

**filoo** · 04/07/2007, 09h58

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.

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

Merci d'avance!

PS: je rame là...

**filoo** · 04/07/2007, 10h08

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

Pour l'inspiration...

**Laurent Gomila** · 04/07/2007, 10h18

Et le shader il ressemble à quoi ?

**filoo** · 04/07/2007, 10h32

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

Le vertex shader simple

Code :

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

1
2
3
4
5
6
void main()
{    
   vec4 p;
 
    gl_Position = gl_ModelViewProjectionMatrix * p;
}

Le fragment shader simple

Code :

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

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

**Bakura** · 05/07/2007, 18h12

Rhaaa j'ai écrit mon premier shader sans l'aide du livre

.
Je suis allé voir dans mon bouquin de math les formules pour calculer les composantes specular, diffuse et ambient, et j'ai codé tout ça, et ça marche bien !

Quel plaisir de pouvoir faire de l'éclairage basique, mais sans avoir glEnable (GL_LIGHTING). Tout à la main

!

Bon c'est pas un éclairage terrible terrible, juste comme celui implémenté de base dans OpenGL, mais c'est vraiment puissant ces shaders !

utilisation GLSL -- HeLP!

OpenGL

Vue hybride

Discussions similaires

Partager

Partager