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 :

Echec du chargement des textures [OpenGL 3.x]


Sujet :

OpenGL

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

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut Echec du chargement des textures
    Bonsoir, meilleurs voeux à tous !

    J'essaie en ce moment de passer de OpenGL 2.1 à OpenGL 3.3 grâce à ce tuto, j'arrive à initialiser le VBO comme je le faisais jusqu'à présent ainsi que le VAO et à coder mes shaders en 330 core. J'ai cependant affronté de nombreux problèmes : Un sol plat et une texture noire, j'ai fini par comprendre que c'était mes textures qui n'étaient pas chargées (Le sol est plat car c'est une texture qui définit le relief). Ça fonctionnait pourtant en OpenGL 2.1, la fonction que j'utilise utilise SDL pour charger l'image, voici son code :

    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
    GLuint loadTexture(const char * filename,bool useMipMap)
    {
        GLuint glID;
        SDL_Surface * picture_surface = NULL;
        SDL_Surface *gl_surface = NULL;
        SDL_Surface * gl_fliped_surface = NULL;
        Uint32 rmask, gmask, bmask, amask;
     
        picture_surface = IMG_Load(filename);
        if (picture_surface == NULL)
            return 0;
     
    #if SDL_BYTEORDER == SDL_BIG_ENDIAN
     
        rmask = 0xff000000;
        gmask = 0x00ff0000;
        bmask = 0x0000ff00;
        amask = 0x000000ff;
    #else
     
        rmask = 0x000000ff;
        gmask = 0x0000ff00;
        bmask = 0x00ff0000;
        amask = 0xff000000;
    #endif
     
        SDL_PixelFormat format = *(picture_surface->format);
        format.BitsPerPixel = 32;
        format.BytesPerPixel = 4;
        format.Rmask = rmask;
        format.Gmask = gmask;
        format.Bmask = bmask;
        format.Amask = amask;
     
        gl_surface = SDL_ConvertSurface(picture_surface,&format,SDL_SWSURFACE);
     
        gl_fliped_surface = flipSurface(gl_surface);
     
        glGenTextures(1, &glID);
     
        glBindTexture(GL_TEXTURE_2D, glID);
     
     
        if (useMipMap)
        {
     
            gluBuild2DMipmaps(GL_TEXTURE_2D, 4, gl_fliped_surface->w,
                              gl_fliped_surface->h, GL_RGBA,GL_UNSIGNED_BYTE,
                              gl_fliped_surface->pixels);
     
            glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                            GL_LINEAR_MIPMAP_LINEAR);
     
        }
        else
        {
            glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w,
                         gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE,
                         gl_fliped_surface->pixels);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        }
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
     
     
        SDL_FreeSurface(gl_fliped_surface);
        SDL_FreeSurface(gl_surface);
        SDL_FreeSurface(picture_surface);
     
        return glID;
    }
    Voici le code de flipSurface() :

    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
    SDL_Surface * flipSurface(SDL_Surface * surface)
    {
        int current_line,pitch;
        SDL_Surface * fliped_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                       surface->w,surface->h,
                                       surface->format->BitsPerPixel,
                                       surface->format->Rmask,
                                       surface->format->Gmask,
                                       surface->format->Bmask,
                                       surface->format->Amask);
     
     
     
        SDL_LockSurface(surface);
        SDL_LockSurface(fliped_surface);
     
        pitch = surface->pitch;
        for (current_line = 0; current_line < surface->h; current_line ++)
        {
            memcpy(&((unsigned char* )fliped_surface->pixels)[current_line*pitch],
                   &((unsigned char* )surface->pixels)[(surface->h - 1  -
                                                        current_line)*pitch],
                   pitch);
        }
     
        SDL_UnlockSurface(fliped_surface);
        SDL_UnlockSurface(surface);
        return fliped_surface;
    }
    En gros l'image est chargée dans une SDL_Surface et renversée grâce à la fonction flipSurface(), puis la fonction glTexImage2D() est appelée et reçoit les données pointées par pixels
    Le texturing est bien activé avant l'appel de loadTexture(), je ne comprends vraiment pas pourquoi le fait de changer de version OpenGL empêche le chargement de la texture, je m'en remets à vous pour trouver une solution car j'ai exploré toutes les pistes à ma portée (Format de fichier, format d'image, nombre d'octets par pixel, résolution, test sur une autre carte graphique, ce tuto).

    Le problème de vient pas de la communication avec les shaders car un simple test m'a permis de m'assurer que les coordonnées de vertices et de textures étaient bonnes.

    Merci par avance pour le coup de pouce !

  2. #2
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 340
    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 : 8 340
    Points : 20 324
    Points
    20 324
    Par défaut
    Citation Envoyé par KevinduC Voir le message
    J'essaie en ce moment de passer de OpenGL 2.1 à OpenGL 3.3 grâce à ce tuto
    bonsoir est-ce pour faire un programme qui fait un affichage en 2d ou bien en 3d ?
    Cela n'a aucun intérêt d'utiliser Open Gl pour faire de la 2d et afficher des bitmaps.
    Il suffit d'appeler SDL_BlitSurface pour ça.
    Et utiliser les shaders ça n'apportera pas plus de performance à mon sens.
    l'exemple du tuto c'est pour afficher des polygones 3d
    Citation Envoyé par KevinduC Voir le message
    Le problème de vient pas de la communication avec les shaders car un simple test m'a permis de m'assurer que les coordonnées de vertices et de textures étaient bonnes.
    je ne pense pas que les shaders soient utiles car la fonction SDL_BlitSurface écrase tout.

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

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Bonsoir, c'est pour un programme en 3D, loadTexture() utilise provisoirement SDL pour charger les images en 2D.
    Pour info je viens de tester les erreurs avec glGetError() et j'obtiens ceci :

    GL_INVALID_ENUM
    GL_INVALID_OPERATION

  4. #4
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 340
    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 : 8 340
    Points : 20 324
    Points
    20 324
    Par défaut
    Citation Envoyé par KevinduC Voir le message
    Bonsoir, c'est pour un programme en 3D, loadTexture() utilise provisoirement SDL pour charger les images en 2D.
    rebonsoir avec Vulkan il n'existe pas des fonctions chargeant des bitmpas directement plutôt que de passer par la SDL ?
    Citation Envoyé par KevinduC Voir le message
    Pour info je viens de tester les erreurs avec glGetError() et j'obtiens ceci :
    ce qui doit se passer c'est que la SDL initialise un objet graphique mettons un pointeur sur la RAM vidéo et Open GL un autre pointeur sur la carte graphique.
    Ce qui fait que les appels d'un côté comme de l'autre doivent être incompatibles j'écris juste ça en passant.
    Et puis on a juste une portion de code.
    Donc je conseille de faire du code 100% Vulkan c.a.d. sans SDL

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

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Vulkan ? Je n'en sais strictement rien, probablement oui. De toute façon le problème ne vient pas de là car le chargement de l'image par SDL fonctionne bien, le problème se situe chez glTexImage2D() visiblement. Je vais tout de même tester ce qu'il se passe si je remplis un tableau à la main avant de l'envoyer à glTexImage2D().

    Edit : Même résultat avec un tableau rempli à la main, le problème vient donc bien de glTexImage2D().

  6. #6
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 340
    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 : 8 340
    Points : 20 324
    Points
    20 324
    Par défaut
    Citation Envoyé par KevinduC Voir le message
    Vulkan ? Je n'en sais strictement rien, probablement oui.
    bonsoir nos réponses se sont croisées.Et j'ai modifié mon message.Vulkan c'est l'API qui succède à Open gl

    modif 23:30
    il ne faut pas utiliser la SDL il faut utiliser la biblio libGL.so sous Linux notamment.
    tout est décrit ici

  7. #7
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 111
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 111
    Points : 32 941
    Points
    32 941
    Billets dans le blog
    4
    Par défaut
    Vulkan ne propose pas plus de fonction de chargement que OpenGL.
    Il n'y a absolument aucun pb à utiliser SDL pour charger les images ou créer la fenêtre.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w,
                         gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE,
                         gl_fliped_surface->pixels);
    C'est quoi 4 ?
    C'est quoi l'image que tu charges ?
    T'es sûr qu'elle est en RGBA ?
    Tu as lu la doc ?

    GL_INVALID_ENUM
    GL_INVALID_OPERATION
    Ces erreurs sont où ?
    Les erreurs ça se devine pas. Il faut vérifier l'état après chaque appel à OpenGL pour savoir si la dernière opération a fonctionné ou non.
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

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

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    J'ai résolu le problème finalement, c'est en fait tout simple :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    glTexImage2D(GL_TEXTURE_2D, 0, 4, gl_fliped_surface->w, gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE, gl_fliped_surface->pixels);
    Comme tu le dis Bousk ce 4 n'a rien à faire ici, j'ignore pourquoi ça fonctionnait en OpenGL 2.1, ce code fonctionne mieux :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, gl_fliped_surface->w, gl_fliped_surface->h, 0, GL_RGBA,GL_UNSIGNED_BYTE, gl_fliped_surface->pixels);
    T'es sûr qu'elle est en RGBA ?
    Tu as lu la doc ?
    Non l'image est un PNG en 16 bits mais OpenGL la convertit au format souhaité de toute façon.
    Oui j'ai lu la doc plusieurs fois mais j'ai dû ne pas faire attention à ce paramètre, bref je m'en souviendrai la prochaine fois.

    Vulkan ne propose pas plus de fonction de chargement que OpenGL.
    Il n'y a absolument aucun pb à utiliser SDL pour charger les images ou créer la fenêtre.
    On est bien d'accord ...

    Bref sujet résolu, merci pour l'aide !

  9. #9
    Expert éminent sénior

    Avatar de dragonjoker59
    Homme Profil pro
    Software Developer
    Inscrit en
    Juin 2005
    Messages
    2 044
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Software Developer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juin 2005
    Messages : 2 044
    Points : 11 358
    Points
    11 358
    Billets dans le blog
    10
    Par défaut
    Bonjour !

    OpenGL ne convertit rien du tout, c'est la SDL qui s'en occupée.
    Le 4 fonctionnait en OpenGL 2.1 car à l'époque, on pouvait spécifier le nombre de composantes (RGBA) de la texture de cette manière.
    Ce n'est plus supporté en 3.3 core profile (je ne sais pas trop pour les autres profils, mais de toute façon, même en OpenGL 2.1 c'était plus un hack qu'autre chose)
    Si vous ne trouvez plus rien, cherchez autre chose...

    Vous trouverez ici des tutoriels OpenGL moderne.
    Mon moteur 3D: Castor 3D, presque utilisable (venez participer, il y a de la place)!
    Un projet qui ne sert à rien, mais qu'il est joli (des fois) : ProceduralGenerator (Génération procédurale d'images, et post-processing).

  10. #10
    Expert éminent sénior
    Avatar de Mat.M
    Profil pro
    Développeur informatique
    Inscrit en
    Novembre 2006
    Messages
    8 340
    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 : 8 340
    Points : 20 324
    Points
    20 324
    Par défaut
    Citation Envoyé par Bousk Voir le message
    Vulkan ne propose pas plus de fonction de chargement que OpenGL.
    Il n'y a absolument aucun pb à utiliser SDL pour charger les images ou créer la fenêtre.
    bonjour bien reçu cette réponse.
    Cependant j'ai pris la décision définitive de ne plus intervenir sur ce forum je remercie au passage les personnes qui ont noté mes messages, puisque nul n'est irremplaçable.

    Là pour essayer de faire avancer le problème j'ai effectué une recherche sur les sites d'Open Gl , de la SDL ,donc j'ai bien dû perdre 20 minutes.
    20 minutes de perdues tout ça pour ça
    Maintenant si mes réponses indisposent tant pis pour les autres...
    Allez sans rancunes et bonne vie à DVP

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

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2013
    Messages : 309
    Points : 105
    Points
    105
    Par défaut
    Citation Envoyé par Mat.M Voir le message
    j'ai pris la décision définitive de ne plus intervenir sur ce forum je remercie au passage les personnes qui ont noté mes messages, puisque nul n'est irremplaçable.
    C'est vous qui voyez navré que vous vous soyez emporté

    Puisqu'on y est j'aimerais souligner un autre problème : Le multitexturing, j'arrive bien à transmettre mes textures au fragment shader mais lorsque je veux dessiner un objet contenant plusieurs matériaux avec ou sans texture j'ai un petit souci : Mes textures sont stockées dans un tableau et j'utilise des attributs de vertex pour indiquer l'index du tableau à utiliser, cet index prend la valeur -1 si le vertex actuel n'est pas texturé. J'ai remarqué qu'en appliquant cela les objets texturés devenaient transparents, j'ai voulu corriger ce problème et j'ai remarqué une erreur lors de l'appel de glVertexAttribPointer() :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    glVertexAttribPointer(4,1,GL_FLOAT,GL_FALSE,sizeof(int),(void*)(vbo->coordVertices.size()*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)+vbo->colors.size()*sizeof(float)));
    Puisqu'il s'agit d'un entier il faut en fait mettre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    glVertexAttribPointer(4,1,GL_INT,GL_FALSE,sizeof(int),(void*)(vbo->coordVertices.size()*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)+vbo->colors.size()*sizeof(float)));
    Mais en faisant cela c'est encore pire : Le jeu plante lorsque la caméra regarde en direction de l'objet.

    Ci-dessous le code de l'initialisation du VBO :

    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
    vbo->nbVertices=vbo->coordVertices.size()/3;
    
    glGenVertexArrays(1,&vbo->VAO);			//Initialisation VAO
    glGenBuffers(1,&vbo->bufferVRAM);		//Initialisation VBO
    
    glBindVertexArray(vbo->VAO);
    glBindBuffer(GL_ARRAY_BUFFER,vbo->bufferVRAM);      //Bindage vers espace mémoire VRAM
    
    glBufferData(GL_ARRAY_BUFFER,vbo->nbVertices*3*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)+vbo->colors.size()*sizeof(float)+vbo->attribNumtex.size()*sizeof(float),NULL,GL_STREAM_DRAW);
    
    glBufferSubData(GL_ARRAY_BUFFER,0,vbo->nbVertices*3*sizeof(float),&vbo->coordVertices[0]);      //Mise en mémoire coordonnées vertices
    
    if(vbo->coordTex.size()!=0)
    	glBufferSubData(GL_ARRAY_BUFFER,vbo->nbVertices*3*sizeof(float),vbo->coordTex.size()*sizeof(float),&vbo->coordTex[0]);      //Mise en mémoire coordonnées texture
    
    if(vbo->normals.size()!=0)
    	glBufferSubData(GL_ARRAY_BUFFER,vbo->nbVertices*3*sizeof(float)+vbo->coordTex.size()*sizeof(float),vbo->normals.size()*sizeof(float),&vbo->normals[0]);      //Mise en mémoire normales
    
    if(vbo->colors.size()!=0)
    	glBufferSubData(GL_ARRAY_BUFFER,vbo->nbVertices*3*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float),vbo->colors.size()*sizeof(float),&vbo->colors[0]);      //Mise en mémoire couleurs
    
    if(vbo->attribNumtex.size()!=0)
    	glBufferSubData(GL_ARRAY_BUFFER,vbo->nbVertices*3*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)+vbo->colors.size()*sizeof(float),vbo->attribNumtex.size()*sizeof(float),&vbo->attribNumtex[0]);      //Mise en mémoire index textures
    
    ///////////////////////////////////////////////////////////////////////////////////////////////
    
    glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)0);
    glEnableVertexAttribArray(0);
    
    glVertexAttribPointer(1,2,GL_FLOAT,GL_FALSE,2*sizeof(float),(void*)(vbo->coordVertices.size()*sizeof(float)));
    glEnableVertexAttribArray(1);
    
    glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)(vbo->coordVertices.size()*sizeof(float)+vbo->coordTex.size()*sizeof(float)));
    glEnableVertexAttribArray(2);
    
    glVertexAttribPointer(3,3,GL_FLOAT,GL_FALSE,3*sizeof(float),(void*)(vbo->coordVertices.size()*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)));
    glEnableVertexAttribArray(3);
    
    glVertexAttribPointer(4,1,GL_INT,GL_FALSE,sizeof(int),(void*)(vbo->coordVertices.size()*sizeof(float)+vbo->coordTex.size()*sizeof(float)+vbo->normals.size()*sizeof(float)+vbo->colors.size()*sizeof(float)));
    glEnableVertexAttribArray(4);
    
    glBindBuffer(GL_ARRAY_BUFFER,0);
    glBindVertexArray(0);
    Le code du rendu :

    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
    glUniformMatrix4fv(glGetUniformLocation(shaderNormal,"projection"),1,false,glm::value_ptr(matriceProjection));
    glUniformMatrix4fv(glGetUniformLocation(shaderNormal,"modelview"),1,false,glm::value_ptr(matriceModelview));
     
    glBindVertexArray(vbo->VAO);
     
    if(vbo->textures.size()!=0)
    {
    	int texShader[vbo->textures.size()];
     
    	int compteurTex=0;
    	while(1)
    	{
    		glActiveTexture(GL_TEXTURE0+compteurTex);
    		glBindTexture(GL_TEXTURE_2D,vbo->textures[compteurTex]);
     
    		texShader[compteurTex]=compteurTex;
     
    		compteurTex++;
    		if(compteurTex==vbo->textures.size())
    			break;
    	}
     
    	glUniform1iv(glGetUniformLocation(shader,"tex"),vbo->textures.size(),texShader);		//Envoi des textures au fragment shader
    }
     
    glDrawArrays(GL_TRIANGLES,0,vbo->nbVertices);		//Rendu
     
    glActiveTexture(GL_TEXTURE0);
     
    glBindVertexArray(0);
    Le 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
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    #version 330 core
     
    layout (location=0) in vec3 vertex;
    layout (location=1) in vec2 coordTex;
    layout (location=2) in vec3 normale;
    layout (location=3) in vec3 couleur;
    layout (location=4) in int numtex;
     
    flat out int numtexFrag;
    out vec4 couleurFrag;
    out vec2 coordTexFrag;
     
    uniform mat4 projection;
    uniform mat4 modelview;
     
    void main(void)
    {
    	gl_Position=projection*modelview*vec4(vertex,1.0);
     
    	couleurFrag=vec4(couleur,1.0);
     
    	coordTexFrag=coordTex;
     
    	numtexFrag=numtex;
    }
    Le fragment 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
    16
    17
    #version 330 core
     
    uniform sampler2D tex[20];
     
    flat in int numtexFrag;
    in vec4 couleurFrag;
    in vec2 coordTexFrag;
     
    out vec4 FragColor;
     
    void main(void)
    {
        if(numtexFrag!=-1)
    		FragColor=texture(tex[numtexFrag],coordTexFrag.xy)*couleurFrag;
    	else
    		FragColor=couleurFrag;
    }
    Désolé ça fait beaucoup de code, j'ai essayé de simplifier au maximum. Est-ce qu'il y aurait une solution plus simple pour le multitexturing ?

    Édit : Problème résolu, il faut garder les attributs en flottants et non entiers.

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

Discussions similaires

  1. Réponses: 2
    Dernier message: 13/01/2016, 14h08
  2. Réponses: 0
    Dernier message: 05/11/2009, 19h06
  3. Chargement des textures pose probleme
    Par epsilon777 dans le forum OpenGL
    Réponses: 1
    Dernier message: 13/05/2008, 06h07
  4. [Eclipse + Jogl] Echec de chargement des librairies natives
    Par dabeuliou dans le forum Eclipse Java
    Réponses: 3
    Dernier message: 18/11/2007, 06h52
  5. Réponses: 1
    Dernier message: 24/04/2007, 10h27

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