source: trunk/src/math/vector.cpp @ 1401

Last change on this file since 1401 was 1401, checked in by sam, 10 years ago

core: no longer deactivate std::ostream features on Android.

  • Property svn:keywords set to Id
File size: 18.5 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2012 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#if defined HAVE_CONFIG_H
12#   include "config.h"
13#endif
14
15#if defined _XBOX
16#   define _USE_MATH_DEFINES /* for M_PI */
17#   include <xtl.h>
18#   undef near /* Fuck Microsoft */
19#   undef far /* Fuck Microsoft again */
20#elif defined _WIN32
21#   define _USE_MATH_DEFINES /* for M_PI */
22#   define WIN32_LEAN_AND_MEAN
23#   include <windows.h>
24#   undef near /* Fuck Microsoft */
25#   undef far /* Fuck Microsoft again */
26#endif
27
28#include <cmath> /* for M_PI */
29#include <cstdlib> /* free() */
30#include <cstring> /* strdup() */
31
32#include <ostream> /* std::ostream */
33
34#include "core.h"
35
36using namespace std;
37
38namespace lol
39{
40
41static inline float det2(float a, float b,
42                         float c, float d)
43{
44    return a * d - b * c;
45}
46
47static inline float det3(float a, float b, float c,
48                         float d, float e, float f,
49                         float g, float h, float i)
50{
51    return a * (e * i - h * f)
52         + b * (f * g - i * d)
53         + c * (d * h - g * e);
54}
55
56static inline float cofact(mat2 const &mat, int i, int j)
57{
58    return mat[(i + 1) & 1][(j + 1) & 1] * (((i + j) & 1) ? -1.0f : 1.0f);
59}
60
61static inline float cofact(mat3 const &mat, int i, int j)
62{
63    return det2(mat[(i + 1) % 3][(j + 1) % 3],
64                mat[(i + 2) % 3][(j + 1) % 3],
65                mat[(i + 1) % 3][(j + 2) % 3],
66                mat[(i + 2) % 3][(j + 2) % 3]);
67}
68
69static inline float cofact(mat4 const &mat, int i, int j)
70{
71    return det3(mat[(i + 1) & 3][(j + 1) & 3],
72                mat[(i + 2) & 3][(j + 1) & 3],
73                mat[(i + 3) & 3][(j + 1) & 3],
74                mat[(i + 1) & 3][(j + 2) & 3],
75                mat[(i + 2) & 3][(j + 2) & 3],
76                mat[(i + 3) & 3][(j + 2) & 3],
77                mat[(i + 1) & 3][(j + 3) & 3],
78                mat[(i + 2) & 3][(j + 3) & 3],
79                mat[(i + 3) & 3][(j + 3) & 3]) * (((i + j) & 1) ? -1.0f : 1.0f);
80}
81
82template<> float determinant(mat2 const &mat)
83{
84    return mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0];
85}
86
87template<> mat2 transpose(mat2 const &mat)
88{
89    mat2 ret;
90    for (int j = 0; j < 2; j++)
91        for (int i = 0; i < 2; i++)
92            ret[j][i] = mat[i][j];
93    return ret;
94}
95
96template<> mat2 inverse(mat2 const &mat)
97{
98    mat2 ret;
99    float d = determinant(mat);
100    if (d)
101    {
102        d = 1.0f / d;
103        for (int j = 0; j < 2; j++)
104            for (int i = 0; i < 2; i++)
105                ret[j][i] = cofact(mat, i, j) * d;
106    }
107    return ret;
108}
109
110template<> float determinant(mat3 const &mat)
111{
112    return det3(mat[0][0], mat[0][1], mat[0][2],
113                mat[1][0], mat[1][1], mat[1][2],
114                mat[2][0], mat[2][1], mat[2][2]);
115}
116
117template<> mat3 transpose(mat3 const &mat)
118{
119    mat3 ret;
120    for (int j = 0; j < 3; j++)
121        for (int i = 0; i < 3; i++)
122            ret[j][i] = mat[i][j];
123    return ret;
124}
125
126template<> mat3 inverse(mat3 const &mat)
127{
128    mat3 ret;
129    float d = determinant(mat);
130    if (d)
131    {
132        d = 1.0f / d;
133        for (int j = 0; j < 3; j++)
134            for (int i = 0; i < 3; i++)
135                ret[j][i] = cofact(mat, i, j) * d;
136    }
137    return ret;
138}
139
140template<> float determinant(mat4 const &mat)
141{
142    float ret = 0;
143    for (int n = 0; n < 4; n++)
144        ret += mat[n][0] * cofact(mat, n, 0);
145    return ret;
146}
147
148template<> mat4 transpose(mat4 const &mat)
149{
150    mat4 ret;
151    for (int j = 0; j < 4; j++)
152        for (int i = 0; i < 4; i++)
153            ret[j][i] = mat[i][j];
154    return ret;
155}
156
157template<> mat4 inverse(mat4 const &mat)
158{
159    mat4 ret;
160    float d = determinant(mat);
161    if (d)
162    {
163        d = 1.0f / d;
164        for (int j = 0; j < 4; j++)
165            for (int i = 0; i < 4; i++)
166                ret[j][i] = cofact(mat, i, j) * d;
167    }
168    return ret;
169}
170
171template<> void vec2::printf() const
172{
173    Log::Debug("[ %6.6f %6.6f ]\n", x, y);
174}
175
176template<> void ivec2::printf() const
177{
178    Log::Debug("[ %i %i ]\n", x, y);
179}
180
181template<> void cmplx::printf() const
182{
183    Log::Debug("[ %6.6f %6.6f ]\n", x, y);
184}
185
186template<> void vec3::printf() const
187{
188    Log::Debug("[ %6.6f %6.6f %6.6f ]\n", x, y, z);
189}
190
191template<> void ivec3::printf() const
192{
193    Log::Debug("[ %i %i %i ]\n", x, y, z);
194}
195
196template<> void vec4::printf() const
197{
198    Log::Debug("[ %6.6f %6.6f %6.6f %6.6f ]\n", x, y, z, w);
199}
200
201template<> void ivec4::printf() const
202{
203    Log::Debug("[ %i %i %i %i ]\n", x, y, z, w);
204}
205
206template<> void quat::printf() const
207{
208    Log::Debug("[ %6.6f %6.6f %6.6f %6.6f ]\n", w, x, y, z);
209}
210
211template<> void mat2::printf() const
212{
213    mat2 const &p = *this;
214
215    Log::Debug("[ %6.6f %6.6f\n", p[0][0], p[1][0]);
216    Log::Debug("  %6.6f %6.6f ]\n", p[0][1], p[1][1]);
217}
218
219template<> void mat3::printf() const
220{
221    mat3 const &p = *this;
222
223    Log::Debug("[ %6.6f %6.6f %6.6f\n", p[0][0], p[1][0], p[2][0]);
224    Log::Debug("  %6.6f %6.6f %6.6f\n", p[0][1], p[1][1], p[2][1]);
225    Log::Debug("  %6.6f %6.6f %6.6f ]\n", p[0][2], p[1][2], p[2][2]);
226}
227
228template<> void mat4::printf() const
229{
230    mat4 const &p = *this;
231
232    Log::Debug("[ %6.6f %6.6f %6.6f %6.6f\n",
233               p[0][0], p[1][0], p[2][0], p[3][0]);
234    Log::Debug("  %6.6f %6.6f %6.6f %6.6f\n",
235               p[0][1], p[1][1], p[2][1], p[3][1]);
236    Log::Debug("  %6.6f %6.6f %6.6f %6.6f\n",
237               p[0][2], p[1][2], p[2][2], p[3][2]);
238    Log::Debug("  %6.6f %6.6f %6.6f %6.6f ]\n",
239               p[0][3], p[1][3], p[2][3], p[3][3]);
240}
241
242template<> std::ostream &operator<<(std::ostream &stream, ivec2 const &v)
243{
244    return stream << "(" << v.x << ", " << v.y << ")";
245}
246
247template<> std::ostream &operator<<(std::ostream &stream, icmplx const &v)
248{
249    return stream << "(" << v.x << ", " << v.y << ")";
250}
251
252template<> std::ostream &operator<<(std::ostream &stream, ivec3 const &v)
253{
254    return stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
255}
256
257template<> std::ostream &operator<<(std::ostream &stream, ivec4 const &v)
258{
259    return stream << "(" << v.x << ", " << v.y << ", "
260                         << v.z << ", " << v.w << ")";
261}
262
263template<> std::ostream &operator<<(std::ostream &stream, iquat const &v)
264{
265    return stream << "(" << v.x << ", " << v.y << ", "
266                         << v.z << ", " << v.w << ")";
267}
268
269template<> std::ostream &operator<<(std::ostream &stream, vec2 const &v)
270{
271    return stream << "(" << v.x << ", " << v.y << ")";
272}
273
274template<> std::ostream &operator<<(std::ostream &stream, cmplx const &v)
275{
276    return stream << "(" << v.x << ", " << v.y << ")";
277}
278
279template<> std::ostream &operator<<(std::ostream &stream, vec3 const &v)
280{
281    return stream << "(" << v.x << ", " << v.y << ", " << v.z << ")";
282}
283
284template<> std::ostream &operator<<(std::ostream &stream, vec4 const &v)
285{
286    return stream << "(" << v.x << ", " << v.y << ", "
287                         << v.z << ", " << v.w << ")";
288}
289
290template<> std::ostream &operator<<(std::ostream &stream, quat const &v)
291{
292    return stream << "(" << v.x << ", " << v.y << ", "
293                         << v.z << ", " << v.w << ")";
294}
295
296template<> std::ostream &operator<<(std::ostream &stream, mat4 const &m)
297{
298    stream << "((" << m[0][0] << ", " << m[1][0]
299            << ", " << m[2][0] << ", " << m[3][0] << "), ";
300    stream << "(" << m[0][1] << ", " << m[1][1]
301           << ", " << m[2][1] << ", " << m[3][1] << "), ";
302    stream << "(" << m[0][2] << ", " << m[1][2]
303           << ", " << m[2][2] << ", " << m[3][2] << "), ";
304    stream << "(" << m[0][3] << ", " << m[1][3]
305           << ", " << m[2][3] << ", " << m[3][3] << "))";
306    return stream;
307}
308
309template<> mat3 mat3::scale(float x, float y, float z)
310{
311    mat3 ret(1.0f);
312
313    ret[0][0] = x;
314    ret[1][1] = y;
315    ret[2][2] = z;
316
317    return ret;
318}
319
320template<> mat3 mat3::scale(vec3 v)
321{
322    return scale(v.x, v.y, v.z);
323}
324
325template<> mat4 mat4::translate(float x, float y, float z)
326{
327    mat4 ret(1.0f);
328    ret[3][0] = x;
329    ret[3][1] = y;
330    ret[3][2] = z;
331    return ret;
332}
333
334template<> mat4 mat4::translate(vec3 v)
335{
336    return translate(v.x, v.y, v.z);
337}
338
339template<> mat2 mat2::rotate(float angle)
340{
341    angle *= (M_PI / 180.0f);
342
343    float st = std::sin(angle);
344    float ct = std::cos(angle);
345
346    mat2 ret;
347
348    ret[0][0] = ct;
349    ret[0][1] = st;
350
351    ret[1][0] = -st;
352    ret[1][1] = ct;
353
354    return ret;
355}
356
357template<> mat3 mat3::rotate(float angle, float x, float y, float z)
358{
359    angle *= (M_PI / 180.0f);
360
361    float st = std::sin(angle);
362    float ct = std::cos(angle);
363
364    float len = std::sqrt(x * x + y * y + z * z);
365    float invlen = len ? 1.0f / len : 0.0f;
366    x *= invlen;
367    y *= invlen;
368    z *= invlen;
369
370    float mtx = (1.0f - ct) * x;
371    float mty = (1.0f - ct) * y;
372    float mtz = (1.0f - ct) * z;
373
374    mat3 ret;
375
376    ret[0][0] = x * mtx + ct;
377    ret[0][1] = x * mty + st * z;
378    ret[0][2] = x * mtz - st * y;
379
380    ret[1][0] = y * mtx - st * z;
381    ret[1][1] = y * mty + ct;
382    ret[1][2] = y * mtz + st * x;
383
384    ret[2][0] = z * mtx + st * y;
385    ret[2][1] = z * mty - st * x;
386    ret[2][2] = z * mtz + ct;
387
388    return ret;
389}
390
391template<> mat3 mat3::rotate(float angle, vec3 v)
392{
393    return rotate(angle, v.x, v.y, v.z);
394}
395
396template<> mat3::Mat3(quat const &q)
397{
398    float n = norm(q);
399
400    if (!n)
401    {
402        for (int j = 0; j < 3; j++)
403            for (int i = 0; i < 3; i++)
404                (*this)[i][j] = (i == j) ? 1.f : 0.f;
405        return;
406    }
407
408    float s = 2.0f / n;
409
410    v0[0] = 1.0f - s * (q.y * q.y + q.z * q.z);
411    v0[1] = s * (q.x * q.y + q.z * q.w);
412    v0[2] = s * (q.x * q.z - q.y * q.w);
413
414    v1[0] = s * (q.x * q.y - q.z * q.w);
415    v1[1] = 1.0f - s * (q.z * q.z + q.x * q.x);
416    v1[2] = s * (q.y * q.z + q.x * q.w);
417
418    v2[0] = s * (q.x * q.z + q.y * q.w);
419    v2[1] = s * (q.y * q.z - q.x * q.w);
420    v2[2] = 1.0f - s * (q.x * q.x + q.y * q.y);
421}
422
423template<> mat4::Mat4(quat const &q)
424{
425    *this = mat4(mat3(q), 1.f);
426}
427
428static inline void MatrixToQuat(quat &that, mat3 const &m)
429{
430    /* See http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/christian.htm for a version with no branches */
431    float t = m[0][0] + m[1][1] + m[2][2];
432    if (t > 0)
433    {
434        that.w = 0.5f * std::sqrt(1.0f + t);
435        float s = 0.25f / that.w;
436        that.x = s * (m[1][2] - m[2][1]);
437        that.y = s * (m[2][0] - m[0][2]);
438        that.z = s * (m[0][1] - m[1][0]);
439    }
440    else if (m[0][0] > m[1][1] && m[0][0] > m[2][2])
441    {
442        that.x = 0.5f * std::sqrt(1.0f + m[0][0] - m[1][1] - m[2][2]);
443        float s = 0.25f / that.x;
444        that.y = s * (m[0][1] + m[1][0]);
445        that.z = s * (m[2][0] + m[0][2]);
446        that.w = s * (m[1][2] - m[2][1]);
447    }
448    else if (m[1][1] > m[2][2])
449    {
450        that.y = 0.5f * std::sqrt(1.0f - m[0][0] + m[1][1] - m[2][2]);
451        float s = 0.25f / that.y;
452        that.x = s * (m[0][1] + m[1][0]);
453        that.z = s * (m[1][2] + m[2][1]);
454        that.w = s * (m[2][0] - m[0][2]);
455    }
456    else
457    {
458        that.z = 0.5f * std::sqrt(1.0f - m[0][0] - m[1][1] + m[2][2]);
459        float s = 0.25f / that.z;
460        that.x = s * (m[2][0] + m[0][2]);
461        that.y = s * (m[1][2] + m[2][1]);
462        that.w = s * (m[0][1] - m[1][0]);
463    }
464}
465
466template<> quat::Quat(mat3 const &m)
467{
468    MatrixToQuat(*this, m);
469}
470
471template<> quat::Quat(mat4 const &m)
472{
473    MatrixToQuat(*this, mat3(m));
474}
475
476template<> quat quat::rotate(float angle, vec3 const &v)
477{
478    angle *= (M_PI / 360.0f);
479
480    vec3 tmp = normalize(v) * std::sin(angle);
481
482    return quat(std::cos(angle), tmp.x, tmp.y, tmp.z);
483}
484
485template<> quat quat::rotate(float angle, float x, float y, float z)
486{
487    return quat::rotate(angle, vec3(x, y, z));
488}
489
490template<> vec3 vec3::toeuler(quat const &q)
491{
492    using std::atan2;
493    using std::asin;
494
495    float n = norm(q);
496
497    if (!n)
498        return vec3(0.f);
499
500    vec3 ret(atan2(2.f * (q.w * q.x + q.y * q.z),
501                   1.f - 2.f * (q.x * q.x + q.y * q.y)),
502             asin(2.f * (q.w * q.y - q.z * q.x)),
503             atan2(2.f * (q.w * q.z + q.y * q.x),
504                   1.f - 2.f * (q.z * q.z + q.y * q.y)));
505
506    return (180.0f / M_PI / n) * ret;
507}
508
509static inline mat3 mat3_fromeuler_generic(vec3 const &v, int i, int j, int k)
510{
511    using std::sin;
512    using std::cos;
513    mat3 ret;
514
515    vec3 radians = (M_PI / 180.0f) * v;
516    float s0 = sin(radians[0]), c0 = cos(radians[0]);
517    float s1 = sin(radians[1]), c1 = cos(radians[1]);
518    float s2 = sin(radians[2]), c2 = cos(radians[2]);
519
520    if (k == i)
521    {
522        k = 3 - i - j;
523
524        ret[i][i] =   c1;
525        ret[j][i] =   s1 * s2;
526        ret[i][j] =   s0 * s1;
527        ret[j][j] =   c0 * c2 - s0 * c1 * s2;
528        ret[k][k] = - s0 * s2 + c0 * c1 * c2;
529
530        if ((2 + i - j) % 3)
531        {
532            ret[k][i] =   s1 * c2;
533            ret[k][j] = - c0 * s2 - s0 * c1 * c2;
534            ret[i][k] = - c0 * s1;
535            ret[j][k] =   s0 * c2 + c0 * c1 * s2;
536        }
537        else
538        {
539            ret[k][i] = - s1 * c2;
540            ret[k][j] =   c0 * s2 + s0 * c1 * c2;
541            ret[i][k] =   c0 * s1;
542            ret[j][k] = - s0 * c2 - c0 * c1 * s2;
543        }
544    }
545    else
546    {
547        ret[i][i] =   c1 * c2;
548        ret[k][k] =   c0 * c1;
549
550        if ((2 + i - j) % 3)
551        {
552            ret[j][i] = - c1 * s2;
553            ret[k][i] =   s1;
554
555            ret[i][j] =   c0 * s2 + s0 * s1 * c2;
556            ret[j][j] =   c0 * c2 - s0 * s1 * s2;
557            ret[k][j] = - s0 * c1;
558
559            ret[i][k] =   s0 * s2 - c0 * s1 * c2;
560            ret[j][k] =   s0 * c2 + c0 * s1 * s2;
561        }
562        else
563        {
564            ret[j][i] =   c1 * s2;
565            ret[k][i] = - s1;
566
567            ret[i][j] = - c0 * s2 + s0 * s1 * c2;
568            ret[j][j] =   c0 * c2 + s0 * s1 * s2;
569            ret[k][j] =   s0 * c1;
570
571            ret[i][k] =   s0 * s2 + c0 * s1 * c2;
572            ret[j][k] = - s0 * c2 + c0 * s1 * s2;
573        }
574    }
575
576    return ret;
577}
578
579static inline quat quat_fromeuler_generic(vec3 const &v, int i, int j, int k)
580{
581    using std::sin;
582    using std::cos;
583
584    vec3 half_angles = (M_PI / 360.0f) * v;
585    float s0 = sin(half_angles[0]), c0 = cos(half_angles[0]);
586    float s1 = sin(half_angles[1]), c1 = cos(half_angles[1]);
587    float s2 = sin(half_angles[2]), c2 = cos(half_angles[2]);
588
589    quat ret;
590
591    if (k == i)
592    {
593        k = 3 - i - j;
594
595        ret[0] = c1 * (c0 * c2 - s0 * s2);
596        ret[1 + i] = c1 * (c0 * s2 + s0 * c2);
597        ret[1 + j] = s1 * (c0 * c2 + s0 * s2);
598        ret[1 + k] = ((2 + i - j) % 3) ? s1 * (s0 * c2 - c0 * s2)
599                                       : s1 * (c0 * s2 - s0 * c2);
600    }
601    else
602    {
603        vec4 v1(c0 * c1 * c2,  s0 * c1 * c2, c0 * s1 * c2,  c0 * c1 * s2);
604        vec4 v2(s0 * s1 * s2, -c0 * s1 * s2, s0 * c1 * s2, -s0 * s1 * c2);
605
606        if ((2 + i - j) % 3)
607            v1 -= v2;
608        else
609            v1 += v2;
610
611        ret[0] = v1[0];
612        ret[1 + i] = v1[1];
613        ret[1 + j] = v1[2];
614        ret[1 + k] = v1[3];
615    }
616
617    return ret;
618}
619
620#define DEFINE_FROMEULER_GENERIC(name, i, j, k) \
621    template<> quat quat::fromeuler_##name(vec3 const &v) \
622    { \
623        return quat_fromeuler_generic(v, i, j, k); \
624    } \
625    \
626    template<> quat quat::fromeuler_##name(float phi, float theta, float psi) \
627    { \
628        return quat::fromeuler_##name(vec3(phi, theta, psi)); \
629    } \
630    \
631    template<> mat3 mat3::fromeuler_##name(vec3 const &v) \
632    { \
633        return mat3_fromeuler_generic(v, i, j, k); \
634    } \
635    \
636    template<> mat3 mat3::fromeuler_##name(float phi, float theta, float psi) \
637    { \
638        return mat3::fromeuler_##name(vec3(phi, theta, psi)); \
639    } \
640    \
641    template<> mat4 mat4::fromeuler_##name(vec3 const &v) \
642    { \
643        return mat4(mat3_fromeuler_generic(v, i, j, k), 1.f); \
644    } \
645    \
646    template<> mat4 mat4::fromeuler_##name(float phi, float theta, float psi) \
647    { \
648        return mat4::fromeuler_##name(vec3(phi, theta, psi)); \
649    }
650
651DEFINE_FROMEULER_GENERIC(xyx, 0, 1, 0)
652DEFINE_FROMEULER_GENERIC(xzx, 0, 2, 0)
653DEFINE_FROMEULER_GENERIC(yxy, 1, 0, 1)
654DEFINE_FROMEULER_GENERIC(yzy, 1, 2, 1)
655DEFINE_FROMEULER_GENERIC(zxz, 2, 0, 2)
656DEFINE_FROMEULER_GENERIC(zyz, 2, 1, 2)
657
658DEFINE_FROMEULER_GENERIC(xyz, 0, 1, 2)
659DEFINE_FROMEULER_GENERIC(xzy, 0, 2, 1)
660DEFINE_FROMEULER_GENERIC(yxz, 1, 0, 2)
661DEFINE_FROMEULER_GENERIC(yzx, 1, 2, 0)
662DEFINE_FROMEULER_GENERIC(zxy, 2, 0, 1)
663DEFINE_FROMEULER_GENERIC(zyx, 2, 1, 0)
664
665#undef DEFINE_FROMEULER_GENERIC
666
667template<> mat4 mat4::lookat(vec3 eye, vec3 center, vec3 up)
668{
669    vec3 v3 = normalize(eye - center);
670    vec3 v2 = normalize(up);
671    vec3 v1 = normalize(cross(v2, v3));
672    v2 = cross(v3, v1);
673
674    mat4 orient(1.0f);
675    orient[0][0] = v1.x;
676    orient[0][1] = v2.x;
677    orient[0][2] = v3.x;
678    orient[1][0] = v1.y;
679    orient[1][1] = v2.y;
680    orient[1][2] = v3.y;
681    orient[2][0] = v1.z;
682    orient[2][1] = v2.z;
683    orient[2][2] = v3.z;
684
685    return orient * mat4::translate(-eye);
686}
687
688template<> mat4 mat4::ortho(float left, float right, float bottom,
689                            float top, float near, float far)
690{
691    float invrl = (right != left) ? 1.0f / (right - left) : 0.0f;
692    float invtb = (top != bottom) ? 1.0f / (top - bottom) : 0.0f;
693    float invfn = (far != near) ? 1.0f / (far - near) : 0.0f;
694
695    mat4 ret(0.0f);
696    ret[0][0] = 2.0f * invrl;
697    ret[1][1] = 2.0f * invtb;
698    ret[2][2] = -2.0f * invfn;
699    ret[3][0] = - (right + left) * invrl;
700    ret[3][1] = - (top + bottom) * invtb;
701    ret[3][2] = - (far + near) * invfn;
702    ret[3][3] = 1.0f;
703    return ret;
704}
705
706template<> mat4 mat4::ortho(float width, float height,
707                            float near, float far)
708{
709    return mat4::ortho(-0.5f * width, 0.5f * width,
710                       -0.5f * height, 0.5f * height, near, far);
711}
712
713template<> mat4 mat4::frustum(float left, float right, float bottom,
714                              float top, float near, float far)
715{
716    float invrl = (right != left) ? 1.0f / (right - left) : 0.0f;
717    float invtb = (top != bottom) ? 1.0f / (top - bottom) : 0.0f;
718    float invfn = (far != near) ? 1.0f / (far - near) : 0.0f;
719
720    mat4 ret(0.0f);
721    ret[0][0] = 2.0f * near * invrl;
722    ret[1][1] = 2.0f * near * invtb;
723    ret[2][0] = (right + left) * invrl;
724    ret[2][1] = (top + bottom) * invtb;
725    ret[2][2] = - (far + near) * invfn;
726    ret[2][3] = -1.0f;
727    ret[3][2] = -2.0f * far * near * invfn;
728    return ret;
729}
730
731template<> mat4 mat4::perspective(float fov_y, float width,
732                                  float height, float near, float far)
733{
734    fov_y *= (M_PI / 180.0f);
735
736    float t2 = tanf(fov_y * 0.5f);
737    float t1 = t2 * width / height;
738
739    return frustum(-near * t1, near * t1, -near * t2, near * t2, near, far);
740}
741
742} /* namespace lol */
743
Note: See TracBrowser for help on using the repository browser.