Transparency In Sprite Texture Not Working

Question

I'm trying to program a sprite into my 3D scene using OpenGL. The problem that I am experiencing is that when my sprite appears in the scene on top of the 3D objects, there's a black box around the sprite, when the black should be transparent.

I created my sprite sheet with GIMP as a BMP file with 32 bits (A8 B8 G8 R8). In addition, I also used GIMP to set the alpha values for every pixel that should be transparent to 0. I load my BMP file into my program as follows:

unsigned int LoadSpriteTexBMP(const char* file)
{
    unsigned int   texture;    // Texture name
    FILE*          f;          // File pointer
    unsigned short magic;      // Image magic
    unsigned int   dx,dy,size; // Image dimensions
    unsigned short nbp,bpp;    // Planes and bits per pixel
    unsigned char* image;      // Image data
    unsigned int   k;          // Counter
    int            max;        // Maximum texture dimensions

    //  Open file
    f = fopen(file,"rb");

    //  Check image magic
    if (fread(&magic,2,1,f)!=1)
        Fatal("Cannot read magic from %s\n",file);

    if (magic!=0x4D42 && magic!=0x424D)
        Fatal("Image magic not BMP in %s\n",file);

    //  Seek to and read header
    if (fseek(f,16,SEEK_CUR) || fread(&dx ,4,1,f)!=1 || fread(&dy ,4,1,f)!=1 ||
    fread(&nbp,2,1,f)!=1 || fread(&bpp,2,1,f)!=1 || fread(&k,4,1,f)!=1)
        Fatal("Cannot read header from %s\n",file);

    //  Reverse bytes on big endian hardware (detected by backwards magic)
    if (magic==0x424D)
    {
        Reverse(&dx,4);
        Reverse(&dy,4);
        Reverse(&nbp,2);
        Reverse(&bpp,2);
        Reverse(&k,4);
    }

    //  Check image parameters
    glGetIntegerv(GL_MAX_TEXTURE_SIZE,&max);
    if (dx<1 || dx>max)
        Fatal("%s image width %d out of range 1-%d\n",file,dx,max);

    if (dy<1 || dy>max)
        Fatal("%s image height %d out of range 1-%d\n",file,dy,max);

    if (nbp!=1)
        Fatal("%s bit planes is not 1: %d\n",file,nbp);

    if (bpp!=32)
        Fatal("%s bits per pixel is not 32: %d\n",file,bpp);

    //  Allocate image memory
    size = 4*dx*dy;
    image = (unsigned char*) malloc(size);
    if (!image)
        Fatal("Cannot allocate %d bytes of memory for image %s\n",size,file);

    //  Seek to and read image
    if (fseek(f,20,SEEK_CUR) || fread(image,size,1,f)!=1)
        Fatal("Error reading data from image %s\n",file);
    fclose(f);

    //  Reverse colors (ABGR -> BGRA)
    for (k=0;k<size;k+=4)
    {
        unsigned char temp = image[k];

        image[k]   = image[k+1];
        image[k+1] = image[k+2];
        image[k+2] = image[k+3];
        image[k+3] = temp;
    }

    //  Generate 2D texture
    glGenTextures(1,&texture);
    glBindTexture(GL_TEXTURE_2D,texture);

    //  Copy image
    glTexImage2D(GL_TEXTURE_2D,0,3,dx,dy,0,GL_BGRA,GL_UNSIGNED_BYTE,image);
    if (glGetError())
        Fatal("Error in glTexImage2D %s %dx%d\n",file,dx,dy);

    //  Scale linearly when image size doesn't match
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

    //  Free image memory
    free(image);

    //  Return texture name
    return texture;

}

To setup displaying my sprite in the scene, I use the following:

unsigned int texture = LoadSpriteTexBMP("Sprite.bmp");
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV , GL_TEXTURE_ENV_MODE , GL_MODULATE);
glBindTexture(GL_TEXTURE_2D,texture[textureIndex]);

Any idea why I'm not getting the desired transparent effect around the sprite?

Answer 1

I discovered the answer. I needed to change this line:

glTexImage2D(GL_TEXTURE_2D,0,3,dx,dy,0,GL_BGRA,GL_UNSIGNED_BYTE,image);

to:

glTexImage2D(GL_TEXTURE_2D,0,4,dx,dy,0,GL_BGRA,GL_UNSIGNED_BYTE,image);

Answer 2

Try setting GL_TEXTURE_WRAP_S and GL_TEXTURE_WRAP_T to GL_CLAMP_TO_EDGE with glTexParameteri. It's possible that due to floating point error, your texture coordinates at the edge of your polygons are slightly less than 0 or slightly greater than 1.