# source:abuse/trunk/src/lol/matrix.h@516Tweet

Last change on this file since 516 was 516, checked in by Sam Hocevar, 11 years ago

lol: import newer matrix.h from Lol Engine.

• Property svn:keywords set to `Id`
File size: 6.9 KB
Line
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2011 Sam Hocevar <sam@hocevar.net>
5//   This program is free software; you can redistribute it and/or
6//   modify it under the terms of the Do What The Fuck You Want To
7//   Public License, Version 2, as published by Sam Hocevar. See
8//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
9//
10
11//
12// The Matrix classes
13// ------------------
14//
15
16#if !defined __LOL_MATRIX_H__
17#define __LOL_MATRIX_H__
18
19#include <cmath>
20
21namespace lol
22{
23
24#define VECTOR_OP(elems, op) \
25    template<typename U> \
26    inline Vec##elems<T> operator op(Vec##elems<U> const &val) const \
27    { \
28        Vec##elems<T> ret; \
29        for (int n = 0; n < elems; n++) \
30            ret[n] = (*this)[n] op val[n]; \
31        return ret; \
32    } \
33    \
34    template<typename U> \
35    inline Vec##elems<T> operator op##=(Vec##elems<U> const &val) \
36    { \
37        return *this = (*this) op val; \
38    }
39
40#define BOOL_OP(elems, op, op2, ret) \
41    inline bool operator op(Vec##elems<T> const &val) const \
42    { \
43        for (int n = 0; n < elems; n++) \
44            if (!((*this)[n] op2 val[n])) \
45                return !ret; \
46        return ret; \
47    }
48
49#define SCALAR_OP(elems, op) \
50    inline Vec##elems<T> operator op(T const &val) const \
51    { \
52        Vec##elems<T> ret; \
53        for (int n = 0; n < elems; n++) \
54            ret[n] = (*this)[n] op val; \
55        return ret; \
56    } \
57    \
58    inline Vec##elems<T> operator op##=(T const &val) \
59    { \
60        return *this = (*this) op val; \
61    }
62
63#define CAST_OP(elems, dest) \
64    inline operator Vec##dest<T>() const \
65    { \
66        Vec##dest<T> ret; \
67        for (int n = 0; n < elems && n < dest; n++) \
68            ret[n] = (*this)[n]; \
69        return ret; \
70    }
71
72#define OPERATORS(elems) \
73    inline T& operator[](int n) { return *(&x + n); } \
74    inline T const& operator[](int n) const { return *(&x + n); } \
75    \
76    VECTOR_OP(elems, -) \
77    VECTOR_OP(elems, +) \
78    VECTOR_OP(elems, *) \
79    VECTOR_OP(elems, /) \
80    \
81    BOOL_OP(elems, ==, ==, true) \
82    BOOL_OP(elems, !=, ==, false) \
83    BOOL_OP(elems, <=, <=, true) \
84    BOOL_OP(elems, >=, >=, true) \
85    BOOL_OP(elems, <, <, true) \
86    BOOL_OP(elems, >, >, true) \
87    \
88    SCALAR_OP(elems, -) \
89    SCALAR_OP(elems, +) \
90    SCALAR_OP(elems, *) \
91    SCALAR_OP(elems, /) \
92    \
93    CAST_OP(elems, 2) \
94    CAST_OP(elems, 3) \
95    CAST_OP(elems, 4) \
96    \
97    template<typename U> \
98    inline operator Vec##elems<U>() const \
99    { \
100        Vec##elems<U> ret; \
101        for (int n = 0; n < elems; n++) \
102            ret[n] = static_cast<U>((*this)[n]); \
103        return ret; \
104    } \
105    \
106    inline T sqlen() const \
107    { \
108        T acc = 0; \
109        for (int n = 0; n < elems; n++) \
110            acc += (*this)[n] * (*this)[n]; \
111        return acc; \
112    } \
113    \
114    inline float len() const \
115    { \
116        return sqrtf((float)sqlen()); \
117    }
118
119template <typename T> struct Vec2;
120template <typename T> struct Vec3;
121template <typename T> struct Vec4;
122
123template <typename T> struct Vec2
124{
125    inline Vec2() { }
126    inline Vec2(T val) { x = y = val; }
127    inline Vec2(T _x, T _y) { x = _x; y = _y; }
128
129    OPERATORS(2)
130
131    union { T x; T a; T i; };
132    union { T y; T b; T j; };
133};
134
135typedef Vec2<float> vec2;
136typedef Vec2<int> vec2i;
137
138template <typename T> struct Vec3
139{
140    inline Vec3() { }
141    inline Vec3(T val) { x = y = z = val; }
142    inline Vec3(T _x, T _y, T _z) { x = _x; y = _y; z = _z; }
143
144    OPERATORS(3)
145
146    union { T x; T a; T i; };
147    union { T y; T b; T j; };
148    union { T z; T c; T k; };
149};
150
151typedef Vec3<float> vec3;
152typedef Vec3<int> vec3i;
153
154template <typename T> struct Vec4
155{
156    inline Vec4() { }
157    inline Vec4(T val) { x = y = z = w = val; }
158    inline Vec4(T _x, T _y, T _z, T _w) { x = _x; y = _y; z = _z; w = _w; }
159
160    OPERATORS(4)
161
162    union { T x; T a; T i; };
163    union { T y; T b; T j; };
164    union { T z; T c; T k; };
165    union { T w; T d; T l; };
166};
167
168typedef Vec4<float> vec4;
169typedef Vec4<int> vec4i;
170
171#define SCALAR_GLOBAL(elems, op, U) \
172    template<typename T> \
173    static inline Vec##elems<U> operator op(U const &val, \
174                                            Vec##elems<T> const &that) \
175    { \
176        Vec##elems<U> ret; \
177        for (int n = 0; n < elems; n++) \
178            ret[n] = val op that[n]; \
179        return ret; \
180    }
181
182#define SCALAR_GLOBAL2(elems, op) \
183    SCALAR_GLOBAL(elems, op, int) \
184    SCALAR_GLOBAL(elems, op, float)
185
186#define GLOBALS(elems) \
187    SCALAR_GLOBAL2(elems, -) \
188    SCALAR_GLOBAL2(elems, +) \
189    SCALAR_GLOBAL2(elems, *) \
190    SCALAR_GLOBAL2(elems, /)
191
192GLOBALS(2)
193GLOBALS(3)
194GLOBALS(4)
195
196template <typename T> struct Mat4
197{
198    inline Mat4() { }
199    inline Mat4(T val)
200    {
201        for (int j = 0; j < 4; j++)
202            for (int i = 0; i < 4; i++)
203                v[i][j] = (i == j) ? val : 0;
204    }
205    inline Mat4(Vec4<T> v0, Vec4<T> v1, Vec4<T> v2, Vec4<T> v3)
206    {
207        v[0] = v0; v[1] = v1; v[2] = v2; v[3] = v3;
208    }
209
210    inline Vec4<T>& operator[](int n) { return v[n]; }
211    inline Vec4<T> const& operator[](int n) const { return v[n]; }
212
213    T det() const;
214    Mat4<T> invert() const;
215
216    static Mat4<T> ortho(T left, T right, T bottom, T top, T near, T far);
217    static Mat4<T> frustum(T left, T right, T bottom, T top, T near, T far);
218    static Mat4<T> perspective(T theta, T width, T height, T near, T far);
219    static Mat4<T> translate(T x, T y, T z);
220    static Mat4<T> rotate(T theta, T x, T y, T z);
221
222    void printf() const;
223
224    inline Mat4<T> operator +(Mat4<T> const val) const
225    {
226        Mat4<T> ret;
227        for (int j = 0; j < 4; j++)
228            for (int i = 0; i < 4; i++)
229                ret[i][j] = v[i][j] + val[i][j];
230        return ret;
231    }
232
233    inline Mat4<T> operator +=(Mat4<T> const val)
234    {
235        return *this = *this + val;
236    }
237
238    inline Mat4<T> operator -(Mat4<T> const val) const
239    {
240        Mat4<T> ret;
241        for (int j = 0; j < 4; j++)
242            for (int i = 0; i < 4; i++)
243                ret[i][j] = v[i][j] - val[i][j];
244        return ret;
245    }
246
247    inline Mat4<T> operator -=(Mat4<T> const val)
248    {
249        return *this = *this - val;
250    }
251
252    inline Mat4<T> operator *(Mat4<T> const val) const
253    {
254        Mat4<T> ret;
255        for (int j = 0; j < 4; j++)
256            for (int i = 0; i < 4; i++)
257            {
258                T tmp = 0;
259                for (int k = 0; k < 4; k++)
260                    tmp += v[k][j] * val[i][k];
261                ret[i][j] = tmp;
262            }
263        return ret;
264    }
265
266    inline Mat4<T> operator *=(Mat4<T> const val)
267    {
268        return *this = *this * val;
269    }
270
271    inline Vec4<T> operator *(Vec4<T> const val) const
272    {
273        Vec4<T> ret;
274        for (int j = 0; j < 4; j++)
275        {
276            T tmp = 0;
277            for (int i = 0; i < 4; i++)
278                tmp += v[i][j] * val[i];
279            ret[j] = tmp;
280        }
281        return ret;
282    }
283
284    Vec4<T> v[4];
285};
286
287typedef Mat4<float> mat4;
288typedef Mat4<int> mat4i;
289
290} /* namespace lol */
291
292#endif // __LOL_MATRIX_H__
293
Note: See TracBrowser for help on using the repository browser.