Added Camera, Emitter, Mesh, Particle, ViewVolume

include/Camera.h

@@ -0,0 +1,194 @@
+/*!
+ * \file include/Camera.h
+ * \brief OpenGL camera class
+ *
+ * \author Mongoose
+ */
+#ifndef _CAMERA_H_
+#define _CAMERA_H_
+
+#include "math/math.h"
+#include "math/Matrix.h"
+#include "math/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

@@ -0,0 +1,179 @@
+/*!
+ * \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/Mesh.h

@@ -0,0 +1,169 @@
+/*!
+ * \file include/Mesh.h
+ * \brief OpenGL Mesh
+ *
+ * \author Mongoose
+ *
+ * \todo Unify the parallel systems here, arrays and the allocate/set
+ */
+
+#ifndef _MESH_H_
+#define _MESH_H_
+
+#include "math/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/Particle.h

@@ -0,0 +1,119 @@
+/*!
+ * \file include/Particle.h
+ * \brief Particle system base header
+ *
+ * \author Mongoose
+ */
+
+#ifndef _PARTICLE_H_
+#define _PARTICLE_H_
+
+#include "math/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/ViewVolume.h

@@ -0,0 +1,200 @@
+/*!
+ * \file include/ViewVolume.h
+ * \brief Viewing Volume for culling use
+ *
+ * \author Mongoose
+ */
+
+#ifndef _VIEWVOLUME_H_
+#define _VIEWVOLUME_H_
+
+#include "math/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

src/CMakeLists.txt

@@ -31,13 +31,18 @@ set (LIBS ${LIBS} ${ZLIB_LIBRARIES})
 #################################################################
 
 # Set Source files
+set (SRCS ${SRCS} "Camera.cpp")
 set (SRCS ${SRCS} "Console.cpp")
+set (SRCS ${SRCS} "Emitter.cpp")
 set (SRCS ${SRCS} "Game.cpp")
 set (SRCS ${SRCS} "main.cpp")
 set (SRCS ${SRCS} "Menu.cpp")
+set (SRCS ${SRCS} "Mesh.cpp")
 set (SRCS ${SRCS} "OpenRaider.cpp")
+set (SRCS ${SRCS} "Particle.cpp")
 set (SRCS ${SRCS} "Sound.cpp")
 set (SRCS ${SRCS} "TombRaider.cpp")
+set (SRCS ${SRCS} "ViewVolume.cpp")
 set (SRCS ${SRCS} "Window.cpp")
 
 # Select available Windowing library

src/Camera.cpp

@@ -0,0 +1,246 @@
+/*!
+ * \file src/Camera.cpp
+ * \brief OpenGL camera class
+ *
+ * \author Mongoose
+ */
+
+#include <stdio.h>
+#include <math.h>
+
+#include "Camera.h"
+
+Camera::Camera() {
+    mFlags = 0;
+    mViewDistance = 14.0f;
+    mTranslateDelta = 256.0f;
+    mRotateDelta = OR_DEG_TO_RAD(15.0f);
+    mRotateDelta2 = OR_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 OR_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 = OR_DEG_TO_RAD(angle);
+}
+
+void Camera::setSensitivityX(float angle) {
+    mRotateDelta = OR_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

@@ -0,0 +1,245 @@
+/*!
+ * \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/Mesh.cpp

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

@@ -0,0 +1,162 @@
+/*!
+ * \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/ViewVolume.cpp

@@ -0,0 +1,270 @@
+/*!
+ * \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;
+
+    midpoint(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 = distance(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;
+}
+