Fresh start

include/Camera.h

@@ -1,194 +0,0 @@
-/*!
- * \file include/Camera.h
- * \brief OpenGL camera class
- *
- * \author Mongoose
- */
-#ifndef _CAMERA_H_
-#define _CAMERA_H_
-
-#include "utils/math.h"
-#include "Matrix.h"
-#include "Quaternion.h"
-
-/*!
- * \brief Commands for interactive camera control
- */
-enum camera_command {
-  CAMERA_MOVE_FORWARD = 1,
-  CAMERA_MOVE_BACKWARD,
-  CAMERA_MOVE_UP,
-  CAMERA_MOVE_DOWN,
-  CAMERA_ROTATE_RIGHT,
-  CAMERA_ROTATE_LEFT,
-  CAMERA_SPEED_UP,
-  CAMERA_SPEED_DOWN,
-  CAMERA_ROTATE_UP,
-  CAMERA_ROTATE_DOWN,
-  CAMERA_MOVE_LEFT,
-  CAMERA_MOVE_RIGHT
-};
-
-/*!
- * \brief Flags a camera can have
- */
-enum CameraFlags {
-    Camera_FlyMode = (1 << 0) //!< Camera is flying free?
-};
-
-/*!
- * \brief OpenGL camera class
- *
- * 2002.12.16:
- * Mongoose - Removed perspective setting and OpenGL dependency
- *            API changes to reflect new direction of this object:
- *              Removing outdated algorithms and code
- *              And refactoring the class in general
- *
- * 2001.06.06:
- * Mongoose - Moving GLU code into here to setup break up
- *            into Camera base class, DynamicCamera,
- *            and GLUCamera child classes
- *
- * 2001.06.04:
- * Mongoose - Quaternion based compile option
- *
- * 2001.05.18:
- * Mongoose - Created, based on my old GL camera code
- *            that has been used in GooseEgg since alpha
- *            and algorithms from Yuri Zhivago's trview
- */
-class Camera {
-public:
-    /*!
-     * \brief Constructs an object of Camera
-     */
-    Camera();
-
-    /*!
-     * \brief Returns the current position
-     * \param pos where the position will be stored
-     */
-    void getPosition(vec3_t pos);
-
-    /*!
-     * \brief Returns the up vector
-     * \param up where the up vector will be stored
-     */
-    void getUp(vec3_t up);
-
-    /*!
-     * \brief Get the target currently looked at
-     * \param target where the target will be stored
-     */
-    void getTarget(vec3_t target);
-
-    /*!
-     * \brief Get current yaw in degrees
-     * \returns yaw in degrees
-     */
-    float getYaw();
-
-    /*!
-     * \brief Get angle/yaw of camera
-     * \returns theta angle/yaw of camera
-     */
-    vec_t getRadianYaw();
-
-    /*!
-     * \brief Get current angle/pitch
-     * \returns current pitch in degrees
-     */
-    float getPitch();
-
-    /*!
-     * \brief Get angle/pitch of camera
-     * \returns phi angle/pitch of camera
-     */
-    vec_t getRadianPitch();
-
-    /*!
-     * \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(float angle, float x, float y, float z);
-
-    /*!
-     * \brief Set Camera position
-     * \param x new X coordinate
-     * \param y new Y coordinate
-     * \param z new Z coordinate
-     */
-    void translate(float x, float y, float z);
-
-    /*!
-     * \brief Set the Camera to its initial state
-     */
-    void reset();
-
-    /*!
-     * \brief Sets the X rotation delta
-     * \param angle thetas rotation delta in degrees
-     */
-    void setSensitivityX(float angle);
-
-    /*!
-     * \brief Sets the Y rotation delta
-     * \param angle thetas rotation delta in degrees
-     */
-    void setSensitivityY(float angle);
-
-    /*!
-     * \brief Sends interactive command to camera
-     * \param cmd valid camera command
-     */
-    void command(enum camera_command cmd);
-
-    /*!
-     * \brief Sets speed
-     * \param s new speed, is 256 or greater in general
-     */
-    void setSpeed(float s);
-
-    /*!
-     * \brief Updates view target
-     */
-    void update();
-
-    /*!
-     * \brief Set current position
-     * \param pos new position
-     */
-    void setPosition(vec3_t pos);
-
-    /*!
-     * \brief Sets the up vector
-     * \param up new up vector
-     */
-    void setUp(vec3_t up);
-
-    /*!
-     * \brief Sets target (look at pos)
-     * \param target new target
-     */
-    void setTarget(vec3_t target);
-
-private:
-    Quaternion mQ;                //!< Quaternion for rotation
-    unsigned int mFlags;          //!< For testing with flags
-    vec_t mPos[4];                //!< Location in 3 space (aka eye)
-    vec_t mTarget[4];             //!< Postition we're looking at
-    vec_t mUp[4];                 //!< Up vector
-    vec_t mSide[4];               //!< Side vector
-    vec_t mViewDistance;          //!< Distance from target
-    vec_t mTranslateDelta;        //!< Step size to move
-    vec_t mRotateDelta;           //!< Radians to rotate Y
-    vec_t mTheta;                 //!< View angle Y
-    vec_t mRotateDelta2;          //!< Radians to rotate Z
-    vec_t mTheta2;                //!< View angle Z
-};
-
-#endif

include/Emitter.h

@@ -1,179 +0,0 @@
-/*!
- * \file include/Emitter.h
- * \brief Particle emitter class.
- *
- * \author Mongoose
- */
-
-#ifndef _EMITTER_H_
-#define _EMITTER_H_
-
-#include "Particle.h"
-
-/*!
- * \brief Particle emitter class.
- */
-class Emitter {
-public:
-
-    /*!
-     * \brief Flags an Emitter can have
-     */
-    typedef enum {
-        fUseFrustumCulling = (1 << 0), //!< Use frustum culling
-        fUseDepthSorting   = (1 << 1)  //!< Use depth sorting
-    } EmitterFlags;
-
-
-    /*!
-     * \brief Constructs an object of Emitter
-     * \param name valid C string
-     * \param n greater than 0
-     */
-    Emitter(const char *name, int n);
-
-    /*!
-     * \brief Deconstructs an object of Emitter
-     */
-    ~Emitter();
-
-    /*!
-     * \brief Get the particles
-     * \returns array of Particles
-     */
-    Particle *Particles();
-
-    /*!
-     * \brief Number of particles emitted
-     * \returns Number of particles emitted
-     */
-    int Count();
-
-    /*!
-     * \brief Sets position of emitter in 3D space
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     */
-    void Pos(float x, float y, float z);
-
-    /*!
-     * \brief Returns position of emitter in 3D space
-     * \param x Where X coordinate will be stored
-     * \param y Where Y coordinate will be stored
-     * \param z Where Z coordinate will be stored
-     */
-    void Pos(float *x, float *y, float *z);
-
-    /*!
-     * \brief Sets orientation of emitter in 3D space
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     */
-    void Orientation(float x, float y, float z);
-
-    /*!
-     * \brief Returns orientation of emitter in 3D space
-     * \param x Where X coordinate will be stored
-     * \param y Where Y coordinate will be stored
-     * \param z Where Z coordinate will be stored
-     */
-    void Orientation(float *x, float *y, float *z);
-
-    /*!
-     * \brief Get the flags of this Emitter
-     * \returns EmitterFlags
-     */
-    unsigned int Flags();
-
-    /*!
-     * \brief Set or Unset a flag
-     * \param flag EmitterFlag to change
-     * \param op new state (true - set)
-     */
-    void Flags(unsigned int flag, bool op);
-
-    /*!
-     * \brief Allocates the particle array and sets the count.
-     * If the array has been allocated previously it will be
-     * deallocated and a new one made.
-     * \param n new size, greater than 0
-     */
-    void ParticleArray(int n);
-
-    /*!
-     * \brief Renders the particles
-     */
-    void Draw();
-
-    /*!
-     * \brief Sets the emitters name
-     * \param name is a valid C string
-     */
-    void Name(const char *name);
-
-    /*!
-     * \brief Resets all particle texture ids
-     * \param id new id
-     * \sa Particle::TextureId()
-     */
-    void SetTextureId(int id);
-
-    /*!
-     * \brief Set the texture id for a range of particles in the array
-     * \param particle_start start of range
-     * \param particle_end end of range
-     * \param id new id
-     * \sa Particle::TextureId()
-     */
-    void TextureId(unsigned int particle_start, unsigned int particle_end, int id);
-
-    /*!
-     * \brief Set the color of a range of particles in the array
-     * \param particle_start start of range
-     * \param particle_end end of range
-     * \param r new red part of color (0.0 to 1.0)
-     * \param g new green part of color (0.0 to 1.0)
-     * \param b new blue part of color (0.0 to 1.0)
-     * \sa Particle::Color()
-     */
-    void Color(unsigned int particle_start, unsigned int particle_end, float r, float g, float b);
-
-    /*!
-     * \brief Set the speed of a range of particles in the array.
-     * Take note that the speed starts out at 2000, and lower means faster.
-     * \param particle_start start of range
-     * \param particle_end end of range
-     * \param x X speed
-     * \param y Y speed
-     * \param z Z speed
-     * \sa Particle::Speed
-     */
-    void Speed(unsigned int particle_start, unsigned int particle_end, float x, float y, float z);
-
-    /*!
-     * \brief Let a force (eg. Gravity) act on a range of particles in the array
-     * \param particle_start start of range
-     * \param particle_end end of range
-     * \param x X force
-     * \param y Y force
-     * \param z Z force
-     * \sa Particle::Force()
-     */
-    void Force(unsigned int particle_start, unsigned int particle_end, float x, float y, float z);
-
-    static vec_t mFrustum[6][4]; //!< View Volume copy
-
-private:
-    static int compareParticleDist(const void *voidA, const void *voidB);
-
-    char *_name;         //!< Emitter name
-    unsigned int _flags; //!< Emitter flags
-    vec3_t _pos;         //!< Position in 3D space
-    vec3_t _mangle;      //!< Oreintation in 3D space
-    Particle *_particle; //!< Array of particles
-    unsigned int _count; //!< Particle count
-};
-
-#endif

include/GLString.h

@@ -1,116 +0,0 @@
-/*!
- * \file include/GLString.h
- * \brief Open GL rendering font/string class
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _GLSTRING_H_
-#define _GLSTRING_H_
-
-/*!
- * \brief Internal data structure representing GL Strings
- */
-typedef struct gl_string_s {
-    int x; //!< X Coordinate
-    int y; //!< Y Coordinate
-    float scale; //!< Scale factor
-    char *text; //!< Text buffer
-    bool active; //!< active state
-    unsigned short int len; //!< length
-} gl_string_t;
-
-/*!
- * \brief Open GL rendering font/string class
- */
-class GLString {
-public:
-
-    /*!
-     * \brief Constructs an object of GLString
-     */
-    GLString();
-
-    /*!
-     * \brief Deconstructs an object of GLString
-     */
-    ~GLString();
-
-    /*!
-     * \brief Set max number of strings
-     * \param max_strings maximum number of strings
-     */
-    void Init(unsigned int max_strings);
-
-    /*!
-     * \brief Sets a single byte in a string
-     * \param string valid gl string id
-     * \param pos position in that gl string to set
-     * \param c character to set in gl string
-     */
-    void SetChar(unsigned int string, unsigned int pos, char c);
-
-    /*!
-     * \brief Gets number of bytes in a string buffer
-     * \param string valid gl string id
-     * \returns length/number of bytes of string
-     */
-    unsigned int GetStringLen(unsigned int string);
-
-    /*!
-     * \brief Returns string buffer
-     * \param string valid gl string id
-     * \returns pointer to string buffer
-     */
-    char *GetBuffer(unsigned int string);
-
-
-    void setActive(unsigned int string, bool active);
-
-    /*!
-     * \brief Sets text in a string.
-     * It will be truncated as needed to fit
-     * \param string valid string id
-     * \param s format string and args like for printf
-     */
-    void SetString(unsigned int string, const char *s, ...) __attribute__((format(printf, 3, 4)));
-
-    /*!
-     * \brief Sets default text scaling
-     * \param scale new scale factor > 0.0
-     */
-    void Scale(float scale);
-
-    /*!
-     * \brief Generates a new string and renders it to the gl target
-     * \param x valid X screen coordinate
-     * \param y valid Y screen coordinate
-     * \param string valid format string with args like for printf
-     * \returns 0 on success, -1 on invalid string, -2 on full string list
-     */
-    int glPrintf(int x, int y, const char *string, ...) __attribute__((format(printf, 4, 5)));
-
-    /*!
-     * \brief Renders strings over GL scene.
-     * Should be called after scene is rendered.
-     * GL Culling should be disabled.
-     */
-    void Render();
-
-    /*!
-     * \brief Get the String data structure for a string id
-     * \param id valid string id
-     * \returns string for id, or NULL if it does not exist
-     */
-    gl_string_t *GetString(unsigned int id);
-
-
-private:
-    unsigned int _num_string_max; //!< Max number of strings buffered
-    unsigned int _num_string; //!< Current number of strings buffered
-    gl_string_t *_string; //!< Buffered strings and their properities
-    float _scale; //!< Default scale factor for new strings
-};
-
-#endif

include/Matrix.h

@@ -1,201 +0,0 @@
-/*!
- * \file include/Matrix.h
- * \brief 3D Matrix
- *
- * \author Mongoose
- */
-
-#ifndef _MATRIX_H_
-#define _MATRIX_H_
-
-#include "utils/math.h"
-#include "Quaternion.h"
-#include "Vector3d.h"
-
-
-/*!
- * \brief 3D Matrix
- *
- * Multidim map for row order encoding
- *
- *     ///////////////////////////////////////////////
- *     // 0,0 - 0;   0,1 - 1;   0,2 - 2;   0,3 - 3  //
- *     // 1,0 - 4;   1,1 - 5;   1,2 - 6;   1,3 - 7  //
- *     // 2,0 - 8;   2,1 - 9;   2,2 - 10;  2,3 - 11 //
- *     // 3,0 - 12;  3,1 - 13;  3,2 - 14;  3,3 - 15 //
- *     ///////////////////////////////////////////////
- *
- * Multidim map for column order encoding
- *
- *     ///////////////////////////////////////////////
- *     // 0,0 - 0;   0,1 - 4;   0,2 - 8;   0,3 - 12 //
- *     // 1,0 - 1;   1,1 - 5;   1,2 - 9;   1,3 - 13 //
- *     // 2,0 - 2;   2,1 - 6;   2,2 - 10;  2,3 - 14 //
- *     // 3,0 - 3;   3,1 - 7;   3,2 - 11;  3,3 - 15 //
- *     ///////////////////////////////////////////////
- */
-class Matrix {
-public:
-
-    /*!
-     * \brief Constructs an object of Matrix
-     */
-    Matrix();
-
-    /*!
-     * \brief Constructs an object of Matrix
-     * \param mat Matrix as data source
-     */
-    Matrix(matrix_t mat);
-
-    /*!
-     * \brief Constructs an object of Matrix
-     * \param q Converts and assigns the Quaternion to the Matrix
-     */
-    Matrix(Quaternion &q);
-
-    /*!
-     * \brief Returns this matrix copy
-     * \param mat target
-     */
-    void getMatrix(matrix_t mat);
-
-    /*!
-     * \brief Returns this matrix transposed
-     * \param mat target
-     */
-    void getTransposeMatrix(matrix_t mat);
-
-    /*!
-     * \brief Returns this matrix inverted
-     * \param mat target
-     */
-    bool getInvert(matrix_t mat);
-
-    /*!
-     * \brief Multiplies two matrices
-     * \param a first matrix
-     * \param b second matrix
-     * \returns resultant matrix
-     */
-    static Matrix multiply(const Matrix &a, const Matrix &b);
-
-    /*!
-     * \brief Multiplies v vector and this matrix
-     * \param v vector
-     * \param result where the result will be stored, may be same as v
-     */
-    void multiply4v(vec4_t v, vec4_t result);
-
-    /*!
-     * \brief Multiplies v vector and this matrix
-     * \param v vector
-     * \param result where the result will be stored, may be same as v
-     */
-    void multiply3v(vec3_t v, vec3_t result);
-
-    /*!
-     * \brief Prints matrix values to stdout
-     */
-    void print();
-
-    /*!
-     * \brief Is this matrix the identity matrix?
-     * \returns true if it is identity, false otherwise
-     */
-    bool isIdentity();
-
-    /*!
-     * \brief Multiplies a and this matrix
-     * \param a matrix to multiply with
-     * \returns resultant matrix
-     */
-    Matrix operator *(const Matrix &a);
-
-    /*!
-     * \brief Multiply vector by this matrix
-     * \param v Vector to multiply with
-     * \returns resultant vector (mult)
-     */
-    Vector3d operator *(Vector3d v);
-
-    /*!
-     * \brief Sets to identity matrix
-     */
-    void setIdentity();
-
-    /*!
-     * \brief S et the matrix
-     * \fixme dangerous, scary, boo!
-     * \param mat new matrix
-     */
-    void setMatrix(matrix_t mat);
-
-    /*!
-     * \brief Rotate object in 3D space
-     * \param x x rotation in radians
-     * \param y y rotation in radians
-     * \param z z rotation in radians
-     */
-    void rotate(vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Rotate object in 3D space
-     * \param xyz rotation in radians
-     */
-    void rotate(const vec_t *xyz);
-
-    /*!
-     * \brief Scale object in 3D space
-     * \param x x scaling
-     * \param y y scaling
-     * \param z z scaling
-     */
-    void scale(vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Scale object in 3D space
-     * \param xyz scaling factors
-     */
-    void scale(const vec_t *xyz);
-
-    /*!
-     * \brief Translate (move) object in 3D space
-     * \param x x translation
-     * \param y y translation
-     * \param z z translation
-     */
-    void translate(vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Translate (move) object in 3D space
-     * \param xyz translations
-     */
-    void translate(const vec_t *xyz);
-
-    /*!
-     * \brief Transpose this matrix
-     */
-    void transpose();
-
-    matrix_t mMatrix; //!< Data model, moved public for faster external renderer feedback use
-
-private:
-
-    /*!
-     * \brief Copys value from source to dest
-     * \param source source
-     * \param dest destination
-     */
-    static void copy(matrix_t source, matrix_t dest);
-
-    /*!
-     * \brief Multiplies matrices a and b. Neither a or b is also the result.
-     * \param a first matrix
-     * \param b second matrix
-     * \param result wil be set to resultant matrix value
-     */
-    static void multiply(const matrix_t a, const matrix_t b, matrix_t result);
-};
-
-#endif

include/Mesh.h

@@ -1,169 +0,0 @@
-/*!
- * \file include/Mesh.h
- * \brief OpenGL Mesh
- *
- * \author Mongoose
- *
- * \todo Unify the parallel systems here, arrays and the allocate/set
- */
-
-#ifndef _OPENGLMESH_H_
-#define _OPENGLMESH_H_
-
-#include "utils/math.h"
-
-/*!
- * \brief OpenGL Mesh
- */
-class Mesh {
-public:
-
-    typedef enum {
-        MeshModeSolid,
-        MeshModeWireframe,
-        MeshModeTexture,
-        MeshModeMultiTexture
-    } MeshMode;
-
-    typedef enum {
-        fMesh_UseVertexArray = (1 << 0)
-    } MeshFlags;
-
-    typedef struct {
-        int texture;
-#ifdef MULTITEXTURE
-        int bumpmap;
-#endif
-
-        unsigned int cnum_triangles;
-        unsigned int cnum_alpha_triangles;
-
-        unsigned int num_texcoors;
-        vec2_t *texcoors;
-
-        unsigned int num_texcoors2;
-        vec2_t *texcoors2;
-
-        //! Arrays of triangle indices sorted by texture
-        unsigned int num_triangles;
-        unsigned int *triangles; //!< ABCABCABC...
-
-        //! Arrays of alpha triangle indices sorted by texture
-        unsigned int num_alpha_triangles;
-        unsigned int *alpha_triangles; //!< ABCABCABC...
-    } tris_t;
-
-    typedef struct {
-
-        int texture;
-#ifdef MULTITEXTURE
-        int bumpmap;
-#endif
-
-        unsigned int cnum_quads;
-        unsigned int cnum_alpha_quads;
-
-        unsigned int num_texcoors;
-        vec2_t *texcoors;
-
-        unsigned int num_texcoors2;
-        vec2_t *texcoors2;
-
-        //! Arrays of rectangle indices sorted by texture
-        unsigned int num_quads;
-        unsigned int *quads; //!< ABCDABCDABCD...
-
-        //! Arrays of alpha rectangle indices sorted by texture
-        unsigned int num_alpha_quads;
-        unsigned int *alpha_quads; //!< ABCDABCDABCD...
-
-    } rect_t;
-
-    /*!
-     * \brief Constructs an object of Mesh
-     */
-    Mesh();
-
-    /*!
-     * \brief Deconstructs an object of Mesh
-     */
-    ~Mesh();
-
-    void drawAlpha();
-
-    void drawSolid();
-
-    void allocateColors(unsigned int n);
-
-    void allocateNormals(unsigned int n);
-
-    void allocateRectangles(unsigned int n);
-
-    void allocateTriangles(unsigned int n);
-
-    void allocateVertices(unsigned int n);
-
-    void bufferColorArray(unsigned int colorCount, vec_t *colors);
-
-    void bufferNormalArray(unsigned int normalCount, vec_t *normals);
-
-    void bufferTriangles(unsigned int count,
-                            unsigned int *indices, vec_t *texCoords,
-                            int *textures, unsigned int *flags);
-
-    void bufferVertexArray(unsigned int vertexCount, vec_t *vertices);
-
-    void setColor(unsigned int index, float r, float g, float b, float a);
-
-    void setColor(unsigned int index, float rgba[4]);
-
-    void setNormal(unsigned int index, float i, float j, float k);
-
-    void setVertex(unsigned int index, float x, float y, float z);
-
-#ifdef NOT_IMPLEMENTED
-    void sortFacesByTexture();
-
-    void addFace(int textureIndex, int textureIndexB, unsigned int flags,
-                    unsigned int vertexIndexCount, vec_t *vertexIndices);
-
-    void addTexTiledFace(int textureIndex, int textureIndexB,
-                            unsigned int flags, unsigned int indexCount,
-                            vec_t *vertexIndices, vec_t *texcoords);
-
-    void bufferTexcoords(unsigned int texcoordCount, vec_t *texcoords);
-
-    void duplicateArraysForTexTiledTexcoords();
-#endif
-
-    unsigned int mFlags;
-
-    MeshMode mMode;
-
-    unsigned int mNumVertices;
-    vec3_t *mVertices; //!< XYZ
-
-    unsigned int mNumNormals;
-    vec3_t *mNormals; //!< IJK
-
-    unsigned int mNumColors;
-    vec4_t *mColors; //!< RGBA
-
-    unsigned int mNumTris;
-    tris_t *mTris;
-
-    unsigned int mNumQuads;
-    rect_t *mQuads;
-
-    unsigned int mTriangleCount;
-    int *mTriangleTextures;
-    unsigned int *mTriangleIndices;
-    unsigned int *mTriangleFlags;
-    vec_t *mTriangleTexCoordArray;
-
-    vec_t *mVertexArray;
-    vec_t *mNormalArray;
-    vec_t *mColorArray;
-};
-
-#endif

include/OpenRaider.h

@@ -1,236 +0,0 @@
-/*!
- * \file include/OpenRaider.h
- * \brief Main Game Singleton
- *
- * \author Mongoose
- */
-
-#ifndef _OPENRAIDER_H_
-#define _OPENRAIDER_H_
-
-#include <map>
-
-#include "Config.h"
-#include "TombRaider.h"
-#include "Camera.h"
-#include "Render.h"
-#include "Sound.h"
-#include "SDLSystem.h"
-#include "World.h"
-#include "templates/List.h"
-#include "templates/Vector.h"
-#include "utils/strings.h"
-
-/*!
- * \brief OpenRaider key events.
- *
- * 0 event reserved for console in System.
- */
-typedef enum {
-    OpenRaiderKey_console = 1, //!< Toggle console
-    OpenRaiderKey_attack,      //!< Attack
-    OpenRaiderKey_forward,     //!< Move forward
-    OpenRaiderKey_left,        //!< Move left
-    OpenRaiderKey_right,       //!< Move right
-    OpenRaiderKey_backward,    //!< Move backward
-    OpenRaiderKey_jump,        //!< Jump
-    OpenRaiderKey_tiltUp,      //!< Tilt camera up
-    OpenRaiderKey_tiltDown,    //!< Tilt camera down
-    OpenRaiderKey_panLeft,     //!< Pan camera left
-    OpenRaiderKey_panRight,    //!< Pan camera right
-    OpenRaiderKey_crouch       //!< Crouch
-} OpenRaider_KeyEvent;
-
-typedef enum {
-    OpenRaider_ShowFPS     = (1 << 0),
-    OpenRaider_DebugMap    = (1 << 1),
-    OpenRaider_DebugModel  = (1 << 2),
-    OpenRaider_EnableSound = (1 << 3),
-    OpenRaider_DumpTexture = (1 << 4), //!< \fixme Not used!
-    OpenRaider_Loading     = (1 << 5)
-} OpenRaider_Flags;
-
-/*!
- * \brief Main Game Singleton
- */
-class OpenRaider : public SDLSystem {
-public:
-
-    /*!
-     * \brief Constructs or returns the OpenRaider Singleton
-     * \returns OpenRaider Singleton
-     */
-    static OpenRaider *Instance();
-
-    /*!
-     * \brief Deconstructs an object of OpenRaider
-     */
-    ~OpenRaider();
-
-    /*!
-     * \brief Initialize the Game
-     */
-    void start();
-
-    /*!
-     * \brief Resizes game window and updated renderer
-     * \param width new width
-     * \param height new height
-     */
-    virtual void resize(unsigned int width, unsigned int height);
-
-    /*!
-     * \brief Mouse motion input
-     * \param x relative x motion
-     * \param y relative y motion
-     */
-    void handleMouseMotionEvent(float x, float y);
-
-    /*!
-     * \brief Receives `Event` bound to `Cmd` from `Key` press
-     * \param key valid keyboard code
-     */
-    void handleBoundKeyPressEvent(unsigned int key);
-
-    /*!
-     * \brief Receives `Event` bound to `Cmd` from `Key` release
-     * \param key valid keyboard code
-     */
-    void handleBoundKeyReleaseEvent(unsigned int key);
-
-    /*!
-     * \brief Executes valid command based on keyword
-     * \param command valid keyword optionally followed by space separated arguments
-     * \param mode current type or resource mode
-     */
-    void handleCommand(char *command, unsigned int mode);
-
-    /*!
-     * \brief Receives `Key` code from text input in console mode
-     * \param key valid keyboard code
-     * \param mod valid modifier code
-     */
-    void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod);
-
-    /*!
-     * \brief Executes command associated with key press, if any
-     * \param key valid keyboard code
-     * \param mod valid modifier code
-     */
-    void handleKeyPressEvent(unsigned int key, unsigned int mod);
-
-    /*!
-     * \brief Executes command associated with key release, if any
-     * \param key valid keyboard code
-     * \param mod valid modifier code
-     */
-    void handleKeyReleaseEvent(unsigned int key, unsigned int mod);
-
-    /*!
-     * \brief Pass a time frame and render a new frame
-     */
-    void gameFrame();
-
-    /*!
-     * \brief Outputs message in game console
-     * \param dump_stdout if true, also print to stdout
-     * \param format printf() style format string
-     */
-    void print(bool dump_stdout, const char *format, ...) __attribute__((format(printf, 3, 4)));
-
-protected:
-
-    /*!
-     * \brief Constructs an object of OpenRaider
-     */
-    OpenRaider();
-
-private:
-
-    void consoleCommand(char *cmd);
-
-    void soundEvent(int type, int id, vec3_t pos, vec3_t angles);
-
-    //void entityEvent(entity_t &e, RaiderEvent event);
-
-    void processPakSounds();
-
-    /*!
-     * \brief Loads and positions level sounds and music.
-     *
-     * Sound system has to be initialized.
-     */
-    void initSound();
-
-    /*!
-     * \brief Generates textures or mipmaps for fonts, splash,
-     * external particles.
-     */
-    void initTextures();
-
-    /*!
-     * \brief Generates tombraider textures or mipmaps for sprites,
-     * rooms and models.
-     */
-    void processTextures();
-
-    /*!
-     * \brief Generates render sprite sequences
-     */
-    void processSprites();
-
-    void processMoveables();
-
-    void processMoveable(int index, int i, int *ent, List <skeletal_model_t *> &cache2, List <unsigned int> &cache, int object_id);
-
-    /*!
-     * \brief Generates render mesh and any textures needed
-     * for the specified model.
-     * \param index valid model index
-     */
-    void processModel(int index);
-
-    /*!
-     * \brief Generates render mesh and any textures needed
-     * for the specified room
-     * \param index valid room index
-     */
-    void processRoom(int index);
-
-    /*!
-     * \brief Loads validated level pak from diskfile using maplist
-     * \param filename level pak file name
-     */
-    void loadLevel(char *filename);
-
-    void loadPakFolderRecursive(const char *dir);
-
-    void menuMapListMove(char dir, bool show);
-
-    static OpenRaider *mInstance; //!< Singleton use
-    TombRaider m_tombraider;      //!< Tombraider data support
-    Sound mSound;                 //!< 3d Audio support
-    Render m_render;              //!< Rendering support
-    Camera m_camera;              //!< Client camera support
-    GLString *mText;              //!< Hook to textbox like output
-
-    // RC vars
-
-    unsigned int mMode[8];            //!< Translate System's mode ids to OR's
-    unsigned int m_flags;             //!< Set options by flags
-    int m_testSFX;                    //!< Used for mixed channel sound tests
-    float m_mouseX, m_mouseY;         //!< XY axis rotation deltas
-    unsigned int m_texOffset;         //!< Offset of TombRaider textures in list
-    unsigned int mLevelTextureOffset;
-
-    // Game vars
-
-    Vector <char *> mMusicList;  //!< List of game level music
-    Vector <char *> mMapList;    //!< List of game maps
-    char m_mapName[32];          //!< Current map filename
-    char *m_pakDir;              //!< Current pak directory
-    char *m_audioDir;            //!< Current audio directory
-    char *m_homeDir;             //!< Current home directory
-};
-
-#endif

include/Particle.h

@@ -1,119 +0,0 @@
-/*!
- * \file include/Particle.h
- * \brief Particle system base header
- *
- * \author Mongoose
- */
-
-#ifndef _PARTICLE_H_
-#define _PARTICLE_H_
-
-#include "utils/math.h"
-
-/*!
- * \brief Partcle systems atomic base
- */
-class Particle {
-public:
-
-    /*!
-     * \brief Constructs an object of Sound
-     */
-    Particle();
-
-    /*!
-     * \brief Toggles active state of particle
-     * \param active new state
-     */
-    void setActive(bool active);
-
-    /*!
-     * \brief Sets gravity/force acting on particle
-     * \param x X part of force vector
-     * \param y Y part
-     * \param z Z part
-     */
-    void Force(float x, float y, float z);
-
-    /*!
-     * \brief Resets particle to defaults
-     */
-    void Reset();
-
-    /*!
-     * \brief Sets gravity/force acting on particle
-     * \note speed inits at 2000, lower is faster
-     * \param x X part of speed vector
-     * \param y Y part
-     * \param z Z part
-     */
-    void Speed(float x, float y, float z);
-
-    /*!
-     * \brief Sets new particle coloring
-     * \note White {1.0, 1.0, 1.0} is the init color
-     * \param r Red part, from 0.0 to 1.0
-     * \param g Green part, from 0.0 to 1.0
-     * \param b Blue part, from 0.0 to 1.0
-     */
-    void Color(float r, float g, float b);
-
-    /*!
-     * \brief Returns position of particle in 3 space
-     * \param x not NULL!
-     * \param y not NULL!
-     * \param z not NULL!
-     */
-    void Pos(float *x, float *y, float *z);
-
-    /*!
-     * \brief Returns current color of particle
-     * \param r not NULL!
-     * \param g not NULL!
-     * \param b not NULL!
-     */
-    void Color(float *r, float *g, float *b);
-
-    /*!
-     * \brief Returns current life (blend) of particle
-     * \returns fade of particle
-     */
-    float Life();
-
-    /*!
-     * \brief Adjusts for particle life cycle
-     */
-    void Update();
-
-    /*!
-     * \brief Returns texture binding for this particle
-     * \returns texture id
-     */
-    int Texture();
-
-    /*!
-     * \brief Returns active value
-     * \returns state
-     */
-    bool isActive();
-
-    /*!
-     * \brief Set the texture for this particle
-     * \param t new texture id
-     */
-    void TextureId(int t);
-
-
-private:
-    bool _active;  //!< Is this particle in use?
-    float _life;   //!< Life of particle
-    float _blend;  //!< Blend amount or fade
-    int _texture;  //!< Texture polygon to use
-    vec3_t _pos;   //!< Current position in 3 space
-    vec3_t _color; //!< Current color
-    vec3_t _dir;   //!< Current direction
-    vec3_t _force; //!< Current force or 'gravity'
-    vec3_t _speed; //!< Speed of particle movement
-};
-
-#endif

include/Quaternion.h

@@ -1,201 +0,0 @@
-/*!
- * \file include/Quaternion.h
- * \brief Quaternion
- *
- * \author Mongoose
- */
-
-#ifndef _QUATERNION_H_
-#define _QUATERNION_H_
-
-#include "utils/math.h"
-
-/*!
- * \brief Quaternion
- */
-class Quaternion {
-public:
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     */
-    Quaternion();
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     * \param w W part of new Quaternion
-     * \param x X part of new Quaternion
-     * \param y Y part of new Quaternion
-     * \param z Z part of new Quaternion
-     */
-    Quaternion(vec_t w, vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Constructs an object of Quaternion
-     * \param v contents of new Quaternion
-     */
-    Quaternion(vec4_t v);
-
-    /*!
-     * \brief Get column order matrix equivalent of this quaternion
-     * \param m where matrix will be stored
-     */
-    void getMatrix(matrix_t m);
-
-    /*!
-     * \brief Multiplies this quaternion.
-     *
-     * Use normalize() call for unit quaternion.
-     *
-     * \param q what to multiply this quaternion with
-     * \returns resultant quaternion
-     * \sa Quaternion::normalize()
-     */
-    Quaternion operator *(const Quaternion &q);
-
-    /*!
-     * \brief Divide from this quaternion
-     * \param q what to divide from this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator /(const Quaternion &q);
-
-    /*!
-     * \brief Add to this quaternion
-     * \param q what to add to this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator +(const Quaternion &q);
-
-    /*!
-     * \brief Subtract from this quaternion
-     * \param q what to subtract from this quaternion
-     * \returns resultant quaternion
-     */
-    Quaternion operator -(const Quaternion &q);
-
-    /*!
-     * \brief Compares q to this quaternion
-     * \param q what to compare this quaternion to
-     * \returns true if equal, false otherwise
-     */
-    bool operator ==(const Quaternion &q);
-
-    /*!
-     * \brief Conjugate this quaternion
-     * \returns Conjugate of this quaternion
-     */
-    Quaternion conjugate();
-
-    /*!
-     * \brief Scale this quaternion
-     * \param s scaling factor
-     * \returns Scaled result of this quaternion
-     */
-    Quaternion scale(vec_t s);
-
-    /*!
-     * \brief Inverse this quaternion
-     * \returns inverse of this quaternion
-     */
-    Quaternion inverse();
-
-    /*!
-     * \brief Dot Product of quaternions
-     * \param a first argument to dot product
-     * \param b second argument to dot product
-     * \returns dot product between a and b quaternions
-     */
-    static vec_t dot(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Magnitude of this quaternion
-     * \returns Magnitude of this quaternion
-     */
-    vec_t magnitude();
-
-    /*!
-     * \brief Interpolates between a and b rotations.
-     *
-     * Using spherical linear interpolation:
-     * `I = (((B . A)^-1)^Time)A`
-     *
-     * \param a first argument for slerp
-     * \param b second argument for slerp
-     * \param time time argument for slerp
-     * \returns resultant quaternion
-     */
-    static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
-
-    /*!
-     * \brief Sets this quaternion to identity
-     */
-    void setIdentity();
-
-    /*!
-     * \brief Sets this quaternion
-     * \param angle new angle
-     * \param x new X coordinate
-     * \param y new Y coordinate
-     * \param z new Z coordinate
-     */
-    void set(vec_t angle, vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Normalize this quaternion
-     */
-    void normalize();
-
-    /*!
-     * \brief Set this quaternion
-     * \param q will be copied into this quaternion
-     */
-    void copy(Quaternion q);
-
-    /*!
-     * \brief Sets matrix equivalent of this quaternion
-     * \param m matrix in valid column order
-     */
-    void setByMatrix(matrix_t m);
-
-private:
-
-    /*!
-     * \brief Multiplies two quaternions
-     * \param a first argument to multiplication
-     * \param b second argument to multiplication
-     * \returns resultant quaternion
-     */
-    static Quaternion multiply(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Divides B from A quaternion
-     * \param a first argument to division
-     * \param b second argument to division
-     * \returns quotient quaternion
-     */
-    static Quaternion divide(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Adds A and B quaternions
-     * \param a first argument to addition
-     * \param b second argument to addition
-     * \returns resultant quaternion
-     */
-    static Quaternion add(Quaternion a, Quaternion b);
-
-    /*!
-     * \brief Subtracts B from A quaternion
-     * \param a first argument to subtraction
-     * \param b second argument to subtraction
-     * \returns resultant quaternion
-     */
-    static Quaternion subtract(Quaternion a, Quaternion b);
-
-    vec_t mW; //!< Quaternion, W part
-    vec_t mX; //!< Quaternion, X part
-    vec_t mY; //!< Quaternion, Y part
-    vec_t mZ; //!< Quaternion, Z part
-};
-
-#endif

include/Render.h

@@ -1,371 +0,0 @@
-/*!
- * \file include/Render.h
- * \brief OpenRaider Renderer class
- *
- * \author Mongoose
- */
-
-#ifndef _RENDER_H_
-#define _RENDER_H_
-
-#include "Config.h"
-#include "Matrix.h"
-#include "ViewVolume.h"
-#include "World.h"
-#include "SkeletalModel.h"
-#include "Mesh.h"
-#include "Texture.h"
-#include "Camera.h"
-#include "GLString.h"
-#include "templates/Vector.h"
-
-#ifdef USING_EMITTER
-#include "Emitter.h"
-#endif
-
-/*!
- * \brief The GL light class
- */
-class Light {
-public:
-    /*!
-     * \brief Type a light can be of
-     */
-    typedef enum {
-        typePoint       = 1, //!< Point light
-        typeSpot        = 2, //!< Spot light
-        typeDirectional = 3  //!< Directional light
-    } LightType;
-
-    vec4_t mPos; //! Light position in 3 space
-    vec3_t mDir; //! Light direction
-    float mAtt;
-    vec4_t mColor; //! Color of light
-    vec_t mCutoff; //! Fade out distance
-    LightType mType; //! Type of light
-};
-
-/*!
- * \brief RenderRoom used by Renderer
- */
-class RenderRoom {
-public:
-
-    /*!
-     * \brief Constructs an object of RenderRoom
-     */
-    RenderRoom() {
-        room = 0x0;
-        dist = 0.0f;
-    }
-
-    /*!
-     * \brief Deconstructs an object of RenderRoom
-     */
-    ~RenderRoom() {
-        //! \fixme Hangs when erasing - might be shared pointers somewhere
-        //lights.erase();
-    }
-
-    vec_t dist;             //!< Distance to near plane, move to room?
-    Vector<Light *> lights; //!< List of lights in this room
-    Mesh mesh;              //!< OpenGL mesh that represents this room
-
-    //! \fixme very dangerous as allocated and used
-    room_mesh_t *room;      //!< Physical room stored in World
-};
-
-/*!
- * \brief OpenRaider Renderer class
- */
-class Render {
-public:
-
-    typedef enum {
-        modeDisabled,
-        modeLoadScreen,
-        modeVertexLight,
-        modeSolid,
-        modeWireframe,
-        modeTexture
-    } RenderMode;
-
-    typedef enum {
-        fParticles              = (1 << 0),
-        fPortals                = (1 << 1),
-        fRoomAlpha              = (1 << 2),
-        fViewModel              = (1 << 3),
-        fSprites                = (1 << 4),
-        fRoomModels             = (1 << 5),
-        fEntityModels           = (1 << 6),
-        fFog                    = (1 << 7),
-        fUsePortals             = (1 << 8),
-        fGL_Lights              = (1 << 9),
-        fOneRoom                = (1 << 10),
-        fRenderPonytail         = (1 << 11),
-        fMultiTexture           = (1 << 12),
-        fUpdateRoomListPerFrame = (1 << 13),
-        fAnimateAllModels       = (1 << 14),
-        fAllRooms               = (1 << 15)
-    } RenderFlags;
-
-    typedef enum {
-        roomMesh,
-        skeletalMesh
-    } RenderMeshType;
-
-    /*!
-     * \brief Constructs an object of Render
-     */
-    Render();
-
-    /*!
-     * \brief Deconstructs an object of Render
-     */
-    ~Render();
-
-    /*!
-     * \brief Makes a screenshot, writes to disk
-     * \param filenameBase basename of file to be written
-     */
-    void screenShot(char *filenameBase);
-
-    /*!
-     * \brief Gets current rendering mode
-     * \returns current RenderMode
-     * \fixme Don't return enum as int?!
-     */
-    int getMode();
-
-    void addRoom(RenderRoom *rRoom);
-
-    /*!
-     * \brief Starts and sets up OpenGL target
-     * \param width width of window
-     * \param height height of window
-     */
-    void Init(int width, int height);
-
-    /*!
-     * \brief Loads textures in a certain id slot
-     * \param image Image to load
-     * \param width width of image
-     * \param height height of image
-     * \param id id for texture
-     * \sa Texture::loadBufferSlot()
-     */
-    void loadTexture(unsigned char *image,
-                          unsigned int width, unsigned int height,
-                          unsigned int id);
-
-    /*!
-     * \brief Sets up textures for OpenRaider.
-     * \param textureDir Is valid and exists with textures
-     * \param numLoaded returns number of loaded textures and will update
-     * number of external textures loaded
-     * \param nextId will update next level texture id
-     */
-    void initTextures(char *textureDir, unsigned int *numLoaded,
-                            unsigned int *nextId);
-
-    /*!
-     * \brief Initializes Emitter.
-     *
-     * Emitter is set up for rendering with 2 textures in
-     * a overhead rain or snow like pattern.
-     * Textures have to be initialized!
-     * \param name valid C-String name
-     * \param size valid size
-     * \param snowTex1 valid first texture
-     * \param snowTex2 valid second texture
-     */
-    void initEmitter(const char *name, unsigned int size,
-                          unsigned int snowTex1, unsigned int snowTex2);
-
-    /*!
-     * Removes current world/entity/etc geometry
-     */
-    void ClearWorld();
-
-    /*!
-     * \brief Clears bitflags, changes state of renderer in some way
-     * \param flags RenderFlags to clear (ORed)
-     * \fixme use enum not integer as parameter?!
-     */
-    void clearFlags(unsigned int flags);
-
-    /*!
-     * \brief Sets bitflags, changes state of renderer in some way
-     * \param flags RenderFlags to set (ORed)
-     * \fixme use enum not integer as parameter?!
-     */
-    void setFlags(unsigned int flags);
-
-    void setMode(int n);
-
-    void Update(int width, int height);
-
-    /*!
-     * \brief Renders a single game frame
-     */
-    void Display();
-
-    void setSkyMesh(int index, bool rot);
-
-    void ViewModel(entity_t *ent, int index);
-
-    void RegisterCamera(Camera *camera);
-
-    /*!
-     * \brief Get the GL text output agent
-     * \returns Used GLString instance
-     */
-    GLString *GetString();
-
-    /*!
-     * \brief Renders load screen.
-     *
-     * Textures must be initialized.
-     * \fixme Should be private!
-     */
-    void drawLoadScreen();
-
-    void addSkeletalModel(SkeletalModel *mdl);
-
-    /*!
-     * \brief Show a texture for a second, for debugging
-     * \param textureId texture id to show
-     * \returns GL texture id on success, < 0 on error
-     */
-    int showTextureDebug(int textureId);
-
-private:
-
-    /*!
-     * \brief Check if a bounding box is in the View Volume
-     * \param bboxMin Start coordinates of a valid bounding box
-     * \param bboxMax End coordinates of a valid bounding box
-     * \returns true if bounding box is visible
-     */
-    bool isVisible(float bboxMin[3], float bboxMax[3]);
-
-    /*!
-     * \brief Check if a point is in the View Volume
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns true if point is visible
-     */
-    bool isVisible(float x, float y, float z);
-
-    /*!
-     * \brief Check if a sphere is in the View Volume
-     * \param x X coordinate of center of sphere
-     * \param y Y coordinate of center of sphere
-     * \param z Z coordinate of center of sphere
-     * \param radius radius of sphere
-     * \returns true if sphere is visible
-     */
-    bool isVisible(float x, float y, float z, float radius);
-
-    /*!
-     * \brief Build a visible room list starting at index
-     * \param index valid room index where to start the list
-     */
-    void newRoomRenderList(int index);
-
-    /*!
-     * \brief Build a visible room list starting from room and
-     * only considers its linked rooms and their linked rooms.
-     * \param room First room in list
-     */
-    void buildRoomRenderList(RenderRoom *room);
-
-    /*!
-     * \brief Renders visible world object.
-     *
-     * Texture must be initialized.
-     */
-    void drawObjects();
-
-    /*!
-     * \brief Renders Sky domes/boxes/etc by scaling factor.
-     *
-     * Texture must be initialized.
-     * \param scale correct scale for map size
-     */
-    void drawSkyMesh(float scale);
-
-    /*!
-     * \brief Renders a skeletal model.
-     *
-     * Texture must be initialized!
-     * \param model model to render
-     */
-    void drawModel(SkeletalModel *model);
-
-    /*!
-     * Renders a room in 2 seperate passes to handle alpha.
-     *
-     * Currently doesnt sort alpha but looks pretty good.
-     * Texture must be initialized.
-     * Draw all rooms with alpha false, then again with alpha true.
-     * \param rRoom room to render
-     * \param draw_alpha once false, once true
-     */
-    void drawRoom(RenderRoom *rRoom, bool draw_alpha);
-
-    /*!
-     * \brief Renders static room model.
-     *
-     * Texture must be initialized.
-     * \param mesh Static model to render
-     */
-    void drawRoomModel(static_model_t *mesh);
-
-    /*!
-     * \brief Renders a mesh.
-     *
-     * Texture must be initialized.
-     * \param r_mesh Mesh to render.
-     * \param type Must be object containing mesh
-     */
-    void drawModelMesh(model_mesh_t *r_mesh, RenderMeshType type);
-
-    /*!
-     * \brief Renders a sprite.
-     *
-     * Texture must be initialized.
-     * \param sprite sprite to render
-     */
-    void drawSprite(sprite_t *sprite);
-
-    /*!
-     * \brief Updates View Volume. Call once per render frame.
-     */
-    void updateViewVolume();
-
-    //! \fixme Let them eat cake...? O.o
-    void tmpRenderModelMesh(model_mesh_t *r_mesh, texture_tri_t *ttri);
-
-    Texture mTexture;                     //!< Texture subsystem
-    Camera *mCamera;                      //!< Camera subsystem
-    GLString mString;                     //!< GL Text subsystem
-    Vector<RenderRoom *> mRoomRenderList;
-    Vector<RenderRoom *> mRooms;
-    Vector<SkeletalModel *> mModels;
-    unsigned int mFlags;                  //!< Rendering flags
-    unsigned int mWidth;                  //!< Viewport width
-    unsigned int mHeight;                 //!< Viewport height
-    unsigned int mMode;                   //!< Rendering mode
-    unsigned int *mNumTexturesLoaded;
-    unsigned int *mNextTextureId;
-    int mLock;
-    int mSkyMesh;                         //!< Skymesh model id
-    bool mSkyMeshRotation;                //!< Should Skymesh be rotated?
-#ifdef USING_EMITTER
-    Emitter *mEmitter;                    //!< Particle emitter test
-#endif
-};
-
-#endif

include/SDLSystem.h

@@ -1,123 +0,0 @@
-/*!
- * \file include/SDLSystem.h
- * \brief SDL System interface implementation
- *
- * \author Mongoose
- */
-
-#ifndef _SDLSYSTEM_H_
-#define _SDLSYSTEM_H_
-
-#include "SDL.h"
-
-#include "Config.h"
-#include "System.h"
-
-/*!
- * \brief SDL System interface implementation
- */
-class SDLSystem : public System {
-public:
-
-    /*!
-     * \brief Constructs an object of SDLSystem
-     */
-    SDLSystem();
-
-    /*!
-     * \brief Deconstructs an object of SDLSystem
-     */
-    virtual ~SDLSystem();
-
-    /*
-     * \brief Sets Event binding Cmd to Key press
-     * \param cmd valid command string
-     * \param key valid keyboard code
-     * \param event valid game event id
-     */
-    //! \fixme void bindKeyCommand(const char *cmd, int key, int event);
-
-    /*!
-     * \brief Renders string in OpenGL (2D projection).
-     *
-     * Requires Texture::glEnterMode2d() call before entry.
-     *
-     * System::bufferString(..) can cache printf() style calls
-     * for use with this method.
-     *
-     * Call Texture::glExitMode2d after finishing calls to this method
-     * and other 2D rendering.
-     *
-     * \param x valid X world coordinate
-     * \param y valid Y world coordinate
-     * \param string valid string
-     *
-     * \sa System::bufferString()
-     * \sa Texture::glEnterMode2d()
-     * \sa Texture::glExitMode2d()
-     */
-    void glPrintf2d(float x, float y, char *string);
-
-    /*!
-     * \brief Renders string in OpenGL (3D projection).
-     *
-     * System::bufferString(..) can cache printf() style calls
-     * for use with this method.
-     *
-     * \param x valid X world coordinate
-     * \param y valid Y world coordinate
-     * \param z valid Z world coordinate
-     * \param string valid string
-     *
-     * \sa System::bufferString()
-     */
-    void glPrintf3d(float x, float y, float z, char *string);
-
-    /*!
-     * \brief Start up video subsystem
-     * \param width valid video mode width
-     * \param height valid video mode height
-     * \param fullscreen enables fullscreen rendering
-     */
-    void initVideo(unsigned int width, unsigned int height, bool fullscreen);
-
-    /*!
-     * \brief Resizes game window
-     * \param width new width
-     * \param height new height
-     */
-    virtual void resize(unsigned int width, unsigned int height);
-
-    /*!
-     * \brief Start game loop
-     */
-    void runGame();
-
-    void setGrabMouse(bool on);
-
-    /*!
-     * \brief Shuts down the game subsystems, exits game loop
-     * \param i exit code
-     */
-    void shutdown(int i);
-
-    /*!
-     * \brief Swaps OpenGL buffers.
-     * Call at end of frame.
-     */
-    void swapBuffersGL();
-
-    /*!
-     * \brief Toggle fullscreen windowing mode
-     */
-    void toggleFullscreen();
-
-protected:
-    bool mFullscreen;      //!< Current Fullscreen/Windowed mode
-
-private:
-    SDL_Window *mWindow;      //!< This is the pointer to the SDL surface
-    SDL_GLContext mGLContext; //!< The OpenGL Context
-};
-
-#endif

include/SkeletalModel.h

@@ -1,92 +0,0 @@
-/*!
- * \file include/SkeletalModel.h
- * \brief This is the factored out skeletal model class
- *
- * \author Mongoose
- *
- * \todo Start cutting off old hacks by simple force use of method interface.
- * Also move the publicly exposed attributes out  =)
- * Better animation system in general - this is memory wasteful
- */
-
-#ifndef _SKELETALMODEL_H_
-#define _SKELETALMODEL_H_
-
-#include "utils/math.h"
-#include "templates/Vector.h"
-
-typedef struct {
-    int mesh;
-    vec3_t off;
-    vec3_t rot;
-    char flag;
-} bone_tag_t;
-
-typedef struct {
-    Vector<bone_tag_t *> tag;
-    vec3_t pos;
-    float yaw;
-} bone_frame_t;
-
-typedef struct {
-    int id;
-    char rate;
-    Vector<bone_frame_t *> frame;
-} animation_frame_t;
-
-typedef struct {
-    int id;
-    bool tr4Overlay;
-    bool pigtails;
-    int ponytailId;
-    vec3_t ponytail;
-    int ponytailMeshId;
-    unsigned int ponytailNumMeshes;
-    float ponytailAngle;
-    float ponyOff;
-    float ponyOff2;
-    Vector<animation_frame_t *> animation;
-} skeletal_model_t;
-
-/*!
- * \brief This is the factored out skeletal model class
- */
-class SkeletalModel {
-public:
-    /*!
-     * \brief Constructs an object of SkeletalModel
-     */
-    SkeletalModel();
-
-     /*!
-     * \brief Deconstructs an object of SkeletalModel
-     */
-    ~SkeletalModel();
-
-    int getAnimation();
-
-    int getFrame();
-
-    int getIdleAnimation();
-
-    void setModel(skeletal_model_t *mdl);
-
-    void setAnimation(int index);
-
-    void setFrame(int index);
-
-    void setIdleAnimation(int index);
-
-    unsigned int flags;
-    skeletal_model_t *model; //!< World render model
-    float time;              //!< Interpolation use
-    float lastTime;
-    float rate;              //!< \fixme temp cache this here for old animation system use
-
-private:
-    int mBoneFrame;      //!< Bone frame
-    int mAnimationFrame; //!< Animation frame
-    int mIdleAnimation;  //!< Idle animation
-};
-
-#endif

include/Sound.h

@@ -1,103 +0,0 @@
-/*!
- * \file include/Sound.h
- * \brief This is the audio manager Header
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _SOUND_H_
-#define _SOUND_H_
-
-/*!
- * \brief This is the audio manager for OpenRaider
- */
-class Sound {
-public:
-
-    typedef enum {
-        SoundFlagsNone = 0, //!< No FX
-        SoundFlagsLoop = 1  //!< Enable looping during playback
-    } SoundFlags;
-
-    /*!
-     * \brief Constructs an object of Sound
-     */
-    Sound();
-
-    /*!
-     * \brief Deconstructs an object of Sound
-     */
-    ~Sound();
-
-    /*!
-     * \brief Initialize sound system
-     * \returns 0 on success or < 0 error flags
-     */
-    int init();
-
-    /*!
-     * \brief Get number of registered sources
-     * \returns number of registered sources
-     */
-    int registeredSources();
-
-    /*!
-     * \brief Move listener and repositions them
-     * \param pos New position for listener
-     * \param angle New orientation for listener
-     */
-    void listenAt(float pos[3], float angle[3]);
-
-    /*!
-     * \brief Move sound source to position
-     * \param source valid source id
-     * \param pos new position for source
-     */
-    void sourceAt(int source, float pos[3]);
-
-    /*!
-     * \brief Load wav file from disk
-     * \param filename not NULL!
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags (un)set options. Use SoundFlags enum
-     * \returns 0 for no error or < 0 error flag
-     */
-    int addFile(const char *filename, int *source, unsigned int flags);
-
-    /*!
-     * \brief Load wav file from buffer
-     * \param wav not NULL! Is a valid waveform buffer!
-     * \param length length of wav buffer
-     * \param source not NULL! Returns new source ID or -1 on error.
-     * \param flags (un)set options. Use SoundFlags enum
-     * \returns 0 for no error or < 0 error flag
-     */
-    int addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags);
-
-    /*!
-     * \brief Remove a loaded sound
-     * \param source valid source id
-     */
-    void remove(int source);
-
-    /*!
-     * \brief Play sound source
-     * \param source sound source to play
-     */
-    void play(int source);
-
-    /*!
-     * \brief Stop playing sound source
-     * \param source sound source to stop
-     */
-    void stop(int source);
-
-private:
-    bool mInit;                //!< Guard to ensure ausio system is active
-    unsigned int mBuffer[256]; //!< Audio buffer id list
-    unsigned int mSource[256]; //!< Audio source id list
-    int mNext;                 //!< Audio id cursor
-};
-
-#endif

include/System.h

@@ -1,167 +0,0 @@
-/*!
- * \file include/System.h
- * \brief Mostly defines the interface of System implementations.
- *
- * Currently only SDL is used, but there was a GLUT implementation.
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _SYSTEM_H_
-#define _SYSTEM_H_
-
-#include <map>
-
-#include "templates/Vector.h"
-#include "utils/strings.h"
-
-//! \todo Replace with unicode compatible key codes
-#define SYS_MOUSE_LEFT    6000
-#define SYS_MOUSE_RIGHT   6001
-#define SYS_MOUSE_MIDDLE  6002
-#define SYS_KEY_ESC       27
-#define SYS_KEY_ENTER     13
-#define SYS_KEY_UP        5000
-#define SYS_KEY_DOWN      5001
-#define SYS_KEY_RIGHT     5002
-#define SYS_KEY_LEFT      5003
-#define SYS_KEY_PAGEDOWN  5004
-#define SYS_KEY_PAGEUP    5005
-#define SYS_KEY_F1        1000
-#define SYS_KEY_F2        1001
-#define SYS_KEY_F3        1002
-#define SYS_KEY_F4        1003
-#define SYS_KEY_F5        1004
-#define SYS_KEY_F6        1005
-#define SYS_KEY_F7        1006
-#define SYS_KEY_F8        1007
-#define SYS_KEY_F9        1008
-#define SYS_KEY_F10       1009
-#define SYS_KEY_F11       1010
-#define SYS_KEY_F12       1011
-
-typedef enum {
-    SYS_MOD_KEY_LSHIFT = 1,
-    SYS_MOD_KEY_RSHIFT = 2,
-    SYS_MOD_KEY_LCTRL  = 4,
-    SYS_MOD_KEY_RCTRL  = 8,
-    SYS_MOD_KEY_LALT   = 16,
-    SYS_MOD_KEY_RALT   = 32,
-    SYS_MOD_KEY_LMETA  = 64,
-    SYS_MOD_KEY_RMETA  = 128
-} sdl_sys_mod_key_t;
-
-/*!
- * \brief Basic Interface for System implementations (SDLSystem)
- */
-class System {
-public:
-    /*!
-     * \brief Constructs an object of System
-     */
-    System();
-
-    /*!
-     * \brief Deconstructs an object of System
-     */
-    virtual ~System();
-
-    /*!
-     * \brief Created a new Command Mode.
-     * \param command valid command mode for the resource file, eg "[Engine.OpenGL.Driver]"
-     * \returns id given to mode
-     */
-    virtual unsigned int addCommandMode(const char *command);
-
-    /*!
-     * \brief Binds a key to a command
-     * \param cmd valid command string for event
-     * \param key valid keyboard code
-     * \param event valid game event id
-     */
-    virtual void bindKeyCommand(const char *cmd, unsigned int key, int event);
-
-    /*!
-     * \brief Executes a command string
-     * \param cmd valid command string, cmd sets its var
-     */
-    virtual void command(const char *cmd);
-
-    virtual void gameFrame() = 0;
-
-    virtual void handleMouseMotionEvent(float x, float y) = 0;
-
-    /*!
-     * \brief Receives the event bound to the command from the key press
-     * \param key key pressed
-     */
-    virtual void handleBoundKeyPressEvent(unsigned int key) = 0;
-
-    /*!
-     * \brief Receives the event bound to the command from the key release
-     * \param key key released
-     */
-    virtual void handleBoundKeyReleaseEvent(unsigned int key) = 0;
-
-    /*!
-     * \brief Executes valid command based on keyword
-     * \param command valid keyword, optionally followed by space separated arguments
-     * \param mode current type or resource mode
-     */
-    virtual void handleCommand(char *command, unsigned int mode) = 0;
-
-    /*!
-     * \brief Receives key code from text input in console mode
-     * \param key is a valid keyboard code
-     * \param mod modifier key
-     */
-    virtual void handleConsoleKeyPressEvent(unsigned int key, unsigned int mod) = 0;
-
-    virtual void handleKeyPressEvent(unsigned int key, unsigned int mod) = 0;
-
-    virtual void handleKeyReleaseEvent(unsigned int key, unsigned int mod) = 0;
-
-    virtual void initVideo(unsigned int width, unsigned int height, bool fullscreen) = 0;
-
-    /*!
-     * \brief Init the resource vars
-     * \param filename resource file
-     * \returns < 0 on error
-     */
-    virtual int loadResourceFile(const char *filename);
-
-    virtual void resizeGL(unsigned int width, unsigned int height);
-
-    virtual void runGame() = 0;
-
-    /*!
-     * \brief Turns console key events on/off
-     * Mostly for allowing text entry vs key impulse commands
-     * \param on new state
-     */
-    void setConsoleMode(bool on);
-
-    void setDriverGL(const char *driver);
-
-    virtual void shutdown(int code) = 0;
-
-    virtual void swapBuffersGL() = 0;
-
-    virtual void toggleFullscreen() = 0;
-
-protected:
-    unsigned int m_width;              //!< Width of the viewport
-    unsigned int m_height;             //!< Height of the viewport
-    char *m_driver;                    //!< String for dynamic use of GL library
-    float m_clipNear;                  //!< Clip near distance
-    float m_clipFar;                   //!< Clip far distance
-    float m_fovY;                      //!< Field of vision
-    std::map<unsigned int, int> mKeyEvents; //!< Single key press event mappings
-    bool mConsoleMode;                 //!< Using text (console) event handler?
-    Vector<const char *> mCmdModes;    //!< Dynamic resource command collection
-    unsigned int mCommandMode;         //!< Current resource command mode
-    unsigned int mConsoleKey;          //!< Console toggle event now handled lower
-};
-
-#endif

include/Texture.h

@@ -1,293 +0,0 @@
-/*!
- * \file include/Texture.h
- * \brief Texture registry
- *
- * \author Mongoose
- */
-
-#ifndef _TEXTURE_H
-#define _TEXTURE_H
-
-#include <stdio.h>
-
-typedef struct {
-    int x;
-    int y;
-    int w;
-    int h;
-    int minx;
-    int maxx;
-    int miny;
-    int maxy;
-    int advance;
-} ttf_glyph_t;
-
-typedef struct {
-    unsigned int utf8Offset;
-    unsigned int count;
-
-/* [utf8Offset -> utf8Offset+count],
-     matches indexing into glyphs[0 -> count] for texcoords, etc
-    ----------------------------------------
-    41     -> 126     ASCII English w/ special chars,
-    0x303f -> 0x3093  Japanese hiragana kana,
-    0x301a -> 0x30f6  Japanese katakana kana */
-
-    unsigned int width;      //!< Width and height of RGBA texture
-    unsigned char *texture;  //!< RGBA texture data
-    ttf_glyph_t *glyphs;     //!< For typesetting and rendering use
-    int fontHeight;
-    int fontAscent;
-    int fontDescent;
-    int fontSpacing;
-} ttf_texture_t;
-
-typedef struct {
-    unsigned int utf8Offset;
-    unsigned int count;
-    int textureId;
-    int drawListBase;
-} gl_font_t;
-
-/*!
- * \brief Texture registry
- */
-class Texture {
-public:
-
-    enum ColorMode {
-        GREYSCALE = 1,
-        RGB,
-        RGBA,
-        ARGB
-    };
-
-    enum TextureFlag {
-        fUseMipmaps      = (1 << 0),
-        fUseMultiTexture = (1 << 1),
-        fUseSDL_TTF      = (1 << 2)
-    };
-
-    /*!
-    * \brief Constructs an object of Texture
-    */
-    Texture();
-
-   /*!
-    * \brief Deconstructs an object of Texture
-    */
-    ~Texture();
-
-    /*!
-     * \brief Generates a texture buffer with (width * height * 4) bytes.
-     * \param rgba 32bpp RGBA color to fill into buffer
-     * \param width width of newly allocated buffer, power of 2, pref same as height
-     * \param height height of newly allocated buffer, power of 2, pref same as width
-     * \returns newly allocated texture buffer filled with specified color
-     */
-    static unsigned char *generateColorTexture(unsigned char rgba[4],
-                                                unsigned int width,
-                                                unsigned int height);
-
-    gl_font_t *generateFont(ttf_texture_t *texture);
-
-    /*!
-     * \brief Generates a font texture with typeset info from TTF.
-     *
-     * Does not load the texture itself! Call loadFont() on returned ttf_texture_t
-     * \param filename filename of TTF font
-     * \param pointSize Point Size to generate
-     * \param textureWidth width of texture, height will match it
-     * \param color RGB 24bit color
-     * \param utf8Offset Offset into fonts encoding chart
-     * \param count number of glyphs to read from offset start
-     * \param verbose dumps debug info to stdout
-     * \returns font texture. Load it with loadFont()!
-     */
-    ttf_texture_t *generateFontTexture(const char *filename, int pointSize,
-                                        unsigned int textureWidth,
-                                        unsigned char color[3],
-                                        unsigned int utf8Offset,
-                                        unsigned int count,
-                                        char verbose);
-
-    /*!
-     * \brief Get number of textures in use
-     * \returns used texture count, or -1 on error (uninitialized)
-     */
-    int getTextureCount();
-
-    /*!
-     * \brief Dumps a screenshot to disk.
-     *
-     * Avoids overwriting files with same base name.
-     * \param base base filename
-     * \param width viewport width
-     * \param height viewport height
-     */
-    void glScreenShot(char *base, unsigned int width, unsigned int height);
-
-    /*!
-     * \brief Sets up multitexture rendering with passed ids
-     * \param texture0 first texture for multitexture
-     * \param texture1 second texture for multitexture
-     */
-    void bindMultiTexture(int texture0, int texture1);
-
-    /*!
-     * \brief Binds the texture for use in GL
-     * \param n valid texture index
-     */
-    void bindTextureId(unsigned int n);
-
-    /*!
-     * \brief Clears an option flag
-     * \param flag flag to clear
-     */
-    void clearFlag(TextureFlag flag);
-
-    void disableMultiTexture();
-
-    /*!
-     * \brief Loads SDL_TTF
-     */
-    void initSDL_TTF();
-
-    /*!
-     * \brief Loads Buffer as texture
-     * \param image pixmap matching other params
-     * \param width width of image
-     * \param height height of image
-     * \param mode mode of image
-     * \param bpp bits per pixel of image
-     * \returns texture ID or < 0 on error
-     */
-    int loadBuffer(unsigned char *image,
-                    unsigned int width, unsigned int height,
-                    ColorMode mode, unsigned int bpp);
-
-    /*!
-     * \brief Loads Buffer as texture
-     * \param image pixmap matching other params
-     * \param width width of image
-     * \param height height of image
-     * \param mode mode of image
-     * \param bpp bits per pixel of image
-     * \param slot slot (ID) of image
-     * \returns texture ID or < 0 on error
-     */
-    int loadBufferSlot(unsigned char *image,
-                        unsigned int width, unsigned int height,
-                        ColorMode mode, unsigned int bpp,
-                        unsigned int slot);
-
-    /*!
-     * \brief Generates and loads a solid color texture.
-     * \param rgba color for new texture
-     * \param width width of new texture
-     * \param height height of new texture
-     * \returns texture ID or -1 on error
-     */
-    int loadColorTexture(unsigned char rgba[4],
-                            unsigned int width, unsigned int height);
-
-    /*!
-     * \brief Loads a TTF, generates texture image, glyph list and drawlist
-     * \param filename Filename of TTF font
-     * \param utf8Offset Offset into Unicode table
-     * \param count number of glyphs to load
-     * \returns font id if successful, or < 0 on error
-     */
-    int loadFontTTF(const char *filename,
-                        unsigned int utf8Offset, unsigned int count);
-
-    /*!
-     * \brief Loads TGA file as texture
-     * \param filename Existing TGA file
-     * \returns ID of new texture or -1 on error
-     */
-    int loadTGA(const char *filename);
-
-    /*!
-     * \brief Resets all texture data
-     */
-    void reset();
-
-    /*!
-     * \brief Sets an option flag
-     * \param flag flag to set
-     */
-    void setFlag(TextureFlag flag);
-
-    /*!
-     * \brief Sets up GL texturing.
-     *
-     * Must be called as first setup step!
-     * \param n maximum number of textures you wish to allow
-     */
-    void setMaxTextureCount(unsigned int n);
-
-    void useMultiTexture(float u, float v);
-
-    void useMultiTexture(float aU, float aV, float bU, float bV);
-
-    /*!
-     * \brief Show a texture for a second, for debugging
-     * \param textureId texture id to show
-     * \returns GL texture id on success, < 0 on error
-     */
-    int showTextureDebug(int textureId);
-
-    /*!
-     * \brief Renders debug texture.
-     *
-     * Called in 2D mode from Texture::Display().
-     */
-    void debugTextureRender(int width, int height);
-
-private:
-
-    int nextPower(int seed);
-
-    unsigned char *scaleBuffer(unsigned char *image, int width, int height,
-                                int components);
-
-    int textureDebug;
-    int textureDebugFrames;
-
-    unsigned int *mTextureIds;  //!< GL texture list
-    unsigned int mTextureCount; //!< Texture counter
-    unsigned int mTextureLimit; //!< The texture limit
-    unsigned int mFlags;        //!< Class options
-    int mTextureId;             //!< Currently bound texture id
-    int mTextureId2;            //!< Multitexture Texture Id
-};
-
-
-// Experimental testing
-
-void bufferedPrintf(char *string, unsigned int len, char *s, ...) __attribute__((format(printf, 3, 4)));
-
-void glPrint3d(float x, float y, float z,
-                float pitch, float yaw, float roll,
-                float scale, char *string);
-
-void glPrint2d(float x, float y, float scale, char *string);
-
-/*!
- * \brief OpenGL ortho projection.
- *
- * Call before using glPrint2d()
- * \param width window width
- * \param height window height
- */
-void glEnterMode2d(unsigned int width, unsigned int height);
-
-/*!
- * \brief OpenGL model matrix projection.
- *
- * Call after using glPrint2d()
- */
-void glExitMode2d();
-
-#endif

include/Vector3d.h

@@ -1,160 +0,0 @@
-/*!
- * \file include/Vector3d.h
- * \brief 3D Math vector
- *
- * \author Mongoose
- */
-
-#ifndef _VECTOR3D_H_
-#define _VECTOR3D_H_
-
-#include "utils/math.h"
-
-/*!
- * \brief 3D Math Vector
- */
-class Vector3d {
-public:
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     */
-    Vector3d();
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param v data to load into new Vector3d
-     */
-    Vector3d(vec3_t v);
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param x X part of new Vector3d
-     * \param y Y part of new Vector3d
-     * \param z Z part of new Vector3d
-     */
-    Vector3d(vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Constructs an object of Vector3d
-     * \param v contents of new Vector3d
-     */
-    Vector3d(const Vector3d &v);
-
-    /*!
-     * \brief Calculate dot product
-     * \param u first argument
-     * \param v second argument
-     * \returns dot product of u and v vectors
-     */
-    static vec_t dot(const Vector3d &u, const Vector3d &v);
-
-    /*!
-     * \brief Calculate cross product
-     * \param u first argument
-     * \param v second argument
-     * \returns cross product of u and v vectors
-     */
-    static Vector3d cross(const Vector3d &u, const Vector3d &v);
-
-    /*!
-     * \brief Get Magnitude
-     * \returns magnitude of this vector
-     */
-    vec_t magnitude();
-
-    /*!
-     * \brief Normalize
-     * \returns normalized copy of this vector
-     */
-    Vector3d unit();
-
-    /*!
-     * \brief Get the Zero vector
-     * \returns (0, 0, 0) vector
-     */
-    static Vector3d zeroVector();
-
-    /*!
-     * \brief Add to this vector
-     * \param v addend
-     * \returns a vector = this vector + v
-     */
-    Vector3d operator +(const Vector3d &v);
-
-    /*!
-     * \brief Subtract from this vector
-     * \param v subtrahend
-     * \returns a vector = this vector - v
-     */
-    Vector3d operator -(const Vector3d &v);
-
-    /*!
-     * \brief Negate this vector
-     * \returns a copy of this vector, negated
-     */
-    Vector3d operator -();
-
-    /*!
-     * \brief Scale this vector
-     * \param s scaling factor
-     * \returns this vector multiplied with s
-     */
-    Vector3d operator *(vec_t s);
-
-    /*!
-     * \brief Scale this vactor
-     * \param s inverse scaling factor
-     * \returns this vector divided by s
-     */
-    Vector3d operator /(vec_t s);
-
-    /*!
-     * \brief Dot product this vector
-     * \param v second vector for dot product
-     * \returns dot product of V by this vector
-     */
-    vec_t operator *(const Vector3d &v);
-
-    /*!
-     * \brief Normalizes this vector
-     */
-    void normalize();
-
-    /*!
-     * \brief Set this vector to Zero (0, 0, 0)
-     */
-    void zero();
-
-    /*!
-     * \brief Set this vector
-     * \param v what this vector will be set to
-     * \returns this vector, now equal to v
-     */
-    Vector3d &operator =(const Vector3d &v);
-
-    /*!
-     * \brief Add to this vector, in place
-     * \param v what will be added to this vector
-     * \returns this vector, with v added
-     */
-    Vector3d &operator +=(const Vector3d &v);
-
-    /*!
-     * \brief Subtract from this vector, in place
-     * \param v what will be subtracted from this vector
-     * \returns this vector, with v subtracted
-     */
-    Vector3d &operator -=(const Vector3d &v);
-
-    /*!
-     * \brief Scale this vector, in place
-     * \param s scaling factor
-     * \returns this vactor multiplied by s
-     */
-    Vector3d &operator *=(vec_t s);
-
-    vec3_t mVec; //!< Vector data
-};
-
-#endif

include/ViewVolume.h

@@ -1,200 +0,0 @@
-/*!
- * \file include/ViewVolume.h
- * \brief Viewing Volume for culling use
- *
- * \author Mongoose
- */
-
-#ifndef _VIEWVOLUME_H_
-#define _VIEWVOLUME_H_
-
-#include "Matrix.h"
-
-/*!
- * \brief Defines a 3D sphere.
- */
-class BoundingSphere {
-public:
-    vec3_t mCenter; //!< Center of bounding sphere
-    vec_t mRadius; //!< Raduis of bounding sphere
-};
-
-/*!
- * \brief Defines a 3D rectangle.
- */
-class BoundingBox {
-public:
-    vec3_t mMin; //!< Bounding box MIN point
-    vec3_t mMax; //!< Bounding box MAX point
-};
-
-/*!
- * \brief Defines a 3D sphere and/or rectangle.
- */
-class BoundingVolume {
-public:
-    BoundingSphere mSphere; //!< Bounding sphere of this volume
-    BoundingBox mBox; //!< Bounding box of this volume
-};
-
-/*!
- * \brief Viewing Volume for culling use
- */
-class ViewVolume {
-public:
-
-    /*!
-     * \brief Sides of the view volume
-     */
-    enum ViewVolumeSide {
-        rightSide  = 0, //!< Right
-        leftSide   = 1, //!< Left
-        bottomSide = 2, //!< Bottom
-        topSide    = 3, //!< Top
-        farSide    = 4, //!< Back
-        nearSide   = 5  //!< Front
-    };
-
-    /*!
-     * \brief Planes of the view volume
-     */
-    enum ViewVolumePlane {
-        planeA = 0, //!< X value of normal
-        planeB = 1, //!< Y value of normal
-        planeC = 2, //!< Z value of normal
-        planeD = 3  //!< Distance to origin
-    };
-
-    /*!
-     * \brief Constructs an object of ViewVolume
-     */
-    ViewVolume();
-
-    /*!
-     * \brief Check if bounding volume is in view volume
-     * \param bvol bounding volume to check
-     * \returns true if frustum contains the given bounding volume
-     */
-    bool isBoundingVolumeInFrustum(BoundingVolume bvol);
-
-    /*!
-     * \brief Check if bounding sphere is in view volume
-     * \param bvol bounding sphere to check
-     * \returns true if frustum contains the given bounding volume
-     */
-    bool isBoundingSphereInFrustum(BoundingSphere bvol);
-
-    /*!
-     * \brief Check if bounding box is in view volume
-     * \param bvol bounding box to check
-     * \returns true if frustum contains the given bounding volume
-     */
-    bool isBoundingBoxInFrustum(BoundingBox bvol);
-
-    /*!
-     * \brief Check if point is in view volume
-     * \param x X coordinate of point
-     * \param y Y coordinate of point
-     * \param z Z coordinate of point
-     * \returns true if point in view volume
-     */
-    bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
-
-    /*!
-     * \brief Check if bounding sphere is in view volume
-     * \param x X coordinate of a valid abstract sphere
-     * \param y Y coordinate of a valid abstract sphere
-     * \param z Z coordinate of a valid abstract sphere
-     * \param radius radius of a valid abstract sphere
-     * \returns true if abstract sphere in view volume
-     */
-    bool isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius);
-
-    /*!
-     * \brief Check if bounding box is in view volume
-     * \param min minimum point of valid abstract bounding box
-     * \param max maximum point of valid abstract bounding box
-     * \returns true if abstract bounding box in view volume
-     */
-    bool isBboxInFrustum(vec3_t min, vec3_t max);
-
-    /*!
-     * \brief Distance to Bounding sphere
-     * \param x X coordinate of a valid abstract sphere
-     * \param y Y coordinate of a valid abstract sphere
-     * \param z Z coordinate of a valid abstract sphere
-     * \param radius radius of a valid abstract sphere
-     * \returns distance to abstract sphere bounding volume
-     */
-    vec_t getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radius);
-
-    /*!
-     * \brief Distance to Bounding box
-     * \param min minimum point of a valid abstract bounding box
-     * \param max maximum point of a valid abstract bounding box
-     * \returns distance to abstract box bounding volume
-     */
-    vec_t getDistToBboxFromNear(vec3_t min, vec3_t max);
-
-    /*!
-     * \brief Get a copy of the view volume
-     * \param frustum where frustum will be stored
-     */
-    void getFrustum(vec_t frustum[6][4]);
-
-    /*!
-     * \brief Get a copy of a given plane in view volume
-     * \param p side
-     * \param plane wher plane will be stored
-     */
-    void getPlane(ViewVolumeSide p, vec4_t plane);
-
-    /*!
-     * \brief Updates view volume for this frame.
-     * \param proj new projection matrix
-     * \param mdl new model matrix
-     */
-    void updateFrame(matrix_t proj, matrix_t mdl);
-
-    /*!
-     * \brief Updates view volume for this frame.
-     *
-     * Model & Projection Matrices must be set.
-     */
-    void updateFrame();
-
-    /*!
-     * \brief Set this class' model matrix
-     * \param mdl new model matrix
-     */
-    void setModel(matrix_t mdl);
-
-    /*!
-     * \brief Set this class' projection matrix
-     * \param proj new projection matrix
-     */
-    void setProjection(matrix_t proj);
-
-private:
-
-    /*!
-     * \brief Computes clipping matrix.
-     *
-     * Model & Projection matrices must be set!
-     */
-    void updateClip();
-
-    /*!
-     * \brief Computes planes of frustum.
-     *
-     * Model, Projection & Clip matrices must be set!
-     */
-    void updateFrustum();
-
-    Matrix mProjection;   //!< Projection matrix
-    Matrix mModel;        //!< Model matrix
-    Matrix mClip;         //!< Clipping matrix
-    vec_t mFrustum[6][4]; //!< View volume
-};
-
-#endif

include/World.h

@@ -1,391 +0,0 @@
-/*!
- * \file include/World.h
- * \brief The game world (model)
- *
- * \author Mongoose
- */
-
-#ifndef _WORLD_H_
-#define _WORLD_H_
-
-#define BAD_BLOOD  //!< \todo For temp rendering use
-
-#ifdef BAD_BLOOD
-#include "SkeletalModel.h"
-#endif
-
-#include "utils/math.h"
-#include "templates/List.h"
-#include "templates/Vector.h"
-
-// Mirrors TombRaider class' room flags really
-typedef enum {
-    roomFlag_underWater    = 0x0001
-} room_flags_t;
-
-typedef enum {
-    worldMoveType_walkNoSwim   = -1,
-    worldMoveType_walk         = 0,
-    worldMoveType_noClipping   = 1,
-    worldMoveType_fly          = 2,
-    worldMoveType_swim         = 3
-} worldMoveType;
-
-typedef struct {
-    vec3_t pos;
-} vertex_t;
-
-/*
-typedef struct {
-    vec2_t uv;
-} uv_t;
-
-typedef struct {
-    vec4_t rgba;
-} color_t;
-*/
-
-typedef struct {
-    vec2_t st;
-} texel_t;
-
-typedef struct {
-    int num_verts;      //!< 4 == Quad, 3 == Triangle, rendered as triangles
-    vertex_t vertex[4];
-    texel_t texel[4];
-    float pos[3];
-    float radius;       //!< \fixme yeah, I know
-    int texture;
-} sprite_t;
-
-typedef struct {
-    int num_sprites;
-    sprite_t *sprite;
-} sprite_seq_t;
-
-/*! \fixme For now shaders are textures on tex objects
- * and materials on color objects. If -1
- * then it doesn't have that information yet.
- */
-typedef struct {
-    int index[3];
-    vec_t st[6];
-    int texture;
-    unsigned short transparency;
-} texture_tri_t;
-
-typedef struct {
-    Vector<texture_tri_t *> texturedTriangles;
-    Vector<texture_tri_t *> coloredTriangles;
-    Vector<texture_tri_t *> texturedRectangles;
-    Vector<texture_tri_t *> coloredRectangles;
-
-    vec3_t center;
-    float radius;
-
-    unsigned int vertexCount;
-    vec_t *vertices;
-
-    unsigned int colorCount;
-    vec_t *colors;
-
-    unsigned int normalCount;
-    vec_t *normals;
-} model_mesh_t;
-
-typedef struct entity_s {
-    int id;                  //!< Unique identifier
-    float pos[3];            //!< World position
-    float angles[3];         //!< Euler angles (pitch, yaw, roll)
-    int type;                //!< {(0x00, item), (0x01, ai), (0x02, player)}
-    int room;                //!< Current room entity is in
-    worldMoveType moveType;  //!< Type of motion/clipping
-    bool moving;             //!< In motion?
-    struct entity_s *master; //!< Part of entity chain?
-
-    int state;               //!< State of the Player, AI, or object
-    int objectId;            //!< What kind of entity?
-
-    int modelId;             //!< Animation model
-    void *tmpHook;
-    bool animate;
-
-    /*
-    float time, lastTime;
-    int state, lastState;
-    int event, lastEvent;
-    int goal;
-    */
-} entity_t;
-
-typedef struct {
-    int index;    //!< model_mesh index
-    float yaw;    //!< angle of rotation on Y
-    float pos[3]; //!< position
-
-    //vec3_t bboxMax;
-    //vec3_t bboxMin;
-} static_model_t;
-
-typedef struct {
-    float vertices[4][3];
-    float normal[3];
-    int adjoining_room;
-} portal_t;
-
-typedef struct {
-    vertex_t a;
-    vertex_t b;
-    vertex_t c;
-    vertex_t d;
-} box_t;
-
-typedef struct {
-    vec_t floor;
-    vec_t ceiling;
-
-    bool wall;
-} sector_t;
-
-//! \fixme No room mesh list or sprites and etc
-typedef struct {
-    Vector<int> adjacentRooms;
-    Vector<portal_t *> portals;
-    Vector<static_model_t *> models;
-    Vector<sprite_t *> sprites;
-    Vector<box_t *> boxes;
-    Vector<sector_t *> sectors;
-
-    int id;
-    unsigned int flags;
-    unsigned int numXSectors;
-    unsigned int numZSectors;
-    float pos[3];
-    vec3_t bbox_min;
-    vec3_t bbox_max;
-} room_mesh_t;
-
-// Workout generic entity and a client class from these entities
-typedef struct world_entity_s {
-    vec3_t pos;
-    vec3_t lastPos;
-    vec3_t angle;
-    vec_t ttl;
-
-    int type;
-    int state;
-
-    //struct world_entity_s *master;
-
-} world_entity_t;
-
-typedef struct {
-    vec3_t pos;
-    vec3_t lastPos;
-    vec3_t angle;
-    char clipping;
-    float time, eventTime, eventTimer;
-    int state, nextState;
-    float health;
-
-    // Client
-    unsigned int uid;
-    char name[32];
-    int actor, enemy;
-
-    // Render
-    unsigned int model;
-    unsigned int skin;
-    unsigned int animFrame;
-
-} actor_entity_t;
-
-enum OpenRaiderEvent {
-    eNone = 0,
-    eWeaponDischarge,
-    eDying,
-    eDead,
-    eWounded,
-    eRunForward,
-    eRunBackward,
-    eJump,
-    eCrouchWalk,
-    eIdle,
-    eTaunt,
-    eTurn,
-    eRespawn,
-    eLand
-};
-
-/*!
- * \brief The game world (model)
- */
-class World {
-public:
-
-    enum WorldFlag {
-        fEnableHopping = 1
-    };
-
-    /*!
-     * \brief Constructs an object of World
-     */
-    World();
-
-    /*!
-     * \brief Deconstructs an object of World
-     */
-    ~World();
-
-    /*!
-     * \brief Find room a location is in.
-     *
-     * If it fails to be in a room it gives closest overlapping room.
-     * \param index Guessed room index
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns correct room index or -1 for unknown
-     */
-    int getRoomByLocation(int index, float x, float y, float z);
-
-    /*!
-     * \brief Find room a location is in.
-     *
-     * If it fails to be in a room it gives closest overlapping room.
-     * \param x X coordinate
-     * \param y Y coordinate
-     * \param z Z coordinate
-     * \returns correct room index or -1 for unknown
-     */
-    int getRoomByLocation(float x, float y, float z);
-
-    /*!
-     * \brief Looks for portal crossings from xyz to xyz2 segment
-     * from room[index]
-     * \param index valid room index
-     * \param x X coordinate of first point
-     * \param y Y coordinate of first point
-     * \param z Z coordinate of first point
-     * \param x2 X coordinate of second point
-     * \param y2 Y coordinate of second point
-     * \param z2 Z coordinate of second point
-     * \returns index of adjoined room or -1
-     */
-    int getAdjoiningRoom(int index,
-                            float x, float y, float z,
-                            float x2, float y2, float z2);
-
-    /*!
-     * \brief Gets the sector index of the position in room
-     * \param room valid room index
-     * \param x X coordinate in room
-     * \param z Z coordinate in room
-     * \returns sector index of position in room
-     */
-    int getSector(int room, float x, float z);
-    int getSector(int room, float x, float z, float *floor, float *ceiling);
-
-    unsigned int getRoomInfo(int room);
-
-    /*!
-     * \brief Check if sector is a wall
-     * \param room valid room index
-     * \param sector valid sector index
-     * \returns true if this sector is a wall
-     */
-    bool isWall(int room, int sector);
-
-    /*!
-     * \brief Get the world height at a position
-     * \param index valid room index
-     * \param x X coordinate
-     * \param y will be set to world height in that room
-     * \param z Z coordinate
-     * \returns true if position is in a room
-     */
-    bool getHeightAtPosition(int index, float x, float *y, float z);
-
-#ifdef BAD_BLOOD
-    //! \todo Temp methods for rendering use until more refactoring is done
-    model_mesh_t *getMesh(int index);
-    skeletal_model_t *getModel(int index);
-    room_mesh_t *getRoom(int index);
-    Vector<entity_t *> *getEntities();
-    Vector<sprite_seq_t *> *getSprites();
-    Vector<room_mesh_t *> *getRooms();
-#endif
-
-    /*!
-     * \brief Set an option flag
-     * \param flag flag to set
-     */
-    void setFlag(WorldFlag flag);
-
-    /*!
-     * \brief Clear an option flag
-     * \param flag flag to clear
-     */
-    void clearFlag(WorldFlag flag);
-
-    /*!
-     * \brief Clears all data in world
-     * \todo in future will check if data is in use before clearing
-     */
-    void destroy();
-
-    /*!
-     * \brief Adds room to world
-     * \param room room to add
-     */
-    void addRoom(room_mesh_t *room);
-
-    /*!
-     * \brief ADds mesh to world
-     * \param model mesh to add
-     */
-    void addMesh(model_mesh_t *model);
-
-    /*!
-     * \brief Adds entity to world
-     * \param e entity to add
-     */
-    void addEntity(entity_t *e);
-
-    /*!
-     * \brief Adds model to world.
-     * \param model model to add
-     * \returns next model ID or -1 on error
-     */
-    int addModel(skeletal_model_t *model);
-
-    /*!
-     * \brief Adds sprite to world
-     * \param sprite sprite to add
-     */
-    void addSprite(sprite_seq_t *sprite);
-
-    /*!
-     * \brief Move entity in given direction unless collision occurs
-     * \param e entity to move
-     * \param movement direction of movement ('f', 'b', 'l' or 'r')
-     */
-    void moveEntity(entity_t *e, char movement);
-
-private:
-
-    /*!
-     * \brief Clears all data in world
-     */
-    void clear();
-
-    bool mClearLock;
-    unsigned int mFlags;                //!< World flags
-    Vector<entity_t *> mEntities;       //!< World entities
-    Vector<room_mesh_t *> mRooms;       //!< Map data and meshes
-    Vector<model_mesh_t *> mMeshes;     //!< Unanimated meshes
-    Vector<sprite_seq_t *> mSprites;    //!< Sprites
-    Vector<skeletal_model_t *> mModels; //!< Skeletal animation models
-};
-
-#endif

include/games/TombRaider1.h

@@ -1,673 +0,0 @@
-/*!
- * \file include/games/TombRaider1.h
- * \brief Tomb Raider 1 items and states.
- *
- * Based on TR Rosetta Stone
- *
- * \author Mongoose
- * \author xythobuz
- */
-#ifndef _TOMBRAIDER1_H_
-#define _TOMBRAIDER1_H_
-
-/*!
- * \brief Tomb Raider 1 items and states
- */
-class TombRaider1 {
-public:
-
-    /*!
-     * \brief States of a Wolf (Item 7)
-     */
-    enum WolfStates {
-        WolfState_Walking       = 1,
-        WolfState_Running       = 2,
-        WolfState_Jumping       = 3,
-        WolfState_Stalking      = 5,
-        WolfState_JumpingAttack = 6,
-        WolfState_Attacking     = 7,
-        WolfState_Lying         = 8,  //!< Lying down
-        WolfState_Getting       = 9,  //!< Getting ready to strike
-        WolfState_RunningJump   = 10,
-        WolfState_Dying         = 11,
-        WolfState_Biting        = 12
-    };
-
-    /*!
-     * \brief States of a Bear (Item 8)
-     */
-    enum BearStates {
-        BearState_Walking       = 0, //!< Walking on all fours
-        BearState_Getting       = 1, //!< Getting back to all fours
-        BearState_WalkingHind   = 2, //!< Walking on hind legs
-        BearState_Running       = 3, //!< Running on all fours
-        BearState_Rearing       = 4, //!< Rearing up on hind legs
-        BearState_Growling      = 5, //!< ?
-        BearState_RunningAttack = 6, //!< Running and attacking
-        BearState_Standing      = 7, //!< Standing on hind legs
-        BearState_Biting        = 8,
-        BearState_Dying         = 9
-    };
-
-    /*!
-     * \brief States of a Bat (Item 9)
-     */
-    enum BatStates {
-        BatState_Starting = 1, //!< Starting to fly
-        BatState_Flying   = 2, //!< Flying straight
-        BatState_Biting   = 3,
-        BatState_Circling = 4,
-        BatState_Dying    = 5
-    };
-
-    /*!
-     * \brief States of a Crocodile on land (Item 10)
-     */
-    enum CrocodileLandStates {
-        CrocodileLandState_Stationary = 1,
-        CrocodileLandState_Walking1   = 2,
-        CrocodileLandState_Walking2   = 3,
-        CrocodileLandState_Turning    = 4,
-        CrocodileLandState_Biting     = 5,
-        CrocodileLandState_Dying      = 7
-    };
-
-    /*!
-     * \brief States of a Crocodile in water (Item 11)
-     */
-    enum CrocodileWaterStates {
-        CrocodileWaterState_Swimming = 1,
-        CrocodileWaterState_Biting   = 2,
-        CrocodileWaterState_Dying    = 3
-    };
-
-    /*!
-     * \brief States of a Lion (Male & Female) and a Panther (Items 12, 13, 14)
-     */
-    enum LionStates {
-        LionState_Standing = 1,
-        LionState_Walking  = 2,
-        LionState_Leaping  = 3,
-        LionState_LeapBite = 4,
-        LionState_Dying    = 5,
-        LionState_Biting1  = 6,
-        LionState_Biting2  = 7
-    };
-
-    /*!
-     * \brief States of a Gorilla (Item 15)
-     */
-    enum GorillaStates {
-        GorillaState_Standing = 1,  //!< Standing on all fours
-        GorillaState_Running  = 3,  //!< Running on all fours
-        GorillaState_Walking  = 4,  //!< Walking on legs (attacking?)
-        GorillaState_Dying    = 5,
-        GorillaState_Thumping = 6,  //!< Thumping on chest
-        GorillaState_Waving   = 7,  //!< Waving arms
-        GorillaState_TurningL = 8,  //!< Turning leftward?
-        GorillaState_TurningR = 9,  //!< Turning rightward?
-        GorillaState_Jumping  = 10, //!< Jumping up and waving arms
-        GorillaState_Climbing = 11
-    };
-
-    /*!
-     * \brief States of a Giant Rat on land (Item 16)
-     */
-    enum GiantRatLandStates {
-        GiantRatLandState_Standing  = 1,
-        GiantRatLandState_JumpBite  = 2,
-        GiantRatLandState_Running   = 3,
-        GiantRatLandState_Biting    = 4,
-        GiantRatLandState_Dying     = 5,
-        GiantRatLandState_RearingUp = 6
-    };
-
-    /*!
-     * \brief States of a Giant Rat in the water (Item 17)
-     */
-    enum GiantRatWaterStates {
-        GiantRatWaterState_Swimming = 1,
-        GiantRatWaterState_Biting   = 2,
-        GiantRatWaterState_Dying    = 3
-    };
-
-    /*!
-     * \brief States of a Tyrannosaur (Item 18)
-     */
-    enum TyrannosaurStates {
-        TyrannosaurState_Standing  = 1,
-        TyrannosaurState_Walking   = 2,
-        TyrannosaurState_Running   = 3,
-        TyrannosaurState_Dying     = 5,
-        TyrannosaurState_Bellowing = 6,
-        TyrannosaurState_Biting    = 7,
-        TyrannosaurState_Shaking   = 8  //!< Shaking Head and Spitting Out
-    };
-
-    /*!
-     * \brief States of a Raptor (Item 19)
-     */
-    enum RaptorStates {
-        RaptorState_Dying     = 0,
-        RaptorState_Standing  = 1,
-        RaptorState_Walking   = 2,
-        RaptorState_Running   = 3,
-        RaptorState_JumpBite  = 4,
-        RaptorState_Bellowing = 6,
-        RaptorState_RunBellow = 7,
-        RaptorState_Biting    = 8
-    };
-
-    /*!
-     * \brief States of a Winged Mutant (Item 20)
-     */
-    enum WingedMutantStates {
-        WingedMutantState_Crouching = 1,
-        WingedMutantState_Walking   = 2,
-        WingedMutantState_Running   = 3,
-        WingedMutantState_Biting    = 4,
-        WingedMutantState_Looking   = 6,
-        WingedMutantState_Jumping   = 7,
-        WingedMutantState_Clawing   = 8,
-        WingedMutantState_Aiming    = 9,  //!< Aiming Right-Hand Gun
-        WingedMutantState_AimFire   = 10, //!< Aiming and Firing Left-Hand Gun
-        WingedMutantState_Firing    = 11, //!< Firing Right-Hand Gun
-        WingedMutantState_Standing  = 12,
-        WingedMutantState_Flying    = 13
-    };
-
-    /*!
-     * \brief States of a Centaur Mutant (Item 23)
-     */
-    enum CentaurMutantStates {
-        CentaurMutantState_Standing  = 1,
-        CentaurMutantState_Firing    = 2,
-        CentaurMutantState_Galloping = 3,
-        CentaurMutantState_Aiming    = 4,
-        CentaurMutantState_Dying     = 5,
-        CentaurMutantState_Rearing   = 6  //!<  Rearing up
-    };
-
-    /*!
-     * \brief States of a Mummy (Item 24)
-     */
-    enum MummyStates {
-        MummyState_Standing = 1,
-        MummyState_Falling  = 2  //!< Falling forward
-    };
-
-    /*!
-     * \brief States of Larson (Item 27)
-     */
-    enum LarsonStates {
-        LarsonState_Walking1    = 0,
-        LarsonState_StandingGun = 1,
-        LarsonState_Walking2    = 2,
-        LarsonState_Running     = 3,
-        LarsonState_Aiming      = 4,
-        LarsonState_Injured     = 5, //!< Injured by gunshot / Dying
-        LarsonState_Standing    = 6,
-        LarsonState_Firing      = 7
-    };
-
-    /*!
-     * \brief States of Pierre (Item 28)
-     */
-    enum PierreStates {
-        PierreState_Standing   = 1,
-        PierreState_Walking    = 2,
-        PierreState_Running    = 3,
-        PierreState_Aiming     = 4,
-        PierreState_Dying      = 5,
-        PierreState_Holstering = 6,
-        PierreState_Firing     = 7
-    };
-
-    /*!
-     * \brief States of the Skateboard (Item 29)
-     */
-    enum SkateboardStates {
-        SkateboardState_BeingTurned = 0,
-        SkateboardState_Stationary1 = 1,
-        SkateboardState_Stationary2 = 2,
-        SkateboardState_Stationary3 = 3,
-        SkateboardState_Stationary4 = 4
-    };
-
-    /*!
-     * \brief States of the Skateboard Kid (Item 30)
-     */
-    enum SkateboardKidStates {
-        SkateboardKidState_Turning = 0, //!< Turning and Aiming?
-        SkateboardKidState_Firing1 = 1,
-        SkateboardKidState_Skating = 2,
-        SkateboardKidState_Aiming  = 3,
-        SkateboardKidState_Firing2 = 4,
-        SkateboardKidState_Dying   = 5
-    };
-
-    /*!
-     * \brief States of the Cowboy (Item 31)
-     */
-    enum CowboyStates {
-        CowboyState_Aiming1 = 1,
-        CowboyState_Walking = 2,
-        CowboyState_Running = 3,
-        CowboyState_Aiming2 = 4,
-        CowboyState_Dying   = 5,
-        CowboyState_Firing  = 6
-    };
-
-    /*!
-     * \brief States of Mr. T (Item 32)
-     */
-    enum MrTStates {
-        MrTState_Dying    = 0,
-        MrTState_Standing = 1,
-        MrTState_Walking  = 2,
-        MrTState_Running  = 3,
-        MrTState_Aiming   = 4,
-        MrTState_Firing   = 6
-    };
-
-    /*!
-     * \brief States of Winged Natla (Item 33)
-     */
-    enum WingedNatlaStates {
-        WingedNatlaState_Standing1 = 1,
-        WingedNatlaState_Flying    = 2,
-        WingedNatlaState_Running   = 3,
-        WingedNatlaState_Aiming    = 4, //!< Aiming and Firing
-        WingedNatlaState_Dying1    = 5, //!< "Dying" the first time
-        WingedNatlaState_Spinning  = 7, //!< Spinning around in air
-        WingedNatlaState_Standing2 = 8,
-        WingedNatlaState_Dying2    = 9  //!< Dying for real
-    };
-
-    /*!
-     * \brief States of the Giant Mutant (Item 34)
-     */
-    enum GiantMutantStates {
-        GiantMutantState_Dying         = 0,
-        GiantMutantState_Sitting       = 1, //!< Sitting on floor
-        GiantMutantState_Pulling       = 2, //!< Pulling self forward
-        GiantMutantState_SlappingRight = 4, //!< Slapping with right hand
-        GiantMutantState_SlappingBoth  = 5, //!< Slapping with both hands
-        GiantMutantState_MakingWave    = 6, //!< Making big wave with right hand
-        GiantMutantState_Dropping      = 8, //!< Dropping to floor after hatching
-        GiantMutantState_RaisingArms   = 9,
-        GiantMutantState_Shaking       = 11 //!< Shaking victim with right hand
-    };
-
-    /*!
-     * \brief States of a piece of Collapsible Floor (Item 35)
-     */
-    enum CollapsibleFloorStates {
-        CollapsibleFloorState_Stationary = 0,
-        CollapsibleFloorState_Shaking    = 1,
-        CollapsibleFloorState_Falling    = 2,
-        CollapsibleFloorState_Settling   = 3  //!< Settling down
-    };
-
-    /*!
-     * \brief States of a Swinging Blade (Item 36)
-     */
-    enum SwingingBladeStates {
-        SwingingBladeState_Stationary = 0,
-        SwingingBladeState_Swinging   = 2
-    };
-
-    /*!
-     * \brief States of a Boulder (Item 38)
-     */
-    enum BoulderStates {
-        BoulderState_Stationary = 0,
-        BoulderState_Rolling    = 1
-    };
-
-    /*!
-     * \brief States of a Dart Gun (Item 40)
-     */
-    enum DartGunStates {
-        DartGunState_Idle   = 0, //!< ?
-        DartGunState_Firing = 1  //!< ?
-    };
-
-    /*!
-     * \brief States of a Door opening upwards (Item 41)
-     */
-    enum DoorUpwardStates {
-        DoorUpwardState_Upward = 0,
-        DoorUpwardState_OnSide = 1
-    };
-
-    /*!
-     * \brief States of a Slamming Door (Item 42)
-     */
-    enum SlammingDoorStates {
-        SlammingDoorState_Open   = 0,
-        SlammingDoorState_Closed = 1
-    };
-
-    /*!
-     * \brief States of the Handle of Thors Hammer (Item 44)
-     */
-    enum ThorHammerHandleStates {
-        ThorHammerHandleState_Stationary = 0, //!< Stationary in up position
-        ThorHammerHandleState_Moving1    = 1, //!< Moving down a little and returning
-        ThorHammerHandleState_Moving2    = 2, //!< Moving down all the way
-        ThorHammerHandleState_Stopped    = 3  //!< Stopped at down position
-    };
-
-    /*!
-     * \brief States of the Block of Thors Hammer (Item 45)
-     */
-    enum ThorHammerBlockStates {
-        ThorHammerBlockState_Stationary = 0,
-        ThorHammerBlockState_Moving1    = 1, //!< Moving down a little and returning
-        ThorHammerBlockState_Moving2    = 2  //!< Moving down all the way
-    };
-
-    /*!
-     * \brief States of a Metal Rod (Item 47)
-     */
-    enum MetalRodStates {
-        MetalRodState_Stationary = 0,
-        MetalRodState_Moving     = 1
-    };
-
-    /*!
-     * \brief States of a Pushable Cubical (Item 48 - 51)
-     */
-    enum PushableStates {
-        PushableState_Stationary = 0,
-        PushableState_Pulled     = 1, //!< ?
-        PushableState_Pushed     = 2  //!< ?
-    };
-
-    /*!
-     * \brief States of a Movable Tall Block (Item 52)
-     */
-    enum MovableTallBlockStates {
-        MovableTallBlockState_Stationary     = 0,
-        MovableTallBlockState_MovingForward  = 1, //!< ?
-        MovableTallBlockState_MovingBackward = 2  //!< ?
-    };
-
-    /*!
-     * \brief States of Falling Pieces (Item 53)
-     */
-    enum FallingPiecesStates {
-        FallingPiecesState_Stationary = 0,
-        FallingPiecesState_Falling    = 1,
-        FallingPiecesState_Settling   = 2  //!< Settling down
-    };
-
-    /*!
-     * \brief States of a Switch (Item 55, 56)
-     */
-    enum SwitchStates {
-        SwitchState_Off = 0,
-        SwitchState_On  = 1  //!< States may be reversed
-    };
-
-    /*!
-     * \brief States of a Door (Item 57 - 66)
-     */
-    enum DoorStates {
-        DoorState_Closed = 0,
-        DoorState_Open   = 1
-    };
-
-    /*!
-     * \brief States of a Cog (Item 74 - 76)
-     */
-    enum CogStates {
-        CogState_Stationary = 0,
-        CogState_Turning    = 1
-    };
-
-    /*!
-     * \brief States of a Shack (Item 162)
-     */
-    enum ShackStates {
-        ShackState_StartingPosition = 0,
-        ShackState_DroppingFirst    = 1, //!< Dropping after first fuse
-        ShackState_DroppingSecond   = 2, //!< Dropping after second fuse
-        ShackState_DroppingThird    = 3, //!< Dropping to ground after third fuse
-        ShackState_OnGround         = 4
-    };
-
-    /*!
-     * \brief States of a Mutant Egg & Holder (Item 163 & 181)
-     */
-    enum MutantEggStates {
-        MutantEggState_Starting = 0,
-        MutantEggState_Hatching = 1  //!< Is the fragmenting hardcoded?
-    };
-
-    /*!
-     * \brief States of a Motorboat (Item 182)
-     */
-    enum MotorboatStates {
-        MotorboatState_StationaryInitial = 1,
-        MotorboatState_Moving            = 2,
-        MotorboatState_StationaryFinal   = 3
-    };
-
-    /*!
-     * \brief Items & IDs in Tomb Raider 1
-     */
-    enum Items {
-        Lara             = 0,
-        PistolAnimation  = 1,
-        ShotgunAnimation = 2,
-        MagnumAnimation  = 3,
-        LaraAlternate    = 4,  //!< Lara's home appearance, wounded, or turned to gold
-        UziAnimation     = 5,
-        LaraMutant       = 6,
-        Wolf             = 7,
-        Bear             = 8,
-        Bat              = 9,
-        CrocodileLand    = 10,
-        CrocodileWater   = 11,
-        LionMale         = 12,
-        LionFemale       = 13, //!< Same states as Male Lion
-        Panther          = 14, //!< Same states as Male and Female Lion
-        Gorilla          = 15,
-        GiantRatLand     = 16,
-        GiantRatWater    = 17,
-        Tyrannosaur      = 18,
-        Raptor           = 19,
-        WingedMutant     = 20, //!< Also winged mummy (unused)
-        LaraHips1        = 21,
-        LaraHips2        = 22,
-        CentaurMutant    = 23,
-        Mummy            = 24,
-
-        Larson           = 27,
-        Pierre           = 28,
-        Skateboard       = 29,
-        SkateboardKid    = 30,
-        Cowboy           = 31,
-        MrT              = 32,
-        WingedNatla      = 33, //!< Actually Natla with a winged mutant
-        GiantMutant      = 34,
-        CollapsibleFloor = 35,
-        SwingingBlade    = 36,
-        Spikes           = 37,
-        Boulder          = 38,
-        Dart             = 39,
-        DartGun          = 40,
-        DoorUpward       = 41,
-        SlammingDoor     = 42,
-        SwordOfDamocles1 = 43,
-        ThorHammerHandle = 44,
-        ThorHammerBlock  = 45,
-        HangingBall      = 46, //!< Hanging ball? Some kind of box?
-        MetalRod         = 47, //!< Metal rod? / Powered mining cart
-        PushableCubical1 = 48,
-        PushableCubical2 = 49,
-        PushableCubical3 = 50,
-        PushableCubical4 = 51,
-        MovableTallBlock = 52,
-        FallingPieces    = 53,
-        SwordOfDamocles2 = 54,
-        AboveWaterSwitch = 55,
-        UnderWaterSwitch = 56,
-        Door1            = 57,
-        Door2            = 58,
-        Door3            = 59,
-        Door4            = 60,
-        Door5            = 61,
-        Door6            = 62,
-        Door7            = 63,
-        Door8            = 64,
-        Trapdoor1        = 65, //!< Uses DoorStates
-        Trapdoor2        = 66, //!< Uses DoorStates
-
-        BridgeFlat       = 68,
-        BridgeSlope1     = 69,
-        BridgeSlope2     = 70,
-        PassportOpen     = 71, //!< Passport opening up
-        Compass          = 72,
-
-        Cogs1            = 74, //!< animated
-        Cogs2            = 75, //!< animated
-        Cogs3            = 76, //!< animated
-        CS_Lara          = 77, //!< Lara / Scion holder in Cut Scene
-        CS_Larson        = 78, //!< Larson / Natla / Scion holder in Cut Scene
-        CS_LarsonGun     = 79, //!< Larsons gun / Scion / Natla in Cut Scene
-        CS_Scion         = 80, //!< Scion in Cut Scene
-        PassportClosed   = 81, //!< Passport closed
-        N                = 82, //!< N-thingy, Playstation memory card?
-        SaveCrystal      = 83,
-        _Pistols         = 84,
-        _Shotgun         = 85,
-        _Magnums         = 86,
-        _Uzis            = 87,
-        _PistolAmmo      = 88, //!< ?
-        _ShotgunAmmo     = 89,
-        _MagnumAmmo      = 90,
-        _UziAmmo         = 91,
-
-        _SmallMedipack   = 93,
-        _LargeMedipack   = 94,
-        Sunglasses       = 95,
-        Cassette         = 96, // Cassette player and headphones
-        DirectionKeys    = 97,
-
-        Pistol           = 99,
-        Shotgun          = 100,
-        Magnum           = 101,
-        Uzi              = 102,
-        PistolAmmo       = 103, //!< ?
-        ShotgunAmmo      = 104,
-        MagnumAmmo       = 105,
-        UziAmmo          = 106,
-
-        SmallMedipack    = 108,
-        LargeMedipack    = 109,
-        _Puzzle1         = 110,
-        _Puzzle2         = 111,
-        _Puzzle3         = 112,
-        _Puzzle4         = 113,
-        Puzzle1          = 114,
-        Puzzle2          = 115,
-        Puzzle3          = 116,
-        Puzzle4          = 117,
-        Slot1Empty       = 118,
-        Slot2Empty       = 119,
-        Slot3Empty       = 120,
-        Slot4Empty       = 121,
-        Slot1Full        = 122,
-        Slot2Full        = 123,
-        Slot3Full        = 124,
-        Slot4Full        = 125,
-        _Pickup1         = 126,
-        Pickup1          = 127,
-        LaraHips3        = 128,
-        _Key1            = 129,
-        _Key2            = 130,
-        _Key3            = 131,
-        _Key4            = 132,
-        Key1             = 133,
-        Key2             = 134,
-        Key3             = 135,
-        Key4             = 136,
-        Lock1            = 137,
-        Lock2            = 138,
-        Lock3            = 139,
-        Lock4            = 140,
-
-        _ScionPiece      = 143,
-
-        CompleteScion    = 146,
-        ScionHolder      = 147,
-
-        ScionPiece       = 150,
-        _Flare           = 151, //!< Flare(?) / Explosion
-
-        _Splash          = 153,
-
-        _Bubbles1        = 155,
-        _Bubbles2        = 156,
-
-        _BloodSplatter   = 158,
-
-        _FlyingDisk      = 160,
-        CentaurStatue    = 161,
-        Shack            = 162, //!< Suspended from wire rope
-        MutantEggNormal  = 163, //!< Mutant Egg and Holder (Normal)
-        _BulletHit       = 164,
-        _Sparkle         = 165,
-        Gunflare1        = 166,
-
-        LaraHips4        = 169,
-        LaraHips5        = 170,
-
-        MutantBullet     = 172,
-        MutantGrenade    = 173,
-
-        _Splatter        = 176,
-        LaraHips6        = 177,
-        _Fire            = 178,
-        LaraHips7        = 179,
-        FlowingLava      = 180, //!< Flowing Atlantean Lava
-        MutantEggBig     = 181, //!< Mutant Egg and Holder (Big)
-        Motorboat        = 182,
-        LaraHips8        = 183,
-
-        ShrinkingWedge   = 189, //!< ?
-        _StandardSymbols = 190,
-        _Plant1          = 191,
-        _Plant2          = 192,
-        _Plant3          = 193,
-        _Plant4          = 194,
-        _Plant5          = 195,
-
-        _Bag1            = 200,
-
-        _Bag2            = 204,
-
-        Gunflare2        = 207,
-
-        _Rock1           = 212,
-        _Rock2           = 213,
-        _Rock3           = 214,
-        _Bag3            = 215,
-        _Pottery1        = 216,
-        _Pottery2        = 217,
-
-        _PaintedPot      = 231,
-
-        _IncaMummy       = 233,
-
-        _Pottery3        = 236,
-        _Pottery4        = 237,
-        _Pottery5        = 238,
-        _Pottery6        = 239
-    };
-};
-
-#endif

include/templates/List.h

@@ -1,460 +0,0 @@
-/*!
- * \file include/templates/List.h
- * \brief Template list
- *
- * UINT_MAX is an error condition, used in place of -1
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifndef _LIST_H_
-#define _LIST_H_
-
-#include <stdlib.h>
-#include <limits.h>
-#include <stdio.h>
-
-/*!
- * \brief Template class encapsulating a single list node
- * \tparam T encapsulated data type
- */
-template <class T> class ListNode {
-public:
-
-    /*!
-     * \brief Create a new ListNode
-     * \param data Data to be stored in node
-     * \param id node id
-     */
-    ListNode(T data, unsigned int id) {
-        _data  = data;
-        _id = id;
-        _next = NULL;
-    }
-
-    /*!
-     * \brief Destroy a ListNode
-     */
-    ~ListNode() {
-    }
-
-    /*!
-     * \brief Set the id of this ListNode
-     * \param id new id
-     */
-    void Id(unsigned int id) {
-        _id = id;
-    }
-
-    /*!
-     * \brief Get the id of this ListNode
-     * \returns current id
-     */
-    unsigned int Id() {
-        return _id;
-    }
-
-    /*!
-     * \brief Set the data of this ListNode
-     * \param data new data
-     */
-    void Data(T data) {
-        _data = data;
-    }
-
-    /*!
-     * \brief Get the data of this ListNode
-     * \returns current data
-     */
-    T Data() {
-        return _data;
-    }
-
-    /*!
-     * \brief Get the next ListNode in the List
-     * \returns next pointer or NULL
-     */
-    ListNode<T> *Next() {
-        return _next;
-    }
-
-    /*!
-     * \brief Set the next ListNode in the List
-     * \param next new next pointer
-     */
-    void Next(ListNode<T> *next) {
-        _next = next;
-    }
-
-    /*!
-     * \brief Print this ListNode
-     */
-    void Print() {
-        printf("(%u, %p)",  _id, _data);
-    }
-
-private:
-
-    ListNode<T> *_next; //!< Next Pointer
-    unsigned int _id; //!< ListNode ID
-    T _data; //!< Encapsulated data
-};
-
-/*!
- * \brief Template class representing a linked list
- * \tparam T encapsulated data type
- */
-template <class T> class List {
-public:
-
-    /*!
-     * \brief Construct a new linked list
-     */
-    List() {
-        _num_items = 0;
-        _head = NULL;
-        _current = NULL;
-        _last = NULL;
-        _cache = NULL;
-    }
-
-    /*!
-     * \brief Deconstruct a linked list
-     * \sa List::Clear()
-     */
-    ~List() {
-        Clear();
-    }
-
-    /*!
-     * \brief Add all data from another list to this one
-     * NOTE: this only copies data, the containers aren't the same ids
-     * \param list source list where data does come from
-     */
-    void Copy(List<T> *list) {
-        if (!list)
-            return;
-        for (list->Reset(); list->CurrentExists(); list->Next())
-            Add(list->Current());
-    }
-
-    /*!
-     * \brief Delete every item in this list
-     */
-    void Clear() {
-        _num_items = 0;
-        _last = _cache = NULL;
-        while (_head) {
-            _current = _head;
-            _head = _head->Next();
-            delete _current;
-        }
-    }
-
-    /*!
-     * \brief Searches the list for an id
-     * \param id id to be searched
-     * \returns data with id, or 0
-     */
-    T SearchId(unsigned int id) {
-        ListNode<T> *current = _head;
-        ListNode<T> *last = NULL;
-        if (_cache) {
-            if (id >= _cache->Id())
-                current = _cache;
-        }
-        while (current) {
-            // Found
-            if (current->Id() == id) {
-                _cache = current;
-                return current->Data();
-            }
-            last = current;
-            current = current->Next();
-        }
-        return 0;
-    }
-
-    /*!
-     * \brief Searches the list for specific data
-     * \param data data to be searched for
-     * \returns id of data, or UINT_MAX
-     */
-    unsigned int SearchKey(T data) {
-        ListNode<T> *current = _head;
-        ListNode<T> *last = NULL;
-        if (_cache) {
-            // Mongoose: 2001-01-31, hhmmm... fixed?
-            if (data == _cache->Data())
-                return _cache->Id();
-        }
-        while (current) {
-            // Found
-            if (current->Data() == data) {
-                _cache = current;
-                return current->Id();
-            }
-            last = current;
-            current = current->Next();
-        }
-        return UINT_MAX;
-    }
-
-    /*!
-     * \brief Search for an id
-     * \param i id to be searched
-     * \returns id or 0
-     * \sa List::SearchId()
-     */
-    T operator [] (unsigned int i) {
-        if (_head) {
-            return SearchId(i);
-        } else {
-#ifdef DEBUG_INDEX_EMPTY_LIST
-            printf("List[%u] = NULL\n", i);
-#endif
-        }
-        return 0;
-    }
-
-    /*!
-     * \brief Search for an id and remove the associated item from the list
-     * \param id id to be deleted
-     */
-    void RemoveId(unsigned int id) {
-        ListNode<T> *current = _head;
-        ListNode<T> *last = NULL;
-        _last = _cache = NULL;
-        while (current) {
-            // Remove
-            if (current->Id() == id) {
-                if (current == _head)
-                    _head = current->Next();
-                else
-                    last->Next(current->Next());
-                if (_current == current)
-                    _current = NULL;
-                delete current;
-                _num_items--;
-                return;
-            }
-            last = current;
-            current = current->Next();
-        }
-    }
-
-    /*!
-     * \brief Search for data and remove the associated item from the list
-     * \param data data to be deleted
-     */
-    void Remove(T data) {
-        ListNode<T> *current = _head;
-        ListNode<T> *last = NULL;
-        _last = _cache = NULL;
-        while (current) {
-            // Remove
-            if (current->Data() == data) {
-                if (current == _head)
-                    _head = current->Next();
-                else
-                    last->Next(current->Next());
-                if (_current == current)
-                    _current = NULL;
-                delete current;
-                _num_items--;
-                return;
-            }
-            last = current;
-            current = current->Next();
-        }
-    }
-
-    /*!
-     * \brief Is the list empty?
-     * \returns true if the list is empty
-     */
-    bool Empty() {
-        return (_head == NULL);
-    }
-
-    /*!
-     * \brief Length of the list
-     * \returns number of items in the list
-     */
-    unsigned int NumItems() {
-        return _num_items;
-    }
-
-    /*!
-     * \brief Print the list
-     * \param print_func function that will be called for each item in the list, after its id was printed. Or NULL.
-     */
-    void Print(void (*print_func)(T)) {
-        ListNode<T> *current = _head;
-        printf(" [%u] {\n", _num_items);
-        while (current) {
-            printf("#%u, ", current->Id());
-            if (print_func)
-                (*print_func)(current->Data());
-            current = current->Next();
-            fflush(stdout);
-        }
-        printf(" }\n");
-    }
-
-    /*!
-     * \brief Print all IDs in this list
-     */
-    void Print() {
-        ListNode<T> *current = _head;
-        printf("List %u {\n", _num_items);
-        while (current) {
-            //current->Print();
-            printf("%u", current->Id());
-            current = current->Next();
-            if (current)
-                printf(", ");
-            fflush(stdout);
-        }
-        printf(" }\n");
-    }
-
-    /*!
-     * \brief Reset the iterator
-     */
-    void Reset() {
-        _current = _head;
-        _cache = _head;
-    }
-
-    /*!
-     * \brief Traverses the list
-     * \returns true if there is a new current item, false if the list is at the end
-     * \sa List::Next()
-     */
-    bool operator ++ (int) {
-        return Next();
-    }
-
-    /*!
-     * \brief Traverses the list
-     * \returns true if there is a new current item, false if the list is at the end
-     * \sa List::Next()
-     */
-    bool operator ++ () {
-        return Next();
-    }
-
-    /*!
-     * \brief Traverses the list
-     * \returns true if there is a new current item, false if the list is at the end
-     */
-    bool Next() {
-        if (_current)
-            _current = _current->Next();
-        return (_current != NULL);
-    }
-
-    /*!
-     * \brief Get the id of the current item
-     * \returns id of current item or UINT_MAX if there is no current item
-     */
-    unsigned int CurrentId() {
-        if (!_current)
-            return UINT_MAX;
-
-        return _current->Id();
-    }
-
-    /*!
-     * \brief Is there a current item?
-     * \returns true if there is a current item, false otherwise
-     */
-    bool CurrentExists() {
-        return (_current != 0);
-    }
-
-    /*!
-     * \brief Get the current items data
-     * \returns data of the current item or 0 if there is no current item
-     */
-    T Current() {
-        if (_current)
-            return _current->Data();
-        else
-            return 0;
-    }
-
-    /*!
-     * \brief Add data to the list. Constructs a new ListNode encapsulating the data.
-     * \param data data to be stored
-     * \returns id of the new ListNode
-     */
-    unsigned int Add(T data) {
-        ListNode<T> *node;
-
-        node = new ListNode<T>(data, _num_items++);
-        return Add(node);
-    }
-
-    /*!
-     * \brief Add a ListNode to the end of this List.
-     * \param node new node
-     * \returns id of the node
-     */
-    unsigned int Add(ListNode<T> *node) {
-        ListNode<T> *current;
-        ListNode<T> *last;
-        unsigned int i;
-
-        if (_head) {
-            current = _head;
-            last = NULL;
-            i = 0;
-
-            //EXP
-            if (_last) {
-                i = _last->Id();
-                current = _last;
-            }
-
-            while (current) {
-                // Prepend
-                if (current->Id() > i) {
-                    node->Id(i);
-                    node->Next(current);
-
-                    if (current == _head)
-                        _head = node;
-                    else if (last)
-                        last->Next(node);
-
-                    return node->Id();
-                }
-
-                i++;
-                last = current;
-                current = current->Next();
-            }
-
-            // Append
-            last->Next(node);
-        } else
-            _head = node;
-
-        _last = node; //EXP
-
-        return node->Id();
-    }
-
-private:
-
-    unsigned int _num_items; //!< Number of items in the list
-    ListNode<T> *_head; //!< First item in the list
-    ListNode<T> *_current; //!< Current item for the list iterator
-    ListNode<T> *_last; //!< Last item in the list
-    ListNode<T> *_cache; //!< cache used by the search methods
-};
-
-#endif

include/templates/Vector.h

@@ -1,409 +0,0 @@
-/*!
- * \file include/templates/Vector.h
- * \brief Template Vector
- *
- * \author Mongoose
- */
-
-#ifndef _VECTOR_H_
-#define _VECTOR_H_
-
-#include <stdlib.h>
-#include <stdio.h>
-
-/*!
- * \brief Template class for a (pretty strange) Vector
- * \tparam Object datatype the Vector can store
- */
-template <class Object> class Vector {
-public:
-
-    /*!
-     * \brief Construct an empty Vector
-     */
-    Vector() {
-        mData = 0x0;
-        mError = 0x0;
-        mReserve = 0;
-        mStart = 0;
-        mEnd = 0;
-        mIndex = 0;
-    }
-
-    /*!
-     * \brief Construct a Vector from another one
-     * \param vector Vector to copy from
-     */
-    Vector(Vector &vector) {
-        mData = 0x0;
-        mError = 0x0;
-        mReserve = 0;
-        mStart = 0;
-        mEnd = 0;
-        mIndex = 0;
-        copy(vector);
-    }
-
-    /*!
-     * \brief Construct a Vector with a specific size
-     * \param size initial size
-     */
-    Vector(unsigned int size) {
-        mData = 0x0;
-        mError = 0x0;
-        mReserve = 0;
-        mStart = 0;
-        mEnd = 0;
-        mIndex = 0;
-        resize(size);
-    }
-
-    /*!
-     * \brief Deconstruct a Vector
-     */
-    ~Vector() {
-        if (!empty() && mData)
-            delete [] mData;
-        clear();
-        mReserve = 0;
-    }
-
-    /*!
-     * \brief Clears the Vector, but deletes nothing
-     * \sa Vector::erase()
-     */
-    void clear() {
-        mStart = 0;
-        mEnd = 0;
-        mIndex = 0;
-    }
-
-    /*!
-     * \brief Clears the vector and deletes everything contained
-     * \sa Vector::clear()
-     */
-    void erase() {
-        for (start(); forward(); next()) {
-            if (current())
-                delete current();
-        }
-        clear();
-    }
-
-    /*!
-     * \brief Reserve more memory
-     * \param count new maximum size
-     */
-    void reserve(unsigned int count) {
-        Object *swap = 0x0;
-        if (count > mReserve) {
-            swap = mData;
-            mReserve = count;
-            mData = new Object[count];
-        }
-        if (swap) {
-            for (unsigned int i = begin(); i < end(); ++i)
-                mData[i] = swap[i];
-            delete [] swap;
-        }
-    }
-
-    /*!
-     * \brief Resize the Vector
-     * \param count new size
-     */
-    void resize(unsigned int count) {
-        resize(count, 0x0);
-    }
-
-    /*!
-     * \brief Resize the Vector
-     * \param count new size
-     * \param object what to put into blank spaces
-     */
-    void resize(unsigned int count, Object object) {
-        reserve(count);
-        for (unsigned int i = 0; i < count; ++i) {
-            if (i < begin() || i >= end())
-                mData[i] = object;
-        }
-        mEnd = count;
-    }
-
-    /*!
-     * \brief Increase size by 1
-     */
-    void pushBack() {
-        pushBack(0x0);
-    }
-
-    /*!
-     * \brief Increase size by 1
-     * \param object what to put into new space
-     */
-    void pushBack(Object object) {
-        resize(size() + 1);
-        mData[size()-1] = object;
-    }
-
-    /*!
-     * \brief Check if empty
-     * \returns true if begin() equals end()
-     */
-    bool empty() {
-        return (begin() == end());
-    }
-
-    /*!
-     * \brief Check maximum capacity
-     * \returns reserved memory
-     */
-    unsigned int capacity() {
-        return mReserve;
-    }
-
-    /*!
-     * \brief Get start index
-     * \returns start index
-     */
-    unsigned int begin() {
-        return mStart;
-    }
-
-    /*!
-     * \brief Get end index
-     * \returns end index
-     */
-    unsigned int end() {
-        return mEnd;
-    }
-
-    /*!
-     * \brief Get size
-     * \returns end index
-     */
-    unsigned int size() {
-        return mEnd;
-    }
-
-    /*!
-     * \brief Copy a Vector into this one.
-     * May increase size.
-     * \param vector Vector to copy from
-     */
-    void copy(Vector<Object> &vector) {
-        unsigned int i;
-        if (vector.capacity() > capacity()) {
-            resize(vector.capacity());
-        }
-        mStart = vector.begin();
-        mEnd = vector.end();
-        mError = vector.Error();
-        mIndex = vector.getCurrentIndex();
-        for (i = vector.begin(); i < vector.end(); ++i) {
-            mData[i] = vector[i];
-        }
-    }
-
-    /*!
-     * \brief Sort the Vector
-     * \param compareFunc comparison function for qsort
-     */
-    void qSort(int (*compareFunc)(const void *, const void *)) {
-        qsort(mData, end(), sizeof(Object), compareFunc);
-    }
-
-    /*!
-     * \brief Swap two items
-     * \param index first index
-     * \param index2 second index
-     */
-    void swap(unsigned int index, unsigned int index2) {
-        if (index < begin() || index > end())
-            return;
-
-        if (index2 < begin() || index2 > end())
-            return;
-
-        Object swap = mData[index];
-        mData[index] = mData[index2];
-        mData[index2] = swap;
-    }
-
-    /*!
-     * \brief Set an index to a value
-     * \param index index to set
-     * \param object object to set it to
-     */
-    void assign(unsigned int index, Object object) {
-        mData[index] = object;
-    }
-
-    /*!
-     * \brief Get value at index
-     * \param index index to look at
-     * \returns data for index, or error object
-     */
-    Object operator [] (unsigned int index) {
-        if (mData == 0x0 || index < begin() || index > end() || index >= size() || empty())
-            return mError;
-        return mData[index];
-    }
-
-    /*!
-     * \brief Print the Vector
-     * \param print_func function that can print Objects
-     */
-    void print(void (*print_func)(Object)) {
-        for (unsigned int i = begin(); i < end(); ++i) {
-            if (print_func)
-                (*print_func)(mData[i]);
-            fflush(stdout);
-        }
-        printf("\n");
-    }
-
-
-    /*!
-     * \brief Start Iterator at specific index
-     * \param index where to start
-     */
-    void start(unsigned int index) {
-        if (mData == 0x0 || index < begin() || index > end() ||
-             index >= size() || empty())
-            return;
-
-        mIndex = index;
-    }
-
-    /*!
-     * \brief Set Iterator to the first element
-     */
-    void start() {
-        mIndex = begin();
-    }
-
-    /*!
-     * \brief Set Iterator to the last element
-     */
-    void finish() {
-        mIndex = end() - 1;
-    }
-
-    /*!
-     * \brief Check if the Iterator can go forward
-     * \returns true if Iterator is still in range
-     */
-    bool forward() {
-        return (mIndex < end());
-    }
-
-    /*!
-     * \brief Check if the Iterator can go backwards
-     * \returns true if Iterator is already in range
-     */
-    bool backward() {
-        return (mIndex + 1 > begin());
-    }
-
-    /*!
-     * \brief Increment the Iterator
-     */
-    void next() {
-        if (mIndex < end())
-            ++mIndex;
-    }
-
-    /*!
-     * \brief Decrement the Iterator
-     */
-    void prev() {
-        --mIndex;
-    }
-
-    /*!
-     * \brief Set the error object
-     * \param object new error object
-     */
-    void setError(Object object) {
-        mError = object;
-    }
-
-    /*!
-     * \brief Get Iterator index
-     * \returns current Iterator index
-     */
-    unsigned int getCurrentIndex() {
-        return mIndex;
-    }
-
-    /*!
-     * \brief Set Iterator index
-     * \param index new Iterator index
-     */
-    void setCurrentIndex(unsigned int index) {
-        if (index < end())
-            mIndex = index;
-    }
-
-    /*!
-     * \brief Get current element
-     * \returns element at Iterator index
-     */
-    Object current() {
-        return mData[mIndex];
-    }
-
-    /*!
-     * \brief Check if an object is in the Vector.
-     * Requires objects to support `==`.
-     * \param object object to find
-     * \returns true if found, false if not.
-     */
-    bool find(Object object) {
-        for (start(); forward(); next()) {
-            if (object == current())
-                return true;
-        }
-        return false;
-    }
-
-    //
-    /*!
-     * \brief Add an object.
-     * Instead of appending objects this attempts replacing 'removed' objects.
-     * \param object object to add
-     * \returns index of added object
-     */
-    unsigned int add(Object object) {
-        if (begin() > 0) {
-            mData[begin() - 1] = object;
-            --mStart;
-
-            return begin();
-        }
-
-        pushBack(object);
-        return size();
-    }
-
-
-    /*!
-     * \brief Remove an object. This will change the index of another element!
-     * \param index index to "remove".
-     */
-    void remove(unsigned int index) {
-        mData[index] = mData[begin()];
-        ++mStart;
-    }
-
-private:
-    Object *mData;         //!< Data array
-    Object mError;         //!< Error object
-    unsigned int mReserve; //!< Index for reserved space
-    unsigned int mStart;   //!< Start index
-    unsigned int mEnd;     //!< End index
-    unsigned int mIndex;   //!< Iterator index
-};
-
-#endif

include/utils/math.h

@@ -1,71 +0,0 @@
-/*!
- *
- * \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

@@ -1,61 +0,0 @@
-/*!
- * \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

@@ -1,89 +0,0 @@
-/*!
- * \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

@@ -1,32 +0,0 @@
-/*!
- * \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

@@ -1,22 +1,5 @@
 # Set Source files
-set (SRCS ${SRCS} "Camera.cpp")
-set (SRCS ${SRCS} "Emitter.cpp")
-set (SRCS ${SRCS} "GLString.cpp")
-set (SRCS ${SRCS} "Matrix.cpp")
-set (SRCS ${SRCS} "Mesh.cpp")
-set (SRCS ${SRCS} "OpenRaider.cpp")
-set (SRCS ${SRCS} "Particle.cpp")
-set (SRCS ${SRCS} "Quaternion.cpp")
-set (SRCS ${SRCS} "Render.cpp")
-set (SRCS ${SRCS} "SDLSystem.cpp")
-set (SRCS ${SRCS} "SkeletalModel.cpp")
-set (SRCS ${SRCS} "Sound.cpp")
-set (SRCS ${SRCS} "System.cpp")
-set (SRCS ${SRCS} "Texture.cpp")
-set (SRCS ${SRCS} "TombRaider.cpp")
-set (SRCS ${SRCS} "Vector3d.cpp")
-set (SRCS ${SRCS} "ViewVolume.cpp")
-set (SRCS ${SRCS} "World.cpp")
+set (SRCS ${SRCS} "main.cpp")
 
 #################################################################
 
@@ -82,7 +65,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})
@@ -164,7 +147,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/Camera.cpp

@@ -1,247 +0,0 @@
-/*!
- * \file src/Camera.cpp
- * \brief OpenGL camera class
- *
- * \author Mongoose
- */
-
-#include <stdio.h>
-#include <math.h>
-
-#include "utils/math.h"
-#include "Camera.h"
-
-Camera::Camera() {
-    mFlags = 0;
-    mViewDistance = 14.0f;
-    mTranslateDelta = 256.0f;
-    mRotateDelta = HEL_DEG_TO_RAD(15.0f);
-    mRotateDelta2 = HEL_DEG_TO_RAD(5.0f);
-    mFlags &= Camera_FlyMode;
-    reset();
-}
-
-void Camera::getPosition(vec3_t pos) {
-    pos[0] = mPos[0];
-    pos[1] = mPos[1];
-    pos[2] = mPos[2];
-}
-
-void Camera::getUp(vec3_t up) {
-    up[0] = mUp[0];
-    up[1] = mUp[1];
-    up[2] = mUp[2];
-}
-
-void Camera::getTarget(vec3_t target) {
-    target[0] = mTarget[0];
-    target[1] = mTarget[1];
-    target[2] = mTarget[2];
-}
-
-float Camera::getYaw() {
-    return HEL_RAD_TO_DEG(mTheta);
-}
-
-vec_t Camera::getRadianYaw() {
-    return mTheta;
-}
-
-vec_t Camera::getRadianPitch() {
-    return mTheta2;
-}
-
-void Camera::rotate(float angle, float x, float y, float z) {
-    Quaternion t, n;
-    Matrix matrix;
-    vec_t side[4] = { 1.0f, 0.0f,  0.0f, 1.0f };
-    vec_t up[4] =   { 0.0f, 1.0f,  0.0f, 1.0f };
-    vec_t look[4] = { 0.0f, 0.0f, -1.0f, 1.0f };
-    unsigned int i;
-    matrix_t m;
-
-    t.set(angle, x, y, z);
-    n = mQ * t;
-    n.normalize();
-
-    n.getMatrix(m);
-    matrix.setMatrix(m);
-    matrix.multiply4v(side, mSide);
-    matrix.multiply4v(look, mTarget);
-    matrix.multiply4v(up, mUp);
-
-    for (i = 0; i < 3; ++i) {
-        mSide[i] += mPos[i];
-        mTarget[i] += mPos[i];
-        mUp[i] += mPos[i];
-    }
-
-    mQ = n;
-}
-
-void Camera::translate(float x, float y, float z) {
-    int i;
-    vec_t result[4];
-    vec_t v[4];
-    matrix_t m;
-    Matrix matrix;
-
-    v[0] = x;
-    v[1] = y;
-    v[2] = -z;
-    v[3] = 1;
-
-    m[0] = mSide[0] - mPos[0];
-    m[1] = mUp[0] - mPos[0];
-    m[2] = mTarget[0] - mPos[0];
-    m[3] = 0;
-    m[4] = mSide[1] - mPos[1];
-    m[5] = mUp[1] - mPos[1];
-    m[6] = mTarget[1] - mPos[1];
-    m[7] = 0;
-    m[8] = mSide[2] - mPos[2];
-    m[9] = mUp[2] - mPos[2];
-    m[10] = mTarget[2] - mPos[2];
-    m[11] = 0;
-    m[12] = 0;
-    m[13] = 0;
-    m[14] = 0;
-    m[15] = 1;
-
-    matrix.setMatrix(m);
-    matrix.multiply4v(v, result);
-
-    for (i = 0; i < 3; ++i) {
-        mSide[i] += result[i];
-        mUp[i] += result[i];
-        mTarget[i] += result[i];
-        mPos[i] += result[i];
-    }
-
-    mPos[0] = x;
-    mPos[1] = y;
-    mPos[2] = z;
-}
-
-void Camera::reset() {
-    mTheta = 0.0f;
-    mTheta2 = 0.0f;
-
-    mPos[0] = 0.0f;
-    mPos[1] = 0.0f;
-    mPos[2] = 0.0f;
-
-    mTarget[0] = 0.0f;
-    mTarget[1] = 0.0f;
-    mTarget[2] = mViewDistance;
-
-    mSide[0] = 1.0f;
-    mSide[1] = 0.0f;
-    mSide[2] = 0.0f;
-
-    mUp[0] = 0.0f;
-    mUp[1] = 1.0f;
-    mUp[2] = 0.0f;
-
-    mQ.setIdentity();
-    translate(0.0f, 0.0f, 0.0f);
-}
-
-void Camera::setSensitivityY(float angle) {
-    mRotateDelta2 = HEL_DEG_TO_RAD(angle);
-}
-
-void Camera::setSensitivityX(float angle) {
-    mRotateDelta = HEL_DEG_TO_RAD(angle);
-}
-
-void Camera::command(enum camera_command cmd) {
-    switch (cmd) {
-        case CAMERA_MOVE_FORWARD:
-            if (mFlags & Camera_FlyMode)
-                mPos[2] += (mTranslateDelta * cosf(mTheta));
-
-            mPos[0] += (mTranslateDelta * sinf(mTheta));
-            mPos[1] += (mTranslateDelta * sinf(mTheta2));
-            break;
-        case CAMERA_MOVE_BACKWARD:
-            if (mFlags & Camera_FlyMode)
-                mPos[2] -= (mTranslateDelta * cosf(mTheta));
-
-            mPos[0] -= (mTranslateDelta * sinf(mTheta));
-            mPos[1] -= (mTranslateDelta * sinf(mTheta2));
-            break;
-        case CAMERA_MOVE_LEFT:
-            mPos[0] -= (mTranslateDelta * sinf(mTheta - 90.0f));
-            mPos[2] -= (mTranslateDelta * cosf(mTheta - 90.0f));
-            break;
-        case CAMERA_MOVE_RIGHT:
-            mPos[0] -= (mTranslateDelta * sinf(mTheta + 90.0f));
-            mPos[2] -= (mTranslateDelta * cosf(mTheta + 90.0f));
-            break;
-        case CAMERA_ROTATE_UP:
-            if (mTheta2 < (M_PI / 2)) {
-                mTheta2 += mRotateDelta2;
-                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
-            }
-            break;
-        case CAMERA_ROTATE_DOWN:
-            if (mTheta2 > -(M_PI / 2)) {
-                mTheta2 -= mRotateDelta2;
-                rotate(mTheta2, 1.0f, 0.0f, 0.0f);
-            }
-            break;
-        case CAMERA_ROTATE_RIGHT:
-            mTheta += mRotateDelta;
-            rotate(mTheta, 0.0f, 1.0f, 0.0f);
-            break;
-        case CAMERA_ROTATE_LEFT:
-            mTheta -= mRotateDelta;
-            rotate(mTheta, 0.0f, 1.0f, 0.0f);
-            break;
-        case CAMERA_MOVE_UP:
-            mPos[1] -= mTranslateDelta / 2.0f;
-            mTarget[1] -= mTranslateDelta / 2.0f;
-            break;
-        case CAMERA_MOVE_DOWN:
-            mPos[1] += mTranslateDelta / 2.0f;
-            mTarget[1] += mTranslateDelta / 2.0f;
-            break;
-        case CAMERA_SPEED_UP:
-            ++mTranslateDelta;
-            break;
-        case CAMERA_SPEED_DOWN:
-            if (--mTranslateDelta < 0.0f)
-                mTranslateDelta = 1.0f;
-            break;
-    }
-}
-
-void Camera::setSpeed(float s) {
-    mTranslateDelta = s;
-}
-
-void Camera::update() {
-    mTarget[2] = (mViewDistance * cosf(mTheta)) + mPos[2];
-    mTarget[0] = (mViewDistance * sinf(mTheta)) + mPos[0];
-    mTarget[1] = (mViewDistance * sinf(mTheta2)) + mPos[1]; // + height_offset;
-}
-
-void Camera::setPosition(vec3_t pos) {
-    mPos[0] = pos[0];
-    mPos[1] = pos[1];
-    mPos[2] = pos[2];
-}
-
-void Camera::setUp(vec3_t up) {
-    mUp[0] = up[0];
-    mUp[1] = up[1];
-    mUp[2] = up[2];
-}
-
-void Camera::setTarget(vec3_t target) {
-    mTarget[0] = target[0];
-    mTarget[1] = target[1];
-    mTarget[2] = target[2];
-}
-

src/Emitter.cpp

@@ -1,245 +0,0 @@
-/*!
- * \file src/Emitter.cpp
- * \brief Particle emitter class.
- *
- * \author Mongoose
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-#include <GL/glu.h>
-#endif
-
-#include "Emitter.h"
-
-vec_t Emitter::mFrustum[6][4];
-
-int Emitter::compareParticleDist(const void *voidA, const void *voidB) {
-    Particle *a = const_cast<Particle *>(static_cast<const Particle *>(voidA));
-    Particle *b = const_cast<Particle *>(static_cast<const Particle *>(voidB));
-    float x, y, z, distA, distB;
-
-    if (!a || !b)
-        return -1; // error really
-
-    a->Pos(&x, &y, &z);
-    distA = (Emitter::mFrustum[5][0] * x +
-            Emitter::mFrustum[5][1] * y +
-            Emitter::mFrustum[5][2] * z +
-            Emitter::mFrustum[5][3]);
-
-    b->Pos(&x, &y, &z);
-    distB = (Emitter::mFrustum[5][0] * x +
-            Emitter::mFrustum[5][1] * y +
-            Emitter::mFrustum[5][2] * z +
-            Emitter::mFrustum[5][3]);
-
-    // reverse less/greater than
-    // less than
-    if (distA > distB)
-        return -1;
-
-    // greater than ( no need for equal )
-    return 1;
-}
-
-Emitter::Emitter(const char *name, int n) {
-    _name = NULL;
-    _flags = 0;
-    _particle = NULL;
-    _count = 0;
-    _pos[0] = _pos[1] = _pos[2] = 0.0;
-    _mangle[0] = _mangle[1] = _mangle[2] = 0.0;
-
-    Name(name);
-    ParticleArray(n);
-}
-
-Emitter::~Emitter() {
-    if (_name)
-        delete [] _name;
-
-    if (_particle)
-        delete [] _particle;
-
-    _count = 0;
-}
-
-Particle *Emitter::Particles() {
-    return _particle;
-}
-
-
-int Emitter::Count() {
-    return _count;
-}
-
-void Emitter::Pos(float *x, float *y, float *z) {
-    *x = _pos[0];
-    *y = _pos[1];
-    *z = _pos[2];
-}
-
-void Emitter::Pos(float x, float y, float z) {
-    _pos[0] = x;
-    _pos[1] = y;
-    _pos[2] = z;
-}
-
-void Emitter::Orientation(float *x, float *y, float *z) {
-    *x = _mangle[0];
-    *y = _mangle[1];
-    *z = _mangle[2];
-}
-
-void Emitter::Orientation(float x, float y, float z) {
-    _mangle[0] = x;
-    _mangle[1] = y;
-    _mangle[2] = z;
-}
-
-unsigned int Emitter::Flags() {
-    return _flags;
-}
-
-void Emitter::Flags(unsigned int flag, bool op) {
-    _flags |= flag;
-
-    if (!op)
-        _flags ^= flag;
-}
-
-void Emitter::ParticleArray(int n) {
-    if (n) {
-        if (_particle) {
-            _count = 0;
-            delete [] _particle;
-        }
-
-        _count = n;
-        _particle = new Particle[_count];
-    }
-}
-
-void Emitter::Name(const char *name) {
-    if (name && name[0]) {
-        if (_name)
-            delete [] _name;
-
-        int l = strlen(name);
-        _name = new char[l+1];
-
-        // Mongoose 2002.01.09, Mongoose says 'Only you can prevent overflows'
-        strncpy(_name, name, l);
-        _name[l] = 0;
-    }
-}
-
-void Emitter::SetTextureId(int id) {
-    for (unsigned int i = 0; i < _count; i++)
-        _particle[i].TextureId(id);
-}
-
-void Emitter::TextureId(unsigned int particle_start, unsigned int particle_end, int id) {
-    if ((particle_start < _count) && (particle_end > 0 && particle_end <= _count) && (particle_start < particle_end)) {
-        for (unsigned int i = particle_start; i < particle_end; i++)
-            _particle[i].TextureId(id);
-    }
-}
-
-void Emitter::Color(unsigned int particle_start, unsigned int particle_end, float r, float g, float b) {
-    if ((particle_start < _count) && (particle_end > 0 && particle_end <= _count) && (particle_start < particle_end)) {
-        for (unsigned int i = particle_start; i < particle_end; i++)
-            _particle[i].Color(r, g, b);
-    }
-}
-
-void Emitter::Speed(unsigned int particle_start, unsigned int particle_end, float x, float y, float z) {
-    if ((particle_start < _count) && (particle_end > 0 && particle_end <= _count) && (particle_start < particle_end)) {
-        for (unsigned int i = particle_start; i < particle_end; i++)
-            _particle[i].Speed(x, y, z);
-    }
-}
-
-void Emitter::Force(unsigned int particle_start, unsigned int particle_end, float x, float y, float z) {
-    if ((particle_start < _count) && (particle_end > 0 && particle_end <= _count) && (particle_start < particle_end)) {
-        for (unsigned int i = particle_start; i < particle_end; i++)
-            _particle[i].Force(x, y, z);
-    }
-}
-
-void Emitter::Draw() {
-    unsigned int i, p;
-    float x, y, z;
-    float r, g, b;
-    float life;
-
-    if (!_count || !_particle) {
-        printf("Emitter::Draw> No particles!\n");
-        return;
-    }
-
-    glPushMatrix();
-
-    //glRotatef(_mangle[0], 1.0, 0.0, 0.0);
-    //glRotatef(_mangle[1], 0.0, 1.0, 0.0);
-    //glRotatef(_mangle[2], 0.0, 0.0, 1.0);
-    //glTranslatef(_pos[0], _pos[1], _pos[2]);
-
-    if (_flags & fUseDepthSorting)
-        qsort(_particle, _count, sizeof(Particle), compareParticleDist);
-
-    for (i = 0; i < _count; i++) {
-        if (_particle[i].isActive()) {
-            _particle[i].Pos(&x, &y, &z);
-
-            if (_flags & fUseFrustumCulling) {
-                for (p = 0; p < 6; ++p) {
-                    if (((mFrustum[p][0] * x) + (mFrustum[p][1] * y) + (mFrustum[p][2] * z) + mFrustum[p][3]) < 0) {
-                        _particle[i].setActive(false);
-                        break;
-                    }
-                }
-
-                if (!_particle[i].isActive())
-                    continue;
-            }
-
-            _particle[i].Color(&r, &g, &b);
-            life = _particle[i].Life();
-
-            // Mongoose 2002.01.01, Removed Texture agent dep
-            glBindTexture(GL_TEXTURE_2D, _particle[i].Texture());
-
-            // Alpha is determined by life, which is affected by blend amount
-            glColor4f(r, g, b, life);
-
-            // Render tristrip quad
-            glBegin(GL_TRIANGLE_STRIP);
-            glTexCoord2d(1.0, 1.0);
-            glVertex3f(x + 0.5f, y + 0.5f, z);
-
-            glTexCoord2d(0.0, 1.0);
-            glVertex3f(x - 0.5f, y + 0.5f, z);
-
-            glTexCoord2d(1.0, 0.0);
-            glVertex3f(x + 0.5f, y - 0.5f, z);
-
-            glTexCoord2d(0.0, 0.0);
-            glVertex3f(x - 0.5f, y - 0.5f, z);
-            glEnd();
-
-            // Update particle's attributes for it's life cycle
-            _particle[i].Update();
-        }
-    }
-
-    glPopMatrix();
-}

src/GLString.cpp

@@ -1,142 +0,0 @@
-/*!
- * \file src/GLString.cpp
- * \brief Open GL rendering font/string class
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <assert.h>
-
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
-
-#include "Texture.h"
-#include "utils/strings.h"
-#include "GLString.h"
-
-GLString::GLString() {
-    _num_string_max = 0;
-    _num_string = 0;
-    _scale = 1.0;
-    _string = NULL;
-}
-
-
-GLString::~GLString() {
-    if (_string) {
-        for (unsigned int i = 0; i < _num_string; ++i) {
-            if (_string[i].text)
-                delete [] _string[i].text;
-        }
-        delete [] _string;
-    }
-}
-
-
-void GLString::Init(unsigned int max_strings) {
-    assert(max_strings > 0);
-
-    _num_string_max = max_strings;
-    _string = new gl_string_t[max_strings];
-}
-
-
-void GLString::SetChar(unsigned int string, unsigned int pos, char c) {
-    gl_string_t *str = GetString(string);
-    assert(str != NULL);
-    if (pos < str->len)
-        str->text[pos] = c;
-}
-
-
-unsigned int GLString::GetStringLen(unsigned int string) {
-    gl_string_t *str = GetString(string);
-    assert(str != NULL);
-    return str->len;
-}
-
-
-char *GLString::GetBuffer(unsigned int string) {
-    gl_string_t *str = GetString(string);
-    assert(str != NULL);
-    return str->text;
-}
-
-
-void GLString::setActive(unsigned int string, bool active) {
-    gl_string_t *str = GetString(string);
-    assert(str != NULL);
-    str->active = active;
-}
-
-
-void GLString::SetString(unsigned int string, const char *s, ...) {
-    va_list args;
-    gl_string_t *str = GetString(string);
-
-    assert(s != NULL);
-    assert(s[0] != '\0');
-    assert(str != NULL);
-
-    delete [] str->text;
-
-    va_start(args, s);
-    str->text = bufferString(s, args);
-    va_end(args);
-
-    str->active = true;
-    str->len = (unsigned short)strlen(str->text);
-}
-
-void GLString::Scale(float scale) {
-    _scale = scale;
-}
-
-int GLString::glPrintf(int x, int y, const char *string, ...) {
-    va_list args;
-
-    assert(string != NULL);
-    assert(string[0] != '\0');
-
-    if (_num_string > _num_string_max)
-        return -2;
-
-    va_start(args, string);
-
-    _string[_num_string].active = true;
-    _string[_num_string].scale = _scale;
-    _string[_num_string].x = x;
-    _string[_num_string].y = y;
-    _string[_num_string].text = bufferString(string, args);
-
-    //! \fixme All this is really unnecessary complex!
-    _string[_num_string].len = (unsigned short)strlen(_string[_num_string].text);
-
-    ++_num_string;
-
-    va_end(args);
-
-    return 0;
-}
-
-void GLString::Render() {
-    for (unsigned int i = 0; i < _num_string; ++i) {
-        if (_string[i].active)
-            glPrint2d(_string[i].x, _string[i].y, _string[i].scale, _string[i].text);
-    }
-}
-
-gl_string_t *GLString::GetString(unsigned int id) {
-    assert(id < _num_string);
-
-    return _string + id;
-}
-

src/Matrix.cpp

@@ -1,406 +0,0 @@
-/*!
- * \file src/Matrix.cpp
- * \brief 3D Matrix
- *
- * \author Mongoose
- */
-
-#include <stdio.h>
-#include <math.h>
-
-#include "Matrix.h"
-
-Matrix::Matrix() {
-    setIdentity();
-}
-
-Matrix::Matrix(matrix_t m) {
-    setMatrix(m);
-}
-
-Matrix::Matrix(Quaternion &q) {
-    matrix_t m;
-    q.getMatrix(m);
-    setMatrix(m);
-}
-
-bool Matrix::getInvert(matrix_t out) {
-    matrix_t m;
-
-#ifdef COLUMN_ORDER
-    getMatrix(m);
-#else
-    getTransposeMatrix(m);
-#endif
-
-    /* Mongoose: This code was from a Jeff Lander tutorial which was based
-       on MESA GL's InvertMatrix */
-
-    /* NB. OpenGL Matrices are COLUMN major. */
-#define SWAP_ROWS(a, b) { float *_tmp = a; (a)=(b); (b)=_tmp; }
-#define MAT(m,r,c) (m)[(c)*4+(r)]
-
-    float wtmp[4][8];
-    float m0, m1, m2, m3, s;
-    float *r0, *r1, *r2, *r3;
-
-    r0 = wtmp[0], r1 = wtmp[1], r2 = wtmp[2], r3 = wtmp[3];
-
-    r0[0] = MAT(m,0,0), r0[1] = MAT(m,0,1),
-    r0[2] = MAT(m,0,2), r0[3] = MAT(m,0,3),
-    r0[4] = 1.0f, r0[5] = r0[6] = r0[7] = 0.0f,
-
-    r1[0] = MAT(m,1,0), r1[1] = MAT(m,1,1),
-    r1[2] = MAT(m,1,2), r1[3] = MAT(m,1,3),
-    r1[5] = 1.0f, r1[4] = r1[6] = r1[7] = 0.0f,
-
-    r2[0] = MAT(m,2,0), r2[1] = MAT(m,2,1),
-    r2[2] = MAT(m,2,2), r2[3] = MAT(m,2,3),
-    r2[6] = 1.0f, r2[4] = r2[5] = r2[7] = 0.0f,
-
-    r3[0] = MAT(m,3,0), r3[1] = MAT(m,3,1),
-    r3[2] = MAT(m,3,2), r3[3] = MAT(m,3,3),
-    r3[7] = 1.0f, r3[4] = r3[5] = r3[6] = 0.0f;
-
-    /* choose pivot - or die */
-    if (fabs(r3[0])>fabs(r2[0])) SWAP_ROWS(r3, r2);
-    if (fabs(r2[0])>fabs(r1[0])) SWAP_ROWS(r2, r1);
-    if (fabs(r1[0])>fabs(r0[0])) SWAP_ROWS(r1, r0);
-    if (0.0f == r0[0])  return false;
-
-    /* eliminate first variable     */
-    m1 = r1[0]/r0[0]; m2 = r2[0]/r0[0]; m3 = r3[0]/r0[0];
-    s = r0[1]; r1[1] -= m1 * s; r2[1] -= m2 * s; r3[1] -= m3 * s;
-    s = r0[2]; r1[2] -= m1 * s; r2[2] -= m2 * s; r3[2] -= m3 * s;
-    s = r0[3]; r1[3] -= m1 * s; r2[3] -= m2 * s; r3[3] -= m3 * s;
-    s = r0[4];
-    if (s != 0.0f) { r1[4] -= m1 * s; r2[4] -= m2 * s; r3[4] -= m3 * s; }
-    s = r0[5];
-    if (s != 0.0f) { r1[5] -= m1 * s; r2[5] -= m2 * s; r3[5] -= m3 * s; }
-    s = r0[6];
-    if (s != 0.0f) { r1[6] -= m1 * s; r2[6] -= m2 * s; r3[6] -= m3 * s; }
-    s = r0[7];
-    if (s != 0.0f) { r1[7] -= m1 * s; r2[7] -= m2 * s; r3[7] -= m3 * s; }
-
-    /* choose pivot - or die */
-    if (fabs(r3[1])>fabs(r2[1])) SWAP_ROWS(r3, r2);
-    if (fabs(r2[1])>fabs(r1[1])) SWAP_ROWS(r2, r1);
-    if (0.0f == r1[1])  return false;
-
-    /* eliminate second variable */
-    m2 = r2[1]/r1[1]; m3 = r3[1]/r1[1];
-    r2[2] -= m2 * r1[2]; r3[2] -= m3 * r1[2];
-    r2[3] -= m2 * r1[3]; r3[3] -= m3 * r1[3];
-    s = r1[4]; if (0.0f != s) { r2[4] -= m2 * s; r3[4] -= m3 * s; }
-    s = r1[5]; if (0.0f != s) { r2[5] -= m2 * s; r3[5] -= m3 * s; }
-    s = r1[6]; if (0.0f != s) { r2[6] -= m2 * s; r3[6] -= m3 * s; }
-    s = r1[7]; if (0.0f != s) { r2[7] -= m2 * s; r3[7] -= m3 * s; }
-
-    /* choose pivot - or die */
-    if (fabs(r3[2])>fabs(r2[2])) SWAP_ROWS(r3, r2);
-    if (0.0f == r2[2])  return false;
-
-    /* eliminate third variable */
-    m3 = r3[2]/r2[2];
-    r3[3] -= m3 * r2[3], r3[4] -= m3 * r2[4],
-    r3[5] -= m3 * r2[5], r3[6] -= m3 * r2[6],
-    r3[7] -= m3 * r2[7];
-
-    /* last check */
-    if (0.0f == r3[3]) return false;
-
-    s = 1.0f/r3[3];              /* now back substitute row 3 */
-    r3[4] *= s; r3[5] *= s; r3[6] *= s; r3[7] *= s;
-
-    m2 = r2[3];                 /* now back substitute row 2 */
-    s  = 1.0f/r2[2];
-    r2[4] = s * (r2[4] - r3[4] * m2), r2[5] = s * (r2[5] - r3[5] * m2),
-    r2[6] = s * (r2[6] - r3[6] * m2), r2[7] = s * (r2[7] - r3[7] * m2);
-    m1 = r1[3];
-    r1[4] -= r3[4] * m1, r1[5] -= r3[5] * m1,
-    r1[6] -= r3[6] * m1, r1[7] -= r3[7] * m1;
-    m0 = r0[3];
-    r0[4] -= r3[4] * m0, r0[5] -= r3[5] * m0,
-    r0[6] -= r3[6] * m0, r0[7] -= r3[7] * m0;
-
-    m1 = r1[2];                 /* now back substitute row 1 */
-    s  = 1.0f/r1[1];
-    r1[4] = s * (r1[4] - r2[4] * m1), r1[5] = s * (r1[5] - r2[5] * m1),
-    r1[6] = s * (r1[6] - r2[6] * m1), r1[7] = s * (r1[7] - r2[7] * m1);
-    m0 = r0[2];
-    r0[4] -= r2[4] * m0, r0[5] -= r2[5] * m0,
-    r0[6] -= r2[6] * m0, r0[7] -= r2[7] * m0;
-
-    m0 = r0[1];                 /* now back substitute row 0 */
-    s  = 1.0f/r0[0];
-    r0[4] = s * (r0[4] - r1[4] * m0), r0[5] = s * (r0[5] - r1[5] * m0),
-    r0[6] = s * (r0[6] - r1[6] * m0), r0[7] = s * (r0[7] - r1[7] * m0);
-
-    MAT(out,0,0) = r0[4];
-    MAT(out,0,1) = r0[5], MAT(out,0,2) = r0[6];
-    MAT(out,0,3) = r0[7], MAT(out,1,0) = r1[4];
-    MAT(out,1,1) = r1[5], MAT(out,1,2) = r1[6];
-    MAT(out,1,3) = r1[7], MAT(out,2,0) = r2[4];
-    MAT(out,2,1) = r2[5], MAT(out,2,2) = r2[6];
-    MAT(out,2,3) = r2[7], MAT(out,3,0) = r3[4];
-    MAT(out,3,1) = r3[5], MAT(out,3,2) = r3[6];
-    MAT(out,3,3) = r3[7];
-
-    return true;
-#undef MAT
-#undef SWAP_ROWS
-}
-
-void Matrix::getMatrix(matrix_t mat) {
-    copy(mMatrix, mat);
-}
-
-void Matrix::getTransposeMatrix(matrix_t m) {
-    m[ 0]= mMatrix[0]; m[ 1]= mMatrix[4]; m[ 2]= mMatrix[ 8]; m[ 3]=mMatrix[12];
-    m[ 4]= mMatrix[1]; m[ 5]= mMatrix[5]; m[ 6]= mMatrix[ 9]; m[ 7]=mMatrix[13];
-    m[ 8]= mMatrix[2]; m[ 9]= mMatrix[6]; m[10]= mMatrix[10]; m[11]=mMatrix[14];
-    m[12]= mMatrix[3]; m[13]= mMatrix[7]; m[14]= mMatrix[11]; m[15]=mMatrix[15];
-}
-
-Matrix Matrix::multiply(const Matrix &a, const Matrix &b) {
-    Matrix c;
-    multiply(a.mMatrix, b.mMatrix, c.mMatrix);
-    return c;
-}
-
-Matrix Matrix::operator *(const Matrix &a) {
-    return multiply(a, *this);
-}
-
-Vector3d Matrix::operator *(Vector3d v) {
-    vec_t x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
-
-#ifdef COLUMN_ORDER
-    return Vector3d(mMatrix[0]*x + mMatrix[4]*y + mMatrix[ 8]*z + mMatrix[12],
-            mMatrix[1]*x + mMatrix[5]*y + mMatrix[ 9]*z + mMatrix[13],
-            mMatrix[2]*x + mMatrix[6]*y + mMatrix[10]*z + mMatrix[14]);
-#else
-    return Vector3d(mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3],
-            mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7],
-            mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11]);
-#endif
-}
-
-void Matrix::multiply3v(vec3_t v, vec3_t result) {
-    vec_t x = v[0], y = v[1], z = v[2];
-
-    result[0] = mMatrix[0]*x + mMatrix[1]*y + mMatrix[ 2]*z + mMatrix[ 3];
-    result[1] = mMatrix[4]*x + mMatrix[5]*y + mMatrix[ 6]*z + mMatrix[ 7];
-    result[2] = mMatrix[8]*x + mMatrix[9]*y + mMatrix[10]*z + mMatrix[11];
-}
-
-void Matrix::multiply4v(vec4_t v, vec4_t result) {
-    vec_t x = v[0], y = v[1], z = v[2], w = v[3];
-
-    result[0] = mMatrix[ 0]*x + mMatrix[ 1]*y + mMatrix[ 2]*z + mMatrix[ 3]*w;
-    result[1] = mMatrix[ 4]*x + mMatrix[ 5]*y + mMatrix[ 6]*z + mMatrix[ 7]*w;
-    result[2] = mMatrix[ 8]*x + mMatrix[ 9]*y + mMatrix[10]*z + mMatrix[11]*w;
-    result[3] = mMatrix[12]*x + mMatrix[13]*y + mMatrix[14]*z + mMatrix[15]*w;
-}
-
-void Matrix::print() {
-    printf("{\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n}\n",
-#ifdef COLUMN_ORDER
-            mMatrix[0], mMatrix[4], mMatrix[ 8], mMatrix[12],
-            mMatrix[1], mMatrix[5], mMatrix[ 9], mMatrix[13],
-            mMatrix[2], mMatrix[6], mMatrix[10], mMatrix[14],
-            mMatrix[3], mMatrix[7], mMatrix[11], mMatrix[15]);
-#else
-            mMatrix[ 0], mMatrix[ 1], mMatrix[ 2], mMatrix[ 3],
-            mMatrix[ 4], mMatrix[ 5], mMatrix[ 6], mMatrix[ 7],
-            mMatrix[ 8], mMatrix[ 9], mMatrix[10], mMatrix[11],
-            mMatrix[12], mMatrix[13], mMatrix[14], mMatrix[15]);
-#endif
-}
-
-bool Matrix::isIdentity() {
-    // Hhhmm... floating point using direct comparisons
-    /*
-    if (mMatrix[ 0] == 1 && mMatrix[ 1] == 0 && mMatrix[ 2] == 0 &&
-            mMatrix[ 3] == 0 &&    mMatrix[ 4] == 0 && mMatrix[ 5] == 1 &&
-            mMatrix[ 6] == 0 && mMatrix[ 7] == 0 && mMatrix[ 8] == 0 &&
-            mMatrix[ 9] == 0 && mMatrix[10] == 1 && mMatrix[11] == 0 &&
-            mMatrix[12] == 0 && mMatrix[13] == 0 && mMatrix[14] == 0 &&
-            mMatrix[15] == 1)
-        return true;
-    */
-    if (equalEpsilon(mMatrix[ 0], 1.0) && equalEpsilon(mMatrix[ 1], 0.0) && equalEpsilon(mMatrix[ 2], 0.0) &&
-        equalEpsilon(mMatrix[ 3], 0.0) && equalEpsilon(mMatrix[ 4], 0.0) && equalEpsilon(mMatrix[ 5], 1.0) &&
-        equalEpsilon(mMatrix[ 6], 0.0) && equalEpsilon(mMatrix[ 7], 0.0) && equalEpsilon(mMatrix[ 8], 0.0) &&
-        equalEpsilon(mMatrix[ 9], 0.0) && equalEpsilon(mMatrix[10], 1.0) && equalEpsilon(mMatrix[11], 0.0) &&
-        equalEpsilon(mMatrix[12], 0.0) && equalEpsilon(mMatrix[13], 0.0) && equalEpsilon(mMatrix[14], 0.0) &&
-        equalEpsilon(mMatrix[15], 1.0))
-        return true;
-
-    return false;
-}
-
-void Matrix::setMatrix(matrix_t mat) {
-    copy(mat, mMatrix);
-}
-
-void Matrix::setIdentity() {
-    mMatrix[ 0] = 1; mMatrix[ 1] = 0; mMatrix[ 2] = 0; mMatrix[ 3] = 0;
-    mMatrix[ 4] = 0; mMatrix[ 5] = 1; mMatrix[ 6] = 0; mMatrix[ 7] = 0;
-    mMatrix[ 8] = 0; mMatrix[ 9] = 0; mMatrix[10] = 1; mMatrix[11] = 0;
-    mMatrix[12] = 0; mMatrix[13] = 0; mMatrix[14] = 0; mMatrix[15] = 1;
-}
-
-void Matrix::scale(const vec_t *xyz) {
-    scale(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::scale(vec_t sx, vec_t sy, vec_t sz) {
-    matrix_t smatrix;
-    matrix_t tmp;
-
-    smatrix[ 0] = sx; smatrix[ 1] = 0;  smatrix[ 2] = 0;  smatrix[ 3] = 0;
-    smatrix[ 4] = 0;  smatrix[ 5] = sy; smatrix[ 6] = 0;  smatrix[ 7] = 0;
-    smatrix[ 8] = 0;  smatrix[ 9] = 0;  smatrix[10] = sz; smatrix[11] = 0;
-    smatrix[12] = 0;  smatrix[13] = 0;  smatrix[14] = 0;  smatrix[15] = 1;
-
-    copy(mMatrix, tmp);
-    multiply(tmp, smatrix, mMatrix);
-}
-
-void Matrix::rotate(const vec_t *xyz) {
-    rotate(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::rotate(vec_t ax, vec_t ay, vec_t az) {
-    matrix_t xmat, ymat, zmat, tmp, tmp2;
-
-    xmat[ 0]=1;         xmat[ 1]=0;         xmat[ 2]=0;         xmat[ 3]=0;
-    xmat[ 4]=0;         xmat[ 5]=cosf(ax);  xmat[ 6]=sinf(ax);  xmat[ 7]=0;
-    xmat[ 8]=0;         xmat[ 9]=-sinf(ax); xmat[10]=cosf(ax);  xmat[11]=0;
-    xmat[12]=0;         xmat[13]=0;         xmat[14]=0;         xmat[15]=1;
-
-    ymat[ 0]=cosf(ay);  ymat[ 1]=0;         ymat[ 2]=-sinf(ay); ymat[ 3]=0;
-    ymat[ 4]=0;         ymat[ 5]=1;         ymat[ 6]=0;         ymat[ 7]=0;
-    ymat[ 8]=sinf(ay);  ymat[ 9]=0;         ymat[10]=cosf(ay);  ymat[11]=0;
-    ymat[12]=0;         ymat[13]=0;         ymat[14]=0;         ymat[15]=1;
-
-    zmat[ 0]=cosf(az);  zmat[ 1]=sinf(az);  zmat[ 2]=0;         zmat[ 3]=0;
-    zmat[ 4]=-sinf(az); zmat[ 5]=cosf(az);  zmat[ 6]=0;         zmat[ 7]=0;
-    zmat[ 8]=0;         zmat[ 9]=0;         zmat[10]=1;         zmat[11]=0;
-    zmat[12]=0;         zmat[13]=0;         zmat[14]=0;         zmat[15]=1;
-
-    multiply(mMatrix, ymat, tmp);
-    multiply(tmp, xmat, tmp2);
-    multiply(tmp2, zmat, mMatrix);
-}
-
-void Matrix::translate(const vec_t *xyz) {
-    translate(xyz[0], xyz[1], xyz[2]);
-}
-
-void Matrix::translate(vec_t tx, vec_t ty, vec_t tz) {
-    matrix_t tmat, tmp;
-
-    tmat[ 0]=1;  tmat[ 1]=0;  tmat[ 2]=0;  tmat[ 3]=0;
-    tmat[ 4]=0;  tmat[ 5]=1;  tmat[ 6]=0;  tmat[ 7]=0;
-    tmat[ 8]=0;  tmat[ 9]=0;  tmat[10]=1;  tmat[11]=0;
-    tmat[12]=tx; tmat[13]=ty; tmat[14]=tz; tmat[15]=1;
-
-    copy(mMatrix, tmp);
-    multiply(tmp, tmat, mMatrix);
-}
-
-void Matrix::copy(matrix_t source, matrix_t dest) {
-    for (int i = 0; i < 16; i++)
-        dest[i] = source[i];
-}
-
-void Matrix::multiply(const matrix_t a, const matrix_t b, matrix_t result) {
-    /* Generated code for matrix mult
-     * Code used:
-
-    // char order is argument
-    int i, j, k;
-    if (order == 'r') {
-        printf("// Row order\n");
-    } else {
-        printf("// Column order\n");
-    }
-    for (i = 0; i < 4; ++i) {
-        for (j = 0; j < 4; ++j) {
-            if (order == 'r') {
-                printf("result[%2i] = ", j+i*4);
-            } else {
-                printf("result[%2i] = ", j+i*4);
-            }
-            for (k = 0; k < 4; ++k) {
-                if (order == 'r') {
-                    printf("a[%2i] * b[%2i]%s",
-                    k+i*4, j+k*4, (k == 3) ? ";\n" : " + ");
-                } else {
-                    printf("a[%2i] * b[%2i]%s",
-                    i+k*4, k+j*4, (k == 3) ? ";\n" : " + ");
-                }
-                //sum+=(elements[i+k*4]*m.elements[k+j*4]);
-            }
-            //result.elements[i+j*4]=sum;
-        }
-        printf("\n");
-    }
-    printf("\n");
-    printf("// Transpose\n");
-    for(i = 0; i < 4; ++i) {
-        for (j = 0; j < 4; ++j) {
-            printf("a[%2i] = b[%2i]%s",
-            j+i*4, i+j*4, (j == 3) ? ";\n" : "; ");
-        }
-    }
-
-     * was in test/Matrix.cpp
-     */
-#ifdef COLUMN_ORDER
-    /* Column order */
-    result[ 0] = a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b[ 3];
-    result[ 1] = a[ 0] * b[ 4] + a[ 4] * b[ 5] + a[ 8] * b[ 6] + a[12] * b[ 7];
-    result[ 2] = a[ 0] * b[ 8] + a[ 4] * b[ 9] + a[ 8] * b[10] + a[12] * b[11];
-    result[ 3] = a[ 0] * b[12] + a[ 4] * b[13] + a[ 8] * b[14] + a[12] * b[15];
-
-    result[ 4] = a[ 1] * b[ 0] + a[ 5] * b[ 1] + a[ 9] * b[ 2] + a[13] * b[ 3];
-    result[ 5] = a[ 1] * b[ 4] + a[ 5] * b[ 5] + a[ 9] * b[ 6] + a[13] * b[ 7];
-    result[ 6] = a[ 1] * b[ 8] + a[ 5] * b[ 9] + a[ 9] * b[10] + a[13] * b[11];
-    result[ 7] = a[ 1] * b[12] + a[ 5] * b[13] + a[ 9] * b[14] + a[13] * b[15];
-
-    result[ 8] = a[ 2] * b[ 0] + a[ 6] * b[ 1] + a[10] * b[ 2] + a[14] * b[ 3];
-    result[ 9] = a[ 2] * b[ 4] + a[ 6] * b[ 5] + a[10] * b[ 6] + a[14] * b[ 7];
-    result[10] = a[ 2] * b[ 8] + a[ 6] * b[ 9] + a[10] * b[10] + a[14] * b[11];
-    result[11] = a[ 2] * b[12] + a[ 6] * b[13] + a[10] * b[14] + a[14] * b[15];
-
-    result[12] = a[ 3] * b[ 0] + a[ 7] * b[ 1] + a[11] * b[ 2] + a[15] * b[ 3];
-    result[13] = a[ 3] * b[ 4] + a[ 7] * b[ 5] + a[11] * b[ 6] + a[15] * b[ 7];
-    result[14] = a[ 3] * b[ 8] + a[ 7] * b[ 9] + a[11] * b[10] + a[15] * b[11];
-    result[15] = a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15];
-#else
-    /* Row order */
-    result[ 0] = a[ 0] * b[ 0] + a[ 1] * b[ 4] + a[ 2] * b[ 8] + a[ 3] * b[12];
-    result[ 1] = a[ 0] * b[ 1] + a[ 1] * b[ 5] + a[ 2] * b[ 9] + a[ 3] * b[13];
-    result[ 2] = a[ 0] * b[ 2] + a[ 1] * b[ 6] + a[ 2] * b[10] + a[ 3] * b[14];
-    result[ 3] = a[ 0] * b[ 3] + a[ 1] * b[ 7] + a[ 2] * b[11] + a[ 3] * b[15];
-
-    result[ 4] = a[ 4] * b[ 0] + a[ 5] * b[ 4] + a[ 6] * b[ 8] + a[ 7] * b[12];
-    result[ 5] = a[ 4] * b[ 1] + a[ 5] * b[ 5] + a[ 6] * b[ 9] + a[ 7] * b[13];
-    result[ 6] = a[ 4] * b[ 2] + a[ 5] * b[ 6] + a[ 6] * b[10] + a[ 7] * b[14];
-    result[ 7] = a[ 4] * b[ 3] + a[ 5] * b[ 7] + a[ 6] * b[11] + a[ 7] * b[15];
-
-    result[ 8] = a[ 8] * b[ 0] + a[ 9] * b[ 4] + a[10] * b[ 8] + a[11] * b[12];
-    result[ 9] = a[ 8] * b[ 1] + a[ 9] * b[ 5] + a[10] * b[ 9] + a[11] * b[13];
-    result[10] = a[ 8] * b[ 2] + a[ 9] * b[ 6] + a[10] * b[10] + a[11] * b[14];
-    result[11] = a[ 8] * b[ 3] + a[ 9] * b[ 7] + a[10] * b[11] + a[11] * b[15];
-
-    result[12] = a[12] * b[ 0] + a[13] * b[ 4] + a[14] * b[ 8] + a[15] * b[12];
-    result[13] = a[12] * b[ 1] + a[13] * b[ 5] + a[14] * b[ 9] + a[15] * b[13];
-    result[14] = a[12] * b[ 2] + a[13] * b[ 6] + a[14] * b[10] + a[15] * b[14];
-    result[15] = a[12] * b[ 3] + a[13] * b[ 7] + a[14] * b[11] + a[15] * b[15];
-#endif
-}
-

src/Mesh.cpp

@@ -1,625 +0,0 @@
-/*!
- * \file src/Mesh.cpp
- * \brief OpenGL Mesh
- *
- * \author Mongoose
- */
-
-#include <stdlib.h>
-#include <assert.h>
-
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
-
-#include "Mesh.h"
-
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-Mesh::Mesh()
-{
-    mNumVertices = 0;
-    mVertices = 0x0;
-
-    mNumNormals = 0;
-    mNormals = 0x0;
-
-    mNumColors = 0;
-    mColors = 0x0;
-
-    mNumTris = 0;
-    mTris = 0x0;
-
-    mNumQuads = 0;
-    mQuads = 0x0;
-
-    mVertexArray = 0x0;
-    mNormalArray = 0x0;
-    mColorArray = 0x0;
-
-    mTriangleCount = 0;
-    mTriangleTextures = 0x0;
-    mTriangleIndices = 0x0;
-    mTriangleFlags = 0x0;
-    mTriangleTexCoordArray = 0x0;
-
-    mFlags = 0;
-    mMode = MeshModeTexture;
-}
-
-
-Mesh::~Mesh()
-{
-    unsigned int i;
-
-
-    if (mVertices)
-    {
-        delete [] mVertices;
-    }
-
-    if (mNormals)
-    {
-        delete [] mNormals;
-    }
-
-    if (mColors)
-    {
-        delete [] mColors;
-    }
-
-    if (mTris)
-    {
-        for (i = 0; i < mNumTris; ++i)
-        {
-            if (mTris[i].triangles)
-                delete [] mTris[i].triangles;
-
-            if (mTris[i].alpha_triangles)
-                delete [] mTris[i].alpha_triangles;
-
-            if (mTris[i].texcoors)
-                delete [] mTris[i].texcoors;
-
-            if (mTris[i].texcoors2)
-                delete [] mTris[i].texcoors2;
-        }
-
-        delete [] mTris;
-    }
-
-    if (mQuads)
-    {
-        for (i = 0; i < mNumQuads; ++i)
-        {
-            if (mQuads[i].quads)
-                delete [] mQuads[i].quads;
-
-            if (mQuads[i].alpha_quads)
-                delete [] mQuads[i].alpha_quads;
-
-            if (mQuads[i].texcoors)
-                delete [] mQuads[i].texcoors;
-
-            if (mQuads[i].texcoors2)
-                delete [] mQuads[i].texcoors2;
-        }
-
-        delete [] mQuads;
-    }
-
-    if (mVertexArray)
-    {
-        delete [] mVertexArray;
-    }
-
-    if (mNormalArray)
-    {
-        delete [] mNormalArray;
-    }
-
-    if (mColorArray)
-    {
-        delete [] mColorArray;
-    }
-
-    if (mTriangleTextures)
-    {
-        delete [] mTriangleTextures;
-    }
-
-    if (mTriangleIndices)
-    {
-        delete [] mTriangleIndices;
-    }
-
-    if (mTriangleFlags)
-    {
-        delete [] mTriangleFlags;
-    }
-
-    if (mTriangleTexCoordArray)
-    {
-        delete [] mTriangleTexCoordArray;
-    }
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-void Mesh::drawAlpha()
-{
-    unsigned int i, j, k, index;
-
-
-    // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i)
-    {
-        switch (mMode)
-        {
-            case MeshModeWireframe:
-                glColor3f(0.0, 0.0, 1.0);
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-            case MeshModeSolid:
-                // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-            case MeshModeTexture:
-            case MeshModeMultiTexture:
-                // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
-                break;
-        }
-
-        glBegin(GL_QUADS);
-
-        for (j = 0; j < mQuads[i].num_alpha_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].alpha_quads[j*4+k];
-
-                glTexCoord2fv(mQuads[i].texcoors2[j*4+k]);
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-
-    // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i)
-    {
-        switch (mMode)
-        {
-            case MeshModeWireframe:
-                glColor3f(0.0, 1.0, 0.0);
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-            case MeshModeSolid:
-                // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-            case MeshModeTexture:
-            case MeshModeMultiTexture:
-                // Bind texture id for textures
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
-                break;
-        }
-
-        glBegin(GL_TRIANGLES);
-
-        for (j = 0; j < mTris[i].num_alpha_triangles; ++j)
-        {
-            for (k = 0; k < 3; ++k)
-            {
-                index = mTris[i].alpha_triangles[j*3+k];
-
-                glTexCoord2fv(mTris[i].texcoors2[j*3+k]);
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-}
-
-
-void Mesh::drawSolid()
-{
-    unsigned int i, j, k, index;
-
-
-    if (mFlags & fMesh_UseVertexArray)
-    {
-        //glEnableClientState(GL_VERTEX_ARRAY);
-        //glVertexPointer(3, GL_FLOAT, 0, mVertexArray);
-
-        glPointSize(2.0f);
-        glColor3f(1.0f, 1.0f, 1.0f);
-        glBegin(GL_TRIANGLES);
-
-        for (i = 0; i < mTriangleCount*3; ++i)
-        {
-            //glArrayElement(mTriangleIndices[i]);
-            glVertex3fv(mVertexArray+mTriangleIndices[i]);
-        }
-
-        glEnd();
-
-        glPointSize(1.0f);
-
-        //! \fixme
-        /*
-        for (j = 0; j < mQuads[i].num_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].quads[j*4+k];
-
-                glTexCoord2fv(mQuads[i].texcoors[j*4+k]);
-                glArrayElement(mQuads[i].quads[j*4+k]);
-            }
-        }
-        */
-
-        return;
-    }
-
-    // Render quadralaterals
-    for (mQuads ? i = 0 : i = mNumQuads; i < mNumQuads; ++i)
-    {
-        switch (mMode)
-        {
-            case MeshModeSolid:
-                glColor3f(0.0, 0.0, 0.0);
-                break;
-            case MeshModeWireframe:
-                // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-#ifdef MULTITEXTURE
-            case MeshModeMultiTexture:
-                glActiveTextureARB(GL_TEXTURE0_ARB);
-                glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
-
-                glActiveTextureARB(GL_TEXTURE1_ARB);
-                glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].bumpmap+1);
-                break;
-#else
-            case MeshModeMultiTexture:
-#endif
-            case MeshModeTexture:
-                // Bind texture id for textures
-                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                glBindTexture(GL_TEXTURE_2D, mQuads[i].texture+1);
-                break;
-        }
-
-        glBegin(GL_QUADS);
-
-        for (j = 0; j < mQuads[i].num_quads; ++j)
-        {
-            for (k = 0; k < 4; ++k)
-            {
-                index = mQuads[i].quads[j*4+k];
-
-                glColor4fv(mColors[index]);
-
-#ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture)
-                {
-                    glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                            mQuads[i].texcoors[j*4+k]);
-                    glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                            mQuads[i].texcoors[j*4+k]);
-                }
-                else
-#endif
-                    glTexCoord2fv(mQuads[i].texcoors[j*4+k]);
-
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-
-    // Render triangles
-    for (mTris ? i = 0 : i = mNumTris; i < mNumTris; ++i)
-    {
-        switch (mMode)
-        {
-            case MeshModeSolid:
-                glColor3f(1.0, 0.0, 0.0);
-                break;
-            case MeshModeWireframe:
-                // Bind WHITE texture for solid colors
-                glBindTexture(GL_TEXTURE_2D, 0);
-                break;
-#ifdef MULTITEXTURE
-            case MeshModeMultiTexture:
-                glActiveTextureARB(GL_TEXTURE0_ARB);
-                glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
-
-                glActiveTextureARB(GL_TEXTURE1_ARB);
-                glEnable(GL_TEXTURE_2D);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].bumpmap+1);
-                break;
-#else
-            case MeshModeMultiTexture:
-#endif
-            case MeshModeTexture:
-                // Bind texture id for textures
-                glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-                glBindTexture(GL_TEXTURE_2D, mTris[i].texture+1);
-                break;
-        }
-
-        glBegin(GL_TRIANGLES);
-
-        for (j = 0; j < mTris[i].num_triangles; ++j)
-        {
-            for (k = 0; k < 3; ++k)
-            {
-                index = mTris[i].triangles[j*3+k];
-
-#ifdef MULTITEXTURE
-                if (mMode == MeshModeMultiTexture)
-                {
-                    glMultiTexCoord2fvARB(GL_TEXTURE0_ARB,
-                            mTris[i].texcoors[j*3+k]);
-                    glMultiTexCoord2fvARB(GL_TEXTURE1_ARB,
-                            mTris[i].texcoors[j*3+k]);
-                }
-                else
-#endif
-                    glTexCoord2fv(mTris[i].texcoors[j*3+k]);
-
-                glColor4fv(mColors[index]);
-                glVertex3fv(mVertices[index]);
-            }
-        }
-
-        glEnd();
-    }
-
-#ifdef MULTITEXTURE
-    if (mMode == MeshModeMultiTexture)
-    {
-        glDisable(GL_TEXTURE_2D);
-        glActiveTextureARB(GL_TEXTURE0_ARB);
-    }
-#endif
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void Mesh::allocateColors(unsigned int n)
-{
-    if (mColors)
-    {
-        mNumColors = 0;
-        delete [] mColors;
-    }
-
-    if (!n)
-    {
-        return;
-    }
-
-    mNumColors = n;
-    mColors = new vec4_t[mNumColors];
-}
-
-
-void Mesh::allocateNormals(unsigned int n)
-{
-    if (mNormals)
-    {
-        mNumNormals = 0;
-        delete [] mNormals;
-    }
-
-    if (!n)
-    {
-        return;
-    }
-
-    mNumNormals = n;
-    mNormals = new vec3_t[mNumNormals];
-}
-
-
-void Mesh::allocateRectangles(unsigned int n)
-{
-    if (mQuads)
-    {
-        mNumQuads = 0;
-        delete [] mQuads;
-    }
-
-    if (!n)
-    {
-        return;
-    }
-
-    mNumQuads = n;
-    mQuads = new rect_t[mNumQuads];
-}
-
-
-void Mesh::allocateTriangles(unsigned int n)
-{
-    if (mTris)
-    {
-        mNumTris = 0;
-        delete [] mTris;
-    }
-
-    if (!n)
-    {
-        return;
-    }
-
-    mNumTris = n;
-    mTris = new tris_t[mNumTris];
-}
-
-
-void Mesh::allocateVertices(unsigned int n)
-{
-    if (mVertices)
-    {
-        mNumVertices = 0;
-        delete [] mVertices;
-    }
-
-    if (!n)
-    {
-        return;
-    }
-
-    mNumVertices = n;
-    mVertices = new vec3_t[mNumVertices];
-}
-
-
-void Mesh::bufferColorArray(unsigned int colorCount, vec_t *colors)
-{
-    if (mColors)
-    {
-        mNumColors = 0;
-        delete [] mColors;
-    }
-
-    if (!colorCount)
-    {
-        return;
-    }
-
-    mNumColors = colorCount;
-    mColorArray = colors;
-}
-
-
-void Mesh::bufferNormalArray(unsigned int normalCount, vec_t *normals)
-{
-    if (mNormals)
-    {
-        mNumNormals = 0;
-        delete [] mNormals;
-    }
-
-    if (!normalCount)
-    {
-        return;
-    }
-
-    mNumNormals = normalCount;
-    mNormalArray = normals;
-}
-
-
-void Mesh::bufferTriangles(unsigned int count,
-        unsigned int *indices, vec_t *texCoords,
-        int *textures, unsigned int *flags)
-{
-
-    mTriangleCount = count;
-    mTriangleTextures = textures;
-    mTriangleIndices = indices;
-    mTriangleFlags = flags;
-    mTriangleTexCoordArray = texCoords;
-
-    //! \fixme sortTrianglesByTexture();
-}
-
-
-void Mesh::bufferVertexArray(unsigned int vertexCount, vec_t *vertices)
-{
-    if (mVertices)
-    {
-        mNumVertices = 0;
-        delete [] mVertices;
-    }
-
-    if (!vertexCount)
-    {
-        return;
-    }
-
-    mNumVertices = vertexCount;
-    mVertexArray = vertices;
-    mFlags |= fMesh_UseVertexArray;
-}
-
-
-void Mesh::setColor(unsigned int index,
-        float r, float g, float b, float a)
-{
-    assert(index < mNumColors);
-
-    mColors[index][0] = r;
-    mColors[index][1] = g;
-    mColors[index][2] = b;
-    mColors[index][3] = a;
-}
-
-
-void Mesh::setColor(unsigned int index, float rgba[4])
-{
-    assert(index < mNumColors);
-
-    mColors[index][0] = rgba[0];
-    mColors[index][1] = rgba[1];
-    mColors[index][2] = rgba[2];
-    mColors[index][3] = rgba[3];
-}
-
-
-void Mesh::setNormal(unsigned int index, float i, float j, float k)
-{
-    assert(index < mNumNormals);
-
-    mNormals[index][0] = i;
-    mNormals[index][1] = j;
-    mNormals[index][2] = k;
-}
-
-
-void Mesh::setVertex(unsigned int index, float x, float y, float z)
-{
-    assert(index < mNumVertices);
-
-    mVertices[index][0] = x;
-    mVertices[index][1] = y;
-    mVertices[index][2] = z;
-}
-
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-

src/Particle.cpp

@@ -1,162 +0,0 @@
-/*!
- * \file src/Particle.cpp
- * \brief Particle system base implementation
- *
- * \author Mongoose
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-
-#include "Particle.h"
-
-Particle::Particle()
-{
-    setActive(true);
-    TextureId(0);
-    Speed(2000.0f, 2000.0f, 2000.0f);
-    Color(1.0f, 1.0f, 1.0f);
-    Force(0.0f, 0.8f, 0.0f);
-
-    Reset();
-}
-
-
-void Particle::TextureId(int id)
-{
-    _texture = id;
-}
-
-
-void Particle::setActive(bool active)
-{
-    _active = active;
-}
-
-
-void Particle::Speed(float x, float y, float z)
-{
-    _speed[0] = x;
-    _speed[1] = y;
-    _speed[2] = z;
-}
-
-
-void Particle::Color(float r, float g, float b)
-{
-    _color[0] = r;
-    _color[1] = g;
-    _color[2] = b;
-}
-
-
-void Particle::Force(float x, float y, float z)
-{
-    _force[0] = x;
-    _force[1] = y;
-    _force[2] = z;
-}
-
-
-void Particle::Reset()
-{
-    // Mongoose 2002.01.01, Ah, how old is that code?
-#ifdef OBSOLETE
-    _active = true;
-    _life = 1.0;
-    _blend = (float)(rand() % 100) / 1000.0 + 0.003;
-
-    _pos[0] = _pos[1] = _pos[2] = 0.0;
-
-    _dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
-    _dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
-    _dir[2] = _dir[1];
-
-    _force[0] = 0.0;
-    _force[1] = -0.8;
-    _force[2] = 0.0;
-#else
-    //! \fixme _blend prob should have nonstatic range
-    _blend = (float)(0.003 + (0.1 * rand() / (RAND_MAX + 1.0))); // high order
-    //_blend = (float)(rand() % 100) / 1000.0 + 0.003;
-
-    //! \fixme Reset these using some nonstatic functions and values later
-    _life = 1.0;
-
-    _pos[0] = _pos[1] = _pos[2] = 0.0;
-
-    _dir[0] = (float)(-26.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
-    _dir[0] *= 10.0;
-    //_dir[0] = (float)((rand() % 50) - 26.0) * 10.0;
-    _dir[1] = (float)(-25.0 + (50.0 * rand() / (RAND_MAX + 1.0))); // high order
-    _dir[1] *= 10.0;
-    //_dir[1] = (float)((rand() % 50) - 25.0) * 10.0;
-    _dir[2] = _dir[1];
-#endif
-}
-
-
-void Particle::Pos(float *x, float *y, float *z)
-{
-    assert(x != NULL);
-    assert(y != NULL);
-    assert(z != NULL);
-
-    *x = _pos[0];
-    *y = _pos[1];
-    *z = _pos[2];
-}
-
-
-void Particle::Color(float *r, float *g, float *b)
-{
-    assert(r != NULL);
-    assert(g != NULL);
-    assert(b != NULL);
-
-    *r = _color[0];
-    *g = _color[1];
-    *b = _color[2];
-}
-
-
-float Particle::Life()
-{
-    return _life;
-}
-
-
-void Particle::Update()
-{
-    // Adjust particle position
-    _pos[0] += _dir[0] / _speed[0];
-    _pos[1] += _dir[1] / _speed[1];
-    _pos[2] += _dir[2] / _speed[2];
-
-    // Adjust particle direction
-    _dir[0] += _force[0];
-    _dir[1] += _force[1];
-    _dir[2] += _force[2];
-
-    // Adjust particle blending/life
-    _life -= _blend;
-
-    // Reset 'dead' OR fully blended particles
-    if (_life < 0.0)
-    {
-        Reset();
-    }
-}
-
-
-int Particle::Texture()
-{
-    return _texture;
-}
-
-
-bool Particle::isActive()
-{
-    return _active;
-}

src/Quaternion.cpp

@@ -1,289 +0,0 @@
-/*!
- * \file src/Quaternion.cpp
- * \brief Quaternion
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "Quaternion.h"
-
-Quaternion::Quaternion() {
-    mW = 0;
-    mX = 0;
-    mY = 0;
-    mZ = 0;
-}
-
-Quaternion::Quaternion(vec_t w, vec_t x, vec_t y, vec_t z) {
-    mW = w;
-    mX = x;
-    mY = y;
-    mZ = z;
-}
-
-Quaternion::Quaternion(vec4_t v) {
-    mW = v[0];
-    mX = v[1];
-    mY = v[2];
-    mZ = v[3];
-}
-
-void Quaternion::getMatrix(matrix_t m) {
-    m[ 0] = 1.0f - 2.0f * (mY*mY + mZ*mZ);
-    m[ 1] = 2.0f * (mX*mY - mW*mZ);
-    m[ 2] = 2.0f * (mX*mZ + mW*mY);
-    m[ 3] = 0.0f;
-
-    m[ 4] = 2.0f * (mX*mY + mW*mZ);
-    m[ 5] = 1.0f - 2.0f * (mX*mX + mZ*mZ);
-    m[ 6] = 2.0f * (mY*mZ - mW*mX);
-    m[ 7] = 0.0f;
-
-    m[ 8] = 2.0f * (mX*mZ - mW*mY);
-    m[ 9] = 2.0f * (mY*mZ + mW*mX);
-    m[10] = 1.0f - 2.0f * (mX*mX + mY*mY);
-    m[11] = 0.0f;
-
-    m[12] = 0.0f;
-    m[13] = 0.0f;
-    m[14] = 0.0f;
-    m[15] = 1.0f;
-}
-
-Quaternion Quaternion::operator *(const Quaternion &q) {
-    return multiply(*this, q);
-}
-
-Quaternion Quaternion::operator /(const Quaternion &q) {
-    return divide(*this, q);
-}
-
-Quaternion Quaternion::operator +(const Quaternion &q) {
-    return add(*this, q);
-}
-
-Quaternion Quaternion::operator -(const Quaternion &q) {
-    return subtract(*this, q);
-}
-
-bool Quaternion::operator ==(const Quaternion &q) {
-    //return (mX == q.mX && mY == q.mY && mZ == q.mZ && mW == q.mW);
-    return (equalEpsilon(mX, q.mX) && equalEpsilon(mY, q.mY) &&
-            equalEpsilon(mZ, q.mZ) && equalEpsilon(mW, q.mW));
-}
-
-Quaternion Quaternion::conjugate() {
-    return Quaternion(mW, -mX, -mY, -mZ);
-}
-
-Quaternion Quaternion::scale(vec_t s) {
-    return Quaternion(mW * s, mX * s, mY * s, mZ * s);
-}
-
-Quaternion Quaternion::inverse() {
-    return conjugate().scale(1/magnitude());
-}
-
-vec_t Quaternion::dot(Quaternion a, Quaternion b) {
-    return ((a.mW * b.mW) + (a.mX * b.mX) + (a.mY * b.mY) + (a.mZ * b.mZ));
-}
-
-vec_t Quaternion::magnitude() {
-    return sqrtf(dot(*this, *this));
-}
-
-void Quaternion::setIdentity() {
-    mW = 1.0;
-    mX = 0.0;
-    mY = 0.0;
-    mZ = 0.0;
-}
-
-void Quaternion::set(vec_t angle, vec_t x, vec_t y, vec_t z) {
-    vec_t temp, dist;
-
-    // Normalize
-    temp = x*x + y*y + z*z;
-
-    dist = 1.0f / sqrtf(temp);
-
-    x *= dist;
-    y *= dist;
-    z *= dist;
-
-    mX = x;
-    mY = y;
-    mZ = z;
-
-    mW = cosf(angle / 2.0f);
-}
-
-void Quaternion::normalize() {
-    vec_t dist, square;
-
-    square = mX * mX + mY * mY + mZ * mZ + mW * mW;
-
-    if (square > 0.0) {
-        dist = 1.0f / sqrtf(square);
-    } else {
-        dist = 1;
-    }
-
-    mX *= dist;
-    mY *= dist;
-    mZ *= dist;
-    mW *= dist;
-}
-
-void Quaternion::copy(Quaternion q) {
-    mW = q.mW;
-    mX = q.mX;
-    mY = q.mY;
-    mZ = q.mZ;
-}
-
-Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time) {
-    /*******************************************************************
-     * Spherical Linear Interpolation algorthim
-     *-----------------------------------------------------------------
-     *
-     * Interpolate between A and B rotations ( Find qI )
-     *
-     * qI = (((qB . qA)^ -1)^ Time) qA
-     *
-     * http://www.magic-software.com/Documentation/quat.pdf
-     *
-     * Thanks to digiben for algorithms and basis of the notes in
-     * this func
-     *
-     *******************************************************************/
-
-    vec_t result, scaleA, scaleB;
-    Quaternion i;
-
-
-    // Don't bother if it's the same rotation, it's the same as the result
-    if (a == b)
-        return a;
-
-    // A . B
-    result = dot(a, b);
-
-    // If the dot product is less than 0, the angle is greater than 90 degrees
-    if (result < 0.0f) {
-        // Negate quaternion B and the result of the dot product
-        b = Quaternion(-b.mW, -b.mX, -b.mY, -b.mZ);
-        result = -result;
-    }
-
-    // Set the first and second scale for the interpolation
-    scaleA = 1 - time;
-    scaleB = time;
-
-    // Next, we want to actually calculate the spherical interpolation.  Since this
-    // calculation is quite computationally expensive, we want to only perform it
-    // if the angle between the 2 quaternions is large enough to warrant it.  If the
-    // angle is fairly small, we can actually just do a simpler linear interpolation
-    // of the 2 quaternions, and skip all the complex math.  We create a "delta" value
-    // of 0.1 to say that if the cosine of the angle (result of the dot product) between
-    // the 2 quaternions is smaller than 0.1, then we do NOT want to perform the full on
-    // interpolation using.  This is because you won't really notice the difference.
-
-    // Check if the angle between the 2 quaternions was big enough
-    // to warrant such calculations
-    if (1 - result > 0.1f) {
-        // Get the angle between the 2 quaternions, and then
-        // store the sin() of that angle
-        vec_t theta = (float)acos(result);
-        vec_t sinTheta = (float)sin(theta);
-
-        // Calculate the scale for qA and qB, according to
-        // the angle and it's sine value
-        scaleA = (float)sin((1 - time) * theta) / sinTheta;
-        scaleB = (float)sin((time * theta)) / sinTheta;
-    }
-
-    // Calculate the x, y, z and w values for the quaternion by using a special
-    // form of linear interpolation for quaternions.
-    return (a.scale(scaleA) + b.scale(scaleB));
-}
-
-void Quaternion::setByMatrix(matrix_t matrix) {
-    float diagonal = matrix[0] + matrix[5] + matrix[10] + 1.0f;
-    float scale = 0.0f;
-    float w = 0.0f, x = 0.0f, y = 0.0f, z = 0.0f;
-
-    if (diagonal > 0.00000001) {
-        // Calculate the scale of the diagonal
-        scale = (float)(sqrt(diagonal) * 2);
-
-        w = 0.25f * scale;
-        x = (matrix[9] - matrix[6]) / scale;
-        y = (matrix[2] - matrix[8]) / scale;
-        z = (matrix[4] - matrix[1]) / scale;
-    } else {
-        // If the first element of the diagonal is the greatest value
-        if (matrix[0] > matrix[5] && matrix[0] > matrix[10]) {
-            // Find the scale according to the first element, and double it
-            scale = (float)sqrt(1.0f + matrix[0] - matrix[5] - matrix[10])*2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[9] - matrix[6]) / scale;
-            x = 0.25f * scale;
-            y = (matrix[4] + matrix[1]) / scale;
-            z = (matrix[2] + matrix[8]) / scale;
-        } else if (matrix[5] > matrix[10]) {
-            // The second element of the diagonal is the greatest value
-            // Find the scale according to the second element, and double it
-            scale = (float)sqrt(1.0f + matrix[5] - matrix[0] - matrix[10])*2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[2] - matrix[8]) / scale;
-            x = (matrix[4] + matrix[1]) / scale;
-            y = 0.25f * scale;
-            z = (matrix[9] + matrix[6]) / scale;
-        } else { // The third element of the diagonal is the greatest value
-            // Find the scale according to the third element, and double it
-            scale = (float)sqrt(1.0f + matrix[10] - matrix[0] - matrix[5])*2.0f;
-
-            // Calculate the quaternion
-            w = (matrix[4] - matrix[1]) / scale;
-            x = (matrix[2] + matrix[8]) / scale;
-            y = (matrix[9] + matrix[6]) / scale;
-            z = 0.25f * scale;
-        }
-    }
-
-    mW = w;
-    mX = x;
-    mY = y;
-    mZ = z;
-}
-
-Quaternion Quaternion::multiply(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW * b.mW - a.mX * b.mX - a.mY * b.mY - a.mZ * b.mZ,
-            a.mW * b.mX + a.mX * b.mW + a.mY * b.mZ - a.mZ * b.mY,
-            a.mW * b.mY + a.mY * b.mW + a.mZ * b.mX - a.mX * b.mZ,
-            a.mW * b.mZ + a.mZ * b.mW + a.mX * b.mY - a.mY * b.mX);
-}
-
-Quaternion Quaternion::divide(Quaternion a, Quaternion b) {
-    return (a * (b.inverse()));
-}
-
-Quaternion Quaternion::add(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW + b.mW,
-            a.mX + b.mX,
-            a.mY + b.mY,
-            a.mZ + b.mZ);
-}
-
-Quaternion Quaternion::subtract(Quaternion a, Quaternion b) {
-    return Quaternion(a.mW - b.mW,
-            a.mX - b.mX,
-            a.mY - b.mY,
-            a.mZ - b.mZ);
-}
-

src/SDLSystem.cpp

@@ -1,352 +0,0 @@
-/*!
- * \file src/SDLSystem.cpp
- * \brief SDL System interface implementation
- *
- * \author Mongoose
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <cmath>
-#include <assert.h>
-
-#include "SDL_opengl.h"
-
-#include "utils/math.h"
-#include "SDLSystem.h"
-
-SDLSystem::SDLSystem() : System() {
-    mWindow = 0x0;
-    mFullscreen = false;
-}
-
-SDLSystem::~SDLSystem() {
-}
-
-#ifdef FIXME
-void SDLSystem::bindKeyCommand(const char *cmd, int key, int event) {
-    if (key > 255) {
-        printf("Currently key event mapping only handles ASCII characters\n");
-        return;
-    }
-
-    printf("Bound command '%s' -> event %i (0x%x key)\n", cmd, event, key);
-
-    keyEvents[key] = event;
-}
-#endif
-
-void SDLSystem::setGrabMouse(bool on) {
-    SDL_SetRelativeMouseMode(on ? SDL_TRUE : SDL_FALSE);
-    if (!on)
-        SDL_ShowCursor(1);
-}
-
-void SDLSystem::initVideo(unsigned int width, unsigned int height, bool fullscreen) {
-    int flags = 0; //, x, y;
-
-    assert(width > 0);
-    assert(height > 0);
-
-    // Create GL context
-    SDL_Init(SDL_INIT_VIDEO);
-    printf("Created OpenGL Context\n");
-    atexit(SDL_Quit);
-
-    m_width = width;
-    m_height = height;
-
-#ifndef __APPLE__
-    if (!m_driver || !m_driver[0] || SDL_GL_LoadLibrary(m_driver) < 0) {
-        SDL_ClearError();
-
-        // Fallback 1
-        if (SDL_GL_LoadLibrary("libGL.so") < 0) {
-            SDL_ClearError();
-
-            // Fallback 2
-            if (SDL_GL_LoadLibrary("libGL.so.1") < 0) {
-                fprintf(stderr, "initVideo> SDL_GL_LoadLibrary failed!\n");
-                fprintf(stderr, "initVideo> Error is [%s].\n", SDL_GetError());
-                shutdown(1);
-            }
-        }
-    }
-#endif
-
-    flags |= SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE;
-
-    mFullscreen = fullscreen;
-    if (mFullscreen)
-        flags |= SDL_WINDOW_FULLSCREEN;
-
-    setGrabMouse(true); // Always grab mouse!
-
-    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
-    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);
-    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
-    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
-    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-
-    mWindow = SDL_CreateWindow(VERSION, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-            width, height, flags);
-    mGLContext = SDL_GL_CreateContext(mWindow);
-
-    // Resize context
-    resizeGL(width, height);
-}
-
-void SDLSystem::resize(unsigned int width, unsigned int height) {
-    assert(width > 0);
-    assert(height > 0);
-
-    m_width = width;
-    m_height = height;
-
-    SDL_SetWindowSize(mWindow, width, height);
-
-    // Resize context
-    resizeGL(width, height);
-}
-
-void SDLSystem::runGame() {
-    SDL_Event event;
-    unsigned int mkeys, mod, key;
-    int btn = 0;
-    bool specialKey;
-
-    for (;;) {
-        // Pause for 10-20 ms
-        SDL_Delay(10);
-
-        while (SDL_PollEvent(&event)) {
-            switch (event.type) {
-                case SDL_QUIT:
-                    shutdown(0);
-                    break;
-                case SDL_MOUSEMOTION:
-                    // Wrap motion
-                    handleMouseMotionEvent(event.motion.xrel / 2, event.motion.yrel / 2);
-                    break;
-                case SDL_MOUSEBUTTONDOWN:
-                case SDL_MOUSEBUTTONUP:
-                    //handleMouseEvent(event.button.button, event.button.state,
-                    //                    event.button.x, event.button.y);
-
-                    switch (event.button.button) {
-                        case SDL_BUTTON_LEFT:
-                            btn = SYS_MOUSE_LEFT;
-                            break;
-                        case SDL_BUTTON_RIGHT:
-                            btn = SYS_MOUSE_RIGHT;
-                            break;
-                        case SDL_BUTTON_MIDDLE:
-                            btn = SYS_MOUSE_MIDDLE;
-                            break;
-                    }
-
-                    if (event.button.state == SDL_PRESSED) {
-                        handleKeyPressEvent(btn, 0); //! \fixme mod not used
-                    } else {
-                        handleKeyReleaseEvent(btn, 0); //! \fixme mod not used
-                    }
-                    break;
-                case SDL_KEYUP:
-                case SDL_KEYDOWN:
-                    //SDL_GetMouseState(&x, &y); // Get cursor pos
-
-                    mkeys = (unsigned int)SDL_GetModState();
-                    mod = 0;
-
-                    if (mkeys & KMOD_LSHIFT)
-                        mod |= SYS_MOD_KEY_LSHIFT;
-
-                    if (mkeys & KMOD_RSHIFT)
-                        mod |= SYS_MOD_KEY_RSHIFT;
-
-                    if (mkeys & KMOD_LCTRL)
-                        mod |= SYS_MOD_KEY_LCTRL;
-
-                    if (mkeys & KMOD_RCTRL)
-                        mod |= SYS_MOD_KEY_RCTRL;
-
-                    if (mkeys & KMOD_LALT)
-                        mod |= SYS_MOD_KEY_LALT;
-
-                    if (mkeys & KMOD_RALT)
-                        mod |= SYS_MOD_KEY_RALT;
-
-                    if (mkeys & KMOD_LGUI)
-                        mod |= SYS_MOD_KEY_LMETA;
-
-                    if (mkeys & KMOD_RGUI)
-                        mod |= SYS_MOD_KEY_RMETA;
-
-                    key = event.key.keysym.sym;
-                    specialKey = false;
-
-                    switch (key) {
-                        case SDLK_F1:
-                            key = SYS_KEY_F1;
-                            specialKey = true;
-                            break;
-                        case SDLK_F2:
-                            key = SYS_KEY_F2;
-                            specialKey = true;
-                            break;
-                        case SDLK_F3:
-                            key = SYS_KEY_F3;
-                            specialKey = true;
-                            break;
-                        case SDLK_F4:
-                            key = SYS_KEY_F4;
-                            specialKey = true;
-                            break;
-                        case SDLK_F5:
-                            key = SYS_KEY_F5;
-                            specialKey = true;
-                            break;
-                        case SDLK_F6:
-                            key = SYS_KEY_F6;
-                            specialKey = true;
-                            break;
-                        case SDLK_F7:
-                            key = SYS_KEY_F7;
-                            specialKey = true;
-                            break;
-                        case SDLK_F8:
-                            key = SYS_KEY_F8;
-                            specialKey = true;
-                            break;
-                        case SDLK_F9:
-                            key = SYS_KEY_F9;
-                            specialKey = true;
-                            break;
-                        case SDLK_F10:
-                            key = SYS_KEY_F10;
-                            specialKey = true;
-                            break;
-                        case SDLK_F11:
-                            key = SYS_KEY_F11;
-                            specialKey = true;
-                            break;
-                        case SDLK_F12:
-                            key = SYS_KEY_F12;
-                            specialKey = true;
-                            break;
-                        case SDLK_UP:
-                            key = SYS_KEY_UP;
-                            specialKey = true;
-                            break;
-                        case SDLK_DOWN:
-                            key = SYS_KEY_DOWN;
-                            specialKey = true;
-                            break;
-                        case SDLK_RIGHT:
-                            key = SYS_KEY_RIGHT;
-                            specialKey = true;
-                            break;
-                        case SDLK_LEFT:
-                            key = SYS_KEY_LEFT;
-                            specialKey = true;
-                            break;
-                        case SDLK_PAGEDOWN:
-                            key = SYS_KEY_PAGEDOWN;
-                            specialKey = true;
-                            break;
-                        case SDLK_PAGEUP:
-                            key = SYS_KEY_PAGEUP;
-                            specialKey = true;
-                            break;
-                    }
-
-#ifdef __APPLE__
-                    // Handle CMD+Q to quit in all circumstances
-                    if (key == 'q') {
-                        if (mod & SYS_MOD_KEY_LMETA) {
-                            shutdown(0);
-                        }
-                    }
-#endif
-
-                    /*! \fixme Avoid passing modifers as a key, since the
-                     * consoles using this expect text characters, add unicode
-                     * support later when they're able to handle it
-                     */
-                    if (key > 255 && key < 1000) {
-                        key = 0;
-                    }
-
-                    if (key == mConsoleKey) {
-                        if (event.type == SDL_KEYDOWN) {
-                            mConsoleMode = !mConsoleMode;
-                            // Tmp hack
-                            handleConsoleKeyPressEvent(mConsoleKey, 0);
-                        }
-                    } else if (mConsoleMode) { // Console keying (text input)
-                        switch (event.type) {
-                            case SDL_KEYDOWN:
-                                handleConsoleKeyPressEvent(key, mod);
-                                break;
-                            default:
-                                ;
-                        }
-                    } else if (mKeyEvents[key] != 0) { // Bound key
-                        //if (key < 255 && mKeyEvents[key] != 0)
-                        key = mKeyEvents[key];
-
-                        switch (event.type) {
-                            case SDL_KEYDOWN:
-                                handleBoundKeyPressEvent(key);
-                                break;
-                            default:
-                                handleBoundKeyReleaseEvent(key);
-                        }
-                    } else { // 'Classic' key event handlers
-                        switch (event.type) {
-                            case SDL_KEYDOWN:
-                                handleKeyPressEvent(key, mod);
-                                break;
-                            default:
-                                handleKeyReleaseEvent(key, mod);
-                        }
-                    }
-                    break;
-                case SDL_WINDOWEVENT:
-                    switch(event.window.event) {
-                        case SDL_WINDOWEVENT_RESIZED:
-                            resize(event.window.data1, event.window.data2);
-                            break;
-                    }
-                    break;
-            }
-        }
-
-        // Game frame
-        gameFrame();
-    }
-}
-
-void SDLSystem::shutdown(int i) {
-    //SDL_QuitSubSystem(SDL_OPENGL);
-    //SDL_Quit(); // Moved to atexit() call
-
-    exit(i);
-}
-
-void SDLSystem::toggleFullscreen() {
-    if (mWindow) {
-        mFullscreen = !mFullscreen;
-
-        if (mFullscreen)
-            SDL_SetWindowFullscreen(mWindow, SDL_WINDOW_FULLSCREEN_DESKTOP);
-        else
-            SDL_SetWindowFullscreen(mWindow, 0);
-    }
-}
-
-void SDLSystem::swapBuffersGL() {
-    SDL_GL_SwapWindow(mWindow);
-}
-

src/SkeletalModel.cpp

@@ -1,161 +0,0 @@
-/*!
- * \file src/SkeletalModel.cpp
- * \brief This is the factored out skeletal model class
- *
- * \author Mongoose
- */
-
-#include "SkeletalModel.h"
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-SkeletalModel::SkeletalModel()
-{
-    model = 0x0;
-    flags = 0;
-    mBoneFrame = 0;
-    mAnimationFrame = 0;
-    mIdleAnimation = 0;
-    time = 0.0f;
-    lastTime = 0.0f;
-    rate = 0.0f;
-}
-
-
-SkeletalModel::~SkeletalModel()
-{
-    if (model)
-    {
-        for (model->animation.start();
-                model->animation.forward();
-                model->animation.next())
-        {
-            animation_frame_t *af = model->animation.current();
-
-            if (!af)
-                continue;
-
-            for (af->frame.start(); af->frame.forward(); af->frame.next())
-            {
-                bone_frame_t *bf = af->frame.current();
-
-                if (!bf)
-                    continue;
-
-                bf->tag.erase();
-
-                //for (bf->tag.start(); bf->tag.forward(); bf->tag.next())
-                //{
-                //  if (bf->tag.current())
-                //      delete bf->tag.current();
-                //}
-
-                delete bf;
-            }
-
-            af->frame.clear();
-
-            delete af;
-        }
-
-        model->animation.clear();
-
-        //! \fixme Causes "freeing already freed pointer" exception
-        //delete model;
-    }
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-int SkeletalModel::getAnimation()
-{
-    return mAnimationFrame;
-}
-
-
-int SkeletalModel::getFrame()
-{
-    return mBoneFrame;
-}
-
-
-int SkeletalModel::getIdleAnimation()
-{
-    return mIdleAnimation;
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void SkeletalModel::setModel(skeletal_model_t *mdl)
-{
-    if (mdl)
-        model = mdl;
-}
-
-
-void SkeletalModel::setAnimation(int index)
-{
-    if (!model) // index > (int)model->animation.size())
-        return;
-
-    animation_frame_t *a = model->animation[index];
-
-    if (a)
-    {
-        mAnimationFrame = index;
-        mBoneFrame = 0;
-        rate = a->rate;
-    }
-}
-
-
-void SkeletalModel::setFrame(int index)
-{
-    if (!model)
-        return;
-
-    animation_frame_t *a = model->animation[mAnimationFrame];
-
-    if (a) // index > (int)a->frame.size())
-    {
-        bone_frame_t *b = a->frame[index];
-
-        if (b)
-        {
-            mBoneFrame = index;
-        }
-    }
-}
-
-
-void SkeletalModel::setIdleAnimation(int index)
-{
-    if (!model)
-        return;
-
-    animation_frame_t *a = model->animation[index];
-
-    if (a)
-    {
-        mIdleAnimation = index;
-    }
-}
-
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-

src/Sound.cpp

@@ -1,262 +0,0 @@
-/*!
- * \file src/Sound.cpp
- * \brief This is the audio manager Implementation
- *
- * \author Mongoose
- * \author xythobuz
- */
-
-#ifdef __APPLE__
-#include <OpenAL/al.h>
-#else
-#include <AL/al.h>
-#endif
-
-#include <AL/alut.h>
-
-#include <time.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <assert.h>
-
-#include "Sound.h"
-
-Sound::Sound()
-{
-    mSource[0] = 0;
-    mBuffer[0] = 0;
-    mNext = 0;
-    mInit = false;
-}
-
-
-Sound::~Sound()
-{
-    if (mInit)
-    {
-        alutExit();
-    }
-}
-
-
-int Sound::init()
-{
-#ifndef __APPLE__
-    int fd;
-
-    fd = open("/dev/dsp", O_RDWR);
-
-    if (fd < 0)
-    {
-        perror("Sound::Init> Could not open /dev/dsp : ");
-        return -1;
-    }
-
-    close(fd);
-#endif
-
-    ALCdevice *Device = alcOpenDevice("OSS");
-    ALCcontext *Context = alcCreateContext(Device, NULL);
-    alcMakeContextCurrent(Context);
-
-    if (alutInitWithoutContext(NULL, NULL) == AL_FALSE) {
-        printf("Sound::Init> Could not initialize alut (%s)\n", alutGetErrorString(alutGetError()));
-        return -2;
-    }
-
-    mInit = true;
-    printf("Created OpenAL Context\n");
-
-    return 0;
-}
-
-
-int Sound::registeredSources() {
-    return mNext;
-}
-
-
-void Sound::listenAt(float pos[3], float angle[3])
-{
-    assert(mInit == true);
-    assert(pos != NULL);
-    assert(angle != NULL);
-
-    alListenerfv(AL_POSITION, pos);
-    alListenerfv(AL_ORIENTATION, angle);
-}
-
-
-void Sound::sourceAt(int source, float pos[3])
-{
-    assert(mInit == true);
-    assert(source >= 0);
-    assert(source < mNext);
-    assert(pos != NULL);
-
-    alSourcefv(mSource[source], AL_POSITION, pos);
-}
-
-
-//! \fixme Seperate sourcing and buffering, Mongoose 2002.01.04
-int Sound::addFile(const char *filename, int *source, unsigned int flags)
-{
-    ALsizei size;
-    ALfloat freq;
-    ALenum format;
-    ALvoid *data;
-
-    assert(mInit == true);
-    assert(filename != NULL);
-    assert(filename[0] != '\0');
-    assert(source != NULL);
-
-    *source = -1;
-
-    alGetError();
-
-    alGenBuffers(1, &mBuffer[mNext]);
-
-    if (alGetError() != AL_NO_ERROR)
-    {
-        fprintf(stderr, "Sound::AddFile> alGenBuffers call failed\n");
-        return -1;
-    }
-
-    alGetError();
-
-    alGenSources(1, &mSource[mNext]);
-
-    if (alGetError() != AL_NO_ERROR)
-    {
-        fprintf(stderr, "Sound::AddFile> alGenSources call failed\n");
-        return -2;
-    }
-
-    // err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
-    // is deprecated!
-    data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
-
-    if (alutGetError() != ALUT_ERROR_NO_ERROR)
-    {
-        fprintf(stderr, "Could not load %s\n", filename);
-        return -3;
-    }
-
-    alBufferData(mBuffer[mNext], format, data, size, static_cast<ALsizei>(freq));
-
-    alSourcei(mSource[mNext], AL_BUFFER, mBuffer[mNext]);
-
-    if (flags & SoundFlagsLoop)
-    {
-        alSourcei(mSource[mNext], AL_LOOPING, 1);
-    }
-
-    *source = mNext++;
-
-    return 0;
-}
-
-int Sound::addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags)
-{
-    ALsizei size;
-    ALfloat freq;
-    ALenum format;
-    ALvoid *data;
-    int error = 0;
-
-    assert(mInit == true);
-    assert(wav != NULL);
-    assert(source != NULL);
-
-    *source = -1;
-
-    data = wav;
-
-    alGetError();
-
-    alGenBuffers(1, &mBuffer[mNext]);
-
-    if (alGetError() != AL_NO_ERROR)
-    {
-        fprintf(stderr, "Sound::AddWave> alGenBuffers call failed\n");
-        return -1;
-    }
-
-    alGetError();
-
-    alGenSources(1, &mSource[mNext]);
-
-    if (alGetError() != AL_NO_ERROR)
-    {
-        fprintf(stderr, "Sound::AddWave> alGenSources call failed\n");
-        return -2;
-    }
-
-    //AL_FORMAT_WAVE_EXT does not exist on Mac!"
-    // alBufferData(mBuffer[mNext], AL_FORMAT_WAVE_EXT, data, size, freq);
-    // Idea: Fill Buffer with
-    // alutLoadMemoryFromFileImage
-    //     (const ALvoid *data, ALsizei length, ALenum *format, ALsizei *size, ALfloat *frequency)
-
-    data = alutLoadMemoryFromFileImage(wav, length, &format, &size, &freq);
-
-    if (((error = alutGetError()) != ALUT_ERROR_NO_ERROR) || (data == NULL)) {
-        fprintf(stderr, "Could not load wav buffer (%s)\n", alutGetErrorString(error));
-        return -3;
-    }
-
-
-    alBufferData(mBuffer[mNext], format, data, size, static_cast<ALsizei>(freq));
-
-    alSourcei(mSource[mNext], AL_BUFFER, mBuffer[mNext]);
-
-    if (flags & SoundFlagsLoop)
-    {
-        alSourcei(mSource[mNext], AL_LOOPING, 1);
-    }
-
-    *source = mNext++;
-
-    //! \fixme Should free alut buffer?
-
-    return 0;
-}
-
-
-void Sound::remove(int source) {
-    assert(source >= 0);
-    assert(source < mNext);
-
-    alDeleteSources(1, &mSource[source]);
-    alDeleteBuffers(1, &mBuffer[source]);
-
-    if (source == (mNext - 1))
-        mNext--;
-}
-
-
-void Sound::play(int source)
-{
-    assert(mInit == true);
-    assert(source >= 0);
-    assert(source < mNext);
-
-    alSourcePlay(mSource[source]);
-}
-
-
-void Sound::stop(int source)
-{
-    assert(mInit == true);
-    assert(source >= 0);
-    assert(source < mNext);
-
-    alSourceStop(mSource[source]);
-}
-

src/System.cpp

@@ -1,217 +0,0 @@
-/*!
- * \file src/System.cpp
- * \brief Mostly defines the interface of System implementations.
- *
- * Currently only SDL is used, but there was a GLUT implementation.
- *
- * \author Mongoose
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <string.h>
-#include <stdarg.h>
-#include <cmath>
-#include <assert.h>
-
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-#include <GL/glu.h>
-#endif
-
-#include "utils/math.h"
-#include "utils/time.h"
-#include "System.h"
-
-System::System() {
-    m_width = 800;
-    m_height = 600;
-
-    m_driver = NULL;
-
-    m_clipFar  = 4000.0f;
-    m_clipNear = 4.0f;
-    m_fovY     = 45.0f;
-
-    mConsoleMode = false;
-    mCommandMode = 0;
-
-    printf("[System.Core]\n");
-
-    // Hack for bad Map class, as well as reserved commands
-    addCommandMode("[System.Console]");
-    mConsoleKey = '`';
-    bindKeyCommand("+console", mConsoleKey, 0);
-
-#ifdef WIN32
-    setDriverGL("libGL32.dll");
-#else
-    setDriverGL("/usr/lib/libGL.so.1");
-#endif
-}
-
-System::~System() {
-}
-
-unsigned int System::addCommandMode(const char *command) {
-    assert(command != NULL);
-    assert(command[0] == '[');
-
-    mCmdModes.pushBack(command);
-    return (mCmdModes.size() - 1);
-}
-
-//! \fixme Modifer support later
-void System::bindKeyCommand(const char *cmd, unsigned int key, int event) {
-    assert(cmd != NULL);
-    assert(cmd[0] != '\0');
-
-    printf("Bound command '%s' -> event %i (0x%x key)\n", cmd, event, key);
-    mKeyEvents[key] = event;
-}
-
-void System::command(const char *cmd) {
-    bool modeFound = false;
-    char *cmdbuf;
-
-    assert(cmd != NULL);
-    assert(cmd[0] != '\0');
-
-    if (cmd[0] == '[') { // Set a mode, eg "[Engine.OpenGL.Driver]"
-        for (mCmdModes.start(); mCmdModes.forward(); mCmdModes.next()) {
-            if (strcmp(cmd, mCmdModes.current()) == 0) {
-                mCommandMode = mCmdModes.getCurrentIndex();
-                modeFound = true;
-            }
-        }
-
-        if (!modeFound) {
-            //  mCommandMode = 0;
-            printf("Command> Unknown mode '%s'\n", cmd);
-        }
-    } else { // Execute a command in current mode, eg "stat fps"
-        cmdbuf = new char[strlen(cmd) + 1];
-        strncpy(cmdbuf, cmd, strlen(cmd) + 1);
-        handleCommand(cmdbuf, mCommandMode);
-    }
-}
-
-int System::loadResourceFile(const char *filename) {
-    char buffer[256];
-    bool line_comment = false;
-    FILE *f;
-    char c;
-    int i, j;
-
-    assert(filename != NULL);
-    assert(filename[0] != '\0');
-
-    f = fopen(filename, "r");
-
-    if (!f) {
-        perror(filename);
-        return -1;
-    }
-
-    printf("Loading %s...\n", filename);
-
-    i = 0;
-    buffer[0] = 0;
-
-    // Strip out whitespace and comments
-    while (fscanf(f, "%c", &c) != EOF) {
-        if (line_comment && c != '\n')
-            continue;
-
-        if (i > 254) {
-            printf("loadResourceFile> Overflow handled\n");
-            i = 254;
-        }
-
-        switch (c) {
-            case '\v':
-            case '\t':
-                break;
-            case '#':
-                buffer[i++] = 0;
-                line_comment = true;
-                break;
-            case '\n':
-                if (line_comment)
-                    line_comment = false;
-
-                if (buffer[0] == 0) {
-                    i = 0;
-                    continue;
-                }
-
-                buffer[i] = 0;
-                //printf("'%s'\n", buffer);
-
-                // 'Preprocessor' commands
-                if (buffer[0] == '@') {
-                    if (strncmp((buffer + 1), "include ", 8) == 0) {
-                        for (j = 9; j < i; ++j) {
-                            buffer[j-9] = buffer[j];
-                            buffer[j-8] = 0;
-                        }
-
-                        printf("Importing '%s'\n", buffer);
-
-                        loadResourceFile(fullPath(buffer, 0));
-                    }
-                } else {
-                    command(buffer);
-                }
-
-                i = 0;
-                buffer[0] = 0;
-                break;
-            default:
-                buffer[i++] = c;
-        }
-    }
-
-    fclose(f);
-
-    return 0;
-}
-
-void System::setDriverGL(const char *driver) {
-    assert(driver != NULL);
-    assert(driver[0] != '\0');
-
-    if (m_driver)
-        delete [] m_driver;
-
-    unsigned int len = strlen(driver);
-    m_driver = new char[len + 1];
-    strncpy(m_driver, driver, len);
-    m_driver[len] = 0;
-}
-
-void System::resizeGL(unsigned int w, unsigned int h) {
-    assert(w > 0);
-    assert(h > 0);
-
-    glViewport(0, 0, w, h);
-    glMatrixMode(GL_PROJECTION);
-    glLoadIdentity();
-
-    // Adjust clipping
-    // gluPerspective is deprecated!
-    // gluPerspective(m_fovY, ((GLdouble)w)/((GLdouble)h), m_clipNear, m_clipFar);
-    // Fix: http://stackoverflow.com/a/2417756
-    GLfloat fH = tanf(m_fovY * HEL_PI / 360.0f) * m_clipNear;
-    GLfloat fW = fH * ((GLfloat)w)/((GLfloat)h);
-    glFrustum(-fW, fW, -fH, fH, m_clipNear, m_clipFar);
-
-    glMatrixMode(GL_MODELVIEW);
-    glLoadIdentity();
-}
-

src/Vector3d.cpp

@@ -1,135 +0,0 @@
-/*!
- * \file src/Vector3d.cpp
- * \brief 3D Math vector
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "Vector3d.h"
-
-Vector3d::Vector3d() {
-    mVec[0] = mVec[1] = mVec[2] = 0.0f;
-}
-
-Vector3d::Vector3d(vec3_t v) {
-    mVec[0] = v[0];
-    mVec[1] = v[1];
-    mVec[2] = v[2];
-}
-
-Vector3d::Vector3d(vec_t x, vec_t y, vec_t z) {
-    mVec[0] = x;
-    mVec[1] = y;
-    mVec[2] = z;
-}
-
-Vector3d::Vector3d(const Vector3d &v) {
-    mVec[0] = v.mVec[0];
-    mVec[1] = v.mVec[1];
-    mVec[2] = v.mVec[2];
-}
-
-vec_t Vector3d::dot(const Vector3d &u, const Vector3d &v) {
-    return (u.mVec[0]*v.mVec[0] + u.mVec[1]*v.mVec[1] + u.mVec[2]*v.mVec[2]);
-}
-
-Vector3d Vector3d::cross(const Vector3d &u, const Vector3d &v) {
-    return Vector3d(u.mVec[1] * v.mVec[2] - u.mVec[2] * v.mVec[1],
-            u.mVec[2] * v.mVec[0] - u.mVec[0] * v.mVec[2],
-            u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
-}
-
-vec_t Vector3d::magnitude() {
-    return sqrtf(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
-}
-
-Vector3d Vector3d::unit() {
-    vec_t norm = magnitude();
-
-    return Vector3d(mVec[0] / norm,
-            mVec[1] / norm,
-            mVec[2] / norm);
-}
-
-Vector3d Vector3d::zeroVector() {
-    return Vector3d(0, 0, 0);
-}
-
-Vector3d Vector3d::operator +(const Vector3d &v) {
-    return Vector3d(mVec[0] + v.mVec[0],
-            mVec[1] + v.mVec[1],
-            mVec[2] + v.mVec[2]);
-}
-
-Vector3d Vector3d::operator -(const Vector3d &v) {
-    return Vector3d(mVec[0] - v.mVec[0],
-            mVec[1] - v.mVec[1],
-            mVec[2] - v.mVec[2]);
-}
-
-Vector3d Vector3d::operator -() {
-    return Vector3d(-mVec[0],
-            -mVec[1],
-            -mVec[2]);
-}
-
-Vector3d Vector3d::operator *(vec_t s) {
-    return Vector3d(s * mVec[0],
-            s * mVec[1],
-            s * mVec[2]);
-}
-
-Vector3d Vector3d::operator /(vec_t s) {
-    return Vector3d(mVec[0] / s,
-            mVec[1] / s,
-            mVec[2] / s);
-}
-
-vec_t Vector3d::operator *(const Vector3d &v) {
-    return dot(*this, v);
-}
-
-void Vector3d::normalize() {
-    vec_t norm = magnitude();
-
-    mVec[0] /= norm;
-    mVec[1] /= norm;
-    mVec[2] /= norm;
-}
-
-void Vector3d::zero() {
-    mVec[0] = 0;
-    mVec[1] = 0;
-    mVec[2] = 0;
-}
-
-Vector3d &Vector3d::operator =(const Vector3d &v) {
-    mVec[0] = v.mVec[0];
-    mVec[1] = v.mVec[1];
-    mVec[2] = v.mVec[2];
-    return *this;
-}
-
-Vector3d &Vector3d::operator +=(const Vector3d &v) {
-    mVec[0] += v.mVec[0];
-    mVec[1] += v.mVec[1];
-    mVec[2] += v.mVec[2];
-    return *this;
-}
-
-Vector3d &Vector3d::operator -=(const Vector3d &v) {
-    mVec[0] -= v.mVec[0];
-    mVec[1] -= v.mVec[1];
-    mVec[2] -= v.mVec[2];
-    return *this;
-}
-
-Vector3d &Vector3d::operator *=(vec_t s) {
-    mVec[0] *= s;
-    mVec[1] *= s;
-    mVec[2] *= s;
-    return *this;
-}
-

src/ViewVolume.cpp

@@ -1,270 +0,0 @@
-/*!
- * \file include/ViewVolume.h
- * \brief Viewing Volume for culling use
- *
- * Thanks Mark Morley for the article I used to get several algorithms.
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "ViewVolume.h"
-
-ViewVolume::ViewVolume() {
-    mFrustum[0][0] = mFrustum[0][1] = mFrustum[0][2] = mFrustum[0][3] = 0.0f;
-    mFrustum[1][0] = mFrustum[1][1] = mFrustum[1][2] = mFrustum[1][3] = 0.0f;
-    mFrustum[2][0] = mFrustum[2][1] = mFrustum[2][2] = mFrustum[2][3] = 0.0f;
-    mFrustum[3][0] = mFrustum[3][1] = mFrustum[3][2] = mFrustum[3][3] = 0.0f;
-    mFrustum[4][0] = mFrustum[4][1] = mFrustum[4][2] = mFrustum[4][3] = 0.0f;
-    mFrustum[5][0] = mFrustum[5][1] = mFrustum[5][2] = mFrustum[5][3] = 0.0f;
-}
-
-bool ViewVolume::isBoundingVolumeInFrustum(BoundingVolume bvol) {
-    return (isBoundingSphereInFrustum(bvol.mSphere) &&
-            isBoundingBoxInFrustum(bvol.mBox));
-}
-
-bool ViewVolume::isBoundingSphereInFrustum(BoundingSphere bvol) {
-    return (isSphereInFrustum(bvol.mCenter[0],
-                bvol.mCenter[1],
-                bvol.mCenter[2],
-                bvol.mRadius));
-}
-
-bool ViewVolume::isBoundingBoxInFrustum(BoundingBox bvol) {
-    return (isBboxInFrustum(bvol.mMin, bvol.mMax));
-}
-
-bool ViewVolume::isPointInFrustum(vec_t x, vec_t y, vec_t z) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        if (mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z +
-                mFrustum[p][3] <= 0) {
-            return false;
-        }
-    }
-    return true;
-}
-
-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];
-        if (d <= -radius)
-            return false;
-    }
-    return true;
-}
-
-bool ViewVolume::isBboxInFrustum(vec3_t min, vec3_t max) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        if (mFrustum[p][0] * min[0] +
-                mFrustum[p][1] * min[1] +
-                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-                mFrustum[p][1] * max[1] +
-                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-                mFrustum[p][1] * max[1] +
-                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-                mFrustum[p][1] * min[1] +
-                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * min[0] +
-                mFrustum[p][1] * max[1] +
-                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-                mFrustum[p][1] * min[1] +
-                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-                mFrustum[p][1] * max[1] +
-                mFrustum[p][2] * min[2] + mFrustum[p][3] > 0)
-            continue;
-
-        if (mFrustum[p][0] * max[0] +
-                mFrustum[p][1] * min[1] +
-                mFrustum[p][2] * max[2] + mFrustum[p][3] > 0)
-            continue;
-
-        return false;
-    }
-    return true;
-}
-
-vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radius) {
-    vec_t d = 0.0;
-    for (unsigned int p = 0; p < 6; ++p) {
-        d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
-        if (d <= -radius)
-            return 0;
-    }
-    return d + radius;
-}
-
-vec_t ViewVolume::getDistToBboxFromNear(vec3_t min, vec3_t max) {
-    vec3_t center;
-    vec_t d, radius;
-
-    helMidpoint3v(min, max, center);
-
-    // 5 should be near plane
-    d = (mFrustum[5][0] * center[0] +
-            mFrustum[5][1] * center[1] +
-            mFrustum[5][2] * center[2] +
-            mFrustum[5][3]);
-
-    radius = helDist3v(max, center);
-
-    if (d <= -radius)
-        return 0;
-
-    return d + radius;
-}
-
-void ViewVolume::getFrustum(vec_t frustum[6][4]) {
-    for (unsigned int p = 0; p < 6; ++p) {
-        for (unsigned int i = 0; i < 4; ++i) {
-            frustum[p][i] = mFrustum[p][i];
-        }
-    }
-}
-
-void ViewVolume::getPlane(ViewVolumeSide p, vec4_t plane) {
-    for (unsigned int i = 0; i < 4; ++i) {
-        plane[i] =  mFrustum[p][i];
-    }
-}
-
-void ViewVolume::updateFrame(matrix_t proj, matrix_t mdl) {
-    setModel(mdl);
-    setProjection(proj);
-    updateClip();
-    updateFrustum();
-}
-
-void ViewVolume::updateFrame() {
-    updateClip();
-    updateFrustum();
-}
-
-void ViewVolume::setModel(matrix_t mdl) {
-    mModel.setMatrix(mdl);
-}
-
-void ViewVolume::setProjection(matrix_t proj) {
-    mProjection.setMatrix(proj);
-}
-
-void ViewVolume::updateClip() {
-    mClip = mProjection * mModel;
-}
-
-void ViewVolume::updateFrustum() {
-    matrix_t clip;
-    vec_t t;
-
-    mClip.getMatrix(clip);
-
-    /* Extract the numbers for the RIGHT plane */
-    mFrustum[0][0] = clip[ 3] - clip[ 0];
-    mFrustum[0][1] = clip[ 7] - clip[ 4];
-    mFrustum[0][2] = clip[11] - clip[ 8];
-    mFrustum[0][3] = clip[15] - clip[12];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[0][0] * mFrustum[0][0] +
-            mFrustum[0][1] * mFrustum[0][1] +
-            mFrustum[0][2] * mFrustum[0][2]);
-    mFrustum[0][0] /= t;
-    mFrustum[0][1] /= t;
-    mFrustum[0][2] /= t;
-    mFrustum[0][3] /= t;
-
-    /* Extract the numbers for the LEFT plane */
-    mFrustum[1][0] = clip[ 3] + clip[ 0];
-    mFrustum[1][1] = clip[ 7] + clip[ 4];
-    mFrustum[1][2] = clip[11] + clip[ 8];
-    mFrustum[1][3] = clip[15] + clip[12];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[1][0] * mFrustum[1][0] +
-            mFrustum[1][1] * mFrustum[1][1] +
-            mFrustum[1][2] * mFrustum[1][2]);
-    mFrustum[1][0] /= t;
-    mFrustum[1][1] /= t;
-    mFrustum[1][2] /= t;
-    mFrustum[1][3] /= t;
-
-    /* Extract the BOTTOM plane */
-    mFrustum[2][0] = clip[ 3] + clip[ 1];
-    mFrustum[2][1] = clip[ 7] + clip[ 5];
-    mFrustum[2][2] = clip[11] + clip[ 9];
-    mFrustum[2][3] = clip[15] + clip[13];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[2][0] * mFrustum[2][0] +
-            mFrustum[2][1] * mFrustum[2][1] +
-            mFrustum[2][2] * mFrustum[2][2]);
-    mFrustum[2][0] /= t;
-    mFrustum[2][1] /= t;
-    mFrustum[2][2] /= t;
-    mFrustum[2][3] /= t;
-
-    /* Extract the TOP plane */
-    mFrustum[3][0] = clip[ 3] - clip[ 1];
-    mFrustum[3][1] = clip[ 7] - clip[ 5];
-    mFrustum[3][2] = clip[11] - clip[ 9];
-    mFrustum[3][3] = clip[15] - clip[13];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[3][0] * mFrustum[3][0] +
-            mFrustum[3][1] * mFrustum[3][1] +
-            mFrustum[3][2] * mFrustum[3][2]);
-    mFrustum[3][0] /= t;
-    mFrustum[3][1] /= t;
-    mFrustum[3][2] /= t;
-    mFrustum[3][3] /= t;
-
-    /* Extract the FAR plane */
-    mFrustum[4][0] = clip[ 3] - clip[ 2];
-    mFrustum[4][1] = clip[ 7] - clip[ 6];
-    mFrustum[4][2] = clip[11] - clip[10];
-    mFrustum[4][3] = clip[15] - clip[14];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[4][0] * mFrustum[4][0] +
-            mFrustum[4][1] * mFrustum[4][1] +
-            mFrustum[4][2] * mFrustum[4][2]);
-    mFrustum[4][0] /= t;
-    mFrustum[4][1] /= t;
-    mFrustum[4][2] /= t;
-    mFrustum[4][3] /= t;
-
-    /* Extract the NEAR plane */
-    mFrustum[5][0] = clip[ 3] + clip[ 2];
-    mFrustum[5][1] = clip[ 7] + clip[ 6];
-    mFrustum[5][2] = clip[11] + clip[10];
-    mFrustum[5][3] = clip[15] + clip[14];
-
-    /* Normalize the result */
-    t = sqrtf(mFrustum[5][0] * mFrustum[5][0] +
-            mFrustum[5][1] * mFrustum[5][1] +
-            mFrustum[5][2] * mFrustum[5][2]);
-    mFrustum[5][0] /= t;
-    mFrustum[5][1] /= t;
-    mFrustum[5][2] /= t;
-    mFrustum[5][3] /= t;
-}
-

src/World.cpp

@@ -1,762 +0,0 @@
-/*!
- * \file src/World.cpp
- * \brief The game world (model)
- *
- * \author Mongoose
- */
-
-#include <math.h>
-
-#include "World.h"
-
-
-////////////////////////////////////////////////////////////
-// Constructors
-////////////////////////////////////////////////////////////
-
-World::World()
-{
-    mClearLock = false;
-    mFlags = 0;
-    mEntities.setError(0x0);
-    mRooms.setError(0x0);
-    mMeshes.setError(0x0);
-    mSprites.setError(0x0);
-    mModels.setError(0x0);
-}
-
-
-World::~World()
-{
-    destroy();
-}
-
-
-////////////////////////////////////////////////////////////
-// Public Accessors
-////////////////////////////////////////////////////////////
-
-int World::getRoomByLocation(int index, float x, float y, float z)
-{
-    room_mesh_t *room = mRooms[index];
-
-    if (room)
-    {
-        if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
-                z > room->bbox_min[2] && z < room->bbox_max[2])
-        {
-            if (y > room->bbox_min[1] && y < room->bbox_max[1])
-                return index;
-        }
-    }
-
-    return getRoomByLocation(x, y, z);
-}
-
-
-int World::getRoomByLocation(float x, float y, float z)
-{
-    room_mesh_t *room;
-    int hop = -1;
-
-
-    for (mRooms.start(); mRooms.forward(); mRooms.next())
-    {
-        room = mRooms.current();
-
-        if (!room)
-            continue;
-
-        if (x > room->bbox_min[0] && x < room->bbox_max[0] &&
-                z > room->bbox_min[2] && z < room->bbox_max[2])
-        {
-            // This room contains current position
-            if (y > room->bbox_min[1] && y < room->bbox_max[1])
-                return mRooms.getCurrentIndex();
-
-            // This room is above or below current position
-            hop = mRooms.getCurrentIndex();
-        }
-    }
-
-    // Room is -1?  Must be in void, try to hop to room with same X,Z
-    if (mFlags & fEnableHopping)
-        return hop;
-
-    return -1;
-}
-
-
-int World::getAdjoiningRoom(int index,
-        float x, float y, float z,
-        float x2, float y2, float z2)
-{
-    room_mesh_t *room = mRooms[index];
-    portal_t * portal;
-    vec3_t intersect, p1, p2;
-
-
-    p1[0] = x;  p1[1] = y;  p1[2] = z;
-    p2[0] = x2; p2[1] = y2; p2[2] = z2;
-
-    if (room)
-    {
-        for (room->portals.start(); room->portals.forward();
-                room->portals.next())
-        {
-            portal = room->portals.current();
-
-            if (!portal)
-                continue;
-
-            if (helIntersectionLineAndPolygon(intersect, p1, p2, // 4,
-                        portal->vertices))
-            {
-                return portal->adjoining_room;
-            }
-        }
-    }
-
-    return -1;
-}
-
-
-int World::getSector(int room, float x, float z, float *floor, float *ceiling)
-{
-    room_mesh_t *r;
-    sector_t * s;
-    int sector;
-
-
-    r = mRooms[room];
-
-    if (!r)
-        return -1;
-
-    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
-            (((int)z - (int)r->pos[2]) / 1024));
-
-    if (sector > -1)
-    {
-        s = r->sectors[sector];
-
-        if (!s)
-            return -1;
-
-        *floor = s->floor;
-        *ceiling = s->ceiling;
-    }
-
-    return sector;
-}
-
-
-int World::getSector(int room, float x, float z)
-{
-    int sector;
-    room_mesh_t *r;
-
-
-    r = mRooms[room];
-
-    if (!r)
-    {
-        return -1;
-    }
-
-    sector = (((((int)x - (int)r->pos[0]) / 1024) * r->numZSectors) +
-            (((int)z - (int)r->pos[2]) / 1024));
-
-    if (sector < 0)
-    {
-        return -1;
-    }
-
-    return sector;
-}
-
-
-unsigned int World::getRoomInfo(int room)
-{
-    room_mesh_t *r;
-
-
-    r = mRooms[room];
-
-    if (!r)
-    {
-        return 0;
-    }
-
-    return r->flags;
-}
-
-
-bool World::isWall(int room, int sector)
-{
-    room_mesh_t *r;
-    sector_t *sect;
-
-
-    r = mRooms[room];
-
-    if (!r)
-    {
-        return true;
-    }
-
-    sect = r->sectors[sector];
-
-    if (!sect)
-    {
-        return true;
-    }
-
-    return (sector > 0 && sect->wall);
-}
-
-
-bool World::getHeightAtPosition(int index, float x, float *y, float z)
-{
-    room_mesh_t *room = mRooms[index];
-
-#ifdef OBSOLETE_USING_BOXES
-    unsigned int i;
-    float zmax, xmax, zmin, xmin;
-
-
-    if (!room)
-    {
-        return false;
-    }
-
-    // Mongoose 2002.08.14, It's 0302 - give me a fucking break --
-    //   this works albeit poorly  =)
-    for (i = 0; (int)i < room->num_boxes; ++i)
-    {
-        xmax = room->boxes[i].c.pos[0];
-        xmin = room->boxes[i].a.pos[0];
-        zmax = room->boxes[i].c.pos[2];
-        zmin = room->boxes[i].a.pos[2];
-
-        if (x < xmax && x > xmin && z < zmax && z > zmin)
-        {
-            //printf("%f %f %f %f\n", xmax, xmin, zmax, zmin);
-
-            *y =  room->boxes[i].a.pos[1]; // hhmm...room->pos[1] +
-            return true;
-        }
-    }
-
-    return false;
-#else
-    int sector;
-    sector_t *sect;
-
-
-    if (!room)
-    {
-        return false;
-    }
-
-    // Mongoose 2002.08.14, Remember sector_z is width of sector array
-    sector = getSector(index, x, z);
-
-    sect = room->sectors[sector];
-
-    if (!sect)
-    {
-        return true;
-    }
-
-    *y = sect->floor;
-
-    return true;
-#endif
-}
-
-
-// Temp methods for rendering use until more refactoring is done
-#ifdef BAD_BLOOD
-model_mesh_t *World::getMesh(int index)
-{
-    return mMeshes[index];
-}
-
-skeletal_model_t *World::getModel(int index)
-{
-    return mModels[index];
-}
-
-room_mesh_t *World::getRoom(int index)
-{
-    return mRooms[index];
-}
-
-Vector<entity_t *> *World::getEntities()
-{
-    return &mEntities;
-}
-
-Vector<sprite_seq_t *> *World::getSprites()
-{
-    return &mSprites;
-}
-
-Vector<room_mesh_t *> *World::getRooms()
-{
-    return &mRooms;
-}
-#endif
-
-
-////////////////////////////////////////////////////////////
-// Public Mutators
-////////////////////////////////////////////////////////////
-
-void World::setFlag(WorldFlag flag)
-{
-    mFlags |= flag;
-}
-
-
-
-void World::clearFlag(WorldFlag flag)
-{
-    mFlags |= flag;
-    mFlags ^= flag;
-}
-
-
-void World::destroy()
-{
-    // Add some locking to check use state first
-    if (!mClearLock)
-    {
-        clear();
-    }
-}
-
-
-void World::addRoom(room_mesh_t *room)
-{
-    mClearLock = false;
-    mRooms.pushBack(room);
-}
-
-
-void World::addMesh(model_mesh_t *mesh)
-{
-    if (mesh)
-    {
-        mClearLock = false;
-        mMeshes.pushBack(mesh);
-    }
-}
-
-
-void World::addEntity(entity_t *e)
-{
-    if (e)
-    {
-        mClearLock = false;
-        e->master = 0x0;
-        e->moveType = worldMoveType_walk; // Walk
-        e->room = getRoomByLocation(e->pos[0], e->pos[1], e->pos[2]);
-        mEntities.pushBack(e);
-    }
-}
-
-
-int World::addModel(skeletal_model_t *model)
-{
-    if (model)
-    {
-        mClearLock = false;
-        mModels.pushBack(model);
-        return mModels.end();
-    }
-
-    return -1;
-}
-
-
-void World::addSprite(sprite_seq_t *sprite)
-{
-    if (sprite)
-    {
-        mClearLock = false;
-        mSprites.pushBack(sprite);
-    }
-}
-
-
-void World::moveEntity(entity_t *e, char movement)
-{
-    const float moved = 180.0f;
-    const float testd = 220.0f;
-    const float camHeight = 8.0f;
-    float x, y, z, pitch, h, floor, ceiling;
-    int room, sector;
-    bool wall;
-    unsigned int roomFlags;
-
-
-    if (!e)
-    {
-        return;
-    }
-
-    switch (e->moveType)
-    {
-        case worldMoveType_walkNoSwim:
-        case worldMoveType_walk:
-            pitch = 0.0f;  // in the future pitch could control jump up blocks here
-            break;
-
-        case worldMoveType_noClipping:
-        case worldMoveType_fly:
-        case worldMoveType_swim:
-            pitch = e->angles[2];
-            break;
-    }
-
-    switch (movement)
-    {
-        case 'f':
-            x = e->pos[0] + (testd * sinf(e->angles[1]));
-            y = e->pos[1] + (testd * sinf(pitch));
-            z = e->pos[2] + (testd * cosf(e->angles[1]));
-            break;
-        case 'b':
-            x = e->pos[0] - (testd * sinf(e->angles[1]));
-            y = e->pos[1] - (testd * sinf(pitch));
-            z = e->pos[2] - (testd * cosf(e->angles[1]));
-            break;
-        case 'l':
-            x = e->pos[0] - (testd * sinf(e->angles[1] + 90.0f));
-            y = e->pos[1];
-            z = e->pos[2] - (testd * cosf(e->angles[1] + 90.0f));
-            break;
-        case 'r':
-            x = e->pos[0] + (testd * sinf(e->angles[1] + 90.0f));
-            y = e->pos[1];
-            z = e->pos[2] + (testd * cosf(e->angles[1] + 90.0f));
-            break;
-        default:
-            return;
-    }
-
-    //room = getRoomByLocation(x, y, z);
-    room = getRoomByLocation(e->room, x, y, z);
-
-    if (room == -1) // Will we hit a portal?
-    {
-#define ADJ_ROOM_CHECK
-#ifdef ADJ_ROOM_CHECK
-        room = getAdjoiningRoom(e->room,
-                e->pos[0],  e->pos[1], e->pos[2],
-                x, y, z);
-#else
-        if (!mFlags & fEnableHopping)
-        {
-            mFlags |= fEnableHopping;
-            room = getRoomByLocation(e->room, x, y, z);
-            printf("Hopped\n");
-            mFlags ^= fEnableHopping;
-        }
-
-        //room = getRoomByLocation(x, y, z);
-#endif
-
-        if (room > -1)
-        {
-            printf("Crossing from room %i to %i\n", e->room, room);
-        }
-    }
-
-    roomFlags = getRoomInfo(room);
-    sector = getSector(room, x, z, &floor, &ceiling);
-    wall = isWall(room, sector);
-
-    // If you're underwater you may want to swim  =)
-    // ...if you're worldMoveType_walkNoSwim, you better hope it's shallow
-    if (roomFlags & roomFlag_underWater && e->moveType == worldMoveType_walk)
-    {
-        e->moveType = worldMoveType_swim;
-    }
-
-    // Don't swim on land
-    if (!(roomFlags & roomFlag_underWater) && e->moveType == worldMoveType_swim)
-    {
-        e->moveType = worldMoveType_walk;
-    }
-
-    // Mongoose 2002.09.02, Add check for room -> room transition
-    //   ( Only allow by movement between rooms by using portals )
-    if (((e->moveType == worldMoveType_noClipping) ||
-                (e->moveType == worldMoveType_fly) ||
-                (e->moveType == worldMoveType_swim)) ||
-            ((room > -1) && (!wall)))
-    {
-        e->room = room;
-
-        switch (movement)
-        {
-            case 'f':
-                x = e->pos[0] + (moved * sinf(e->angles[1]));
-                y = e->pos[1] + (moved * sinf(pitch));
-                z = e->pos[2] + (moved * cosf(e->angles[1]));
-                break;
-            case 'b':
-                x = e->pos[0] - (moved * sinf(e->angles[1]));
-                y = e->pos[1] - (moved * sinf(pitch));
-                z = e->pos[2] - (moved * cosf(e->angles[1]));
-                break;
-            case 'l':
-                x = e->pos[0] - (moved * sinf(e->angles[1] + 90.0f));
-                z = e->pos[2] - (moved * cosf(e->angles[1] + 90.0f));
-                break;
-            case 'r':
-                x = e->pos[0] + (moved * sinf(e->angles[1] + 90.0f));
-                z = e->pos[2] + (moved * cosf(e->angles[1] + 90.0f));
-                break;
-        }
-
-        /*! \fixme Test for vector (move vector) / plane (portal) collision here
-         * to see if we need to switch rooms... man...
-         */
-
-        h = y;
-        getHeightAtPosition(room, x, &h, z);
-
-        switch (e->moveType)
-        {
-            case worldMoveType_fly:
-            case worldMoveType_swim:
-#ifdef DIVE_GAP
-                // Clips to top of water, waiting for DIVE event
-                if (h < floor)
-                    e->pos[1] = floor;
-                else if (h > ceiling)
-                    e->pos[1] = ceiling;
-                else
-                    e->pos[1] = y;
-#endif
-
-                // Don't fall out of world, avoid a movement that does
-                if (h > y - camHeight)
-                {
-                    e->pos[0] = x;
-                    e->pos[1] = y;
-                    e->pos[2] = z;
-                }
-                break;
-            case worldMoveType_walk:
-            case worldMoveType_walkNoSwim:
-                y = e->pos[1];  // Override vector movement walking ( er, not pretty )
-
-                // Now fake gravity
-                // Mongoose 2002.08.14, Remember TR is upside down ( you fall 'up' )
-
-                //ddist = h - e->pos[1];
-
-                // This is to force false gravity, by making camera stay on ground
-                e->pos[1] = h; //roomFloor->bbox_min[1];
-
-                // Check for camera below terrian and correct
-                if (e->pos[1] < h - camHeight)
-                {
-                    e->pos[1] = h - camHeight;
-                }
-
-                e->pos[0] = x;
-                e->pos[2] = z;
-                break;
-            case worldMoveType_noClipping:
-                e->pos[0] = x;
-                e->pos[1] = y;
-                e->pos[2] = z;
-        }
-
-#ifdef OBSOLETE
-        m_text->SetString(1,"Room %2i  Sector %2i %sPos %.0f %.0f %.0f Yaw %.0f",
-                room, sector,
-                wall ? " Wall " : " ",
-                e->pos[0], e->pos[1], e->pos[2], e->angles[1]);
-#endif
-    }
-    else
-    {
-        e->moving = false;
-        return;
-    }
-
-    e->room = room;
-    e->moving = true;
-}
-
-
-////////////////////////////////////////////////////////////
-// Private Accessors
-////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////
-// Private Mutators
-////////////////////////////////////////////////////////////
-
-void World::clear()
-{
-    room_mesh_t *room;
-    model_mesh_t *mesh;
-    sprite_seq_t *sprite;
-    skeletal_model_t *model;
-    bone_frame_t *boneframe;
-    bone_tag_t *tag;
-    animation_frame_t *animation;
-    List<skeletal_model_t *> cache;
-
-
-    mClearLock = true;
-
-    mEntities.erase();
-
-    for (mRooms.start(); mRooms.forward(); mRooms.next())
-    {
-        room = mRooms.current();
-
-        if (room)
-        {
-            room->portals.erase();
-            room->models.erase();
-            room->sprites.erase();
-            room->sectors.erase();
-            room->boxes.erase();
-        }
-    }
-
-    mRooms.erase();
-
-    for (mMeshes.start(); mMeshes.forward(); mMeshes.next())
-    {
-        mesh = mMeshes.current();
-
-        if (!mesh)
-            continue;
-
-        for (mesh->texturedTriangles.start();
-                mesh->texturedTriangles.forward();
-                mesh->texturedTriangles.next())
-        {
-            if (mesh->texturedTriangles.current())
-                delete mesh->texturedTriangles.current();
-        }
-
-        for (mesh->coloredTriangles.start(); mesh->coloredTriangles.forward();
-                mesh->coloredTriangles.next())
-        {
-            if (mesh->coloredTriangles.current())
-                delete mesh->coloredTriangles.current();
-        }
-
-        for (mesh->texturedRectangles.start();
-                mesh->texturedRectangles.forward();
-                mesh->texturedRectangles.next())
-        {
-            if (mesh->texturedRectangles.current())
-                delete mesh->texturedRectangles.current();
-        }
-
-        for (mesh->coloredRectangles.start(); mesh->coloredRectangles.forward();
-                mesh->coloredRectangles.next())
-        {
-            if (mesh->coloredRectangles.current())
-                delete mesh->coloredRectangles.current();
-        }
-
-        if (mesh->vertices)
-            delete [] mesh->vertices;
-
-        if (mesh->colors)
-            delete [] mesh->colors;
-
-        if (mesh->normals)
-            delete [] mesh->normals;
-
-        delete mesh;
-    }
-
-    mMeshes.clear();
-
-    for (mSprites.start(); mSprites.forward(); mSprites.next())
-    {
-        sprite = mSprites.current();
-
-        if (!sprite)
-            continue;
-
-        if (sprite->sprite)
-            delete [] sprite->sprite;
-
-        delete sprite;
-    }
-
-    mSprites.clear();
-
-    for (mModels.start(); mModels.forward(); mModels.next())
-    {
-        model = mModels.current();
-
-        if (!model)
-            continue;
-
-        // No smart pointers, so skip if deleted once  =)
-        if (!cache.SearchKey(model))
-        {
-            cache.Add(model);
-        }
-        else
-        {
-            continue;
-        }
-
-        for (model->animation.start(); model->animation.forward();
-                model->animation.next())
-        {
-            animation  = model->animation.current();
-
-            if (!animation)
-                continue;
-
-            for (animation->frame.start(); animation->frame.forward();
-                    animation->frame.next())
-            {
-                boneframe = animation->frame.current();
-
-                if (!boneframe)
-                    continue;
-
-                for (boneframe->tag.start(); boneframe->tag.forward();
-                        boneframe->tag.next())
-                {
-                    tag = boneframe->tag.current();
-
-                    if (!tag)
-                        continue;
-
-                    delete tag;
-                }
-
-                delete boneframe;
-            }
-
-            delete animation;
-        }
-
-        delete model;
-    }
-
-    mModels.clear();
-}
-

src/main.cpp

@@ -0,0 +1,30 @@
+/*!
+ * \file src/main.cpp
+ * \brief Where main() is
+ *
+ * \author xythobuz
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "config.h"
+
+void cleanupHandler() {
+
+}
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        // Use default rc file path
+    } else if (argc == 2) {
+        // Use provided rc file
+    } else {
+        printf("Usage:\n%s [/path/to/config.file]\n", argv[0]);
+        return 1;
+    }
+
+    atexit(cleanupHandler);
+
+    return 0;
+}

src/utils/CMakeLists.txt

@@ -1,11 +0,0 @@
-# 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

@@ -1,137 +0,0 @@
-/*!
- *
- * \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 "Vector3d.h"
-#include "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

@@ -1,171 +0,0 @@
-/*!
- * \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

@@ -1,382 +0,0 @@
-/*!
- * \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

@@ -1,33 +0,0 @@
-/*!
- * \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);
-}
-