Re-added utils

include/utils/math.h

@@ -0,0 +1,71 @@
+/*!
+ *
+ * \file include/utils/math.h
+ * \brief Vector and Matrix math
+ *
+ * \author Mongoose
+ */
+
+#include <math.h>
+
+#ifndef _UTILS_MATH_H
+#define _UTILS_MATH_H
+
+#define HEL_PI           ((float)M_PI) //!< pi
+#define HEL_2_PI         (HEL_PI * 2.0f) //!< pi*2
+#define HEL_PI_OVER_4    (HEL_PI / 4.0f) //!< pi/4
+#define HEL_PI_OVER_180  (HEL_PI / 180.0f) //!< pi/180
+#define HEL_180_OVER_PI  (180.0f / HEL_PI) //!< 180/pi
+
+#define HEL_RAD_TO_DEG(x) ((x) * HEL_180_OVER_PI) //!< Convert radians to degrees
+#define HEL_DEG_TO_RAD(x) ((x) * HEL_PI_OVER_180) //!< Convert degrees to radians
+
+typedef float vec_t;        //!< 1D Vector, aka float
+typedef float vec2_t[2];    //!< 2D Vector
+typedef float vec3_t[3];    //!< 3D Vector
+typedef float vec4_t[4];    //!< 4D Vector
+typedef vec_t matrix_t[16]; //!< Used as _Column_major_ in every class now!
+
+/*!
+ * \brief Compare two floats with an Epsilon.
+ * \param a first float
+ * \param b second float
+ * \returns true if a and b are probably the same.
+ */
+bool equalEpsilon(vec_t a, vec_t b);
+
+/*!
+ * \brief Calculate Intersection of a line and a polygon
+ * \param intersect Where the intersection is stored, if it exists
+ * \param p1 First point of line segment
+ * \param p2 Second point of line segment
+ * \param polygon polygon vertex array (0 to 2 are used)
+ * \returns 0 if there is no intersection
+ */
+int helIntersectionLineAndPolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t *polygon);
+
+/*!
+ * \brief Calculate the length of a line segment / the distance between two points
+ * \param a First point
+ * \param b Second point
+ * \returns distance/length
+ */
+vec_t helDist3v(vec3_t a, vec3_t b);
+
+/*!
+ * \brief Calculates the midpoint between two points / of a line segment
+ * \param a First point
+ * \param b Second point
+ * \param mid Midpoint will be stored here
+ */
+void helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid);
+
+/*!
+ * \brief Calculates a pseudo-random number
+ * \param from Lower bound of resulting number
+ * \param to Upper bound
+ * \returns random number
+ */
+vec_t helRandomNum(vec_t from, vec_t to);
+
+#endif

include/utils/strings.h

@@ -0,0 +1,61 @@
+/*!
+ * \file include/utils/strings.h
+ * \brief String handling utilities
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#ifndef _UTILS_STRINGS_H_
+#define _UTILS_STRINGS_H_
+
+/*!
+ * \brief Check if a string ends with another string.
+ * \param str string to check
+ * \param suffix suffix for which to check
+ * \returns true if str ends with suffix
+ */
+bool stringEndsWith(const char *str, const char *suffix);
+
+/*!
+ * \brief Generates a buffered string for the printf call
+ * \param string format string like for printf
+ * \param args arguments matching format string
+ * \returns string in a buffer
+ */
+char *bufferString(const char *string, va_list args) __attribute__((format(printf, 1, 0)));
+
+/*!
+ * \brief Generates a buffered string for the printf call
+ * \param string format string like for printf
+ * \returns string in a buffer
+ */
+char *bufferString(const char *string, ...) __attribute__((format(printf, 1, 2)));
+
+/*!
+ * \brief Expansion of unix home enviroment char.
+ * Also makes sure string ends in "end" char.
+ * \param path path string
+ * \param end end character. 0 appends no additional char
+ * \returns allocated string of path with expansions
+ */
+char *fullPath(const char *path, char end);
+
+/*!
+ * \brief Checks if Command matches Symbol.
+ * Returns the rest of the argument list back in command buffer, if any
+ * \param symbol command string
+ * \param command with arguments
+ * \returns true if command matches symbol
+ */
+bool rc_command(const char *symbol, char *command);
+
+/*!
+ * \brief Interpret a string as a bool
+ * \param buffer "true" or "false"
+ * \param val is set to boolean interpretation of buffer
+ * \returns -1 for null string, -2 if string is not "true" or "false"
+ */
+int rc_get_bool(const char *buffer, bool *val);
+
+#endif

include/utils/tga.h

@@ -0,0 +1,89 @@
+/*!
+ * \file include/utils/tga.h
+ * \brief TGA image reader/writer
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+#ifndef _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 tgaCheck(FILE *f);
+
+/*!
+ * \brief Load a TGA image from file
+ * \param f valid image file
+ * \param image Where the pixmap will be stored (or NULL)
+ * \param width where the width will be stored
+ * \param height where the height will be stored
+ * \param type where the type will be stored (tga_type_t)
+ * \returns 0 on success, else error condition
+ */
+int tgaLoad(FILE *f, unsigned char **image,
+                unsigned int *width, unsigned int *height, char *type);
+
+/*!
+ * \brief Save a pixel buffer into a file on disk
+ * \param f file in which image will be saved
+ * \param image pixmap to be stored
+ * \param width width of pixmap/image
+ * \param height height of pixmap/image
+ * \param type tga type to use
+ * \returns 0 on success, 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

include/utils/time.h

@@ -0,0 +1,32 @@
+/*!
+ * \file include/utils/time.h
+ * \brief Time handling utilities
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#ifndef _UTILS_TIME_H_
+#define _UTILS_TIME_H_
+
+#if defined(linux) || defined(__APPLE__)
+#include <time.h>
+#include <sys/time.h>
+#endif
+
+extern struct timeval system_timer_start; //!< System timer start time
+extern struct timeval system_timer_stop; //!< System timer last read time
+extern struct timezone system_timer_tz; //!< System timer timezone info
+
+/*!
+ * \brief Read the system timer
+ * \returns number of ticks
+ */
+unsigned int systemTimerGet();
+
+/*!
+ * \brief Reset the system timer
+ */
+void systemTimerReset();
+
+#endif

src/CMakeLists.txt

@@ -66,7 +66,7 @@ set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${OpenRaider_CXX_FLAGS} ${O
 set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${OpenRaider_CXX_FLAGS} ${OpenRaider_CXX_FLAGS_RELEASE}")
 
 # Add utils directory
-# add_subdirectory (utils)
+add_subdirectory (utils)
 
 # Add Executable
 add_executable (OpenRaider MACOSX_BUNDLE ${SRCS})
@@ -148,7 +148,7 @@ include_directories (SYSTEM ${ZLIB_INCLUDE_DIRS})
 set (LIBS ${LIBS} ${ZLIB_LIBRARIES})
 
 # Add utils Library
-# set (LIBS ${LIBS} utilities)
+set (LIBS ${LIBS} utilities)
 
 # Link to all found libs
 target_link_libraries (OpenRaider ${LIBS})

src/utils/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Source files
+set (UTIL_SRCS ${UTIL_SRCS} "math.cpp")
+set (UTIL_SRCS ${UTIL_SRCS} "strings.cpp")
+set (UTIL_SRCS ${UTIL_SRCS} "tga.cpp")
+set (UTIL_SRCS ${UTIL_SRCS} "time.cpp")
+
+# Include directory
+include_directories ("${PROJECT_SOURCE_DIR}/include")
+
+# Add library
+add_library (utilities ${UTIL_SRCS})

src/utils/math.cpp

@@ -0,0 +1,137 @@
+/*!
+ *
+ * \file src/utils/math.cpp
+ * \brief Vector and Matrix math
+ *
+ * \author Mongoose
+ */
+
+#include <stdlib.h>
+#include <math.h>
+#include <float.h>
+#include <assert.h>
+
+#include "utils/Vector3d.h"
+#include "utils/Matrix.h"
+#include "utils/math.h"
+
+bool equalEpsilon(vec_t a, vec_t b) {
+    vec_t epsilon = FLT_EPSILON;
+    if (fabs(a - b) <= (fmax(fabs(a), fabs(b)) * epsilon))
+        return true;
+    return false;
+}
+
+
+inline vec_t square(vec_t a)
+{
+    return a * a;
+}
+
+
+int helIntersectionLineAndPolygon(vec3_t intersect,
+        vec3_t p1, vec3_t p2,
+        vec3_t *polygon)
+{
+    assert(polygon != NULL);
+
+    //  vec3_t normal, a, b;
+    Vector3d a, b, normal, pA, pB;
+    vec_t d, denominator, mu;
+
+
+    pA = Vector3d(p1);
+    pB = Vector3d(p2);
+
+    // Find normal
+    a = Vector3d(polygon[1]) - Vector3d(polygon[0]);
+    b = Vector3d(polygon[2]) - Vector3d(polygon[0]);
+    normal = Vector3d::cross(a, b);
+    normal.normalize();
+
+    // find D
+    //d = (normal[0] * polygon[0][0] -
+    //    normal[1] * polygon[0][1] -
+    //    normal[2] * polygon[0][2]);
+    d = (normal.mVec[0] * polygon[0][0] -
+            normal.mVec[1] * polygon[0][1] -
+            normal.mVec[2] * polygon[0][2]);
+
+    // line segment parallel to plane?
+    a = pB - pA;
+
+    //denominator = (normal[0] * a[0] +
+    //                  normal[1] * a[1] +
+    //                  normal[2] * a[2]);
+    denominator = Vector3d::dot(normal, a);
+
+    if (denominator > 0.0)
+        return 0;
+
+    // Line segment contains intercept point?
+    //mu = - ((d + normal[0] * p1[0] + normal[1] * p1[1] + normal[2] * p1[2]) /
+    //        denominator);
+    mu = -((d + Vector3d::dot(normal, pA)) / denominator);
+
+    if (mu < 0.0 || mu > 1.0)
+        return 0;
+
+    //intersect[0] = p1[0] + mu * a[0];
+    //intersect[1] = p1[1] + mu * a[1];
+    //intersect[2] = p1[2] + mu * a[2];
+    b = pA + (a * mu);
+    intersect[0] = b.mVec[0];
+    intersect[1] = b.mVec[1];
+    intersect[2] = b.mVec[2];
+
+
+    // See if the intercept is bound by polygon by winding number
+    // assume convex polygons here for sure
+    double theta = Vector3d::dot(b - Vector3d(polygon[0]), normal); // b = intersect
+
+    if (theta >= 90.0) // Yeah I know
+        return 0;
+
+    return 1;
+}
+
+
+vec_t helDist3v(vec3_t a, vec3_t b)
+{
+    return (sqrtf( ((b[0] - a[0]) * (b[0] - a[0])) +
+                ((b[1] - a[1]) * (b[1] - a[1])) +
+                ((b[2] - a[2]) * (b[2] - a[2]))));
+}
+
+
+void helMidpoint3v(vec3_t a, vec3_t b, vec3_t mid)
+{
+    mid[0] = (a[0] + b[0]) / 2.0f;
+    mid[1] = (a[1] + b[1]) / 2.0f;
+    mid[2] = (a[2] + b[2]) / 2.0f;
+}
+
+
+vec_t helNorm4v(vec4_t v)
+{
+    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2] + v[3]*v[3]));
+}
+
+
+vec_t helNorm3v(vec3_t v)
+{
+    return (sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]));
+}
+
+
+vec_t helNorm2v(vec2_t v)
+{
+    return (sqrtf(v[0]*v[0] + v[1]*v[1]));
+}
+
+
+vec_t helRandomNum(vec_t from, vec_t to)
+{
+    return from + ((to - from) * rand() / (RAND_MAX + 1.0f));
+}
+

src/utils/strings.cpp

@@ -0,0 +1,171 @@
+/*!
+ * \file include/utils/strings.h
+ * \brief String handling utilities
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#include <cstdarg>
+#include <cstdlib>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#if defined(unix) || defined(__APPLE__)
+#include <wordexp.h>
+#endif
+
+#include "utils/strings.h"
+
+bool stringEndsWith(const char *str, const char *suffix) {
+    assert(str != NULL);
+    assert(suffix != NULL);
+
+    size_t lenstr = strlen(str);
+    size_t lensuffix = strlen(suffix);
+
+    if (lensuffix > lenstr)
+        return false;
+
+    return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
+}
+
+char *bufferString(const char *string, va_list args) {
+    int sz = 60;
+    int n;
+    char *text;
+
+    assert(string != NULL);
+    assert(string[0] != '\0');
+
+    text = new char[sz];
+
+    n = vsnprintf(text, sz, string, args);
+
+    if (n < 0) {
+        delete [] text;
+        return NULL; // encoding error
+    } else if (n >= sz) {
+        sz = n + 1; // buffer too small
+        delete [] text;
+        text = new char[sz];
+        n = vsnprintf(text, sz, string, args);
+    }
+
+    return text;
+}
+
+char *bufferString(const char *string, ...) {
+    va_list args;
+    va_start(args, string);
+    char *text = bufferString(string, args);
+    va_end(args);
+    return text;
+}
+
+char *fullPath(const char *path, char end) {
+    unsigned int lenPath, offset;
+    wordexp_t word;
+    char *dir;
+
+    assert(path != NULL);
+    assert(path[0] != '\0');
+
+    if (path[0] == '~') {
+#if defined(unix) || defined(__APPLE__)
+#ifdef __APPLE__
+        // Workaround for Mac OS X. See:
+        // http://stackoverflow.com/questions/20534788/why-does-wordexp-fail-with-wrde-syntax-on-os-x
+        signal(SIGCHLD, SIG_DFL);
+#endif
+        // Expand string into segments
+        int res = wordexp(path, &word, 0);
+#ifdef __APPLE__
+        signal(SIGCHLD, SIG_IGN);
+#endif
+        if (res != 0) {
+            printf("fullPath> wordexp() failed: %d\n", res);
+            return NULL;
+        }
+
+        // Get length of complete string
+        lenPath = 0;
+        for (unsigned int i = 0; i < word.we_wordc; i++) {
+            lenPath += strlen(word.we_wordv[i]);
+        }
+
+        // Allocate new string
+        dir = new char[lenPath + 2]; // space for end char
+
+        // Copy segments into new string
+        offset = 0;
+        for (unsigned int i = 0; i < word.we_wordc; i++) {
+            unsigned int len = strlen(word.we_wordv[i]);
+            strncpy(dir + offset, word.we_wordv[i], len);
+            offset += len;
+        }
+
+        wordfree(&word);
+#else
+        printf("WARNING: Tilde expansion not supported on this platform!\n");
+        lenPath = strlen(path);
+        dir = new char[lenPath + 2]; // space for end char
+        strncpy(dir, path, lenPath);
+#endif
+    } else {
+        lenPath = strlen(path);
+        dir = new char[lenPath + 2]; // space for end char
+        strncpy(dir, path, lenPath);
+    }
+
+    // Make sure ends in "end" char
+    if ((lenPath > 0) && (end != 0) && (dir[lenPath - 1] != end)) {
+        dir[lenPath] = end;
+        dir[lenPath + 1] = 0;
+    } else {
+        dir[lenPath] = 0;
+    }
+
+    return dir;
+}
+
+bool rc_command(const char *symbol, char *command) {
+    assert(symbol != NULL);
+    assert(symbol[0] != '\0');
+    assert(command != NULL);
+    assert(command[0] != '\0');
+
+    int lens = strlen(symbol);
+
+    if (strncmp(command, symbol, lens) == 0) {
+        int lenc = strlen(command);
+
+        //! \fixme Should ignore whitespace, but only if it is really there...?
+        // lens+1 skips '=' or ' '
+        for (int i = 0, j = lens+1; j < lenc; ++i, ++j) {
+            command[i] = command[j];
+            command[i+1] = 0;
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+int rc_get_bool(const char *buffer, bool *val) {
+    assert(buffer != NULL);
+    assert(buffer[0] != '\0');
+    assert(val != NULL);
+
+    if ((buffer[0] == '1') || (strncmp(buffer, "true", 4) == 0))
+        *val = true;
+    else if ((buffer[0] == '0') || (strncmp(buffer, "false", 5) == 0))
+        *val = false;
+    else
+        return -2;
+
+    return 0;
+}
+

src/utils/tga.cpp

@@ -0,0 +1,382 @@
+/*!
+ * \file src/utils/tga.cpp
+ * \brief TGA image reader/writer
+ *
+ * \todo type should pass more info (2 bits for RGBA|RGB|GREY; val for depth)
+ *
+ * \author Mongoose
+ * \author xythobuz
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#include "utils/tga.h"
+
+int tgaCheck(FILE *f) {
+    char buffer[10];
+
+    assert(f != NULL);
+
+    /* Read the header */
+    fseek(f, 0, SEEK_SET);
+    fread(buffer, 8, 1, f);
+
+    // buffer[1] = 0 - Means not color mapped (1 would mean mapped)
+    if (!(buffer[1] == 0 && (buffer[2] == TGA_TYPE__COLOR ||
+                    //buffer[2] == TGA_TYPE__GREYSCALE ||
+                    buffer[2] == TGA_TYPE__COLOR_RLE))) {
+        printf("tgaCheck> Inavlid or unknown TGA format.\n");
+        return -2;
+    }
+    return 0;
+}
+
+int tgaLoad(FILE *f, unsigned char **image, unsigned int *width, unsigned int *height, char *type) {
+    tga_t header;
+    char comment[256];
+    unsigned char pixel[4];
+    unsigned char *swap_row = NULL;
+    unsigned char tmp, packet;
+    bool must_flip = 0;
+    unsigned int size;
+    unsigned int i, j;
+
+    assert(f != NULL);
+    assert(image != NULL);
+    assert(width != NULL);
+    assert(height != NULL);
+    assert(type != NULL);
+
+    fseek(f, 0, SEEK_SET);
+
+    // Read TGA header
+    fread(&header.comment_lenght, 1, 1, f);
+    fread(&header.colormap_type, 1, 1, f);
+    fread(&header.image_type, 1, 1, f);
+    fread(&header.colormap_index, 2, 1, f);
+    fread(&header.colormap_lenght, 2, 1, f);
+    fread(&header.colormap_bbp, 1, 1, f);
+
+    fread(&tmp, 1, 1, f);
+    header.origin_x = tmp;
+    fread(&tmp, 1, 1, f);
+    header.origin_x += tmp * 256;
+
+    fread(&tmp, 1, 1, f);
+    header.origin_y = tmp;
+    fread(&tmp, 1, 1, f);
+    header.origin_y += tmp * 256;
+
+    fread(&tmp, 1, 1, f);
+    header.width = tmp;
+    fread(&tmp, 1, 1, f);
+    header.width += tmp * 256;
+
+    fread(&tmp, 1, 1, f);
+    header.height = tmp;
+    fread(&tmp, 1, 1, f);
+    header.height += tmp * 256;
+
+    fread(&header.bpp, 1, 1, f);
+    fread(&header.desc_flags, 1, 1, f);
+
+    *width = header.width;
+    *height = header.height;
+
+    switch (header.bpp) {
+        case 32:
+            *type = 2; //32;
+            break;
+        case 24:
+            *type = 1; //24;
+            break;
+        case 8:
+        default:
+            *type = 0; //8;
+            break;
+    }
+
+#ifdef DEBUG_TGA
+    printf("TGA [%ix%i@%ibpp, %it, %ix, %iy, %uf]\n",
+            header.width, header.height, header.bpp, header.image_type,
+            header.origin_x, header.origin_y,
+            header.desc_flags);
+#endif
+
+    // Comments can be 0 - 255
+    if (header.comment_lenght) {
+        fread(&comment, 1, header.comment_lenght, f);
+        for (i = 0; i < 255; ++i) {
+            if (!(comment[i] > 32 && comment[i] < 127))
+                comment[i] = 183; // print a dot for invalid text
+        }
+        comment[255] = 0;
+        printf("Comment: '%s'\n", comment);
+    }
+
+    *image = NULL;
+    size = header.width * header.height;
+
+    if (!size || (!(header.colormap_type == 0 && (header.image_type == 2 || header.image_type == 10)))) {
+        fprintf(stderr, "tgaLoad> Unknown image format.\n");
+        return -2;
+    }
+
+    // Mongoose: Added 'screen origin bit' support back here
+    if (!(header.desc_flags & 32)) {
+        must_flip = true;
+    }
+
+    switch (header.bpp) {
+        case 32:
+            size *= 4;
+            *image = new unsigned char [size];
+            switch (header.image_type) {
+                case TGA_TYPE__COLOR_RLE:
+                    for (i = 0; i < size;) {
+                        fread(&packet, 1, 1, f);
+                        if (packet & 0x80) { // Run Length
+                            packet = (packet &0x7F) + 1;
+                            fread(&pixel, 4, 1, f);
+                            for (j = 0; j < packet; j++) {
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                                (*image)[i++] = pixel[3];
+                            }
+                        } else { // RAW
+                            packet = (packet &0x7F) + 1;
+                            for (j = 0; j < packet; j++) {
+                                fread(&pixel, 4, 1, f);
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                                (*image)[i++] = pixel[3];
+                            }
+                        }
+                    }
+                    break;
+                case TGA_TYPE__COLOR:
+                    if (fread((*image), size, 1, f) < 1) {
+                        fprintf(stderr, "tgaLoad> Image fread failed.\n");
+                        delete [] *image;
+                        return -4;
+                    }
+                    for (i = 0; i < size; i += 4) {
+                        tmp = (*image)[i];
+                        (*image)[i] = (*image)[i + 2];
+                        (*image)[i + 2] = tmp;
+                    }
+                    break;
+                default:
+                    ;
+            }
+            if (must_flip) {
+                swap_row = new unsigned char [header.width * 4];
+                for (i = 0, j = header.height-1; (int)i < header.height/2; i++, j--) {
+                    memcpy(swap_row, &(*image)[i*header.width*4], header.width*4);
+                    memcpy(&(*image)[i*header.width*4], &(*image)[j*header.width*4],
+                            header.width*4);
+                    memcpy(&(*image)[j*header.width*4], swap_row, header.width*4);
+                }
+                delete [] swap_row;
+            }
+            break;
+        case 24:
+            size *= 3;
+            *image = new unsigned char [size];
+            switch (header.image_type) {
+                case TGA_TYPE__COLOR_RLE:
+                    for (i = 0; i < size;) {
+                        fread(&packet, 1, 1, f);
+                        if (packet & 0x80) { // Run Length
+                            packet = (packet &0x7F) + 1;
+                            fread(&pixel, 3, 1, f);
+                            for (j = 0; j < packet; j++) {
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                            }
+                        } else { // RAW
+                            packet = (packet &0x7F) + 1;
+                            for (j = 0; j < packet; j++) {
+                                fread(&pixel, 3, 1, f);
+                                (*image)[i++] = pixel[2];
+                                (*image)[i++] = pixel[1];
+                                (*image)[i++] = pixel[0];
+                            }
+                        }
+                    }
+                    break;
+                case TGA_TYPE__COLOR:
+                    if (fread((*image), size, 1, f) < 1) {
+                        fprintf(stderr, "tgaLoad> Image fread failed.\n");
+                        delete [] *image;
+                        return -4;
+                    }
+                    for (i = 0; i < size; i += 3) {
+                        tmp = (*image)[i];
+                        (*image)[i] = (*image)[i + 2];
+                        (*image)[i + 2] = tmp;
+                    }
+                    break;
+                default:
+                    ;
+            }
+            if (must_flip) {
+                swap_row = new unsigned char [header.width * 3];
+                for (i = 0, j = header.height - 1; (int)i < header.height / 2; i++, j--) {
+                    memcpy(swap_row, &(*image)[i*header.width*3], header.width*3);
+                    memcpy(&(*image)[i*header.width*3], &(*image)[j*header.width*3],
+                            header.width*3);
+                    memcpy(&(*image)[j*header.width*3], swap_row, header.width*3);
+                }
+                delete [] swap_row;
+            }
+            break;
+        case 8:
+            printf("tgaLoad> 8bpp Not implemented\n");
+            break;
+        default:
+            ;
+    }
+
+#ifdef DEBUG_TGA
+    char c;
+    printf("TGA Comment: ");
+    while (fread(&c, 1, 1, f) == 1) {
+        printf("%c", c);
+    }
+    printf("\n");
+#endif
+
+    return 0;
+}
+
+int tgaSave(FILE *f, unsigned char *image, unsigned int width, unsigned int height, char type) {
+    tga_t header;
+    unsigned int size;
+    char comment[64];
+    //unsigned int i;
+    //unsigned char tmp;
+
+    assert(f != NULL);
+    assert(image != NULL);
+    assert(width > 0);
+    assert(height > 0);
+
+    strncpy(comment, "OpenRaider TGA", 63);
+    comment[63] = 0;
+
+    header.comment_lenght = (unsigned char)strlen(comment);
+    header.colormap_type = 0;
+
+    // No colormaps
+    header.colormap_index = 0;
+    header.colormap_lenght = 0;
+    header.colormap_bbp = 0;
+
+    header.origin_x = header.origin_y = 0;
+    header.width = (unsigned short)width;
+    header.height = (unsigned short)height;
+
+    header.desc_flags = 0;
+
+    switch (type) {
+        case 4:
+            header.image_type = TGA_TYPE__COLOR;
+            header.desc_flags = 32;
+            header.bpp = 32;
+            break;
+        case 2:
+            header.bpp = 32;
+            break;
+        case 1:
+            header.image_type = TGA_TYPE__GREYSCALE;
+            header.bpp = 8;
+            break;
+        default:
+            header.image_type = TGA_TYPE__COLOR;
+            header.bpp = 24;
+    }
+
+    // Write TGA header
+    fwrite(&header.comment_lenght, 1, 1, f);
+    fwrite(&header.colormap_type, 1, 1, f);
+    fwrite(&header.image_type, 1, 1, f);
+    fwrite(&header.colormap_index, 2, 1, f);
+    fwrite(&header.colormap_lenght, 2, 1, f);
+    fwrite(&header.colormap_bbp, 1, 1, f);
+    fwrite(&header.origin_x, 2, 1, f);
+    fwrite(&header.origin_y, 2, 1, f);
+    fwrite(&header.width, 2, 1, f);
+    fwrite(&header.height, 2, 1, f);
+    fwrite(&header.bpp, 1, 1, f);
+    fwrite(&header.desc_flags, 1, 1, f);
+
+    // Write comment
+    fwrite(&comment, 1, header.comment_lenght, f);
+
+    switch (header.bpp) {
+        case 32:
+            size = header.width * header.height * 4;
+
+            //for (i = 0; i < size; i += 4)
+            //{
+            //  tmp = image[i];
+            //  image[i] = image[i + 2];
+            //  image[i + 2] = tmp;
+            //}
+            break;
+        case 24:
+            size = header.width * header.height * 3;
+
+            //for (i = 0; i < size; i += 3)
+            //{
+            //  tmp = image[i];
+            //  image[i] = image[i + 2];
+            //  image[i + 2] = tmp;
+            //}
+            break;
+        case 8:
+        default:
+            size = header.width * header.height;
+            break;
+    }
+
+    // Write image data
+    if (fwrite(image, size, 1, f) < 1) {
+        perror("tgaSave> Disk write failed.\n");
+        return -2;
+    }
+    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;
+}
+

src/utils/time.cpp

@@ -0,0 +1,33 @@
+/*!
+ * \file include/utils/time.h
+ * \brief Time handling utilities
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#include "utils/time.h"
+
+struct timeval system_timer_start;
+struct timeval system_timer_stop;
+struct timezone system_timer_tz;
+
+unsigned int systemTimerGet() {
+    gettimeofday(&system_timer_stop, &system_timer_tz);
+
+    if (system_timer_start.tv_usec > system_timer_stop.tv_usec) {
+        system_timer_stop.tv_usec += 1000000;
+        system_timer_stop.tv_sec--;
+    }
+
+    system_timer_stop.tv_usec -= system_timer_start.tv_usec;
+    system_timer_stop.tv_sec -= system_timer_start.tv_sec;
+
+    return ((system_timer_stop.tv_sec - system_timer_start.tv_sec) * 1000)
+        + ((system_timer_stop.tv_usec - system_timer_start.tv_usec) / 1000);
+}
+
+void systemTimerReset() {
+    gettimeofday(&system_timer_start, &system_timer_tz);
+}
+