lolengine
/
lol
镜像自地址 https://github.com/lolengine/lol
1
0
派生 0
代码 工单 0 版本发布 0 百科 动态
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
3156 提交
5 分支
77 MiB
 
 
 
目录树: 01e1b2736d
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 '01e1b2736d'
${ noResults }
lol/include/lol/private/math/vector.h

1432 行
48 KiB
原始文件 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 <algorithm>   // std::min, std::max

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

  25. 

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

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

  28. 

  29. #include "ops.h"

  30. 

  31. namespace lol

  32. {

  33. 

  34. template<typename T> struct quat_t;

  35. 

  36. /*

  37.  * Magic vector swizzling

  38.  *

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

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

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

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

  43.  * casts.

  44.  *

  45.  * Using swizzled vectors as lvalues:

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

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

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

  49.  * However, Visual Studio 2013 doesn't support unrestricted unions, so

  50.  * fuck it for now.

  51.  */

  52. 

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

  54. struct [[nodiscard]] vec_t

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

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

  57.      * failures. */

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

  59. {

  60.     static int const count = N;

  61.     typedef T scalar_element;

  62.     typedef T element;

  63.     typedef vec_t<T,N> type;

  64. 

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

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

  67.     {

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

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

  70.         return *this;

  71.     }

  72. 

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

  74.     {

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

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

  77.     }

  78. 

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

  80.     {

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

  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 i = (SWIZZLE >> (3 * (N - 1 - n))) & 3;

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

  89.     }

  90. 

  91. private:

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

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

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

  95. 

  96.     vec_t() = default;

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

  98.     ~vec_t() = default;

  99. };

  100. 

  101. /*

  102.  * Helper macros for vector type member functions

  103.  */

  104. 

  105. #define LOL_COMMON_MEMBER_OPS(first) \

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

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

  108.     \

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

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

  111.     { \

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

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

  114.         return *this; \

  115.     } \

  116.     \

  117.     std::string tostring() const;

  118. 

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

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

  121. template<typename T, int N>

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

  123.   : public componentwise_ops::base<T>

  124. {

  125.     static int const count = N;

  126.     typedef T scalar_element;

  127.     typedef T element;

  128.     typedef vec_t<T,N> type;

  129. 

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

  131.     inline constexpr vec_t() = default;

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

  133.     inline ~vec_t() = default;

  134. 

  135.     LOL_COMMON_MEMBER_OPS(m_data[0])

  136. 

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

  138.     template<typename... ARGS>

  139.     explicit inline vec_t(T const &X,

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

  141.         ARGS... args)

  142.     {

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

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

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

  146.     }

  147. 

  148.     /* Various explicit constructors */

  149.     explicit inline vec_t(T const &X)

  150.     {

  151.         for (auto &value : m_data)

  152.             value = X;

  153.     }

  154. 

  155.     /* Explicit constructor for type conversion */

  156.     template<typename U>

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

  158.     {

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

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

  161.     }

  162. 

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

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

  165.     {

  166.         assert(i >= 0);

  167.         assert(i < N);

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

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

  170.         return ret;

  171.     }

  172. 

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

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

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

  176.     {

  177.         auto l = list.begin();

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

  179.             m_data[i] = *l;

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

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

  182.     }

  183. 

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

  185. 

  186. private:

  187.     template<typename... ARGS>

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

  189.     {

  190.         *data++ = x;

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

  192.     }

  193. 

  194.     static inline void internal_init(T *data)

  195.     {

  196.         (void)data;

  197.     }

  198. 

  199.     T m_data[count];

  200. };

  201. 

  202. /*

  203.  * 2-element vectors

  204.  */

  205. 

  206. template <typename T>

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

  208.   : public swizzle_ops::base<T>

  209. {

  210.     static int const count = 2;

  211.     typedef T scalar_element;

  212.     typedef T element;

  213.     typedef vec_t<T,2> type;

  214. 

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

  216.     inline constexpr vec_t() = default;

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

  218.     inline ~vec_t() = default;

  219. 

  220.     /* Implicit constructor for swizzling */

  221.     template<int SWIZZLE>

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

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

  224. 

  225.     /* Explicit constructor for type conversion */

  226.     template<typename U, int SWIZZLE>

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

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

  229. 

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

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

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

  233.     {

  234.         auto l = list.begin();

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

  236.             m_data[i] = *l;

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

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

  239.     }

  240. 

  241.     /* Various explicit constructors */

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

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

  244.     explicit inline constexpr vec_t(T X)

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

  246. 

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

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

  249.     {

  250.         assert(i >= 0);

  251.         assert(i < 2);

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

  253.     }

  254. 

  255.     LOL_COMMON_MEMBER_OPS(x)

  256. 

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

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

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

  260. 

  261.     union

  262.     {

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

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

  265.         struct { T s, t; };

  266. 

  267. #if !_DOXYGEN_SKIP_ME

  268.         vec_t<T,2,000> const xx, rr, ss;

  269.         vec_t<T,2,001> const xy, rg, st;

  270.         vec_t<T,2,010> const yx, gr, ts;

  271.         vec_t<T,2,011> const yy, gg, tt;

  272. 

  273.         vec_t<T,3,0000> const xxx, rrr, sss;

  274.         vec_t<T,3,0001> const xxy, rrg, sst;

  275.         vec_t<T,3,0010> const xyx, rgr, sts;

  276.         vec_t<T,3,0011> const xyy, rgg, stt;

  277.         vec_t<T,3,0100> const yxx, grr, tss;

  278.         vec_t<T,3,0101> const yxy, grg, tst;

  279.         vec_t<T,3,0110> const yyx, ggr, tts;

  280.         vec_t<T,3,0111> const yyy, ggg, ttt;

  281. 

  282.         vec_t<T,4,00000> const xxxx, rrrr, ssss;

  283.         vec_t<T,4,00001> const xxxy, rrrg, ssst;

  284.         vec_t<T,4,00010> const xxyx, rrgr, ssts;

  285.         vec_t<T,4,00011> const xxyy, rrgg, sstt;

  286.         vec_t<T,4,00100> const xyxx, rgrr, stss;

  287.         vec_t<T,4,00101> const xyxy, rgrg, stst;

  288.         vec_t<T,4,00110> const xyyx, rggr, stts;

  289.         vec_t<T,4,00111> const xyyy, rggg, sttt;

  290.         vec_t<T,4,01000> const yxxx, grrr, tsss;

  291.         vec_t<T,4,01001> const yxxy, grrg, tsst;

  292.         vec_t<T,4,01010> const yxyx, grgr, tsts;

  293.         vec_t<T,4,01011> const yxyy, grgg, tstt;

  294.         vec_t<T,4,01100> const yyxx, ggrr, ttss;

  295.         vec_t<T,4,01101> const yyxy, ggrg, ttst;

  296.         vec_t<T,4,01110> const yyyx, gggr, ttts;

  297.         vec_t<T,4,01111> const yyyy, gggg, tttt;

  298. #endif

  299. 

  300.         T m_data[count];

  301.     };

  302. };

  303. 

  304. /*

  305.  * 3-element vectors

  306.  */

  307. 

  308. template <typename T>

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

  310.   : public swizzle_ops::base<T>

  311. {

  312.     static int const count = 3;

  313.     typedef T scalar_element;

  314.     typedef T element;

  315.     typedef vec_t<T,3> type;

  316. 

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

  318.     inline constexpr vec_t() = default;

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

  320.     inline ~vec_t() = default;

  321. 

  322.     /* Implicit constructor for swizzling */

  323.     template<int SWIZZLE>

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

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

  326. 

  327.     /* Explicit constructor for type conversion */

  328.     template<typename U, int SWIZZLE>

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

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

  331. 

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

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

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

  335.     {

  336.         auto l = list.begin();

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

  338.             m_data[i] = *l;

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

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

  341.     }

  342. 

  343.     /* Various explicit constructors */

  344.     explicit inline constexpr vec_t(T X)

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

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

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

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

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

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

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

  352. 

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

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

  355.     {

  356.         assert(i >= 0);

  357.         assert(i < 3);

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

  359.     }

  360. 

  361.     LOL_COMMON_MEMBER_OPS(x)

  362. 

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

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

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

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

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

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

  369. 

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

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

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

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

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

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

  376. 

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

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

  379.     {

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

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

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

  383.     }

  384. 

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

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

  387.     {

  388.         using std::fabs;

  389. 

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

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

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

  393.     }

  394. 

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

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

  397.     {

  398.         return normalize(orthogonal(a));

  399.     }

  400. 

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

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

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

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

  405. 

  406.     union

  407.     {

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

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

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

  411. 

  412. #if !_DOXYGEN_SKIP_ME

  413.         vec_t<T,2,000> const xx, rr, ss;

  414.         vec_t<T,2,001> const xy, rg, st;

  415.         vec_t<T,2,002> const xz, rb, sp;

  416.         vec_t<T,2,010> const yx, gr, ts;

  417.         vec_t<T,2,011> const yy, gg, tt;

  418.         vec_t<T,2,012> const yz, gb, tp;

  419.         vec_t<T,2,020> const zx, br, ps;

  420.         vec_t<T,2,021> const zy, bg, pt;

  421.         vec_t<T,2,022> const zz, bb, pp;

  422. 

  423.         vec_t<T,3,0000> const xxx, rrr, sss;

  424.         vec_t<T,3,0001> const xxy, rrg, sst;

  425.         vec_t<T,3,0002> const xxz, rrb, ssp;

  426.         vec_t<T,3,0010> const xyx, rgr, sts;

  427.         vec_t<T,3,0011> const xyy, rgg, stt;

  428.         vec_t<T,3,0012> const xyz, rgb, stp;

  429.         vec_t<T,3,0020> const xzx, rbr, sps;

  430.         vec_t<T,3,0021> const xzy, rbg, spt;

  431.         vec_t<T,3,0022> const xzz, rbb, spp;

  432.         vec_t<T,3,0100> const yxx, grr, tss;

  433.         vec_t<T,3,0101> const yxy, grg, tst;

  434.         vec_t<T,3,0102> const yxz, grb, tsp;

  435.         vec_t<T,3,0110> const yyx, ggr, tts;

  436.         vec_t<T,3,0111> const yyy, ggg, ttt;

  437.         vec_t<T,3,0112> const yyz, ggb, ttp;

  438.         vec_t<T,3,0120> const yzx, gbr, tps;

  439.         vec_t<T,3,0121> const yzy, gbg, tpt;

  440.         vec_t<T,3,0122> const yzz, gbb, tpp;

  441.         vec_t<T,3,0200> const zxx, brr, pss;

  442.         vec_t<T,3,0201> const zxy, brg, pst;

  443.         vec_t<T,3,0202> const zxz, brb, psp;

  444.         vec_t<T,3,0210> const zyx, bgr, pts;

  445.         vec_t<T,3,0211> const zyy, bgg, ptt;

  446.         vec_t<T,3,0212> const zyz, bgb, ptp;

  447.         vec_t<T,3,0220> const zzx, bbr, pps;

  448.         vec_t<T,3,0221> const zzy, bbg, ppt;

  449.         vec_t<T,3,0222> const zzz, bbb, ppp;

  450. 

  451.         vec_t<T,4,00000> const xxxx, rrrr, ssss;

  452.         vec_t<T,4,00001> const xxxy, rrrg, ssst;

  453.         vec_t<T,4,00002> const xxxz, rrrb, sssp;

  454.         vec_t<T,4,00010> const xxyx, rrgr, ssts;

  455.         vec_t<T,4,00011> const xxyy, rrgg, sstt;

  456.         vec_t<T,4,00012> const xxyz, rrgb, sstp;

  457.         vec_t<T,4,00020> const xxzx, rrbr, ssps;

  458.         vec_t<T,4,00021> const xxzy, rrbg, sspt;

  459.         vec_t<T,4,00022> const xxzz, rrbb, sspp;

  460.         vec_t<T,4,00100> const xyxx, rgrr, stss;

  461.         vec_t<T,4,00101> const xyxy, rgrg, stst;

  462.         vec_t<T,4,00102> const xyxz, rgrb, stsp;

  463.         vec_t<T,4,00110> const xyyx, rggr, stts;

  464.         vec_t<T,4,00111> const xyyy, rggg, sttt;

  465.         vec_t<T,4,00112> const xyyz, rggb, sttp;

  466.         vec_t<T,4,00120> const xyzx, rgbr, stps;

  467.         vec_t<T,4,00121> const xyzy, rgbg, stpt;

  468.         vec_t<T,4,00122> const xyzz, rgbb, stpp;

  469.         vec_t<T,4,00200> const xzxx, rbrr, spss;

  470.         vec_t<T,4,00201> const xzxy, rbrg, spst;

  471.         vec_t<T,4,00202> const xzxz, rbrb, spsp;

  472.         vec_t<T,4,00210> const xzyx, rbgr, spts;

  473.         vec_t<T,4,00211> const xzyy, rbgg, sptt;

  474.         vec_t<T,4,00212> const xzyz, rbgb, sptp;

  475.         vec_t<T,4,00220> const xzzx, rbbr, spps;

  476.         vec_t<T,4,00221> const xzzy, rbbg, sppt;

  477.         vec_t<T,4,00222> const xzzz, rbbb, sppp;

  478.         vec_t<T,4,01000> const yxxx, grrr, tsss;

  479.         vec_t<T,4,01001> const yxxy, grrg, tsst;

  480.         vec_t<T,4,01002> const yxxz, grrb, tssp;

  481.         vec_t<T,4,01010> const yxyx, grgr, tsts;

  482.         vec_t<T,4,01011> const yxyy, grgg, tstt;

  483.         vec_t<T,4,01012> const yxyz, grgb, tstp;

  484.         vec_t<T,4,01020> const yxzx, grbr, tsps;

  485.         vec_t<T,4,01021> const yxzy, grbg, tspt;

  486.         vec_t<T,4,01022> const yxzz, grbb, tspp;

  487.         vec_t<T,4,01100> const yyxx, ggrr, ttss;

  488.         vec_t<T,4,01101> const yyxy, ggrg, ttst;

  489.         vec_t<T,4,01102> const yyxz, ggrb, ttsp;

  490.         vec_t<T,4,01110> const yyyx, gggr, ttts;

  491.         vec_t<T,4,01111> const yyyy, gggg, tttt;

  492.         vec_t<T,4,01112> const yyyz, gggb, tttp;

  493.         vec_t<T,4,01120> const yyzx, ggbr, ttps;

  494.         vec_t<T,4,01121> const yyzy, ggbg, ttpt;

  495.         vec_t<T,4,01122> const yyzz, ggbb, ttpp;

  496.         vec_t<T,4,01200> const yzxx, gbrr, tpss;

  497.         vec_t<T,4,01201> const yzxy, gbrg, tpst;

  498.         vec_t<T,4,01202> const yzxz, gbrb, tpsp;

  499.         vec_t<T,4,01210> const yzyx, gbgr, tpts;

  500.         vec_t<T,4,01211> const yzyy, gbgg, tptt;

  501.         vec_t<T,4,01212> const yzyz, gbgb, tptp;

  502.         vec_t<T,4,01220> const yzzx, gbbr, tpps;

  503.         vec_t<T,4,01221> const yzzy, gbbg, tppt;

  504.         vec_t<T,4,01222> const yzzz, gbbb, tppp;

  505.         vec_t<T,4,02000> const zxxx, brrr, psss;

  506.         vec_t<T,4,02001> const zxxy, brrg, psst;

  507.         vec_t<T,4,02002> const zxxz, brrb, pssp;

  508.         vec_t<T,4,02010> const zxyx, brgr, psts;

  509.         vec_t<T,4,02011> const zxyy, brgg, pstt;

  510.         vec_t<T,4,02012> const zxyz, brgb, pstp;

  511.         vec_t<T,4,02020> const zxzx, brbr, psps;

  512.         vec_t<T,4,02021> const zxzy, brbg, pspt;

  513.         vec_t<T,4,02022> const zxzz, brbb, pspp;

  514.         vec_t<T,4,02100> const zyxx, bgrr, ptss;

  515.         vec_t<T,4,02101> const zyxy, bgrg, ptst;

  516.         vec_t<T,4,02102> const zyxz, bgrb, ptsp;

  517.         vec_t<T,4,02110> const zyyx, bggr, ptts;

  518.         vec_t<T,4,02111> const zyyy, bggg, pttt;

  519.         vec_t<T,4,02112> const zyyz, bggb, pttp;

  520.         vec_t<T,4,02120> const zyzx, bgbr, ptps;

  521.         vec_t<T,4,02121> const zyzy, bgbg, ptpt;

  522.         vec_t<T,4,02122> const zyzz, bgbb, ptpp;

  523.         vec_t<T,4,02200> const zzxx, bbrr, ppss;

  524.         vec_t<T,4,02201> const zzxy, bbrg, ppst;

  525.         vec_t<T,4,02202> const zzxz, bbrb, ppsp;

  526.         vec_t<T,4,02210> const zzyx, bbgr, ppts;

  527.         vec_t<T,4,02211> const zzyy, bbgg, pptt;

  528.         vec_t<T,4,02212> const zzyz, bbgb, pptp;

  529.         vec_t<T,4,02220> const zzzx, bbbr, ppps;

  530.         vec_t<T,4,02221> const zzzy, bbbg, pppt;

  531.         vec_t<T,4,02222> const zzzz, bbbb, pppp;

  532. #endif

  533. 

  534.         T m_data[count];

  535.     };

  536. };

  537. 

  538. /*

  539.  * 4-element vectors

  540.  */

  541. 

  542. template <typename T>

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

  544.   : public swizzle_ops::base<T>

  545. {

  546.     static int const count = 4;

  547.     typedef T scalar_element;

  548.     typedef T element;

  549.     typedef vec_t<T,4> type;

  550. 

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

  552.     inline constexpr vec_t() = default;

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

  554.     inline ~vec_t() = default;

  555. 

  556.     /* Implicit constructor for swizzling */

  557.     template<int SWIZZLE>

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

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

  560. 

  561.     /* Explicit constructor for type conversion */

  562.     template<typename U, int SWIZZLE>

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

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

  565. 

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

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

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

  569.     {

  570.         auto l = list.begin();

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

  572.             m_data[i] = *l;

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

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

  575.     }

  576. 

  577.     /* Various explicit constructors */

  578.     explicit inline constexpr vec_t(T X)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  594. 

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

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

  597.     {

  598.         assert(i >= 0);

  599.         assert(i < 4);

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

  601.     }

  602. 

  603.     LOL_COMMON_MEMBER_OPS(x)

  604. 

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

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

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

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

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

  610. 

  611.     union

  612.     {

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

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

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

  616. 

  617. #if !_DOXYGEN_SKIP_ME

  618.         vec_t<T,2,000> const xx, rr, ss;

  619.         vec_t<T,2,001> const xy, rg, st;

  620.         vec_t<T,2,002> const xz, rb, sp;

  621.         vec_t<T,2,003> const xw, ra, sq;

  622.         vec_t<T,2,010> const yx, gr, ts;

  623.         vec_t<T,2,011> const yy, gg, tt;

  624.         vec_t<T,2,012> const yz, gb, tp;

  625.         vec_t<T,2,013> const yw, ga, tq;

  626.         vec_t<T,2,020> const zx, br, ps;

  627.         vec_t<T,2,021> const zy, bg, pt;

  628.         vec_t<T,2,022> const zz, bb, pp;

  629.         vec_t<T,2,023> const zw, ba, pq;

  630.         vec_t<T,2,030> const wx, ar, qs;

  631.         vec_t<T,2,031> const wy, ag, qt;

  632.         vec_t<T,2,032> const wz, ab, qp;

  633.         vec_t<T,2,033> const ww, aa, qq;

  634. 

  635.         vec_t<T,3,0000> const xxx, rrr, sss;

  636.         vec_t<T,3,0001> const xxy, rrg, sst;

  637.         vec_t<T,3,0002> const xxz, rrb, ssp;

  638.         vec_t<T,3,0003> const xxw, rra, ssq;

  639.         vec_t<T,3,0010> const xyx, rgr, sts;

  640.         vec_t<T,3,0011> const xyy, rgg, stt;

  641.         vec_t<T,3,0012> const xyz, rgb, stp;

  642.         vec_t<T,3,0013> const xyw, rga, stq;

  643.         vec_t<T,3,0020> const xzx, rbr, sps;

  644.         vec_t<T,3,0021> const xzy, rbg, spt;

  645.         vec_t<T,3,0022> const xzz, rbb, spp;

  646.         vec_t<T,3,0023> const xzw, rba, spq;

  647.         vec_t<T,3,0030> const xwx, rar, sqs;

  648.         vec_t<T,3,0031> const xwy, rag, sqt;

  649.         vec_t<T,3,0032> const xwz, rab, sqp;

  650.         vec_t<T,3,0033> const xww, raa, sqq;

  651.         vec_t<T,3,0100> const yxx, grr, tss;

  652.         vec_t<T,3,0101> const yxy, grg, tst;

  653.         vec_t<T,3,0102> const yxz, grb, tsp;

  654.         vec_t<T,3,0103> const yxw, gra, tsq;

  655.         vec_t<T,3,0110> const yyx, ggr, tts;

  656.         vec_t<T,3,0111> const yyy, ggg, ttt;

  657.         vec_t<T,3,0112> const yyz, ggb, ttp;

  658.         vec_t<T,3,0113> const yyw, gga, ttq;

  659.         vec_t<T,3,0120> const yzx, gbr, tps;

  660.         vec_t<T,3,0121> const yzy, gbg, tpt;

  661.         vec_t<T,3,0122> const yzz, gbb, tpp;

  662.         vec_t<T,3,0123> const yzw, gba, tpq;

  663.         vec_t<T,3,0130> const ywx, gar, tqs;

  664.         vec_t<T,3,0131> const ywy, gag, tqt;

  665.         vec_t<T,3,0132> const ywz, gab, tqp;

  666.         vec_t<T,3,0133> const yww, gaa, tqq;

  667.         vec_t<T,3,0200> const zxx, brr, pss;

  668.         vec_t<T,3,0201> const zxy, brg, pst;

  669.         vec_t<T,3,0202> const zxz, brb, psp;

  670.         vec_t<T,3,0203> const zxw, bra, psq;

  671.         vec_t<T,3,0210> const zyx, bgr, pts;

  672.         vec_t<T,3,0211> const zyy, bgg, ptt;

  673.         vec_t<T,3,0212> const zyz, bgb, ptp;

  674.         vec_t<T,3,0213> const zyw, bga, ptq;

  675.         vec_t<T,3,0220> const zzx, bbr, pps;

  676.         vec_t<T,3,0221> const zzy, bbg, ppt;

  677.         vec_t<T,3,0222> const zzz, bbb, ppp;

  678.         vec_t<T,3,0223> const zzw, bba, ppq;

  679.         vec_t<T,3,0230> const zwx, bar, pqs;

  680.         vec_t<T,3,0231> const zwy, bag, pqt;

  681.         vec_t<T,3,0232> const zwz, bab, pqp;

  682.         vec_t<T,3,0233> const zww, baa, pqq;

  683.         vec_t<T,3,0300> const wxx, arr, qss;

  684.         vec_t<T,3,0301> const wxy, arg, qst;

  685.         vec_t<T,3,0302> const wxz, arb, qsp;

  686.         vec_t<T,3,0303> const wxw, ara, qsq;

  687.         vec_t<T,3,0310> const wyx, agr, qts;

  688.         vec_t<T,3,0311> const wyy, agg, qtt;

  689.         vec_t<T,3,0312> const wyz, agb, qtp;

  690.         vec_t<T,3,0313> const wyw, aga, qtq;

  691.         vec_t<T,3,0320> const wzx, abr, qps;

  692.         vec_t<T,3,0321> const wzy, abg, qpt;

  693.         vec_t<T,3,0322> const wzz, abb, qpp;

  694.         vec_t<T,3,0323> const wzw, aba, qpq;

  695.         vec_t<T,3,0330> const wwx, aar, qqs;

  696.         vec_t<T,3,0331> const wwy, aag, qqt;

  697.         vec_t<T,3,0332> const wwz, aab, qqp;

  698.         vec_t<T,3,0333> const www, aaa, qqq;

  699. 

  700.         vec_t<T,4,00000> const xxxx, rrrr, ssss;

  701.         vec_t<T,4,00001> const xxxy, rrrg, ssst;

  702.         vec_t<T,4,00002> const xxxz, rrrb, sssp;

  703.         vec_t<T,4,00003> const xxxw, rrra, sssq;

  704.         vec_t<T,4,00010> const xxyx, rrgr, ssts;

  705.         vec_t<T,4,00011> const xxyy, rrgg, sstt;

  706.         vec_t<T,4,00012> const xxyz, rrgb, sstp;

  707.         vec_t<T,4,00013> const xxyw, rrga, sstq;

  708.         vec_t<T,4,00020> const xxzx, rrbr, ssps;

  709.         vec_t<T,4,00021> const xxzy, rrbg, sspt;

  710.         vec_t<T,4,00022> const xxzz, rrbb, sspp;

  711.         vec_t<T,4,00023> const xxzw, rrba, sspq;

  712.         vec_t<T,4,00030> const xxwx, rrar, ssqs;

  713.         vec_t<T,4,00031> const xxwy, rrag, ssqt;

  714.         vec_t<T,4,00032> const xxwz, rrab, ssqp;

  715.         vec_t<T,4,00033> const xxww, rraa, ssqq;

  716.         vec_t<T,4,00100> const xyxx, rgrr, stss;

  717.         vec_t<T,4,00101> const xyxy, rgrg, stst;

  718.         vec_t<T,4,00102> const xyxz, rgrb, stsp;

  719.         vec_t<T,4,00103> const xyxw, rgra, stsq;

  720.         vec_t<T,4,00110> const xyyx, rggr, stts;

  721.         vec_t<T,4,00111> const xyyy, rggg, sttt;

  722.         vec_t<T,4,00112> const xyyz, rggb, sttp;

  723.         vec_t<T,4,00113> const xyyw, rgga, sttq;

  724.         vec_t<T,4,00120> const xyzx, rgbr, stps;

  725.         vec_t<T,4,00121> const xyzy, rgbg, stpt;

  726.         vec_t<T,4,00122> const xyzz, rgbb, stpp;

  727.         vec_t<T,4,00123> const xyzw, rgba, stpq;

  728.         vec_t<T,4,00130> const xywx, rgar, stqs;

  729.         vec_t<T,4,00131> const xywy, rgag, stqt;

  730.         vec_t<T,4,00132> const xywz, rgab, stqp;

  731.         vec_t<T,4,00133> const xyww, rgaa, stqq;

  732.         vec_t<T,4,00200> const xzxx, rbrr, spss;

  733.         vec_t<T,4,00201> const xzxy, rbrg, spst;

  734.         vec_t<T,4,00202> const xzxz, rbrb, spsp;

  735.         vec_t<T,4,00203> const xzxw, rbra, spsq;

  736.         vec_t<T,4,00210> const xzyx, rbgr, spts;

  737.         vec_t<T,4,00211> const xzyy, rbgg, sptt;

  738.         vec_t<T,4,00212> const xzyz, rbgb, sptp;

  739.         vec_t<T,4,00213> const xzyw, rbga, sptq;

  740.         vec_t<T,4,00220> const xzzx, rbbr, spps;

  741.         vec_t<T,4,00221> const xzzy, rbbg, sppt;

  742.         vec_t<T,4,00222> const xzzz, rbbb, sppp;

  743.         vec_t<T,4,00223> const xzzw, rbba, sppq;

  744.         vec_t<T,4,00230> const xzwx, rbar, spqs;

  745.         vec_t<T,4,00231> const xzwy, rbag, spqt;

  746.         vec_t<T,4,00232> const xzwz, rbab, spqp;

  747.         vec_t<T,4,00233> const xzww, rbaa, spqq;

  748.         vec_t<T,4,00300> const xwxx, rarr, sqss;

  749.         vec_t<T,4,00301> const xwxy, rarg, sqst;

  750.         vec_t<T,4,00302> const xwxz, rarb, sqsp;

  751.         vec_t<T,4,00303> const xwxw, rara, sqsq;

  752.         vec_t<T,4,00310> const xwyx, ragr, sqts;

  753.         vec_t<T,4,00311> const xwyy, ragg, sqtt;

  754.         vec_t<T,4,00312> const xwyz, ragb, sqtp;

  755.         vec_t<T,4,00313> const xwyw, raga, sqtq;

  756.         vec_t<T,4,00320> const xwzx, rabr, sqps;

  757.         vec_t<T,4,00321> const xwzy, rabg, sqpt;

  758.         vec_t<T,4,00322> const xwzz, rabb, sqpp;

  759.         vec_t<T,4,00323> const xwzw, raba, sqpq;

  760.         vec_t<T,4,00330> const xwwx, raar, sqqs;

  761.         vec_t<T,4,00331> const xwwy, raag, sqqt;

  762.         vec_t<T,4,00332> const xwwz, raab, sqqp;

  763.         vec_t<T,4,00333> const xwww, raaa, sqqq;

  764.         vec_t<T,4,01000> const yxxx, grrr, tsss;

  765.         vec_t<T,4,01001> const yxxy, grrg, tsst;

  766.         vec_t<T,4,01002> const yxxz, grrb, tssp;

  767.         vec_t<T,4,01003> const yxxw, grra, tssq;

  768.         vec_t<T,4,01010> const yxyx, grgr, tsts;

  769.         vec_t<T,4,01011> const yxyy, grgg, tstt;

  770.         vec_t<T,4,01012> const yxyz, grgb, tstp;

  771.         vec_t<T,4,01013> const yxyw, grga, tstq;

  772.         vec_t<T,4,01020> const yxzx, grbr, tsps;

  773.         vec_t<T,4,01021> const yxzy, grbg, tspt;

  774.         vec_t<T,4,01022> const yxzz, grbb, tspp;

  775.         vec_t<T,4,01023> const yxzw, grba, tspq;

  776.         vec_t<T,4,01030> const yxwx, grar, tsqs;

  777.         vec_t<T,4,01031> const yxwy, grag, tsqt;

  778.         vec_t<T,4,01032> const yxwz, grab, tsqp;

  779.         vec_t<T,4,01033> const yxww, graa, tsqq;

  780.         vec_t<T,4,01100> const yyxx, ggrr, ttss;

  781.         vec_t<T,4,01101> const yyxy, ggrg, ttst;

  782.         vec_t<T,4,01102> const yyxz, ggrb, ttsp;

  783.         vec_t<T,4,01103> const yyxw, ggra, ttsq;

  784.         vec_t<T,4,01110> const yyyx, gggr, ttts;

  785.         vec_t<T,4,01111> const yyyy, gggg, tttt;

  786.         vec_t<T,4,01112> const yyyz, gggb, tttp;

  787.         vec_t<T,4,01113> const yyyw, ggga, tttq;

  788.         vec_t<T,4,01120> const yyzx, ggbr, ttps;

  789.         vec_t<T,4,01121> const yyzy, ggbg, ttpt;

  790.         vec_t<T,4,01122> const yyzz, ggbb, ttpp;

  791.         vec_t<T,4,01123> const yyzw, ggba, ttpq;

  792.         vec_t<T,4,01130> const yywx, ggar, ttqs;

  793.         vec_t<T,4,01131> const yywy, ggag, ttqt;

  794.         vec_t<T,4,01132> const yywz, ggab, ttqp;

  795.         vec_t<T,4,01133> const yyww, ggaa, ttqq;

  796.         vec_t<T,4,01200> const yzxx, gbrr, tpss;

  797.         vec_t<T,4,01201> const yzxy, gbrg, tpst;

  798.         vec_t<T,4,01202> const yzxz, gbrb, tpsp;

  799.         vec_t<T,4,01203> const yzxw, gbra, tpsq;

  800.         vec_t<T,4,01210> const yzyx, gbgr, tpts;

  801.         vec_t<T,4,01211> const yzyy, gbgg, tptt;

  802.         vec_t<T,4,01212> const yzyz, gbgb, tptp;

  803.         vec_t<T,4,01213> const yzyw, gbga, tptq;

  804.         vec_t<T,4,01220> const yzzx, gbbr, tpps;

  805.         vec_t<T,4,01221> const yzzy, gbbg, tppt;

  806.         vec_t<T,4,01222> const yzzz, gbbb, tppp;

  807.         vec_t<T,4,01223> const yzzw, gbba, tppq;

  808.         vec_t<T,4,01230> const yzwx, gbar, tpqs;

  809.         vec_t<T,4,01231> const yzwy, gbag, tpqt;

  810.         vec_t<T,4,01232> const yzwz, gbab, tpqp;

  811.         vec_t<T,4,01233> const yzww, gbaa, tpqq;

  812.         vec_t<T,4,01300> const ywxx, garr, tqss;

  813.         vec_t<T,4,01301> const ywxy, garg, tqst;

  814.         vec_t<T,4,01302> const ywxz, garb, tqsp;

  815.         vec_t<T,4,01303> const ywxw, gara, tqsq;

  816.         vec_t<T,4,01310> const ywyx, gagr, tqts;

  817.         vec_t<T,4,01311> const ywyy, gagg, tqtt;

  818.         vec_t<T,4,01312> const ywyz, gagb, tqtp;

  819.         vec_t<T,4,01313> const ywyw, gaga, tqtq;

  820.         vec_t<T,4,01320> const ywzx, gabr, tqps;

  821.         vec_t<T,4,01321> const ywzy, gabg, tqpt;

  822.         vec_t<T,4,01322> const ywzz, gabb, tqpp;

  823.         vec_t<T,4,01323> const ywzw, gaba, tqpq;

  824.         vec_t<T,4,01330> const ywwx, gaar, tqqs;

  825.         vec_t<T,4,01331> const ywwy, gaag, tqqt;

  826.         vec_t<T,4,01332> const ywwz, gaab, tqqp;

  827.         vec_t<T,4,01333> const ywww, gaaa, tqqq;

  828.         vec_t<T,4,02000> const zxxx, brrr, psss;

  829.         vec_t<T,4,02001> const zxxy, brrg, psst;

  830.         vec_t<T,4,02002> const zxxz, brrb, pssp;

  831.         vec_t<T,4,02003> const zxxw, brra, pssq;

  832.         vec_t<T,4,02010> const zxyx, brgr, psts;

  833.         vec_t<T,4,02011> const zxyy, brgg, pstt;

  834.         vec_t<T,4,02012> const zxyz, brgb, pstp;

  835.         vec_t<T,4,02013> const zxyw, brga, pstq;

  836.         vec_t<T,4,02020> const zxzx, brbr, psps;

  837.         vec_t<T,4,02021> const zxzy, brbg, pspt;

  838.         vec_t<T,4,02022> const zxzz, brbb, pspp;

  839.         vec_t<T,4,02023> const zxzw, brba, pspq;

  840.         vec_t<T,4,02030> const zxwx, brar, psqs;

  841.         vec_t<T,4,02031> const zxwy, brag, psqt;

  842.         vec_t<T,4,02032> const zxwz, brab, psqp;

  843.         vec_t<T,4,02033> const zxww, braa, psqq;

  844.         vec_t<T,4,02100> const zyxx, bgrr, ptss;

  845.         vec_t<T,4,02101> const zyxy, bgrg, ptst;

  846.         vec_t<T,4,02102> const zyxz, bgrb, ptsp;

  847.         vec_t<T,4,02103> const zyxw, bgra, ptsq;

  848.         vec_t<T,4,02110> const zyyx, bggr, ptts;

  849.         vec_t<T,4,02111> const zyyy, bggg, pttt;

  850.         vec_t<T,4,02112> const zyyz, bggb, pttp;

  851.         vec_t<T,4,02113> const zyyw, bgga, pttq;

  852.         vec_t<T,4,02120> const zyzx, bgbr, ptps;

  853.         vec_t<T,4,02121> const zyzy, bgbg, ptpt;

  854.         vec_t<T,4,02122> const zyzz, bgbb, ptpp;

  855.         vec_t<T,4,02123> const zyzw, bgba, ptpq;

  856.         vec_t<T,4,02130> const zywx, bgar, ptqs;

  857.         vec_t<T,4,02131> const zywy, bgag, ptqt;

  858.         vec_t<T,4,02132> const zywz, bgab, ptqp;

  859.         vec_t<T,4,02133> const zyww, bgaa, ptqq;

  860.         vec_t<T,4,02200> const zzxx, bbrr, ppss;

  861.         vec_t<T,4,02201> const zzxy, bbrg, ppst;

  862.         vec_t<T,4,02202> const zzxz, bbrb, ppsp;

  863.         vec_t<T,4,02203> const zzxw, bbra, ppsq;

  864.         vec_t<T,4,02210> const zzyx, bbgr, ppts;

  865.         vec_t<T,4,02211> const zzyy, bbgg, pptt;

  866.         vec_t<T,4,02212> const zzyz, bbgb, pptp;

  867.         vec_t<T,4,02213> const zzyw, bbga, pptq;

  868.         vec_t<T,4,02220> const zzzx, bbbr, ppps;

  869.         vec_t<T,4,02221> const zzzy, bbbg, pppt;

  870.         vec_t<T,4,02222> const zzzz, bbbb, pppp;

  871.         vec_t<T,4,02223> const zzzw, bbba, pppq;

  872.         vec_t<T,4,02230> const zzwx, bbar, ppqs;

  873.         vec_t<T,4,02231> const zzwy, bbag, ppqt;

  874.         vec_t<T,4,02232> const zzwz, bbab, ppqp;

  875.         vec_t<T,4,02233> const zzww, bbaa, ppqq;

  876.         vec_t<T,4,02300> const zwxx, barr, pqss;

  877.         vec_t<T,4,02301> const zwxy, barg, pqst;

  878.         vec_t<T,4,02302> const zwxz, barb, pqsp;

  879.         vec_t<T,4,02303> const zwxw, bara, pqsq;

  880.         vec_t<T,4,02310> const zwyx, bagr, pqts;

  881.         vec_t<T,4,02311> const zwyy, bagg, pqtt;

  882.         vec_t<T,4,02312> const zwyz, bagb, pqtp;

  883.         vec_t<T,4,02313> const zwyw, baga, pqtq;

  884.         vec_t<T,4,02320> const zwzx, babr, pqps;

  885.         vec_t<T,4,02321> const zwzy, babg, pqpt;

  886.         vec_t<T,4,02322> const zwzz, babb, pqpp;

  887.         vec_t<T,4,02323> const zwzw, baba, pqpq;

  888.         vec_t<T,4,02330> const zwwx, baar, pqqs;

  889.         vec_t<T,4,02331> const zwwy, baag, pqqt;

  890.         vec_t<T,4,02332> const zwwz, baab, pqqp;

  891.         vec_t<T,4,02333> const zwww, baaa, pqqq;

  892.         vec_t<T,4,03000> const wxxx, arrr, qsss;

  893.         vec_t<T,4,03001> const wxxy, arrg, qsst;

  894.         vec_t<T,4,03002> const wxxz, arrb, qssp;

  895.         vec_t<T,4,03003> const wxxw, arra, qssq;

  896.         vec_t<T,4,03010> const wxyx, argr, qsts;

  897.         vec_t<T,4,03011> const wxyy, argg, qstt;

  898.         vec_t<T,4,03012> const wxyz, argb, qstp;

  899.         vec_t<T,4,03013> const wxyw, arga, qstq;

  900.         vec_t<T,4,03020> const wxzx, arbr, qsps;

  901.         vec_t<T,4,03021> const wxzy, arbg, qspt;

  902.         vec_t<T,4,03022> const wxzz, arbb, qspp;

  903.         vec_t<T,4,03023> const wxzw, arba, qspq;

  904.         vec_t<T,4,03030> const wxwx, arar, qsqs;

  905.         vec_t<T,4,03031> const wxwy, arag, qsqt;

  906.         vec_t<T,4,03032> const wxwz, arab, qsqp;

  907.         vec_t<T,4,03033> const wxww, araa, qsqq;

  908.         vec_t<T,4,03100> const wyxx, agrr, qtss;

  909.         vec_t<T,4,03101> const wyxy, agrg, qtst;

  910.         vec_t<T,4,03102> const wyxz, agrb, qtsp;

  911.         vec_t<T,4,03103> const wyxw, agra, qtsq;

  912.         vec_t<T,4,03110> const wyyx, aggr, qtts;

  913.         vec_t<T,4,03111> const wyyy, aggg, qttt;

  914.         vec_t<T,4,03112> const wyyz, aggb, qttp;

  915.         vec_t<T,4,03113> const wyyw, agga, qttq;

  916.         vec_t<T,4,03120> const wyzx, agbr, qtps;

  917.         vec_t<T,4,03121> const wyzy, agbg, qtpt;

  918.         vec_t<T,4,03122> const wyzz, agbb, qtpp;

  919.         vec_t<T,4,03123> const wyzw, agba, qtpq;

  920.         vec_t<T,4,03130> const wywx, agar, qtqs;

  921.         vec_t<T,4,03131> const wywy, agag, qtqt;

  922.         vec_t<T,4,03132> const wywz, agab, qtqp;

  923.         vec_t<T,4,03133> const wyww, agaa, qtqq;

  924.         vec_t<T,4,03200> const wzxx, abrr, qpss;

  925.         vec_t<T,4,03201> const wzxy, abrg, qpst;

  926.         vec_t<T,4,03202> const wzxz, abrb, qpsp;

  927.         vec_t<T,4,03203> const wzxw, abra, qpsq;

  928.         vec_t<T,4,03210> const wzyx, abgr, qpts;

  929.         vec_t<T,4,03211> const wzyy, abgg, qptt;

  930.         vec_t<T,4,03212> const wzyz, abgb, qptp;

  931.         vec_t<T,4,03213> const wzyw, abga, qptq;

  932.         vec_t<T,4,03220> const wzzx, abbr, qpps;

  933.         vec_t<T,4,03221> const wzzy, abbg, qppt;

  934.         vec_t<T,4,03222> const wzzz, abbb, qppp;

  935.         vec_t<T,4,03223> const wzzw, abba, qppq;

  936.         vec_t<T,4,03230> const wzwx, abar, qpqs;

  937.         vec_t<T,4,03231> const wzwy, abag, qpqt;

  938.         vec_t<T,4,03232> const wzwz, abab, qpqp;

  939.         vec_t<T,4,03233> const wzww, abaa, qpqq;

  940.         vec_t<T,4,03300> const wwxx, aarr, qqss;

  941.         vec_t<T,4,03301> const wwxy, aarg, qqst;

  942.         vec_t<T,4,03302> const wwxz, aarb, qqsp;

  943.         vec_t<T,4,03303> const wwxw, aara, qqsq;

  944.         vec_t<T,4,03310> const wwyx, aagr, qqts;

  945.         vec_t<T,4,03311> const wwyy, aagg, qqtt;

  946.         vec_t<T,4,03312> const wwyz, aagb, qqtp;

  947.         vec_t<T,4,03313> const wwyw, aaga, qqtq;

  948.         vec_t<T,4,03320> const wwzx, aabr, qqps;

  949.         vec_t<T,4,03321> const wwzy, aabg, qqpt;

  950.         vec_t<T,4,03322> const wwzz, aabb, qqpp;

  951.         vec_t<T,4,03323> const wwzw, aaba, qqpq;

  952.         vec_t<T,4,03330> const wwwx, aaar, qqqs;

  953.         vec_t<T,4,03331> const wwwy, aaag, qqqt;

  954.         vec_t<T,4,03332> const wwwz, aaab, qqqp;

  955.         vec_t<T,4,03333> const wwww, aaaa, qqqq;

  956. #endif

  957. 

  958.         T m_data[count];

  959.     };

  960. };

  961. 

  962. /*

  963.  * stdstream method implementation

  964.  */

  965. 

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

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

  968. {

  969.     stream << '(';

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

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

  972.     return stream;

  973. }

  974. 

  975. /*

  976.  * vec_t *(scalar, vec_t)

  977.  */

  978. 

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

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

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

  982. {

  983.     vec_t<T,N> ret;

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

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

  986.     return ret;

  987. }

  988. 

  989. /*

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

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

  992.  */

  993. 

  994. #define LOL_SWIZZLE_V_VV_FUN(fun) \

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

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

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

  998.     { \

  999.         using std::fun; \

  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.         using std::fun; \

  1010.         vec_t<T,N> ret; \

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

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

  1013.         return ret; \

  1014.     } \

  1015.     \

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

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

  1018.     { \

  1019.         using std::fun; \

  1020.         vec_t<T,N> ret; \

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

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

  1023.         return ret; \

  1024.     }

  1025. 

  1026. LOL_SWIZZLE_V_VV_FUN(min)

  1027. LOL_SWIZZLE_V_VV_FUN(max)

  1028. LOL_SWIZZLE_V_VV_FUN(fmod)

  1029. 

  1030. #undef LOL_SWIZZLE_V_VV_FUN

  1031. 

  1032. /*

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

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

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

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

  1037.  */

  1038. 

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

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

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

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

  1043. {

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

  1045. }

  1046. 

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

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

  1049.                                T const &a,

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

  1051. {

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

  1053. }

  1054. 

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

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

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

  1058.                                T const &b)

  1059. {

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

  1061. }

  1062. 

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

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

  1065.                                T const &a,

  1066.                                T const &b)

  1067. {

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

  1069. }

  1070. 

  1071. /*

  1072.  * vec_t mix(vec_t, vec_t, vec_t)

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

  1074.  */

  1075. 

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

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

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

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

  1080. {

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

  1082. }

  1083. 

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

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

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

  1087.                              T const &a)

  1088. {

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

  1090. }

  1091. 

  1092. /*

  1093.  * Some GLSL-like functions.

  1094.  */

  1095. 

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

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

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

  1099. {

  1100.     T ret(0);

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

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

  1103.     return ret;

  1104. }

  1105. 

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

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

  1108. {

  1109.     return dot(a, a);

  1110. }

  1111. 

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

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

  1114. {

  1115.     using std::sqrt;

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

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

  1118. }

  1119. 

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

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

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

  1123.                               T const &s)

  1124. {

  1125.     vec_t<T,N> ret;

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

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

  1128.     return ret;

  1129. }

  1130. 

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

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

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

  1134. {

  1135.     return length(a - b);

  1136. }

  1137. 

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

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

  1140. {

  1141.     vec_t<T,N> ret;

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

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

  1144.     return ret;

  1145. }

  1146. 

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

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

  1149. {

  1150.     vec_t<T,N> ret;

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

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

  1153.     return ret;

  1154. }

  1155. 

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

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

  1158. {

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

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

  1161. }

  1162. 

  1163. // We define fabs() because that’s the C++ std library uses for

  1164. // floating-point numbers, and abs() because GLSL does.

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

  1166. static inline vec_t<T,N> fabs(vec_t<T,N,SWIZZLE> const &a)

  1167. {

  1168.     using std::fabs;

  1169.     vec_t<T,N> ret;

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

  1171.         ret[i] = fabs(a[i]);

  1172.     return ret;

  1173. }

  1174. 

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

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

  1177. {

  1178.     return fabs(a);

  1179. }

  1180. 

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

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

  1183. {

  1184.     vec_t<T,N> ret;

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

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

  1187.     return ret;

  1188. }

  1189. 

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

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

  1192. {

  1193.     vec_t<T, N> ret;

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

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

  1196.     return ret;

  1197. }

  1198. 

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

  1200. template<typename T, int SWIZZLE>

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

  1202. {

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

  1204. 

  1205.     vec_t<T, 2> ret;

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

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

  1208.     return ret;

  1209. }

  1210. 

  1211. template<typename T, int SWIZZLE>

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

  1213. {

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

  1215. 

  1216.     vec_t<T, 3> ret;

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

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

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

  1220.     return ret;

  1221. }

  1222. 

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

  1224. template<typename T, int SWIZZLE>

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

  1226. {

  1227.     vec_t<T, 2> ret;

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

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

  1230.     return ret;

  1231. }

  1232. 

  1233. template<typename T, int SWIZZLE>

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

  1235. {

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

  1237. 

  1238.     vec_t<T, 3> ret;

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

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

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

  1242.     return ret;

  1243. }

  1244. 

  1245. /*

  1246.  * C++11 iterators

  1247.  */

  1248. 

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

  1250. class vec_const_iter

  1251. {

  1252. public:

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

  1254.       : m_vec(vec),

  1255.         m_pos(pos)

  1256.     { }

  1257. 

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

  1259.     {

  1260.         return m_pos != that.m_pos;

  1261.     }

  1262. 

  1263.     template<int S = SWIZZLE>

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

  1265.     operator *() const

  1266.     {

  1267.         return m_vec[m_pos];

  1268.     }

  1269. 

  1270.     template<int S = SWIZZLE>

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

  1272.     operator *() const

  1273.     {

  1274.         return m_vec[m_pos];

  1275.     }

  1276. 

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

  1278.     {

  1279.         ++m_pos;

  1280.         return *this;

  1281.     }

  1282. 

  1283. private:

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

  1285.     int m_pos;

  1286. };

  1287. 

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

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

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

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

  1292. {

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

  1294. }

  1295. 

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

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

  1298. {

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

  1300. }

  1301. 

  1302. /*

  1303.  * Constants

  1304.  */

  1305. 

  1306. template<typename T, int N>

  1307. vec_t<T,N> const vec_t<T,N>::zero = vec_t<T,N>(T(0));

  1308. template<typename T>

  1309. vec_t<T,2> const vec_t<T,2>::zero = vec_t<T,2>(T(0));

  1310. template<typename T>

  1311. vec_t<T,3> const vec_t<T,3>::zero = vec_t<T,3>(T(0));

  1312. template<typename T>

  1313. vec_t<T,4> const vec_t<T,4>::zero = vec_t<T,4>(T(0));

  1314. 

  1315. template<typename T>

  1316. vec_t<T,2> const vec_t<T,2>::axis_x = vec_t<T,2>(T(1), T(0));

  1317. template<typename T>

  1318. vec_t<T,2> const vec_t<T,2>::axis_y = vec_t<T,2>(T(0), T(1));

  1319. 

  1320. template<typename T>

  1321. vec_t<T,3> const vec_t<T,3>::axis_x = vec_t<T,3>(T(1), T(0), T(0));

  1322. template<typename T>

  1323. vec_t<T,3> const vec_t<T,3>::axis_y = vec_t<T,3>(T(0), T(1), T(0));

  1324. template<typename T>

  1325. vec_t<T,3> const vec_t<T,3>::axis_z = vec_t<T,3>(T(0), T(0), T(1));

  1326. 

  1327. template<typename T>

  1328. vec_t<T,4> const vec_t<T,4>::axis_x = vec_t<T,4>(T(1), T(0), T(0), T(0));

  1329. template<typename T>

  1330. vec_t<T,4> const vec_t<T,4>::axis_y = vec_t<T,4>(T(0), T(1), T(0), T(0));

  1331. template<typename T>

  1332. vec_t<T,4> const vec_t<T,4>::axis_z = vec_t<T,4>(T(0), T(0), T(1), T(0));

  1333. template<typename T>

  1334. vec_t<T,4> const vec_t<T,4>::axis_w = vec_t<T,4>(T(0), T(0), T(0), T(1));

  1335. 

  1336. //

  1337. // Generic GLSL-like type names

  1338. //

  1339. 

  1340. #define T_(tleft, tright, suffix) \

  1341.     typedef tleft half tright f16##suffix; \

  1342.     typedef tleft float tright suffix; \

  1343.     typedef tleft double tright d##suffix; \

  1344.     typedef tleft ldouble tright f128##suffix; \

  1345.     typedef tleft int8_t tright i8##suffix; \

  1346.     typedef tleft uint8_t tright u8##suffix; \

  1347.     typedef tleft int16_t tright i16##suffix; \

  1348.     typedef tleft uint16_t tright u16##suffix; \

  1349.     typedef tleft int32_t tright i##suffix; \

  1350.     typedef tleft uint32_t tright u##suffix; \

  1351.     typedef tleft int64_t tright i64##suffix; \

  1352.     typedef tleft uint64_t tright u64##suffix; \

  1353.     typedef tleft real tright r##suffix;

  1354. 

  1355. // Idiotic hack to put "," inside a macro argument

  1356. #define C_ ,

  1357. 

  1358. T_(vec_t<, C_ 2>, vec2)

  1359. T_(vec_t<, C_ 3>, vec3)

  1360. T_(vec_t<, C_ 4>, vec4)

  1361. T_(vec_t<, C_ 5>, vec5)

  1362. T_(vec_t<, C_ 6>, vec6)

  1363. T_(vec_t<, C_ 7>, vec7)

  1364. T_(vec_t<, C_ 8>, vec8)

  1365. T_(vec_t<, C_ 9>, vec9)

  1366. T_(vec_t<, C_ 10>, vec10)

  1367. T_(vec_t<, C_ 11>, vec11)

  1368. T_(vec_t<, C_ 12>, vec12)

  1369. 

  1370. #undef C_

  1371. #undef T_

  1372. 

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

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

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

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

  1377. 

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

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

  1380. 

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

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

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

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

  1385. 

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

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

  1388. 

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

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

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

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

  1393. 

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

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

  1396. 

  1397. //

  1398. // HLSL/Cg-compliant type names

  1399. //

  1400. 

  1401. typedef vec2 float2;

  1402. typedef vec3 float3;

  1403. typedef vec4 float4;

  1404. typedef vec5 float5;

  1405. typedef vec6 float6;

  1406. typedef vec7 float7;

  1407. typedef vec8 float8;

  1408. typedef vec9 float9;

  1409. typedef vec10 float10;

  1410. typedef vec11 float11;

  1411. typedef vec12 float12;

  1412. 

  1413. typedef f16vec2 half2;

  1414. typedef f16vec3 half3;

  1415. typedef f16vec4 half4;

  1416. 

  1417. typedef ivec2 int2;

  1418. typedef ivec3 int3;

  1419. typedef ivec4 int4;

  1420. typedef ivec5 int5;

  1421. typedef ivec6 int6;

  1422. typedef ivec7 int7;

  1423. typedef ivec8 int8;

  1424. typedef ivec9 int9;

  1425. typedef ivec10 int10;

  1426. typedef ivec11 int11;

  1427. typedef ivec12 int12;

  1428. 

  1429. } // namespace lol

  1430. 

  1431. #include "vector.ipp"