tga + alpha channel

hi ich verwende diesen code um eine tga zu laden und eine textur daraus zu machen:

bool TEXTURE::
    LoadTGA(char* filename) 
    {    
    GLubyte     TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0};    //Unkomprimierter TGA Header
    GLubyte     TGAcompare[12];                 //Wird verwendet um Header zu vergleichen
    GLubyte     header[6];                      //Die ersten 6 Bytes des Headers
    GLuint      bytesPerPixel;                  //BPP
    GLuint      imageSize;                      //RAM verbrauch
    GLuint      temp;                           //Temp Variable

    FILE* file = fopen(filename, "rb");         // TGA öffnen

    if(file==NULL                                                      ||   // Existiert die Datei?
       fread(TGAcompare,1,sizeof(TGAcompare),file)!=sizeof(TGAcompare) ||   // Sind die 12 Bytes des Headers vorhanden?
       memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0               ||   // Steht im Header 0,0,2,0,0,0,0,0,0,0,0,0
       fread(header,1,sizeof(header),file)!=sizeof(header))                 // Wenn ja die nächsten 6 Bytes einlesen
        {
        if(file==NULL)                          // Wenn die Datei nicht existiert, dann Fehler ausgabe in Datei
            {
            loadlog.Output("TGA \"%s\" existiert nicht", filename);
            return false;                           
            }
        else
            {
            fclose(file);                       // Wenn sind etwas falsch gelaufen ist...
            loadlog.Output("TGA  \"%s\" kann nicht geladen werden", filename);
            return false;                       
            }
        }

    width = header[1] * 256 + header[0];        // TGA width herausbekommen (highbyte*256+lowbyte)
    height= header[3] * 256 + header[2];        // TGA height herausbekommen    (highbyte*256+lowbyte)

    if(width    <=0  ||                          // Width < oder <= 0?
       height<=0 ||                          // Height < oder <= 0?
        (header[4]!=24 && header[4]!=32))       // Datei nicht 24 oder 32 Bpp
        {
        fclose(file);                           // Wenn etwas falsch gelaufen ist...
        loadlog.Output("TGA \"%s\" kann nicht geladen werden", filename);
        return false;                           
        }

    bpp  = header[4];                           // Bpp in Variable schreiben
    bytesPerPixel= bpp/8;                       // Bpp/8 um tatsächliche bytesPerPixel herauszubekommen
    imageSize    = width*height*bytesPerPixel;  // RAM verbrauch

    data= new GLubyte [imageSize];              // Speicher reservieren

    if(data==NULL ||                            // Genug Speicher frei?
       fread(data, 1, imageSize, file)!=imageSize)  // Datei gleich groß wie reservierter Speicher?
        {
        if(data!=NULL)                          // Sind die Daten geladen worden?
            free(data);                         // Wenn ja speicher frei geben

        fclose(file);                           // Datei schließen
        return false;                           // Return False
        }

    for(GLuint i=0; i<int(imageSize); i+=bytesPerPixel)      // Schleife durch die Daten
        {                                       // Tausch 1. und 3. Byte
        temp     =data[i];                      // Temp
        data[i]  = data[i + 2];                 // 1 -> 3
        data[i+2]= temp;                        // 3 -> Temp(1)

/*  if (data[i] == 0 && data[i+1] == 0 && data[i+1] == 0)
      data[i+3] = 0;
    else
      data[i+3] = 0xFF;*/
        }

    fclose (file);                              //Datei schließen

    loadlog.Output("TGA \"%s\" geladen", filename);
    return true;
    }

bool TEXTURE::LoadTexture (char* filename, int fileFormat, GLfloat minFilter, GLfloat maxFilter)
{
    if (fileFormat==TGA) LoadTGA(filename);
    else if (fileFormat==BMP) LoadBMP(filename);
    else 
    {
        loadlog.Output ("TEXTURE Format wird nicht unterstützt!");
        return false;
    }

    GLuint type=GL_RGBA;            //Default auf RGBA stellen (32 Bpp)
    if(bpp==24) type=GL_RGB;
    // Textur aus den Daten bilden
    glGenTextures(1, &ID);          //ID's erzeugen

    glBindTexture(GL_TEXTURE_2D, ID);            

    gluBuild2DMipmaps(GL_TEXTURE_2D, 3, width, height, type, GL_UNSIGNED_BYTE, data);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, maxFilter);

    glTexParameteri(GL_TEXTURE_2D, GL_REPEAT, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_REPEAT, GL_CLAMP_TO_EDGE);

    glTexImage2D(GL_TEXTURE_2D, 0, type, width, height, 0, type, GL_UNSIGNED_BYTE, data);
    loadlog.Output("TEXTURE %s(%i BPP) erstellt", filename,bpp);
    return true;
}

Ich möchte jetzt alles was schwarz ist nicht zeichnen, nichts leichter als das habe ich mir gedacht: einfach blending einschalten und weg sind die schwarzen flächen:

glEnable(GL_BLEND);
 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 glEnable(GL_ALPHA_TEST);
 glAlphaFunc(GL_GREATER, 0);
/*
 HIER DIE TEXTUR RAUFKLEBEN UND OBJEKT (BILLBOARD) ZEICHNEN
*/
  glDisable(GL_BLEND);
  glDisable(GL_ALPHA_TEST);

Mein Problem ist das das nur richt mit den im code ausdokumenten teil
(

/*  if (data[i] == 0 && data[i+1] == 0 && data[i+1] == 0)
      data[i+3] = 0;
       else
      data[i+3] = 0xFF;*/

)

Mein Problem ist dass ich nicht verstehe wieso es ohne nicht funzt. es müsste ja automatisch auch gehen...

weiß keiner was?

meine frage anderst formuliert: wie kann ich nur gewisse stellen einer tga zeichnen

Headhunter

Du musst im Grafikprogramm deiner Wahl einen Alphachannel für die TGA erstellen. Dann musst du für OGL ein paar Renderstates setzen (weiß leider nicht welche, guck mal bei nehe.gamedev.net für mehr Infos).

So sollte es funktionieren

Danke!! Habs gefunden
Man muss einen State setzen: glEnable(GL_ALPHA_TEST)