Added PCX image reading support

ChangeLog.md

     * No longer crashes simply by walking in the wrong place
     * Added walk Action, supposed to switch to slow walking/sidesteps
     * Removed unused Camera functionality (side and up vector)
+    * Wrote simple PCX image reading library with proof-of-concept
+      code to load the TR2 menu background as splash screen
 
     [ 20140517 ]
     * Wrote new assert() implementation for Unix that prints a call stack

TODO.md

 ## Changes
 
 * Using std::vector with [] is not bound checked. Segfaults were caused because the upper bound of the argument was never checked and garbage was returned... Do consistent checks, or use .at() as it throws an exception
-* Creating the Room class has introduced a bug that crashes when walking the level:
-
-    Assertion failed: (sector < (int)mRooms.at(room)->sizeSectors()), function isWall, file /Users/thomas/Projekte/OpenRaider/src/World.cpp, line 180.
-
 * The wrong SkeletalModels are used by entities, except for Lara...?
 
 ## Cmake
 ## Future Features
 
 * Use only assets from old TR games?
-* PCX image reading for eg. TR2 built-in menu background
+* [PCX image reading](http://bespin.org/~qz/pc-gpe/pcx.txt) for eg. TR2 built-in menu background
     * Cut TGA image reader, currently only used for menu background?!
 * When cutscene rendering is working, use TR4/5 style menu?
 

include/Camera.h

     void update();
 
     /*!
-     * \brief Rotate the camera
-     * \param angle angle in radians
-     * \param x X coordinate of axis
-     * \param y Y coordinate of axis
-     * \param z Z coordinate of axis
-     */
-    void rotate(vec_t angle, vec_t x, vec_t y, vec_t z);
-
-    /*!
      * \brief Sends interactive command to camera
      * \param cmd valid camera command
      */
     void command(enum camera_command cmd);
 
 private:
+
+    void rotate(vec_t angle, vec_t x, vec_t y, vec_t z);
+
     Quaternion mQ;         //!< Quaternion for rotation
     vec4_t mPos;           //!< Location in 3 space (aka eye)
     vec4_t mTarget;        //!< Postition we're looking at

include/global.h

 #include <GL/gl.h>
 #endif
 
+// If available, use our own assert that prints the call stack
 #if defined(HAVE_EXECINFO_H) && defined(HAVE_BACKTRACE) && defined(HAVE_BACKTRACE_SYMBOLS)
 #ifndef NDEBUG
 [[noreturn]] void assertImplementation(const char *exp, const char *file, int line);
 #define assert(x)
 #endif
 #else
+// Fall back to the default C assert
 #include <cassert>
 #endif
 
+// Colors used for Rendering
 const float BLACK[]       = {  0.0f,  0.0f,  0.0f, 1.0f };
 const float DIM_WHITE[]   = {  0.5f,  0.5f,  0.5f, 1.0f };
 const float WHITE[]       = {  1.0f,  1.0f,  1.0f, 1.0f };
 const float YELLOW[]      = {  1.0f,  1.0f,  0.0f, 1.0f };
 const float CYAN[]        = {  0.0f,  1.0f,  1.0f, 1.0f };
 
+// Actions that can be bound to a key and sent to the game engine
 typedef enum {
     menuAction = 0,
     consoleAction, // menu and console should always be the first two items
     ActionEventCount // Should always be at the end
 } ActionEvents;
 
+// Keys available for binding
 typedef enum {
     zeroKey = '0', oneKey = '1', twoKey = '2',
     threeKey = '3', fourKey = '4', fiveKey = '5',
     rightguiKey, rightbracketKey, rightshiftKey, scrolllockKey,
     semicolonKey, slashKey, spaceKey, tabKey,
     leftmouseKey, middlemouseKey, rightmouseKey,
-    unknownKey
+
+    unknownKey // Should always be at the end
 } KeyboardButton;
 
 #endif

include/utils/pcx.h

+/*!
+ * \file include/utils/pcx.h
+ * \brief PCX image reader
+ *
+ * Based on official technical documentation from ZSoft:
+ * http://bespin.org/~qz/pc-gpe/pcx.txt
+ *
+ * \author xythobuz
+ */
+
+#ifndef _UTILS_PCX_H_
+#define _UTILS_PCX_H_
+
+// Returns 0 on success
+int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height);
+
+#endif
+

src/Render.cpp

     if (mTexture.loadColorTexture(color, 32, 32) > -1)
         numTextures++;
 
+#ifdef PCX_PROOF_OF_CONCEPT
+    filename = bufferString("/Users/thomas/.OpenRaider/paks/tr2/TITLE.PCX");
+    if (mTexture.loadTGA(filename) > -1)
+        numTextures++;
+    delete [] filename;
+#else
     //! \fixme Error Checking. Return negative error code, check in calling place too
     filename = bufferString("%s/%s", textureDir, "splash.tga");
     if (mTexture.loadTGA(filename) > -1)
         numTextures++;
     delete [] filename;
+#endif
 
     return numTextures;
 }

src/Texture.cpp

 #include <stdarg.h>
 
 #include "global.h"
+#include "utils/pcx.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
 #include "Texture.h"
 }
 
 int Texture::loadTGA(const char *filename) {
+#ifdef PCX_PROOF_OF_CONCEPT
+    unsigned char *image;
+    unsigned int w, h;
+    int id = -1;
+    int error = pcxLoad(filename, &image, &w, &h);
+    if (error == 0) {
+        id = loadBuffer(image, w, h, RGBA, 32);
+        delete [] image;
+    }
+    return id;
+#else
     FILE *f;
     unsigned char *image = NULL;
     unsigned char *image2 = NULL;
     }
 
     return id;
+#endif
 }
 
 int Texture::nextPower(int seed) {

src/utils/CMakeLists.txt

 # Source files
+set (UTIL_SRCS ${UTIL_SRCS} "pcx.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "strings.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "tga.cpp")
 set (UTIL_SRCS ${UTIL_SRCS} "time.cpp")

src/utils/pcx.cpp

+/*!
+ * \file src/utils/pcx.cpp
+ * \brief PCX image reader
+ *
+ * Based on official technical documentation from ZSoft:
+ * http://bespin.org/~qz/pc-gpe/pcx.txt
+ *
+ * \author xythobuz
+ */
+
+#include <fstream>
+
+#include "global.h"
+#include "utils/pcx.h"
+
+#include "Console.h"
+
+#ifdef DEBUG
+#define pcxPrint getConsole().print
+#else
+void pcxPrint(...) { }
+#endif
+
+int pcxLoad(const char *filename, unsigned char **image, unsigned int *width, unsigned int *height) {
+    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;
+    }
+
+    // Read header informations
+    bool versionFive = (header[1] == 5);
+    bool compressed = (header[2] == 1);
+    //unsigned char bitsPerPixel = header[3];
+    unsigned int xMin = header[4] | (header[5] << 8);
+    unsigned int yMin = header[6] | (header[7] << 8);
+    unsigned int xMax = header[8] | (header[9] << 8);
+    unsigned int yMax = header[10] | (header[11] << 8);
+    //unsigned int hDPI = header[12] | (header[13] << 8);
+    //unsigned int vDPI = header[14] | (header[15] << 8);
+    //unsigned char *colormap = header + 16;
+    unsigned char nPlanes = header[65];
+    unsigned int bytesPerLine = header[66] | (header[67] << 8);
+    //unsigned int paletteInfo = header[68] | (header[69] << 8);
+    //unsigned int hScreenSize = header[70] | (header[71] << 8); // Only in some versionFive files
+    //unsigned int vScreenSize = header[72] | (header[73] << 8); // Only in some versionFive files
+
+    delete [] header;
+
+    // Calculations
+    *width = xMax - xMin + 1;
+    *height = yMax - yMin + 1;
+    unsigned long totalBytes = nPlanes * bytesPerLine; // total bytes per scan line
+    unsigned long imageSize = totalBytes * *height;
+    unsigned char *buffer = new unsigned char[imageSize];
+    unsigned long b = 0;
+
+    // Read encoded pixel data
+    for (unsigned long i = 0; i < imageSize;) {
+        unsigned int n = 1; // Run-length-encoding assumes 1
+        int c = file.get();
+        if (!file) {
+            pcxPrint("Could not read data (%lu%s)", i, (file.eof() ? " EOF" : ""));
+            delete buffer;
+            return -7;
+        }
+
+        // Run-Length-Encoding
+        if (compressed) {
+            if ((c & 0xC0) == 0xC0) {
+                n = c & 0x3F;
+                c = file.get();
+                if (!file) {
+                    pcxPrint("Could not read data rle (%lu%s)", i, (file.eof() ? " EOF" : ""));
+                    return -8;
+                }
+            }
+        }
+
+        for (unsigned int j = 0; j < n; j++)
+            buffer[b++] = (unsigned char)c;
+
+        i += n;
+    }
+
+    // Read color palette
+    unsigned char *palette = NULL;
+    if (versionFive) {
+        int c = file.get();
+        if ((c == 12) && file) {
+            palette = new unsigned char[768];
+            for (unsigned int i = 0; i < 768; i++) {
+                palette[i] = (unsigned char)file.get();
+                if (!file) {
+                    pcxPrint("Could not read 256 color palette (%d)", i);
+                    return -9;
+                }
+            }
+        }
+    }
+
+    // Bring buffer into preferred format
+    unsigned long size = *width * *height * 4;
+    *image = new unsigned char[size];
+    for (unsigned int y = 0; y < *height; y++) {
+        for (unsigned int x = 0; x < *width; x++) {
+            unsigned long baseIndex = (x + (y * *width)) * 4;
+            unsigned char alpha = 255, red = 0, green = 0, blue = 0;
+
+            if (palette != NULL) {
+                if (nPlanes == 1) {
+                    red = palette[buffer[(y * totalBytes) + x] * 3];
+                    green = palette[(buffer[(y * totalBytes) + x] * 3) + 1];
+                    blue = palette[(buffer[(y * totalBytes) + x] * 3) + 2];
+                } else {
+                    pcxPrint("Unsupported number of planes (%d)", nPlanes);
+                    delete [] buffer;
+                    delete [] *image;
+                    return -10;
+                }
+            } else {
+                if ((nPlanes == 3) || (nPlanes == 4)) {
+                    red = buffer[(y * totalBytes) + x];
+                    green = buffer[(y * totalBytes) + *width + x];
+                    blue = buffer[(y * totalBytes) + (2 * *width) + x];
+                    if (nPlanes == 4)
+                        alpha = buffer[(y * totalBytes) + (3 * *width) + x];
+                } else if (nPlanes == 1) {
+                    red = green = blue = buffer[(y * totalBytes) + x];
+                } else {
+                    pcxPrint("Unsupported number of planes (%d)", nPlanes);
+                    delete [] buffer;
+                    delete [] *image;
+                    return -11;
+                }
+            }
+
+            (*image)[baseIndex + 0] = red;
+            (*image)[baseIndex + 1] = green;
+            (*image)[baseIndex + 2] = blue;
+            (*image)[baseIndex + 3] = alpha;
+        }
+    }
+
+    if (palette != NULL)
+        delete [] palette;
+
+    return 0;
+}
+