Discussion :

[KevinduC]

Bonjour, je suis entrain de suivre un tuto sur les shaders et je suis déjà bloqué : J'essaie de récupérer l'id d'une variable globale de mon vertex shader avec glGetUniformLocation() mais quoi que je fasse, cette variable renvoie -1. Pourtant, mon programme est bien rattaché à mes shaders, il n'y a aucune erreur de compilation GLSL et le nom de ma variable est bien envoyé à glGetUniformLocation(), c'est un copier-coller !

Voici mon main côté OpenGL :

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
int main(int argc,char *argv[])
{
    SDL_Event evenement;
    GLuint programShader;
 
    if(SDL_Init(SDL_INIT_VIDEO)<0)
        return 0;
 
    putenv("SDL_VIDEO_CENTERED=1");
    SDL_SetVideoMode(800,600,32,SDL_OPENGL);
 
    if(glewInit()!=GLEW_OK)
    {
        printf("Erreur initialisation GLEW, presser une toucher pour quitter");
        getch();
        SDL_Quit();
        return 0;
    }
 
    programShader=chargeShaders();		//Chargement shaders
    if(programShader==0)			//En cas d'erreur de chargement ou de compilation
    {
        SDL_Quit();
        return 0;
    }
 
    GLint varShader=glGetUniformLocation(programShader,"variable");
    printf("%d\n",varShader);		//Ici ça m'affiche sans cesse -1
 
    while(1)
    {
        SDL_PollEvent(&evenement);
        if(evenement.type==SDL_QUIT)
            break;
 
        //glUniform3f(varShader,0.5,1.2,2.4);
 
        SDL_GL_SwapBuffers();
        glFlush();
    }
 
    SDL_Quit();
    return 0;
}

Voici la fonction chargeShaders() :

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
GLuint chargeShaders(void)
{
    char *vertexSource;
    char *fragmentSource;
    GLuint vertexShader;
    GLuint fragmentShader;
    GLuint programID;
    int vertexSize;
    int fragmentSize;
 
    vertexSource=lectureFichierShader("InitShaders/simple.vert");
    if(vertexSource==NULL)
        return 0;
 
    fragmentSource=lectureFichierShader("InitShaders/simple.frag");
    if(fragmentSource==NULL)
        return 0;
 
    vertexShader=glCreateShader(GL_VERTEX_SHADER);       //Création shaders
    fragmentShader=glCreateShader(GL_FRAGMENT_SHADER);
 
    if(vertexShader==0)
    {
        printf("Erreur creation vertex shader, presser une touche pour quitter");
        getch();
        return 0;
    }
 
    if(fragmentShader==0)
    {
        printf("Erreur creation fragment shader, presser une touche pour quitter");
        getch();
        return 0;
    }
 
    glShaderSource(vertexShader,1,&vertexSource,NULL);
    glShaderSource(fragmentShader,1,&fragmentSource,NULL);
 
    free(vertexSource);
    free(fragmentSource);
 
    glCompileShader(vertexShader);
    glCompileShader(fragmentShader);
 
    if(!verifCompilShader(vertexShader))
        return 0;
 
    if(!verifCompilShader(fragmentShader))
        return 0;
 
    programID=glCreateProgram();
 
    glAttachShader(programID,vertexShader);
    glAttachShader(programID,fragmentShader);       //Liens shaders
 
    glLinkProgram(programID);
    if(!verifLiage(programID))
        return 0;
 
    glUseProgram(programID);
 
    return programID;
}

La fonction lectureFichierShader() :

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
char *lectureFichierShader(char *chemin)
{
    unsigned int tailleFichier;
    char *contenuFichier;
    FILE *fichier=fopen(chemin,"rb");
    if(fichier==NULL)
    {
        printf("Erreur chargement '%s', presser une touche pour quitter",chemin);
        getch();
        return NULL;
    }
 
    fseek(fichier,0,SEEK_END);
    tailleFichier=ftell(fichier);
    rewind(fichier);
 
    contenuFichier=(char*)malloc((tailleFichier+1)*sizeof(char));
 
    fread(contenuFichier,tailleFichier,1,fichier);
    contenuFichier[tailleFichier]='\0';
 
    fclose(fichier);
 
    return contenuFichier;
}

La fonction verifCompilShader() :

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
bool verifCompilShader(GLuint shader)
{
    GLint statut;
    char *log;
    int tailleLog;
 
    glGetShaderiv(shader,GL_COMPILE_STATUS,&statut);
    if(statut!=GL_TRUE)     //Erreur compilation
    {
        glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&tailleLog);        //Récup taille log de compilation
 
        tailleLog++;
        log=(char*)malloc(tailleLog*sizeof(char));
 
        glGetShaderInfoLog(shader,tailleLog,&tailleLog,log);
 
        printf("Erreur compilation : '%s', presser une touche pour quitter",log);
        free(log);
        getch();
        glDeleteShader(shader);
        return false;
    }
 
    return true;
}

La fonction verifLiage() :

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
bool verifLiage(GLuint programID)
{
    GLint statut;
    char *log;
    int tailleLog;
 
    glGetProgramiv(programID,GL_LINK_STATUS,&statut);
    if(statut!=GL_TRUE)
    {
        glGetProgramiv(programID,GL_INFO_LOG_LENGTH,&tailleLog);
 
        tailleLog++;
        log=(char*)malloc(tailleLog*sizeof(char));
 
        glGetProgramInfoLog(programID,tailleLog,&tailleLog,log);
 
        printf("Erreur liage programe : '%s', presser une touche pour quitter",log);
        free(log);
        getch();
        glDeleteProgram(programID);
        return false;
    }
 
    return true;
}

Voici mon vertex shader :

Code :

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

1
2
3
4
5
6
7
8
9
uniform int variable;
uniform vec3 vecteur;
 
void main(void)
{
	gl_FrontColor=gl_Color;
 
	gl_Position=gl_ModelViewProjectionMatrix*gl_Vertex;
}

Et mon fragment shader :

Code :

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

1
2
3
4
void main(void)
{
	gl_FragColor=gl_Color;
}

Bref je ne peux pas découvrir la puissance des shaders à cause d'un problème assez mystérieux. Si une âme charitable peut m'aider à débloquer cela. Merci par avance.

[KevinduC]

Personne n'aurait une idée ? Je viens de vérifier et revérifier qu'il n'y avait pas d'erreur dans le code. C'est vraiment dommage si je peux pas utiliser les shaders.

[KevinduC]

Bon et bien apparemment ça ne fonctionne vraiment pas, grosse déception je dois dire. Qu'on ne vienne plus me vanter les performances des shaders car c'est tout sauf stable ...

[Mat.M]

salut juste une remarque et sans vouloir créer de polémiques moi je n'utiliserais pas la SDL car tu n'as pas accés au pipeline de rendu.
SDL c'est bien pour les gens qui débutent et apprennent à faire des programmes informatiques , pour tâter un peu.
Mais en utilisant SDL tu ne contrôles pas ce qui se passe en coulisse à moins de modifier le code source.

Il faut faire un programme win32 et créer une fenêtre avec CreateWindow à moins d'être sous Linux...
je sais que c'est un peu compliqué la win32 mais on finit par comprendre vite et puis là tu maitrises tout le processus.
Bon c'est juste une remarque.
Sinon sur les sites concernant Open GL il doit bien y avoir de la doc.

[Kannagi]

Bon et bien apparemment ça ne fonctionne vraiment pas, grosse déception je dois dire. Qu'on ne vienne plus me vanter les performances des shaders car c'est tout sauf stable ...

Les gens ici ne sont pas a ta disposition , mais oui c'est évident que OpenGL utilisé dans la modélisation 3D ou le jeux vidéo est absolument pas stable

Voilà en reprenant ton code une version qui affiche quelque chose :

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
 
int main(int argc,char *argv[])
{
    SDL_Event evenement;
    GLuint programShader;
 
    if(SDL_Init(SDL_INIT_VIDEO)<0)
        return 0;
 
 
    SDL_SetVideoMode(800,600,32,SDL_OPENGL);
 
    if(glewInit()!=GLEW_OK)
    {
        printf("Erreur initialisation GLEW, presser une toucher pour quitter");
        SDL_Quit();
        return 0;
    }
 
    programShader=chargeShaders();		//Chargement shaders
    if(programShader==0)			//En cas d'erreur de chargement ou de compilation
    {
        SDL_Quit();
        return 0;
    }
    GLint varShader=glGetUniformLocation(programShader,"pos");
    GLint uniformId  = glGetUniformLocation(programShader, "couleur");
    printf("%d\n",uniformId);
 
 
    float vertex[8];
    float rect_w,rect_h;
 
    rect_w = 0.4;
    rect_h = 0.3;
 
    vertex[0] = rect_w;
    vertex[1] = -rect_h;
    vertex[2] = rect_w;
    vertex[3] = rect_h;
    vertex[4] = -rect_w;
    vertex[5] = -rect_h;
    vertex[6] = -rect_w;
    vertex[7] = rect_h;
 
    while(1)
    {
        SDL_PollEvent(&evenement);
        if(evenement.type==SDL_QUIT)
            break;
 
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
	glUseProgram(programShader);
 
        glUniform3f(uniformId,1.0f,1.0f,0.0f); //pour la couleur
        glUniform4f(varShader,0.0f,0,0,0.0f); //pour la position
 
        glEnableClientState( GL_VERTEX_ARRAY );
 
        glVertexPointer(2,GL_FLOAT,0,vertex);
        glDrawArrays(GL_TRIANGLE_STRIP,0,4);
 
        glDisableClientState( GL_VERTEX_ARRAY );
 
        SDL_GL_SwapBuffers();
        glFlush();
    }
 
    SDL_Quit();
    return 0;
}

Et niveau vertex shader :

Code :

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

1
2
3
4
5
6
7
8
9
 
#version 120
 
uniform vec4 pos;
 
void main(void)
{
	gl_Position=(gl_ModelViewProjectionMatrix*gl_Vertex)+pos;
}

Et niveau fragment shader :

Code :

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

1
2
3
4
5
6
7
8
9
 
#version 120
 
uniform vec3 couleur;
 
void main(void)
{
    gl_FragColor = vec4(couleur.xyz,1.0);
}

@Mat.M
Je vois pas ce que tu veux dire , parce que si tu déconseille la SDL pour gérer le fenêtrage/event de façon multi-plateforme, tu déconseille donc aussi la SFML , GLUT , GLFW aussi ?
(j'ai fait les 4 et dans le fond c'est a peu prés la même chose si c'est pour créer une fenêtre et recup les quelques events).
De plus étant sur Linux , je refuse de faire du X11

[KevinduC]

Merci, je regarderai de plus près quand je serai chez moi, resto avec des amis pour le moment ^^

[KevinduC]

Merci Kannagi, ça fonctionne parfaitement. Il y a juste une chose que je ne comprends pas : Je vois que le rendu se fait toujours dans l'appli OpenGL et (Donc toujours par le CPU si je ne dis pas de bêtises) et non dans les shaders, donc en quoi ces derniers permettent de gagner en performances ?

[Kannagi]

Et moi je ne comprend pas ce que tu dis , le rendu même sur GL1 se fait en partie coté GPU , si tu veux coder par exemple un personnage qui s'anime (via animation par squelette) tu le fait via le vertex shader , alors qu’auparavant tu serait obligé de le faire coté CPU , pareil pour les effets de particules ou autre.
De même tu veux faire de la lumière et plein d'autre effet ,tu as le fragment shader , OpenGL moderne permet juste de n'envoyer que des commandes au GPU et que lui fait tout les calculs.

[KevinduC]

Désolé je pensais qu'il fallait supprimer les glDrawArrays() ou autres pour mettre des instructions de ce genre dans les shaders mais en fait je vois qu'il n'en est rien.

Edit : Je pense mieux comprendre, si je veux effectuer des opérations lourdes comme agir sur les coordonnées de plusieurs centaines de milliers de vertices il vaut mieux utiliser un shader. Par exemple, je pourrais coder un shader qui calcule la position d'un vertex après rotation au lieu de faire glRotated()

[KevinduC]

Bon je reviens de quelques essais et il y a une chose que je ne comprends pas : Je veux spécifier une couleur différente pour chaque sommet, je crée donc un tableau de 12 float (3 paramètres par sommet) que j'utilise avec glColorPointer(). Dans le fragment shader, je me contente du code de base :

Code :

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

1
2
3
4
void main(void)
{
    gl_FragColor=gl_Color;
}

Mais le rectangle n'apparaît plus.
Si dans le shader je fais :

Code :

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

1
2
3
4
void main(void)
{
    gl_FragColor=1-gl_Color;
}

Là le rectangle apparaît blanc, ce qui démontre que tous les champs de "gl_Color" sont à 0, mais pour quelle raison ?

(N.B : Le problème se pose également si je fais un glBegin() ... glEnd())

Code de l'appli :

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
int main(int argc,char *argv[])
{
    SDL_Event evenement;
    GLuint programShader;
 
    if(SDL_Init(SDL_INIT_VIDEO)<0)
        return 0;
 
    SDL_SetVideoMode(800,600,32,SDL_OPENGL);
 
    if(glewInit()!=GLEW_OK)
    {
        printf("Erreur initialisation GLEW, presser une toucher pour quitter");
        SDL_Quit();
        return 0;
    }
 
    programShader=chargeShaders();		//Chargement shaders
    if(programShader==0)			//En cas d'erreur de chargement ou de compilation
    {
        SDL_Quit();
        return 0;
    }
 
    GLint posShader=glGetUniformLocation(programShader,"pos");
    GLint couleurShader=glGetUniformLocation(programShader,"couleur");
 
    float vertex[8];
    float rect_w,rect_h;
    float position[4]={0,0,0,0};
    float couleur[3]={1,1,0};
    float couleur2[12];
 
    rect_w=0.4;
    rect_h=0.3;
 
    vertex[0]=rect_w;
    vertex[1]=-rect_h;
    vertex[2]=rect_w;
    vertex[3]=rect_h;
    vertex[4]=-rect_w;
    vertex[5]=-rect_h;
    vertex[6]=-rect_w;
    vertex[7]=rect_h;
 
    couleur2[0]=1;
    couleur2[1]=0;
    couleur2[2]=0;
    couleur2[3]=0;
    couleur2[4]=1;
    couleur2[5]=0;
    couleur2[6]=0;
    couleur2[7]=0;
    couleur2[8]=1;
    couleur2[9]=1;
    couleur2[10]=1;
    couleur2[11]=0;
 
    while(1)
    {
        SDL_PollEvent(&evenement);
        if(evenement.type==SDL_QUIT)
            break;
 
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
 
        glUseProgram(programShader);
 
        glUniform3fv(couleurShader,1,couleur); //pour la couleur
        glUniform4fv(posShader,1,position); //pour la position
 
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_COLOR_ARRAY);
 
        glVertexPointer(2,GL_FLOAT,0,vertex);
        glColorPointer(3,GL_FLOAT,0,couleur2);
 
        glDrawArrays(GL_TRIANGLE_STRIP,0,4);
 
        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_COLOR_ARRAY);
 
        SDL_GL_SwapBuffers();
        glFlush();
    }
 
    SDL_Quit();
    return 0;
}

Je ne pense pas avoir fait d'erreur au niveau du fragment shader, c'est le code de base indiqué dans le tuto.
Ah oui autrechose aussi, j'ai essayé de réaliser une rotation avec le vertex shader mais ça a donné un résultat plutôt étrange :



Voici ce que j'ai fait au niveau du vertex shader :

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
#version 120
 
uniform vec4 pos;
uniform float angle;
 
void main(void)
{
	mat4 matriceRotation={
						 {cos(radians(angle)),-sin(radians(angle)),0,0},
						 {sin(radians(angle)),cos(radians(angle)),0,0},
						 {0,0,1,0},
						 {0,0,0,1}};
 
	gl_Position=((gl_ModelViewProjectionMatrix*gl_Vertex)+pos)*matriceRotation;
}

Et dans l'appli OpenGL j'ai fait :

Code :

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

GLint angleShader=glGetUniformLocation(programShader,"angle");

Et :

Code :

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

glUniform1f(angleShader,45);

[Kannagi]

Pour le souci de ton fragment shader , tu dois rajouter dans le vertex shader ceci :

Code :

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

1
2
 
gl_FrontColor = gl_Color;

Pour la rotation , j'aurais utilisé personnellement `glUniformMatrix4fv` , parce que si on fait 100 000 cos/sin dans le gpu , c'est tout de même moins performant que de le faire qu'une fois dans le CPU :p
Sinon elle marche correctement , mais comme ton rendu est en 800*600 , la position par exemple 0.5 en hauteur , n'est pas la même en largeur (je parle en pixel) du coup il y'a cette légère déformation et comme la Matrice gl_ModelViewProjectionMatrix est par défaut à '1' , il ne fait aucune correction.

[KevinduC]

Merci beaucoup

[KevinduC]

Et bien que dire, j'ai réussi à avoir le code des shaders de base et je peux désormais faire un rendu avec shaders, j'en ai donc profité pour coder un vertex shader effectuant une déformation de type ondulation et j'y suis parvenu :





Je comprends l'utilité des shaders : Sans ça, il aurait fallu ajouter une boucle dans le rendu pour traiter chacun des vertices et ça aurait été lourd. Tandis que là, le vertex shader permet d'ajouter l'effet en même temps que le rendu.

Bref merci beaucoup !