lolengine
/
lolengine
огледало од https://github.com/lolengine/lolengine
1
0
Креирај огранак 0
Код Дискусије 0 Издања 2 Вики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2194 Комити
10 Гране
141 MiB
 
 
 
 
 
 
Дрво: 11dc5eebcc
Гране Ознаке
${ item.name }
Create branch ${ searchTerm }
from '11dc5eebcc'
${ noResults }
lolengine/src/lol/math/vector.h

1084 lines
40 KiB
Датотека Blame Историја 

  1. //

  2. // Lol Engine

  3. //

  4. // Copyright: (c) 2010-2014 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://www.wtfpl.net/ for more details.

  9. //

  10. 

  11. //

  12. // The vector classes

  13. // ------------------

  14. //

  15. 

  16. #if !defined __LOL_MATH_VECTOR_H__

  17. #define __LOL_MATH_VECTOR_H__

  18. 

  19. #include <ostream>

  20. 

  21. #include <lol/math/half.h>

  22. #include <lol/math/real.h>

  23. #include <lol/math/ops.h>

  24. 

  25. namespace lol

  26. {

  27. 

  28. #if !LOL_FEATURE_CXX11_CONSTEXPR

  29. #   define constexpr /* */

  30. #endif

  31. 

  32. #if !LOL_FEATURE_CXX11_RELAXED_UNIONS

  33. #   define _____ const

  34. #else

  35. #   define _____ /* */

  36. #endif

  37. 

  38. /*

  39.  * Magic vector swizzling (part 1/2)

  40.  * These vectors are empty, but thanks to static_cast we can take their

  41.  * address and access the vector of T's that they are union'ed with. We

  42.  * use static_cast instead of reinterpret_cast because there is a stronger

  43.  * guarantee (by the standard) that the address will stay the same across

  44.  * casts.

  45.  * We need to implement an assignment operator _and_ override the default

  46.  * assignment operator. We try to pass arguments by value so that we don't

  47.  * have to care about overwriting ourselves (e.g. c.rgb = c.bgr).

  48.  * However, Visual Studio 2012 doesn't support unrestricted unions, so

  49.  * fuck it.

  50.  */

  51. 

  52. template<typename T, int N, int SWIZZLE>

  53. struct vec_t

  54.     /* MUST be a different base than e.g. vec_t<T,2> otherwise the unions

  55.      * in vec_t<T,2> with the same base will cause empty base optimisation

  56.      * failures. */

  57.   : public swizzle_ops::base<T, SWIZZLE>

  58. {

  59.     static int const count = N;

  60.     typedef T element;

  61.     typedef vec_t<T,N> type;

  62. 

  63.     inline vec_t<T, N, SWIZZLE>& operator =(vec_t<T, N> that);

  64. 

  65. #if LOL_FEATURE_CXX11_RELAXED_UNIONS

  66.     inline vec_t<T, N, SWIZZLE>& operator =(vec_t<T, N, SWIZZLE> const &that)

  67.     {

  68.         /* Pass by value in case this == &that */

  69.         return *this = (vec_t<T,N>)that;

  70.     }

  71. #endif

  72. 

  73.     inline T& operator[](size_t n)

  74.     {

  75.         int i = (SWIZZLE >> (4 * (N - 1 - n))) & 3;

  76.         return static_cast<T*>(static_cast<void*>(this))[i];

  77.     }

  78. 

  79.     inline T const& operator[](size_t n) const

  80.     {

  81.         int i = (SWIZZLE >> (4 * (N - 1 - n))) & 3;

  82.         return static_cast<T const*>(static_cast<void const *>(this))[i];

  83.     }

  84. };

  85. 

  86. /* The generic “vec_t” type, which is a fixed-size vector with no

  87.  * swizzling. There's an override for N=2, N=3, N=4 that has swizzling. */

  88. template<typename T, int N>

  89. struct vec_t<T, N, FULL_SWIZZLE>

  90.   : public linear_ops::base<T>,

  91.     public componentwise_ops::base<T>

  92. {

  93.     static int const count = N;

  94.     typedef T element;

  95.     typedef vec_t<T,N> type;

  96. 

  97.     inline T& operator[](size_t n) { return m_data[n]; }

  98.     inline T const& operator[](size_t n) const { return m_data[n]; }

  99. 

  100. private:

  101.     T m_data[N];

  102. };

  103. 

  104. /*

  105.  * Helper macros for vector type member functions

  106.  */

  107. 

  108. #define LOL_COMMON_MEMBER_OPS(first) \

  109.     inline T& operator[](size_t n) { return (&this->first)[n]; } \

  110.     inline T const& operator[](size_t n) const { return (&this->first)[n]; } \

  111.     \

  112.     /* Visual Studio insists on having an assignment operator. */ \

  113.     inline type & operator =(type const &that) \

  114.     { \

  115.         for (int i = 0; i < type::count; ++i) \

  116.             (*this)[i] = that[i]; \

  117.         return *this; \

  118.     } \

  119.     \

  120.     void printf() const; \

  121.     String tostring() const;

  122. 

  123. /*

  124.  * 2-element vectors

  125.  */

  126. 

  127. template <typename T>

  128. struct vec_t<T,2>

  129.   : public swizzle_ops::base<T>,

  130.     public linear_ops::base<T>,

  131.     public componentwise_ops::base<T>

  132. {

  133.     static int const count = 2;

  134.     typedef T element;

  135.     typedef vec_t<T,2> type;

  136. 

  137.     /* Default constructor, copy constructor, and destructor */

  138.     inline constexpr vec_t() : x(), y() {}

  139.     inline constexpr vec_t(vec_t<T,2> const &v) : x(v.x), y(v.y) {}

  140.     inline ~vec_t() { x.~T(); y.~T(); }

  141. 

  142.     /* Implicit constructor for swizzling */

  143.     template<int SWIZZLE>

  144.     inline constexpr vec_t(vec_t<T, 2, SWIZZLE> const &v)

  145.       : x(v[0]), y(v[1]) {}

  146. 

  147.     /* Explicit constructor for type conversion */

  148.     template<typename U, int SWIZZLE>

  149.     explicit inline constexpr vec_t(vec_t<U, 2, SWIZZLE> const &v)

  150.       : x(v[0]), y(v[1]) {}

  151. 

  152.     /* Various explicit constructors */

  153.     explicit inline constexpr vec_t(T X, T Y)

  154.       : x(X), y(Y) {}

  155.     explicit inline constexpr vec_t(T X)

  156.       : x(X), y(X) {}

  157. 

  158.     LOL_COMMON_MEMBER_OPS(x)

  159. 

  160.     static const vec_t<T,2> zero;

  161.     static const vec_t<T,2> axis_x;

  162.     static const vec_t<T,2> axis_y;

  163. 

  164.     template<typename U>

  165.     friend std::ostream &operator<<(std::ostream &stream, vec_t<U,2> const &v);

  166. 

  167.     union

  168.     {

  169.         struct { T x, y; };

  170.         struct { T r, g; };

  171.         struct { T s, t; };

  172. 

  173. #if !_DOXYGEN_SKIP_ME

  174.         vec_t<T,2,0x00> const xx, rr, ss;

  175.         vec_t<T,2,0x01> _____ xy, rg, st;

  176.         vec_t<T,2,0x10> _____ yx, gr, ts;

  177.         vec_t<T,2,0x11> const yy, gg, tt;

  178. 

  179.         vec_t<T,3,0x000> const xxx, rrr, sss;

  180.         vec_t<T,3,0x001> const xxy, rrg, sst;

  181.         vec_t<T,3,0x010> const xyx, rgr, sts;

  182.         vec_t<T,3,0x011> const xyy, rgg, stt;

  183.         vec_t<T,3,0x100> const yxx, grr, tss;

  184.         vec_t<T,3,0x101> const yxy, grg, tst;

  185.         vec_t<T,3,0x110> const yyx, ggr, tts;

  186.         vec_t<T,3,0x111> const yyy, ggg, ttt;

  187. 

  188.         vec_t<T,4,0x0000> const xxxx, rrrr, ssss;

  189.         vec_t<T,4,0x0001> const xxxy, rrrg, ssst;

  190.         vec_t<T,4,0x0010> const xxyx, rrgr, ssts;

  191.         vec_t<T,4,0x0011> const xxyy, rrgg, sstt;

  192.         vec_t<T,4,0x0100> const xyxx, rgrr, stss;

  193.         vec_t<T,4,0x0101> const xyxy, rgrg, stst;

  194.         vec_t<T,4,0x0110> const xyyx, rggr, stts;

  195.         vec_t<T,4,0x0111> const xyyy, rggg, sttt;

  196.         vec_t<T,4,0x1000> const yxxx, grrr, tsss;

  197.         vec_t<T,4,0x1001> const yxxy, grrg, tsst;

  198.         vec_t<T,4,0x1010> const yxyx, grgr, tsts;

  199.         vec_t<T,4,0x1011> const yxyy, grgg, tstt;

  200.         vec_t<T,4,0x1100> const yyxx, ggrr, ttss;

  201.         vec_t<T,4,0x1101> const yyxy, ggrg, ttst;

  202.         vec_t<T,4,0x1110> const yyyx, gggr, ttts;

  203.         vec_t<T,4,0x1111> const yyyy, gggg, tttt;

  204. #endif

  205.     };

  206. };

  207. 

  208. static_assert(sizeof(i8vec2) == 2, "sizeof(i8vec2) == 2");

  209. static_assert(sizeof(i16vec2) == 4, "sizeof(i16vec2) == 4");

  210. static_assert(sizeof(ivec2) == 8, "sizeof(ivec2) == 8");

  211. static_assert(sizeof(i64vec2) == 16, "sizeof(i64vec2) == 16");

  212. 

  213. static_assert(sizeof(f16vec2) == 4, "sizeof(f16vec2) == 4");

  214. static_assert(sizeof(vec2) == 8, "sizeof(vec2) == 8");

  215. static_assert(sizeof(dvec2) == 16, "sizeof(dvec2) == 16");

  216. 

  217. /*

  218.  * 3-element vectors

  219.  */

  220. 

  221. template <typename T>

  222. struct vec_t<T,3>

  223.   : public swizzle_ops::base<T>,

  224.     public linear_ops::base<T>,

  225.     public componentwise_ops::base<T>

  226. {

  227.     static int const count = 3;

  228.     typedef T element;

  229.     typedef vec_t<T,3> type;

  230. 

  231.     /* Default constructor, copy constructor, and destructor */

  232.     inline constexpr vec_t() : x(), y(), z() {}

  233.     inline constexpr vec_t(vec_t<T,3> const &v) : x(v.x), y(v.y), z(v.z) {}

  234.     inline ~vec_t() { x.~T(); y.~T(); z.~T(); }

  235. 

  236.     /* Implicit constructor for swizzling */

  237.     template<int SWIZZLE>

  238.     inline constexpr vec_t(vec_t<T, 3, SWIZZLE> const &v)

  239.       : x(v[0]), y(v[1]), z(v[2]) {}

  240. 

  241.     /* Explicit constructor for type conversion */

  242.     template<typename U, int SWIZZLE>

  243.     explicit inline constexpr vec_t(vec_t<U, 3, SWIZZLE> const &v)

  244.       : x(v[0]), y(v[1]), z(v[2]) {}

  245. 

  246.     /* Various explicit constructors */

  247.     explicit inline constexpr vec_t(T X)

  248.       : x(X), y(X), z(X) {}

  249.     explicit inline constexpr vec_t(T X, T Y, T Z)

  250.       : x(X), y(Y), z(Z) {}

  251.     explicit inline constexpr vec_t(vec_t<T,2> XY, T Z)

  252.       : x(XY.x), y(XY.y), z(Z) {}

  253.     explicit inline constexpr vec_t(T X, vec_t<T,2> YZ)

  254.       : x(X), y(YZ.x), z(YZ.y) {}

  255. 

  256.     LOL_COMMON_MEMBER_OPS(x)

  257. 

  258.     static vec_t<T,3> toeuler_xyx(quat_t<T> const &q);

  259.     static vec_t<T,3> toeuler_xzx(quat_t<T> const &q);

  260.     static vec_t<T,3> toeuler_yxy(quat_t<T> const &q);

  261.     static vec_t<T,3> toeuler_yzy(quat_t<T> const &q);

  262.     static vec_t<T,3> toeuler_zxz(quat_t<T> const &q);

  263.     static vec_t<T,3> toeuler_zyz(quat_t<T> const &q);

  264. 

  265.     static vec_t<T,3> toeuler_xyz(quat_t<T> const &q);

  266.     static vec_t<T,3> toeuler_xzy(quat_t<T> const &q);

  267.     static vec_t<T,3> toeuler_yxz(quat_t<T> const &q);

  268.     static vec_t<T,3> toeuler_yzx(quat_t<T> const &q);

  269.     static vec_t<T,3> toeuler_zxy(quat_t<T> const &q);

  270.     static vec_t<T,3> toeuler_zyx(quat_t<T> const &q);

  271. 

  272.     /* Return the cross product (vector product) of “a” and “b” */ \

  273.     friend inline type cross(type const &a, type const &b)

  274.     {

  275.         return type(a.y * b.z - a.z * b.y,

  276.                     a.z * b.x - a.x * b.z,

  277.                     a.x * b.y - a.y * b.x);

  278.     }

  279. 

  280.     /* Return a vector that is orthogonal to “a” */

  281.     friend inline type orthogonal(type const &a)

  282.     {

  283.         return lol::abs(a.x) > lol::abs(a.z)

  284.              ? type(-a.y, a.x, (T)0)

  285.              : type((T)0, -a.z, a.y);

  286.     }

  287. 

  288.     /* Return a vector that is orthonormal to “a” */

  289.     friend inline type orthonormal(type const &a)

  290.     {

  291.         return normalize(orthogonal(a));

  292.     }

  293. 

  294.     static const vec_t<T,3> zero;

  295.     static const vec_t<T,3> axis_x;

  296.     static const vec_t<T,3> axis_y;

  297.     static const vec_t<T,3> axis_z;

  298. 

  299.     template<typename U>

  300.     friend std::ostream &operator<<(std::ostream &stream, vec_t<U,3> const &v);

  301. 

  302.     union

  303.     {

  304.         struct { T x, y, z; };

  305.         struct { T r, g, b; };

  306.         struct { T s, t, p; };

  307. 

  308. #if !_DOXYGEN_SKIP_ME

  309.         vec_t<T,2,0x00> const xx, rr, ss;

  310.         vec_t<T,2,0x01> _____ xy, rg, st;

  311.         vec_t<T,2,0x02> _____ xz, rb, sp;

  312.         vec_t<T,2,0x10> _____ yx, gr, ts;

  313.         vec_t<T,2,0x11> const yy, gg, tt;

  314.         vec_t<T,2,0x12> _____ yz, gb, tp;

  315.         vec_t<T,2,0x20> _____ zx, br, ps;

  316.         vec_t<T,2,0x21> _____ zy, bg, pt;

  317.         vec_t<T,2,0x22> const zz, bb, pp;

  318. 

  319.         vec_t<T,3,0x000> const xxx, rrr, sss;

  320.         vec_t<T,3,0x001> const xxy, rrg, sst;

  321.         vec_t<T,3,0x002> const xxz, rrb, ssp;

  322.         vec_t<T,3,0x010> const xyx, rgr, sts;

  323.         vec_t<T,3,0x011> const xyy, rgg, stt;

  324.         vec_t<T,3,0x012> _____ xyz, rgb, stp;

  325.         vec_t<T,3,0x020> const xzx, rbr, sps;

  326.         vec_t<T,3,0x021> _____ xzy, rbg, spt;

  327.         vec_t<T,3,0x022> const xzz, rbb, spp;

  328.         vec_t<T,3,0x100> const yxx, grr, tss;

  329.         vec_t<T,3,0x101> const yxy, grg, tst;

  330.         vec_t<T,3,0x102> _____ yxz, grb, tsp;

  331.         vec_t<T,3,0x110> const yyx, ggr, tts;

  332.         vec_t<T,3,0x111> const yyy, ggg, ttt;

  333.         vec_t<T,3,0x112> const yyz, ggb, ttp;

  334.         vec_t<T,3,0x120> _____ yzx, gbr, tps;

  335.         vec_t<T,3,0x121> const yzy, gbg, tpt;

  336.         vec_t<T,3,0x122> const yzz, gbb, tpp;

  337.         vec_t<T,3,0x200> const zxx, brr, pss;

  338.         vec_t<T,3,0x201> _____ zxy, brg, pst;

  339.         vec_t<T,3,0x202> const zxz, brb, psp;

  340.         vec_t<T,3,0x210> _____ zyx, bgr, pts;

  341.         vec_t<T,3,0x211> const zyy, bgg, ptt;

  342.         vec_t<T,3,0x212> const zyz, bgb, ptp;

  343.         vec_t<T,3,0x220> const zzx, bbr, pps;

  344.         vec_t<T,3,0x221> const zzy, bbg, ppt;

  345.         vec_t<T,3,0x222> const zzz, bbb, ppp;

  346. 

  347.         vec_t<T,4,0x0000> const xxxx, rrrr, ssss;

  348.         vec_t<T,4,0x0001> const xxxy, rrrg, ssst;

  349.         vec_t<T,4,0x0002> const xxxz, rrrb, sssp;

  350.         vec_t<T,4,0x0010> const xxyx, rrgr, ssts;

  351.         vec_t<T,4,0x0011> const xxyy, rrgg, sstt;

  352.         vec_t<T,4,0x0012> const xxyz, rrgb, sstp;

  353.         vec_t<T,4,0x0020> const xxzx, rrbr, ssps;

  354.         vec_t<T,4,0x0021> const xxzy, rrbg, sspt;

  355.         vec_t<T,4,0x0022> const xxzz, rrbb, sspp;

  356.         vec_t<T,4,0x0100> const xyxx, rgrr, stss;

  357.         vec_t<T,4,0x0101> const xyxy, rgrg, stst;

  358.         vec_t<T,4,0x0102> const xyxz, rgrb, stsp;

  359.         vec_t<T,4,0x0110> const xyyx, rggr, stts;

  360.         vec_t<T,4,0x0111> const xyyy, rggg, sttt;

  361.         vec_t<T,4,0x0112> const xyyz, rggb, sttp;

  362.         vec_t<T,4,0x0120> const xyzx, rgbr, stps;

  363.         vec_t<T,4,0x0121> const xyzy, rgbg, stpt;

  364.         vec_t<T,4,0x0122> const xyzz, rgbb, stpp;

  365.         vec_t<T,4,0x0200> const xzxx, rbrr, spss;

  366.         vec_t<T,4,0x0201> const xzxy, rbrg, spst;

  367.         vec_t<T,4,0x0202> const xzxz, rbrb, spsp;

  368.         vec_t<T,4,0x0210> const xzyx, rbgr, spts;

  369.         vec_t<T,4,0x0211> const xzyy, rbgg, sptt;

  370.         vec_t<T,4,0x0212> const xzyz, rbgb, sptp;

  371.         vec_t<T,4,0x0220> const xzzx, rbbr, spps;

  372.         vec_t<T,4,0x0221> const xzzy, rbbg, sppt;

  373.         vec_t<T,4,0x0222> const xzzz, rbbb, sppp;

  374.         vec_t<T,4,0x1000> const yxxx, grrr, tsss;

  375.         vec_t<T,4,0x1001> const yxxy, grrg, tsst;

  376.         vec_t<T,4,0x1002> const yxxz, grrb, tssp;

  377.         vec_t<T,4,0x1010> const yxyx, grgr, tsts;

  378.         vec_t<T,4,0x1011> const yxyy, grgg, tstt;

  379.         vec_t<T,4,0x1012> const yxyz, grgb, tstp;

  380.         vec_t<T,4,0x1020> const yxzx, grbr, tsps;

  381.         vec_t<T,4,0x1021> const yxzy, grbg, tspt;

  382.         vec_t<T,4,0x1022> const yxzz, grbb, tspp;

  383.         vec_t<T,4,0x1100> const yyxx, ggrr, ttss;

  384.         vec_t<T,4,0x1101> const yyxy, ggrg, ttst;

  385.         vec_t<T,4,0x1102> const yyxz, ggrb, ttsp;

  386.         vec_t<T,4,0x1110> const yyyx, gggr, ttts;

  387.         vec_t<T,4,0x1111> const yyyy, gggg, tttt;

  388.         vec_t<T,4,0x1112> const yyyz, gggb, tttp;

  389.         vec_t<T,4,0x1120> const yyzx, ggbr, ttps;

  390.         vec_t<T,4,0x1121> const yyzy, ggbg, ttpt;

  391.         vec_t<T,4,0x1122> const yyzz, ggbb, ttpp;

  392.         vec_t<T,4,0x1200> const yzxx, gbrr, tpss;

  393.         vec_t<T,4,0x1201> const yzxy, gbrg, tpst;

  394.         vec_t<T,4,0x1202> const yzxz, gbrb, tpsp;

  395.         vec_t<T,4,0x1210> const yzyx, gbgr, tpts;

  396.         vec_t<T,4,0x1211> const yzyy, gbgg, tptt;

  397.         vec_t<T,4,0x1212> const yzyz, gbgb, tptp;

  398.         vec_t<T,4,0x1220> const yzzx, gbbr, tpps;

  399.         vec_t<T,4,0x1221> const yzzy, gbbg, tppt;

  400.         vec_t<T,4,0x1222> const yzzz, gbbb, tppp;

  401.         vec_t<T,4,0x2000> const zxxx, brrr, psss;

  402.         vec_t<T,4,0x2001> const zxxy, brrg, psst;

  403.         vec_t<T,4,0x2002> const zxxz, brrb, pssp;

  404.         vec_t<T,4,0x2010> const zxyx, brgr, psts;

  405.         vec_t<T,4,0x2011> const zxyy, brgg, pstt;

  406.         vec_t<T,4,0x2012> const zxyz, brgb, pstp;

  407.         vec_t<T,4,0x2020> const zxzx, brbr, psps;

  408.         vec_t<T,4,0x2021> const zxzy, brbg, pspt;

  409.         vec_t<T,4,0x2022> const zxzz, brbb, pspp;

  410.         vec_t<T,4,0x2100> const zyxx, bgrr, ptss;

  411.         vec_t<T,4,0x2101> const zyxy, bgrg, ptst;

  412.         vec_t<T,4,0x2102> const zyxz, bgrb, ptsp;

  413.         vec_t<T,4,0x2110> const zyyx, bggr, ptts;

  414.         vec_t<T,4,0x2111> const zyyy, bggg, pttt;

  415.         vec_t<T,4,0x2112> const zyyz, bggb, pttp;

  416.         vec_t<T,4,0x2120> const zyzx, bgbr, ptps;

  417.         vec_t<T,4,0x2121> const zyzy, bgbg, ptpt;

  418.         vec_t<T,4,0x2122> const zyzz, bgbb, ptpp;

  419.         vec_t<T,4,0x2200> const zzxx, bbrr, ppss;

  420.         vec_t<T,4,0x2201> const zzxy, bbrg, ppst;

  421.         vec_t<T,4,0x2202> const zzxz, bbrb, ppsp;

  422.         vec_t<T,4,0x2210> const zzyx, bbgr, ppts;

  423.         vec_t<T,4,0x2211> const zzyy, bbgg, pptt;

  424.         vec_t<T,4,0x2212> const zzyz, bbgb, pptp;

  425.         vec_t<T,4,0x2220> const zzzx, bbbr, ppps;

  426.         vec_t<T,4,0x2221> const zzzy, bbbg, pppt;

  427.         vec_t<T,4,0x2222> const zzzz, bbbb, pppp;

  428. #endif

  429.     };

  430. };

  431. 

  432. static_assert(sizeof(i8vec3) == 3, "sizeof(i8vec3) == 3");

  433. static_assert(sizeof(i16vec3) == 6, "sizeof(i16vec3) == 6");

  434. static_assert(sizeof(ivec3) == 12, "sizeof(ivec3) == 12");

  435. static_assert(sizeof(i64vec3) == 24, "sizeof(i64vec3) == 24");

  436. 

  437. static_assert(sizeof(f16vec3) == 6, "sizeof(f16vec3) == 6");

  438. static_assert(sizeof(vec3) == 12, "sizeof(vec3) == 12");

  439. static_assert(sizeof(dvec3) == 24, "sizeof(dvec3) == 24");

  440. 

  441. /*

  442.  * 4-element vectors

  443.  */

  444. 

  445. template <typename T>

  446. struct vec_t<T,4>

  447.   : public swizzle_ops::base<T>,

  448.     public linear_ops::base<T>,

  449.     public componentwise_ops::base<T>

  450. {

  451.     static int const count = 4;

  452.     typedef T element;

  453.     typedef vec_t<T,4> type;

  454. 

  455.     /* Default constructor, copy constructor, and destructor */

  456.     inline constexpr vec_t() : x(), y(), z(), w() {}

  457.     inline constexpr vec_t(vec_t<T,4> const &v)

  458.       : x(v.x), y(v.y), z(v.z), w(v.w) {}

  459.     inline ~vec_t() { x.~T(); y.~T(); z.~T(); w.~T(); }

  460. 

  461.     /* Implicit constructor for swizzling */

  462.     template<int SWIZZLE>

  463.     inline constexpr vec_t(vec_t<T, 4, SWIZZLE> const &v)

  464.       : x(v[0]), y(v[1]), z(v[2]), w(v[3]) {}

  465. 

  466.     /* Explicit constructor for type conversion */

  467.     template<typename U, int SWIZZLE>

  468.     explicit inline constexpr vec_t(vec_t<U, 4, SWIZZLE> const &v)

  469.       : x(v[0]), y(v[1]), z(v[2]), w(v[3]) {}

  470. 

  471.     /* Various explicit constructors */

  472.     explicit inline constexpr vec_t(T X)

  473.       : x(X), y(X), z(X), w(X) {}

  474.     explicit inline constexpr vec_t(T X, T Y, T Z, T W)

  475.       : x(X), y(Y), z(Z), w(W) {}

  476.     explicit inline constexpr vec_t(vec_t<T,2> XY, T Z, T W)

  477.       : x(XY.x), y(XY.y), z(Z), w(W) {}

  478.     explicit inline constexpr vec_t(T X, vec_t<T,2> YZ, T W)

  479.       : x(X), y(YZ.x), z(YZ.y), w(W) {}

  480.     explicit inline constexpr vec_t(T X, T Y, vec_t<T,2> ZW)

  481.       : x(X), y(Y), z(ZW.x), w(ZW.y) {}

  482.     explicit inline constexpr vec_t(vec_t<T,2> XY, vec_t<T,2> ZW)

  483.       : x(XY.x), y(XY.y), z(ZW.x), w(ZW.y) {}

  484.     explicit inline constexpr vec_t(vec_t<T,3> XYZ, T W)

  485.       : x(XYZ.x), y(XYZ.y), z(XYZ.z), w(W) {}

  486.     explicit inline constexpr vec_t(T X, vec_t<T,3> YZW)

  487.       : x(X), y(YZW.x), z(YZW.y), w(YZW.z) {}

  488. 

  489.     LOL_COMMON_MEMBER_OPS(x)

  490. 

  491.     static const vec_t<T,4> zero;

  492.     static const vec_t<T,4> axis_x;

  493.     static const vec_t<T,4> axis_y;

  494.     static const vec_t<T,4> axis_z;

  495.     static const vec_t<T,4> axis_w;

  496. 

  497.     template<typename U>

  498.     friend std::ostream &operator<<(std::ostream &stream, vec_t<U,4> const &v);

  499. 

  500.     union

  501.     {

  502.         struct { T x, y, z, w; };

  503.         struct { T r, g, b, a; };

  504.         struct { T s, t, p, q; };

  505. 

  506. #if !_DOXYGEN_SKIP_ME

  507.         vec_t<T,2,0x00> const xx, rr, ss;

  508.         vec_t<T,2,0x01> _____ xy, rg, st;

  509.         vec_t<T,2,0x02> _____ xz, rb, sp;

  510.         vec_t<T,2,0x03> _____ xw, ra, sq;

  511.         vec_t<T,2,0x10> _____ yx, gr, ts;

  512.         vec_t<T,2,0x11> const yy, gg, tt;

  513.         vec_t<T,2,0x12> _____ yz, gb, tp;

  514.         vec_t<T,2,0x13> _____ yw, ga, tq;

  515.         vec_t<T,2,0x20> _____ zx, br, ps;

  516.         vec_t<T,2,0x21> _____ zy, bg, pt;

  517.         vec_t<T,2,0x22> const zz, bb, pp;

  518.         vec_t<T,2,0x23> _____ zw, ba, pq;

  519.         vec_t<T,2,0x30> _____ wx, ar, qs;

  520.         vec_t<T,2,0x31> _____ wy, ag, qt;

  521.         vec_t<T,2,0x32> _____ wz, ab, qp;

  522.         vec_t<T,2,0x33> const ww, aa, qq;

  523. 

  524.         vec_t<T,3,0x000> const xxx, rrr, sss;

  525.         vec_t<T,3,0x001> const xxy, rrg, sst;

  526.         vec_t<T,3,0x002> const xxz, rrb, ssp;

  527.         vec_t<T,3,0x003> const xxw, rra, ssq;

  528.         vec_t<T,3,0x010> const xyx, rgr, sts;

  529.         vec_t<T,3,0x011> const xyy, rgg, stt;

  530.         vec_t<T,3,0x012> _____ xyz, rgb, stp;

  531.         vec_t<T,3,0x013> _____ xyw, rga, stq;

  532.         vec_t<T,3,0x020> const xzx, rbr, sps;

  533.         vec_t<T,3,0x021> _____ xzy, rbg, spt;

  534.         vec_t<T,3,0x022> const xzz, rbb, spp;

  535.         vec_t<T,3,0x023> _____ xzw, rba, spq;

  536.         vec_t<T,3,0x030> const xwx, rar, sqs;

  537.         vec_t<T,3,0x031> _____ xwy, rag, sqt;

  538.         vec_t<T,3,0x032> _____ xwz, rab, sqp;

  539.         vec_t<T,3,0x033> const xww, raa, sqq;

  540.         vec_t<T,3,0x100> const yxx, grr, tss;

  541.         vec_t<T,3,0x101> const yxy, grg, tst;

  542.         vec_t<T,3,0x102> _____ yxz, grb, tsp;

  543.         vec_t<T,3,0x103> _____ yxw, gra, tsq;

  544.         vec_t<T,3,0x110> const yyx, ggr, tts;

  545.         vec_t<T,3,0x111> const yyy, ggg, ttt;

  546.         vec_t<T,3,0x112> const yyz, ggb, ttp;

  547.         vec_t<T,3,0x113> const yyw, gga, ttq;

  548.         vec_t<T,3,0x120> _____ yzx, gbr, tps;

  549.         vec_t<T,3,0x121> const yzy, gbg, tpt;

  550.         vec_t<T,3,0x122> const yzz, gbb, tpp;

  551.         vec_t<T,3,0x123> _____ yzw, gba, tpq;

  552.         vec_t<T,3,0x130> _____ ywx, gar, tqs;

  553.         vec_t<T,3,0x131> const ywy, gag, tqt;

  554.         vec_t<T,3,0x132> _____ ywz, gab, tqp;

  555.         vec_t<T,3,0x133> const yww, gaa, tqq;

  556.         vec_t<T,3,0x200> const zxx, brr, pss;

  557.         vec_t<T,3,0x201> _____ zxy, brg, pst;

  558.         vec_t<T,3,0x202> const zxz, brb, psp;

  559.         vec_t<T,3,0x203> _____ zxw, bra, psq;

  560.         vec_t<T,3,0x210> _____ zyx, bgr, pts;

  561.         vec_t<T,3,0x211> const zyy, bgg, ptt;

  562.         vec_t<T,3,0x212> const zyz, bgb, ptp;

  563.         vec_t<T,3,0x213> _____ zyw, bga, ptq;

  564.         vec_t<T,3,0x220> const zzx, bbr, pps;

  565.         vec_t<T,3,0x221> const zzy, bbg, ppt;

  566.         vec_t<T,3,0x222> const zzz, bbb, ppp;

  567.         vec_t<T,3,0x223> const zzw, bba, ppq;

  568.         vec_t<T,3,0x230> _____ zwx, bar, pqs;

  569.         vec_t<T,3,0x231> _____ zwy, bag, pqt;

  570.         vec_t<T,3,0x232> const zwz, bab, pqp;

  571.         vec_t<T,3,0x233> const zww, baa, pqq;

  572.         vec_t<T,3,0x300> const wxx, arr, qss;

  573.         vec_t<T,3,0x301> _____ wxy, arg, qst;

  574.         vec_t<T,3,0x302> _____ wxz, arb, qsp;

  575.         vec_t<T,3,0x303> const wxw, ara, qsq;

  576.         vec_t<T,3,0x310> _____ wyx, agr, qts;

  577.         vec_t<T,3,0x311> const wyy, agg, qtt;

  578.         vec_t<T,3,0x312> _____ wyz, agb, qtp;

  579.         vec_t<T,3,0x313> const wyw, aga, qtq;

  580.         vec_t<T,3,0x320> _____ wzx, abr, qps;

  581.         vec_t<T,3,0x321> _____ wzy, abg, qpt;

  582.         vec_t<T,3,0x322> const wzz, abb, qpp;

  583.         vec_t<T,3,0x323> const wzw, aba, qpq;

  584.         vec_t<T,3,0x330> const wwx, aar, qqs;

  585.         vec_t<T,3,0x331> const wwy, aag, qqt;

  586.         vec_t<T,3,0x332> const wwz, aab, qqp;

  587.         vec_t<T,3,0x333> const www, aaa, qqq;

  588. 

  589.         vec_t<T,4,0x0000> const xxxx, rrrr, ssss;

  590.         vec_t<T,4,0x0001> const xxxy, rrrg, ssst;

  591.         vec_t<T,4,0x0002> const xxxz, rrrb, sssp;

  592.         vec_t<T,4,0x0003> const xxxw, rrra, sssq;

  593.         vec_t<T,4,0x0010> const xxyx, rrgr, ssts;

  594.         vec_t<T,4,0x0011> const xxyy, rrgg, sstt;

  595.         vec_t<T,4,0x0012> const xxyz, rrgb, sstp;

  596.         vec_t<T,4,0x0013> const xxyw, rrga, sstq;

  597.         vec_t<T,4,0x0020> const xxzx, rrbr, ssps;

  598.         vec_t<T,4,0x0021> const xxzy, rrbg, sspt;

  599.         vec_t<T,4,0x0022> const xxzz, rrbb, sspp;

  600.         vec_t<T,4,0x0023> const xxzw, rrba, sspq;

  601.         vec_t<T,4,0x0030> const xxwx, rrar, ssqs;

  602.         vec_t<T,4,0x0031> const xxwy, rrag, ssqt;

  603.         vec_t<T,4,0x0032> const xxwz, rrab, ssqp;

  604.         vec_t<T,4,0x0033> const xxww, rraa, ssqq;

  605.         vec_t<T,4,0x0100> const xyxx, rgrr, stss;

  606.         vec_t<T,4,0x0101> const xyxy, rgrg, stst;

  607.         vec_t<T,4,0x0102> const xyxz, rgrb, stsp;

  608.         vec_t<T,4,0x0103> const xyxw, rgra, stsq;

  609.         vec_t<T,4,0x0110> const xyyx, rggr, stts;

  610.         vec_t<T,4,0x0111> const xyyy, rggg, sttt;

  611.         vec_t<T,4,0x0112> const xyyz, rggb, sttp;

  612.         vec_t<T,4,0x0113> const xyyw, rgga, sttq;

  613.         vec_t<T,4,0x0120> const xyzx, rgbr, stps;

  614.         vec_t<T,4,0x0121> const xyzy, rgbg, stpt;

  615.         vec_t<T,4,0x0122> const xyzz, rgbb, stpp;

  616.         vec_t<T,4,0x0123> _____ xyzw, rgba, stpq;

  617.         vec_t<T,4,0x0130> const xywx, rgar, stqs;

  618.         vec_t<T,4,0x0131> const xywy, rgag, stqt;

  619.         vec_t<T,4,0x0132> _____ xywz, rgab, stqp;

  620.         vec_t<T,4,0x0133> const xyww, rgaa, stqq;

  621.         vec_t<T,4,0x0200> const xzxx, rbrr, spss;

  622.         vec_t<T,4,0x0201> const xzxy, rbrg, spst;

  623.         vec_t<T,4,0x0202> const xzxz, rbrb, spsp;

  624.         vec_t<T,4,0x0203> const xzxw, rbra, spsq;

  625.         vec_t<T,4,0x0210> const xzyx, rbgr, spts;

  626.         vec_t<T,4,0x0211> const xzyy, rbgg, sptt;

  627.         vec_t<T,4,0x0212> const xzyz, rbgb, sptp;

  628.         vec_t<T,4,0x0213> _____ xzyw, rbga, sptq;

  629.         vec_t<T,4,0x0220> const xzzx, rbbr, spps;

  630.         vec_t<T,4,0x0221> const xzzy, rbbg, sppt;

  631.         vec_t<T,4,0x0222> const xzzz, rbbb, sppp;

  632.         vec_t<T,4,0x0223> const xzzw, rbba, sppq;

  633.         vec_t<T,4,0x0230> const xzwx, rbar, spqs;

  634.         vec_t<T,4,0x0231> _____ xzwy, rbag, spqt;

  635.         vec_t<T,4,0x0232> const xzwz, rbab, spqp;

  636.         vec_t<T,4,0x0233> const xzww, rbaa, spqq;

  637.         vec_t<T,4,0x0300> const xwxx, rarr, sqss;

  638.         vec_t<T,4,0x0301> const xwxy, rarg, sqst;

  639.         vec_t<T,4,0x0302> const xwxz, rarb, sqsp;

  640.         vec_t<T,4,0x0303> const xwxw, rara, sqsq;

  641.         vec_t<T,4,0x0310> const xwyx, ragr, sqts;

  642.         vec_t<T,4,0x0311> const xwyy, ragg, sqtt;

  643.         vec_t<T,4,0x0312> _____ xwyz, ragb, sqtp;

  644.         vec_t<T,4,0x0313> const xwyw, raga, sqtq;

  645.         vec_t<T,4,0x0320> const xwzx, rabr, sqps;

  646.         vec_t<T,4,0x0321> _____ xwzy, rabg, sqpt;

  647.         vec_t<T,4,0x0322> const xwzz, rabb, sqpp;

  648.         vec_t<T,4,0x0323> const xwzw, raba, sqpq;

  649.         vec_t<T,4,0x0330> const xwwx, raar, sqqs;

  650.         vec_t<T,4,0x0331> const xwwy, raag, sqqt;

  651.         vec_t<T,4,0x0332> const xwwz, raab, sqqp;

  652.         vec_t<T,4,0x0333> const xwww, raaa, sqqq;

  653.         vec_t<T,4,0x1000> const yxxx, grrr, tsss;

  654.         vec_t<T,4,0x1001> const yxxy, grrg, tsst;

  655.         vec_t<T,4,0x1002> const yxxz, grrb, tssp;

  656.         vec_t<T,4,0x1003> const yxxw, grra, tssq;

  657.         vec_t<T,4,0x1010> const yxyx, grgr, tsts;

  658.         vec_t<T,4,0x1011> const yxyy, grgg, tstt;

  659.         vec_t<T,4,0x1012> const yxyz, grgb, tstp;

  660.         vec_t<T,4,0x1013> const yxyw, grga, tstq;

  661.         vec_t<T,4,0x1020> const yxzx, grbr, tsps;

  662.         vec_t<T,4,0x1021> const yxzy, grbg, tspt;

  663.         vec_t<T,4,0x1022> const yxzz, grbb, tspp;

  664.         vec_t<T,4,0x1023> _____ yxzw, grba, tspq;

  665.         vec_t<T,4,0x1030> const yxwx, grar, tsqs;

  666.         vec_t<T,4,0x1031> const yxwy, grag, tsqt;

  667.         vec_t<T,4,0x1032> _____ yxwz, grab, tsqp;

  668.         vec_t<T,4,0x1033> const yxww, graa, tsqq;

  669.         vec_t<T,4,0x1100> const yyxx, ggrr, ttss;

  670.         vec_t<T,4,0x1101> const yyxy, ggrg, ttst;

  671.         vec_t<T,4,0x1102> const yyxz, ggrb, ttsp;

  672.         vec_t<T,4,0x1103> const yyxw, ggra, ttsq;

  673.         vec_t<T,4,0x1110> const yyyx, gggr, ttts;

  674.         vec_t<T,4,0x1111> const yyyy, gggg, tttt;

  675.         vec_t<T,4,0x1112> const yyyz, gggb, tttp;

  676.         vec_t<T,4,0x1113> const yyyw, ggga, tttq;

  677.         vec_t<T,4,0x1120> const yyzx, ggbr, ttps;

  678.         vec_t<T,4,0x1121> const yyzy, ggbg, ttpt;

  679.         vec_t<T,4,0x1122> const yyzz, ggbb, ttpp;

  680.         vec_t<T,4,0x1123> const yyzw, ggba, ttpq;

  681.         vec_t<T,4,0x1130> const yywx, ggar, ttqs;

  682.         vec_t<T,4,0x1131> const yywy, ggag, ttqt;

  683.         vec_t<T,4,0x1132> const yywz, ggab, ttqp;

  684.         vec_t<T,4,0x1133> const yyww, ggaa, ttqq;

  685.         vec_t<T,4,0x1200> const yzxx, gbrr, tpss;

  686.         vec_t<T,4,0x1201> const yzxy, gbrg, tpst;

  687.         vec_t<T,4,0x1202> const yzxz, gbrb, tpsp;

  688.         vec_t<T,4,0x1203> _____ yzxw, gbra, tpsq;

  689.         vec_t<T,4,0x1210> const yzyx, gbgr, tpts;

  690.         vec_t<T,4,0x1211> const yzyy, gbgg, tptt;

  691.         vec_t<T,4,0x1212> const yzyz, gbgb, tptp;

  692.         vec_t<T,4,0x1213> const yzyw, gbga, tptq;

  693.         vec_t<T,4,0x1220> const yzzx, gbbr, tpps;

  694.         vec_t<T,4,0x1221> const yzzy, gbbg, tppt;

  695.         vec_t<T,4,0x1222> const yzzz, gbbb, tppp;

  696.         vec_t<T,4,0x1223> const yzzw, gbba, tppq;

  697.         vec_t<T,4,0x1230> _____ yzwx, gbar, tpqs;

  698.         vec_t<T,4,0x1231> const yzwy, gbag, tpqt;

  699.         vec_t<T,4,0x1232> const yzwz, gbab, tpqp;

  700.         vec_t<T,4,0x1233> const yzww, gbaa, tpqq;

  701.         vec_t<T,4,0x1300> const ywxx, garr, tqss;

  702.         vec_t<T,4,0x1301> const ywxy, garg, tqst;

  703.         vec_t<T,4,0x1302> _____ ywxz, garb, tqsp;

  704.         vec_t<T,4,0x1303> const ywxw, gara, tqsq;

  705.         vec_t<T,4,0x1310> const ywyx, gagr, tqts;

  706.         vec_t<T,4,0x1311> const ywyy, gagg, tqtt;

  707.         vec_t<T,4,0x1312> const ywyz, gagb, tqtp;

  708.         vec_t<T,4,0x1313> const ywyw, gaga, tqtq;

  709.         vec_t<T,4,0x1320> _____ ywzx, gabr, tqps;

  710.         vec_t<T,4,0x1321> const ywzy, gabg, tqpt;

  711.         vec_t<T,4,0x1322> const ywzz, gabb, tqpp;

  712.         vec_t<T,4,0x1323> const ywzw, gaba, tqpq;

  713.         vec_t<T,4,0x1330> const ywwx, gaar, tqqs;

  714.         vec_t<T,4,0x1331> const ywwy, gaag, tqqt;

  715.         vec_t<T,4,0x1332> const ywwz, gaab, tqqp;

  716.         vec_t<T,4,0x1333> const ywww, gaaa, tqqq;

  717.         vec_t<T,4,0x2000> const zxxx, brrr, psss;

  718.         vec_t<T,4,0x2001> const zxxy, brrg, psst;

  719.         vec_t<T,4,0x2002> const zxxz, brrb, pssp;

  720.         vec_t<T,4,0x2003> const zxxw, brra, pssq;

  721.         vec_t<T,4,0x2010> const zxyx, brgr, psts;

  722.         vec_t<T,4,0x2011> const zxyy, brgg, pstt;

  723.         vec_t<T,4,0x2012> const zxyz, brgb, pstp;

  724.         vec_t<T,4,0x2013> _____ zxyw, brga, pstq;

  725.         vec_t<T,4,0x2020> const zxzx, brbr, psps;

  726.         vec_t<T,4,0x2021> const zxzy, brbg, pspt;

  727.         vec_t<T,4,0x2022> const zxzz, brbb, pspp;

  728.         vec_t<T,4,0x2023> const zxzw, brba, pspq;

  729.         vec_t<T,4,0x2030> const zxwx, brar, psqs;

  730.         vec_t<T,4,0x2031> _____ zxwy, brag, psqt;

  731.         vec_t<T,4,0x2032> const zxwz, brab, psqp;

  732.         vec_t<T,4,0x2033> const zxww, braa, psqq;

  733.         vec_t<T,4,0x2100> const zyxx, bgrr, ptss;

  734.         vec_t<T,4,0x2101> const zyxy, bgrg, ptst;

  735.         vec_t<T,4,0x2102> const zyxz, bgrb, ptsp;

  736.         vec_t<T,4,0x2103> _____ zyxw, bgra, ptsq;

  737.         vec_t<T,4,0x2110> const zyyx, bggr, ptts;

  738.         vec_t<T,4,0x2111> const zyyy, bggg, pttt;

  739.         vec_t<T,4,0x2112> const zyyz, bggb, pttp;

  740.         vec_t<T,4,0x2113> const zyyw, bgga, pttq;

  741.         vec_t<T,4,0x2120> const zyzx, bgbr, ptps;

  742.         vec_t<T,4,0x2121> const zyzy, bgbg, ptpt;

  743.         vec_t<T,4,0x2122> const zyzz, bgbb, ptpp;

  744.         vec_t<T,4,0x2123> const zyzw, bgba, ptpq;

  745.         vec_t<T,4,0x2130> _____ zywx, bgar, ptqs;

  746.         vec_t<T,4,0x2131> const zywy, bgag, ptqt;

  747.         vec_t<T,4,0x2132> const zywz, bgab, ptqp;

  748.         vec_t<T,4,0x2133> const zyww, bgaa, ptqq;

  749.         vec_t<T,4,0x2200> const zzxx, bbrr, ppss;

  750.         vec_t<T,4,0x2201> const zzxy, bbrg, ppst;

  751.         vec_t<T,4,0x2202> const zzxz, bbrb, ppsp;

  752.         vec_t<T,4,0x2203> const zzxw, bbra, ppsq;

  753.         vec_t<T,4,0x2210> const zzyx, bbgr, ppts;

  754.         vec_t<T,4,0x2211> const zzyy, bbgg, pptt;

  755.         vec_t<T,4,0x2212> const zzyz, bbgb, pptp;

  756.         vec_t<T,4,0x2213> const zzyw, bbga, pptq;

  757.         vec_t<T,4,0x2220> const zzzx, bbbr, ppps;

  758.         vec_t<T,4,0x2221> const zzzy, bbbg, pppt;

  759.         vec_t<T,4,0x2222> const zzzz, bbbb, pppp;

  760.         vec_t<T,4,0x2223> const zzzw, bbba, pppq;

  761.         vec_t<T,4,0x2230> const zzwx, bbar, ppqs;

  762.         vec_t<T,4,0x2231> const zzwy, bbag, ppqt;

  763.         vec_t<T,4,0x2232> const zzwz, bbab, ppqp;

  764.         vec_t<T,4,0x2233> const zzww, bbaa, ppqq;

  765.         vec_t<T,4,0x2300> const zwxx, barr, pqss;

  766.         vec_t<T,4,0x2301> _____ zwxy, barg, pqst;

  767.         vec_t<T,4,0x2302> const zwxz, barb, pqsp;

  768.         vec_t<T,4,0x2303> const zwxw, bara, pqsq;

  769.         vec_t<T,4,0x2310> _____ zwyx, bagr, pqts;

  770.         vec_t<T,4,0x2311> const zwyy, bagg, pqtt;

  771.         vec_t<T,4,0x2312> const zwyz, bagb, pqtp;

  772.         vec_t<T,4,0x2313> const zwyw, baga, pqtq;

  773.         vec_t<T,4,0x2320> const zwzx, babr, pqps;

  774.         vec_t<T,4,0x2321> const zwzy, babg, pqpt;

  775.         vec_t<T,4,0x2322> const zwzz, babb, pqpp;

  776.         vec_t<T,4,0x2323> const zwzw, baba, pqpq;

  777.         vec_t<T,4,0x2330> const zwwx, baar, pqqs;

  778.         vec_t<T,4,0x2331> const zwwy, baag, pqqt;

  779.         vec_t<T,4,0x2332> const zwwz, baab, pqqp;

  780.         vec_t<T,4,0x2333> const zwww, baaa, pqqq;

  781.         vec_t<T,4,0x3000> const wxxx, arrr, qsss;

  782.         vec_t<T,4,0x3001> const wxxy, arrg, qsst;

  783.         vec_t<T,4,0x3002> const wxxz, arrb, qssp;

  784.         vec_t<T,4,0x3003> const wxxw, arra, qssq;

  785.         vec_t<T,4,0x3010> const wxyx, argr, qsts;

  786.         vec_t<T,4,0x3011> const wxyy, argg, qstt;

  787.         vec_t<T,4,0x3012> _____ wxyz, argb, qstp;

  788.         vec_t<T,4,0x3013> const wxyw, arga, qstq;

  789.         vec_t<T,4,0x3020> const wxzx, arbr, qsps;

  790.         vec_t<T,4,0x3021> _____ wxzy, arbg, qspt;

  791.         vec_t<T,4,0x3022> const wxzz, arbb, qspp;

  792.         vec_t<T,4,0x3023> const wxzw, arba, qspq;

  793.         vec_t<T,4,0x3030> const wxwx, arar, qsqs;

  794.         vec_t<T,4,0x3031> const wxwy, arag, qsqt;

  795.         vec_t<T,4,0x3032> const wxwz, arab, qsqp;

  796.         vec_t<T,4,0x3033> const wxww, araa, qsqq;

  797.         vec_t<T,4,0x3100> const wyxx, agrr, qtss;

  798.         vec_t<T,4,0x3101> const wyxy, agrg, qtst;

  799.         vec_t<T,4,0x3102> _____ wyxz, agrb, qtsp;

  800.         vec_t<T,4,0x3103> const wyxw, agra, qtsq;

  801.         vec_t<T,4,0x3110> const wyyx, aggr, qtts;

  802.         vec_t<T,4,0x3111> const wyyy, aggg, qttt;

  803.         vec_t<T,4,0x3112> const wyyz, aggb, qttp;

  804.         vec_t<T,4,0x3113> const wyyw, agga, qttq;

  805.         vec_t<T,4,0x3120> _____ wyzx, agbr, qtps;

  806.         vec_t<T,4,0x3121> const wyzy, agbg, qtpt;

  807.         vec_t<T,4,0x3122> const wyzz, agbb, qtpp;

  808.         vec_t<T,4,0x3123> const wyzw, agba, qtpq;

  809.         vec_t<T,4,0x3130> const wywx, agar, qtqs;

  810.         vec_t<T,4,0x3131> const wywy, agag, qtqt;

  811.         vec_t<T,4,0x3132> const wywz, agab, qtqp;

  812.         vec_t<T,4,0x3133> const wyww, agaa, qtqq;

  813.         vec_t<T,4,0x3200> const wzxx, abrr, qpss;

  814.         vec_t<T,4,0x3201> _____ wzxy, abrg, qpst;

  815.         vec_t<T,4,0x3202> const wzxz, abrb, qpsp;

  816.         vec_t<T,4,0x3203> const wzxw, abra, qpsq;

  817.         vec_t<T,4,0x3210> _____ wzyx, abgr, qpts;

  818.         vec_t<T,4,0x3211> const wzyy, abgg, qptt;

  819.         vec_t<T,4,0x3212> const wzyz, abgb, qptp;

  820.         vec_t<T,4,0x3213> const wzyw, abga, qptq;

  821.         vec_t<T,4,0x3220> const wzzx, abbr, qpps;

  822.         vec_t<T,4,0x3221> const wzzy, abbg, qppt;

  823.         vec_t<T,4,0x3222> const wzzz, abbb, qppp;

  824.         vec_t<T,4,0x3223> const wzzw, abba, qppq;

  825.         vec_t<T,4,0x3230> const wzwx, abar, qpqs;

  826.         vec_t<T,4,0x3231> const wzwy, abag, qpqt;

  827.         vec_t<T,4,0x3232> const wzwz, abab, qpqp;

  828.         vec_t<T,4,0x3233> const wzww, abaa, qpqq;

  829.         vec_t<T,4,0x3300> const wwxx, aarr, qqss;

  830.         vec_t<T,4,0x3301> const wwxy, aarg, qqst;

  831.         vec_t<T,4,0x3302> const wwxz, aarb, qqsp;

  832.         vec_t<T,4,0x3303> const wwxw, aara, qqsq;

  833.         vec_t<T,4,0x3310> const wwyx, aagr, qqts;

  834.         vec_t<T,4,0x3311> const wwyy, aagg, qqtt;

  835.         vec_t<T,4,0x3312> const wwyz, aagb, qqtp;

  836.         vec_t<T,4,0x3313> const wwyw, aaga, qqtq;

  837.         vec_t<T,4,0x3320> const wwzx, aabr, qqps;

  838.         vec_t<T,4,0x3321> const wwzy, aabg, qqpt;

  839.         vec_t<T,4,0x3322> const wwzz, aabb, qqpp;

  840.         vec_t<T,4,0x3323> const wwzw, aaba, qqpq;

  841.         vec_t<T,4,0x3330> const wwwx, aaar, qqqs;

  842.         vec_t<T,4,0x3331> const wwwy, aaag, qqqt;

  843.         vec_t<T,4,0x3332> const wwwz, aaab, qqqp;

  844.         vec_t<T,4,0x3333> const wwww, aaaa, qqqq;

  845. #endif

  846.     };

  847. };

  848. 

  849. static_assert(sizeof(i8vec4) == 4, "sizeof(i8vec4) == 4");

  850. static_assert(sizeof(i16vec4) == 8, "sizeof(i16vec4) == 8");

  851. static_assert(sizeof(ivec4) == 16, "sizeof(ivec4) == 16");

  852. static_assert(sizeof(i64vec4) == 32, "sizeof(i64vec4) == 32");

  853. 

  854. static_assert(sizeof(f16vec4) == 8, "sizeof(f16vec4) == 8");

  855. static_assert(sizeof(vec4) == 16, "sizeof(vec4) == 16");

  856. static_assert(sizeof(dvec4) == 32, "sizeof(dvec4) == 32");

  857. 

  858. /*

  859.  * vec_t *(scalar, vec_t)

  860.  */

  861. 

  862. template<typename T, int N, int SWIZZLE>

  863. static inline vec_t<T,N> operator *(T const &val, vec_t<T,N,SWIZZLE> const &a)

  864. {

  865.     vec_t<T,N> ret;

  866.     for (int i = 0; i < N; ++i)

  867.         ret[i] = val * a[i];

  868.     return ret;

  869. }

  870. 

  871. /*

  872.  * vec_t min|max|fmod(vec_t, vec_t|scalar)

  873.  * vec_t min|max|fmod(scalar, vec_t)

  874.  */

  875. 

  876. #define LOL_SWIZZLE_V_VV_FUN(fun) \

  877.     template<typename T, int N, int SWIZZLE1, int SWIZZLE2> \

  878.     inline vec_t<T,N> fun(vec_t<T,N,SWIZZLE1> const &a, \

  879.                           vec_t<T,N,SWIZZLE2> const &b) \

  880.     { \

  881.         using lol::fun; \

  882.         vec_t<T,N> ret; \

  883.         for (int i = 0; i < N; ++i) \

  884.             ret[i] = fun(a[i], b[i]); \

  885.         return ret; \

  886.     } \

  887.     \

  888.     template<typename T, int N, int SWIZZLE> \

  889.     inline vec_t<T,N> fun(vec_t<T,N,SWIZZLE> const &a, T const &b) \

  890.     { \

  891.         using lol::fun; \

  892.         vec_t<T,N> ret; \

  893.         for (int i = 0; i < N; ++i) \

  894.             ret[i] = fun(a[i], b); \

  895.         return ret; \

  896.     } \

  897.     \

  898.     template<typename T, int N, int SWIZZLE> \

  899.     inline vec_t<T,N> fun(T const &a, vec_t<T,N,SWIZZLE> const &b) \

  900.     { \

  901.         using lol::fun; \

  902.         vec_t<T,N> ret; \

  903.         for (int i = 0; i < N; ++i) \

  904.             ret[i] = fun(a, b[i]); \

  905.         return ret; \

  906.     }

  907. 

  908. LOL_SWIZZLE_V_VV_FUN(min)

  909. LOL_SWIZZLE_V_VV_FUN(max)

  910. LOL_SWIZZLE_V_VV_FUN(fmod)

  911. 

  912. #undef LOL_SWIZZLE_V_VV_FUN

  913. 

  914. /*

  915.  * vec_t clamp(vec_t, vec_t, vec_t)

  916.  * vec_t clamp(vec_t, scalar, vec_t)

  917.  * vec_t clamp(vec_t, vec_t, scalar)

  918.  * vec_t clamp(vec_t, scalar, scalar)

  919.  */

  920. 

  921. template<typename T, int N, int SWIZZLE1, int SWIZZLE2, int SWIZZLE3>

  922. static inline vec_t<T,N> clamp(vec_t<T,N,SWIZZLE1> const &x,

  923.                                vec_t<T,N,SWIZZLE2> const &a,

  924.                                vec_t<T,N,SWIZZLE3> const &b)

  925. {

  926.     return max(min(x, b), a);

  927. }

  928. 

  929. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  930. static inline vec_t<T,N> clamp(vec_t<T,N,SWIZZLE1> const &x,

  931.                                T const &a,

  932.                                vec_t<T,N,SWIZZLE2> const &b)

  933. {

  934.     return max(min(x, b), a);

  935. }

  936. 

  937. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  938. static inline vec_t<T,N> clamp(vec_t<T,N,SWIZZLE1> const &x,

  939.                                vec_t<T,N,SWIZZLE2> const &a,

  940.                                T const &b)

  941. {

  942.     return max(min(x, b), a);

  943. }

  944. 

  945. template<typename T, int N, int SWIZZLE1>

  946. static inline vec_t<T,N> clamp(vec_t<T,N,SWIZZLE1> const &x,

  947.                                T const &a,

  948.                                T const &b)

  949. {

  950.     return max(min(x, b), a);

  951. }

  952. 

  953. /*

  954.  * vec_t mix(vec_t, vec_t, vec_t)

  955.  * vec_t mix(vec_t, vec_t, scalar)

  956.  */

  957. 

  958. template<typename T, int N, int SWIZZLE1, int SWIZZLE2, int SWIZZLE3>

  959. static inline vec_t<T,N> mix(vec_t<T,N,SWIZZLE1> const &x,

  960.                              vec_t<T,N,SWIZZLE2> const &y,

  961.                              vec_t<T,N,SWIZZLE3> const &a)

  962. {

  963.     return x + a * (y - x);

  964. }

  965. 

  966. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  967. static inline vec_t<T,N> mix(vec_t<T,N,SWIZZLE1> const &x,

  968.                              vec_t<T,N,SWIZZLE2> const &y,

  969.                              T const &a)

  970. {

  971.     return x + a * (y - x);

  972. }

  973. 

  974. /*

  975.  * Some GLSL-like functions.

  976.  */

  977. 

  978. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  979. static inline T dot(vec_t<T,N,SWIZZLE1> const &a,

  980.                     vec_t<T,N,SWIZZLE2> const &b)

  981. {

  982.     T ret(0);

  983.     for (int i = 0; i < N; ++i)

  984.         ret += a[i] * b[i];

  985.     return ret;

  986. }

  987. 

  988. template<typename T, int N, int SWIZZLE>

  989. static inline T sqlength(vec_t<T,N,SWIZZLE> const &a)

  990. {

  991.     return dot(a, a);

  992. }

  993. 

  994. template<typename T, int N, int SWIZZLE>

  995. static inline T length(vec_t<T,N,SWIZZLE> const &a)

  996. {

  997.     /* FIXME: this is not very nice */

  998.     return (T)sqrt((double)sqlength(a));

  999. }

  1000. 

  1001. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  1002. static inline vec_t<T,N> lerp(vec_t<T,N,SWIZZLE1> const &a,

  1003.                               vec_t<T,N,SWIZZLE2> const &b,

  1004.                               T const &s)

  1005. {

  1006.     vec_t<T,N> ret;

  1007.     for (int i = 0; i < N; ++i)

  1008.         ret[i] = a[i] + s * (b[i] - a[i]);

  1009.     return ret;

  1010. }

  1011. 

  1012. template<typename T, int N, int SWIZZLE1, int SWIZZLE2>

  1013. static inline T distance(vec_t<T,N,SWIZZLE1> const &a,

  1014.                          vec_t<T,N,SWIZZLE2> const &b)

  1015. {

  1016.     return length(a - b);

  1017. }

  1018. 

  1019. template<typename T, int N, int SWIZZLE>

  1020. static inline vec_t<T,N> fract(vec_t<T,N,SWIZZLE> const &a)

  1021. {

  1022.     vec_t<T,N> ret;

  1023.     for (int i = 0; i < N; ++i)

  1024.         ret[i] = fract(a[i]);

  1025.     return ret;

  1026. }

  1027. 

  1028. template<typename T, int N, int SWIZZLE>

  1029. static inline vec_t<T,N> normalize(vec_t<T,N,SWIZZLE> const &a)

  1030. {

  1031.     T norm = (T)length(a);

  1032.     return norm ? a / norm : vec_t<T,N>(T(0));

  1033. }

  1034. 

  1035. template<typename T, int N, int SWIZZLE>

  1036. static inline vec_t<T,N> abs(vec_t<T,N,SWIZZLE> const &a)

  1037. {

  1038.     vec_t<T,N> ret;

  1039.     for (int i = 0; i < N; ++i)

  1040.         ret[i] = lol::abs(a[i]);

  1041.     return ret;

  1042. }

  1043. 

  1044. template<typename T, int N, int SWIZZLE>

  1045. static inline vec_t<T,N> degrees(vec_t<T,N,SWIZZLE> const &a)

  1046. {

  1047.     vec_t<T,N> ret;

  1048.     for (int i = 0; i < N; ++i)

  1049.         ret[i] = lol::degrees(a[i]);

  1050.     return ret;

  1051. }

  1052. 

  1053. template<typename T, int N, int SWIZZLE>

  1054. static inline vec_t<T,N> radians(vec_t<T,N,SWIZZLE> const &a)

  1055. {

  1056.     vec_t<T,N> ret;

  1057.     for (int i = 0; i < N; ++i)

  1058.         ret[i] = lol::radians(a[i]);

  1059.     return ret;

  1060. }

  1061. 

  1062. /*

  1063.  * Magic vector swizzling (part 2/2)

  1064.  */

  1065. 

  1066. #if LOL_FEATURE_CXX11_RELAXED_UNIONS

  1067. template<int N, typename T, int SWIZZLE>

  1068. inline vec_t<T, N, SWIZZLE>& vec_t<T, N, SWIZZLE>::operator =(vec_t<T,N> that)

  1069. {

  1070.     for (int i = 0; i < N; ++i)

  1071.         (*this)[i] = that[i];

  1072.     return *this;

  1073. }

  1074. #endif

  1075. 

  1076. #if !LOL_FEATURE_CXX11_CONSTEXPR

  1077. #undef constexpr

  1078. #endif

  1079. 

  1080. } /* namespace lol */

  1081. 

  1082. #endif // __LOL_MATH_VECTOR_H__