Removed vec_t typedefs

ChangeLog.md

 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20140704 ]
+    * Removed unnecessary #include dependencies
+    * Removed vecX_t typedefs
+
     [ 20140703 ]
     * Removed SDL_GL_LoadLibrary() call and corresponding
       config file entry

include/Camera.h

 #ifndef _CAMERA_H_
 #define _CAMERA_H_
 
-#include "math/math.h"
 #include "math/Quaternion.h"
 
 /*!
      * \brief Get the target currently looked at
      * \param target where the target will be stored
      */
-    void getTarget(vec3_t target);
+    void getTarget(float target[3]);
 
     /*!
      * \brief Get angle/yaw of camera
      * \returns theta angle/yaw of camera
      */
-    vec_t getRadianYaw();
+    float getRadianYaw();
 
     /*!
      * \brief Get angle/pitch of camera
      * \returns phi angle/pitch of camera
      */
-    vec_t getRadianPitch();
+    float getRadianPitch();
 
     /*!
      * \brief Set current position
      * \param pos new position
      */
-    void setPosition(vec3_t pos);
+    void setPosition(float pos[3]);
 
-    void setSensitivityX(vec_t sens);
+    void setSensitivityX(float sens);
 
-    void setSensitivityY(vec_t sens);
+    void setSensitivityY(float sens);
 
     /*!
      * \brief Updates view target
 
 private:
 
-    void rotate(vec_t angle, vec_t x, vec_t y, vec_t z);
+    void rotate(float angle, float x, float y, float z);
 
     Quaternion mQ;         //!< Quaternion for rotation
-    vec4_t mPos;           //!< Location in 3 space (aka eye)
-    vec4_t mTarget;        //!< Postition we're looking at
-    vec_t mViewDistance;   //!< Distance from target
-    vec_t mTheta;          //!< View angle Y
-    vec_t mTheta2;         //!< View angle Z
-    vec_t mRotationDeltaX; //!< Horizontal mouse sensitivity
-    vec_t mRotationDeltaY; //!< Vertical mouse sensitivity
+    float mPos[4];         //!< Location in 3 space (aka eye)
+    float mTarget[4];      //!< Postition we're looking at
+    float mViewDistance;   //!< Distance from target
+    float mTheta;          //!< View angle Y
+    float mTheta2;         //!< View angle Z
+    float mRotationDeltaX; //!< Horizontal mouse sensitivity
+    float mRotationDeltaY; //!< Vertical mouse sensitivity
 };
 
 Camera &getCamera();

include/Console.h

 #ifndef _CONSOLE_H_
 #define _CONSOLE_H_
 
-#include <cstring>
 #include <vector>
 
 /*!

include/Entity.h

 #ifndef _ENTITY_H_
 #define _ENTITY_H_
 
-#include "math/math.h"
 #include "SkeletalModel.h"
 #include "TombRaider.h"
 
     MoveType getMoveType();
     void setMoveType(MoveType m);
     int getObjectId();
-    void setAngles(vec3_t a);
-    vec_t getPos(unsigned int i);
-    vec_t getAngle(unsigned int i);
+    void setAngles(float a[3]);
+    float getPos(unsigned int i);
+    float getAngle(unsigned int i);
     int getRoom();
 
     // Animation State
     void setIdleAnimation(unsigned int index);
 
 private:
-    vec3_t pos;
-    vec3_t angles;
+    float pos[3];
+    float angles[3];
     int room;
 
     unsigned int skeletalModel;

include/FontTRLE.h

 #ifndef _FONT_TRLE_H_
 #define _FONT_TRLE_H_
 
-#include "math/math.h"
 #include "Font.h"
 
 /*!

include/Game.h

 
 #include <vector>
 
-#include "Camera.h"
 #include "Entity.h"
-#include "Render.h"
 #include "TombRaider.h"
-#include "World.h"
 
 /*!
  * \brief Game abstraction

include/Mesh.h

 #ifndef _MESH_H_
 #define _MESH_H_
 
-#include "math/math.h"
-
 /*!
  * \brief OpenGL Mesh
  */
         unsigned int cnum_alpha_triangles;
 
         unsigned int num_texcoors;
-        vec2_t *texcoors;
+        float **texcoors; // 2D
 
         unsigned int num_texcoors2;
-        vec2_t *texcoors2;
+        float **texcoors2; // 2D
 
         //! Arrays of triangle indices sorted by texture
         unsigned int num_triangles;
         unsigned int cnum_alpha_quads;
 
         unsigned int num_texcoors;
-        vec2_t *texcoors;
+        float **texcoors; // 2D
 
         unsigned int num_texcoors2;
-        vec2_t *texcoors2;
+        float **texcoors2; // 2D
 
         //! Arrays of rectangle indices sorted by texture
         unsigned int num_quads;
 
     void allocateVertices(unsigned int n);
 
-    void bufferColorArray(unsigned int colorCount, vec_t *colors);
+    void bufferColorArray(unsigned int colorCount, float *colors);
 
-    void bufferNormalArray(unsigned int normalCount, vec_t *normals);
+    void bufferNormalArray(unsigned int normalCount, float *normals);
 
     void bufferTriangles(unsigned int count,
-                            unsigned int *indices, vec_t *texCoords,
+                            unsigned int *indices, float *texCoords,
                             int *textures, unsigned int *flags);
 
-    void bufferVertexArray(unsigned int vertexCount, vec_t *vertices);
+    void bufferVertexArray(unsigned int vertexCount, float *vertices);
 
     void setColor(unsigned int index, float r, float g, float b, float a);
 
     void sortFacesByTexture();
 
     void addFace(int textureIndex, int textureIndexB, unsigned int flags,
-                    unsigned int vertexIndexCount, vec_t *vertexIndices);
+                    unsigned int vertexIndexCount, float *vertexIndices);
 
     void addTexTiledFace(int textureIndex, int textureIndexB,
                             unsigned int flags, unsigned int indexCount,
-                            vec_t *vertexIndices, vec_t *texcoords);
+                            float *vertexIndices, float *texcoords);
 
-    void bufferTexcoords(unsigned int texcoordCount, vec_t *texcoords);
+    void bufferTexcoords(unsigned int texcoordCount, float *texcoords);
 
     void duplicateArraysForTexTiledTexcoords();
 #endif
     MeshMode mMode;
 
     unsigned int mNumVertices;
-    vec3_t *mVertices; //!< XYZ
+    float **mVertices; //!< XYZ
 
     unsigned int mNumNormals;
-    vec3_t *mNormals; //!< IJK
+    float **mNormals; //!< IJK
 
     unsigned int mNumColors;
-    vec4_t *mColors; //!< RGBA
+    float **mColors; //!< RGBA
 
     unsigned int mNumTris;
     tris_t *mTris;
     int *mTriangleTextures;
     unsigned int *mTriangleIndices;
     unsigned int *mTriangleFlags;
-    vec_t *mTriangleTexCoordArray;
+    float *mTriangleTexCoordArray;
 
-    vec_t *mVertexArray;
-    vec_t *mNormalArray;
-    vec_t *mColorArray;
+    float *mVertexArray;
+    float *mNormalArray;
+    float *mColorArray;
 };
 
 #endif

include/OpenRaider.h

 #ifndef _OPENRAIDER_H_
 #define _OPENRAIDER_H_
 
-#include <sstream>
+#include <istream>
 #include <string>
-#include <vector>
-
-#include "Console.h"
-#include "Font.h"
-#include "Game.h"
-#include "Menu.h"
-#include "Sound.h"
 
 /*!
  * \brief Main Game Singleton

include/Room.h

 #define _ROOM_H_
 
 #include <vector>
-#include "math/math.h"
 #include "Mesh.h"
 #include "Sprite.h"
 #include "TombRaider.h"
 
     unsigned int getNumXSectors();
     unsigned int getNumZSectors();
-    void getPos(vec3_t p);
+    void getPos(float p[3]);
 
     void setFlags(unsigned int f);
     unsigned int getFlags();
     unsigned int flags;
     unsigned int numXSectors;
     unsigned int numZSectors;
-    vec3_t pos;
+    float pos[3];
 
     BoundingBox bbox;
     Mesh mesh;
     std::vector<Light *> lights;
 
     // Was used for "depth sorting" render list, but never assigned...?!
-    //vec_t dist; // Distance to near plane, move to room?
+    //float dist; // Distance to near plane, move to room?
 };
 
 #endif

include/RoomData.h

 
 #include <vector>
 #include <memory>
-#include "math/math.h"
 #include "math/Matrix.h"
 #include "TombRaider.h"
 
 class BoundingBox {
 public:
     BoundingBox();
-    void getBoundingBox(vec3_t box[2]);
-    void setBoundingBox(vec3_t min, vec3_t max);
+    void getBoundingBox(float box[2][3]);
+    void setBoundingBox(float min[3], float max[3]);
     void display(bool points, const unsigned char c1[4], const unsigned char c2[4]);
-    bool inBox(vec_t x, vec_t y, vec_t z);
-    bool inBoxPlane(vec_t x, vec_t z);
+    bool inBox(float x, float y, float z);
+    bool inBoxPlane(float x, float z);
 
 private:
-    vec3_t a, b;
+    float a[3], b[3];
 };
 
 class Light {
 
     Light(TombRaider &tr, unsigned int room, unsigned int index);
 
-    void getPos(vec4_t p);
-    void getDir(vec3_t d);
-    vec_t getAtt();
-    void getColor(vec4_t c);
-    vec_t getCutoff();
+    void getPos(float p[4]);
+    void getDir(float d[3]);
+    float getAtt();
+    void getColor(float c[4]);
+    float getCutoff();
     LightType getType();
 
 private:
-    vec4_t pos; //! Light position in 3 space
-    vec3_t dir; //! Light direction
-    vec_t att;
-    vec4_t color; //! Color of light
-    vec_t cutoff; //! Fade out distance
+    float pos[4]; //! Light position in 3 space
+    float dir[3]; //! Light direction
+    float att;
+    float color[4]; //! Color of light
+    float cutoff; //! Fade out distance
     LightType type; //! Type of light
 };
 
 
 private:
     int index;
-    vec_t yaw;
-    vec3_t pos;
+    float yaw;
+    float pos[3];
 
     // ?
-    //vec3_t bbox[2];
+    //float bbox[2][3];
 };
 
 class Portal {
 public:
     Portal(TombRaider &tr, unsigned int room, unsigned int index, Matrix &transform);
 
-    void getVertices(vec3_t vert[4]);
+    void getVertices(float vert[4][3]);
     int getAdjoiningRoom();
 
 private:
-    vec3_t vertices[4];
-    vec3_t normal;
+    float vertices[4][3];
+    float normal[3];
     int adjoiningRoom;
 };
 
     Box(TombRaider &tr, unsigned int room, unsigned int index);
 
 private:
-    vec3_t a;
-    vec3_t b;
-    vec3_t c;
-    vec3_t d;
+    float a[3], b[3], c[3], d[3];
 };
 
 class Sector {
 public:
     Sector(TombRaider &tr, unsigned int room, unsigned int index);
-    vec_t getFloor();
-    vec_t getCeiling();
+    float getFloor();
+    float getCeiling();
     bool isWall();
 
 private:
-    vec_t floor;
-    vec_t ceiling;
+    float floor;
+    float ceiling;
     bool wall;
 };
 

include/SkeletalModel.h

 
 #include <vector>
 
-#include "math/math.h"
 #include "TombRaider.h"
 
 class BoneTag {
     BoneTag(TombRaider &tr, unsigned int index, unsigned int j, unsigned int *l, unsigned int frame_offset);
     void display();
 
-    void getOffset(vec3_t o);
-    void getRotation(vec3_t r);
+    void getOffset(float o[3]);
+    void getRotation(float r[3]);
     char getFlag();
 
 private:
     int mesh;
-    vec3_t off;
-    vec3_t rot;
+    float off[3];
+    float rot[3];
     char flag;
 };
 
     BoneFrame(TombRaider &tr, unsigned int index, unsigned int frame_offset);
     ~BoneFrame();
 
-    void getPosition(vec3_t p);
+    void getPosition(float p[3]);
 
     unsigned int size();
     BoneTag &get(unsigned int i);
 
 private:
-    vec3_t pos;
+    float pos[3];
     std::vector<BoneTag *> tag;
 };
 
 
     int getId();
     void setPigTail(bool b);
-    void setPonyPos(vec_t x, vec_t y, vec_t z, vec_t angle);
+    void setPonyPos(float x, float y, float z, float angle);
 
     unsigned int size();
     AnimationFrame &get(unsigned int i);
     bool tr4Overlay;
     bool pigtails;
     int ponytailId;
-    vec3_t ponytail;
+    float ponytail[3];
     int ponytailMeshId;
     unsigned int ponytailNumMeshes;
-    vec_t ponytailAngle;
-    vec_t ponyOff;
-    vec_t ponyOff2;
+    float ponytailAngle;
+    float ponyOff;
+    float ponyOff2;
     std::vector<AnimationFrame *> animation;
 };
 

include/Sprite.h

 #ifndef _SPRITE_H_
 #define _SPRITE_H_
 
-#include "math/math.h"
 #include "TombRaider.h"
 
 class Sprite {
     void display();
 
 private:
-    vec3_t vertex[4];
-    vec2_t texel[4];
-    vec3_t pos;
-    vec_t radius;     //!< \fixme yeah, I know (I don't? --xythobuz)
+    float vertex[4][3];
+    float texel[4][2];
+    float pos[3];
+    float radius; //!< \fixme yeah, I know (I don't? --xythobuz)
     int texture;
 };
 

include/StaticMesh.h

 #define _STATIC_MODEL_H_
 
 #include <vector>
-#include "math/math.h"
 #include "TombRaider.h"
 
 class TexturedTriangle {
 public:
-    TexturedTriangle(int i[3], vec_t s[6], int tex, unsigned short trans);
-    void display(vec_t *vertices, vec_t *colors, vec_t *normals);
+    TexturedTriangle(int i[3], float s[6], int tex, unsigned short trans);
+    void display(float *vertices, float *colors, float *normals);
 
 private:
     int index[3];
-    vec_t st[6];
+    float st[6];
     int texture;
     unsigned short transparency;
 };
     StaticMesh(TombRaider &tr, unsigned int index);
     ~StaticMesh();
     void display();
-    vec_t getRadius();
+    float getRadius();
 
 private:
     bool dontshow;
-    vec3_t center;
-    vec_t radius;
+    float center[3];
+    float radius;
 
     unsigned int vertexCount;
     unsigned int colorCount;
     unsigned int normalCount;
 
-    vec_t *vertices;
-    vec_t *colors;
-    vec_t *normals;
+    float *vertices;
+    float *colors;
+    float *normals;
 
     std::vector<TexturedTriangle *> triangles;
 };

include/ViewVolume.h

 #define _VIEWVOLUME_H_
 
 #include "math/Matrix.h"
-#include "RoomData.h"
 
 /*!
  * \brief Viewing Volume for culling use
      * \param z Z coordinate of point
      * \returns true if point in view volume
      */
-    bool isPointInFrustum(vec_t x, vec_t y, vec_t z);
+    bool isPointInFrustum(float x, float y, float z);
 
     /*!
      * \brief Check if bounding sphere is in view volume
      * \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);
+    bool isSphereInFrustum(float x, float y, float z, float radius);
 
     /*!
      * \brief Check if bounding box is in view volume
      * \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);
+    bool isBboxInFrustum(float min[3], float max[3]);
 
     /*!
      * \brief Distance to Bounding 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);
+    float getDistToSphereFromNear(float x, float y, float z, float radius);
 
     /*!
      * \brief Distance to Bounding box
      * \param max maximum point of a valid abstract bounding box
      * \returns distance to abstract box bounding volume
      */
-    vec_t getDistToBboxFromNear(const vec3_t min, const vec3_t max);
+    float getDistToBboxFromNear(const float min[3], const float max[3]);
 
     /*!
      * \brief Get a copy of the view volume
      * \param frustum where frustum will be stored
      */
-    void getFrustum(vec_t frustum[6][4]);
+    void getFrustum(float 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);
+    void getPlane(ViewVolumeSide p, float plane[4]);
 
     /*!
      * \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);
+    void updateFrame(float proj[16], float mdl[16]);
 
     /*!
      * \brief Updates view volume for this frame.
      * \brief Set this class' model matrix
      * \param mdl new model matrix
      */
-    void setModel(matrix_t mdl);
+    void setModel(float mdl[16]);
 
     /*!
      * \brief Set this class' projection matrix
      * \param proj new projection matrix
      */
-    void setProjection(matrix_t proj);
+    void setProjection(float proj[16]);
 
 private:
 
     Matrix mProjection;   //!< Projection matrix
     Matrix mModel;        //!< Model matrix
     Matrix mClip;         //!< Clipping matrix
-    vec_t mFrustum[6][4]; //!< View volume
+    float mFrustum[6][4]; //!< View volume
 };
 
 #endif

include/Window.h

 #ifndef _WINDOW_H_
 #define _WINDOW_H_
 
-#include <ctime>
-
 /*!
  * \brief Windowing interface
  */
 class Window {
 public:
 
-    /*!
-     * \brief Deconstructs an object of Window
-     */
-    virtual ~Window();
+    virtual ~Window() {}
 
     virtual void setSize(unsigned int width, unsigned int height) = 0;
 
 
     virtual void setTextInput(bool on) = 0;
 
-    virtual void delay(clock_t ms) = 0;
+    virtual void delay(unsigned int ms) = 0;
 
     virtual void swapBuffersGL() = 0;
 

include/WindowSDL.h

 
     virtual void setTextInput(bool on);
 
-    virtual void delay(clock_t ms);
+    virtual void delay(unsigned int ms);
 
     virtual void swapBuffersGL();
 

include/World.h

 #ifndef _WORLD_H_
 #define _WORLD_H_
 
-#include <list>
 #include <vector>
 
 #include "Entity.h"

include/math/Matrix.h

      * \brief Constructs an object of Matrix
      * \param mat Matrix as data source
      */
-    Matrix(matrix_t mat);
+    Matrix(float mat[16]);
 
     /*!
      * \brief Constructs an object of Matrix
      * \brief Returns this matrix copy
      * \param mat target
      */
-    void getMatrix(matrix_t mat);
+    void getMatrix(float mat[16]);
 
     /*!
      * \brief Returns this matrix transposed
      * \param mat target
      */
-    void getTransposeMatrix(matrix_t mat);
+    void getTransposeMatrix(float mat[16]);
 
     /*!
      * \brief Returns this matrix inverted
      * \param mat target
      */
-    bool getInvert(matrix_t mat);
+    bool getInvert(float mat[16]);
 
     /*!
      * \brief Multiplies two matrices
      * \param v vector
      * \param result where the result will be stored, may be same as v
      */
-    void multiply4v(vec4_t v, vec4_t result);
+    void multiply4v(float v[4], float result[4]);
 
     /*!
      * \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);
+    void multiply3v(float v[3], float result[3]);
 
     /*!
      * \brief Prints matrix values to stdout
      * \fixme dangerous, scary, boo!
      * \param mat new matrix
      */
-    void setMatrix(matrix_t mat);
+    void setMatrix(float mat[16]);
 
     /*!
      * \brief Rotate object in 3D space
      * \param y y rotation in radians
      * \param z z rotation in radians
      */
-    void rotate(vec_t x, vec_t y, vec_t z);
+    void rotate(float x, float y, float z);
 
     /*!
      * \brief Rotate object in 3D space
      * \param xyz rotation in radians
      */
-    void rotate(const vec_t *xyz);
+    void rotate(const float *xyz);
 
     /*!
      * \brief Scale object in 3D space
      * \param y y scaling
      * \param z z scaling
      */
-    void scale(vec_t x, vec_t y, vec_t z);
+    void scale(float x, float y, float z);
 
     /*!
      * \brief Scale object in 3D space
      * \param xyz scaling factors
      */
-    void scale(const vec_t *xyz);
+    void scale(const float *xyz);
 
     /*!
      * \brief Translate (move) object in 3D space
      * \param y y translation
      * \param z z translation
      */
-    void translate(vec_t x, vec_t y, vec_t z);
+    void translate(float x, float y, float z);
 
     /*!
      * \brief Translate (move) object in 3D space
      * \param xyz translations
      */
-    void translate(const vec_t *xyz);
+    void translate(const float *xyz);
 
     /*!
      * \brief Transpose this matrix
      */
     void transpose();
 
-    matrix_t mMatrix; //!< Data model, moved public for faster external renderer feedback use
+    float mMatrix[16]; //!< Data model, moved public for faster external renderer feedback use
 
 private:
 
      * \param source source
      * \param dest destination
      */
-    static void copy(matrix_t source, matrix_t dest);
+    static void copy(float source[16], float dest[16]);
 
     /*!
      * \brief Multiplies matrices a and b. Neither a or b is also the result.
      * \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);
+    static void multiply(const float a[16], const float b[16], float result[16]);
 };
 
 #endif

include/math/Quaternion.h

      * \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);
+    Quaternion(float w, float x, float y, float z);
 
     /*!
      * \brief Constructs an object of Quaternion
      * \param v contents of new Quaternion
      */
-    Quaternion(vec4_t v);
+    Quaternion(float v[4]);
 
     /*!
      * \brief Get column order matrix equivalent of this quaternion
      * \param m where matrix will be stored
      */
-    void getMatrix(matrix_t m);
+    void getMatrix(float m[16]);
 
     /*!
      * \brief Multiplies this quaternion.
      * \param s scaling factor
      * \returns Scaled result of this quaternion
      */
-    Quaternion scale(vec_t s);
+    Quaternion scale(float s);
 
     /*!
      * \brief Inverse this quaternion
      * \param b second argument to dot product
      * \returns dot product between a and b quaternions
      */
-    static vec_t dot(Quaternion a, Quaternion b);
+    static float dot(Quaternion a, Quaternion b);
 
     /*!
      * \brief Magnitude of this quaternion
      * \returns Magnitude of this quaternion
      */
-    vec_t magnitude();
+    float magnitude();
 
     /*!
      * \brief Interpolates between a and b rotations.
      * \param time time argument for slerp
      * \returns resultant quaternion
      */
-    static Quaternion slerp(Quaternion a, Quaternion b, vec_t time);
+    static Quaternion slerp(Quaternion a, Quaternion b, float time);
 
     /*!
      * \brief Sets this quaternion to identity
      * \param y new Y coordinate
      * \param z new Z coordinate
      */
-    void set(vec_t angle, vec_t x, vec_t y, vec_t z);
+    void set(float angle, float x, float y, float z);
 
     /*!
      * \brief Normalize this quaternion
      * \brief Sets matrix equivalent of this quaternion
      * \param m matrix in valid column order
      */
-    void setByMatrix(matrix_t m);
+    void setByMatrix(float m[16]);
 
 private:
 
      */
     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
+    float mW; //!< Quaternion, W part
+    float mX; //!< Quaternion, X part
+    float mY; //!< Quaternion, Y part
+    float mZ; //!< Quaternion, Z part
 };
 
 #endif

include/math/Vector3d.h

      * \brief Constructs an object of Vector3d
      * \param v data to load into new Vector3d
      */
-    Vector3d(vec3_t v);
+    Vector3d(float v[3]);
 
     /*!
      * \brief Constructs an object of 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);
+    Vector3d(float x, float y, float z);
 
     /*!
      * \brief Constructs an object of Vector3d
      * \param v second argument
      * \returns dot product of u and v vectors
      */
-    static vec_t dot(const Vector3d &u, const Vector3d &v);
+    static float dot(const Vector3d &u, const Vector3d &v);
 
     /*!
      * \brief Calculate cross product
      * \brief Get Magnitude
      * \returns magnitude of this vector
      */
-    vec_t magnitude();
+    float magnitude();
 
     /*!
      * \brief Normalize
      * \param s scaling factor
      * \returns this vector multiplied with s
      */
-    Vector3d operator *(vec_t s);
+    Vector3d operator *(float s);
 
     /*!
      * \brief Scale this vactor
      * \param s inverse scaling factor
      * \returns this vector divided by s
      */
-    Vector3d operator /(vec_t s);
+    Vector3d operator /(float 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);
+    float operator *(const Vector3d &v);
 
     /*!
      * \brief Normalizes this vector
      * \param s scaling factor
      * \returns this vactor multiplied by s
      */
-    Vector3d &operator *=(vec_t s);
+    Vector3d &operator *=(float s);
 
-    vec3_t mVec; //!< Vector data
+    float mVec[3]; //!< Vector data
 };
 
 #endif

include/math/math.h

  * \author xythobuz
  */
 
-#include <cmath>
-
 #ifndef _MATH_MATH_H
 #define _MATH_MATH_H
 
 #ifndef M_PI
-#define M_PI 3.14159265358979323846
+#define OR_PI (3.14159265358979323846f) //!< pi
+#else
+#define OR_PI ((float)M_PI) //!< pi
 #endif
 
-#define OR_PI           ((float)M_PI) //!< pi
-#define OR_2_PI         (OR_PI * 2.0f) //!< pi*2
-#define OR_PI_OVER_4    (OR_PI / 4.0f) //!< pi/4
-#define OR_PI_OVER_180  (OR_PI / 180.0f) //!< pi/180
-#define OR_180_OVER_PI  (180.0f / OR_PI) //!< 180/pi
-
-#define OR_RAD_TO_DEG(x) ((x) * OR_180_OVER_PI) //!< Convert radians to degrees
-#define OR_DEG_TO_RAD(x) ((x) * OR_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!
+#define OR_RAD_TO_DEG(x) ((x) * (180.0f / OR_PI)) //!< Convert radians to degrees
+#define OR_DEG_TO_RAD(x) ((x) * (OR_PI / 180.0f)) //!< Convert degrees to radians
 
 /*!
  * \brief Compare two floats with an Epsilon.
  * \param b second float
  * \returns true if a and b are probably the same.
  */
-bool equalEpsilon(vec_t a, vec_t b);
+bool equalEpsilon(float a, float b);
 
 /*!
  * \brief Calculate Intersection of a line and a polygon
  * \param polygon polygon vertex array (0 to 2 are used)
  * \returns 0 if there is no intersection
  */
-int intersectionLinePolygon(vec3_t intersect, vec3_t p1, vec3_t p2, vec3_t *polygon);
+int intersectionLinePolygon(float intersect[3], float p1[3], float p2[3], float polygon[3][3]);
 
 /*!
  * \brief Calculate the length of a line segment / the distance between two points
  * \param b Second point
  * \returns distance/length
  */
-vec_t distance(const vec3_t a, const vec3_t b);
+float distance(const float a[3], const float b[3]);
 
 /*!
  * \brief Calculates the midpoint between two points / of a line segment
  * \param b Second point
  * \param mid Midpoint will be stored here
  */
-void midpoint(const vec3_t a, const vec3_t b, vec3_t mid);
+void midpoint(const float a[3], const float b[3], float mid[3]);
 
 /*!
  * \brief Calculates a pseudo-random number
  * \param to Upper bound
  * \returns random number
  */
-vec_t randomNum(vec_t from, vec_t to);
+float randomNum(float from, float to);
 
 #endif
 

include/utils/strings.h

 #define _UTILS_STRINGS_H_
 
 #include <cstdarg>
-#include <vector>
 
 char *stringRemoveQuotes(const char *s);
 

src/Camera.cpp

  */
 
 #include "global.h"
+#include <cmath>
 #include "math/Matrix.h"
 #include "Camera.h"
 
     mQ.setIdentity();
 }
 
-void Camera::getTarget(vec3_t target) {
+void Camera::getTarget(float target[3]) {
     target[0] = mTarget[0];
     target[1] = mTarget[1];
     target[2] = mTarget[2];
 }
 
-vec_t Camera::getRadianYaw() {
+float Camera::getRadianYaw() {
     return mTheta;
 }
 
-vec_t Camera::getRadianPitch() {
+float Camera::getRadianPitch() {
     return mTheta2;
 }
 
-void Camera::setPosition(vec3_t pos) {
+void Camera::setPosition(float pos[3]) {
     mPos[0] = pos[0];
     mPos[1] = pos[1];
     mPos[2] = pos[2];
 }
 
-void Camera::setSensitivityX(vec_t sens) {
+void Camera::setSensitivityX(float sens) {
     mRotationDeltaX = sens;
 }
 
-void Camera::setSensitivityY(vec_t sens) {
+void Camera::setSensitivityY(float sens) {
     mRotationDeltaY = sens;
 }
 

src/Command.cpp

  */
 
 #include <fstream>
-
-#include "WindowSDL.h"
+#include <sstream>
 
 #include "global.h"
+#include "Camera.h"
 #include "Console.h"
 #include "Entity.h"
 #include "Font.h"
 #include "Game.h"
 #include "math/math.h"
 #include "Menu.h"
+#include "Render.h"
 #include "Sound.h"
 #include "TombRaider.h"
+#include "Window.h"
+#include "World.h"
 #include "utils/strings.h"
 #include "utils/time.h"
 #include "OpenRaider.h"

src/Entity.cpp

  * \author xythobuz
  */
 
+#include <cmath>
+
 #include "global.h"
 #include "Console.h"
 #include "Entity.h"
 }
 
 bool Entity::operator<(Entity &o) {
-    vec_t distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0], pos[1], pos[2], 1.0f);
-    vec_t distB = getRender().mViewVolume.getDistToSphereFromNear(o.pos[0], o.pos[1], o.pos[2], 1.0f);
+    float distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0], pos[1], pos[2], 1.0f);
+    float distB = getRender().mViewVolume.getDistToSphereFromNear(o.pos[0], o.pos[1], o.pos[2], 1.0f);
     return (distA < distB);
 }
 
     return objectId;
 }
 
-void Entity::setAngles(vec3_t a) {
+void Entity::setAngles(float a[3]) {
     for (unsigned int i = 0; i < 3; i++)
         angles[i] = a[i];
 }
 
-vec_t Entity::getPos(unsigned int i) {
+float Entity::getPos(unsigned int i) {
     return pos[i];
 }
 
-vec_t Entity::getAngle(unsigned int i) {
+float Entity::getAngle(unsigned int i) {
     return angles[i];
 }
 

src/FontTRLE.cpp

 #define SCALING 2.0f
 
 void FontTRLE::writeChar(unsigned int index, unsigned int xDraw, FontString &s) {
-    int width = (int)(((vec_t)offsets[index][2]) * s.scale * SCALING);
-    int height = (int)(((vec_t)offsets[index][3]) * s.scale * SCALING);
-    int offset = (int)(((vec_t)offsets[index][4]) * s.scale * SCALING);
+    int width = (int)(((float)offsets[index][2]) * s.scale * SCALING);
+    int height = (int)(((float)offsets[index][3]) * s.scale * SCALING);
+    int offset = (int)(((float)offsets[index][4]) * s.scale * SCALING);
 
     // screen coordinates
     int xMin = xDraw;
     int yMax = yMin + height;
 
     // texture part
-    vec_t txMin = ((vec_t)offsets[index][0]) / 256.0f;
-    vec_t txMax = ((vec_t)(offsets[index][0] + offsets[index][2])) / 256.0f;
-    vec_t tyMin = ((vec_t)offsets[index][1]) / 256.0f;
-    vec_t tyMax = ((vec_t)(offsets[index][1] + offsets[index][3])) / 256.0f;
+    float txMin = ((float)offsets[index][0]) / 256.0f;
+    float txMax = ((float)(offsets[index][0] + offsets[index][2])) / 256.0f;
+    float tyMin = ((float)offsets[index][1]) / 256.0f;
+    float tyMax = ((float)(offsets[index][1] + offsets[index][3])) / 256.0f;
 
     // draw
     glBindTexture(GL_TEXTURE_2D, mFontTexture);
             continue; // skip unprintable chars
 
         writeChar((unsigned int)index, x, s);
-        x += (int)((vec_t)(offsets[index][2] + 1) * s.scale * SCALING); // width
+        x += (int)((float)(offsets[index][2] + 1) * s.scale * SCALING); // width
 
-        if (y < (unsigned int)(((vec_t)offsets[index][3]) * s.scale * SCALING))
-            y = (unsigned int)(((vec_t)offsets[index][3]) * s.scale * SCALING);
+        if (y < (unsigned int)(((float)offsets[index][3]) * s.scale * SCALING))
+            y = (unsigned int)(((float)offsets[index][3]) * s.scale * SCALING);
     }
 
     s.w = x - s.x;

src/Game.cpp

 #include <cstdlib>
 
 #include "global.h"
+#include "Camera.h"
 #include "Console.h"
 #include "Game.h"
 #include "OpenRaider.h"
+#include "Render.h"
 #include "Sound.h"
 #include "StaticMesh.h"
 #include "TextureManager.h"
+#include "World.h"
 #include "utils/strings.h"
 
 #include "games/TombRaider1.h"
                 getCamera().command(CAMERA_ROTATE_DOWN);
 
         // Fix Laras rotation
-        vec3_t angles = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
+        float angles[3] = { 0.0f, getCamera().getRadianYaw(), getCamera().getRadianPitch() };
         getLara().setAngles(angles);
     }
 }

src/Menu.cpp

 #include "Console.h"
 #include "OpenRaider.h"
 #include "utils/strings.h"
+#include "TombRaider.h"
 #include "Window.h"
 #include "Menu.h"
 

src/Mesh.cpp

 
 Mesh::~Mesh()
 {
+    for (unsigned int i = 0; i < mNumVertices; i++)
+        delete [] mVertices[i];
     delete [] mVertices;
     mVertices = NULL;
 
+    for (unsigned int i = 0; i < mNumNormals; i++)
+        delete [] mNormals[i];
     delete [] mNormals;
     mNormals = NULL;
 
+    for (unsigned int i = 0; i < mNumColors; i++)
+        delete [] mColors[i];
     delete [] mColors;
     mColors = NULL;
 
 {
     if (mColors)
     {
-        mNumColors = 0;
+        for (unsigned int i = 0; i < mNumColors; i++)
+            delete [] mColors[i];
         delete [] mColors;
+        mNumColors = 0;
     }
 
     if (!n)
     }
 
     mNumColors = n;
-    mColors = new vec4_t[mNumColors];
+    mColors = new float *[mNumColors];
+    for (unsigned int i = 0; i < mNumColors; i++)
+        mColors[i] = new float[4];
 }
 
 
 {
     if (mNormals)
     {
-        mNumNormals = 0;
+        for (unsigned int i = 0; i < mNumNormals; i++)
+            delete [] mNormals[i];
         delete [] mNormals;
+        mNumNormals = 0;
     }
 
     if (!n)
     }
 
     mNumNormals = n;
-    mNormals = new vec3_t[mNumNormals];
+    mNormals = new float *[mNumNormals];
+    for (unsigned int i = 0; i < mNumNormals; i++)
+        mNormals[i] = new float[3];
 }
 
 
 {
     if (mVertices)
     {
-        mNumVertices = 0;
+        for (unsigned int i = 0; i < mNumVertices; i++)
+            delete [] mVertices[i];
         delete [] mVertices;
+        mNumVertices = 0;
     }
 
     if (!n)
     }
 
     mNumVertices = n;
-    mVertices = new vec3_t[mNumVertices];
+    mVertices = new float *[mNumVertices];
+    for (unsigned int i = 0; i < mNumVertices; i++)
+        mVertices[i] = new float[3];
 }
 
 
-void Mesh::bufferColorArray(unsigned int colorCount, vec_t *colors)
+void Mesh::bufferColorArray(unsigned int colorCount, float *colors)
 {
     if (mColors)
     {
-        mNumColors = 0;
+        for (unsigned int i = 0; i < mNumColors; i++)
+            delete [] mColors[i];
         delete [] mColors;
+        mNumColors = 0;
     }
 
     if (!colorCount)
 }
 
 
-void Mesh::bufferNormalArray(unsigned int normalCount, vec_t *normals)
+void Mesh::bufferNormalArray(unsigned int normalCount, float *normals)
 {
     if (mNormals)
     {
-        mNumNormals = 0;
+        for (unsigned int i = 0; i < mNumNormals; i++)
+            delete [] mNormals[i];
         delete [] mNormals;
+        mNumNormals = 0;
     }
 
     if (!normalCount)
 
 
 void Mesh::bufferTriangles(unsigned int count,
-        unsigned int *indices, vec_t *texCoords,
+        unsigned int *indices, float *texCoords,
         int *textures, unsigned int *flags)
 {
 
 }
 
 
-void Mesh::bufferVertexArray(unsigned int vertexCount, vec_t *vertices)
+void Mesh::bufferVertexArray(unsigned int vertexCount, float *vertices)
 {
     if (mVertices)
     {
-        mNumVertices = 0;
+        for (unsigned int i = 0; i < mNumVertices; i++)
+            delete [] mVertices[i];
         delete [] mVertices;
+        mNumVertices = 0;
     }
 
     if (!vertexCount)

src/OpenRaider.cpp

 #include "global.h"
 #include "Console.h"
 #include "Game.h"
-#include "math/math.h"
 #include "Menu.h"
+#include "Render.h"
 #include "Sound.h"
 #include "TextureManager.h"
 #include "TombRaider.h"

src/Render.cpp

 #include <string.h>
 
 #include "global.h"
+#include "Camera.h"
 #include "Game.h"
 #include "OpenRaider.h"
 #include "Render.h"
 #include "utils/strings.h"
 #include "utils/tga.h"
 #include "Window.h"
+#include "World.h"
 
 Render::Render() {
     mSkyMesh = -1;
     for (unsigned int i = 0; i < room.sizeLights(); ++i)
     {
         Light &light = room.getLight(i);
-        vec4_t pos, color;
-        vec3_t dir;
+        float pos[4], color[4];
+        float dir[3];
         light.getPos(pos);
         light.getColor(color);
         light.getDir(dir);
             break;
     }
 
-    vec3_t curPos;
-    vec3_t camPos;
-    vec3_t atPos;
+    float curPos[3], camPos[3], atPos[3];
 
     curPos[0] = getGame().getLara().getPos(0);
     curPos[1] = getGame().getLara().getPos(1);
     curPos[2] = getGame().getLara().getPos(2);
-    vec_t yaw = getGame().getLara().getAngle(1);
+    float yaw = getGame().getLara().getAngle(1);
 
     // Mongoose 2002.08.24, New 3rd person camera hack
     camPos[0] = curPos[0] - (1024.0f * sinf(yaw));
 
 void Render::updateViewVolume()
 {
-    matrix_t proj;
-    matrix_t mdl;
-
+    float proj[16], mdl[16];
 
     glGetFloatv(GL_PROJECTION_MATRIX, proj);
     glGetFloatv(GL_MODELVIEW_MATRIX, mdl);
 }
 
 bool Render::isVisible(BoundingBox &box) {
-    vec3_t bbox[2];
+    float bbox[2][3];
     box.getBoundingBox(bbox);
 
     // For debugging purposes

src/Room.cpp

 #endif
 
 Room::Room(TombRaider &tr, unsigned int index) {
-    vec3_t box[2];
+    float box[2][3];
     Matrix transform;
 
     if (!tr.isRoomValid(index)) {
 //#define EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
 #ifdef EXPERIMENTAL_UNIFIED_ROOM_GEOMETERY
     unsigned int vertexCount, normalCount, colorCount, triCount;
-    vec_t *vertexArray;
-    vec_t *normalArray;
-    vec_t *colorArray;
+    float *vertexArray;
+    float *normalArray;
+    float *colorArray;
     unsigned int *indices, *fflags;
     float *texCoords;
     int *textures;
                 mesh.mTris[j].num_triangles = t;
                 mesh.mTris[j].triangles = new unsigned int[t*3];
                 mesh.mTris[j].num_texcoors = t * 3;
-                mesh.mTris[j].texcoors = new vec2_t[t * 3];
+                mesh.mTris[j].texcoors = new float *[t * 3];
+                for (unsigned int tmp = 0; tmp < (t * 3); tmp++)
+                    mesh.mTris[j].texcoors[tmp] = new float[2];
             }
 
             t = triangle_counter_alpha[i];
                 mesh.mTris[j].num_alpha_triangles = t;
                 mesh.mTris[j].alpha_triangles = new unsigned int[t*3];
                 mesh.mTris[j].num_texcoors2 = t * 3;
-                mesh.mTris[j].texcoors2 = new vec2_t[t * 3];
+                mesh.mTris[j].texcoors2 = new float *[t * 3];
+                for (unsigned int tmp = 0; tmp < (t * 3); tmp++)
+                    mesh.mTris[j].texcoors2[tmp] = new float[2];
             }
         }
 
                 mesh.mQuads[j].num_quads = r;
                 mesh.mQuads[j].quads = new unsigned int[r*4];
                 mesh.mQuads[j].num_texcoors = r * 4;
-                mesh.mQuads[j].texcoors = new vec2_t[r * 4];
+                mesh.mQuads[j].texcoors = new float *[r * 4];
+                for (unsigned int tmp = 0; tmp < (r * 4); tmp++)
+                    mesh.mQuads[j].texcoors[tmp] = new float[2];
             }
 
             r = rectangle_counter_alpha[i];
                 mesh.mQuads[j].num_alpha_quads = r;
                 mesh.mQuads[j].alpha_quads = new unsigned int[r*4];
                 mesh.mQuads[j].num_texcoors2 = r * 4;
-                mesh.mQuads[j].texcoors2 = new vec2_t[r * 4];
+                mesh.mQuads[j].texcoors2 = new float *[r * 4];
+                for (unsigned int tmp = 0; tmp < (r * 4); tmp++)
+                    mesh.mQuads[j].texcoors2[tmp] = new float[2];
             }
         }
     }
 
         for (unsigned int i = 0; i < sizePortals(); i++) {
             Portal &portal = getPortal(i);
-            vec3_t vertices[4];
+            float vertices[4][3];
             portal.getVertices(vertices);
 
             glBegin(GL_LINE_LOOP);
 
 int Room::getAdjoiningRoom(float x, float y, float z,
         float x2, float y2, float z2) {
-    vec3_t intersect, p1, p2;
-    vec3_t vertices[4];
+    float intersect[3], p1[3], p2[3];
+    float vertices[4][3];
 
     p1[0] = x;  p1[1] = y;  p1[2] = z;
     p2[0] = x2; p2[1] = y2; p2[2] = z2;
     return numZSectors;
 }
 
-void Room::getPos(vec3_t p) {
+void Room::getPos(float p[3]) {
     for (unsigned int i = 0; i < 3; i++)
         p[i] = pos[i];
 }

src/RoomData.cpp

     b[0] = b[1] = b[2] = 0;
 }
 
-void BoundingBox::getBoundingBox(vec3_t box[2]) {
+void BoundingBox::getBoundingBox(float box[2][3]) {
     box[0][0] = a[0];
     box[1][0] = b[0];
     box[0][1] = a[1];
     box[1][2] = b[2];
 }
 
-void BoundingBox::setBoundingBox(vec3_t min, vec3_t max) {
+void BoundingBox::setBoundingBox(float min[3], float max[3]) {
     a[0] = min[0];
     b[0] = max[0];
     a[1] = min[1];
     b[2] = max[2];
 }
 
-bool BoundingBox::inBox(vec_t x, vec_t y, vec_t z) {
+bool BoundingBox::inBox(float x, float y, float z) {
     return ((y > a[1]) && (y < b[1]) && inBoxPlane(x, z));
 }
 
-bool BoundingBox::inBoxPlane(vec_t x, vec_t z) {
+bool BoundingBox::inBoxPlane(float x, float z) {
     return ((x > a[0]) && (x < b[0])
             && (z > a[2]) && (z < b[2]));
 }
     //! \todo Light flags?
 }
 
-void Light::getPos(vec4_t p) {
+void Light::getPos(float p[4]) {
     p[0] = pos[0];
     p[1] = pos[1];
     p[2] = pos[2];
     p[3] = pos[3];
 }
 
-void Light::getDir(vec3_t d) {
+void Light::getDir(float d[3]) {
     d[0] = dir[0];
     d[1] = dir[1];
     d[2] = dir[2];
 }
 
-vec_t Light::getAtt() {
+float Light::getAtt() {
     return att;
 }
 
-void Light::getColor(vec4_t c) {
+void Light::getColor(float c[4]) {
     c[0] = color[0];
     c[1] = color[1];
     c[2] = color[2];
     c[3] = color[3];
 }
 
-vec_t Light::getCutoff() {
+float Light::getCutoff() {
     return cutoff;
 }
 
 }
 
 bool StaticModel::operator<(const StaticModel &other) {
-    vec_t distA, distB;
+    float distA, distB;
     distA = getRender().mViewVolume.getDistToSphereFromNear(pos[0],
             pos[1], pos[2], 128.0f);
     distB = getRender().mViewVolume.getDistToSphereFromNear(other.pos[0],
     }
 }
 
-void Portal::getVertices(vec3_t vert[4]) {
+void Portal::getVertices(float vert[4][3]) {
     for (unsigned int i = 0; i < 4; i++) {
         for (unsigned int j = 0; j < 3; j++) {
             vert[i][j] = vertices[i][j];
     wall = (sectorFlags & tombraiderSector_wall);
 }
 
-vec_t Sector::getFloor() {
+float Sector::getFloor() {
     return floor;
 }
 
-vec_t Sector::getCeiling() {
+float Sector::getCeiling() {
     return ceiling;
 }
 

src/SkeletalModel.cpp

     tr2_meshtree_t *meshtree = tr.MeshTree();
     unsigned short *frame = tr.Frame();
 
-    off[0] = 0.0;
-    off[1] = 0.0;
-    off[2] = 0.0;
+    off[0] = 0.0f;
+    off[1] = 0.0f;
+    off[2] = 0.0f;
     flag = 0x00;
-    rot[0] = 0.0;
-    rot[1] = 0.0;
-    rot[2] = 0.0;
+    rot[0] = 0.0f;
+    rot[1] = 0.0f;
+    rot[2] = 0.0f;
     mesh = moveable[index].starting_mesh + i;
 
     // Setup offsets to produce skeleton
     getWorld().getStaticMesh(mesh).display();
 }
 
-void BoneTag::getOffset(vec3_t o) {
+void BoneTag::getOffset(float o[3]) {
     o[0] = off[0];
     o[1] = off[1];
     o[2] = off[2];
 }
 
-void BoneTag::getRotation(vec3_t r) {
+void BoneTag::getRotation(float r[3]) {
     r[0] = rot[0];
     r[1] = rot[1];
     r[2] = rot[2];
     return *tag.at(i);
 }
 
-void BoneFrame::getPosition(vec3_t p) {
+void BoneFrame::getPosition(float p[3]) {
     p[0] = pos[0];
     p[1] = pos[1];
     p[2] = pos[2];
     AnimationFrame &anim = get(aframe);
     BoneFrame &boneframe = anim.get(bframe);
 
-    vec3_t pos;
+    float pos[3];
     boneframe.getPosition(pos);
     glTranslatef(pos[0], pos[1], pos[2]);
 
     for (unsigned int a = 0; a < boneframe.size(); a++) {
         BoneTag &tag = boneframe.get(a);
-        vec3_t rot, off;
+        float rot[3], off[3];
+
         tag.getRotation(rot);
         tag.getOffset(off);
 
     }
 }
 
-void SkeletalModel::setPonyPos(vec_t x, vec_t y, vec_t z, vec_t angle) {
+void SkeletalModel::setPonyPos(float x, float y, float z, float angle) {
     ponytail[0] = x;
     ponytail[1] = y;
     ponytail[2] = z;

src/Sprite.cpp

     vertex[2][2] = 0;
     vertex[3][2] = 0;
 
-    texel[3][0] = (vec_t)(x+width)/texelScale;
-    texel[3][1] = (vec_t)(y+height)/texelScale;
+    texel[3][0] = (float)(x+width)/texelScale;
+    texel[3][1] = (float)(y+height)/texelScale;
 
-    texel[2][0] = (vec_t)(x+width)/texelScale;
-    texel[2][1] = (vec_t)(y)/texelScale;
+    texel[2][0] = (float)(x+width)/texelScale;
+    texel[2][1] = (float)(y)/texelScale;
 
-    texel[1][0] = (vec_t)(x) /texelScale;
-    texel[1][1] = (vec_t)(y) /texelScale;
+    texel[1][0] = (float)(x) /texelScale;
+    texel[1][1] = (float)(y) /texelScale;
 
-    texel[0][0] = (vec_t)(x) / texelScale;
-    texel[0][1] = (vec_t)(y+height)/texelScale;
+    texel[0][0] = (float)(x) / texelScale;
+    texel[0][1] = (float)(y+height)/texelScale;
 
     texture = sprite->tile + getGame().getTextureStart();
     radius = width2 / 2.0f;

src/StaticMesh.cpp

 #include "utils/pixel.h"
 #include "StaticMesh.h"
 
-TexturedTriangle::TexturedTriangle(int i[3], vec_t s[6], int tex, unsigned short trans) {
+TexturedTriangle::TexturedTriangle(int i[3], float s[6], int tex, unsigned short trans) {
     index[0] = i[0];
     index[1] = i[1];
     index[2] = i[2];
     transparency = trans;
 }
 
-void TexturedTriangle::display(vec_t *vertices, vec_t *colors, vec_t *normals) {
+void TexturedTriangle::display(float *vertices, float *colors, float *normals) {
     assert(vertices != NULL);
 
     if ((getRender().getMode() != Render::modeWireframe)
     }
 }
 
-vec_t StaticMesh::getRadius() {
+float StaticMesh::getRadius() {
     return radius;
 }
 

src/TextureManager.cpp

 #include <stdarg.h>
 
 #include "global.h"
+#include "Console.h"
 #include "OpenRaider.h"
 #include "utils/pcx.h"
 #include "utils/pixel.h"

src/ViewVolume.cpp

     mFrustum[5][0] = mFrustum[5][1] = mFrustum[5][2] = mFrustum[5][3] = 0.0f;
 }
 
-bool ViewVolume::isPointInFrustum(vec_t x, vec_t y, vec_t z) {
+bool ViewVolume::isPointInFrustum(float x, float y, float 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 true;
 }
 
-bool ViewVolume::isSphereInFrustum(vec_t x, vec_t y, vec_t z, vec_t radius) {
+bool ViewVolume::isSphereInFrustum(float x, float y, float z, float radius) {
     for (unsigned int p = 0; p < 6; ++p) {
-        vec_t d = mFrustum[p][0] * x + mFrustum[p][1] * y + mFrustum[p][2] * z + mFrustum[p][3];
+        float 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) {
+bool ViewVolume::isBboxInFrustum(float min[3], float max[3]) {
     for (unsigned int p = 0; p < 6; ++p) {
         if (mFrustum[p][0] * min[0] +
                 mFrustum[p][1] * min[1] +
     return true;
 }
 
-vec_t ViewVolume::getDistToSphereFromNear(vec_t x, vec_t y, vec_t z, vec_t radius) {
-    vec_t d = 0.0;
+float ViewVolume::getDistToSphereFromNear(float x, float y, float z, float radius) {
+    float 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 d + radius;
 }
 
-vec_t ViewVolume::getDistToBboxFromNear(const vec3_t min, const vec3_t max) {
-    vec3_t center;
-    vec_t d, radius;
+float ViewVolume::getDistToBboxFromNear(const float min[3], const float max[3]) {
+    float center[3];
+    float d, radius;
 
     midpoint(min, max, center);
 
     return d + radius;
 }
 
-void ViewVolume::getFrustum(vec_t frustum[6][4]) {
+void ViewVolume::getFrustum(float 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) {
+void ViewVolume::getPlane(ViewVolumeSide p, float plane[4]) {
     for (unsigned int i = 0; i < 4; ++i) {
         plane[i] =  mFrustum[p][i];
     }
 }
 
-void ViewVolume::updateFrame(matrix_t proj, matrix_t mdl) {
+void ViewVolume::updateFrame(float proj[16], float mdl[16]) {
     setModel(mdl);
     setProjection(proj);
     updateClip();
     updateFrustum();
 }
 
-void ViewVolume::setModel(matrix_t mdl) {
+void ViewVolume::setModel(float mdl[16]) {
     mModel.setMatrix(mdl);
 }
 
-void ViewVolume::setProjection(matrix_t proj) {
+void ViewVolume::setProjection(float proj[16]) {
     mProjection.setMatrix(proj);
 }
 
 }
 
 void ViewVolume::updateFrustum() {
-    matrix_t clip;
-    vec_t t;
+    float clip[16];
+    float t;
 
     mClip.getMatrix(clip);
 

src/Window.cpp

 #include <cstdio>
 #include <cstring>
 #include <cstdarg>
+#include <cmath>
 
 #include "global.h"
 #include "math/math.h"
 #include "utils/strings.h"
 #include "Window.h"
 
-Window::~Window() {
-}
-
 unsigned int Window::getWidth() {
     return mWidth;
 }

src/WindowSDL.cpp

  */
 
 #include <cstdio>
+#include <ctime>
 
 #include "global.h"
 #include "OpenRaider.h"
         SDL_StopTextInput();
 }
 
-void WindowSDL::delay(clock_t ms) {
+void WindowSDL::delay(unsigned int ms) {
     assert(mInit == true);
 
     SDL_Delay(ms);

src/math/Matrix.cpp

     setIdentity();
 }
 
-Matrix::Matrix(matrix_t m) {
+Matrix::Matrix(float m[16]) {
     setMatrix(m);
 }
 
 Matrix::Matrix(Quaternion &q) {
-    matrix_t m;
+    float m[16];
     q.getMatrix(m);
     setMatrix(m);
 }
 
-bool Matrix::getInvert(matrix_t out) {
-    matrix_t m;
+bool Matrix::getInvert(float out[16]) {
+    float m[16];
 
 #ifdef COLUMN_ORDER
     getMatrix(m);
 #undef SWAP_ROWS
 }
 
-void Matrix::getMatrix(matrix_t mat) {
+void Matrix::getMatrix(float mat[16]) {
     copy(mMatrix, mat);
 }
 
-void Matrix::getTransposeMatrix(matrix_t m) {
+void Matrix::getTransposeMatrix(float m[16]) {
     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];
 }
 
 Vector3d Matrix::operator *(Vector3d v) {
-    vec_t x = v.mVec[0], y = v.mVec[1], z = v.mVec[2];
+    float 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],
 #endif
 }
 
-void Matrix::multiply3v(vec3_t v, vec3_t result) {
-    vec_t x = v[0], y = v[1], z = v[2];
+void Matrix::multiply3v(float v[3], float result[3]) {
+    float 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];
+void Matrix::multiply4v(float v[4], float result[4]) {
+    float 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;
     return false;
 }
 
-void Matrix::setMatrix(matrix_t mat) {
+void Matrix::setMatrix(float mat[16]) {
     copy(mat, mMatrix);
 }
 
     mMatrix[12] = 0; mMatrix[13] = 0; mMatrix[14] = 0; mMatrix[15] = 1;
 }
 
-void Matrix::scale(const vec_t *xyz) {
+void Matrix::scale(const float *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;
+void Matrix::scale(float sx, float sy, float sz) {
+    float smatrix[16];
+    float tmp[16];
 
     smatrix[ 0] = sx; smatrix[ 1] = 0;  smatrix[ 2] = 0;  smatrix[ 3] = 0;
     smatrix[ 4] = 0;  smatrix[ 5] = sy; smatrix[ 6] = 0;  smatrix[ 7] = 0;
     multiply(tmp, smatrix, mMatrix);
 }
 
-void Matrix::rotate(const vec_t *xyz) {
+void Matrix::rotate(const float *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;
+void Matrix::rotate(float ax, float ay, float az) {
+    float xmat[16], ymat[16], zmat[16], tmp[16], tmp2[16];
 
     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;
     multiply(tmp2, zmat, mMatrix);
 }
 
-void Matrix::translate(const vec_t *xyz) {
+void Matrix::translate(const float *xyz) {
     translate(xyz[0], xyz[1], xyz[2]);
 }
 
-void Matrix::translate(vec_t tx, vec_t ty, vec_t tz) {
-    matrix_t tmat, tmp;
+void Matrix::translate(float tx, float ty, float tz) {
+    float tmat[16], tmp[16];
 
     tmat[ 0]=1;  tmat[ 1]=0;  tmat[ 2]=0;  tmat[ 3]=0;
     tmat[ 4]=0;  tmat[ 5]=1;  tmat[ 6]=0;  tmat[ 7]=0;
     multiply(tmp, tmat, mMatrix);
 }
 
-void Matrix::copy(matrix_t source, matrix_t dest) {
+void Matrix::copy(float source[16], float dest[16]) {
     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) {
+void Matrix::multiply(const float a[16], const float b[16], float result[16]) {
     /* Generated code for matrix mult
      * Code used:
 

src/math/Quaternion.cpp

     mZ = 0;
 }
 
-Quaternion::Quaternion(vec_t w, vec_t x, vec_t y, vec_t z) {
+Quaternion::Quaternion(float w, float x, float y, float z) {
     mW = w;
     mX = x;
     mY = y;
     mZ = z;
 }
 
-Quaternion::Quaternion(vec4_t v) {
+Quaternion::Quaternion(float v[4]) {
     mW = v[0];
     mX = v[1];
     mY = v[2];
     mZ = v[3];
 }
 
-void Quaternion::getMatrix(matrix_t m) {
+void Quaternion::getMatrix(float m[16]) {
     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);
     return Quaternion(mW, -mX, -mY, -mZ);
 }
 
-Quaternion Quaternion::scale(vec_t s) {
+Quaternion Quaternion::scale(float s) {
     return Quaternion(mW * s, mX * s, mY * s, mZ * s);
 }
 
     return conjugate().scale(1/magnitude());
 }
 
-vec_t Quaternion::dot(Quaternion a, Quaternion b) {
+float 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() {
+float Quaternion::magnitude() {
     return sqrtf(dot(*this, *this));
 }
 
     mZ = 0.0;
 }
 
-void Quaternion::set(vec_t angle, vec_t x, vec_t y, vec_t z) {
-    vec_t temp, dist;
+void Quaternion::set(float angle, float x, float y, float z) {
+    float temp, dist;
 
     // Normalize
     temp = x*x + y*y + z*z;
 }
 
 void Quaternion::normalize() {
-    vec_t dist, square;
+    float dist, square;
 
     square = mX * mX + mY * mY + mZ * mZ + mW * mW;
 
     mZ = q.mZ;
 }
 
-Quaternion Quaternion::slerp(Quaternion a, Quaternion b, vec_t time) {
+Quaternion Quaternion::slerp(Quaternion a, Quaternion b, float time) {
     /*******************************************************************
      * Spherical Linear Interpolation algorthim
      *-----------------------------------------------------------------
      *
      *******************************************************************/
 
-    vec_t result, scaleA, scaleB;
+    float result, scaleA, scaleB;
     Quaternion i;
 
 
     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);
+        float theta = (float)acos(result);
+        float sinTheta = (float)sin(theta);
 
         // Calculate the scale for qA and qB, according to
         // the angle and it's sine value
     return (a.scale(scaleA) + b.scale(scaleB));
 }
 
-void Quaternion::setByMatrix(matrix_t matrix) {
+void Quaternion::setByMatrix(float matrix[16]) {
     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;

src/math/Vector3d.cpp

     mVec[0] = mVec[1] = mVec[2] = 0.0f;
 }
 
-Vector3d::Vector3d(vec3_t v) {
+Vector3d::Vector3d(float v[3]) {
     mVec[0] = v[0];
     mVec[1] = v[1];
     mVec[2] = v[2];
 }
 
-Vector3d::Vector3d(vec_t x, vec_t y, vec_t z) {
+Vector3d::Vector3d(float x, float y, float z) {
     mVec[0] = x;
     mVec[1] = y;
     mVec[2] = z;
     mVec[2] = v.mVec[2];
 }
 
-vec_t Vector3d::dot(const Vector3d &u, const Vector3d &v) {
+float 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]);
 }
 
             u.mVec[0] * v.mVec[1] - u.mVec[1] * v.mVec[0]);
 }
 
-vec_t Vector3d::magnitude() {
+float Vector3d::magnitude() {
     return sqrtf(mVec[0]*mVec[0] + mVec[1]*mVec[1] + mVec[2]*mVec[2]);
 }
 
 Vector3d Vector3d::unit() {
-    vec_t norm = magnitude();
+    float norm = magnitude();
 
     return Vector3d(mVec[0] / norm,
             mVec[1] / norm,
             -mVec[2]);
 }
 
-Vector3d Vector3d::operator *(vec_t s) {
+Vector3d Vector3d::operator *(float s) {
     return Vector3d(s * mVec[0],
             s * mVec[1],
             s * mVec[2]);
 }
 
-Vector3d Vector3d::operator /(vec_t s) {
+Vector3d Vector3d::operator /(float s) {
     return Vector3d(mVec[0] / s,
             mVec[1] / s,
             mVec[2] / s);
 }
 
-vec_t Vector3d::operator *(const Vector3d &v) {
+float Vector3d::operator *(const Vector3d &v) {
     return dot(*this, v);
 }
 
 void Vector3d::normalize() {
-    vec_t norm = magnitude();
+    float norm = magnitude();
 
     mVec[0] /= norm;
     mVec[1] /= norm;
     return *this;
 }
 
-Vector3d &Vector3d::operator *=(vec_t s) {
+Vector3d &Vector3d::operator *=(float s) {
     mVec[0] *= s;
     mVec[1] *= s;
     mVec[2] *= s;

src/math/math.cpp

  * \author xythobuz
  */
 
-#include <stdlib.h>
-#include <math.h>
+#include <cstdlib>
+#include <cmath>
 #include <float.h>
 #include <algorithm>
 
 #include "math/Matrix.h"
 #include "math/math.h"
 
-bool equalEpsilon(vec_t a, vec_t b) {
-    vec_t epsilon = FLT_EPSILON;
+bool equalEpsilon(float a, float b) {
+    float epsilon = FLT_EPSILON;
     if (fabs(a - b) <= (std::max(fabs(a), fabs(b)) * epsilon))
         return true;
     return false;
 }
 
-int intersectionLinePolygon(vec3_t intersect,
-        vec3_t p1, vec3_t p2, vec3_t *polygon) {
+int intersectionLinePolygon(float intersect[3],
+        float p1[3], float p2[3], float polygon[3][3]) {
     assert(polygon != NULL);
 
-    // vec3_t normal, a, b;
+    // float normal[3], a[3], b[3];
     Vector3d a, b, normal, pA, pB;
-    vec_t d, denominator, mu;
+    float d, denominator, mu;
 
 
     pA = Vector3d(p1);
     return 1;
 }
 
-vec_t distance(const vec3_t a, const vec3_t b) {
+float distance(const float a[3], const float b[3]) {
     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 midpoint(const vec3_t a, const vec3_t b, vec3_t mid) {
+void midpoint(const float a[3], const float b[3], float mid[3]) {
     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 randomNum(vec_t from, vec_t to) {
+float randomNum(float from, float to) {
     return from + ((to - from) * rand() / (RAND_MAX + 1.0f));
 }