Problème avec TGA Loader

textureTGA.h
#ifndef TEXTURETGA_H
#define TEXTURETGA_H

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <iostream>
#include <fstream>
#include "GL/gl.h"
#include "GL/glu.h"

typedef unsigned char byte;

typedef struct{
    byte idLength;
    byte colorMapType;
    byte imageType;
    byte colorMapInfo[5];
    byte x[2];
    byte y[2];
    byte width[2];
    byte height[2];
    byte bpp;   
}headerTga;

class textureTGA{
private:
    int m_width;
    int m_height;
    int m_bpp;
    int m_format;
   
public:
    textureTGA(const char *filename, const int textureId);
 textureTGA(std::string filename, const int textureId){textureTGA(filename.c_str(),textureId);}
   
    int getWidth(){return m_width;}
    int getHeight(){return m_width;}
    int getBpp(){return m_bpp;}
};

#endif //TEXTURETGA_H

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////::
textureTGA.cpp

#include "textureTGA.h"

textureTGA::textureTGA(const char *filename, const int textureId){
    byte *imageData;
    int numPixels;
    int bytesInPixel;
    int imageDataSize;
    headerTga fileHeader;
    byte temp; 
   
    // Open file
    std::ifstream textureFile(filename, std::ios::in | std::ios::binary | std::ios::ate);
   
    if(!textureFile.is_open()){
        std::cout<<"[TGA] ERROR: Could not open '"<<filename<<"'"<<std::endl;
        return;  
    }
    if(int(textureFile.tellg()) == 0){
        std::cout<<"[TGA] ERROR: Texture '"<<filename<<"' is empty"<<std::endl;
        textureFile.close();
        return;
    } 
   
    // Read TGA header
    textureFile.seekg(0, std::ios::beg);
    textureFile.read((char*)&fileHeader, sizeof(fileHeader));
   
    m_width = fileHeader.width[0] + (fileHeader.width[1] << 8);
    m_height = fileHeader.height[0] + (fileHeader.height[1] << 8);
    m_bpp = fileHeader.bpp;

    // We only support uncompressed 24 or 32 bits per pixel TGAs
    if(fileHeader.colorMapType == 1 || int(fileHeader.imageType) != 2){
        std::cout<<"[TGA] ERROR: '"<<filename<<"' is an texture invalid format\n[TGA] ERROR: It should be an uncompressed 24/32bpp TGA"<<std::endl;
        textureFile.close();
        return;
    }
    if(m_bpp != 32 && m_bpp != 24){
        std::cout<<"[TGA] ERROR: Invalid texture color depth, '"<<filename<<"' must be uncompressed 24/32bpp TGA"<<std::endl;
        textureFile.close();
        return;
    }
   
    // OpenGL textures must be power-of-two
    /*if((m_width&(m_width-1)) || (m_height&(m_height-1))){
        std::cout<<"[TGA] ERROR: Texture '"<<filename<<"' must have power-of-two width & height"<<std::endl;
        textureFile.close();
        return;       
    }*/
   
    // Determine format
    switch(m_bpp){
        case 24:m_format = GL_RGB;  bytesInPixel = 3; break;  
        case 32:m_format = GL_RGBA; bytesInPixel = 4; break;
        default:
            std::cout<<"[TGA] ERROR: Invalid texture color depth, '"<<filename<<"' must be uncompressed 24/32bpp TGA"<<std::endl;
            textureFile.close();
            return;
            break;
    }
   
    // Allocate memory for image   
    numPixels = m_width * m_height;
    imageDataSize = numPixels * bytesInPixel;
    imageData = new byte[imageDataSize];
    if(!imageData){
        std::cout<<"[TGA] ERROR: Out of memory"<<std::endl;
        textureFile.close();
        return;
    }
   
    // Read image data
    textureFile.seekg(18, std::ios::beg);
    textureFile.read((char*)imageData, imageDataSize);
    textureFile.close();
     
    // TGAs are BGRA, convert to RGBA
    for(int pixel=0; pixel < numPixels*bytesInPixel; pixel+=bytesInPixel){
        temp = imageData[pixel+2];
        imageData[pixel+2] = imageData[pixel];
        imageData[pixel] = temp;
    }
   
    // Bind texture ID to load
    glBindTexture(GL_TEXTURE_2D, textureId);
   
    // Set texture parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
   
    // Upload texture to card with bound texture ID
    //glTexImage2D(GL_TEXTURE_2D, 0, m_format, m_width, m_height, 0, m_format, GL_UNSIGNED_BYTE, imageData);
 gluBuild2DMipmaps(GL_TEXTURE_2D, m_format, m_width, m_height, m_format, GL_UNSIGNED_BYTE, imageData);
   
    // Texture's uploaded, don't need data any more  
    delete imageData;
   
    std::cout<<"[TGA] Texture '"<<filename<<"' loaded"<<std::endl;
}

Je voudrais réussir à utiliser TGA Loader, sinon j'aurais déjà utilisé d'autres classes trouvées sur le net...

La taille de ton image est bien un multiple de 2?

Oui. Pour les tests j'ai récupéré un tga de funto66 (qu'il a utilisé dans son jeu) pour justement éviter ce genre de problèmes..

j'ai codé un loader dynamique tga/bmp/pcx/jpg je l'ameliore au fur et a mesure mais pour le tga je me suis inspirer du loader de funtoo donc si ca t'intersee regarde a ce lien 

Ok je vais l'essayer, puisqu'apparement, il n'y a pas de solution au problème du loader de funto66