Texture now TextureManager

ChangeLog.md

 
     [ 20140622 ]
     * Wrote simple image reader/writer utilizing libpng
+    * Created utils/pixels for pixel handling utilities
+    * Renamed Texture to TextureManager
+    * Added support for BGR(A) color types in TextureManager
+    * Added pngCheck() and pcxCheck() methods
+    * Added ColorMode and bpp info to pcx/png API
+    * Modified tga to match png/pcx API
 
     [ 20140621 ]
     * Created StaticMesh class replacing model_mesh_t stuff

include/Render.h

 #include <vector>
 
 #include "Room.h"
-#include "Texture.h"
+#include "TextureManager.h"
 #include "ViewVolume.h"
 
 /*!
 
     //! \fixme should be private
     ViewVolume mViewVolume; //!< View Volume for frustum culling
-    Texture mTexture; //!< Texture subsystem
+    TextureManager mTexture; //!< Texture subsystem
 
 private:
 

include/Texture.h → include/TextureManager.h

 /*!
- * \file include/Texture.h
+ * \file include/TextureManager.h
  * \brief Texture registry
  *
  * \author Mongoose
  * \author xythobuz
  */
 
-#ifndef _TEXTURE_H
-#define _TEXTURE_H
+#ifndef _TEXTURE_MANAGER_H
+#define _TEXTURE_MANAGER_H
 
 /*!
  * \brief Texture registry
  */
-class Texture {
+class TextureManager {
 public:
 
     enum ColorMode {
     /*!
     * \brief Constructs an object of Texture
     */
-    Texture();
+    TextureManager();
 
    /*!
     * \brief Deconstructs an object of Texture
     */
-    ~Texture();
+    ~TextureManager();
 
     /*!
      * \brief Resets all texture data
     void useMultiTexture(float aU, float aV, float bU, float bV);
 
 private:
-
-    int nextPower(int seed);
-
-    unsigned char *scaleBuffer(unsigned char *image, int width, int height,
-                                int components);
-
     unsigned int *mTextureIds;  //!< GL texture list
     unsigned int mTextureCount; //!< Texture counter
     unsigned int mTextureLimit; //!< The texture limit

include/global.h

 #define __attribute__(x)
 #endif
 
+//! \todo Replace NULL usage with nullptr
+#ifndef NULL
+#define NULL nullptr
+#endif
+
 // Globally include OpenGL header
 #ifdef __APPLE__
 #include <OpenGL/gl.h>

include/utils/pcx.h

 #ifndef _UTILS_PCX_H_
 #define _UTILS_PCX_H_
 
+#include "TextureManager.h"
+
+/*!
+ * \brief Check if a file is a valid PCX image
+ * \param filename path of file to read
+ * \returns 0 on success
+ */
+int pcxCheck(const char *filename);
+
 /*!
- * \brief Load a PCX image file into a RGBA buffer
+ * \brief Load a PCX image file into a buffer
  * \param filename path of file to read
- * \param image place where allocated buffer of size (width * height * 4) will be allocated
+ * \param image place where allocated buffer of size (width * height * (bpp / 8)) will be allocated
  * \param width place where image width will be stored
  * \param height place where image height will be stored
+ * \param mode place where Color Mode of image will be stored
+ * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height);
+int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp);
 
 #endif
 

include/utils/pixel.h

 #ifndef _UTILS_PIXEL_H_
 #define _UTILS_PIXEL_H_
 
+void bgr2rgb24(unsigned char *image, unsigned int w, unsigned int h);
+void bgra2rgba32(unsigned char *image, unsigned int w, unsigned int h);
 void argb2rgba32(unsigned char *image, unsigned int w, unsigned int h);
 
+unsigned char *scaleBuffer(unsigned char *image, int width, int height, int components);
+
 #endif
 

include/utils/png.h

 #ifndef _UTILS_PNG_H_
 #define _UTILS_PNG_H_
 
+#include "TextureManager.h"
+
+/*!
+ * \brief Check if a file is a valid PNG image
+ * \param filename path of file to read
+ * \returns 0 on success
+ */
+int pngCheck(const char *filename);
+
 /*!
  * \brief Load a PNG image file into an RGBA buffer
  * \param filename path of file to read
  * \param image place where allocated buffer of size (width * height * 4) will be allocated
  * \param width place where image width will be stored
  * \param height place where image height will be stored
+ * \param mode place where Color Mode of image will be stored
+ * \param bpp place where pixel width will be stored (8, 24, 32)
  * \returns 0 on success
  */
-int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height);
+int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp);
 
 /*!
  * \brief Create a PNG image file from an RGBA buffer
  * \param image buffer of size (width * height * 4)
  * \param width image width
  * \param height image height
+ * \param mode color mode
+ * \param bpp bits per pixel (8, 24, 32)
  * \returns 0 on success
  */
-int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height);
+int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height, TextureManager::ColorMode mode, unsigned int bpp);
 
 #endif
 

include/utils/tga.h

 #define _UTILS_TGA_H
 
 /*!
- * \brief Possible TGA image types
- */
-typedef enum {
-    TGA_TYPE__NO_DATA    = 0,
-    TGA_TYPE__MAPPED     = 1,
-    TGA_TYPE__COLOR      = 2,
-    TGA_TYPE__GREYSCALE  = 3,
-    TGA_TYPE__MAPPED_RLE = 9,
-    TGA_TYPE__COLOR_RLE  = 10
-    // TGA_TYPE__GREYSCALE_COMPRESSED  = 11,
-    // TGA_TYPE__COLOR_HUFFMAN_DELTA_RLE  = 32,
-    // TGA_TYPE__COLOR_HUFFMAN_DELTA_RLE_4PASS  = 33
-} tga_type_t;
-
-/*!
- * \brief Data structure representing TGA file header
- */
-typedef struct {
-    unsigned char comment_lenght;       //!< Number of bytes in comment
-    unsigned char colormap_type;        //!< 0 No colormap; 1 Has colormap
-    unsigned char image_type;           //!< 1 Colormapped; 2 Unmapped; 9 Colormapped RLE; 10 Unmapped RLE
-    unsigned short colormap_index;      //!< Index of first color map entry
-    unsigned short colormap_lenght;     //!< Number of color map entries
-    unsigned char colormap_bbp;         //!< 16, 24, or 32 bits per pixel format
-    unsigned short origin_x;            //!< X coor of lower-left corner
-    unsigned short origin_y;            //!< Y coor of lower-left corner
-    unsigned short width;               //!< Width in pixels
-    unsigned short height;              //!< Height in pixels
-    unsigned char bpp;                  //!< Number of bits in a pixel index
-    unsigned char desc_flags;           //!< Various magic bits
-} tga_t;
-
-/*!
  * \brief Check if a file is a valid TGA image
  * \param f file to be checked
  * \returns 0 if valid, else error condition
 int tgaSave(FILE *f, unsigned char *image,
                 unsigned int width, unsigned int height, char type);
 
-/*!
- * \brief Save a pixel buffer into a file on disk
- * \param image pixmap to be stored
- * \param width width of pixmap/image
- * \param height height of pixmap/image
- * \param type tga type to use
- * \param s format string for file path/name
- * \returns 0 on success, else error condition
- */
-int tgaSaveFilename(unsigned char *image,
-                        unsigned int width, unsigned int height,
-                        char type, const char *s, ...)
-    __attribute__((format(printf, 5, 6)));
-
 #endif
 

src/CMakeLists.txt

 set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "Sprite.cpp")
 set (SRCS ${SRCS} "StaticMesh.cpp")
-set (SRCS ${SRCS} "Texture.cpp")
+set (SRCS ${SRCS} "TextureManager.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
 set (SRCS ${SRCS} "ViewVolume.cpp")
 set (SRCS ${SRCS} "Window.cpp")

src/Render.cpp

     // Capture frame buffer
     glReadPixels(0, 0, getWindow().getWidth(), getWindow().getHeight(), GL_BGR_EXT, GL_UNSIGNED_BYTE, image);
 
-    tgaSaveFilename(image, getWindow().getWidth(), getWindow().getHeight(), 0, "%s", filename);
-    printf("Took screenshot '%s'.\n", filename);
+    FILE *f = fopen(filename, "wb");
+    if (f) {
+        tgaSave(f, image, getWindow().getWidth(), getWindow().getHeight(), 0);
+        printf("Took screenshot '%s'.\n", filename);
+    }
 
     delete [] filename;
     delete [] image;
         unsigned int id)
 {
     glColor3fv(WHITE);
-    mTexture.loadBufferSlot(image, width, height, Texture::RGBA, 32, id);
+    mTexture.loadBufferSlot(image, width, height, TextureManager::RGBA, 32, id);
 }
 
 
     mTexture.setMaxTextureCount(128);  /* TR never needs more than 32 iirc
                                           However, color texturegen is a lot */
 
-    mTexture.setFlag(Texture::fUseMipmaps);
+    mTexture.setFlag(TextureManager::fUseMipmaps);
 
     color[0] = 0xff;
     color[1] = 0xff;

src/StaticMesh.cpp

         gColorTextureHACK.push_back(colorI);
         texture = getGame().getTextureOffset() + gColorTextureHACK.size();
 
-        getRender().loadTexture(Texture::generateColorTexture(color, 32, 32),
+        getRender().loadTexture(TextureManager::generateColorTexture(color, 32, 32),
                 32, 32, texture);
     } else {
         texture = getGame().getTextureOffset() + foundIndex;

src/Texture.cpp → src/TextureManager.cpp

 /*!
- * \file src/Texture.cpp
+ * \file src/TextureManager.cpp
  * \brief Texture registry
  *
  * \author Mongoose
 #include "utils/pixel.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
-#include "Texture.h"
+#include "TextureManager.h"
 
-Texture::Texture() {
+TextureManager::TextureManager() {
     mTextureIds = NULL;
     mFlags = 0;
     mTextureId = -1;
     mTextureLimit = 0;
 }
 
-Texture::~Texture() {
+TextureManager::~TextureManager() {
     reset();
 }
 
-unsigned char *Texture::generateColorTexture(unsigned char rgba[4],
+unsigned char *TextureManager::generateColorTexture(unsigned char rgba[4],
         unsigned int width, unsigned int height) {
     unsigned char *image;
     unsigned int i, size;
     return image;
 }
 
-int Texture::loadColorTexture(unsigned char rgba[4],
+int TextureManager::loadColorTexture(unsigned char rgba[4],
         unsigned int width, unsigned int height) {
     unsigned char *image;
     int id;
     return id;
 }
 
-void Texture::setFlag(TextureFlag flag) {
+void TextureManager::setFlag(TextureFlag flag) {
     mFlags |= flag;
 }
 
-void Texture::clearFlag(TextureFlag flag) {
+void TextureManager::clearFlag(TextureFlag flag) {
     mFlags &= ~flag;
 }
 
-void Texture::reset() {
+void TextureManager::reset() {
     if (mTextureIds) {
         glDeleteTextures(mTextureLimit, mTextureIds);
         delete [] mTextureIds;
     mTextureLimit = 0;
 }
 
-void Texture::disableMultiTexture() {
+void TextureManager::disableMultiTexture() {
     mFlags ^= fUseMultiTexture;
     mTextureId = -1;
     mTextureId2 = -1;
     glActiveTextureARB(GL_TEXTURE0_ARB);
 }
 
-void Texture::useMultiTexture(float aU, float aV, float bU, float bV) {
+void TextureManager::useMultiTexture(float aU, float aV, float bU, float bV) {
     if (!(mFlags & fUseMultiTexture))
         return;
 
     glMultiTexCoord2fARB(GL_TEXTURE1_ARB, bU, bV);
 }
 
-void Texture::useMultiTexture(float u, float v) {
+void TextureManager::useMultiTexture(float u, float v) {
     if (!(mFlags & fUseMultiTexture))
         return;
 
     glMultiTexCoord2fARB(GL_TEXTURE1_ARB, u, v);
 }
 
-void Texture::bindMultiTexture(int texture0, int texture1) {
+void TextureManager::bindMultiTexture(int texture0, int texture1) {
     assert(mTextureIds != NULL);
     assert(texture0 >= 0);
     assert((unsigned int)texture0 <= mTextureCount);
     glBindTexture(GL_TEXTURE_2D, mTextureIds[texture1]);
 }
 
-void Texture::setMaxTextureCount(unsigned int n) {
+void TextureManager::setMaxTextureCount(unsigned int n) {
     assert(n > 0);
 
     mTextureLimit = n;
     glGenTextures(n, mTextureIds);
 }
 
-int Texture::getTextureCount() {
+int TextureManager::getTextureCount() {
     return mTextureCount - 1;
 }
 
-int Texture::loadBuffer(unsigned char *image,
+int TextureManager::loadBuffer(unsigned char *image,
         unsigned int width, unsigned int height,
         ColorMode mode, unsigned int bpp) {
     int id;
     return id;
 }
 
-int Texture::loadBufferSlot(unsigned char *image,
+int TextureManager::loadBufferSlot(unsigned char *image,
         unsigned int width, unsigned int height,
         ColorMode mode, unsigned int bpp,
         unsigned int slot) {
     switch (mode) {
         case GREYSCALE:
             if (bpp != 8) {
-                printf("Texture::Load ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 1;
 
         case RGB:
             if (bpp != 24) {
-                printf("Texture::Load ERROR Unsupported RGB, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported RGB, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 3;
             if (bpp == 32) {
                 argb2rgba32(image, width, height);
             } else {
-                printf("Texture::Load ERROR Unsupported ARGB, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported ARGB, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 4;
 
         case RGBA:
             if (bpp != 32) {
-                printf("Texture::Load ERROR Unsupported RGBA, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported RGBA, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 4;
 
         case BGR:
             if (bpp != 24) {
-                printf("Texture::Load ERROR Unsupported BGR, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported BGR, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 3;
 
         case BGRA:
             if (bpp != 32) {
-                printf("Texture::Load ERROR Unsupported BGRA, %i bpp\n", bpp);
+                printf("TextureManager::Load ERROR Unsupported BGRA, %i bpp\n", bpp);
                 return -1;
             }
             bytes = 4;
     return slot;
 }
 
-void Texture::bindTextureId(unsigned int n) {
+void TextureManager::bindTextureId(unsigned int n) {
     assert(mTextureIds != NULL);
     assert(n <= mTextureCount);
 
     glBindTexture(GL_TEXTURE_2D, mTextureIds[n]);
 }
 
-int Texture::loadPCX(const char *filename) {
+int TextureManager::loadPCX(const char *filename) {
     unsigned char *image;
-    unsigned int w, h;
+    unsigned int w, h, bpp;
+    ColorMode c;
     int id = -1;
-    int error = pcxLoad(filename, &image, &w, &h);
+    int error = pcxLoad(filename, &image, &w, &h, &c, &bpp);
     if (error == 0) {
-        id = loadBuffer(image, w, h, RGBA, 32);
+        id = loadBuffer(image, w, h, c, bpp);
         delete [] image;
     }
     return id;
 }
 
-int Texture::loadTGA(const char *filename) {
+int TextureManager::loadTGA(const char *filename) {
     FILE *f;
     unsigned char *image = NULL;
     unsigned char *image2 = NULL;
         image2 = scaleBuffer(image, w, h, (type == 4) ? 4 : 3);
 
         if (image2) {
+            delete [] image;
             image = image2;
             w = h = 256;
         }
     }
 
     if (id == -1) {
-        printf("Texture::loadTGA> ERROR: Failed to load '%s'\n", filename);
+        printf("TextureManager::loadTGA> ERROR: Failed to load '%s'\n", filename);
     }
 
     return id;
 }
 
-int Texture::nextPower(int seed) {
-    int i = 1;
-    for (; i < seed; i *= 2);
-    return i;
-}
-
-/* This code based off on gluScaleImage()  */
-unsigned char *Texture::scaleBuffer(unsigned char *image,
-        int width, int height, int components) {
-    int i, j, k;
-    float* tempin;
-    float* tempout;
-    float sx, sy;
-    //int components = 3;
-    unsigned char *timage;
-    int original_height = height;
-    int original_width = width;
-
-    assert(image != NULL);
-    assert(width > 0);
-    assert(height > 0);
-
-    height = nextPower(height);
-    width = nextPower(width);
-
-    if (height > 256)
-        height = 256;
-
-    if (width > 256)
-        width = 256;
-
-    // Check to see if scaling is needed
-    if (height == original_height && width == original_width)
-        return NULL;
-
-    //printf("%i\n", components);
-
-    timage = new unsigned char[height * width * components];
-    tempin = new float[original_width * original_height * components * sizeof(float)];
-    tempout = new float[width * height * components * sizeof(float)];
-
-    // Copy user data to float format.
-    for (i = 0; i < original_height * original_width * components; ++i) {
-        tempin[i] = (float)image[i];
-    }
-
-    // Determine which filter to use by checking ratios.
-    if (width > 1) {
-        sx = (float)(original_width - 1) / (float)(width - 1);
-    } else {
-        sx = (float)(original_width - 1);
-    }
-
-    if (height > 1) {
-        sy = (float)(original_height - 1) / (float) (height - 1);
-    } else {
-        sy = (float)(original_height - 1);
-    }
-
-    if (sx < 1.0 && sy < 1.0) {
-        /* Magnify both width and height:  use weighted sample of 4 pixels */
-        for (i = 0; i < height; ++i) {
-            int i0 = (int)(i * sy);
-            int i1 = i0 + 1;
-
-            if (i1 >= original_height) {
-                i1 = original_height - 1;
-            }
-
-            float alpha = i * sy - i0;
-
-            for (j = 0; j < width; ++j) {
-                int j0 = (int) (j * sx);
-                int j1 = j0 + 1;
-
-                if (j1 >= original_width) {
-                    j1 = original_width - 1;
-                }
-
-                float beta = j * sx - j0;
-
-                /* Compute weighted average of pixels in rect (i0,j0)-(i1,j1) */
-                float *src00 = tempin + (i0 * original_width + j0) * components;
-                float *src01 = tempin + (i0 * original_width + j1) * components;
-                float *src10 = tempin + (i1 * original_width + j0) * components;
-                float *src11 = tempin + (i1 * original_width + j1) * components;
-
-                float *dst = tempout + (i * width + j) * components;
-
-                for (k = 0; k < components; ++k) {
-                    float s1 = *src00++ * (1.0f - beta) + *src01++ * beta;
-                    float s2 = *src10++ * (1.0f - beta) + *src11++ * beta;
-                    *dst++ = s1 * (1.0f - alpha) + s2 * alpha;
-                }
-            }
-        }
-    } else {
-        /* Shrink width and/or height:  use an unweighted box filter */
-        for (i = 0; i < height; ++i) {
-            int i0 = (int) (i * sy);
-            int i1 = i0 + 1;
-
-            if (i1 >= original_height) {
-                i1 = original_height - 1;
-            }
-
-            for (j = 0; j < width; ++j) {
-                int j0 = (int) (j * sx);
-                int j1 = j0 + 1;
-
-                if (j1 >= original_width) {
-                    j1 = original_width - 1;
-                }
-
-                float *dst = tempout + (i * width + j) * components;
-
-                /* Compute average of pixels in the rectangle (i0,j0)-(i1,j1) */
-                for (k = 0; k < components; ++k) {
-                    float sum = 0.0;
-
-                    for (int ii = i0; ii <= i1; ++ii) {
-                        for (int jj = j0; jj <= j1; ++jj) {
-                            sum += *(tempin + (ii * original_width + jj)
-                                    * components + k);
-                        }
-                    }
-
-                    sum /= ( j1 - j0 + 1 ) * ( i1 - i0 + 1 );
-                    *dst++ = sum;
-                }
-            }
-        }
-    }
-
-    // Copy to our results.
-    for (i = 0; i < height * width * components; ++i) {
-        timage[i] = (unsigned char)tempout[i];
-    }
-
-    // Delete our temp buffers.
-    delete[] tempin;
-    delete[] tempout;
-    delete[] image;
-
-    return timage;
-}
-

src/utils/pcx.cpp

 void pcxPrint(...) { }
 #endif
 
-int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height) {
+int pcxCheck(const char *filename) {
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+
+    std::ifstream file(filename, std::ios::in | std::ios::binary);
+
+    // Read raw PCX header, 128 bytes
+    unsigned char *header = new unsigned char[128];
+
+    // Basic validation
+    if (!file.read((char *)(&header[0]), 128)) {
+        pcxPrint("File not big enough for valid PCX header!");
+        delete [] header;
+        return -1;
+    }
+
+    if (header[0] != 0x0A) {
+        pcxPrint("Magic number at file start is wrong (0x%X != 0x0A)", header[0]);
+        delete [] header;
+        return -2;
+    }
+
+    if ((header[1] != 0) && ((header[1] < 2) || (header[1] > 5))) {
+        // Valid: 0, 2, 3, 4, 5
+        pcxPrint("Unknown PCX file format version (%d)", header[1]);
+        delete [] header;
+        return -3;
+    }
+
+    if ((header[2] != 0) && (header[2] != 1)) {
+        pcxPrint("Unknown PCX file encoding (%d)", header[2]);
+        delete [] header;
+        return -4;
+    }
+
+    if (header[3] != 8) {
+        pcxPrint("Only supporting 8bit (%dbit)", header[3]);
+        delete [] header;
+        return -5;
+    }
+
+    if (header[64] != 0) {
+        pcxPrint("Reserved field is  used (%d != 0)", header[64]);
+        delete [] header;
+        return -6;
+    }
+
+    delete [] header;
+    return 0;
+}
+
+int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp) {
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+    assert(image != NULL);
+    assert(width != NULL);
+    assert(height != NULL);
+    assert(mode != NULL);
+    assert(bpp != NULL);
+
     std::ifstream file(filename, std::ios::in | std::ios::binary);
 
     // Read raw PCX header, 128 bytes
         }
     }
 
+    *mode = TextureManager::RGBA;
+    *bpp = 32;
+
     delete [] buffer;
     delete [] palette;
-
     return 0;
 }
 

src/utils/pixel.cpp

 #include "global.h"
 #include "utils/pixel.h"
 
+void bgr2rgb24(unsigned char *image, unsigned int w, unsigned int h) {
+    assert(image != nullptr);
+    assert(w > 0);
+    assert(h > 0);
+
+    for (unsigned int i = 0; i < (w * h); ++i) {
+        /* 24-bit BGR to RGB */
+        unsigned char swap = image[(i * 3) + 2];
+        image[(i * 3) + 2] = image[(i * 3)];
+        image[(i * 3)] = swap;
+    }
+}
+
+void bgra2rgba32(unsigned char *image, unsigned int w, unsigned int h) {
+    assert(image != nullptr);
+    assert(w > 0);
+    assert(h > 0);
+
+    for (unsigned int i = 0; i < (w * h); ++i) {
+        /* 32-bit BGRA to RGBA */
+        unsigned char swap = image[(i * 4) + 2];
+        image[(i * 4) + 2] = image[(i * 4)];
+        image[(i * 4)] = swap;
+    }
+}
+
 void argb2rgba32(unsigned char *image, unsigned int w, unsigned int h) {
     assert(image != nullptr);
     assert(w > 0);
     }
 }
 
+#define NEXT_POWER(x) do {        \
+    int i;                        \
+    for (i = 1; i < (x); i *= 2); \
+    x = i;                        \
+} while (false);
+
+// This code based off on gluScaleImage()
+unsigned char *scaleBuffer(unsigned char *image, int width, int height, int components) {
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
+    assert((components == 3) || (components == 4));
+
+    int original_height = height;
+    int original_width = width;
+
+    NEXT_POWER(height);
+    NEXT_POWER(width);
+
+    if (height > 256)
+        height = 256;
+
+    if (width > 256)
+        width = 256;
+
+    // Check to see if scaling is needed
+    if (height == original_height && width == original_width)
+        return NULL;
+
+    unsigned char *timage = new unsigned char[height * width * components];
+    float *tempin = new float[original_width * original_height * components];
+    float *tempout = new float[width * height * components];
+
+    // Copy user data to float format.
+    for (int i = 0; i < original_height * original_width * components; ++i) {
+        tempin[i] = (float)image[i];
+    }
+
+    // Determine which filter to use by checking ratios.
+    float sx;
+    if (width > 1) {
+        sx = (float)(original_width - 1) / (float)(width - 1);
+    } else {
+        sx = (float)(original_width - 1);
+    }
+
+    float sy;
+    if (height > 1) {
+        sy = (float)(original_height - 1) / (float) (height - 1);
+    } else {
+        sy = (float)(original_height - 1);
+    }
+
+    if (sx < 1.0 && sy < 1.0) { // Magnify both width and height: use weighted sample of 4 pixels
+        for (int i = 0; i < height; ++i) {
+            int i0 = (int)(i * sy);
+            int i1 = i0 + 1;
+
+            if (i1 >= original_height) {
+                i1 = original_height - 1;
+            }
+
+            float alpha = i * sy - i0;
+
+            for (int j = 0; j < width; ++j) {
+                int j0 = (int) (j * sx);
+                int j1 = j0 + 1;
+
+                if (j1 >= original_width) {
+                    j1 = original_width - 1;
+                }
+
+                float beta = j * sx - j0;
+
+                // Compute weighted average of pixels in rect (i0,j0)-(i1,j1)
+                float *src00 = tempin + (i0 * original_width + j0) * components;
+                float *src01 = tempin + (i0 * original_width + j1) * components;
+                float *src10 = tempin + (i1 * original_width + j0) * components;
+                float *src11 = tempin + (i1 * original_width + j1) * components;
+
+                float *dst = tempout + (i * width + j) * components;
+
+                for (int k = 0; k < components; ++k) {
+                    float s1 = *src00++ * (1.0f - beta) + *src01++ * beta;
+                    float s2 = *src10++ * (1.0f - beta) + *src11++ * beta;
+                    *dst++ = s1 * (1.0f - alpha) + s2 * alpha;
+                }
+            }
+        }
+    } else { // Shrink width and/or height: use an unweighted box filter
+        for (int i = 0; i < height; ++i) {
+            int i0 = (int) (i * sy);
+            int i1 = i0 + 1;
+
+            if (i1 >= original_height) {
+                i1 = original_height - 1;
+            }
+
+            for (int j = 0; j < width; ++j) {
+                int j0 = (int) (j * sx);
+                int j1 = j0 + 1;
+
+                if (j1 >= original_width) {
+                    j1 = original_width - 1;
+                }
+
+                float *dst = tempout + (i * width + j) * components;
+
+                // Compute average of pixels in the rectangle (i0,j0)-(i1,j1)
+                for (int k = 0; k < components; ++k) {
+                    float sum = 0.0;
+
+                    for (int ii = i0; ii <= i1; ++ii) {
+                        for (int jj = j0; jj <= j1; ++jj) {
+                            sum += *(tempin + (ii * original_width + jj)
+                                    * components + k);
+                        }
+                    }
+
+                    sum /= (j1 - j0 + 1) * (i1 - i0 + 1);
+                    *dst++ = sum;
+                }
+            }
+        }
+    }
+
+    // Copy to our results.
+    for (int i = 0; i < height * width * components; ++i) {
+        timage[i] = (unsigned char)tempout[i];
+    }
+
+    // Delete our temp buffers.
+    delete [] tempin;
+    delete [] tempout;
+
+    return timage;
+}
+

src/utils/png.cpp

 #include <cstdio>
 
 #include "global.h"
+#include "utils/pixel.h"
 #include "utils/png.h"
 
 #ifdef DEBUG
 void pngPrint(...) { }
 #endif
 
-int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height) {
+int pngCheck(const char *filename) {
+    png_byte header[8];
+
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+
+    FILE *fp = fopen(filename, "rb");
+    if (fp == NULL) {
+        pngPrint("Could not open %s", filename);
+        return -1;
+    }
+
+    fread(header, 1, 8, fp);
+    fclose(fp);
+
+    if (png_sig_cmp(header, 0, 8)) {
+        pngPrint("File %s is not a PNG.", filename);
+        return -2;
+    }
+
+    return 0;
+}
+
+int pngLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height, TextureManager::ColorMode *mode, unsigned int *bpp) {
     png_byte header[8];
 
     assert(filename != NULL);
     assert(image != NULL);
     assert(width != NULL);
     assert(height != NULL);
+    assert(mode != NULL);
+    assert(bpp != NULL);
 
     FILE *fp = fopen(filename, "rb");
     if (fp == NULL) {
     delete [] row_pointers;
     fclose(fp);
 
-    // Fix alpha
-    if (color_type != PNG_COLOR_TYPE_RGB_ALPHA) {
-        unsigned char *tmpimage = image_data;
-        image_data = new unsigned char[*width * *height * 4];
-        if (color_type == PNG_COLOR_TYPE_RGB) {
-            for (unsigned int i = 0; i < (*width * *height); i++) {
-                image_data[i * 4] = tmpimage[i * 3];
-                image_data[(i * 4) + 1] = tmpimage[(i * 3) + 1];
-                image_data[(i * 4) + 2] = tmpimage[(i * 3) + 2];
-                image_data[(i * 4) + 3] = 255;
-            }
-        } else {
-            pngPrint("%s: Unknown libpng color type %d.", filename, color_type);
-            delete [] image_data;
-            delete [] tmpimage;
-            return -8;
-        }
-        delete [] tmpimage;
+    if (color_type == PNG_COLOR_TYPE_GRAY) {
+        *mode = TextureManager::GREYSCALE;
+        *bpp = 8;
+    } else if (color_type == PNG_COLOR_TYPE_RGB) {
+        *mode = TextureManager::RGB;
+        *bpp = 24;
+    } else if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
+        *mode = TextureManager::RGBA;
+        *bpp = 32;
+    } else {
+        pngPrint("%s: Unknown libpng color type %d.", filename, color_type);
+        delete [] image_data;
+        return -8;
     }
 
     // Flip
-    *image = new unsigned char[*width * *height * 4];
+    *image = new unsigned char[*width * *height * (*bpp / 8)];
     for (unsigned int y = 0; y < (*height); y++) {
         for (unsigned int x = 0; x < (*width); x++) {
-            (*image)[((y * *width) + x) * 4] = image_data[(((*height - y - 1) * *width) + x) * 4];
-            (*image)[(((y * *width) + x) * 4) + 1] = image_data[((((*height - y - 1) * *width) + x) * 4) + 1];
-            (*image)[(((y * *width) + x) * 4) + 2] = image_data[((((*height - y - 1) * *width) + x) * 4) + 2];
-            (*image)[(((y * *width) + x) * 4) + 3] = image_data[((((*height - y - 1) * *width) + x) * 4) + 3];
+            (*image)[((y * *width) + x) * (*bpp / 8)]
+                = image_data[(((*height - y - 1) * *width) + x) * (*bpp / 8)];
+            (*image)[(((y * *width) + x) * (*bpp / 8)) + 1]
+                = image_data[((((*height - y - 1) * *width) + x) * (*bpp / 8)) + 1];
+            (*image)[(((y * *width) + x) * (*bpp / 8)) + 2]
+                = image_data[((((*height - y - 1) * *width) + x) * (*bpp / 8)) + 2];
+            (*image)[(((y * *width) + x) * (*bpp / 8)) + 3]
+                = image_data[((((*height - y - 1) * *width) + x) * (*bpp / 8)) + 3];
         }
     }
 
     return 0;
 }
 
-int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height) {
+int pngSave(const char *filename, unsigned char *image, unsigned int width, unsigned int height, TextureManager::ColorMode mode, unsigned int bpp) {
     assert(filename != NULL);
     assert(filename[0] != '\0');
     assert(image != NULL);
         return -5;
     }
 
+    int color_type;
+    if ((mode == TextureManager::GREYSCALE) && (bpp == 8)) {
+        color_type = PNG_COLOR_TYPE_GRAY;
+    } else if (((mode == TextureManager::RGB) || (mode == TextureManager::BGR)) && (bpp == 24)) {
+        if (mode == TextureManager::BGR) {
+            bgr2rgb24(image, width, height);
+        }
+        color_type = PNG_COLOR_TYPE_RGB;
+    } else if (((mode == TextureManager::RGBA) || (mode == TextureManager::BGRA)) && (bpp == 32)) {
+        if (mode == TextureManager::BGRA) {
+            bgra2rgba32(image, width, height);
+        }
+        color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+    } else {
+        pngPrint("Error invalid color mode");
+        fclose(fp);
+        return -6;
+    }
+
     png_set_IHDR(png_ptr, info_ptr, width, height,
-            8, PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
+            8, color_type, PNG_INTERLACE_NONE,
             PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
 
     png_write_info(png_ptr, info_ptr);
         pngPrint("Error during writing bytes");
         delete [] row_pointers;
         fclose(fp);
-        return -6;
+        return -7;
     }
 
     png_write_image(png_ptr, row_pointers);
         pngPrint("Error during end of write");
         delete [] row_pointers;
         fclose(fp);
-        return -7;
+        return -8;
     }
 
     png_write_end(png_ptr, NULL);

src/utils/tga.cpp

 #include "global.h"
 #include "utils/tga.h"
 
+typedef enum {
+    //TGA_TYPE__NO_DATA    = 0,
+    //TGA_TYPE__MAPPED     = 1,
+    TGA_TYPE__COLOR      = 2,
+    TGA_TYPE__GREYSCALE  = 3,
+    //TGA_TYPE__MAPPED_RLE = 9,
+    TGA_TYPE__COLOR_RLE  = 10
+} tga_type_t;
+
+typedef struct {
+    unsigned char comment_lenght;   //!< Number of bytes in comment
+    unsigned char colormap_type;    //!< 0 No colormap; 1 Has colormap
+    unsigned char image_type;       //!< 1 Colormapped; 2 Unmapped; 9 Colormapped RLE; 10 Unmapped RLE
+    unsigned short colormap_index;  //!< Index of first color map entry
+    unsigned short colormap_lenght; //!< Number of color map entries
+    unsigned char colormap_bbp;     //!< 16, 24, or 32 bits per pixel format
+    unsigned short origin_x;        //!< X coor of lower-left corner
+    unsigned short origin_y;        //!< Y coor of lower-left corner
+    unsigned short width;           //!< Width in pixels
+    unsigned short height;          //!< Height in pixels
+    unsigned char bpp;              //!< Number of bits in a pixel index
+    unsigned char desc_flags;       //!< Various magic bits
+} tga_t;
+
 int tgaCheck(FILE *f) {
     char buffer[10];
 
     return 0;
 }
 
-int tgaSaveFilename(unsigned char *image, unsigned int width, unsigned int height, char type, const char *s, ...) {
-    char buffer[1024];
-    FILE *f;
-    int v;
-    va_list args;
-
-    assert(image != NULL);
-    assert(width > 0);
-    assert(height > 0);
-    assert(s != NULL);
-    assert(s[0] != '\0');
-
-    va_start(args, s);
-    vsnprintf(buffer, 1023, s, args);
-    va_end(args);
-    f = fopen(buffer, "wb");
-    if (!f) {
-        perror(buffer);
-        return -1;
-    }
-    v = tgaSave(f, image, width, height, type);
-    fclose(f);
-    return v;
-}
-