IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Développement 2D, 3D et Jeux Discussion :

[Shaders] Problème de localisation variable


Sujet :

Développement 2D, 3D et Jeux

  1. #1
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut [Shaders] Problème de localisation variable
    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.

  2. #2
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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.

  3. #3
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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 ...

  4. #4
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    novembre 2006
    Messages
    7 671
    Détails du profil
    Informations personnelles :
    Localisation : France, Rhône (Rhône Alpes)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : novembre 2006
    Messages : 7 671
    Points : 18 098
    Points
    18 098
    Par défaut
    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.

  5. #5
    Expert éminent
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    mai 2010
    Messages
    3 105
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : mai 2010
    Messages : 3 105
    Points : 9 752
    Points
    9 752
    Par défaut
    Citation Envoyé par KevinduC Voir le message
    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

  6. #6
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    Merci, je regarderai de plus près quand je serai chez moi, resto avec des amis pour le moment ^^

  7. #7
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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 ?

  8. #8
    Expert éminent
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    mai 2010
    Messages
    3 105
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : mai 2010
    Messages : 3 105
    Points : 9 752
    Points
    9 752
    Par défaut
    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.

  9. #9
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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()

  10. #10
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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 :

    Nom : Image.jpg
Affichages : 65
Taille : 25,1 Ko

    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);

  11. #11
    Expert éminent
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    mai 2010
    Messages
    3 105
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : mai 2010
    Messages : 3 105
    Points : 9 752
    Points
    9 752
    Par défaut
    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.

  12. #12
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    Merci beaucoup

  13. #13
    Membre régulier
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    août 2013
    Messages
    303
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : août 2013
    Messages : 303
    Points : 104
    Points
    104
    Par défaut
    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 :

    Nom : Capture1.jpg
Affichages : 51
Taille : 57,0 Ko

    Nom : Capture2.jpg
Affichages : 48
Taille : 57,7 Ko

    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 !

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 5
    Dernier message: 31/08/2005, 11h05
  2. [PERL] problème désallocation de variable
    Par LE NEINDRE dans le forum Langage
    Réponses: 11
    Dernier message: 24/08/2005, 11h07
  3. Problème d'initialisation variable tableau
    Par HeZiX dans le forum Langage
    Réponses: 3
    Dernier message: 08/06/2005, 17h30
  4. Problèmes avec les variables final
    Par casolaro dans le forum Langage
    Réponses: 7
    Dernier message: 09/12/2004, 15h29
  5. Réponses: 6
    Dernier message: 28/05/2004, 10h39

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo