Fixed strange Texture offset in GL, added asserts.

include/Texture.h

     enum TextureFlag {
         fUseMipmaps      = (1 << 0),
         fUseMultiTexture = (1 << 1),
-        fUseSDL_TTF      = (1 << 2)
     };
 
     /*!

src/Render.cpp

     char filename[128];
     int snow1_id;
     int snow2_id;
-    int bg_id;
     unsigned int numTextures = 0;
     unsigned char color[4];
 
-
     // We want to update as needed later
     mNumTexturesLoaded = numLoaded;
     mNextTextureId = nextId;
     color[3] = 0xff;
 
     if (mTexture.loadColorTexture(color, 32, 32) > -1)
-    {
-        ++numTextures;
-    }
+        numTextures++;
 
     snprintf(filename, 126, "%s/%s", textureDir, "splash.tga");
     filename[127] = 0;
 
-    if ((bg_id = mTexture.loadTGA(filename)) > -1)
-    {
-        ++numTextures;
-    }
+    if (mTexture.loadTGA(filename) > -1)
+        numTextures++;
 
     snprintf(filename, 126, "%s/%s", textureDir, "snow.tga");
     filename[127] = 0;
 
     if ((snow1_id = mTexture.loadTGA(filename)) > -1)
-    {
-        ++numTextures;
-    }
+        numTextures++;
 
     snprintf(filename, 126, "%s/%s", textureDir, "snow2.tga");
     filename[127] = 0;
 
     if ((snow2_id = mTexture.loadTGA(filename)) > -1)
-    {
-        ++numTextures;
-    }
+        numTextures++;
 
     // Weird that it isn't linear, must be some storage deal in Texture
     // I forgot about Id allocation
     glTranslatef(0.0f, 0.0f, -2000.0f);
     glRotatef(180.0f, 1.0f, 0.0f, 0.0f);
 
-    glBindTexture(GL_TEXTURE_2D, 2); //! \fixme store texture id somewhere
+    glBindTexture(GL_TEXTURE_2D, 3); //! \fixme store texture id somewhere
 
     glBegin(GL_TRIANGLE_STRIP);
     glTexCoord2f(1.0, 1.0);

src/Texture.cpp

 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 
 #ifdef __APPLE__
 #include <OpenGL/gl.h>
 #include "utils/tga.h"
 #include "Texture.h"
 
-#define TEXTURE_OFFSET -1
-
 Texture::Texture() {
     mTextureIds = NULL;
     mFlags = 0;
     unsigned char *image;
     unsigned int i, size;
 
+    assert(rgba != NULL);
+    assert(width > 0);
+    assert(height > 0);
+
     image = new unsigned char[height*width*4];
 
     for (i = 0, size = width*height; i < size; ++i) {
     unsigned char *image;
     int id;
 
+    assert(rgba != NULL);
+    assert(width > 0);
+    assert(height > 0);
+
     image = generateColorTexture(rgba, width, height);
     id = loadBuffer(image, width, height, RGBA, 32);
     delete [] image;
         delete [] mTextureIds;
     }
 
-    mTextureIds = 0x0;
+    mTextureIds = NULL;
     mTextureCount = 0;
     mTextureLimit = 0;
 }
 }
 
 void Texture::bindMultiTexture(int texture0, int texture1) {
-    if (//(int)a == mTextureId && (int)b == mTextureId2 ||
-            !mTextureIds ||
-            texture0 < 0 || texture0 > (int)mTextureCount ||
-            texture1 < 0 || texture1 > (int)mTextureCount) {
-        return;
-    }
+    assert(mTextureIds != NULL);
+    assert(texture0 >= 0);
+    assert((unsigned int)texture0 <= mTextureCount);
+    assert(texture1 >= 0);
+    assert((unsigned int)texture1 <= mTextureCount);
 
     mFlags |= fUseMultiTexture;
     mTextureId  = texture0;
 
     glActiveTextureARB(GL_TEXTURE0_ARB);
     glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture0] + TEXTURE_OFFSET);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture0]);
 
     glActiveTextureARB(GL_TEXTURE1_ARB);
     glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture1] + TEXTURE_OFFSET);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds[texture1]);
 }
 
 void Texture::setMaxTextureCount(unsigned int n) {
+    assert(n > 0);
+
     mTextureLimit = n;
 
     mTextureIds = new unsigned int[n];
 }
 
 int Texture::getTextureCount() {
-    return (mTextureCount-1);
+    return mTextureCount - 1;
 }
 
 int Texture::loadBuffer(unsigned char *image,
         ColorMode mode, unsigned int bpp) {
     int id;
 
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
+    assert((bpp == 8) || (bpp == 24) || (bpp == 32));
+
     id = loadBufferSlot(image, width, height, mode, bpp, mTextureCount++);
 
     if (id < 0)
         return id;
 
-    return ++id;
+    return id;
 }
 
 void convertARGB32bppToRGBA32bpp(unsigned char *image,
         unsigned int w, unsigned int h) {
-    unsigned int i, size = w*h;
+    unsigned int i, size = w * h;
     unsigned char swap;
 
-    for (i = 0; i < size; ++i)
-    {
+    assert(image != NULL);
+    assert(w > 0);
+    assert(h > 0);
+
+    for (i = 0; i < size; ++i) {
         /* 32-bit ARGB to RGBA */
-        swap = image[i*4+3];
-        image[i*4]   = image[i*4+1];
-        image[i*4+1] = image[i*4+2];
-        image[i*4+2] = image[i*4+3];
-        image[i*4+3] = swap;
+        swap = image[(i * 4) + 3];
+        image[(i * 4)] = image[(i * 4) + 1];
+        image[(i * 4) + 1] = image[(i * 4) + 2];
+        image[(i * 4) + 2] = image[(i * 4) + 3];
+        image[(i * 4) + 3] = swap;
     }
 }
 
     unsigned char bytes;
     unsigned int glcMode;
 
-
-    if (!mTextureIds || slot >= mTextureLimit) {
-        printf("Texture::Load> ERROR Not initialized or out of free slots\n");
-        return -1000;
-    }
-
-    if (!width || !height || !image) {
-        printf("Texture::Load> ERROR Assertion 'image is valid' failed\n");
-        return -1;
-    }
+    assert(mTextureIds != NULL);
+    assert(slot < mTextureLimit);
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
+    assert((bpp == 8) || (bpp == 24) || (bpp == 32));
 
     switch (mode) {
         case GREYSCALE:
             if (bpp != 8) {
-                printf("Texture::Load> ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
-                return -2;
+                printf("Texture::Load ERROR Unsupported GREYSCALE, %i bpp\n", bpp);
+                return -1;
             }
             bytes = 1;
             glcMode = GL_LUMINANCE;
             break;
         case RGB:
             if (bpp != 24) {
-                printf("Texture::Load> ERROR Unsupported RGB, %i bpp\n", bpp);
-                return -2;
+                printf("Texture::Load ERROR Unsupported RGB, %i bpp\n", bpp);
+                return -1;
             }
             bytes = 3;
             glcMode = GL_RGB;
             if (bpp == 32) {
                 convertARGB32bppToRGBA32bpp(image, width, height);
             } else {
-                printf("Texture::Load> ERROR Unsupported ARGB, %i bpp\n", bpp);
-                return -2;
+                printf("Texture::Load ERROR Unsupported ARGB, %i bpp\n", bpp);
+                return -1;
             }
             bytes = 4;
             glcMode = GL_RGBA;
             break;
         case RGBA:
             if (bpp != 32) {
-                printf("Texture::Load> ERROR Unsupported RGBA, %i bpp\n", bpp);
-                return -2;
+                printf("Texture::Load ERROR Unsupported RGBA, %i bpp\n", bpp);
+                return -1;
             }
             bytes = 4;
             glcMode = GL_RGBA;
 
     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[slot] + TEXTURE_OFFSET);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds[slot]);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 }
 
 void Texture::bindTextureId(unsigned int n) {
-    if ((int)n == mTextureId || !mTextureIds || n > mTextureCount) {
-        return;
-    }
+    assert(mTextureIds != NULL);
+    assert((int)n != mTextureId);
+    assert(n <= mTextureCount);
 
     mTextureId = n;
 
     glEnable(GL_TEXTURE_2D);
     //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
-    glBindTexture(GL_TEXTURE_2D, mTextureIds[n] + TEXTURE_OFFSET);
+    glBindTexture(GL_TEXTURE_2D, mTextureIds[n]);
 }
 
 void Texture::glScreenShot(char *base, unsigned int width, unsigned int height) {
     static int count = 0;
     bool done = false;
 
-    if (!image || !width || !height) {
-        if (image)
-            delete [] image;
-
-        printf("glScreenShot> ERROR: Couldn't allocate image!\n");
-        return;
-    }
+    assert(base != NULL);
+    assert(width > 0);
+    assert(height > 0);
 
     // Don't overwrite files
     while (!done) {
     char type;
     int id = -1;
 
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+
     f = fopen(filename, "rb");
 
     if (!f) {
 }
 
 int Texture::nextPower(int seed) {
-    int i;
-    for (i = 1; i < seed; i *= 2);
+    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 width, int height, int components) {
     int i, j, k;
     float* tempin;
     float* tempout;
     int original_height = height;
     int original_width = width;
 
-    if (!image || !width || !height)
-        return NULL;
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
 
     height = nextPower(height);
     width = nextPower(width);