Various little fixes

TODO.md

         * Don't even new ... the data structures but use std::make_shared or allocate_shared?
         * Pass object references to all other objects that need it, completely remove gOpenRaider
     * Use streams for (file) I/O
+        * Does not need strtok() anymore
     * Use std::strings
 
 ## Changes

include/Console.h

 #include <cstring>
 #include <vector>
 
-#include "Window.h"
-
 /*!
  * \brief Console 'overlay'
  */

include/Menu.h

 
 private:
 
-#ifdef WIN32
-    void loadPakFolderHelper(std::vector<char *> &list);
-#endif
-
     void loadPakFolderRecursive(const char *dir);
 
     void fillMapList();

include/Window.h

 
     virtual int initializeFont() = 0;
 
-    virtual void writeString(WindowString *s) = 0;
+    virtual void writeString(WindowString &s) = 0;
 
     virtual void drawText(unsigned int x, unsigned int y, float scale, const float color[4], const char *s, ...)
         __attribute__((format(printf, 6, 0))) = 0;

include/WindowSDL.h

 
     virtual int initializeFont();
 
-    virtual void writeString(WindowString *s);
+    virtual void writeString(WindowString &s);
 
     virtual void drawText(unsigned int x, unsigned int y, float scale, const float color[4], const char *s, ...)
         __attribute__((format(printf, 6, 0)));

src/Menu.cpp

     return mVisible;
 }
 
-#ifdef WIN32
-void Menu::loadPakFolderHelper(std::vector<char *> &list) {
-
-}
-#endif
-
 void Menu::loadPakFolderRecursive(const char *dir) {
     assert(dir != NULL);
     assert(dir[0] != '\0');
         glRecti(0, 0, getWindow().mWidth, getWindow().mHeight);
         glEnable(GL_TEXTURE_2D);
 
-        // Draw heading text
+        // Draw heading text, using WindowString so we can get the
+        // width of the drawn text to center it
         mainText.x = (getWindow().mWidth / 2) - (mainText.w / 2);
-        getWindow().writeString(&mainText);
+        getWindow().writeString(mainText);
 
         if (!mMapListFilled) {
             getWindow().drawText(25, (getWindow().mHeight / 2) - 20, 0.75f, OR_BLUE, "Generating map list...");

src/OpenRaider.cpp

     if (strcmp(var, "size") == 0) {
         // value has format like "\"1024x768\""
         unsigned int w = DEFAULT_WIDTH, h = DEFAULT_HEIGHT;
-        if (sscanf(value, "\"%5dx%5d\"", &w, &h) != 2) {
+        if (sscanf(value, "\"%5ux%5u\"", &w, &h) != 2) {
             getConsole().print("set-size-Error: Invalid value (%s)", value);
             return -2;
         }

src/Render.cpp

 
 void Render::screenShot(char *filenameBase)
 {
-    FILE *f;
     int sz = getWindow().mWidth * getWindow().mHeight;
     unsigned char *image = new unsigned char[sz * 3];
     char *filename = NULL;
     while (!done) {
         filename = bufferString("%s-%04i.tga", filenameBase, count++);
 
-        f = fopen(filename, "rb");
+        FILE *f = fopen(filename, "rb");
 
         if (f)
             fclose(f);
     f[0] = lookAtX - eyeX;
     f[1] = lookAtY - eyeY;
     f[2] = lookAtZ - eyeZ;
-    float fMag, upMag;
-    fMag = sqrtf(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
-    upMag = sqrtf(upX * upX + upY * upY + upZ * upZ);
+
+    float fMag = sqrtf(f[0] * f[0] + f[1] * f[1] + f[2] * f[2]);
+    //float upMag = sqrtf(upX * upX + upY * upY + upZ * upZ);
 
     // normalizing the viewing vector
     f[0] = f[0] / fMag;

src/Sprite.cpp

 
     for (unsigned int j = 0; j < 8; j++)
         texel[j / 2][j % 2] = spriteTexCoords[j];
+
+    radius = 0.0f;
 }
 
 void Sprite::display() {

src/Texture.cpp

 void convertARGB32bppToRGBA32bpp(unsigned char *image,
         unsigned int w, unsigned int h) {
     unsigned int i, size = w * h;
-    unsigned char swap;
 
     assert(image != NULL);
     assert(w > 0);
 
     for (i = 0; i < size; ++i) {
         /* 32-bit ARGB to RGBA */
-        swap = image[(i * 4) + 3];
+        unsigned char 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];
 
     if (sx < 1.0 && sy < 1.0) {
         /* Magnify both width and height:  use weighted sample of 4 pixels */
-        int i0, i1, j0, j1;
-        float alpha, beta;
-        float* src00;
-        float* src01;
-        float* src10;
-        float* src11;
-        float s1, s2;
-        float* dst;
-
         for (i = 0; i < height; ++i) {
-            i0 = (int)(i * sy);
-            i1 = i0 + 1;
+            int i0 = (int)(i * sy);
+            int i1 = i0 + 1;
 
             if (i1 >= original_height) {
                 i1 = original_height - 1;
             }
 
-            alpha = i * sy - i0;
+            float alpha = i * sy - i0;
 
             for (j = 0; j < width; ++j) {
-                j0 = (int) (j * sx);
-                j1 = j0 + 1;
+                int j0 = (int) (j * sx);
+                int j1 = j0 + 1;
 
                 if (j1 >= original_width) {
                     j1 = original_width - 1;
                 }
 
-                beta = j * sx - j0;
+                float beta = j * sx - j0;
 
                 /* Compute weighted average of pixels in rect (i0,j0)-(i1,j1) */
-                src00 = tempin + (i0 * original_width + j0) * components;
-                src01 = tempin + (i0 * original_width + j1) * components;
-                src10 = tempin + (i1 * original_width + j0) * components;
-                src11 = tempin + (i1 * original_width + j1) * components;
+                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;
 
-                dst = tempout + (i * width + j) * components;
+                float *dst = tempout + (i * width + j) * components;
 
                 for (k = 0; k < components; ++k) {
-                    s1 = *src00++ * (1.0f - beta) + *src01++ * beta;
-                    s2 = *src10++ * (1.0f - beta) + *src11++ * beta;
+                    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 */
-        int i0, i1;
-        int j0, j1;
-        int ii, jj;
-        float sum;
-        float* dst;
-
         for (i = 0; i < height; ++i) {
-            i0 = (int) (i * sy);
-            i1 = i0 + 1;
+            int i0 = (int) (i * sy);
+            int i1 = i0 + 1;
 
             if (i1 >= original_height) {
                 i1 = original_height - 1;
             }
 
             for (j = 0; j < width; ++j) {
-                j0 = (int) (j * sx);
-                j1 = j0 + 1;
+                int j0 = (int) (j * sx);
+                int j1 = j0 + 1;
 
                 if (j1 >= original_width) {
                     j1 = original_width - 1;
                 }
 
-                dst = tempout + (i * width + j) * components;
+                float *dst = tempout + (i * width + j) * components;
 
                 /* Compute average of pixels in the rectangle (i0,j0)-(i1,j1) */
                 for (k = 0; k < components; ++k) {
-                    sum = 0.0;
+                    float sum = 0.0;
 
-                    for (ii = i0; ii <= i1; ++ii) {
-                        for (jj = j0; jj <= j1; ++jj) {
+                    for (int ii = i0; ii <= i1; ++ii) {
+                        for (int jj = j0; jj <= j1; ++jj) {
                             sum += *(tempin + (ii * original_width + jj)
                                     * components + k);
                         }
     }
 
     // Copy to our results.
-    for( i = 0; i < height * width * components; ++i) {
+    for (i = 0; i < height * width * components; ++i) {
         timage[i] = (unsigned char)tempout[i];
     }
 

src/ViewVolume.cpp

 }
 
 bool ViewVolume::isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius) {
-    vec_t d;
     for (unsigned int p = 0; p < 6; ++p) {
-        d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
+        vec_t d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
         if (d <= -radius)
             return false;
     }

src/WindowSDL.cpp

     mFontInit = false;
     mFontName = NULL;
     mFont = NULL;
+    mFontTexture = 0;
 
 #ifdef WIN32
     setDriver("libGL32.dll");
     return 0;
 }
 
-void WindowSDL::writeString(WindowString *s) {
-    assert(s != NULL);
-    assert(s->text != NULL);
+void WindowSDL::writeString(WindowString &s) {
+    assert(s.text != NULL);
     assert(mInit == true);
 
     SDL_Color color;
-    color.r = (unsigned char)(s->color[0] * 255.0f);
-    color.g = (unsigned char)(s->color[1] * 255.0f);
-    color.b = (unsigned char)(s->color[2] * 255.0f);
-    color.a = (unsigned char)(s->color[3] * 255.0f);
+    color.r = (unsigned char)(s.color[0] * 255.0f);
+    color.g = (unsigned char)(s.color[1] * 255.0f);
+    color.b = (unsigned char)(s.color[2] * 255.0f);
+    color.a = (unsigned char)(s.color[3] * 255.0f);
 
-    SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s->text, color);
+    SDL_Surface *surface = TTF_RenderUTF8_Blended(mFont, s.text, color);
     if (surface == NULL) {
         printf("TTF_RenderUTF8_Blended Error: %s\n", TTF_GetError());
         return;
     }
 
-    s->w = (int)((float)surface->w * s->scale);
-    s->h = (int)((float)surface->h * s->scale);
+    s.w = (int)((float)surface->w * s.scale);
+    s.h = (int)((float)surface->h * s.scale);
 
     GLenum textureFormat;
     if (surface->format->BytesPerPixel == 4) {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexImage2D(GL_TEXTURE_2D, 0, surface->format->BytesPerPixel, surface->w, surface->h, 0, textureFormat, GL_UNSIGNED_BYTE, surface->pixels);
 
-    GLuint xMin = s->x;
-    GLuint yMin = s->y;
-    GLuint xMax = xMin + (int)((float)surface->w * s->scale);
-    GLuint yMax = yMin + (int)((float)surface->h * s->scale);
+    GLuint xMin = s.x;
+    GLuint yMin = s.y;
+    GLuint xMax = xMin + s.w;
+    GLuint yMax = yMin + s.h;
 
     glColor4f(color.r / 256.0f, color.g / 256.0f, color.b / 256.0f, color.a / 256.0f);
 
         tempText.color[2] = color[2];
         tempText.color[3] = color[3];
     }
-    writeString(&tempText);
+    writeString(tempText);
 }
 

src/utils/pcx.cpp

         int c = file.get();
         if (!file) {
             pcxPrint("Could not read data (%lu%s)", i, (file.eof() ? " EOF" : ""));
-            delete buffer;
+            delete [] buffer;
             return -7;
         }
 
                 c = file.get();
                 if (!file) {
                     pcxPrint("Could not read data rle (%lu%s)", i, (file.eof() ? " EOF" : ""));
+                    delete [] buffer;
                     return -8;
                 }
             }
                 palette[i] = (unsigned char)file.get();
                 if (!file) {
                     pcxPrint("Could not read 256 color palette (%d)", i);
+                    delete [] buffer;
+                    delete [] palette;
                     return -9;
                 }
             }
                     pcxPrint("Unsupported number of planes (%d)", nPlanes);
                     delete [] buffer;
                     delete [] *image;
+                    if (palette != NULL)
+                        delete [] palette;
                     return -10;
                 }
             } else {
                     pcxPrint("Unsupported number of planes (%d)", nPlanes);
                     delete [] buffer;
                     delete [] *image;
+                    if (palette != NULL)
+                        delete [] palette;
                     return -11;
                 }
             }
         }
     }
 
+    delete [] buffer;
+
     if (palette != NULL)
         delete [] palette;