See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  Math Library
  Submitted by



Here's my hat in the ring for math libraries. It's the math system for the engine I'm currently developing. I'm posting it in the hopes that someone else may find it usefull, but because I also want people to nitpick about it, any errors I may have missed, and ways to improve it. I am still working on the classes and adding to it, so any help is, of course, appreciated. The engine also works standalone, the project included compiles as a static library, which can easily be linked into a project. The include files are all linked through the GEKXMath.h file, so you only have to include it. The source is also commented (decently), compatible with (and a project file for) DoXygen source commentor. So far, it sports quite a few features:
  • 2D/3D/4D vectors (seperate classes, I opted to seperate them instead of templating them so that I didn't have to specialize anything). I have overloaded basic operators for conveniance (like plus, minus, multiple, divide. I didn't want to overload actuall functions (like dot or cross product), because I felt it gets confusing to overload these, everyone has a different spin on what symbols to use.
  • A quaternion class, with everything I've found that I've needed (so far at least).
  • A 4x4 matrix class (and conversions between quaternions and matrices in the classes), with rotations, scaling, etc (everything a matrix should be able to do).
  • A plane class, simple so far, I've just starting adding interesection between containment objects.
  • A bounding sphere, and an axis aligned bounding box class, with intersections tests against themselves and each other.
  • A 6 plane view frustum class, and a function to generate the planes from a projection matrix, and visibility checks against points, bounding spheres, and axis aligned bounding boxes.

  • Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/GEKxMath.h] - (4,017 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEK_Math__
    #define __GEK_Math__
    /*! 
    	\author MoJo
        \file GEKXMath.h
        \brief GEKvX Math Main Header
    */

    /*! \mainpage GEKvX Math Library \section disclamer Disclamer Game Excelleration Kit vX

    <center><img src="..\..\hourglass.jpg" alt="HourGlass SoftWare"></center> Copyright (C) 2001 by HourGlass Software NonInc

    This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

    Please read the file LICENSE.TXT for additional details.

    <a href="http://www.doxygen.org>Doxygen</a> was used for all documentation. */


    #define _PI 3.14159265358979323846f //!< Extended floating point definition of PI #define _2_PI 6.28318530717958623200f //!< Extended floating point definition of (PI * 2) #define _PI_2 1.57079632679489661923f //!< Extended floating point definition of (PI / 2) #define _INV_PI 0.31830988618379069122f //!< Extended floating point definition of Inverse PI #define _DEGTORAD(x) (x * (_PI / 180.0f)) //!< Macro to convert degrees to radians #define _RADTODEG(x) (x * (180.0f / _PI)) //!< Macro to convert radians to degrees #define _EPSILON 1.0e-5f //!< Small offset to account for floating point error

    int __fastcall F2ID(float fValue); //!< Rounds a value down and returns the integer int __fastcall F2IU(float fValue); //!< Rounds a value up and returns the integer float __fastcall ABS(float fValue); //!< Returns the absolute value of a value float __fastcall SIN(float fValue); //!< Returns the sin of a value float __fastcall COS(float fValue); //!< Returns the cos of a value float TAN(float fValue); //!< Returns the tangent of a value float SQRT(float fValue); //!< Returns the square root of a value float __fastcall ISQRT(float fValue); //!< Returns the inverse square root of a value int NextSquare(int iValue); //!< Returns the next possible squared value

    template <typename CLASS> inline void SWAP(CLASS &kValueA, CLASS &kValueB) { CLASS kTemp = kValueA; kValueA = kValueB; kValueB = kTemp; }

    struct GEKVECTOR2; //!< 2D Vector Class struct GEKVECTOR3; //!< 3D Vector Class struct GEKVECTOR4; //!< 4D Vector Class struct GEKQUATERNION; //!< 4D Quaternion Class struct GEKMATRIX; //!< 4x4 Matrix Class struct GEKPLANE; //!< Standard Plane Equation typedef GEKVECTOR4 GEKCOLOR; //!< RGBA Color Class struct GEKSPHERE; //!< Basic Bounding Sphere struct GEKAABB; //!< Basic Axis Aligned Bounding Box struct GEKRAY; //!< Basic Ray class

    #include ".\Include\GEKRect.h" #include ".\Include\GEKVector2.h" #include ".\Include\GEKVector3.h" #include ".\Include\GEKVector4.h" #include ".\Include\GEKQuaternion.h" #include ".\Include\GEKMatrix.h" #include ".\Include\GEKPlane.h"

    #include ".\Include\GEKCurve.h" #include ".\Include\GEKContain.h" #include ".\Include\GEKFrustum.h"

    #include ".\Inline\GEKRect.inl" #include ".\Inline\GEKVector2.inl" #include ".\Inline\GEKVector3.inl" #include ".\Inline\GEKVector4.inl" #include ".\Inline\GEKQuaternion.inl" #include ".\Inline\GEKMatrix.inl" #include ".\Inline\GEKPlane.inl"

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKContain.h] - (1,294 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKContain__
    #define __GEKContain__
    /*! 
    	\author MoJo
        \file GEKContain.h
        \brief Basic Containment
    */

    struct GEKRAY { public: GEKVECTOR3 m_kOrigin; GEKVECTOR3 m_kVector;

    public: GEKRAY(void); GEKRAY(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kVector);

    inline float GetLength(void) { return m_kVector.GetLength(); }; inline GEKVECTOR3 GetEnd(void) { return (m_kOrigin + m_kVector); }; };

    struct GEKAABB { public: GEKVECTOR3 m_kMin; GEKVECTOR3 m_kMax;

    public: bool Collision(const GEKAABB &kAABB) const; bool Collision(const GEKSPHERE &kSphere) const;

    void Extend(const GEKVECTOR3 &kPoint); inline GEKVECTOR3 GetSize(void) { return (m_kMax - m_kMin); }; inline GEKVECTOR3 GetCenter(void) { return ((m_kMax + m_kMin) / 2.0f); }; };

    struct GEKSPHERE { public: GEKVECTOR3 m_kOrigin; float m_fRadius;

    public: GEKSPHERE(void); GEKSPHERE(const GEKVECTOR3 &kOrigin, float fRadius);

    bool Collision(const GEKAABB &kAABB) const; bool Collision(const GEKSPHERE &kSphere) const; };

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKCurve.h] - (732 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKCurve__
    #define __GEKCurve__
    /*! 
    	\author MoJo
        \file GEKCurve.h
        \brief Curve Calculation
    */

    #include <math.h>

    template <class CLASS> CLASS GEKXBernstein(float fFactor, CLASS *pkBase) { CLASS kA(pkBase[0] * powf(fFactor, 3.0f)); CLASS kB(pkBase[1] * (3.0f * powf(fFactor, 2.0f) * (1.0f - fFactor))); CLASS kC(pkBase[2] * (3.0f * fFactor * powf((1.0f - fFactor), 2.0f))); CLASS kD(pkBase[3] * powf((1.0f - fFactor), 3.0f)); return ((kA + kB) + (kC + kD)); }

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKFrustum.h] - (616 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKFrustum__
    #define __GEKFrustum__
    /*! 
    	\author MoJo
        \file GEKCollide.h
        \brief Basic View Frustum
    */

    struct GEKFRUSTUM { public: GEKPLANE m_akFrustum[6];

    public: void Generate(const GEKMATRIX &kMatrix);

    bool Visible(const GEKVECTOR3 &kPoint) const; bool Visible(const GEKSPHERE &kSphere) const; bool Visible(const GEKAABB &kAABB) const; };

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKMatrix.h] - (5,569 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKMatrix__
    #define __GEKMatrix__
    /*! 
    	\author MoJo
        \file GEKMatrix.h
        \brief 4x4 Matrix Class
    */

    //! 4x4 Matrix Class struct GEKMATRIX { public: union { float d[16]; float m[4][4];

    struct { float _11, _12, _13, _14; float _21, _22, _23, _24; float _31, _32, _33, _34; float _41, _42, _43, _44; };

    struct { GEKVECTOR4 rx; GEKVECTOR4 ry; GEKVECTOR4 rz;

    union { struct { GEKVECTOR3 t; float w; };

    struct { float x, y, z, w; }; }; }; };

    public: inline GEKMATRIX(void); inline GEKMATRIX(float *pfData); inline GEKMATRIX(float _11, float _12, float _13, float _14, float _21, float _22, float _23, float _24, float _31, float _32, float _33, float _34, float _41, float _42, float _43, float _44); inline GEKMATRIX(const GEKMATRIX &kMatrix); inline GEKMATRIX(const GEKVECTOR3 &kAxis, float fAngle); inline GEKMATRIX(const GEKVECTOR3 &kEuler);

    //@{ //! Assignment Operators inline GEKMATRIX operator = (const GEKMATRIX &kMatrix); void operator *= (const GEKMATRIX &kMatrix); //@} //@{ //! Casting Operators inline float operator () (int iRow, int iCol) const; inline float operator () (int iRow, int iCol); inline operator const float * (void) const; inline operator float * (void); //@} //! Binary Operator GEKMATRIX operator * (const GEKMATRIX &kMatrix);

    inline void SetIdentity(void); //!< Sets a matrix to identity void SetEuler(const GEKVECTOR3 &kEuler); //!< Sets the XYZ euler angles of a rotation matrix void SetRotation(const GEKVECTOR3 &kAxis, float fAngle); //!< Sets the axial angle of a rotation matrix void SetQuaternion(const GEKQUATERNION &kQuat); //!< Converts a quaternion to a rotation matrix inline void SetScaling(const GEKVECTOR3 &kScale); //!< Sets the scaling factor of a matrix inline GEKVECTOR3 GetScaling(void); //!< Gets the scaling factor of a matrix void Transpose(void); //!< Transposes a matrix inline float Determinant(void); //!< Calculates the determinant of a matrix GEKMATRIX Inverse(void); //!< Calculates the inverse of a matrix void Invert(void); //!< Inverts a matrix //! Rotates a matrix preserving translations void Rotate(const GEKMATRIX &kMatrix);

    //@{ //! Rotates a point by a rotation matrix GEKVECTOR3 Rotate(const GEKVECTOR2 &kVector); GEKVECTOR3 Rotate(const GEKVECTOR3 &kVector); GEKVECTOR3 Rotate(const GEKVECTOR4 &kVector); GEKVECTOR3 Rotate(const GEKVECTOR2 &kVector) const; GEKVECTOR3 Rotate(const GEKVECTOR3 &kVector) const; GEKVECTOR3 Rotate(const GEKVECTOR4 &kVector) const; //@} //@{ //! Transforms a point by a matrix GEKVECTOR4 Transform(const GEKVECTOR2 &kVector); GEKVECTOR4 Transform(const GEKVECTOR3 &kVector); GEKVECTOR4 Transform(const GEKVECTOR4 &kVector); GEKVECTOR4 Transform(const GEKVECTOR2 &kVector) const; GEKVECTOR4 Transform(const GEKVECTOR3 &kVector) const; GEKVECTOR4 Transform(const GEKVECTOR4 &kVector) const; //@} };

    /*! \brief Creates an orthographic projection matrix \param fXMin [in] the minimum X value of the view volume \param fYMin [in] the minimum Y value of the view volume \param fXMax [in] the maximum X value of the view volume \param fYMax [in] the maximum Y value of the view volume \param fNear [in] the distance from the viewer to the near clipping plane \param fFar [in] the distance from the viewer to the far clipping plane

    The orthographic matrix is defined as follows: <pre> fX 0 0 fTX 0 fY 0 fTY 0 0 -fZ -fTZ 0 0 0 1

    fX = (2.0f / (fXMax - fXMin)) fY = (2.0f / (fYMax - fYMin)) fZ = (-2.0f / (fFar - fNear)) fTX = -((fXMax + fXMin) / (fXMax - fXMin)) fTY = -((fYMax + fYMin) / (fYMax - fYMin)) fTZ = -((fFar + fNear) / (fFar - fNear)) </pre> */
    GEKMATRIX GEKMatrixOrtho(float fXMin, float fYMin, float fXMax, float fYMax, float fNear, float fFar);

    /*! \brief Creates a perspective projection matrix \param fFOV [in] the field of view angle of the view volume \param fAspect [in] the width to height aspect ratio of the view volume \param fNear [in] the distance from the viewer to the near clipping plane \param fFar [in] the distance from the viewer to the far clipping plane The perspective matrix is defined as follows: <pre> fX 0 fA 0 0 fY fB 0 0 0 fC fD 0 0 -1 0

    fX = ((2.0f * fNear) / (fXMax - fXMin)) fY = ((2.0f * fNear) / (fYMax - fYMin)) fA = ((fXMax + fXMin) / (fXMax - fXMin)) fB = ((fYMax + fYMin) / (fYMax - fYMin)) fC = -((fFar + fNear) / (fFar - fNear)) fD = -((2.0f * fFar * fNear) / (fFar - fNear)) </pre> */
    GEKMATRIX GEKMatrixPerspective(float fFOV, float fAspect, float fNear, float fFar);

    /*! \brief Creates a matrix to mirror coordinates around a plane \param kPlane [in] the plane to mirror coordinates by */ GEKMATRIX GEKMatrixMirror(const GEKPLANE &kPlane);

    /*! \brief Creates a view matrix based upon a direction \param kOrigin [in] the origin of the view matrix \param kTarget [in] the target of the view matrix */ GEKMATRIX GEKMatrixTarget(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kTarget);

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKPlane.h] - (1,392 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKPlane__
    #define __GEKPlane__
    /*! 
    	\author MoJo
        \file GEKPlane.h
        \brief Plane Class
    */

    //! Generates a normal from 3 planar points GEKVECTOR3 GEKNormalize(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3);

    //! Plane Class struct GEKPLANE { public: GEKVECTOR3 n; float d;

    public: inline GEKPLANE(void); inline GEKPLANE(const GEKPLANE &kPlane); inline GEKPLANE(float fA, float fB, float fC, float fD); inline GEKPLANE(const GEKVECTOR3 &kNormal, float fDistance); GEKPLANE(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3);

    //! Assignment Operator inline GEKPLANE operator = (const GEKPLANE &kPlane);

    //! Returns the distance from a plane to a point float Distance(const GEKVECTOR3 &kPoint) const;

    /*! \brief Returns the if a ray and a plane intersect \param kRay [in] the ray to check against */ bool Intersect(const GEKRAY &kRay) const;

    /*! \brief Returns the point of intersection of a ray to a plane \param kRay [in] the ray to check against */ GEKVECTOR3 Intersection(const GEKRAY &kRay) const; };

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKQuaternion.h] - (2,560 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKQuaternion__
    #define __GEKQuaternion__
    /*! 
        \author MoJo
        \file GEKQuaternion.h
        \brief 4D Quaternion Class
    */

    //! 4D Quaternion Class struct GEKQUATERNION { public: float x; float y; float z; float w;

    public: inline GEKQUATERNION(void); inline GEKQUATERNION(const GEKMATRIX &kMatrix); inline GEKQUATERNION(const GEKQUATERNION &kQuat); inline GEKQUATERNION(float fX, float fY, float fZ, float fW); inline GEKQUATERNION(const GEKVECTOR3 &kAxis, float fAngle); inline GEKQUATERNION(const GEKVECTOR3 &kEuler);

    //! Casting Operator inline operator float * (void);

    //@{ //! Assignment Operators void operator *= (const GEKQUATERNION &kQuat); inline GEKQUATERNION operator = (const GEKQUATERNION &kQuat); inline operator -= (const GEKQUATERNION &kQuat); inline operator += (const GEKQUATERNION &kQuat); inline operator /= (float fScalar); inline operator *= (float fScalar); //@} //@{ //! Binary Operators GEKQUATERNION operator * (const GEKQUATERNION &kQuat); inline GEKQUATERNION operator - (const GEKQUATERNION &kQuat); inline GEKQUATERNION operator + (const GEKQUATERNION &kQuat); inline GEKQUATERNION operator / (float fScalar); inline GEKQUATERNION operator * (float fScalar); //@} inline void SetIdentity(void); //!< Sets a quaternion to identity void SetEuler(const GEKVECTOR3 &kEuler); //!< Sets the XYZ euler angles of a quaternion void SetRotation(const GEKVECTOR3 &kAxis, float fAngle); //!< Sets the axial angle of a quaternion void SetMatrix(const GEKMATRIX &kMatrix); //!< Converts a rotation matrix to a quaternion inline float Dot(const GEKQUATERNION &kQuat); //!< Calculates the dot product of two quaternions inline float LengthSqr(void); //!< Calculates the square length of a quaternion inline float Length(void); //!< Calculates the length of a quaternion GEKQUATERNION Normal(void); //!< Calculates the normal of a quaternion void Normalize(void); //!< Normalizes a quaternion GEKQUATERNION Slerp(const GEKQUATERNION &kQuat, float fFactor); //!< Calculates the spherical interpolation of two quaternions GEKQUATERNION Lerp(const GEKQUATERNION &kQuat, float fFactor); //!< Calculates the linear interpolation of two quaternions };

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKRect.h] - (658 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKRect__
    #define __GEKRect__
    /*! 
        \author MoJo
        \file GEKRect.h
        \brief Basic Rectangle Class
    */

    //! Basic Rectangle Class struct GEKRECT { public: float m_fXPos; float m_fYPos; float m_fXSize; float m_fYSize;

    public: inline GEKRECT(void); inline GEKRECT(int iXPos, int iYPos, int iXSize, int iYSize); inline GEKRECT(float fXPos, float fYPos, float fXSize, float fYSize); };

    #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKVector2.h] - (3,477 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKVECTOR2__
    #define __GEKVECTOR2__
    /*! 
        \author MoJo
        \file GEKVector2.h
        \brief 2D Vector Class
    */

    //! 2D Vector Class struct GEKVECTOR2 { public: union { float xy[2]; float uv[2]; struct { float x, y; }; struct { float u, v; }; };

    public: inline GEKVECTOR2(void); inline GEKVECTOR2(const GEKVECTOR2 &kVector); inline GEKVECTOR2(const GEKVECTOR3 &kVector); inline GEKVECTOR2(const GEKVECTOR4 &kVector); inline GEKVECTOR2(float fX, float fY);

    inline float &operator [] (int iAxis); inline bool operator < (const GEKVECTOR2 &kVector) const; inline bool operator > (const GEKVECTOR2 &kVector) const;

    //@{ //! Casting operator inline operator float * (void); inline operator const float * (void) const; //@} //@{ //! Assignment operators inline GEKVECTOR2 operator = (const GEKVECTOR2 &kVector); inline GEKVECTOR2 operator = (const GEKVECTOR3 &kVector); inline GEKVECTOR2 operator = (const GEKVECTOR4 &kVector); inline operator -= (const GEKVECTOR2 &kVector); inline operator += (const GEKVECTOR2 &kVector); inline operator /= (float fScalar); inline operator *= (float fScalar); //@} //@{ //! Binary Operators inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector) const; inline GEKVECTOR2 operator + (const GEKVECTOR2 &kVector) const; inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector); inline GEKVECTOR2 operator + (const GEKVECTOR2 &kVector); inline GEKVECTOR2 operator / (float fScalar) const; inline GEKVECTOR2 operator * (float fScalar) const; inline GEKVECTOR2 operator / (float fScalar); inline GEKVECTOR2 operator * (float fScalar); //@} inline void SetLength(float fLength); //!< Sets the length of a vector inline float GetLengthSqr(void) const; //!< Calculates the square length of a vector inline float GetLengthSqr(void); //!< Calculates the square length of a vector inline float GetLength(void) const; //!< Calculates the length of a vector inline float GetLength(void); //!< Calculates the length of a vector inline float GetAngle(const GEKVECTOR2 &kVector); //!< Calculates the angle between two vectors inline float Distance(const GEKVECTOR2 &kVector) const; //!< Calculates the distance to a vector inline float Distance(const GEKVECTOR2 &kVector); //!< Calculates the distance to a vector inline float Dot(const GEKVECTOR2 &kVector) const; //!< Calculates the dot product of two vectors inline float Dot(const GEKVECTOR2 &kVector); //!< Calculates the dot product of two vectors inline GEKVECTOR2 Lerp(const GEKVECTOR2 &kVector, float fFactor) const; //!< Calculates the linear interpolation of two vectors inline GEKVECTOR2 Lerp(const GEKVECTOR2 &kVector, float fFactor); //!< Calculates the linear interpolation of two vectors inline GEKVECTOR2 Normal(void) const; //!< Calculates the normal of a vector inline GEKVECTOR2 Normal(void); //!< Calculates the normal of a vector inline void Normalize(void); //!< Normalizes a vector };

    inline GEKVECTOR2 operator - (const GEKVECTOR2 &kVector); //!< Negative Operator inline GEKVECTOR2 operator - (GEKVECTOR2 &kVector); //!< Negative Operator #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKVector3.h] - (3,676 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKVECTOR3__
    #define __GEKVECTOR3__
    /*! 
        \author MoJo
        \file GEKVector3.h
        \brief 3D Vector Class
    */

    //! 3D Vector Class struct GEKVECTOR3 { public: union { float xyz[3]; struct { float x, y, z; }; };

    public: inline GEKVECTOR3(void); inline GEKVECTOR3(const GEKVECTOR2 &kVector); inline GEKVECTOR3(const GEKVECTOR3 &kVector); inline GEKVECTOR3(const GEKVECTOR4 &kVector); inline GEKVECTOR3(float fX, float fY, float fZ);

    inline float &operator [] (int iAxis); inline bool operator < (const GEKVECTOR3 &kVector) const; inline bool operator > (const GEKVECTOR3 &kVector) const;

    //@{ //! Casting operator inline operator float * (void); inline operator const float * (void) const; //@} //@{ //! Assignment operators inline GEKVECTOR3 operator = (const GEKVECTOR2 &kVector); inline GEKVECTOR3 operator = (const GEKVECTOR3 &kVector); inline GEKVECTOR3 operator = (const GEKVECTOR4 &kVector); inline operator -= (const GEKVECTOR3 &kVector); inline operator += (const GEKVECTOR3 &kVector); inline operator /= (float fScalar); inline operator *= (float fScalar); //@} //@{ //! Binary Operators inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector) const; inline GEKVECTOR3 operator + (const GEKVECTOR3 &kVector) const; inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector); inline GEKVECTOR3 operator + (const GEKVECTOR3 &kVector); inline GEKVECTOR3 operator / (float fScalar) const; inline GEKVECTOR3 operator * (float fScalar) const; inline GEKVECTOR3 operator / (float fScalar); inline GEKVECTOR3 operator * (float fScalar); //@} inline void SetLength(float fLength); //!< Sets the length of a vector inline float GetLengthSqr(void) const; //!< Calculates the square length of a vector inline float GetLengthSqr(void); //!< Calculates the square length of a vector inline float GetLength(void) const; //!< Calculates the length of a vector inline float GetLength(void); //!< Calculates the length of a vector inline float GetAngle(const GEKVECTOR3 &kVector); //!< Calculates the angle between two vectors inline GEKVECTOR3 Cross(const GEKVECTOR3 &kVector) const; //!< Calculates the cross product of two vectors inline GEKVECTOR3 Cross(const GEKVECTOR3 &kVector); //!< Calculates the cross product of two vectors inline float Distance(const GEKVECTOR3 &kVector) const; //!< Calculates the distance to a vector inline float Distance(const GEKVECTOR3 &kVector); //!< Calculates the distance to a vector inline float Dot(const GEKVECTOR3 &kVector) const; //!< Calculates the dot product of two vectors inline float Dot(const GEKVECTOR3 &kVector); //!< Calculates the dot product of two vectors inline GEKVECTOR3 Lerp(const GEKVECTOR3 &kVector, float fFactor) const; //!< Calculates the linear interpolation of two vectors inline GEKVECTOR3 Lerp(const GEKVECTOR3 &kVector, float fFactor); //!< Calculates the linear interpolation of two vectors inline GEKVECTOR3 Normal(void) const; //!< Calculates the normal of a vector inline GEKVECTOR3 Normal(void); //!< Calculates the normal of a vector inline void Normalize(void); //!< Normalizes a vector };

    inline GEKVECTOR3 operator - (const GEKVECTOR3 &kVector); //!< Negative Operator inline GEKVECTOR3 operator - (GEKVECTOR3 &kVector); //!< Negative Operator #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Include/GEKVector4.h] - (3,731 bytes)

    /***************************************************/
    /* Game Excelleration Kit vX                       */
    /* Copyright (C) 2001 by HourGlass Software NonInc */
    /***************************************************/
    #ifndef __GEKVECTOR4__
    #define __GEKVECTOR4__
    /*! 
        \author MoJo
        \file GEKVector4.h
        \brief 4D Vector Class
    */

    //! 4D Vector Class struct GEKVECTOR4 { public: union { float xyzw[4]; float rgba[4]; struct { float x, y, z, w; }; struct { float r, g, b, a; }; };

    public: inline GEKVECTOR4(void); inline GEKVECTOR4(const GEKVECTOR2 &kVector); inline GEKVECTOR4(const GEKVECTOR3 &kVector); inline GEKVECTOR4(const GEKVECTOR4 &kVector); inline GEKVECTOR4(float fX, float fY, float fZ, float fW);

    inline float &operator [] (int iAxis); inline bool operator < (const GEKVECTOR4 &kVector) const; inline bool operator > (const GEKVECTOR4 &kVector) const;

    //@{ //! Casting operator inline operator float * (void); inline operator const float * (void) const; //@} //@{ //! Assignment operators inline GEKVECTOR4 operator = (const GEKVECTOR2 &kVector); inline GEKVECTOR4 operator = (const GEKVECTOR3 &kVector); inline GEKVECTOR4 operator = (const GEKVECTOR4 &kVector); inline operator -= (const GEKVECTOR4 &kVector); inline operator += (const GEKVECTOR4 &kVector); inline operator /= (float fScalar); inline operator *= (float fScalar); //@} //@{ //! Binary Operators inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector) const; inline GEKVECTOR4 operator + (const GEKVECTOR4 &kVector) const; inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector); inline GEKVECTOR4 operator + (const GEKVECTOR4 &kVector); inline GEKVECTOR4 operator / (float fScalar) const; inline GEKVECTOR4 operator * (float fScalar) const; inline GEKVECTOR4 operator / (float fScalar); inline GEKVECTOR4 operator * (float fScalar); //@} inline void SetLength(float fLength); //!< Sets the length of a vector inline float GetLengthSqr(void) const; //!< Calculates the square length of a vector inline float GetLengthSqr(void); //!< Calculates the square length of a vector inline float GetLength(void) const; //!< Calculates the length of a vector inline float GetLength(void); //!< Calculates the length of a vector inline float GetAngle(const GEKVECTOR4 &kVector); //!< Calculates the angle between two vectors inline GEKVECTOR4 Cross(const GEKVECTOR4 &kVector) const; //!< Calculates the cross product of two vectors inline GEKVECTOR4 Cross(const GEKVECTOR4 &kVector); //!< Calculates the cross product of two vectors inline float Distance(const GEKVECTOR4 &kVector) const; //!< Calculates the distance to a vector inline float Distance(const GEKVECTOR4 &kVector); //!< Calculates the distance to a vector inline float Dot(const GEKVECTOR4 &kVector) const; //!< Calculates the dot product of two vectors inline float Dot(const GEKVECTOR4 &kVector); //!< Calculates the dot product of two vectors inline GEKVECTOR4 Lerp(const GEKVECTOR4 &kVector, float fFactor) const; //!< Calculates the linear interpolation of two vectors inline GEKVECTOR4 Lerp(const GEKVECTOR4 &kVector, float fFactor); //!< Calculates the linear interpolation of two vectors inline GEKVECTOR4 Normal(void) const; //!< Calculates the normal of a vector inline GEKVECTOR4 Normal(void); //!< Calculates the normal of a vector void Normalize(void); //!< Normalizes a vector };

    inline GEKVECTOR4 operator - (const GEKVECTOR4 &kVector); //!< Negative Operator inline GEKVECTOR4 operator - (GEKVECTOR4 &kVector); //!< Negative Operator #endif

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKContain.cpp] - (1,972 bytes)

    #include "..\GEKXMath.h"

    GEKRAY::GEKRAY(void) { }

    GEKRAY::GEKRAY(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kVector) { m_kOrigin = kOrigin; m_kVector = kVector; }

    bool GEKAABB::Collision(const GEKAABB &kAABB) const { if(m_kMin > kAABB.m_kMax) return false; if(m_kMax < kAABB.m_kMin) return false; return true; }

    inline bool GEK_AABB_Sphere_Collision(const GEKSPHERE &kSphere, const GEKAABB &kAABB) { float fDistance = 0.0f; for(int iAxis = 0; iAxis < 3; iAxis++) { if(kSphere.m_kOrigin[iAxis] < kAABB.m_kMin[iAxis]) { float fValue = (kSphere.m_kOrigin[iAxis] - kAABB.m_kMin[iAxis]); fDistance += (fValue * fValue); } else if(kSphere.m_kOrigin[iAxis] > kAABB.m_kMax[iAxis]) { float fValue = (kSphere.m_kOrigin[iAxis] - kAABB.m_kMax[iAxis]); fDistance += (fValue * fValue); } }

    if(fDistance <= (kSphere.m_fRadius * kSphere.m_fRadius)) return true; return false; }

    bool GEKAABB::Collision(const GEKSPHERE &kSphere) const { return GEK_AABB_Sphere_Collision(kSphere, *this); }

    void GEKAABB::Extend(const GEKVECTOR3 &kPoint) { if(kPoint.x < m_kMin.x) m_kMin.x = kPoint.x; if(kPoint.y < m_kMin.y) m_kMin.y = kPoint.y; if(kPoint.z < m_kMin.z) m_kMin.z = kPoint.z; if(kPoint.x > m_kMax.x) m_kMax.x = kPoint.x; if(kPoint.y > m_kMax.y) m_kMax.y = kPoint.y; if(kPoint.z > m_kMax.z) m_kMax.z = kPoint.z; }

    GEKSPHERE::GEKSPHERE(void) { m_fRadius = 0.0f; }

    GEKSPHERE::GEKSPHERE(const GEKVECTOR3 &kOrigin, float fRadius) { m_kOrigin = kOrigin; m_fRadius = fRadius; }

    bool GEKSPHERE::Collision(const GEKAABB &kAABB) const { return GEK_AABB_Sphere_Collision(*this, kAABB); }

    bool GEKSPHERE::Collision(const GEKSPHERE &kSphere) const { GEKVECTOR3 kDistance(m_kOrigin - kSphere.m_kOrigin); float fDistance = kDistance.GetLengthSqr();

    float fRadius = (m_fRadius + kSphere.m_fRadius); if(fDistance <= (fRadius * fRadius)) return true; return false; }

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKCurve.cpp] - (26 bytes)

    #include "..\GEKXMath.h"
     

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKFrustum.cpp] - (2,436 bytes)

    #include "..\GEKXMath.h"

    void GEKFRUSTUM::Generate(const GEKMATRIX &kMatrix) { // Extract the near plane m_akFrustum[0].n.x = (kMatrix[ 3] + kMatrix[ 2]); m_akFrustum[0].n.y = (kMatrix[ 7] + kMatrix[ 6]); m_akFrustum[0].n.z = (kMatrix[11] + kMatrix[10]); m_akFrustum[0].d = (kMatrix[15] + kMatrix[14]); // Extract the far plane m_akFrustum[1].n.x = (kMatrix[ 3] - kMatrix[ 2]); m_akFrustum[1].n.y = (kMatrix[ 7] - kMatrix[ 6]); m_akFrustum[1].n.z = (kMatrix[11] - kMatrix[10]); m_akFrustum[1].d = (kMatrix[15] - kMatrix[14]);

    // Extract the left plane m_akFrustum[2].n.x = (kMatrix[ 3] + kMatrix[ 0]); m_akFrustum[2].n.y = (kMatrix[ 7] + kMatrix[ 4]); m_akFrustum[2].n.z = (kMatrix[11] + kMatrix[ 8]); m_akFrustum[2].d = (kMatrix[15] + kMatrix[12]);

    // Extract the right plane m_akFrustum[3].n.x = (kMatrix[ 3] - kMatrix[ 0]); m_akFrustum[3].n.y = (kMatrix[ 7] - kMatrix[ 4]); m_akFrustum[3].n.z = (kMatrix[11] - kMatrix[ 8]); m_akFrustum[3].d = (kMatrix[15] - kMatrix[12]);

    // Extract the bottom plane m_akFrustum[4].n.x = (kMatrix[ 3] + kMatrix[ 1]); m_akFrustum[4].n.y = (kMatrix[ 7] + kMatrix[ 5]); m_akFrustum[4].n.z = (kMatrix[11] + kMatrix[ 9]); m_akFrustum[4].d = (kMatrix[15] + kMatrix[13]);

    // Extract the top plane m_akFrustum[5].n.x = (kMatrix[ 3] - kMatrix[ 1]); m_akFrustum[5].n.y = (kMatrix[ 7] - kMatrix[ 5]); m_akFrustum[5].n.z = (kMatrix[11] - kMatrix[ 9]); m_akFrustum[5].d = (kMatrix[15] - kMatrix[13]); }

    bool GEKFRUSTUM::Visible(const GEKVECTOR3 &kPoint) const { for(int iIndex = 0; iIndex < 6; iIndex++) { if(m_akFrustum[iIndex].Distance(kPoint) <= 0.0f) return false; }

    return true; }

    bool GEKFRUSTUM::Visible(const GEKSPHERE &kSphere) const { for(int iIndex = 0; iIndex < 6; iIndex++) { float fDistance = m_akFrustum[iIndex].Distance(kSphere.m_kOrigin); if(fDistance <= -kSphere.m_fRadius) return false; }

    return true; }

    bool GEKFRUSTUM::Visible(const GEKAABB &kAABB) const { GEKVECTOR3 kPoint; for(int iIndex = 0; iIndex < 6; iIndex++) { kPoint.x = ((m_akFrustum[iIndex].n.x < 0.0f) ? kAABB.m_kMin.x : kAABB.m_kMax.x); kPoint.y = ((m_akFrustum[iIndex].n.y < 0.0f) ? kAABB.m_kMin.y : kAABB.m_kMax.y); kPoint.z = ((m_akFrustum[iIndex].n.z < 0.0f) ? kAABB.m_kMin.z : kAABB.m_kMax.z); if(m_akFrustum[iIndex].Distance(kPoint) <= 0.0f) return false; }

    return true; }

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKMatrix.cpp] - (14,221 bytes)

    #include "..\GEKXMath.h"

    GEKMATRIX GEKMATRIX::operator * (const GEKMATRIX &kMatrix) { return GEKMATRIX(((_11 * kMatrix._11) + (_12 * kMatrix._21) + (_13 * kMatrix._31) + (_14 * kMatrix._41)), ((_11 * kMatrix._12) + (_12 * kMatrix._22) + (_13 * kMatrix._32) + (_14 * kMatrix._42)), ((_11 * kMatrix._13) + (_12 * kMatrix._23) + (_13 * kMatrix._33) + (_14 * kMatrix._43)), ((_11 * kMatrix._14) + (_12 * kMatrix._24) + (_13 * kMatrix._34) + (_14 * kMatrix._44)),

    ((_21 * kMatrix._11) + (_22 * kMatrix._21) + (_23 * kMatrix._31) + (_24 * kMatrix._41)), ((_21 * kMatrix._12) + (_22 * kMatrix._22) + (_23 * kMatrix._32) + (_24 * kMatrix._42)), ((_21 * kMatrix._13) + (_22 * kMatrix._23) + (_23 * kMatrix._33) + (_24 * kMatrix._43)), ((_21 * kMatrix._14) + (_22 * kMatrix._24) + (_23 * kMatrix._34) + (_24 * kMatrix._44)),

    ((_31 * kMatrix._11) + (_32 * kMatrix._21) + (_33 * kMatrix._31) + (_34 * kMatrix._41)), ((_31 * kMatrix._12) + (_32 * kMatrix._22) + (_33 * kMatrix._32) + (_34 * kMatrix._42)), ((_31 * kMatrix._13) + (_32 * kMatrix._23) + (_33 * kMatrix._33) + (_34 * kMatrix._43)), ((_31 * kMatrix._14) + (_32 * kMatrix._24) + (_33 * kMatrix._34) + (_34 * kMatrix._44)),

    ((_41 * kMatrix._11) + (_42 * kMatrix._21) + (_43 * kMatrix._31) + (_44 * kMatrix._41)), ((_41 * kMatrix._12) + (_42 * kMatrix._22) + (_43 * kMatrix._32) + (_44 * kMatrix._42)), ((_41 * kMatrix._13) + (_42 * kMatrix._23) + (_43 * kMatrix._33) + (_44 * kMatrix._43)), ((_41 * kMatrix._14) + (_42 * kMatrix._24) + (_43 * kMatrix._34) + (_44 * kMatrix._44))); }

    void GEKMATRIX::operator *= (const GEKMATRIX &kMatrix) { *this = GEKMATRIX(((_11 * kMatrix._11) + (_12 * kMatrix._21) + (_13 * kMatrix._31) + (_14 * kMatrix._41)), ((_11 * kMatrix._12) + (_12 * kMatrix._22) + (_13 * kMatrix._32) + (_14 * kMatrix._42)), ((_11 * kMatrix._13) + (_12 * kMatrix._23) + (_13 * kMatrix._33) + (_14 * kMatrix._43)), ((_11 * kMatrix._14) + (_12 * kMatrix._24) + (_13 * kMatrix._34) + (_14 * kMatrix._44)),

    ((_21 * kMatrix._11) + (_22 * kMatrix._21) + (_23 * kMatrix._31) + (_24 * kMatrix._41)), ((_21 * kMatrix._12) + (_22 * kMatrix._22) + (_23 * kMatrix._32) + (_24 * kMatrix._42)), ((_21 * kMatrix._13) + (_22 * kMatrix._23) + (_23 * kMatrix._33) + (_24 * kMatrix._43)), ((_21 * kMatrix._14) + (_22 * kMatrix._24) + (_23 * kMatrix._34) + (_24 * kMatrix._44)),

    ((_31 * kMatrix._11) + (_32 * kMatrix._21) + (_33 * kMatrix._31) + (_34 * kMatrix._41)), ((_31 * kMatrix._12) + (_32 * kMatrix._22) + (_33 * kMatrix._32) + (_34 * kMatrix._42)), ((_31 * kMatrix._13) + (_32 * kMatrix._23) + (_33 * kMatrix._33) + (_34 * kMatrix._43)), ((_31 * kMatrix._14) + (_32 * kMatrix._24) + (_33 * kMatrix._34) + (_34 * kMatrix._44)),

    ((_41 * kMatrix._11) + (_42 * kMatrix._21) + (_43 * kMatrix._31) + (_44 * kMatrix._41)), ((_41 * kMatrix._12) + (_42 * kMatrix._22) + (_43 * kMatrix._32) + (_44 * kMatrix._42)), ((_41 * kMatrix._13) + (_42 * kMatrix._23) + (_43 * kMatrix._33) + (_44 * kMatrix._43)), ((_41 * kMatrix._14) + (_42 * kMatrix._24) + (_43 * kMatrix._34) + (_44 * kMatrix._44))); }

    void GEKMATRIX::Rotate(const GEKMATRIX &kMatrix) { GEKMATRIX kBase(*this); _11 = ((kBase._11 * kMatrix._11) + (kBase._12 * kMatrix._21) + (kBase._13 * kMatrix._31)); _12 = ((kBase._11 * kMatrix._12) + (kBase._12 * kMatrix._22) + (kBase._13 * kMatrix._32)); _13 = ((kBase._11 * kMatrix._13) + (kBase._12 * kMatrix._23) + (kBase._13 * kMatrix._33));

    _21 = ((kBase._21 * kMatrix._11) + (kBase._22 * kMatrix._21) + (kBase._23 * kMatrix._31)); _22 = ((kBase._21 * kMatrix._12) + (kBase._22 * kMatrix._22) + (kBase._23 * kMatrix._32)); _23 = ((kBase._21 * kMatrix._13) + (kBase._22 * kMatrix._23) + (kBase._23 * kMatrix._33));

    _31 = ((kBase._31 * kMatrix._11) + (kBase._32 * kMatrix._21) + (kBase._33 * kMatrix._31)); _32 = ((kBase._31 * kMatrix._12) + (kBase._32 * kMatrix._22) + (kBase._33 * kMatrix._32)); _33 = ((kBase._31 * kMatrix._13) + (kBase._32 * kMatrix._23) + (kBase._33 * kMatrix._33)); }

    void GEKMATRIX::SetEuler(const GEKVECTOR3 &kEuler) { SetIdentity(); float fCOSx = COS(kEuler.x); float fSINx = SIN(kEuler.x); float fCOSy = COS(kEuler.y); float fSINy = SIN(kEuler.y); float fCOSz = COS(kEuler.z); float fSINz = SIN(kEuler.z);

    _11 = (fCOSy * fCOSz); _12 = (fCOSy * fSINz); _13 = (-fSINy);

    float fSINxSINy = (fSINx * fSINy); float fCOSxSINy = (fCOSx * fSINy);

    _21 = ((fSINxSINy * fCOSz) - (fCOSx * fSINz)); _22 = ((fSINxSINy * fSINz) + (fCOSx * fCOSz)); _23 = (fSINx * fCOSy);

    _31 = ((fCOSxSINy * fCOSz) + (fSINx * fSINz)); _32 = ((fCOSxSINy * fSINz) - (fSINx * fCOSz)); _33 = (fCOSx * fCOSy); }

    void GEKMATRIX::SetRotation(const GEKVECTOR3 &kAxis, float fAngle) { float fCOS = COS(fAngle); float fSIN = SIN(fAngle); GEKVECTOR3 kNormal(((GEKVECTOR3 &)kAxis).Normal());

    _11 = ((kNormal.x * kNormal.x) * (1.0f - fCOS) + fCOS); _12 = ((kNormal.x * kNormal.y) * (1.0f - fCOS) - (kNormal.z * fSIN)); _13 = ((kNormal.x * kNormal.z) * (1.0f - fCOS) + (kNormal.y * fSIN));

    _21 = ((kNormal.y * kNormal.x) * (1.0f - fCOS) + (kNormal.z * fSIN)); _22 = ((kNormal.y * kNormal.y) * (1.0f - fCOS) + fCOS); _23 = ((kNormal.y * kNormal.z) * (1.0f - fCOS) - (kNormal.x * fSIN));

    _31 = ((kNormal.z * kNormal.x) * (1.0f - fCOS) - (kNormal.y * fSIN)); _32 = ((kNormal.z * kNormal.y) * (1.0f - fCOS) + (kNormal.x * fSIN)); _33 = ((kNormal.z * kNormal.z) * (1.0f - fCOS) + fCOS); }

    void GEKMATRIX::SetQuaternion(const GEKQUATERNION &kQuat) { float f2X = (kQuat.x * 2.0f); float f2Y = (kQuat.y * 2.0f); float f2Z = (kQuat.z * 2.0f); float fWX = (kQuat.w * f2X); float fWY = (kQuat.w * f2Y); float fWZ = (kQuat.w * f2Z); float fXX = (kQuat.x * f2X); float fXY = (kQuat.x * f2Y); float fXZ = (kQuat.x * f2Z); float fYY = (kQuat.y * f2Y); float fYZ = (kQuat.y * f2Z); float fZZ = (kQuat.z * f2Z); _11 = (1.0f - fYY - fZZ); _12 = (fXY + fWZ); _13 = (fXZ - fWY);

    _21 = (fXY - fWZ); _22 = (1.0f - fXX - fZZ); _23 = (fYZ + fWX);

    _31 = (fXZ + fWY); _32 = (fYZ - fWX); _33 = (1.0f - fXX - fYY); }

    void GEKMATRIX::Transpose(void) { GEKMATRIX kMatrix(*this); _11 = kMatrix._11; _12 = kMatrix._21; _13 = kMatrix._31; _14 = kMatrix._41; _21 = kMatrix._12; _22 = kMatrix._22; _23 = kMatrix._32; _24 = kMatrix._42; _31 = kMatrix._13; _32 = kMatrix._23; _33 = kMatrix._33; _34 = kMatrix._43; _41 = kMatrix._14; _42 = kMatrix._24; _43 = kMatrix._34; _44 = kMatrix._44; }

    GEKMATRIX GEKMATRIX::Inverse(void) { /* if((ABS(_44 - 1.0f) > 0.001f)|| (ABS(_14) > 0.001f)|| (ABS(_24) > 0.001f)|| (ABS(_34) > 0.001f)) return *this;*/

    GEKMATRIX kResult; float fDetInverse = (1.0f / Determinant()); kResult._11 = ( fDetInverse * ((_22 * _33) - (_23 * _32))); kResult._12 = (-fDetInverse * ((_12 * _33) - (_13 * _32))); kResult._13 = ( fDetInverse * ((_12 * _23) - (_13 * _22))); kResult._14 = 0.0f;

    kResult._21 = (-fDetInverse * ((_21 * _33) - (_23 * _31))); kResult._22 = ( fDetInverse * ((_11 * _33) - (_13 * _31))); kResult._23 = (-fDetInverse * ((_11 * _23) - (_13 * _21))); kResult._24 = 0.0f;

    kResult._31 = ( fDetInverse * ((_21 * _32) - (_22 * _31))); kResult._32 = (-fDetInverse * ((_11 * _32) - (_12 * _31))); kResult._33 = ( fDetInverse * ((_11 * _22) - (_12 * _21))); kResult._34 = 0.0f;

    kResult._41 = -((_41 * kResult._11) + (_42 * kResult._21) + (_43 * kResult._31)); kResult._42 = -((_41 * kResult._12) + (_42 * kResult._22) + (_43 * kResult._32)); kResult._43 = -((_41 * kResult._13) + (_42 * kResult._23) + (_43 * kResult._33)); kResult._44 = 1.0f; return kResult; }

    void GEKMATRIX::Invert(void) { *this = Inverse(); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR2 &kVector) { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21)), ((kVector.x * _12) + (kVector.y * _22)), ((kVector.x * _13) + (kVector.y * _23))); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR3 &kVector) { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33))); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR4 &kVector) { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33))); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR2 &kVector) const { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21)), ((kVector.x * _12) + (kVector.y * _22)), ((kVector.x * _13) + (kVector.y * _23))); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR3 &kVector) const { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33))); }

    GEKVECTOR3 GEKMATRIX::Rotate(const GEKVECTOR4 &kVector) const { return GEKVECTOR3(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33))); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR2 &kVector) { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + _41), ((kVector.x * _12) + (kVector.y * _22) + _42), ((kVector.x * _13) + (kVector.y * _23) + _43), ((kVector.x * _14) + (kVector.y * _24) + _44)); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR3 &kVector) { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + _41), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + _42), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + _43), ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + _44)); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR4 &kVector) { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + (kVector.w * _41)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + (kVector.w * _42)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + (kVector.w * _43)), ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + (kVector.w * _44))); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR2 &kVector) const { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + _41), ((kVector.x * _12) + (kVector.y * _22) + _42), ((kVector.x * _13) + (kVector.y * _23) + _43), ((kVector.x * _14) + (kVector.y * _24) + _44)); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR3 &kVector) const { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + _41), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + _42), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + _43), ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + _44)); }

    GEKVECTOR4 GEKMATRIX::Transform(const GEKVECTOR4 &kVector) const { return GEKVECTOR4(((kVector.x * _11) + (kVector.y * _21) + (kVector.z * _31) + (kVector.w * _41)), ((kVector.x * _12) + (kVector.y * _22) + (kVector.z * _32) + (kVector.w * _42)), ((kVector.x * _13) + (kVector.y * _23) + (kVector.z * _33) + (kVector.w * _43)), ((kVector.x * _14) + (kVector.y * _24) + (kVector.z * _34) + (kVector.w * _44))); }

    GEKMATRIX GEKMatrixOrtho(float fXMin, float fYMin, float fXMax, float fYMax, float fNear, float fFar) { float fX = (2.0f / (fXMax - fXMin)); float fY = (2.0f / (fYMax - fYMin)); float fZ = (-2.0f / (fFar - fNear)); float fTX = -((fXMax + fXMin) / (fXMax - fXMin)); float fTY = -((fYMax + fYMin) / (fYMax - fYMin)); float fTZ = -((fFar + fNear) / (fFar - fNear));

    return GEKMATRIX( fX, 0.0f, 0.0f, 0.0f, 0.0f, -fY, 0.0f, 0.0f, 0.0f, 0.0f, -fZ, 0.0f, fTX, -fTY, -fTZ, 1.0f); }

    GEKMATRIX GEKMatrixPerspective(float fFOV, float fAspect, float fNear, float fFar) { float fYMax = (fNear * (SIN(fFOV / 2.0f) / COS(fFOV / 2.0f))); float fXMax = (fYMax * fAspect); float fYMin = -fYMax; float fXMin = -fXMax;

    float fX = ((2.0f * fNear) / (fXMax - fXMin)); float fY = ((2.0f * fNear) / (fYMax - fYMin)); float fA = ((fXMax + fXMin) / (fXMax - fXMin)); float fB = ((fYMax + fYMin) / (fYMax - fYMin)); float fC = -((fFar + fNear) / (fFar - fNear)); float fD = -((2.0f * fFar * fNear) / (fFar - fNear));

    return GEKMATRIX( fX, 0.0f, fA, 0.0f, 0.0f, fY, fB, 0.0f, 0.0f, 0.0f, -fC, -fD, 0.0f, 0.0f,-1.0f, 0.0f); }

    GEKMATRIX GEKMatrixMirror(const GEKPLANE &kPlane) { float fX = kPlane.n.x; float fY = kPlane.n.y; float fZ = kPlane.n.z; float fD = kPlane.d;

    return GEKMATRIX((0.0f - (2.0f * fX * fX)), (0.0f - (2.0f * fX * fY)), (0.0f - (2.0f * fX * fZ)), 0.0f, (0.0f - (2.0f * fY * fX)), (0.0f - (2.0f * fY * fY)), (0.0f - (2.0f * fY * fZ)), 0.0f, (0.0f - (2.0f * fZ * fX)), (0.0f - (2.0f * fZ * fY)), (0.0f - (2.0f * fZ * fZ)), 0.0f, (0.0f - (2.0f * fD * fX)), (0.0f - (2.0f * fD * fY)), (0.0f - (2.0f * fD * fZ)), 1.0f); }

    GEKMATRIX GEKMatrixTarget(const GEKVECTOR3 &kOrigin, const GEKVECTOR3 &kTarget) { GEKVECTOR3 kZAxis(kTarget - kOrigin); kZAxis.Normalize();

    GEKVECTOR3 m_kYAxis(0.0f, 1.0f, 0.0f); GEKVECTOR3 kXAxis(m_kYAxis.Cross(kZAxis)); kXAxis.Normalize();

    GEKVECTOR3 kYAxis(kZAxis.Cross(kXAxis));

    return GEKMATRIX(kXAxis.x, kXAxis.y, kXAxis.z, -kXAxis.Dot(kOrigin), kYAxis.x, kYAxis.y, kYAxis.z, -kYAxis.Dot(kOrigin), kZAxis.x, kZAxis.y, kZAxis.z, -kZAxis.Dot(kOrigin), 0.0f, 0.0f, 0.0f, 1.0f); }

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKPlane.cpp] - (1,137 bytes)

    #include "..\GEKXMath.h"

    GEKVECTOR3 GEKNormalize(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3) { GEKVECTOR3 kVectorA(kVector2 - kVector1); GEKVECTOR3 kVectorB(kVector3 - kVector1); GEKVECTOR3 kCross(kVectorA.Cross(kVectorB)); return kCross.Normal(); }

    GEKPLANE::GEKPLANE(const GEKVECTOR3 &kVector1, const GEKVECTOR3 &kVector2, const GEKVECTOR3 &kVector3) { n = GEKNormalize(kVector1, kVector2, kVector3); d = -n.Dot(kVector1); }

    float GEKPLANE::Distance(const GEKVECTOR3 &kPoint) const { return (n.Dot(kPoint) + d); }

    bool GEKPLANE::Intersect(const GEKRAY &kRay) const { float fDistanceA = Distance(kRay.m_kOrigin); float fDistanceB = Distance(kRay.m_kOrigin + kRay.m_kVector); if((fDistanceA > 0.0f)&&(fDistanceB < 0.0f)) return true; if((fDistanceA < 0.0f)&&(fDistanceB > 0.0f)) return true; return false; }

    GEKVECTOR3 GEKPLANE::Intersection(const GEKRAY &kRay) const { float fNumer = n.Dot(kRay.m_kOrigin); float fDenom = n.Dot(kRay.m_kVector); float fInter = (d - (fNumer / fDenom)); return (kRay.m_kOrigin + (kRay.m_kVector * fInter)); }

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKQuaternion.cpp] - (4,447 bytes)

    #include "..\GEKXMath.h"

    GEKQUATERNION GEKQUATERNION::operator * (const GEKQUATERNION &kQuat) { GEKQUATERNION kResult; kResult.x = ((w * kQuat.x) + (x * kQuat.w) + (y * kQuat.z) - (z * kQuat.y)); kResult.y = ((w * kQuat.y) - (x * kQuat.z) + (y * kQuat.w) + (z * kQuat.x)); kResult.z = ((w * kQuat.z) + (x * kQuat.y) - (y * kQuat.x) + (z * kQuat.w)); kResult.w = ((w * kQuat.w) - (x * kQuat.x) - (y * kQuat.y) - (z * kQuat.z)); return kResult; }

    void GEKQUATERNION::operator *= (const GEKQUATERNION &kQuat) { GEKQUATERNION kResult; kResult.x = ((w * kQuat.x) + (x * kQuat.w) + (y * kQuat.z) - (z * kQuat.y)); kResult.y = ((w * kQuat.y) - (x * kQuat.z) + (y * kQuat.w) + (z * kQuat.x)); kResult.z = ((w * kQuat.z) + (x * kQuat.y) - (y * kQuat.x) + (z * kQuat.w)); kResult.w = ((w * kQuat.w) - (x * kQuat.x) - (y * kQuat.y) - (z * kQuat.z)); *this = kResult; }

    void GEKQUATERNION::SetEuler(const GEKVECTOR3 &kEuler) { float fSINx = SIN(kEuler.x * 0.5f); float fSINy = SIN(kEuler.y * 0.5f); float fSINz = SIN(kEuler.z * 0.5f); float fCOSx = COS(kEuler.x * 0.5f); float fCOSy = COS(kEuler.y * 0.5f); float fCOSz = COS(kEuler.z * 0.5f); float fSINyCOSz = (fSINy * fCOSz); float fSINySINz = (fSINy * fSINz); float fCOSyCOSz = (fCOSy * fCOSz); float fCOSySINz = (fCOSy * fSINz);

    x = ((fSINx * fCOSyCOSz) - (fCOSx * fSINySINz)); y = ((fSINx * fCOSySINz) + (fCOSx * fSINyCOSz)); z = ((fCOSx * fCOSySINz) - (fSINx * fSINyCOSz)); w = ((fCOSx * fCOSyCOSz) + (fSINx * fSINySINz)); }

    void GEKQUATERNION::SetRotation(const GEKVECTOR3 &kAxis, float fAngle) { GEKVECTOR3 kNormal(((GEKVECTOR3 &)kAxis).Normal()); float fSinA = SIN(fAngle * 0.5f);

    x = (kNormal.x * fSinA); y = (kNormal.y * fSinA); z = (kNormal.z * fSinA); w = COS(fAngle * 0.5f); }

    void GEKQUATERNION::SetMatrix(const GEKMATRIX &kMatrix) { static int aiNext[3] = {1, 2, 0}; float fDiagonal = (kMatrix._11 + kMatrix._22 + kMatrix._33); if(fDiagonal > 0.0f) { float fSQRT = SQRT(fDiagonal + 1.0f); w = (fSQRT / 2.0f);

    fSQRT = (0.5f / fSQRT); x = ((kMatrix._23 - kMatrix._32) * fSQRT); y = ((kMatrix._31 - kMatrix._13) * fSQRT); z = ((kMatrix._12 - kMatrix._21) * fSQRT); } else { int iCount = 0; if(kMatrix._22 > kMatrix._11) iCount = 1; if(kMatrix._33 > kMatrix.m[iCount][iCount]) iCount = 2;

    float afTemp[4]; int iTemp1 = aiNext[iCount]; int iTemp2 = aiNext[iTemp1];

    float fSQRT = SQRT((kMatrix.m[iCount][iCount] - (kMatrix.m[iTemp1][iTemp1] + kMatrix.m[iTemp2][iTemp2])) + 1.0f); afTemp[iCount] = (fSQRT * 0.5f);

    if(fSQRT != 0.0) fSQRT = (0.5f / fSQRT); afTemp[3] = ((kMatrix.m[iTemp1][iTemp2] - kMatrix.m[iTemp2][iTemp1]) * fSQRT); afTemp[iTemp1] = ((kMatrix.m[iCount][iTemp1] + kMatrix.m[iTemp1][iCount]) * fSQRT); afTemp[iTemp2] = ((kMatrix.m[iCount][iTemp2] + kMatrix.m[iTemp2][iCount]) * fSQRT); x = afTemp[0]; y = afTemp[1]; z = afTemp[2]; w = afTemp[3]; } }

    GEKQUATERNION GEKQUATERNION::Normal(void) { float fLength = Length(); return GEKQUATERNION((x / fLength), (y / fLength), (z / fLength), (w / fLength)); }

    void GEKQUATERNION::Normalize(void) { *this = Normal(); }

    #include <math.h> GEKQUATERNION GEKQUATERNION::Slerp(const GEKQUATERNION &kQuat, float fFactor) { float fDot = Dot(kQuat); float fSqrt = SQRT(ABS(1.0f - fDot * fDot)); if(ABS(fSqrt) < (_EPSILON * 100.0f)) return *this; if(fDot < 0.0f) fDot = -fDot;

    float fAngle = 0.0f; if(fDot != 0.0f) fAngle = (float)atanf(fSqrt / fDot); fSqrt = 1 / fSqrt; GEKQUATERNION kResult; kResult.x = ((x * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.x * fSqrt * SIN(fAngle * fFactor))); kResult.y = ((y * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.y * fSqrt * SIN(fAngle * fFactor))); kResult.z = ((z * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.z * fSqrt * SIN(fAngle * fFactor))); kResult.w = ((w * fSqrt * SIN(fAngle * (1.0f - fFactor))) + (kQuat.w * fSqrt * SIN(fAngle * fFactor))); return kResult; }

    GEKQUATERNION GEKQUATERNION::Lerp(const GEKQUATERNION &kQuat, float fFactor) { GEKQUATERNION kResult; kResult.x = (x + ((kQuat.x - x) * fFactor)); kResult.y = (y + ((kQuat.y - y) * fFactor)); kResult.z = (z + ((kQuat.z - z) * fFactor)); kResult.w = (w + ((kQuat.w - w) * fFactor)); return kResult; }

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKVector2.cpp] - (24 bytes)

    #include "..\GEKXMath.h" 

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKVector3.cpp] - (24 bytes)

    #include "..\GEKXMath.h" 

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKVector4.cpp] - (24 bytes)

    #include "..\GEKXMath.h" 

    Currently browsing [GEKxMath.zip] (24,025 bytes) - [GEKxMath/Source/GEKXMath.cpp] - (3,522 bytes)

    #include "..\GEKXMath.h"

    int NextSquare(int iValue) { long Squared = 1; while(Squared < iValue) Squared <<= 1; if(Squared == iValue) return Squared; else return (Squared >> 1); }

    __declspec(naked) int __fastcall F2ID(float fValue) { __asm { push ebp mov ebp,esp push ecx push ebx push esi mov eax,dword ptr [ebp+8] mov ebx,eax sar ebx,31 mov edx,eax and edx,2147483647 sar edx,23 add edx,-127 mov ecx,edx sar ecx,31 not ecx mov dword ptr [ebp-4],ecx mov ecx,dword ptr [ebp-4] and ecx,edx push ecx mov ecx,31 pop esi sub ecx,esi mov esi,1 shl esi,cl dec esi and eax,8388607 mov ecx,31 sub ecx,edx mov edx,eax or edx,8388608 shl edx,8 shr edx,cl and edx,dword ptr [ebp-4] xor edx,ebx shl eax,8 test eax,esi sete al and eax,1 and ebx,eax add edx,ebx mov eax,edx pop esi pop ebx pop ecx pop ebp ret 4 }; }

    __declspec(naked) int __fastcall F2IU(float fValue) { __asm { push ebp mov ebp,esp push ecx push ebx push esi mov eax,dword ptr [ebp+8] xor eax,-2147483648 mov edx,eax sar edx,31 mov dword ptr [ebp-4],edx mov edx,eax and edx,2147483647 sar edx,23 add edx,-127 mov ebx,edx sar ebx,31 not ebx mov ecx,ebx and ecx,edx push ecx mov ecx,31 pop esi sub ecx,esi mov esi,1 shl esi,cl dec esi and eax,8388607 mov ecx,31 sub ecx,edx mov edx,eax or edx,8388608 shl edx,8 shr edx,cl and edx,ebx xor edx,dword ptr [ebp-4] shl eax,8 test eax,esi sete al and eax,1 and eax,dword ptr [ebp-4] and ebx,eax add edx,ebx neg edx mov eax,edx pop esi pop ebx pop ecx pop ebp ret 4 }; }

    __declspec(naked) float __fastcall ABS(float fValue) { __asm { fld dword ptr[esp + 4] fabs ret 4 }; }

    __declspec(naked) float __fastcall SIN(float fValue) { __asm { fld dword ptr[esp + 4] fsin ret 4 }; }

    __declspec(naked) float __fastcall COS(float fValue) { __asm { fld dword ptr[esp + 4] fcos ret 4 }; }

    float TAN(float fValue) { return (SIN(fValue) / COS(fValue)); }

    float SQRT(float fValue) { return (fValue ? (fValue * ISQRT(fValue)) : 0.0f); }

    __declspec(naked) float __fastcall ISQRT(float fValue) { __asm { mov eax, 0be6eb508h mov dword ptr[esp-12],03fc00000h sub eax, dword ptr[esp + 4] sub dword ptr[esp+4], 800000h shr eax, 1 mov dword ptr[esp - 8], eax

    fld dword ptr[esp - 8] fmul st, st fld dword ptr[esp - 8] fxch st(1) fmul dword ptr[esp + 4] fld dword ptr[esp - 12] fld st(0) fsub st,st(2)

    fld st(1) fxch st(1) fmul st(3),st fmul st(3),st fmulp st(4),st fsub st,st(2)

    fmul st(2),st fmul st(3),st fmulp st(2),st fxch st(1) fsubp st(1),st

    fmulp st(1), st ret 4 } }

    The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

     

    Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
    Please read our Terms, Conditions, and Privacy information.