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

DevIL Discussion :

Chargement de texture avec DevIL


Sujet :

DevIL

  1. #1
    Futur Membre du Club
    Chargement de texture avec DevIL
    Bonjour,

    Je cherche à charger une texture avec DevIL pour l'utiliser avec OpenGL. Cependant avec le code que j'ai fait, j'obtiens une texture blanche lorsque je l'affiche.

    Voici le 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
    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
     
    bool load(std::string file, int w, int h)
    {
        unload();
        _width = w;
        _height = h;
        _loaded = true;
        ILuint devilId;
    	ilGenImages(1, &devilId);
    	ilBindImage(devilId);
    	ilLoadImage(file.c_str());
    	int scaledX;
    	int scaledY;
    	unsigned char *image = NULL;
    	unsigned char *imageScaled = NULL;
    	unsigned char *devilData = NULL;
    	if (checkForErrors())
    	{
    	    _loaded = false;
    	}
    	else
    	{
    	    int imageSize = ilGetInteger(IL_IMAGE_WIDTH) * ilGetInteger(IL_IMAGE_HEIGHT) * 4;
    	    scaledX = nextPowerOf2(ilGetInteger(IL_IMAGE_WIDTH));
    	    scaledY = nextPowerOf2(ilGetInteger(IL_IMAGE_HEIGHT));
    	    int imageSizeScaled = scaledX * scaledY * 4;
            try
            {
                image = new unsigned char[imageSize];
                imageScaled = new unsigned char[imageSizeScaled];
            }
            catch (std::bad_alloc e)
            {
                std::string erreur = "Mémoire insuffisante : \"";
                erreur.append(e.what());
                erreur.append("\".");
                _engine->error(erreur);
                _loaded = false;
            }
            if (_loaded)
            {
                if (ilGetInteger(IL_IMAGE_FORMAT) == IL_RGBA)
                {
                    devilData = ilGetData();
                    if (devilData)
                    {
                        if (_useColorKey)
                        {
                            for (int i = 0; i < imageSize; i += 4)
                            {
                                if (devilData[i+3] == 0)
                                {
                                    image[i] = _colorKeyR;
                                    image[i+1] = _colorKeyG;
                                    image[i+2] = _colorKeyB;
                                    image[i+3] = 0;
                                }
                                else
                                {
                                    image[i] = devilData[i];
                                    image[i+1] = devilData[i+1];
                                    image[i+2] = devilData[i+2];
                                    image[i+3] = devilData[i+3];
                                }
                            }
                        }
                        else
                        {
                            for (int i = 0; i < imageSize; i += 4)
                            {
                                image[i] = devilData[i];
                                image[i+1] = devilData[i+1];
                                image[i+2] = devilData[i+2];
                                image[i+3] = devilData[i+3];
                            }
                        }
                    }
                    else
                    {
                        checkForErrors();
                        _engine->error("Erreur lors de la récupération des données pixel.");
                        _loaded = false;
                    }
                }
                else
                {
                    ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
                    if (checkForErrors())
                    {
                        _loaded = false;
                    }
                    else
                    {
                        devilData = ilGetData();
                        if (devilData)
                        {
                            if (_useColorKey)
                            {
                                for (int i = 0; i < imageSize; i += 4)
                                {
                                    if (devilData[i] == _colorKeyR && devilData[i+1] == _colorKeyG && devilData[i+2] == _colorKeyB)
                                    {
                                        image[i+3] = 0;
                                    }
                                    else
                                    {
                                        image[i+3] = 255;
                                    }
                                    image[i] = devilData[i];
                                    image[i+1] = devilData[i+1];
                                    image[i+2] = devilData[i+2];
                                }
                            }
                            else
                            {
                                for (int i = 0; i < imageSize; i += 4)
                                {
                                    image[i] = devilData[i];
                                    image[i+1] = devilData[i+1];
                                    image[i+2] = devilData[i+2];
                                    image[i+3] = 255;
                                }
                            }
                        }
                        else
                        {
                            checkForErrors();
                            _engine->error("Erreur lors de la récupération des données pixel.");
                            _loaded = false;
                        }
                    }
                }
            }
        }
        if (_loaded)
        {
            _width = ilGetInteger(IL_IMAGE_WIDTH);
            _height = ilGetInteger(IL_IMAGE_HEIGHT);
            glGenTextures(1, &_glId);
                glBindTexture(GL_TEXTURE_2D, _glId);
            if (gluScaleImage(GL_RGBA, _width, _height, GL_UNSIGNED_BYTE, image, scaledX, scaledY, GL_UNSIGNED_BYTE, imageScaled) == 0)
            {
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, scaledX, scaledY, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageScaled);
            }
            else
            {
                _loaded = false;
                _engine->error("Redimensionnement en puissance de 2 impossible.");
            }
        }
        delete [] image;
        delete [] imageScaled;
        if (!_loaded && !_silence)
        {
            _engine->warning("Echec du chargement de \"" + file + "\".");
        }
        ilDeleteImages(1, &devilId);
        return _loaded;
    }


    Je précise que si je fait une boucle qui parcours le tableau imageScaled et qui affiche certaines valeurs avec des printf dans une console, j'obtiens bien une image redimensionnée en puissance de 2, parfaitement conforme avec l'image devant être chargée. Pourtant quand j'essaye d'afficher cette texture avec OpenGL, carré blanc...

    Merci d'avance pour votre aide
    paps

  2. #2
    Futur Membre du Club
    On va faire plus simple, parce que donner autant de code d'un coup, je suppose que sa motive pas.

    J'ai testé en faisant un programme très simple :

    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
    #include <GL/glfw.h>
    #include <IL/ilu.h>
     
    int main()
    {
        glfwInit();
        glfwOpenWindow(800, 600, 8, 8, 8, 8, 24, 0, GLFW_WINDOW);
        ilInit();
        iluInit();
     
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0, 800, 0, 600);
        glViewport(0, 0, 800, 600);
     
        ILuint devilId;
    	ilGenImages(1, &devilId);
    	ilBindImage(devilId);
    	ilLoadImage("65.bmp");
     
    	ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE); // on est sur d'avoir une image RGBA
     
        GLuint _glId;
        glGenTextures(1, &_glId);
        glBindTexture(GL_TEXTURE_2D, _glId);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, ilGetInteger(IL_IMAGE_WIDTH), ilGetInteger(IL_IMAGE_HEIGHT), 0, GL_RGBA, GL_UNSIGNED_BYTE, ilGetData());
     
        ilDeleteImages(1, &devilId); // supprimme la texture en mémoire
                                    // opengl a sa propre copie
     
        glEnable(GL_TEXTURE_2D);
     
        glBegin(GL_QUADS); // dessine la texture
            glTexCoord2i(0, 0);
            glVertex2i(100, 100);
            glTexCoord2i(0, 1);
            glVertex2i(100, 132);
            glTexCoord2i(1, 1);
            glVertex2i(132, 132);
            glTexCoord2i(1, 0);
            glVertex2i(132, 100);
        glEnd();
     
        glfwSwapBuffers();
     
        glfwSleep(2); // attend 2 secondes histoire de voir qqch
     
        glfwTerminate();
        return 0;
    }


    Ce code ne fait que charger une texture avec Devil, puis génère une texture avec opengl pour l'afficher. J'obtiens un carré blanc.

    Je précise que je charge une texture en 32x32 donc ce n'est pas un problème lié a une texture qui n'est pas en puissance de 2.

    C'est incompréhensible.

    Merci d'avance pour votre aide.

  3. #3
    Membre régulier
    Il faut initialiser les paramètres de textures
    J'ai rajouté :

    Code :Sélectionner tout -Visualiser dans une fenêtre à part
    1
    2
    3
     
    glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR );
    glTexParameteri( GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR );

    après le glTexImage2D et ça a marché chez moi.

    Devil a aussi la fonction magique ilutGLBindMipmaps() pour faire le sale boulot à ta place. Ca te renvoie directement l'id de la texture openGL

  4. #4
    Membre régulier
    Juste au passage, j'ai essayé d'utiliser DevIL mais j'avais des problèmes de dll et j'ai laissé tomber. La dll de Devil semblait incomplète. Comment avez-vous installé DevIL et quel est votre compilateur ou EDI?

    Merci d'avance

###raw>template_hook.ano_emploi###