Iphone – Creating and loading .pngs in RGBA4444 RGBA5551 for openGL

iphoneopengl-estextures

I'm creating an openGL game and so far I have been using .pngs in the RGBA8888 format as texture sheets, but those are too memory hungry, and my app crashes frequently. I read in Apple's site that such format such be used just when too much quality is needed, and recommends to use RGBA4444 and RGBA5551 instead ( I already converted my textures to PVR but the quality loss is too great in most of the sprite sheets).

I only need to use GL_UNSIGNED_SHORT_5_5_5_1 or GL_UNSIGNED_SHORT_4_4_4_4 in my glTexImage2D call inside my texture loader class in order to load my textures, but I need to convert my texture sheets to RGBA4444 and RGBA5551, and I'm clueless about how could I achieve this.

Best Answer

Seriously? There are libraries to do this kind of conversion. But frankly, this is a bit of bit twiddling. There are libraries that use asm, or specialized SSE commands to accellerate this which will be fast, but its pretty easy to roll your own format converter in C/C++. Your basic process would be:

  • Given a buffer of RGBA8888 encoded values
  • Create a buffer big enough to hold the RGBA4444 or RGBA5551 values. In this case, its simple - half the size.

  • Loop over the source buffer, unpacking each component, and repacking into the destination format, and write it into the destination buffer.

    void* rgba8888_to_rgba4444(
  void* src, // IN, pointer to source buffer
  int cb)    // IN size of source buffer, in bytes
{
  // this code assumes that a long is 4 bytes and short is 2.
  //on some compilers this isnt true
  int i;
  // compute the actual number of pixel elements in the buffer.
  int cpel = cb/4;
  unsigned long* psrc = (unsigned long*)src;
  // create the RGBA4444 buffer
  unsigned short* pdst = (unsigned short*)malloc(cpel*2);
  // convert every pixel
  for(i=0;i<cpel; i++)
  {
    // read a source pixel
    unsigned pel = psrc[i];
    // unpack the source data as 8 bit values
    unsigned r = p & 0xff;
    unsigned g = (pel >> 8) & 0xff;
    unsigned b = (pel >> 16) & 0xff; 
    unsigned a = (pel >> 24) & 0xff;
    //convert to 4 bit vales
    r >>= 4;
    g >>= 4;
    b >>= 4;
    a >>= 4;
    // and store
    pdst[i] = r | g << 4  | b << 8 | a << 12;
  }
  return pdst;
}

The actual conversion loop I did very wastefully, the components can be extracted, converted and repacked in a single pass, making for far faster code. I did it this way to make the conversion explicit, and easy to change. Also, im not sure that I got the component order the right way around. So it might be b, r, g, a, but it shouldn't effect the result of the function as it repackes in the same order into the dest buffer.

Related Topic