title: OpenGL Set Transparent Color for textures
body: <p>My question-> How do i make color 255,200,255 transparent in OpenGL? (by transparent i mean removing the pixels color 255,200,255 or whatever works...) </p>
  
  <p>my texture loading functions are from this tutorial-> <a href="http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=33" rel="nofollow noreferrer">http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=33</a></p>
  
  <p>note that i don't have to use Alpha Channels, i have a set of pre-made images with custom color (255,200,255) which must be transparent/removed pixels..</p>
  
  <p>some .tga loading functions of my program:</p>
  
  <pre><code>Texture AllTextures[1000];
  typedef struct                                  
  {
      GLubyte * imageData;                                    // Image Data (Up To 32 Bits)
      GLuint  bpp;                                            // Image Color Depth In Bits Per Pixel
      GLuint  width;                                          // Image Width
      GLuint  height;                                         // Image Height
      GLuint  texID;                                          // Texture ID Used To Select A Texture
      GLuint  type;                                           // Image Type (GL_RGB, GL_RGBA)
  } Texture;  
  bool LoadUncompressedTGA(Texture * texture, char * filename, FILE * fTGA)   // Load an uncompressed TGA (note, much of this code is based on NeHe's 
      {                                                                           // TGA Loading code nehe.gamedev.net)
          if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)                 // Read TGA header
          {                                       
              MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);     // Display error
              if(fTGA != NULL)                                                    // if file is still open
              {
                  fclose(fTGA);                                                   // Close it
              }
              return false;                                                       // Return failular
          }   
  
          texture-&gt;width  = tga.header[1] * 256 + tga.header[0];                  // Determine The TGA Width  (highbyte*256+lowbyte)
          texture-&gt;height = tga.header[3] * 256 + tga.header[2];                  // Determine The TGA Height (highbyte*256+lowbyte)
          texture-&gt;bpp    = tga.header[4];                                        // Determine the bits per pixel
          tga.Width       = texture-&gt;width;                                       // Copy width into local structure                      
          tga.Height      = texture-&gt;height;                                      // Copy height into local structure
          tga.Bpp         = texture-&gt;bpp;                                         // Copy BPP into local structure
  
          if((texture-&gt;width &lt;= 0) || (texture-&gt;height &lt;= 0) || ((texture-&gt;bpp != 24) &amp;&amp; (texture-&gt;bpp !=32)))    // Make sure all information is valid
          {
              MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);    // Display Error
              if(fTGA != NULL)                                                    // Check if file is still open
              {
                  fclose(fTGA);                                                   // If so, close it
              }
              return false;                                                       // Return failed
          }
  
          if(texture-&gt;bpp == 24)                                                  //If the BPP of the image is 24...
          {
              texture-&gt;type   = GL_RGBA;                                          // Set Image type to GL_RGB
          }
          else                                                                    // Else if its 32 BPP
          {
              texture-&gt;type   = GL_RGBA;                                          // Set image type to GL_RGBA
          }
  
          tga.bytesPerPixel   = (tga.Bpp / 8);                                    // Compute the number of BYTES per pixel
          tga.imageSize       = (tga.bytesPerPixel * tga.Width * tga.Height);     // Compute the total amout ofmemory needed to store data
          texture-&gt;imageData  = (GLubyte *)malloc(tga.imageSize);                 // Allocate that much memory
  
          if(texture-&gt;imageData == NULL)                                          // If no space was allocated
          {
              MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);    // Display Error
              fclose(fTGA);                                                       // Close the file
              return false;                                                       // Return failed
          }
  
          if(fread(texture-&gt;imageData, 1, tga.imageSize, fTGA) != tga.imageSize)  // Attempt to read image data
          {
              MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);      // Display Error
              if(texture-&gt;imageData != NULL)                                      // If imagedata has data in it
              {
                  free(texture-&gt;imageData);                                       // Delete data from memory
              }
              fclose(fTGA);                                                       // Close file
              return false;                                                       // Return failed
          }
  
          // Byte Swapping Optimized By Steve Thomas
          for(GLuint cswap = 0; cswap &lt; (int)tga.imageSize; cswap += tga.bytesPerPixel)
          {
              texture-&gt;imageData[cswap] ^= texture-&gt;imageData[cswap+2] ^=texture-&gt;imageData[cswap] ^= texture-&gt;imageData[cswap+2];
          }
  
          fclose(fTGA);                                                           // Close file
          return true;                                                            // Return success
      }
      void LoadMyTextureTGA(int id,char* texturename)
      {
           //texturename ex: "Data/Uncompressed.tga"
          if(LoadTGA(&amp;AllTextures[id], texturename))
          {
              //success      
  
                  glGenTextures(1, &amp;AllTextures[id].texID);               // Create The Texture ( CHANGE )
                  glBindTexture(GL_TEXTURE_2D, AllTextures[id].texID);
                  glTexImage2D(GL_TEXTURE_2D, 0, 3, AllTextures[id].width, AllTextures[id].height, 0, GL_RGB, GL_UNSIGNED_BYTE, AllTextures[id].imageData);
                  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
                  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  
  
                  if (AllTextures[id].imageData)                      // If Texture Image Exists ( CHANGE )
                  {
                      free(AllTextures[id].imageData);                    // Free The Texture Image Memory ( CHANGE )
                  }        
          }
          else
          {
             MessageBoxA(0,"Textures Loading Fail! Game will close now","Game Problem",0);
             exit(1);
          }
  
      }
  </code></pre>