[mupen64plus-pandora.git] / source / rice_gles / src / VectorMath.h

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - VectorMath.h                                            *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   Copyright (C) 2002 Rice1964                                           *
 *                                                                         *
 *   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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#ifndef VECTORMATH_H
#define VECTORMATH_H

/******************************************************************************
 * 4x4 matrix
 ******************************************************************************/

typedef struct _MATRIX {
    union {
        struct {
            float        _11, _12, _13, _14;
            float        _21, _22, _23, _24;
            float        _31, _32, _33, _34;
            float        _41, _42, _43, _44;
        };
        float m[4][4];
    };
} MATRIX;

typedef struct XMATRIX : public MATRIX {
public:
    XMATRIX();
    XMATRIX( const float * );
    XMATRIX( const MATRIX & );
    XMATRIX( 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 );

    float& operator () ( unsigned int Row, unsigned int Col );
    float  operator () ( unsigned int Row, unsigned int Col ) const;

    operator float* ();
    operator const float* () const;

    // assignment operators
    XMATRIX& operator *= ( const XMATRIX & );
    XMATRIX& operator += ( const XMATRIX & );
    XMATRIX& operator -= ( const XMATRIX & );
    XMATRIX& operator *= ( float );
    XMATRIX& operator /= ( float );

    // unary operators
    XMATRIX operator + () const;
    XMATRIX operator - () const;

    // binary operators
    XMATRIX operator * ( const XMATRIX & ) const;
    XMATRIX operator + ( const XMATRIX & ) const;
    XMATRIX operator - ( const XMATRIX & ) const;
    XMATRIX operator * ( float ) const;
    XMATRIX operator / ( float ) const;
    friend XMATRIX operator * ( float, const XMATRIX & );
    bool operator == ( const XMATRIX & ) const;
    bool operator != ( const XMATRIX & ) const;
} XMATRIX, *LPXMATRIX;

/******************************************************************************
 * 3d vector
 ******************************************************************************/

typedef struct _VECTOR3
{
    float x;
    float y;
    float z;
} VECTOR3;

class XVECTOR3 : public VECTOR3
{
public:
    XVECTOR3();
    XVECTOR3( const float *f );
    XVECTOR3( const VECTOR3 &v );
    XVECTOR3( float _x, float _y, float _z );

    // casting
    inline operator float* ();
    inline operator const float* () const;

    // assignment operators
    inline XVECTOR3& operator += ( const XVECTOR3 &op );
    inline XVECTOR3& operator -= ( const XVECTOR3 &op );
    inline XVECTOR3& operator *= ( float op );
    inline XVECTOR3& operator /= ( float op );

    // unary operators
    inline XVECTOR3 operator + () const;
    inline XVECTOR3 operator - () const;

    // binary operators
        inline XVECTOR3 operator + ( const XVECTOR3 &op ) const;
    inline XVECTOR3 operator - ( const XVECTOR3 &op ) const;
    inline XVECTOR3 operator * ( float op ) const;
    inline XVECTOR3 operator / ( float op ) const;


    friend XVECTOR3 operator * ( float, const XVECTOR3& );

    inline bool operator == ( const XVECTOR3 &op ) const;
    inline bool operator != ( const XVECTOR3 &op ) const;
};

/******************************************************************************
 * 4d vector
 ******************************************************************************/

typedef struct _VECTOR4
{
    float x;
    float y;
    float z;
    float w;
} VECTOR4;

class XVECTOR4 : public VECTOR4
{
public:
    XVECTOR4();
    XVECTOR4( const float *f );
    XVECTOR4( const VECTOR4 &v );
    XVECTOR4( float _x, float _y, float _z, float _w );

    // casting
    inline operator float* ();
    inline operator const float* () const;

    // assignment operators
    inline XVECTOR4& operator += ( const XVECTOR4 &op );
    inline XVECTOR4& operator -= ( const XVECTOR4 &op );
    inline XVECTOR4& operator *= ( float op );
    inline XVECTOR4& operator /= ( float op );

    // unary operators
    inline XVECTOR4 operator + () const;
    inline XVECTOR4 operator - () const;

    // binary operators
    inline XVECTOR4 operator + ( const XVECTOR4 &op ) const;
    inline XVECTOR4 operator - ( const XVECTOR4 &op ) const;
    inline XVECTOR4 operator * ( float op ) const;
    inline XVECTOR4 operator / ( float op ) const;

    friend XVECTOR4 operator * ( float, const XVECTOR4& );

    inline bool operator == ( const XVECTOR4 &op ) const;
    inline bool operator != ( const XVECTOR4 &op ) const;
};

XVECTOR4 Vec3Transform(XVECTOR4 *pOut, const XVECTOR3 *pV, const XMATRIX *pM);

XMATRIX* MatrixTranspose(XMATRIX* pOut, const XMATRIX* pM);

#endif
Commit	Line	Data
d07c171f	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - VectorMath.h *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2002 Rice1964 *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#ifndef VECTORMATH_H
	23	#define VECTORMATH_H
	24
	25	/******************************************************************************
	26	* 4x4 matrix
	27	******************************************************************************/
	28
	29	typedef struct _MATRIX {
	30	union {
	31	struct {
	32	float _11, _12, _13, _14;
	33	float _21, _22, _23, _24;
	34	float _31, _32, _33, _34;
	35	float _41, _42, _43, _44;
	36	};
	37	float m[4][4];
	38	};
	39	} MATRIX;
	40
	41	typedef struct XMATRIX : public MATRIX {
	42	public:
	43	XMATRIX();
	44	XMATRIX( const float * );
	45	XMATRIX( const MATRIX & );
	46	XMATRIX( float _11, float _12, float _13, float _14,
	47	float _21, float _22, float _23, float _24,
	48	float _31, float _32, float _33, float _34,
	49	float _41, float _42, float _43, float _44 );
	50
	51	float& operator () ( unsigned int Row, unsigned int Col );
	52	float operator () ( unsigned int Row, unsigned int Col ) const;
	53
	54	operator float* ();
	55	operator const float* () const;
	56
	57	// assignment operators
	58	XMATRIX& operator *= ( const XMATRIX & );
	59	XMATRIX& operator += ( const XMATRIX & );
	60	XMATRIX& operator -= ( const XMATRIX & );
	61	XMATRIX& operator *= ( float );
	62	XMATRIX& operator /= ( float );
	63
	64	// unary operators
65	XMATRIX operator + () const;
66	XMATRIX operator - () const;
67
68	// binary operators
69	XMATRIX operator * ( const XMATRIX & ) const;
70	XMATRIX operator + ( const XMATRIX & ) const;
71	XMATRIX operator - ( const XMATRIX & ) const;
72	XMATRIX operator * ( float ) const;
73	XMATRIX operator / ( float ) const;
74	friend XMATRIX operator * ( float, const XMATRIX & );
75	bool operator == ( const XMATRIX & ) const;
76	bool operator != ( const XMATRIX & ) const;
77	} XMATRIX, *LPXMATRIX;
78
79	/******************************************************************************
80	* 3d vector
81	******************************************************************************/
82
83	typedef struct _VECTOR3
84	{
85	float x;
86	float y;
87	float z;
88	} VECTOR3;
89
90	class XVECTOR3 : public VECTOR3
91	{
92	public:
93	XVECTOR3();
94	XVECTOR3( const float *f );
95	XVECTOR3( const VECTOR3 &v );
96	XVECTOR3( float _x, float _y, float _z );
97
98	// casting
99	inline operator float* ();
100	inline operator const float* () const;
101
102	// assignment operators
103	inline XVECTOR3& operator += ( const XVECTOR3 &op );
104	inline XVECTOR3& operator -= ( const XVECTOR3 &op );
105	inline XVECTOR3& operator *= ( float op );
106	inline XVECTOR3& operator /= ( float op );
107
108	// unary operators
109	inline XVECTOR3 operator + () const;
110	inline XVECTOR3 operator - () const;
111
112	// binary operators
113	inline XVECTOR3 operator + ( const XVECTOR3 &op ) const;
114	inline XVECTOR3 operator - ( const XVECTOR3 &op ) const;
115	inline XVECTOR3 operator * ( float op ) const;
116	inline XVECTOR3 operator / ( float op ) const;
117
118
119	friend XVECTOR3 operator * ( float, const XVECTOR3& );
120
121	inline bool operator == ( const XVECTOR3 &op ) const;
122	inline bool operator != ( const XVECTOR3 &op ) const;
123	};
124
125	/******************************************************************************
126	* 4d vector
127	******************************************************************************/
128
129	typedef struct _VECTOR4
130	{
131	float x;
132	float y;
133	float z;
134	float w;
135	} VECTOR4;
136
137	class XVECTOR4 : public VECTOR4
138	{
139	public:
140	XVECTOR4();
141	XVECTOR4( const float *f );
142	XVECTOR4( const VECTOR4 &v );
143	XVECTOR4( float _x, float _y, float _z, float _w );
144
145	// casting
146	inline operator float* ();
147	inline operator const float* () const;
148
149	// assignment operators
150	inline XVECTOR4& operator += ( const XVECTOR4 &op );
151	inline XVECTOR4& operator -= ( const XVECTOR4 &op );
152	inline XVECTOR4& operator *= ( float op );
153	inline XVECTOR4& operator /= ( float op );
154
155	// unary operators
156	inline XVECTOR4 operator + () const;
157	inline XVECTOR4 operator - () const;
158
159	// binary operators
160	inline XVECTOR4 operator + ( const XVECTOR4 &op ) const;
161	inline XVECTOR4 operator - ( const XVECTOR4 &op ) const;
162	inline XVECTOR4 operator * ( float op ) const;
163	inline XVECTOR4 operator / ( float op ) const;
164
165	friend XVECTOR4 operator * ( float, const XVECTOR4& );
166
167	inline bool operator == ( const XVECTOR4 &op ) const;
168	inline bool operator != ( const XVECTOR4 &op ) const;
169	};
170
171	XVECTOR4 Vec3Transform(XVECTOR4 pOut, const XVECTOR3 pV, const XMATRIX *pM);
172
173	XMATRIX* MatrixTranspose(XMATRIX* pOut, const XMATRIX* pM);
174
175	#endif
176