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

OpenGL Discussion :

Problème d'implémentation de shader GLSL


Sujet :

OpenGL

  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut Problème d'implémentation de shader GLSL
    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

  2. #2
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    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.

  3. #3
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    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
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  4. #4
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    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 !

  5. #5
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    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
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  6. #6
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    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 ^^

  7. #7
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Bon en fait, avec un peu de recherche j'ai peut être réussi à intégrer les Shaders au programme, il ne plante plus, mais n'affiche même plus le cube "fuyant"...

    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
    171
    172
    173
    174
    175
    176
    #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);
     
    //INITIALISATION glew
        glewInit();
     
    //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);
     
    // Initialisation d'OpenGL
     
    	glEnable(GL_LIGHTING);
    	glEnable(GL_SMOOTH);
        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);
    	glEnable(GL_LIGHT0);
     
     
     
     
     
     
        // 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;
     
    }
     
     
     
     
     
    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( );
     
    }
    Voilà, je pige toujours pas pourquois le cube ne s'affiche plus du tout, et pourquoi dans la version précédente il fuyait...

  8. #8
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    Citation Envoyé par Marco17 Voir le message
    Bah, apparamment j'ai réglé le problème de gluPerspective... j'avais pas linké glew32.lib... Et forcément avec ça marche mieux ^^
    euh... glew32.lib et glu n'ont rien à voir l'un avec l'autre
    le problème ne venait pas de gluPerspective si tu l'as résolu en liant glew
    relis mon post t'expliquant qui fait quoi

    après dans ton programme, il y a une grosse erreur : tu ne vérifie pas si les shaders sont supportés par ta carte
    le problème venait visiblement du fait que tu n'initialisais pas glew

    si le problème vient du shader lui même, je ne saurai pas te dire où
    d'autant plus que le shader est contenu dans 2 fichiers :
    toon.vert
    toon.frag

    pour ton problème de "fuite", je te conseille comme première solution d'utiliser du Pampers...

    seconde solution, dans Display() :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    	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);
    grosse erreur de mettre des glRotate avant le gluLookAt
    décales donc le gluLookAt avant les glRotate et ton problème sera résolu car dans l'état les glRotate influent sur gluLookAt et font tourner la "caméra"
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  9. #9
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Me revoilà, alors maintenant, j'ai réussi à afficher une pyramide (oui j'en avait marre des cubes... ^^) qui tourne sur elle même avec le code de shader décommenté qui ne fait rien planter, par contre, le fond de la fenetre est grise, et la pyramide noire si bien, que, ne voyant qu'une silhouette, je ne sais pas si le shader fait bien son boulot... j'ai essayé de mettre de la couleur sur la pyramide, mais apparamment ça ne marche pas... Alors je me demande si j'ai crée les polygones dans le bon sens et si j'ai pas oublié une autre option quelconque pour les couleurs ? Oo

    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
    171
    172
    173
    174
    175
     
    #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_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
     
    //INITIALISATION glew
        glewInit();
     
    //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);
     
    // Initialisation d'OpenGL
     
    	glEnable(GL_LIGHTING);
    	glShadeModel(GL_SMOOTH);
        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);
    	glEnable(GL_LIGHT0);
    	glEnable(GL_LIGHT1);
     
     
     
     
     
     
        // 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;
     
    }
     
     
     
     
     
    void Display()
    {
        glClearColor(0.5f,0.5f,0.5f,0.5f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();                // Reinitialise la vue
        glTranslatef(-1.5f,0.0f,-6.0f);  // Se deplace vers la gauche vers l'interieur de l'ecran
        glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
        glBegin(GL_TRIANGLES);
        gluLookAt(5,0,10,0,0,0,0,1,0);
     
     
     
    	glBegin(GL_TRIANGLES);
            glColor3f(1,0,0);
            glVertex3i(0,2,0);
            glColor3f(1,0,0);
            glVertex3i(1,-1,1);
            glColor3f(1,0,0);
            glVertex3i(1,-1,-1);
     
            glColor3f(0,1,0);
            glVertex3i(0,2,0);
            glVertex3i(1,-1,1);
            glVertex3i(-1,-1,1);
     
            glColor3f(0,0,1);
            glVertex3i(0,2,0);
            glVertex3i(-1,-1,1);
            glVertex3i(-1,-1,-1);
     
            glVertex3i(0,2,0);
            glVertex3i(1,-1,-1);
            glVertex3i(-1,-1,-1);
     
            glVertex3i(-1,-1,-1);
            glVertex3i(-1,-1,1);
            glVertex3i(1,-1,1);
     
            glVertex3i(1,-1,1);
            glVertex3i(1,-1,-1);
            glVertex3i(-1,-1,-1);
     
    	glEnd();
     
    	SDL_GL_SwapBuffers( );
     
    }

    Et donc glu.h est bel et bien inclus par glew visiblement parce-que je n'ai plus d'erreurs venant de là... :p

  10. #10
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Je suis encore sur mon problème, visiblement je n'arrive toujours pas à faire tourner quoi que ce soit sur place, ce qui fait que ça fonctionnait tout à l'heure est une erreur de copier collé qui à donné ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
        glClearColor(0.5f,0.5f,0.5f,0.5f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();                // Reinitialise la vue
        glTranslatef(-1.5f,0.0f,-6.0f);  // Se deplace vers la gauche vers l'interieur de l'ecran
        glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
        glBegin(GL_TRIANGLES);
        gluLookAt(5,0,10,0,0,0,0,1,0);
    Je ne sais absolument pas pourquoi cette ligne qui n'a rien à faire ici, me permet d'avoir une rotation "sur place" mais sans cette ligne, pas moyen d'y parvenir... Que'est-ce qui ne va pas d'après-vous ? Si quelqu'un à une idée...

  11. #11
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    je vois 2 fois glBegin(GL_TIRANGLES) dans ton code

    qui plus est, gluLookAt ne peux pas être appelé entre un glBegin et un glEnd, ça génère une erreur et la commande n'est pas exécutée

    pour ton shader, sans le code on ne peux pas t'aider
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  12. #12
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Ok, pas de problème je balance le code en intégralité ^^ Pour la redondance du glBegin(GL_TRIANGLES); c'est justement pour ça que je postait... Enfait, avec cette redondance totalement involontaire la pyramide tournait bien en face de la caméra et sans... bah elle fuit... C'est pour ça que je n'y comprend rien :s

    Alors voilà le code dans son intégralité (à la base c'est un code pour m'entrainer, alors l'absence des tests de réussite pour les fonctions shader est volontaire... Ma carte les supportant de toute façon..)

    main.cpp
    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
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    #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, 32,
                                               SDL_OPENGL);
        if ( !openGLContext )
        {
            printf("Unable to set 640x480 video: %s\n", SDL_GetError());
            return 1;
        }
     
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
     
    //INITIALISATION glew
        glewInit();
     
    //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);
     
    // Initialisation d'OpenGL
     
    	glEnable(GL_LIGHTING);
    	glShadeModel(GL_SMOOTH);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
     
        glClearColor(0.0f,0.0f,0.0f,0.0f);
        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);
    	glEnable(GL_LIGHT0);
     
     
     
     
     
     
        // 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 ;}
            }
     
    //SHADER .
            glUseProgram(program);
            glEnable (GL_CULL_FACE);
            glFrontFace (GL_CW);
     
            // Draw front-facing polygons as filled using toon shader
            glPolygonMode (GL_FRONT, GL_FILL);
            glDepthFunc (GL_LESS);
            glCullFace (GL_BACK);
     
            Display();
     
            glUseProgram(0);
     
            // Draw back-facing polygons as black lines using standard OpenGL
            glLineWidth (5.0f);
            glPolygonMode (GL_BACK, GL_LINE);
            glDepthFunc (GL_LEQUAL);
            glCullFace (GL_FRONT);
            glColor3f (0.0f, 0.0f, 0.0f);
            Display();
     
            glLineWidth (1.0f);
            //glDepthFunc (GL_LESS);
            //glPolygonMode (GL_BACK, GL_FILL);
     
     
            if (angle>=360){angle=0;}
            angle++;
        }
        return 0;
     
    }
     
     
     
     
     
    void Display()
    {
        glMatrixMode(GL_MODELVIEW);
        glClearColor(0.5f,0.5f,0.5f,0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();              // Reinitialise la vue
        glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
        gluLookAt(0,0.3,10,0,0,0,0,1,0);
     
    //Les 4 faces de la pyramide
    	glBegin(GL_TRIANGLES);
            glVertex3i(0,2,0);
            glVertex3i(1,-1,1);
            glVertex3i(1,-1,-1);
     
            glVertex3i(0,2,0);
            glVertex3i(-1,-1,1);
            glVertex3i(1,-1,1);
     
            glVertex3i(0,2,0);
            glVertex3i(-1,-1,-1);
            glVertex3i(-1,-1,1);
     
            glVertex3i(0,2,0);
            glVertex3i(1,-1,-1);
            glVertex3i(-1,-1,-1);
    	glEnd();
     
    //Base de la pyramide
        glBegin(GL_QUADS);
            glVertex3i(-1,-1,-1);
            glVertex3i(-1,-1,1);
            glVertex3i(1,-1,1);
            glVertex3i(1,-1,-1);
    	glEnd();
     
    	SDL_GL_SwapBuffers( );
     
    }
    toon.frag
    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
    //
    // Fragment shader for cartoon-style shading
    //
    // Author: Philip Rideout
    //
    // Copyright (c) 2004 3Dlabs Inc. Ltd.
    //
    // See 3Dlabs-License.txt for license information
    //
     
    uniform vec3 DiffuseColor;
    uniform vec3 PhongColor;
    uniform float Edge;
    uniform float Phong;
    varying vec3 Normal;
     
    void main (void)
    {
    	vec3 color = DiffuseColor;
    	float f = dot(vec3(0,0,1),Normal);
    	if (abs(f) < Edge)
    		color = vec3(0);
    	if (f > Phong)
    		color = PhongColor;
     
    	gl_FragColor = vec4(color, 1);
    }
    toon.vert
    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
    //
    // Vertex shader for cartoon-style shading
    //
    // Author: Philip Rideout
    //
    // Copyright (c) 2004 3Dlabs Inc. Ltd.
    //
    // See 3Dlabs-License.txt for license information
    //
     
    varying vec3 Normal;
     
    void main(void)
    {
    	Normal = normalize(gl_NormalMatrix * gl_Normal);
    	gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    }
    (je précise que ces deux fichiers de GLSL sont les exemples fournis avec le logiciel Shader Designer de Typhoon.)

    textfile.h
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    // textfile.h: interface for reading and writing text files
    // www.lighthouse3d.com
    //
    // You may use these functions freely.
    // they are provided as is, and no warranties, either implicit,
    // or explicit are given
    //////////////////////////////////////////////////////////////////////
     
    char *textFileRead(char *fn);
    int textFileWrite(char *fn, char *s);
    (ce dernier est également tiré d'un tutoriel d'internet)

  13. #13
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Je post aussi un screen pour montrer ce que j'obtiens...
    Les deux images sont en réalité affichées l'une après l'autre très rapidement ce qui donne un effet de grillage et on voit la pyramide à moitié transparente tourner autour de la caméra (elle passe devant la caméra du bord droit vers le bord gauche de la fenêtre...)
    Images attachées Images attachées  

  14. #14
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    Citation Envoyé par Marco17 Voir le message
    Ok, pas de problème je balance le code en intégralité ^^ Pour la redondance du glBegin(GL_TRIANGLES); c'est justement pour ça que je postait... Enfait, avec cette redondance totalement involontaire la pyramide tournait bien en face de la caméra et sans... bah elle fuit... C'est pour ça que je n'y comprend rien :s
    si tu ne lis pas mes réponses je vais me facher
    Citation Envoyé par shenron666 Voir le message
    grosse erreur de mettre des glRotate avant le gluLookAt
    décales donc le gluLookAt avant les glRotate et ton problème sera résolu car dans l'état les glRotate influent sur gluLookAt et font tourner la "caméra"
    pour les shaders je regarde mais comme je ne suis pas spécialement calé en glsl il va me faloir un peu de temps
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  15. #15
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Merci, de me le rappeller, en fait je l'avais pris en compte, d'ailleurs pendant un temps le problème etait résolu puis, comme j'ai par la suite réutilisé des bouts de code à droite à gauche j'ai du coller un truc avec le gluLookAt derrière par dessus la précédente correction... :s Donc effectivement ça c'est résolu... Merci beaucoup ! La pyramide reste bien sur place, et j'ai réussi aussi à enlever le phénomène de clignotement qui était dû si je me souvient bien au fait que j'appelle deux fois Display(), et qu'il y a un SDL_GL_SwapBuffers() dans chaque...

    Donc dans l'état actuel du problème, j'ai une pyramide qui tourne sur place au centre de mon champ de vision, par contre... Là ou je ne comprend rien maintenant c'est le problème de couleurs... :/ J'ai une pyramide dont les arrêtes devraient me semble t-il être en noir et les faces colorées en rouge et en fait j'ai les arrêtes blanches et les faces noires...

    Je repost le code tel qu'il est maintenant, dans l'espoir que quelqu'un pourra m'expliquer ce qui bugge...


    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
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    #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, 32,
                                               SDL_OPENGL);
        if ( !openGLContext )
        {
            printf("Unable to set 640x480 video: %s\n", SDL_GetError());
            return 1;
        }
     
        SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
        SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,  8);
        SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 32);
     
    //INITIALISATION glew
        glewInit();
     
    //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);
     
    // Initialisation d'OpenGL
     
    	glEnable(GL_LIGHTING);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
    	glEnable(GL_LIGHT0);
        //glClearColor(0.0f,0.0f,0.0f,0.0f);
        //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);
     
     
        // 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 ;}
            }
     
     
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            glClearColor(0.5,0.5,0.5,0.5);
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();// Reinitialise la vue
            gluLookAt(0,0,10,0,0,0,0,1,0);
            glRotatef(angle,0.0f,1.0f,0.0f);  // Tourne la pyramide sur son axe Y
     
     
    // Draw front-facing polygons as filled using toon shader
            glUseProgram(program);
            glClearDepth( 1.0);
            glEnable (GL_CULL_FACE);
            glFrontFace (GL_CW);
            glPolygonMode (GL_FRONT, GL_FILL);
            glDepthFunc (GL_LESS);
            glCullFace (GL_BACK);
            glColor3f(1,0,0);
            Display();
     
    // Draw back-facing polygons as black lines using standard OpenGL
            glUseProgram(0);
            glLineWidth (5.0f);
            glPolygonMode (GL_BACK,GL_LINE);
            glDepthFunc (GL_LEQUAL);
            glCullFace (GL_FRONT);
            glColor3f (0.0f, 0.0f, 0.0f);
            Display();
     
            glLineWidth (1.0f);
            glDepthFunc (GL_LESS);
            glPolygonMode (GL_BACK, GL_FILL);
            glDisable(GL_CULL_FACE);
            glFrontFace(GL_CCW);
     
     
    //Increment angle value, and swap buffers
            if (angle>=360){angle=0;}
            angle++;
            SDL_GL_SwapBuffers( );
        }
        return 0;
     
    }
     
     
     
     
     
    void Display()
    {
        glBegin( GL_TRIANGLES );
     
    	 glVertex3f( 0.0, 1.0, 0.0);
    	 glVertex3f(-1.0,-1.0, 1.0);
    	 glVertex3f( 1.0,-1.0, 1.0);
     
    	 glVertex3f( 0.0, 1.0, 0.0);
    	 glVertex3f( 1.0,-1.0, 1.0);
    	 glVertex3f( 1.0,-1.0, -1.0);
     
    	 glVertex3f( 0.0, 1.0, 0.0);
    	 glVertex3f( 1.0,-1.0, -1.0);
    	 glVertex3f(-1.0,-1.0, -1.0);
     
    	 glVertex3f( 0.0, 1.0, 0.0);
    	 glVertex3f(-1.0,-1.0,-1.0);
    	 glVertex3f(-1.0,-1.0, 1.0);
     
         glEnd();
     
         glBegin( GL_QUADS );
     
    	 glVertex3f( 1.0,-1.0,-1.0);
    	 glVertex3f( 1.0,-1.0, 1.0);
    	 glVertex3f(-1.0,-1.0, 1.0);
    	 glVertex3f(-1.0,-1.0,-1.0);
     
         glEnd();
    }

  16. #16
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    vu la cature d'écran que tu as posté, tes faces semblent inversées
    j'ai l'impression qu'on voit l'intérieur de ta pyramide
    pas certain que ça soit la source de ton probème mais on ne sait jamais
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  17. #17
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    En fait, c'est ce que je me disait aussi alors j'ai changé de pyramide dans mon code j'en ai chopé une sur internet Les faces sont correctement écrites maintenant

    Ca y est, j'ai finalement tout résolu ou presque... En fait, mon problème de couleurs est dû au fait que je ne sais pas encore gérer les lumières en OpenGL donc forcément sans lumières ou avec des lumières mal gérées, et bah j'ai une pyramide qui est telle qu'elle est... Donc j'ai juste une dernière petite question...

    Quelqu'un connaît-il un bon tutoriel ou un bon cours sur les lumières d'OpenGL ?

    PS : Merci encore pour toutes tes réponses Shenron666

  18. #18
    Expert confirmé
    Avatar de shenron666
    Homme Profil pro
    avancé
    Inscrit en
    Avril 2005
    Messages
    2 524
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Seine et Marne (Île de France)

    Informations professionnelles :
    Activité : avancé

    Informations forums :
    Inscription : Avril 2005
    Messages : 2 524
    Points : 5 184
    Points
    5 184
    Par défaut
    en cherchant sur le net tu trouveras quelques tutos en anglais principalement sur l'éclairage opengl
    sur developpez, il y a les articles de nehe qui ont étés traduits :
    Les filtres et l'éclairage

    sinon globalement, la première chose que tu auras à faire pour gérer l'éclairage, sera d'ajouter des normales aux sommets de ta pyramide
    ensuite il faudra :
    - créer une lumière (voir la doc de glLightfv)
    - activer cette lumière avec glEnable
    - activer l'éclairage avec glEnable(GL_LIGHTING)
    Tutoriels OpenGL
    Je ne répondrai à aucune question en MP
    - Si c'est simple tu dis que c'est compliqué et tu le fait
    - Si c'est compliqué tu dis que c'est simple et tu le sous-traite ou le fait faire par un stagiaire.

  19. #19
    Membre du Club
    Profil pro
    Inscrit en
    Juillet 2007
    Messages
    67
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juillet 2007
    Messages : 67
    Points : 41
    Points
    41
    Par défaut
    Ok, merci bien, je vais me documenter là dessus !

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

Discussions similaires

  1. problème avec les geometry shaders dans GLSL
    Par Syl_20 dans le forum OpenGL
    Réponses: 7
    Dernier message: 03/04/2009, 13h59
  2. Réponses: 0
    Dernier message: 24/02/2009, 04h36
  3. Réponses: 7
    Dernier message: 03/03/2007, 19h15
  4. Réponses: 2
    Dernier message: 05/07/2006, 12h09
  5. Réponses: 12
    Dernier message: 01/07/2004, 11h03

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