MercuryTypes.h

Go to the documentation of this file.

#ifndef _MERCURYTYPES_H
#define _MERCURYTYPES_H

#include "global.h"
#include "MercuryMath.h"
#include "MercuryMatrix.h"

class MercuryPoint
{
public:
    MercuryPoint() : x(0), y(0), z(0) { };
    MercuryPoint( float ix, float iy, float iz ) : x(ix), y(iy), z(iz) { };
    MercuryPoint( const float * in ) : x(in[0]), y(in[1]), z(in[2]) { };

    operator float* () { return &x; }
    operator const float* () const { return &x; }

    inline const float GetX() const { return x; }
    inline const float GetY() const { return y; }
    inline const float GetZ() const { return z; }
    inline bool SetX(const float ix) { if (ix == x) { return false; } x = ix; return true; }
    inline bool SetY(const float iy) { if (iy == y) { return false; } y = iy; return true; }
    inline bool SetZ(const float iz) { if (iz == z) { return false; } z = iz; return true; }
    inline void Clear() { x = 0; y = 0; z = 0; }
    
    //allow [] to access
    float & operator[] ( const int rhs );
    const float operator[] ( const int rhs ) const;

    void NormalizeSelf();
    const MercuryPoint Normalize() const;
    float Magnitude() const;

    float GetBiggestElement() const { if( x > y ) return (x>z)?x:z; else return (y>z)?y:z; }

    inline void ConvertToVector3( float* out ) const { out[0] = x; out[1] = y; out[2] = z; }
    inline void ConvertToVector4( float* out ) const { out[0] = x; out[1] = y; out[2] = z; out[3] = 0; }
    inline void ConvertToIVector4( float* out ) const { out[0] = -x; out[1] = -y; out[2] = -z; out[3] = 0; }

    MercuryPoint operator*(const MercuryPoint& p) const;
    MercuryPoint operator/(const MercuryPoint& p) const;

    inline MercuryPoint& operator += ( const MercuryPoint& other )      { x+=other.x; y+=other.y; z+=other.z; return *this; }
    inline MercuryPoint& operator -= ( const MercuryPoint& other )      { x-=other.x; y-=other.y; z-=other.z; return *this; }
    inline MercuryPoint& operator *= ( float f )                        { x*=f; y*=f; z*=f; return *this; }
    inline MercuryPoint& operator /= ( float f )                        { x/=f; y/=f; z/=f; return *this; }

    inline MercuryPoint operator + ( const MercuryPoint& other ) const  { return MercuryPoint( x+other.x, y+other.y, z+other.z ); }
    inline MercuryPoint operator - ( const MercuryPoint& other ) const  { return MercuryPoint( x-other.x, y-other.y, z-other.z ); }
    inline MercuryPoint operator * ( float f ) const                    { return MercuryPoint( x*f, y*f, z*f ); }
    inline MercuryPoint operator / ( float f ) const                    { return MercuryPoint( x/f, y/f, z/f ); }

    friend MercuryPoint operator * ( float f, const MercuryPoint& other )   { return other*f; }

    bool operator==(const MercuryPoint& p) const;
    inline bool operator!=(const MercuryPoint& p) const { return !(*this == p); }

    bool operator==(const float f) const;
    inline bool operator!=(const float f) const { return !(*this == f); }

    MercuryPoint CrossProduct(const MercuryPoint& p) const;

    float x;
    float y;
    float z;
};

extern const MercuryPoint gpZero;
extern const MercuryPoint gpOne;



MercuryPoint Rotate2DPoint( float fAngle, MercuryPoint pIn );

void AngleMatrix (const MercuryPoint & angles, MercuryMatrix & mat );
void TranslationMatrix( const MercuryPoint & position, MercuryMatrix & mat );
void R_ConcatTransforms3 (  MercuryMatrix in1,  MercuryMatrix in2, MercuryMatrix & out );

void VectorIRotate (const MercuryPoint & in1, MercuryMatrix &in2, MercuryPoint & out);
void VectorRotate (const MercuryPoint & in1, const MercuryMatrix &in2, MercuryPoint & out);

void VectorMultiply( MercuryMatrix &m, const MercuryPoint &p, MercuryPoint &out );

void InvertMatrix( MercuryMatrix &in, MercuryMatrix & out );

class MQuaternion {
public:
    //Defines a Quaternion such that q = w + xi + yj + zk
    float w,x,y,z;
    MQuaternion() : w(0), x(0), y(0), z(0) { };
    MQuaternion(float W, float X, float Y, float Z) : w(W), x(X), y(Y), z(Z) { };
    MQuaternion(float* wxyz) : w(wxyz[0]), x(wxyz[1]), y(wxyz[2]), z(wxyz[3]) { };
    MQuaternion(const MercuryPoint& p) : w(0), x(p.GetX()), y(p.GetY()), z(p.GetZ()) {};

    void SetEuler(const MercuryPoint& angles);

    void CreateFromAxisAngle(const MercuryPoint& p, const float radians);

    float & operator[] ( const int rhs );
    const float & operator[] ( const int rhs ) const;

    float magnitude() const;
    MQuaternion normalize() const;
    MQuaternion conjugate() const;
    MQuaternion reciprocal() const;
    MQuaternion rotateAbout(const MQuaternion &spinAxis) const;
    void toMatrix( MercuryMatrix & mat ) const;
    void toMatrix4( MercuryMatrix & mat ) const;
    MercuryPoint ToPoint() { return MercuryPoint( x,y,z ); }
    /******************************************************
     * NOTE: Quaternion multipication is not commutative  *
     *       Therefore the / operator could imply for a/b *
     *       a*b.reciprocal() or b.reciprocal()*a         *
     ******************************************************/
    MQuaternion operator + (const MQuaternion &rhs) const;
    MQuaternion operator - (const MQuaternion &rhs) const;
    MQuaternion operator * (const MQuaternion &rhs) const;
    MQuaternion& operator =  (const MQuaternion &rhs);
    MQuaternion& operator += (const MQuaternion &rhs);
    MQuaternion& operator -= (const MQuaternion &rhs);
    MQuaternion& operator *= (const MQuaternion &rhs);
    MQuaternion operator * (const float &rhs) const;
    MQuaternion operator / (const float &rhs) const;
    MQuaternion& operator *= (const float &rhs);
    MQuaternion& operator /= (const float &rhs);
} M_ALIGN(32);

float innerProduct( const MQuaternion &a, const MQuaternion &b );

MercuryPoint outerProduct( const MQuaternion &a, const MQuaternion &b );

MQuaternion evenProduct(const MQuaternion &a, const MQuaternion &b );

MercuryPoint oddProduct( const MQuaternion &a, const MQuaternion &b );

MQuaternion SLERP( const MQuaternion &a, const MQuaternion &b, float t );

#endif


/* 
 * Copyright (c) 2005-2006, Joshua Allen, Charles Lohr, Adam Lowman
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by