lolengine
/
lol
의 미러 https://github.com/lolengine/lol
1
0
포크 0
코드 이슈 0 릴리즈 0 위키 활동
25개 이상의 토픽을 선택하실 수 없습니다. Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3097 커밋
5 브랜치
220 MiB
 
 
 
트리: d05eb96665
브랜치 태그
${ item.name }
${ searchTerm } 브랜치 생성
from 'd05eb96665'
${ noResults }
lol/include/lol/math/vector.h

1422 lines
49 KiB
Raw Blame 히스토리 

  1. //

  2. //  Lol Engine

  3. //

  4. //  Copyright © 2010—2020 Sam Hocevar <sam@hocevar.net>

  5. //

  6. //  Lol Engine is free software. It comes without any warranty, to

  7. //  the extent permitted by applicable law. You can redistribute it

  8. //  and/or modify it under the terms of the Do What the Fuck You Want

  9. //  to Public License, Version 2, as published by the WTFPL Task Force.

  10. //  See http://www.wtfpl.net/ for more details.

  11. //

  12. 

  13. #pragma once

  14. 

  15. //

  16. // The vector classes

  17. // ——————————————————

  18. //

  19. 

  20. #include <cassert>

  21. #include <ostream>     // std::ostream

  22. #include <type_traits>

  23. #include <cmath>       // std::fabs, std::cos…

  24. 

  25. // FIXME: get rid of this, too

  26. #include <../legacy/lol/base/types.h>

  27. 

  28. #include "private/ops.h"

  29. 

  30. namespace lol

  31. {

  32. 

  33. template<typename T> struct quat_t;

  34. 

  35. /*

  36.  * Magic vector swizzling

  37.  *

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

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

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

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

  42.  * casts.

  43.  *

  44.  * Using swizzled vectors as lvalues:

  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 2013 doesn't support unrestricted unions, so

  49.  * fuck it for now.

  50.  */

  51. 

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

  53. struct [[nodiscard]] vec_t

  54.     /* MUST have 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 scalar_element;

  61.     typedef T element;

  62.     typedef vec_t<T,N> type;

  63. 

  64.     /* Allow the assignment operator if unrestricted unions are supported. */

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

  66.     {

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

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

  69.         return *this;

  70.     }

  71. 

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

  73.     {

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

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

  76.     }

  77. 

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

  79.     {

  80.         int const lut[] = { 1000, 100, 10, 1 };

  81.         int const i = SWIZZLE / lut[n + 4 - N] % 10;

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

  83.     }

  84. 

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

  86.     {

  87.         int const lut[] = { 1000, 100, 10, 1 };

  88.         int const i = SWIZZLE / lut[n + 4 - N] % 10;

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

  90.     }

  91. 

  92. private:

  93.     // Hide all default constructors and destructors; this object

  94.     // is only intended to exist as part of a union.

  95.     template<typename T2, int N2, int SWIZZLE2> friend struct vec_t;

  96. 

  97.     vec_t() = default;

  98.     vec_t(vec_t<T, N, SWIZZLE> const &) = default;

  99.     ~vec_t() = default;

  100. };

  101. 

  102. /*

  103.  * Helper macros for vector type member functions

  104.  */

  105. 

  106. #define LOL_COMMON_MEMBER_OPS(first) \

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

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

  109.     \

  110.     /* An explicit assignment operator is now mandatory */ \

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

  112.     { \

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

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

  115.         return *this; \

  116.     } \

  117.     \

  118.     std::string tostring() const;

  119. 

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

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

  122. template<typename T, int N>

  123. struct [[nodiscard]] vec_t<T, N, FULL_SWIZZLE>

  124.   : public componentwise_ops::base<T>

  125. {

  126.     static int const count = N;

  127.     typedef T scalar_element;

  128.     typedef T element;

  129.     typedef vec_t<T,N> type;

  130. 

  131.     // Default constructor, copy constructor, and destructor

  132.     inline constexpr vec_t() = default;

  133.     inline constexpr vec_t(type const &v) = default;

  134.     inline ~vec_t() = default;

  135. 

  136.     LOL_COMMON_MEMBER_OPS(m_data[0])

  137. 

  138.     /* Explicit constructor that takes exactly N arguments thanks to SFINAE. */

  139.     template<typename... ARGS>

  140.     explicit inline vec_t(T const &X,

  141.         typename std::enable_if<sizeof...(ARGS) + 2 == N, T>::type const &Y,

  142.         ARGS... args)

  143.     {

  144.         static_assert(sizeof...(ARGS) + 2 == N,

  145.                       "wrong argument count in vec_t constructor");

  146.         internal_init(m_data, X, Y, args...);

  147.     }

  148. 

  149.     /* Various explicit constructors */

  150.     explicit inline vec_t(T const &X)

  151.     {

  152.         for (auto &value : m_data)

  153.             value = X;

  154.     }

  155. 

  156.     /* Explicit constructor for type conversion */

  157.     template<typename U>

  158.     explicit inline vec_t(vec_t<U, N> const &v)

  159.     {

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

  161.             m_data[i] = T(v[i]);

  162.     }

  163. 

  164.     /* Factory for base axis vectors, e.g. [1,0,0,…,0] */

  165.     static inline vec_t<T, N> axis(int i)

  166.     {

  167.         assert(i >= 0);

  168.         assert(i < N);

  169.         vec_t<T, N> ret(T(0));

  170.         ret[i] = T(1);

  171.         return ret;

  172.     }

  173. 

  174.     /* Constructor for initializer_list. We need these ugly

  175.      * loops until C++ lets us initialize m_data directly. */

  176.     inline vec_t(std::initializer_list<element> const &list)

  177.     {

  178.         auto l = list.begin();

  179.         for (int i = 0; i < count && l != list.end(); ++i, ++l)

  180.             m_data[i] = *l;

  181.         for (int i = (int)list.size(); i < count; ++i)

  182.             m_data[i] = T(0);

  183.     }

  184. 

  185.     static const vec_t<T,N> zero;

  186. 

  187. private:

  188.     template<typename... ARGS>

  189.     static inline void internal_init(T *data, T const &x, ARGS... args)

  190.     {

  191.         *data++ = x;

  192.         internal_init(data, args...);

  193.     }

  194. 

  195.     static inline void internal_init(T *data)

  196.     {

  197.         (void)data;

  198.     }

  199. 

  200.     T m_data[count];

  201. };

  202. 

  203. /*

  204.  * 2-element vectors

  205.  */

  206. 

  207. template <typename T>

  208. struct [[nodiscard]] vec_t<T,2>

  209.   : public swizzle_ops::base<T>

  210. {

  211.     static int const count = 2;

  212.     typedef T scalar_element;

  213.     typedef T element;

  214.     typedef vec_t<T,2> type;

  215. 

  216.     // Default constructor, copy constructor, and destructor

  217.     inline constexpr vec_t() = default;

  218.     inline constexpr vec_t(type const &v) = default;

  219.     inline ~vec_t() = default;

  220. 

  221.     /* Implicit constructor for swizzling */

  222.     template<int SWIZZLE>

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

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

  225. 

  226.     /* Explicit constructor for type conversion */

  227.     template<typename U, int SWIZZLE>

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

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

  230. 

  231.     /* Constructor for initializer_list. We need these ugly

  232.      * loops until C++ lets us initialize m_data directly. */

  233.     inline vec_t(std::initializer_list<element> const &list)

  234.     {

  235.         auto l = list.begin();

  236.         for (int i = 0; i < count && l != list.end(); ++i, ++l)

  237.             m_data[i] = *l;

  238.         for (int i = (int)list.size(); i < count; ++i)

  239.             m_data[i] = T(0);

  240.     }

  241. 

  242.     /* Various explicit constructors */

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

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

  245.     explicit inline constexpr vec_t(T X)

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

  247. 

  248.     /* Factory for base axis vectors, e.g. [1,0,0,…,0] */

  249.     static inline vec_t<T,2> axis(int i)

  250.     {

  251.         assert(i >= 0);

  252.         assert(i < 2);

  253.         return vec_t<T,2>(T(i == 0), T(i == 1));

  254.     }

  255. 

  256.     LOL_COMMON_MEMBER_OPS(x)

  257. 

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

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

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

  261. 

  262.     union

  263.     {

  264.         struct { T x, y; }; /* axis */

  265.         struct { T r, g; }; /* red, green */

  266.         struct { T s, t; };

  267. 

  268. #if !_DOXYGEN_SKIP_ME

  269.         vec_t<T, 2, 9000> const xx, rr, ss/**/, ww;

  270.         vec_t<T, 2, 9001> const xy, rg, st, rt, wh;

  271.         vec_t<T, 2, 9010> const yx, gr, ts, tr, hw;

  272.         vec_t<T, 2, 9011> const yy, gg, tt/**/, hh;

  273. 

  274.         vec_t<T, 3, 90000> const xxx, rrr, sss /**/, www;

  275.         vec_t<T, 3, 90001> const xxy, rrg, sst, rrt, wwh;

  276.         vec_t<T, 3, 90010> const xyx, rgr, sts, rtr, whw;

  277.         vec_t<T, 3, 90011> const xyy, rgg, stt, rtt, whh;

  278.         vec_t<T, 3, 90100> const yxx, grr, tss, trr, hww;

  279.         vec_t<T, 3, 90101> const yxy, grg, tst, trt, hwh;

  280.         vec_t<T, 3, 90110> const yyx, ggr, tts, ttr, hhw;

  281.         vec_t<T, 3, 90111> const yyy, ggg, ttt /**/, hhh;

  282. 

  283.         vec_t<T, 4, 900000> const xxxx, rrrr, ssss  /**/, wwww;

  284.         vec_t<T, 4, 900001> const xxxy, rrrg, ssst, rrrt, wwwh;

  285.         vec_t<T, 4, 900010> const xxyx, rrgr, ssts, rrtr, wwhw;

  286.         vec_t<T, 4, 900011> const xxyy, rrgg, sstt, rrtt, wwhh;

  287.         vec_t<T, 4, 900100> const xyxx, rgrr, stss, rtrr, whww;

  288.         vec_t<T, 4, 900101> const xyxy, rgrg, stst, rtrt, whwh;

  289.         vec_t<T, 4, 900110> const xyyx, rggr, stts, rttr, whhw;

  290.         vec_t<T, 4, 900111> const xyyy, rggg, sttt, rttt, whhh;

  291.         vec_t<T, 4, 901000> const yxxx, grrr, tsss, trrr, hwww;

  292.         vec_t<T, 4, 901001> const yxxy, grrg, tsst, trrt, hwwh;

  293.         vec_t<T, 4, 901010> const yxyx, grgr, tsts, trtr, hwhw;

  294.         vec_t<T, 4, 901011> const yxyy, grgg, tstt, trtt, hwhh;

  295.         vec_t<T, 4, 901100> const yyxx, ggrr, ttss, ttrr, hhww;

  296.         vec_t<T, 4, 901101> const yyxy, ggrg, ttst, ttrt, hhwh;

  297.         vec_t<T, 4, 901110> const yyyx, gggr, ttts, tttr, hhhw;

  298.         vec_t<T, 4, 901111> const yyyy, gggg, tttt  /**/, hhhh;

  299. #endif

  300. 

  301.         T m_data[count];

  302.     };

  303. };

  304. 

  305. /*

  306.  * 3-element vectors

  307.  */

  308. 

  309. template <typename T>

  310. struct [[nodiscard]] vec_t<T,3>

  311.   : public swizzle_ops::base<T>

  312. {

  313.     static int const count = 3;

  314.     typedef T scalar_element;

  315.     typedef T element;

  316.     typedef vec_t<T,3> type;

  317. 

  318.     // Default constructor, copy constructor, and destructor

  319.     inline constexpr vec_t() = default;

  320.     inline constexpr vec_t(type const &v) = default;

  321.     inline ~vec_t() = default;

  322. 

  323.     /* Implicit constructor for swizzling */

  324.     template<int SWIZZLE>

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

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

  327. 

  328.     /* Explicit constructor for type conversion */

  329.     template<typename U, int SWIZZLE>

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

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

  332. 

  333.     /* Constructor for initializer_list. We need these ugly

  334.      * loops until C++ lets us initialize m_data directly. */

  335.     inline vec_t(std::initializer_list<element> const &list)

  336.     {

  337.         auto l = list.begin();

  338.         for (int i = 0; i < count && l != list.end(); ++i, ++l)

  339.             m_data[i] = *l;

  340.         for (int i = (int)list.size(); i < count; ++i)

  341.             m_data[i] = T(0);

  342.     }

  343. 

  344.     /* Various explicit constructors */

  345.     explicit inline constexpr vec_t(T X)

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

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

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

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

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

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

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

  353. 

  354.     /* Factory for base axis vectors, e.g. [1,0,0,…,0] */

  355.     static inline vec_t<T,3> axis(int i)

  356.     {

  357.         assert(i >= 0);

  358.         assert(i < 3);

  359.         return vec_t<T,3>(T(i == 0), T(i == 1), T(i == 2));

  360.     }

  361. 

  362.     LOL_COMMON_MEMBER_OPS(x)

  363. 

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

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

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

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

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

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

  370. 

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

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

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

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

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

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

  377. 

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

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

  380.     {

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

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

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

  384.     }

  385. 

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

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

  388.     {

  389.         using std::fabs;

  390. 

  391.         return fabs(a.x) > fabs(a.z)

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

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

  394.     }

  395. 

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

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

  398.     {

  399.         return normalize(orthogonal(a));

  400.     }

  401. 

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

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

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

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

  406. 

  407.     union

  408.     {

  409.         struct { T x, y, z; }; /* axis */

  410.         struct { T r, g, b; }; /* red, green, blue */

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

  412. 

  413. #if !_DOXYGEN_SKIP_ME

  414.         vec_t<T, 2, 9000> const xx, rr, ss/**/, ww;

  415.         vec_t<T, 2, 9001> const xy, rg, st, rt, wh;

  416.         vec_t<T, 2, 9002> const xz, rb, sp, rp, wd;

  417.         vec_t<T, 2, 9010> const yx, gr, ts, tr, hw;

  418.         vec_t<T, 2, 9011> const yy, gg, tt/**/, hh;

  419.         vec_t<T, 2, 9012> const yz, gb, tp/**/, hd;

  420.         vec_t<T, 2, 9020> const zx, br, ps, pr, dw;

  421.         vec_t<T, 2, 9021> const zy, bg, pt/**/, dh;

  422.         vec_t<T, 2, 9022> const zz, bb, pp/**/, dd;

  423. 

  424.         vec_t<T, 3, 90000> const xxx, rrr, sss /**/, www;

  425.         vec_t<T, 3, 90001> const xxy, rrg, sst, rrt, wwh;

  426.         vec_t<T, 3, 90002> const xxz, rrb, ssp, rrp, wwd;

  427.         vec_t<T, 3, 90010> const xyx, rgr, sts, rtr, whw;

  428.         vec_t<T, 3, 90011> const xyy, rgg, stt, rtt, whh;

  429.         vec_t<T, 3, 90012> const xyz, rgb, stp, rtp, whd;

  430.         vec_t<T, 3, 90020> const xzx, rbr, sps, rpr, wdw;

  431.         vec_t<T, 3, 90021> const xzy, rbg, spt, rpt, wdh;

  432.         vec_t<T, 3, 90022> const xzz, rbb, spp, rpp, wdd;

  433.         vec_t<T, 3, 90100> const yxx, grr, tss, trr, hww;

  434.         vec_t<T, 3, 90101> const yxy, grg, tst, trt, hwh;

  435.         vec_t<T, 3, 90102> const yxz, grb, tsp, trp, hwd;

  436.         vec_t<T, 3, 90110> const yyx, ggr, tts, ttr, hhw;

  437.         vec_t<T, 3, 90111> const yyy, ggg, ttt /**/, hhh;

  438.         vec_t<T, 3, 90112> const yyz, ggb, ttp /**/, hhd;

  439.         vec_t<T, 3, 90120> const yzx, gbr, tps, tpr, hdw;

  440.         vec_t<T, 3, 90121> const yzy, gbg, tpt /**/, hdh;

  441.         vec_t<T, 3, 90122> const yzz, gbb, tpp /**/, hdd;

  442.         vec_t<T, 3, 90200> const zxx, brr, pss, prr, dww;

  443.         vec_t<T, 3, 90201> const zxy, brg, pst, prt, dwh;

  444.         vec_t<T, 3, 90202> const zxz, brb, psp, prp, dwd;

  445.         vec_t<T, 3, 90210> const zyx, bgr, pts, ptr, dhw;

  446.         vec_t<T, 3, 90211> const zyy, bgg, ptt /**/, dhh;

  447.         vec_t<T, 3, 90212> const zyz, bgb, ptp /**/, dhd;

  448.         vec_t<T, 3, 90220> const zzx, bbr, pps, ppr, ddw;

  449.         vec_t<T, 3, 90221> const zzy, bbg, ppt /**/, ddh;

  450.         vec_t<T, 3, 90222> const zzz, bbb, ppp /**/, ddd;

  451. 

  452.         vec_t<T,4,900000> const xxxx, rrrr, ssss;

  453.         vec_t<T,4,900001> const xxxy, rrrg, ssst;

  454.         vec_t<T,4,900002> const xxxz, rrrb, sssp;

  455.         vec_t<T,4,900010> const xxyx, rrgr, ssts;

  456.         vec_t<T,4,900011> const xxyy, rrgg, sstt;

  457.         vec_t<T,4,900012> const xxyz, rrgb, sstp;

  458.         vec_t<T,4,900020> const xxzx, rrbr, ssps;

  459.         vec_t<T,4,900021> const xxzy, rrbg, sspt;

  460.         vec_t<T,4,900022> const xxzz, rrbb, sspp;

  461.         vec_t<T,4,900100> const xyxx, rgrr, stss;

  462.         vec_t<T,4,900101> const xyxy, rgrg, stst;

  463.         vec_t<T,4,900102> const xyxz, rgrb, stsp;

  464.         vec_t<T,4,900110> const xyyx, rggr, stts;

  465.         vec_t<T,4,900111> const xyyy, rggg, sttt;

  466.         vec_t<T,4,900112> const xyyz, rggb, sttp;

  467.         vec_t<T,4,900120> const xyzx, rgbr, stps;

  468.         vec_t<T,4,900121> const xyzy, rgbg, stpt;

  469.         vec_t<T,4,900122> const xyzz, rgbb, stpp;

  470.         vec_t<T,4,900200> const xzxx, rbrr, spss;

  471.         vec_t<T,4,900201> const xzxy, rbrg, spst;

  472.         vec_t<T,4,900202> const xzxz, rbrb, spsp;

  473.         vec_t<T,4,900210> const xzyx, rbgr, spts;

  474.         vec_t<T,4,900211> const xzyy, rbgg, sptt;

  475.         vec_t<T,4,900212> const xzyz, rbgb, sptp;

  476.         vec_t<T,4,900220> const xzzx, rbbr, spps;

  477.         vec_t<T,4,900221> const xzzy, rbbg, sppt;

  478.         vec_t<T,4,900222> const xzzz, rbbb, sppp;

  479.         vec_t<T,4,901000> const yxxx, grrr, tsss;

  480.         vec_t<T,4,901001> const yxxy, grrg, tsst;

  481.         vec_t<T,4,901002> const yxxz, grrb, tssp;

  482.         vec_t<T,4,901010> const yxyx, grgr, tsts;

  483.         vec_t<T,4,901011> const yxyy, grgg, tstt;

  484.         vec_t<T,4,901012> const yxyz, grgb, tstp;

  485.         vec_t<T,4,901020> const yxzx, grbr, tsps;

  486.         vec_t<T,4,901021> const yxzy, grbg, tspt;

  487.         vec_t<T,4,901022> const yxzz, grbb, tspp;

  488.         vec_t<T,4,901100> const yyxx, ggrr, ttss;

  489.         vec_t<T,4,901101> const yyxy, ggrg, ttst;

  490.         vec_t<T,4,901102> const yyxz, ggrb, ttsp;

  491.         vec_t<T,4,901110> const yyyx, gggr, ttts;

  492.         vec_t<T,4,901111> const yyyy, gggg, tttt;

  493.         vec_t<T,4,901112> const yyyz, gggb, tttp;

  494.         vec_t<T,4,901120> const yyzx, ggbr, ttps;

  495.         vec_t<T,4,901121> const yyzy, ggbg, ttpt;

  496.         vec_t<T,4,901122> const yyzz, ggbb, ttpp;

  497.         vec_t<T,4,901200> const yzxx, gbrr, tpss;

  498.         vec_t<T,4,901201> const yzxy, gbrg, tpst;

  499.         vec_t<T,4,901202> const yzxz, gbrb, tpsp;

  500.         vec_t<T,4,901210> const yzyx, gbgr, tpts;

  501.         vec_t<T,4,901211> const yzyy, gbgg, tptt;

  502.         vec_t<T,4,901212> const yzyz, gbgb, tptp;

  503.         vec_t<T,4,901220> const yzzx, gbbr, tpps;

  504.         vec_t<T,4,901221> const yzzy, gbbg, tppt;

  505.         vec_t<T,4,901222> const yzzz, gbbb, tppp;

  506.         vec_t<T,4,902000> const zxxx, brrr, psss;

  507.         vec_t<T,4,902001> const zxxy, brrg, psst;

  508.         vec_t<T,4,902002> const zxxz, brrb, pssp;

  509.         vec_t<T,4,902010> const zxyx, brgr, psts;

  510.         vec_t<T,4,902011> const zxyy, brgg, pstt;

  511.         vec_t<T,4,902012> const zxyz, brgb, pstp;

  512.         vec_t<T,4,902020> const zxzx, brbr, psps;

  513.         vec_t<T,4,902021> const zxzy, brbg, pspt;

  514.         vec_t<T,4,902022> const zxzz, brbb, pspp;

  515.         vec_t<T,4,902100> const zyxx, bgrr, ptss;

  516.         vec_t<T,4,902101> const zyxy, bgrg, ptst;

  517.         vec_t<T,4,902102> const zyxz, bgrb, ptsp;

  518.         vec_t<T,4,902110> const zyyx, bggr, ptts;

  519.         vec_t<T,4,902111> const zyyy, bggg, pttt;

  520.         vec_t<T,4,902112> const zyyz, bggb, pttp;

  521.         vec_t<T,4,902120> const zyzx, bgbr, ptps;

  522.         vec_t<T,4,902121> const zyzy, bgbg, ptpt;

  523.         vec_t<T,4,902122> const zyzz, bgbb, ptpp;

  524.         vec_t<T,4,902200> const zzxx, bbrr, ppss;

  525.         vec_t<T,4,902201> const zzxy, bbrg, ppst;

  526.         vec_t<T,4,902202> const zzxz, bbrb, ppsp;

  527.         vec_t<T,4,902210> const zzyx, bbgr, ppts;

  528.         vec_t<T,4,902211> const zzyy, bbgg, pptt;

  529.         vec_t<T,4,902212> const zzyz, bbgb, pptp;

  530.         vec_t<T,4,902220> const zzzx, bbbr, ppps;

  531.         vec_t<T,4,902221> const zzzy, bbbg, pppt;

  532.         vec_t<T,4,902222> const zzzz, bbbb, pppp;

  533. #endif

  534. 

  535.         T m_data[count];

  536.     };

  537. };

  538. 

  539. /*

  540.  * 4-element vectors

  541.  */

  542. 

  543. template <typename T>

  544. struct [[nodiscard]] vec_t<T,4>

  545.   : public swizzle_ops::base<T>

  546. {

  547.     static int const count = 4;

  548.     typedef T scalar_element;

  549.     typedef T element;

  550.     typedef vec_t<T,4> type;

  551. 

  552.     // Default constructor, copy constructor, and destructor

  553.     inline constexpr vec_t() = default;

  554.     inline constexpr vec_t(type const &v) = default;

  555.     inline ~vec_t() = default;

  556. 

  557.     /* Implicit constructor for swizzling */

  558.     template<int SWIZZLE>

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

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

  561. 

  562.     /* Explicit constructor for type conversion */

  563.     template<typename U, int SWIZZLE>

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

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

  566. 

  567.     /* Constructor for initializer_list. We need these ugly

  568.      * loops until C++ lets us initialize m_data directly. */

  569.     inline vec_t(std::initializer_list<element> const &list)

  570.     {

  571.         auto l = list.begin();

  572.         for (int i = 0; i < count && l != list.end(); ++i, ++l)

  573.             m_data[i] = *l;

  574.         for (int i = (int)list.size(); i < count; ++i)

  575.             m_data[i] = T(0);

  576.     }

  577. 

  578.     /* Various explicit constructors */

  579.     explicit inline constexpr vec_t(T X)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  595. 

  596.     /* Factory for base axis vectors, e.g. [1,0,0,…,0] */

  597.     static inline vec_t<T,4> axis(int i)

  598.     {

  599.         assert(i >= 0);

  600.         assert(i < 4);

  601.         return vec_t<T,4>(T(i == 0), T(i == 1), T(i == 2), T(i == 3));

  602.     }

  603. 

  604.     LOL_COMMON_MEMBER_OPS(x)

  605. 

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

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

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

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

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

  611. 

  612.     union

  613.     {

  614.         struct { T x, y, z, w; }; /* axis */

  615.         struct { T r, g, b, a; }; /* red, green, blue, alpha */

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

  617. 

  618. #if !_DOXYGEN_SKIP_ME

  619.         vec_t<T,2,9000> const xx, rr, ss;

  620.         vec_t<T,2,9001> const xy, rg, st;

  621.         vec_t<T,2,9002> const xz, rb, sp;

  622.         vec_t<T,2,9003> const xw, ra, sq;

  623.         vec_t<T,2,9010> const yx, gr, ts;

  624.         vec_t<T,2,9011> const yy, gg, tt;

  625.         vec_t<T,2,9012> const yz, gb, tp;

  626.         vec_t<T,2,9013> const yw, ga, tq;

  627.         vec_t<T,2,9020> const zx, br, ps;

  628.         vec_t<T,2,9021> const zy, bg, pt;

  629.         vec_t<T,2,9022> const zz, bb, pp;

  630.         vec_t<T,2,9023> const zw, ba, pq;

  631.         vec_t<T,2,9030> const wx, ar, qs;

  632.         vec_t<T,2,9031> const wy, ag, qt;

  633.         vec_t<T,2,9032> const wz, ab, qp;

  634.         vec_t<T,2,9033> const ww, aa, qq;

  635. 

  636.         vec_t<T,3,90000> const xxx, rrr, sss;

  637.         vec_t<T,3,90001> const xxy, rrg, sst;

  638.         vec_t<T,3,90002> const xxz, rrb, ssp;

  639.         vec_t<T,3,90003> const xxw, rra, ssq;

  640.         vec_t<T,3,90010> const xyx, rgr, sts;

  641.         vec_t<T,3,90011> const xyy, rgg, stt;

  642.         vec_t<T,3,90012> const xyz, rgb, stp;

  643.         vec_t<T,3,90013> const xyw, rga, stq;

  644.         vec_t<T,3,90020> const xzx, rbr, sps;

  645.         vec_t<T,3,90021> const xzy, rbg, spt;

  646.         vec_t<T,3,90022> const xzz, rbb, spp;

  647.         vec_t<T,3,90023> const xzw, rba, spq;

  648.         vec_t<T,3,90030> const xwx, rar, sqs;

  649.         vec_t<T,3,90031> const xwy, rag, sqt;

  650.         vec_t<T,3,90032> const xwz, rab, sqp;

  651.         vec_t<T,3,90033> const xww, raa, sqq;

  652.         vec_t<T,3,90100> const yxx, grr, tss;

  653.         vec_t<T,3,90101> const yxy, grg, tst;

  654.         vec_t<T,3,90102> const yxz, grb, tsp;

  655.         vec_t<T,3,90103> const yxw, gra, tsq;

  656.         vec_t<T,3,90110> const yyx, ggr, tts;

  657.         vec_t<T,3,90111> const yyy, ggg, ttt;

  658.         vec_t<T,3,90112> const yyz, ggb, ttp;

  659.         vec_t<T,3,90113> const yyw, gga, ttq;

  660.         vec_t<T,3,90120> const yzx, gbr, tps;

  661.         vec_t<T,3,90121> const yzy, gbg, tpt;

  662.         vec_t<T,3,90122> const yzz, gbb, tpp;

  663.         vec_t<T,3,90123> const yzw, gba, tpq;

  664.         vec_t<T,3,90130> const ywx, gar, tqs;

  665.         vec_t<T,3,90131> const ywy, gag, tqt;

  666.         vec_t<T,3,90132> const ywz, gab, tqp;

  667.         vec_t<T,3,90133> const yww, gaa, tqq;

  668.         vec_t<T,3,90200> const zxx, brr, pss;

  669.         vec_t<T,3,90201> const zxy, brg, pst;

  670.         vec_t<T,3,90202> const zxz, brb, psp;

  671.         vec_t<T,3,90203> const zxw, bra, psq;

  672.         vec_t<T,3,90210> const zyx, bgr, pts;

  673.         vec_t<T,3,90211> const zyy, bgg, ptt;

  674.         vec_t<T,3,90212> const zyz, bgb, ptp;

  675.         vec_t<T,3,90213> const zyw, bga, ptq;

  676.         vec_t<T,3,90220> const zzx, bbr, pps;

  677.         vec_t<T,3,90221> const zzy, bbg, ppt;

  678.         vec_t<T,3,90222> const zzz, bbb, ppp;

  679.         vec_t<T,3,90223> const zzw, bba, ppq;

  680.         vec_t<T,3,90230> const zwx, bar, pqs;

  681.         vec_t<T,3,90231> const zwy, bag, pqt;

  682.         vec_t<T,3,90232> const zwz, bab, pqp;

  683.         vec_t<T,3,90233> const zww, baa, pqq;

  684.         vec_t<T,3,90300> const wxx, arr, qss;

  685.         vec_t<T,3,90301> const wxy, arg, qst;

  686.         vec_t<T,3,90302> const wxz, arb, qsp;

  687.         vec_t<T,3,90303> const wxw, ara, qsq;

  688.         vec_t<T,3,90310> const wyx, agr, qts;

  689.         vec_t<T,3,90311> const wyy, agg, qtt;

  690.         vec_t<T,3,90312> const wyz, agb, qtp;

  691.         vec_t<T,3,90313> const wyw, aga, qtq;

  692.         vec_t<T,3,90320> const wzx, abr, qps;

  693.         vec_t<T,3,90321> const wzy, abg, qpt;

  694.         vec_t<T,3,90322> const wzz, abb, qpp;

  695.         vec_t<T,3,90323> const wzw, aba, qpq;

  696.         vec_t<T,3,90330> const wwx, aar, qqs;

  697.         vec_t<T,3,90331> const wwy, aag, qqt;

  698.         vec_t<T,3,90332> const wwz, aab, qqp;

  699.         vec_t<T,3,90333> const www, aaa, qqq;

  700. 

  701.         vec_t<T,4,900000> const xxxx, rrrr, ssss;

  702.         vec_t<T,4,900001> const xxxy, rrrg, ssst;

  703.         vec_t<T,4,900002> const xxxz, rrrb, sssp;

  704.         vec_t<T,4,900003> const xxxw, rrra, sssq;

  705.         vec_t<T,4,900010> const xxyx, rrgr, ssts;

  706.         vec_t<T,4,900011> const xxyy, rrgg, sstt;

  707.         vec_t<T,4,900012> const xxyz, rrgb, sstp;

  708.         vec_t<T,4,900013> const xxyw, rrga, sstq;

  709.         vec_t<T,4,900020> const xxzx, rrbr, ssps;

  710.         vec_t<T,4,900021> const xxzy, rrbg, sspt;

  711.         vec_t<T,4,900022> const xxzz, rrbb, sspp;

  712.         vec_t<T,4,900023> const xxzw, rrba, sspq;

  713.         vec_t<T,4,900030> const xxwx, rrar, ssqs;

  714.         vec_t<T,4,900031> const xxwy, rrag, ssqt;

  715.         vec_t<T,4,900032> const xxwz, rrab, ssqp;

  716.         vec_t<T,4,900033> const xxww, rraa, ssqq;

  717.         vec_t<T,4,900100> const xyxx, rgrr, stss;

  718.         vec_t<T,4,900101> const xyxy, rgrg, stst;

  719.         vec_t<T,4,900102> const xyxz, rgrb, stsp;

  720.         vec_t<T,4,900103> const xyxw, rgra, stsq;

  721.         vec_t<T,4,900110> const xyyx, rggr, stts;

  722.         vec_t<T,4,900111> const xyyy, rggg, sttt;

  723.         vec_t<T,4,900112> const xyyz, rggb, sttp;

  724.         vec_t<T,4,900113> const xyyw, rgga, sttq;

  725.         vec_t<T,4,900120> const xyzx, rgbr, stps;

  726.         vec_t<T,4,900121> const xyzy, rgbg, stpt;

  727.         vec_t<T,4,900122> const xyzz, rgbb, stpp;

  728.         vec_t<T,4,900123> const xyzw, rgba, stpq;

  729.         vec_t<T,4,900130> const xywx, rgar, stqs;

  730.         vec_t<T,4,900131> const xywy, rgag, stqt;

  731.         vec_t<T,4,900132> const xywz, rgab, stqp;

  732.         vec_t<T,4,900133> const xyww, rgaa, stqq;

  733.         vec_t<T,4,900200> const xzxx, rbrr, spss;

  734.         vec_t<T,4,900201> const xzxy, rbrg, spst;

  735.         vec_t<T,4,900202> const xzxz, rbrb, spsp;

  736.         vec_t<T,4,900203> const xzxw, rbra, spsq;

  737.         vec_t<T,4,900210> const xzyx, rbgr, spts;

  738.         vec_t<T,4,900211> const xzyy, rbgg, sptt;

  739.         vec_t<T,4,900212> const xzyz, rbgb, sptp;

  740.         vec_t<T,4,900213> const xzyw, rbga, sptq;

  741.         vec_t<T,4,900220> const xzzx, rbbr, spps;

  742.         vec_t<T,4,900221> const xzzy, rbbg, sppt;

  743.         vec_t<T,4,900222> const xzzz, rbbb, sppp;

  744.         vec_t<T,4,900223> const xzzw, rbba, sppq;

  745.         vec_t<T,4,900230> const xzwx, rbar, spqs;

  746.         vec_t<T,4,900231> const xzwy, rbag, spqt;

  747.         vec_t<T,4,900232> const xzwz, rbab, spqp;

  748.         vec_t<T,4,900233> const xzww, rbaa, spqq;

  749.         vec_t<T,4,900300> const xwxx, rarr, sqss;

  750.         vec_t<T,4,900301> const xwxy, rarg, sqst;

  751.         vec_t<T,4,900302> const xwxz, rarb, sqsp;

  752.         vec_t<T,4,900303> const xwxw, rara, sqsq;

  753.         vec_t<T,4,900310> const xwyx, ragr, sqts;

  754.         vec_t<T,4,900311> const xwyy, ragg, sqtt;

  755.         vec_t<T,4,900312> const xwyz, ragb, sqtp;

  756.         vec_t<T,4,900313> const xwyw, raga, sqtq;

  757.         vec_t<T,4,900320> const xwzx, rabr, sqps;

  758.         vec_t<T,4,900321> const xwzy, rabg, sqpt;

  759.         vec_t<T,4,900322> const xwzz, rabb, sqpp;

  760.         vec_t<T,4,900323> const xwzw, raba, sqpq;

  761.         vec_t<T,4,900330> const xwwx, raar, sqqs;

  762.         vec_t<T,4,900331> const xwwy, raag, sqqt;

  763.         vec_t<T,4,900332> const xwwz, raab, sqqp;

  764.         vec_t<T,4,900333> const xwww, raaa, sqqq;

  765.         vec_t<T,4,901000> const yxxx, grrr, tsss;

  766.         vec_t<T,4,901001> const yxxy, grrg, tsst;

  767.         vec_t<T,4,901002> const yxxz, grrb, tssp;

  768.         vec_t<T,4,901003> const yxxw, grra, tssq;

  769.         vec_t<T,4,901010> const yxyx, grgr, tsts;

  770.         vec_t<T,4,901011> const yxyy, grgg, tstt;

  771.         vec_t<T,4,901012> const yxyz, grgb, tstp;

  772.         vec_t<T,4,901013> const yxyw, grga, tstq;

  773.         vec_t<T,4,901020> const yxzx, grbr, tsps;

  774.         vec_t<T,4,901021> const yxzy, grbg, tspt;

  775.         vec_t<T,4,901022> const yxzz, grbb, tspp;

  776.         vec_t<T,4,901023> const yxzw, grba, tspq;

  777.         vec_t<T,4,901030> const yxwx, grar, tsqs;

  778.         vec_t<T,4,901031> const yxwy, grag, tsqt;

  779.         vec_t<T,4,901032> const yxwz, grab, tsqp;

  780.         vec_t<T,4,901033> const yxww, graa, tsqq;

  781.         vec_t<T,4,901100> const yyxx, ggrr, ttss;

  782.         vec_t<T,4,901101> const yyxy, ggrg, ttst;

  783.         vec_t<T,4,901102> const yyxz, ggrb, ttsp;

  784.         vec_t<T,4,901103> const yyxw, ggra, ttsq;

  785.         vec_t<T,4,901110> const yyyx, gggr, ttts;

  786.         vec_t<T,4,901111> const yyyy, gggg, tttt;

  787.         vec_t<T,4,901112> const yyyz, gggb, tttp;

  788.         vec_t<T,4,901113> const yyyw, ggga, tttq;

  789.         vec_t<T,4,901120> const yyzx, ggbr, ttps;

  790.         vec_t<T,4,901121> const yyzy, ggbg, ttpt;

  791.         vec_t<T,4,901122> const yyzz, ggbb, ttpp;

  792.         vec_t<T,4,901123> const yyzw, ggba, ttpq;

  793.         vec_t<T,4,901130> const yywx, ggar, ttqs;

  794.         vec_t<T,4,901131> const yywy, ggag, ttqt;

  795.         vec_t<T,4,901132> const yywz, ggab, ttqp;

  796.         vec_t<T,4,901133> const yyww, ggaa, ttqq;

  797.         vec_t<T,4,901200> const yzxx, gbrr, tpss;

  798.         vec_t<T,4,901201> const yzxy, gbrg, tpst;

  799.         vec_t<T,4,901202> const yzxz, gbrb, tpsp;

  800.         vec_t<T,4,901203> const yzxw, gbra, tpsq;

  801.         vec_t<T,4,901210> const yzyx, gbgr, tpts;

  802.         vec_t<T,4,901211> const yzyy, gbgg, tptt;

  803.         vec_t<T,4,901212> const yzyz, gbgb, tptp;

  804.         vec_t<T,4,901213> const yzyw, gbga, tptq;

  805.         vec_t<T,4,901220> const yzzx, gbbr, tpps;

  806.         vec_t<T,4,901221> const yzzy, gbbg, tppt;

  807.         vec_t<T,4,901222> const yzzz, gbbb, tppp;

  808.         vec_t<T,4,901223> const yzzw, gbba, tppq;

  809.         vec_t<T,4,901230> const yzwx, gbar, tpqs;

  810.         vec_t<T,4,901231> const yzwy, gbag, tpqt;

  811.         vec_t<T,4,901232> const yzwz, gbab, tpqp;

  812.         vec_t<T,4,901233> const yzww, gbaa, tpqq;

  813.         vec_t<T,4,901300> const ywxx, garr, tqss;

  814.         vec_t<T,4,901301> const ywxy, garg, tqst;

  815.         vec_t<T,4,901302> const ywxz, garb, tqsp;

  816.         vec_t<T,4,901303> const ywxw, gara, tqsq;

  817.         vec_t<T,4,901310> const ywyx, gagr, tqts;

  818.         vec_t<T,4,901311> const ywyy, gagg, tqtt;

  819.         vec_t<T,4,901312> const ywyz, gagb, tqtp;

  820.         vec_t<T,4,901313> const ywyw, gaga, tqtq;

  821.         vec_t<T,4,901320> const ywzx, gabr, tqps;

  822.         vec_t<T,4,901321> const ywzy, gabg, tqpt;

  823.         vec_t<T,4,901322> const ywzz, gabb, tqpp;

  824.         vec_t<T,4,901323> const ywzw, gaba, tqpq;

  825.         vec_t<T,4,901330> const ywwx, gaar, tqqs;

  826.         vec_t<T,4,901331> const ywwy, gaag, tqqt;

  827.         vec_t<T,4,901332> const ywwz, gaab, tqqp;

  828.         vec_t<T,4,901333> const ywww, gaaa, tqqq;

  829.         vec_t<T,4,902000> const zxxx, brrr, psss;

  830.         vec_t<T,4,902001> const zxxy, brrg, psst;

  831.         vec_t<T,4,902002> const zxxz, brrb, pssp;

  832.         vec_t<T,4,902003> const zxxw, brra, pssq;

  833.         vec_t<T,4,902010> const zxyx, brgr, psts;

  834.         vec_t<T,4,902011> const zxyy, brgg, pstt;

  835.         vec_t<T,4,902012> const zxyz, brgb, pstp;

  836.         vec_t<T,4,902013> const zxyw, brga, pstq;

  837.         vec_t<T,4,902020> const zxzx, brbr, psps;

  838.         vec_t<T,4,902021> const zxzy, brbg, pspt;

  839.         vec_t<T,4,902022> const zxzz, brbb, pspp;

  840.         vec_t<T,4,902023> const zxzw, brba, pspq;

  841.         vec_t<T,4,902030> const zxwx, brar, psqs;

  842.         vec_t<T,4,902031> const zxwy, brag, psqt;

  843.         vec_t<T,4,902032> const zxwz, brab, psqp;

  844.         vec_t<T,4,902033> const zxww, braa, psqq;

  845.         vec_t<T,4,902100> const zyxx, bgrr, ptss;

  846.         vec_t<T,4,902101> const zyxy, bgrg, ptst;

  847.         vec_t<T,4,902102> const zyxz, bgrb, ptsp;

  848.         vec_t<T,4,902103> const zyxw, bgra, ptsq;

  849.         vec_t<T,4,902110> const zyyx, bggr, ptts;

  850.         vec_t<T,4,902111> const zyyy, bggg, pttt;

  851.         vec_t<T,4,902112> const zyyz, bggb, pttp;

  852.         vec_t<T,4,902113> const zyyw, bgga, pttq;

  853.         vec_t<T,4,902120> const zyzx, bgbr, ptps;

  854.         vec_t<T,4,902121> const zyzy, bgbg, ptpt;

  855.         vec_t<T,4,902122> const zyzz, bgbb, ptpp;

  856.         vec_t<T,4,902123> const zyzw, bgba, ptpq;

  857.         vec_t<T,4,902130> const zywx, bgar, ptqs;

  858.         vec_t<T,4,902131> const zywy, bgag, ptqt;

  859.         vec_t<T,4,902132> const zywz, bgab, ptqp;

  860.         vec_t<T,4,902133> const zyww, bgaa, ptqq;

  861.         vec_t<T,4,902200> const zzxx, bbrr, ppss;

  862.         vec_t<T,4,902201> const zzxy, bbrg, ppst;

  863.         vec_t<T,4,902202> const zzxz, bbrb, ppsp;

  864.         vec_t<T,4,902203> const zzxw, bbra, ppsq;

  865.         vec_t<T,4,902210> const zzyx, bbgr, ppts;

  866.         vec_t<T,4,902211> const zzyy, bbgg, pptt;

  867.         vec_t<T,4,902212> const zzyz, bbgb, pptp;

  868.         vec_t<T,4,902213> const zzyw, bbga, pptq;

  869.         vec_t<T,4,902220> const zzzx, bbbr, ppps;

  870.         vec_t<T,4,902221> const zzzy, bbbg, pppt;

  871.         vec_t<T,4,902222> const zzzz, bbbb, pppp;

  872.         vec_t<T,4,902223> const zzzw, bbba, pppq;

  873.         vec_t<T,4,902230> const zzwx, bbar, ppqs;

  874.         vec_t<T,4,902231> const zzwy, bbag, ppqt;

  875.         vec_t<T,4,902232> const zzwz, bbab, ppqp;

  876.         vec_t<T,4,902233> const zzww, bbaa, ppqq;

  877.         vec_t<T,4,902300> const zwxx, barr, pqss;

  878.         vec_t<T,4,902301> const zwxy, barg, pqst;

  879.         vec_t<T,4,902302> const zwxz, barb, pqsp;

  880.         vec_t<T,4,902303> const zwxw, bara, pqsq;

  881.         vec_t<T,4,902310> const zwyx, bagr, pqts;

  882.         vec_t<T,4,902311> const zwyy, bagg, pqtt;

  883.         vec_t<T,4,902312> const zwyz, bagb, pqtp;

  884.         vec_t<T,4,902313> const zwyw, baga, pqtq;

  885.         vec_t<T,4,902320> const zwzx, babr, pqps;

  886.         vec_t<T,4,902321> const zwzy, babg, pqpt;

  887.         vec_t<T,4,902322> const zwzz, babb, pqpp;

  888.         vec_t<T,4,902323> const zwzw, baba, pqpq;

  889.         vec_t<T,4,902330> const zwwx, baar, pqqs;

  890.         vec_t<T,4,902331> const zwwy, baag, pqqt;

  891.         vec_t<T,4,902332> const zwwz, baab, pqqp;

  892.         vec_t<T,4,902333> const zwww, baaa, pqqq;

  893.         vec_t<T,4,903000> const wxxx, arrr, qsss;

  894.         vec_t<T,4,903001> const wxxy, arrg, qsst;

  895.         vec_t<T,4,903002> const wxxz, arrb, qssp;

  896.         vec_t<T,4,903003> const wxxw, arra, qssq;

  897.         vec_t<T,4,903010> const wxyx, argr, qsts;

  898.         vec_t<T,4,903011> const wxyy, argg, qstt;

  899.         vec_t<T,4,903012> const wxyz, argb, qstp;

  900.         vec_t<T,4,903013> const wxyw, arga, qstq;

  901.         vec_t<T,4,903020> const wxzx, arbr, qsps;

  902.         vec_t<T,4,903021> const wxzy, arbg, qspt;

  903.         vec_t<T,4,903022> const wxzz, arbb, qspp;

  904.         vec_t<T,4,903023> const wxzw, arba, qspq;

  905.         vec_t<T,4,903030> const wxwx, arar, qsqs;

  906.         vec_t<T,4,903031> const wxwy, arag, qsqt;

  907.         vec_t<T,4,903032> const wxwz, arab, qsqp;

  908.         vec_t<T,4,903033> const wxww, araa, qsqq;

  909.         vec_t<T,4,903100> const wyxx, agrr, qtss;

  910.         vec_t<T,4,903101> const wyxy, agrg, qtst;

  911.         vec_t<T,4,903102> const wyxz, agrb, qtsp;

  912.         vec_t<T,4,903103> const wyxw, agra, qtsq;

  913.         vec_t<T,4,903110> const wyyx, aggr, qtts;

  914.         vec_t<T,4,903111> const wyyy, aggg, qttt;

  915.         vec_t<T,4,903112> const wyyz, aggb, qttp;

  916.         vec_t<T,4,903113> const wyyw, agga, qttq;

  917.         vec_t<T,4,903120> const wyzx, agbr, qtps;

  918.         vec_t<T,4,903121> const wyzy, agbg, qtpt;

  919.         vec_t<T,4,903122> const wyzz, agbb, qtpp;

  920.         vec_t<T,4,903123> const wyzw, agba, qtpq;

  921.         vec_t<T,4,903130> const wywx, agar, qtqs;

  922.         vec_t<T,4,903131> const wywy, agag, qtqt;

  923.         vec_t<T,4,903132> const wywz, agab, qtqp;

  924.         vec_t<T,4,903133> const wyww, agaa, qtqq;

  925.         vec_t<T,4,903200> const wzxx, abrr, qpss;

  926.         vec_t<T,4,903201> const wzxy, abrg, qpst;

  927.         vec_t<T,4,903202> const wzxz, abrb, qpsp;

  928.         vec_t<T,4,903203> const wzxw, abra, qpsq;

  929.         vec_t<T,4,903210> const wzyx, abgr, qpts;

  930.         vec_t<T,4,903211> const wzyy, abgg, qptt;

  931.         vec_t<T,4,903212> const wzyz, abgb, qptp;

  932.         vec_t<T,4,903213> const wzyw, abga, qptq;

  933.         vec_t<T,4,903220> const wzzx, abbr, qpps;

  934.         vec_t<T,4,903221> const wzzy, abbg, qppt;

  935.         vec_t<T,4,903222> const wzzz, abbb, qppp;

  936.         vec_t<T,4,903223> const wzzw, abba, qppq;

  937.         vec_t<T,4,903230> const wzwx, abar, qpqs;

  938.         vec_t<T,4,903231> const wzwy, abag, qpqt;

  939.         vec_t<T,4,903232> const wzwz, abab, qpqp;

  940.         vec_t<T,4,903233> const wzww, abaa, qpqq;

  941.         vec_t<T,4,903300> const wwxx, aarr, qqss;

  942.         vec_t<T,4,903301> const wwxy, aarg, qqst;

  943.         vec_t<T,4,903302> const wwxz, aarb, qqsp;

  944.         vec_t<T,4,903303> const wwxw, aara, qqsq;

  945.         vec_t<T,4,903310> const wwyx, aagr, qqts;

  946.         vec_t<T,4,903311> const wwyy, aagg, qqtt;

  947.         vec_t<T,4,903312> const wwyz, aagb, qqtp;

  948.         vec_t<T,4,903313> const wwyw, aaga, qqtq;

  949.         vec_t<T,4,903320> const wwzx, aabr, qqps;

  950.         vec_t<T,4,903321> const wwzy, aabg, qqpt;

  951.         vec_t<T,4,903322> const wwzz, aabb, qqpp;

  952.         vec_t<T,4,903323> const wwzw, aaba, qqpq;

  953.         vec_t<T,4,903330> const wwwx, aaar, qqqs;

  954.         vec_t<T,4,903331> const wwwy, aaag, qqqt;

  955.         vec_t<T,4,903332> const wwwz, aaab, qqqp;

  956.         vec_t<T,4,903333> const wwww, aaaa, qqqq;

  957. #endif

  958. 

  959.         T m_data[count];

  960.     };

  961. };

  962. 

  963. /*

  964.  * stdstream method implementation

  965.  */

  966. 

  967. template<typename U, int N, int SWIZZLE = FULL_SWIZZLE>

  968. std::ostream &operator<<(std::ostream &stream, vec_t<U,N> const &v)

  969. {

  970.     stream << '(';

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

  972.         stream << v[i] << (i == N - 1 ? ")" : ", ");

  973.     return stream;

  974. }

  975. 

  976. /*

  977.  * vec_t *(scalar, vec_t)

  978.  */

  979. 

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

  981. static inline typename std::enable_if<SWIZZLE != FULL_SWIZZLE, vec_t<T,N>>::type

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

  983. {

  984.     vec_t<T,N> ret;

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

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

  987.     return ret;

  988. }

  989. 

  990. /*

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

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

  993.  */

  994. 

  995. #define LOL_SWIZZLE_V_VV_FUN(fun) \

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

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

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

  999.     { \

  1000.         vec_t<T,N> ret; \

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

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

  1003.         return ret; \

  1004.     } \

  1005.     \

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

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

  1008.     { \

  1009.         vec_t<T,N> ret; \

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

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

  1012.         return ret; \

  1013.     } \

  1014.     \

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

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

  1017.     { \

  1018.         vec_t<T,N> ret; \

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

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

  1021.         return ret; \

  1022.     }

  1023. 

  1024. LOL_SWIZZLE_V_VV_FUN(min)

  1025. LOL_SWIZZLE_V_VV_FUN(max)

  1026. LOL_SWIZZLE_V_VV_FUN(fmod)

  1027. 

  1028. #undef LOL_SWIZZLE_V_VV_FUN

  1029. 

  1030. /*

  1031.  * vec_t clamp(vec_t, vec_t, vec_t)

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

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

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

  1035.  */

  1036. 

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

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

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

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

  1041. {

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

  1043. }

  1044. 

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

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

  1047.                                T const &a,

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

  1049. {

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

  1051. }

  1052. 

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

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

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

  1056.                                T const &b)

  1057. {

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

  1059. }

  1060. 

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

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

  1063.                                T const &a,

  1064.                                T const &b)

  1065. {

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

  1067. }

  1068. 

  1069. /*

  1070.  * vec_t mix(vec_t, vec_t, vec_t)

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

  1072.  */

  1073. 

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

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

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

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

  1078. {

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

  1080. }

  1081. 

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

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

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

  1085.                              T const &a)

  1086. {

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

  1088. }

  1089. 

  1090. /*

  1091.  * Some GLSL-like functions.

  1092.  */

  1093. 

  1094. template<typename T, int N, int SWIZZLE1, int SWIZZLE2> [[nodiscard]]

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

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

  1097. {

  1098.     T ret(0);

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

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

  1101.     return ret;

  1102. }

  1103. 

  1104. template<typename T, int N, int SWIZZLE> [[nodiscard]]

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

  1106. {

  1107.     return dot(a, a);

  1108. }

  1109. 

  1110. template<typename T, int N, int SWIZZLE> [[nodiscard]]

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

  1112. {

  1113.     using std::sqrt;

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

  1115.     return T(sqrt(sqlength(a)));

  1116. }

  1117. 

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

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

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

  1121.                               T const &s)

  1122. {

  1123.     vec_t<T,N> ret;

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

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

  1126.     return ret;

  1127. }

  1128. 

  1129. template<typename T, int N, int SWIZZLE1, int SWIZZLE2> [[nodiscard]]

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

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

  1132. {

  1133.     return length(a - b);

  1134. }

  1135. 

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

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

  1138. {

  1139.     vec_t<T,N> ret;

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

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

  1142.     return ret;

  1143. }

  1144. 

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

  1146. static inline vec_t<T,N> saturate(vec_t<T,N,SWIZZLE> const &a)

  1147. {

  1148.     vec_t<T,N> ret;

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

  1150.         ret[i] = saturate(a[i]);

  1151.     return ret;

  1152. }

  1153. 

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

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

  1156. {

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

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

  1159. }

  1160. 

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

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

  1163. {

  1164.     vec_t<T,N> ret;

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

  1166.         ret[i] = abs(a[i]);

  1167.     return ret;

  1168. }

  1169. 

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

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

  1172. {

  1173.     vec_t<T,N> ret;

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

  1175.         ret[i] = degrees(a[i]);

  1176.     return ret;

  1177. }

  1178. 

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

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

  1181. {

  1182.     vec_t<T, N> ret;

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

  1184.         ret[i] = radians(a[i]);

  1185.     return ret;

  1186. }

  1187. 

  1188. // Cartesian operation consider that you're in spherical coordinate

  1189. template<typename T, int SWIZZLE>

  1190. static inline vec_t<T, 2> cartesian(vec_t<T, 2, SWIZZLE> const &a)

  1191. {

  1192.     using std::sin, std::cos;

  1193. 

  1194.     vec_t<T, 2> ret;

  1195.     ret.x = a[0] * cos(a[1]);

  1196.     ret.y = a[0] * sin(a[1]);

  1197.     return ret;

  1198. }

  1199. 

  1200. template<typename T, int SWIZZLE>

  1201. static inline vec_t<T, 3> cartesian(vec_t<T, 3, SWIZZLE> const &a)

  1202. {

  1203.     using std::sin, std::cos;

  1204. 

  1205.     vec_t<T, 3> ret;

  1206.     ret.x = a[0] * sin(a[2]) * cos(a[1]);

  1207.     ret.y = a[0] * cos(a[2]);

  1208.     ret.z = a[0] * sin(a[2]) * sin(a[1]);

  1209.     return ret;

  1210. }

  1211. 

  1212. // Spherical operation consider that you're in cartesian coordinate

  1213. template<typename T, int SWIZZLE>

  1214. static inline vec_t<T, 2> spherical(vec_t<T, 2, SWIZZLE> const &a)

  1215. {

  1216.     vec_t<T, 2> ret;

  1217.     ret[0] = sqlength(a);

  1218.     ret[1] = atan2(a.y, a.x);

  1219.     return ret;

  1220. }

  1221. 

  1222. template<typename T, int SWIZZLE>

  1223. static inline vec_t<T, 3> spherical(vec_t<T, 3, SWIZZLE> const &a)

  1224. {

  1225.     using std::atan, std::acos;

  1226. 

  1227.     vec_t<T, 3> ret;

  1228.     ret[0] = sqlength(a);

  1229.     ret[1] = atan(a.y / a.x);

  1230.     ret[2] = acos(a.z / ret[0]);

  1231.     return ret;

  1232. }

  1233. 

  1234. /*

  1235.  * C++11 iterators

  1236.  */

  1237. 

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

  1239. class vec_const_iter

  1240. {

  1241. public:

  1242.     inline vec_const_iter(vec_t<T,N,SWIZZLE> const &vec, int pos)

  1243.       : m_vec(vec),

  1244.         m_pos(pos)

  1245.     { }

  1246. 

  1247.     inline bool operator !=(vec_const_iter<T,N,SWIZZLE> const & that) const

  1248.     {

  1249.         return m_pos != that.m_pos;

  1250.     }

  1251. 

  1252.     template<int S = SWIZZLE>

  1253.     inline typename std::enable_if<S != FULL_SWIZZLE, T const &>::type

  1254.     operator *() const

  1255.     {

  1256.         return m_vec[m_pos];

  1257.     }

  1258. 

  1259.     template<int S = SWIZZLE>

  1260.     inline typename std::enable_if<S == FULL_SWIZZLE, T const &>::type

  1261.     operator *() const

  1262.     {

  1263.         return m_vec[m_pos];

  1264.     }

  1265. 

  1266.     inline vec_const_iter<T,N,SWIZZLE> & operator ++()

  1267.     {

  1268.         ++m_pos;

  1269.         return *this;

  1270.     }

  1271. 

  1272. private:

  1273.     vec_t<T,N,SWIZZLE> const &m_vec;

  1274.     int m_pos;

  1275. };

  1276. 

  1277. /* FIXME: do we need a non-const iterator? Looks almost useless to me,

  1278.  * and a lot of hassle with swizzling. */

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

  1280. inline vec_const_iter<T,N,SWIZZLE> begin(vec_t<T,N,SWIZZLE> const &a)

  1281. {

  1282.     return vec_const_iter<T,N,SWIZZLE>(a, 0);

  1283. }

  1284. 

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

  1286. inline vec_const_iter<T,N,SWIZZLE> end(vec_t<T,N,SWIZZLE> const &a)

  1287. {

  1288.     return vec_const_iter<T,N,SWIZZLE>(a, N);

  1289. }

  1290. 

  1291. /*

  1292.  * Constants

  1293.  */

  1294. 

  1295. template<typename T, int N>

  1296. vec_t<T,N> const vec_t<T,N>::zero = vec_t<T,N>(T(0));

  1297. template<typename T>

  1298. vec_t<T,2> const vec_t<T,2>::zero = vec_t<T,2>(T(0));

  1299. template<typename T>

  1300. vec_t<T,3> const vec_t<T,3>::zero = vec_t<T,3>(T(0));

  1301. template<typename T>

  1302. vec_t<T,4> const vec_t<T,4>::zero = vec_t<T,4>(T(0));

  1303. 

  1304. template<typename T>

  1305. vec_t<T,2> const vec_t<T,2>::axis_x = vec_t<T,2>(T(1), T(0));

  1306. template<typename T>

  1307. vec_t<T,2> const vec_t<T,2>::axis_y = vec_t<T,2>(T(0), T(1));

  1308. 

  1309. template<typename T>

  1310. vec_t<T,3> const vec_t<T,3>::axis_x = vec_t<T,3>(T(1), T(0), T(0));

  1311. template<typename T>

  1312. vec_t<T,3> const vec_t<T,3>::axis_y = vec_t<T,3>(T(0), T(1), T(0));

  1313. template<typename T>

  1314. vec_t<T,3> const vec_t<T,3>::axis_z = vec_t<T,3>(T(0), T(0), T(1));

  1315. 

  1316. template<typename T>

  1317. vec_t<T,4> const vec_t<T,4>::axis_x = vec_t<T,4>(T(1), T(0), T(0), T(0));

  1318. template<typename T>

  1319. vec_t<T,4> const vec_t<T,4>::axis_y = vec_t<T,4>(T(0), T(1), T(0), T(0));

  1320. template<typename T>

  1321. vec_t<T,4> const vec_t<T,4>::axis_z = vec_t<T,4>(T(0), T(0), T(1), T(0));

  1322. template<typename T>

  1323. vec_t<T,4> const vec_t<T,4>::axis_w = vec_t<T,4>(T(0), T(0), T(0), T(1));

  1324. 

  1325. //

  1326. // Generic GLSL-like type names

  1327. //

  1328. 

  1329. #define T_(tleft, tright, suffix) \

  1330.     typedef tleft half tright f16##suffix; \

  1331.     typedef tleft float tright suffix; \

  1332.     typedef tleft double tright d##suffix; \

  1333.     typedef tleft ldouble tright f128##suffix; \

  1334.     typedef tleft int8_t tright i8##suffix; \

  1335.     typedef tleft uint8_t tright u8##suffix; \

  1336.     typedef tleft int16_t tright i16##suffix; \

  1337.     typedef tleft uint16_t tright u16##suffix; \

  1338.     typedef tleft int32_t tright i##suffix; \

  1339.     typedef tleft uint32_t tright u##suffix; \

  1340.     typedef tleft int64_t tright i64##suffix; \

  1341.     typedef tleft uint64_t tright u64##suffix; \

  1342.     typedef tleft real tright r##suffix;

  1343. 

  1344. // Idiotic hack to put "," inside a macro argument

  1345. #define C_ ,

  1346. 

  1347. T_(vec_t<, C_ 2>, vec2)

  1348. T_(vec_t<, C_ 3>, vec3)

  1349. T_(vec_t<, C_ 4>, vec4)

  1350. T_(vec_t<, C_ 5>, vec5)

  1351. T_(vec_t<, C_ 6>, vec6)

  1352. T_(vec_t<, C_ 7>, vec7)

  1353. T_(vec_t<, C_ 8>, vec8)

  1354. T_(vec_t<, C_ 9>, vec9)

  1355. T_(vec_t<, C_ 10>, vec10)

  1356. T_(vec_t<, C_ 11>, vec11)

  1357. T_(vec_t<, C_ 12>, vec12)

  1358. 

  1359. #undef C_

  1360. #undef T_

  1361. 

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

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

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

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

  1366. 

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

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

  1369. 

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

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

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

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

  1374. 

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

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

  1377. 

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

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

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

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

  1382. 

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

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

  1385. 

  1386. //

  1387. // HLSL/Cg-compliant type names

  1388. //

  1389. 

  1390. typedef vec2 float2;

  1391. typedef vec3 float3;

  1392. typedef vec4 float4;

  1393. typedef vec5 float5;

  1394. typedef vec6 float6;

  1395. typedef vec7 float7;

  1396. typedef vec8 float8;

  1397. typedef vec9 float9;

  1398. typedef vec10 float10;

  1399. typedef vec11 float11;

  1400. typedef vec12 float12;

  1401. 

  1402. typedef f16vec2 half2;

  1403. typedef f16vec3 half3;

  1404. typedef f16vec4 half4;

  1405. 

  1406. typedef ivec2 int2;

  1407. typedef ivec3 int3;

  1408. typedef ivec4 int4;

  1409. typedef ivec5 int5;

  1410. typedef ivec6 int6;

  1411. typedef ivec7 int7;

  1412. typedef ivec8 int8;

  1413. typedef ivec9 int9;

  1414. typedef ivec10 int10;

  1415. typedef ivec11 int11;

  1416. typedef ivec12 int12;

  1417. 

  1418. } // namespace lol

  1419. 

  1420. #include "private/vector.ipp"