17 #ifndef GLM_ENABLE_EXPERIMENTAL 
   18 #       error "GLM: GLM_GTX_vec_swizzle is an experimental extension and may change in the future. Use #define GLM_ENABLE_EXPERIMENTAL before including it, if you really want to use it." 
   19 #elif GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) 
   20 #       pragma message("GLM: GLM_GTX_vec_swizzle extension included") 
   28         template<
typename T, qualifier Q>
 
   29         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xx(
const glm::vec<1, T, Q> &v) {
 
   30                 return glm::vec<2, T, Q>(v.x, v.x);
 
   33         template<
typename T, qualifier Q>
 
   34         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xx(
const glm::vec<2, T, Q> &v) {
 
   35                 return glm::vec<2, T, Q>(v.x, v.x);
 
   38         template<
typename T, qualifier Q>
 
   39         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xx(
const glm::vec<3, T, Q> &v) {
 
   40                 return glm::vec<2, T, Q>(v.x, v.x);
 
   43         template<
typename T, qualifier Q>
 
   44         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xx(
const glm::vec<4, T, Q> &v) {
 
   45                 return glm::vec<2, T, Q>(v.x, v.x);
 
   49         template<
typename T, qualifier Q>
 
   50         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xy(
const glm::vec<2, T, Q> &v) {
 
   51                 return glm::vec<2, T, Q>(v.x, v.y);
 
   54         template<
typename T, qualifier Q>
 
   55         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xy(
const glm::vec<3, T, Q> &v) {
 
   56                 return glm::vec<2, T, Q>(v.x, v.y);
 
   59         template<
typename T, qualifier Q>
 
   60         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xy(
const glm::vec<4, T, Q> &v) {
 
   61                 return glm::vec<2, T, Q>(v.x, v.y);
 
   65         template<
typename T, qualifier Q>
 
   66         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xz(
const glm::vec<3, T, Q> &v) {
 
   67                 return glm::vec<2, T, Q>(v.x, v.z);
 
   70         template<
typename T, qualifier Q>
 
   71         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xz(
const glm::vec<4, T, Q> &v) {
 
   72                 return glm::vec<2, T, Q>(v.x, v.z);
 
   76         template<
typename T, qualifier Q>
 
   77         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> xw(
const glm::vec<4, T, Q> &v) {
 
   78                 return glm::vec<2, T, Q>(v.x, v.w);
 
   82         template<
typename T, qualifier Q>
 
   83         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yx(
const glm::vec<2, T, Q> &v) {
 
   84                 return glm::vec<2, T, Q>(v.y, v.x);
 
   87         template<
typename T, qualifier Q>
 
   88         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yx(
const glm::vec<3, T, Q> &v) {
 
   89                 return glm::vec<2, T, Q>(v.y, v.x);
 
   92         template<
typename T, qualifier Q>
 
   93         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yx(
const glm::vec<4, T, Q> &v) {
 
   94                 return glm::vec<2, T, Q>(v.y, v.x);
 
   98         template<
typename T, qualifier Q>
 
   99         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yy(
const glm::vec<2, T, Q> &v) {
 
  100                 return glm::vec<2, T, Q>(v.y, v.y);
 
  103         template<
typename T, qualifier Q>
 
  104         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yy(
const glm::vec<3, T, Q> &v) {
 
  105                 return glm::vec<2, T, Q>(v.y, v.y);
 
  108         template<
typename T, qualifier Q>
 
  109         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yy(
const glm::vec<4, T, Q> &v) {
 
  110                 return glm::vec<2, T, Q>(v.y, v.y);
 
  114         template<
typename T, qualifier Q>
 
  115         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yz(
const glm::vec<3, T, Q> &v) {
 
  116                 return glm::vec<2, T, Q>(v.y, v.z);
 
  119         template<
typename T, qualifier Q>
 
  120         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yz(
const glm::vec<4, T, Q> &v) {
 
  121                 return glm::vec<2, T, Q>(v.y, v.z);
 
  125         template<
typename T, qualifier Q>
 
  126         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> yw(
const glm::vec<4, T, Q> &v) {
 
  127                 return glm::vec<2, T, Q>(v.y, v.w);
 
  131         template<
typename T, qualifier Q>
 
  132         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zx(
const glm::vec<3, T, Q> &v) {
 
  133                 return glm::vec<2, T, Q>(v.z, v.x);
 
  136         template<
typename T, qualifier Q>
 
  137         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zx(
const glm::vec<4, T, Q> &v) {
 
  138                 return glm::vec<2, T, Q>(v.z, v.x);
 
  142         template<
typename T, qualifier Q>
 
  143         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zy(
const glm::vec<3, T, Q> &v) {
 
  144                 return glm::vec<2, T, Q>(v.z, v.y);
 
  147         template<
typename T, qualifier Q>
 
  148         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zy(
const glm::vec<4, T, Q> &v) {
 
  149                 return glm::vec<2, T, Q>(v.z, v.y);
 
  153         template<
typename T, qualifier Q>
 
  154         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zz(
const glm::vec<3, T, Q> &v) {
 
  155                 return glm::vec<2, T, Q>(v.z, v.z);
 
  158         template<
typename T, qualifier Q>
 
  159         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zz(
const glm::vec<4, T, Q> &v) {
 
  160                 return glm::vec<2, T, Q>(v.z, v.z);
 
  164         template<
typename T, qualifier Q>
 
  165         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> zw(
const glm::vec<4, T, Q> &v) {
 
  166                 return glm::vec<2, T, Q>(v.z, v.w);
 
  170         template<
typename T, qualifier Q>
 
  171         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> wx(
const glm::vec<4, T, Q> &v) {
 
  172                 return glm::vec<2, T, Q>(v.w, v.x);
 
  176         template<
typename T, qualifier Q>
 
  177         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> wy(
const glm::vec<4, T, Q> &v) {
 
  178                 return glm::vec<2, T, Q>(v.w, v.y);
 
  182         template<
typename T, qualifier Q>
 
  183         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> wz(
const glm::vec<4, T, Q> &v) {
 
  184                 return glm::vec<2, T, Q>(v.w, v.z);
 
  188         template<
typename T, qualifier Q>
 
  189         GLM_FUNC_QUALIFIER glm::vec<2, T, Q> ww(
const glm::vec<4, T, Q> &v) {
 
  190                 return glm::vec<2, T, Q>(v.w, v.w);
 
  194         template<
typename T, qualifier Q>
 
  195         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxx(
const glm::vec<1, T, Q> &v) {
 
  196                 return glm::vec<3, T, Q>(v.x, v.x, v.x);
 
  199         template<
typename T, qualifier Q>
 
  200         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxx(
const glm::vec<2, T, Q> &v) {
 
  201                 return glm::vec<3, T, Q>(v.x, v.x, v.x);
 
  204         template<
typename T, qualifier Q>
 
  205         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxx(
const glm::vec<3, T, Q> &v) {
 
  206                 return glm::vec<3, T, Q>(v.x, v.x, v.x);
 
  209         template<
typename T, qualifier Q>
 
  210         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxx(
const glm::vec<4, T, Q> &v) {
 
  211                 return glm::vec<3, T, Q>(v.x, v.x, v.x);
 
  215         template<
typename T, qualifier Q>
 
  216         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxy(
const glm::vec<2, T, Q> &v) {
 
  217                 return glm::vec<3, T, Q>(v.x, v.x, v.y);
 
  220         template<
typename T, qualifier Q>
 
  221         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxy(
const glm::vec<3, T, Q> &v) {
 
  222                 return glm::vec<3, T, Q>(v.x, v.x, v.y);
 
  225         template<
typename T, qualifier Q>
 
  226         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxy(
const glm::vec<4, T, Q> &v) {
 
  227                 return glm::vec<3, T, Q>(v.x, v.x, v.y);
 
  231         template<
typename T, qualifier Q>
 
  232         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxz(
const glm::vec<3, T, Q> &v) {
 
  233                 return glm::vec<3, T, Q>(v.x, v.x, v.z);
 
  236         template<
typename T, qualifier Q>
 
  237         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxz(
const glm::vec<4, T, Q> &v) {
 
  238                 return glm::vec<3, T, Q>(v.x, v.x, v.z);
 
  242         template<
typename T, qualifier Q>
 
  243         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xxw(
const glm::vec<4, T, Q> &v) {
 
  244                 return glm::vec<3, T, Q>(v.x, v.x, v.w);
 
  248         template<
typename T, qualifier Q>
 
  249         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyx(
const glm::vec<2, T, Q> &v) {
 
  250                 return glm::vec<3, T, Q>(v.x, v.y, v.x);
 
  253         template<
typename T, qualifier Q>
 
  254         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyx(
const glm::vec<3, T, Q> &v) {
 
  255                 return glm::vec<3, T, Q>(v.x, v.y, v.x);
 
  258         template<
typename T, qualifier Q>
 
  259         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyx(
const glm::vec<4, T, Q> &v) {
 
  260                 return glm::vec<3, T, Q>(v.x, v.y, v.x);
 
  264         template<
typename T, qualifier Q>
 
  265         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyy(
const glm::vec<2, T, Q> &v) {
 
  266                 return glm::vec<3, T, Q>(v.x, v.y, v.y);
 
  269         template<
typename T, qualifier Q>
 
  270         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyy(
const glm::vec<3, T, Q> &v) {
 
  271                 return glm::vec<3, T, Q>(v.x, v.y, v.y);
 
  274         template<
typename T, qualifier Q>
 
  275         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyy(
const glm::vec<4, T, Q> &v) {
 
  276                 return glm::vec<3, T, Q>(v.x, v.y, v.y);
 
  280         template<
typename T, qualifier Q>
 
  281         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyz(
const glm::vec<3, T, Q> &v) {
 
  282                 return glm::vec<3, T, Q>(v.x, v.y, v.z);
 
  285         template<
typename T, qualifier Q>
 
  286         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyz(
const glm::vec<4, T, Q> &v) {
 
  287                 return glm::vec<3, T, Q>(v.x, v.y, v.z);
 
  291         template<
typename T, qualifier Q>
 
  292         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xyw(
const glm::vec<4, T, Q> &v) {
 
  293                 return glm::vec<3, T, Q>(v.x, v.y, v.w);
 
  297         template<
typename T, qualifier Q>
 
  298         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzx(
const glm::vec<3, T, Q> &v) {
 
  299                 return glm::vec<3, T, Q>(v.x, v.z, v.x);
 
  302         template<
typename T, qualifier Q>
 
  303         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzx(
const glm::vec<4, T, Q> &v) {
 
  304                 return glm::vec<3, T, Q>(v.x, v.z, v.x);
 
  308         template<
typename T, qualifier Q>
 
  309         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzy(
const glm::vec<3, T, Q> &v) {
 
  310                 return glm::vec<3, T, Q>(v.x, v.z, v.y);
 
  313         template<
typename T, qualifier Q>
 
  314         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzy(
const glm::vec<4, T, Q> &v) {
 
  315                 return glm::vec<3, T, Q>(v.x, v.z, v.y);
 
  319         template<
typename T, qualifier Q>
 
  320         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzz(
const glm::vec<3, T, Q> &v) {
 
  321                 return glm::vec<3, T, Q>(v.x, v.z, v.z);
 
  324         template<
typename T, qualifier Q>
 
  325         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzz(
const glm::vec<4, T, Q> &v) {
 
  326                 return glm::vec<3, T, Q>(v.x, v.z, v.z);
 
  330         template<
typename T, qualifier Q>
 
  331         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xzw(
const glm::vec<4, T, Q> &v) {
 
  332                 return glm::vec<3, T, Q>(v.x, v.z, v.w);
 
  336         template<
typename T, qualifier Q>
 
  337         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xwx(
const glm::vec<4, T, Q> &v) {
 
  338                 return glm::vec<3, T, Q>(v.x, v.w, v.x);
 
  342         template<
typename T, qualifier Q>
 
  343         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xwy(
const glm::vec<4, T, Q> &v) {
 
  344                 return glm::vec<3, T, Q>(v.x, v.w, v.y);
 
  348         template<
typename T, qualifier Q>
 
  349         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xwz(
const glm::vec<4, T, Q> &v) {
 
  350                 return glm::vec<3, T, Q>(v.x, v.w, v.z);
 
  354         template<
typename T, qualifier Q>
 
  355         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> xww(
const glm::vec<4, T, Q> &v) {
 
  356                 return glm::vec<3, T, Q>(v.x, v.w, v.w);
 
  360         template<
typename T, qualifier Q>
 
  361         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxx(
const glm::vec<2, T, Q> &v) {
 
  362                 return glm::vec<3, T, Q>(v.y, v.x, v.x);
 
  365         template<
typename T, qualifier Q>
 
  366         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxx(
const glm::vec<3, T, Q> &v) {
 
  367                 return glm::vec<3, T, Q>(v.y, v.x, v.x);
 
  370         template<
typename T, qualifier Q>
 
  371         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxx(
const glm::vec<4, T, Q> &v) {
 
  372                 return glm::vec<3, T, Q>(v.y, v.x, v.x);
 
  376         template<
typename T, qualifier Q>
 
  377         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxy(
const glm::vec<2, T, Q> &v) {
 
  378                 return glm::vec<3, T, Q>(v.y, v.x, v.y);
 
  381         template<
typename T, qualifier Q>
 
  382         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxy(
const glm::vec<3, T, Q> &v) {
 
  383                 return glm::vec<3, T, Q>(v.y, v.x, v.y);
 
  386         template<
typename T, qualifier Q>
 
  387         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxy(
const glm::vec<4, T, Q> &v) {
 
  388                 return glm::vec<3, T, Q>(v.y, v.x, v.y);
 
  392         template<
typename T, qualifier Q>
 
  393         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxz(
const glm::vec<3, T, Q> &v) {
 
  394                 return glm::vec<3, T, Q>(v.y, v.x, v.z);
 
  397         template<
typename T, qualifier Q>
 
  398         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxz(
const glm::vec<4, T, Q> &v) {
 
  399                 return glm::vec<3, T, Q>(v.y, v.x, v.z);
 
  403         template<
typename T, qualifier Q>
 
  404         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yxw(
const glm::vec<4, T, Q> &v) {
 
  405                 return glm::vec<3, T, Q>(v.y, v.x, v.w);
 
  409         template<
typename T, qualifier Q>
 
  410         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyx(
const glm::vec<2, T, Q> &v) {
 
  411                 return glm::vec<3, T, Q>(v.y, v.y, v.x);
 
  414         template<
typename T, qualifier Q>
 
  415         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyx(
const glm::vec<3, T, Q> &v) {
 
  416                 return glm::vec<3, T, Q>(v.y, v.y, v.x);
 
  419         template<
typename T, qualifier Q>
 
  420         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyx(
const glm::vec<4, T, Q> &v) {
 
  421                 return glm::vec<3, T, Q>(v.y, v.y, v.x);
 
  425         template<
typename T, qualifier Q>
 
  426         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyy(
const glm::vec<2, T, Q> &v) {
 
  427                 return glm::vec<3, T, Q>(v.y, v.y, v.y);
 
  430         template<
typename T, qualifier Q>
 
  431         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyy(
const glm::vec<3, T, Q> &v) {
 
  432                 return glm::vec<3, T, Q>(v.y, v.y, v.y);
 
  435         template<
typename T, qualifier Q>
 
  436         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyy(
const glm::vec<4, T, Q> &v) {
 
  437                 return glm::vec<3, T, Q>(v.y, v.y, v.y);
 
  441         template<
typename T, qualifier Q>
 
  442         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyz(
const glm::vec<3, T, Q> &v) {
 
  443                 return glm::vec<3, T, Q>(v.y, v.y, v.z);
 
  446         template<
typename T, qualifier Q>
 
  447         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyz(
const glm::vec<4, T, Q> &v) {
 
  448                 return glm::vec<3, T, Q>(v.y, v.y, v.z);
 
  452         template<
typename T, qualifier Q>
 
  453         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yyw(
const glm::vec<4, T, Q> &v) {
 
  454                 return glm::vec<3, T, Q>(v.y, v.y, v.w);
 
  458         template<
typename T, qualifier Q>
 
  459         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzx(
const glm::vec<3, T, Q> &v) {
 
  460                 return glm::vec<3, T, Q>(v.y, v.z, v.x);
 
  463         template<
typename T, qualifier Q>
 
  464         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzx(
const glm::vec<4, T, Q> &v) {
 
  465                 return glm::vec<3, T, Q>(v.y, v.z, v.x);
 
  469         template<
typename T, qualifier Q>
 
  470         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzy(
const glm::vec<3, T, Q> &v) {
 
  471                 return glm::vec<3, T, Q>(v.y, v.z, v.y);
 
  474         template<
typename T, qualifier Q>
 
  475         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzy(
const glm::vec<4, T, Q> &v) {
 
  476                 return glm::vec<3, T, Q>(v.y, v.z, v.y);
 
  480         template<
typename T, qualifier Q>
 
  481         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzz(
const glm::vec<3, T, Q> &v) {
 
  482                 return glm::vec<3, T, Q>(v.y, v.z, v.z);
 
  485         template<
typename T, qualifier Q>
 
  486         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzz(
const glm::vec<4, T, Q> &v) {
 
  487                 return glm::vec<3, T, Q>(v.y, v.z, v.z);
 
  491         template<
typename T, qualifier Q>
 
  492         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yzw(
const glm::vec<4, T, Q> &v) {
 
  493                 return glm::vec<3, T, Q>(v.y, v.z, v.w);
 
  497         template<
typename T, qualifier Q>
 
  498         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> ywx(
const glm::vec<4, T, Q> &v) {
 
  499                 return glm::vec<3, T, Q>(v.y, v.w, v.x);
 
  503         template<
typename T, qualifier Q>
 
  504         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> ywy(
const glm::vec<4, T, Q> &v) {
 
  505                 return glm::vec<3, T, Q>(v.y, v.w, v.y);
 
  509         template<
typename T, qualifier Q>
 
  510         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> ywz(
const glm::vec<4, T, Q> &v) {
 
  511                 return glm::vec<3, T, Q>(v.y, v.w, v.z);
 
  515         template<
typename T, qualifier Q>
 
  516         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> yww(
const glm::vec<4, T, Q> &v) {
 
  517                 return glm::vec<3, T, Q>(v.y, v.w, v.w);
 
  521         template<
typename T, qualifier Q>
 
  522         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxx(
const glm::vec<3, T, Q> &v) {
 
  523                 return glm::vec<3, T, Q>(v.z, v.x, v.x);
 
  526         template<
typename T, qualifier Q>
 
  527         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxx(
const glm::vec<4, T, Q> &v) {
 
  528                 return glm::vec<3, T, Q>(v.z, v.x, v.x);
 
  532         template<
typename T, qualifier Q>
 
  533         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxy(
const glm::vec<3, T, Q> &v) {
 
  534                 return glm::vec<3, T, Q>(v.z, v.x, v.y);
 
  537         template<
typename T, qualifier Q>
 
  538         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxy(
const glm::vec<4, T, Q> &v) {
 
  539                 return glm::vec<3, T, Q>(v.z, v.x, v.y);
 
  543         template<
typename T, qualifier Q>
 
  544         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxz(
const glm::vec<3, T, Q> &v) {
 
  545                 return glm::vec<3, T, Q>(v.z, v.x, v.z);
 
  548         template<
typename T, qualifier Q>
 
  549         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxz(
const glm::vec<4, T, Q> &v) {
 
  550                 return glm::vec<3, T, Q>(v.z, v.x, v.z);
 
  554         template<
typename T, qualifier Q>
 
  555         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zxw(
const glm::vec<4, T, Q> &v) {
 
  556                 return glm::vec<3, T, Q>(v.z, v.x, v.w);
 
  560         template<
typename T, qualifier Q>
 
  561         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyx(
const glm::vec<3, T, Q> &v) {
 
  562                 return glm::vec<3, T, Q>(v.z, v.y, v.x);
 
  565         template<
typename T, qualifier Q>
 
  566         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyx(
const glm::vec<4, T, Q> &v) {
 
  567                 return glm::vec<3, T, Q>(v.z, v.y, v.x);
 
  571         template<
typename T, qualifier Q>
 
  572         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyy(
const glm::vec<3, T, Q> &v) {
 
  573                 return glm::vec<3, T, Q>(v.z, v.y, v.y);
 
  576         template<
typename T, qualifier Q>
 
  577         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyy(
const glm::vec<4, T, Q> &v) {
 
  578                 return glm::vec<3, T, Q>(v.z, v.y, v.y);
 
  582         template<
typename T, qualifier Q>
 
  583         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyz(
const glm::vec<3, T, Q> &v) {
 
  584                 return glm::vec<3, T, Q>(v.z, v.y, v.z);
 
  587         template<
typename T, qualifier Q>
 
  588         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyz(
const glm::vec<4, T, Q> &v) {
 
  589                 return glm::vec<3, T, Q>(v.z, v.y, v.z);
 
  593         template<
typename T, qualifier Q>
 
  594         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zyw(
const glm::vec<4, T, Q> &v) {
 
  595                 return glm::vec<3, T, Q>(v.z, v.y, v.w);
 
  599         template<
typename T, qualifier Q>
 
  600         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzx(
const glm::vec<3, T, Q> &v) {
 
  601                 return glm::vec<3, T, Q>(v.z, v.z, v.x);
 
  604         template<
typename T, qualifier Q>
 
  605         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzx(
const glm::vec<4, T, Q> &v) {
 
  606                 return glm::vec<3, T, Q>(v.z, v.z, v.x);
 
  610         template<
typename T, qualifier Q>
 
  611         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzy(
const glm::vec<3, T, Q> &v) {
 
  612                 return glm::vec<3, T, Q>(v.z, v.z, v.y);
 
  615         template<
typename T, qualifier Q>
 
  616         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzy(
const glm::vec<4, T, Q> &v) {
 
  617                 return glm::vec<3, T, Q>(v.z, v.z, v.y);
 
  621         template<
typename T, qualifier Q>
 
  622         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzz(
const glm::vec<3, T, Q> &v) {
 
  623                 return glm::vec<3, T, Q>(v.z, v.z, v.z);
 
  626         template<
typename T, qualifier Q>
 
  627         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzz(
const glm::vec<4, T, Q> &v) {
 
  628                 return glm::vec<3, T, Q>(v.z, v.z, v.z);
 
  632         template<
typename T, qualifier Q>
 
  633         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zzw(
const glm::vec<4, T, Q> &v) {
 
  634                 return glm::vec<3, T, Q>(v.z, v.z, v.w);
 
  638         template<
typename T, qualifier Q>
 
  639         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zwx(
const glm::vec<4, T, Q> &v) {
 
  640                 return glm::vec<3, T, Q>(v.z, v.w, v.x);
 
  644         template<
typename T, qualifier Q>
 
  645         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zwy(
const glm::vec<4, T, Q> &v) {
 
  646                 return glm::vec<3, T, Q>(v.z, v.w, v.y);
 
  650         template<
typename T, qualifier Q>
 
  651         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zwz(
const glm::vec<4, T, Q> &v) {
 
  652                 return glm::vec<3, T, Q>(v.z, v.w, v.z);
 
  656         template<
typename T, qualifier Q>
 
  657         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> zww(
const glm::vec<4, T, Q> &v) {
 
  658                 return glm::vec<3, T, Q>(v.z, v.w, v.w);
 
  662         template<
typename T, qualifier Q>
 
  663         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wxx(
const glm::vec<4, T, Q> &v) {
 
  664                 return glm::vec<3, T, Q>(v.w, v.x, v.x);
 
  668         template<
typename T, qualifier Q>
 
  669         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wxy(
const glm::vec<4, T, Q> &v) {
 
  670                 return glm::vec<3, T, Q>(v.w, v.x, v.y);
 
  674         template<
typename T, qualifier Q>
 
  675         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wxz(
const glm::vec<4, T, Q> &v) {
 
  676                 return glm::vec<3, T, Q>(v.w, v.x, v.z);
 
  680         template<
typename T, qualifier Q>
 
  681         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wxw(
const glm::vec<4, T, Q> &v) {
 
  682                 return glm::vec<3, T, Q>(v.w, v.x, v.w);
 
  686         template<
typename T, qualifier Q>
 
  687         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wyx(
const glm::vec<4, T, Q> &v) {
 
  688                 return glm::vec<3, T, Q>(v.w, v.y, v.x);
 
  692         template<
typename T, qualifier Q>
 
  693         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wyy(
const glm::vec<4, T, Q> &v) {
 
  694                 return glm::vec<3, T, Q>(v.w, v.y, v.y);
 
  698         template<
typename T, qualifier Q>
 
  699         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wyz(
const glm::vec<4, T, Q> &v) {
 
  700                 return glm::vec<3, T, Q>(v.w, v.y, v.z);
 
  704         template<
typename T, qualifier Q>
 
  705         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wyw(
const glm::vec<4, T, Q> &v) {
 
  706                 return glm::vec<3, T, Q>(v.w, v.y, v.w);
 
  710         template<
typename T, qualifier Q>
 
  711         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wzx(
const glm::vec<4, T, Q> &v) {
 
  712                 return glm::vec<3, T, Q>(v.w, v.z, v.x);
 
  716         template<
typename T, qualifier Q>
 
  717         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wzy(
const glm::vec<4, T, Q> &v) {
 
  718                 return glm::vec<3, T, Q>(v.w, v.z, v.y);
 
  722         template<
typename T, qualifier Q>
 
  723         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wzz(
const glm::vec<4, T, Q> &v) {
 
  724                 return glm::vec<3, T, Q>(v.w, v.z, v.z);
 
  728         template<
typename T, qualifier Q>
 
  729         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wzw(
const glm::vec<4, T, Q> &v) {
 
  730                 return glm::vec<3, T, Q>(v.w, v.z, v.w);
 
  734         template<
typename T, qualifier Q>
 
  735         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wwx(
const glm::vec<4, T, Q> &v) {
 
  736                 return glm::vec<3, T, Q>(v.w, v.w, v.x);
 
  740         template<
typename T, qualifier Q>
 
  741         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wwy(
const glm::vec<4, T, Q> &v) {
 
  742                 return glm::vec<3, T, Q>(v.w, v.w, v.y);
 
  746         template<
typename T, qualifier Q>
 
  747         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> wwz(
const glm::vec<4, T, Q> &v) {
 
  748                 return glm::vec<3, T, Q>(v.w, v.w, v.z);
 
  752         template<
typename T, qualifier Q>
 
  753         GLM_FUNC_QUALIFIER glm::vec<3, T, Q> www(
const glm::vec<4, T, Q> &v) {
 
  754                 return glm::vec<3, T, Q>(v.w, v.w, v.w);
 
  758         template<
typename T, qualifier Q>
 
  759         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxx(
const glm::vec<1, T, Q> &v) {
 
  760                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
 
  763         template<
typename T, qualifier Q>
 
  764         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxx(
const glm::vec<2, T, Q> &v) {
 
  765                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
 
  768         template<
typename T, qualifier Q>
 
  769         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxx(
const glm::vec<3, T, Q> &v) {
 
  770                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
 
  773         template<
typename T, qualifier Q>
 
  774         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxx(
const glm::vec<4, T, Q> &v) {
 
  775                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.x);
 
  779         template<
typename T, qualifier Q>
 
  780         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxy(
const glm::vec<2, T, Q> &v) {
 
  781                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
 
  784         template<
typename T, qualifier Q>
 
  785         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxy(
const glm::vec<3, T, Q> &v) {
 
  786                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
 
  789         template<
typename T, qualifier Q>
 
  790         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxy(
const glm::vec<4, T, Q> &v) {
 
  791                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.y);
 
  795         template<
typename T, qualifier Q>
 
  796         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxz(
const glm::vec<3, T, Q> &v) {
 
  797                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
 
  800         template<
typename T, qualifier Q>
 
  801         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxz(
const glm::vec<4, T, Q> &v) {
 
  802                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.z);
 
  806         template<
typename T, qualifier Q>
 
  807         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxxw(
const glm::vec<4, T, Q> &v) {
 
  808                 return glm::vec<4, T, Q>(v.x, v.x, v.x, v.w);
 
  812         template<
typename T, qualifier Q>
 
  813         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyx(
const glm::vec<2, T, Q> &v) {
 
  814                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
 
  817         template<
typename T, qualifier Q>
 
  818         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyx(
const glm::vec<3, T, Q> &v) {
 
  819                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
 
  822         template<
typename T, qualifier Q>
 
  823         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyx(
const glm::vec<4, T, Q> &v) {
 
  824                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.x);
 
  828         template<
typename T, qualifier Q>
 
  829         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyy(
const glm::vec<2, T, Q> &v) {
 
  830                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
 
  833         template<
typename T, qualifier Q>
 
  834         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyy(
const glm::vec<3, T, Q> &v) {
 
  835                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
 
  838         template<
typename T, qualifier Q>
 
  839         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyy(
const glm::vec<4, T, Q> &v) {
 
  840                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.y);
 
  844         template<
typename T, qualifier Q>
 
  845         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyz(
const glm::vec<3, T, Q> &v) {
 
  846                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
 
  849         template<
typename T, qualifier Q>
 
  850         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyz(
const glm::vec<4, T, Q> &v) {
 
  851                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.z);
 
  855         template<
typename T, qualifier Q>
 
  856         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxyw(
const glm::vec<4, T, Q> &v) {
 
  857                 return glm::vec<4, T, Q>(v.x, v.x, v.y, v.w);
 
  861         template<
typename T, qualifier Q>
 
  862         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzx(
const glm::vec<3, T, Q> &v) {
 
  863                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
 
  866         template<
typename T, qualifier Q>
 
  867         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzx(
const glm::vec<4, T, Q> &v) {
 
  868                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.x);
 
  872         template<
typename T, qualifier Q>
 
  873         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzy(
const glm::vec<3, T, Q> &v) {
 
  874                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
 
  877         template<
typename T, qualifier Q>
 
  878         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzy(
const glm::vec<4, T, Q> &v) {
 
  879                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.y);
 
  883         template<
typename T, qualifier Q>
 
  884         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzz(
const glm::vec<3, T, Q> &v) {
 
  885                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
 
  888         template<
typename T, qualifier Q>
 
  889         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzz(
const glm::vec<4, T, Q> &v) {
 
  890                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.z);
 
  894         template<
typename T, qualifier Q>
 
  895         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxzw(
const glm::vec<4, T, Q> &v) {
 
  896                 return glm::vec<4, T, Q>(v.x, v.x, v.z, v.w);
 
  900         template<
typename T, qualifier Q>
 
  901         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxwx(
const glm::vec<4, T, Q> &v) {
 
  902                 return glm::vec<4, T, Q>(v.x, v.x, v.w, v.x);
 
  906         template<
typename T, qualifier Q>
 
  907         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxwy(
const glm::vec<4, T, Q> &v) {
 
  908                 return glm::vec<4, T, Q>(v.x, v.x, v.w, v.y);
 
  912         template<
typename T, qualifier Q>
 
  913         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxwz(
const glm::vec<4, T, Q> &v) {
 
  914                 return glm::vec<4, T, Q>(v.x, v.x, v.w, v.z);
 
  918         template<
typename T, qualifier Q>
 
  919         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xxww(
const glm::vec<4, T, Q> &v) {
 
  920                 return glm::vec<4, T, Q>(v.x, v.x, v.w, v.w);
 
  924         template<
typename T, qualifier Q>
 
  925         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxx(
const glm::vec<2, T, Q> &v) {
 
  926                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
 
  929         template<
typename T, qualifier Q>
 
  930         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxx(
const glm::vec<3, T, Q> &v) {
 
  931                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
 
  934         template<
typename T, qualifier Q>
 
  935         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxx(
const glm::vec<4, T, Q> &v) {
 
  936                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.x);
 
  940         template<
typename T, qualifier Q>
 
  941         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxy(
const glm::vec<2, T, Q> &v) {
 
  942                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
 
  945         template<
typename T, qualifier Q>
 
  946         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxy(
const glm::vec<3, T, Q> &v) {
 
  947                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
 
  950         template<
typename T, qualifier Q>
 
  951         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxy(
const glm::vec<4, T, Q> &v) {
 
  952                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.y);
 
  956         template<
typename T, qualifier Q>
 
  957         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxz(
const glm::vec<3, T, Q> &v) {
 
  958                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
 
  961         template<
typename T, qualifier Q>
 
  962         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxz(
const glm::vec<4, T, Q> &v) {
 
  963                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.z);
 
  967         template<
typename T, qualifier Q>
 
  968         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyxw(
const glm::vec<4, T, Q> &v) {
 
  969                 return glm::vec<4, T, Q>(v.x, v.y, v.x, v.w);
 
  973         template<
typename T, qualifier Q>
 
  974         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyx(
const glm::vec<2, T, Q> &v) {
 
  975                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
 
  978         template<
typename T, qualifier Q>
 
  979         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyx(
const glm::vec<3, T, Q> &v) {
 
  980                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
 
  983         template<
typename T, qualifier Q>
 
  984         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyx(
const glm::vec<4, T, Q> &v) {
 
  985                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.x);
 
  989         template<
typename T, qualifier Q>
 
  990         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyy(
const glm::vec<2, T, Q> &v) {
 
  991                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
 
  994         template<
typename T, qualifier Q>
 
  995         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyy(
const glm::vec<3, T, Q> &v) {
 
  996                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
 
  999         template<
typename T, qualifier Q>
 
 1000         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyy(
const glm::vec<4, T, Q> &v) {
 
 1001                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.y);
 
 1005         template<
typename T, qualifier Q>
 
 1006         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyz(
const glm::vec<3, T, Q> &v) {
 
 1007                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
 
 1010         template<
typename T, qualifier Q>
 
 1011         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyz(
const glm::vec<4, T, Q> &v) {
 
 1012                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.z);
 
 1016         template<
typename T, qualifier Q>
 
 1017         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyyw(
const glm::vec<4, T, Q> &v) {
 
 1018                 return glm::vec<4, T, Q>(v.x, v.y, v.y, v.w);
 
 1022         template<
typename T, qualifier Q>
 
 1023         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzx(
const glm::vec<3, T, Q> &v) {
 
 1024                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
 
 1027         template<
typename T, qualifier Q>
 
 1028         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzx(
const glm::vec<4, T, Q> &v) {
 
 1029                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.x);
 
 1033         template<
typename T, qualifier Q>
 
 1034         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzy(
const glm::vec<3, T, Q> &v) {
 
 1035                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
 
 1038         template<
typename T, qualifier Q>
 
 1039         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzy(
const glm::vec<4, T, Q> &v) {
 
 1040                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.y);
 
 1044         template<
typename T, qualifier Q>
 
 1045         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzz(
const glm::vec<3, T, Q> &v) {
 
 1046                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
 
 1049         template<
typename T, qualifier Q>
 
 1050         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzz(
const glm::vec<4, T, Q> &v) {
 
 1051                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.z);
 
 1055         template<
typename T, qualifier Q>
 
 1056         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyzw(
const glm::vec<4, T, Q> &v) {
 
 1057                 return glm::vec<4, T, Q>(v.x, v.y, v.z, v.w);
 
 1061         template<
typename T, qualifier Q>
 
 1062         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xywx(
const glm::vec<4, T, Q> &v) {
 
 1063                 return glm::vec<4, T, Q>(v.x, v.y, v.w, v.x);
 
 1067         template<
typename T, qualifier Q>
 
 1068         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xywy(
const glm::vec<4, T, Q> &v) {
 
 1069                 return glm::vec<4, T, Q>(v.x, v.y, v.w, v.y);
 
 1073         template<
typename T, qualifier Q>
 
 1074         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xywz(
const glm::vec<4, T, Q> &v) {
 
 1075                 return glm::vec<4, T, Q>(v.x, v.y, v.w, v.z);
 
 1079         template<
typename T, qualifier Q>
 
 1080         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xyww(
const glm::vec<4, T, Q> &v) {
 
 1081                 return glm::vec<4, T, Q>(v.x, v.y, v.w, v.w);
 
 1085         template<
typename T, qualifier Q>
 
 1086         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxx(
const glm::vec<3, T, Q> &v) {
 
 1087                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
 
 1090         template<
typename T, qualifier Q>
 
 1091         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxx(
const glm::vec<4, T, Q> &v) {
 
 1092                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.x);
 
 1096         template<
typename T, qualifier Q>
 
 1097         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxy(
const glm::vec<3, T, Q> &v) {
 
 1098                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
 
 1101         template<
typename T, qualifier Q>
 
 1102         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxy(
const glm::vec<4, T, Q> &v) {
 
 1103                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.y);
 
 1107         template<
typename T, qualifier Q>
 
 1108         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxz(
const glm::vec<3, T, Q> &v) {
 
 1109                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
 
 1112         template<
typename T, qualifier Q>
 
 1113         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxz(
const glm::vec<4, T, Q> &v) {
 
 1114                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.z);
 
 1118         template<
typename T, qualifier Q>
 
 1119         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzxw(
const glm::vec<4, T, Q> &v) {
 
 1120                 return glm::vec<4, T, Q>(v.x, v.z, v.x, v.w);
 
 1124         template<
typename T, qualifier Q>
 
 1125         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyx(
const glm::vec<3, T, Q> &v) {
 
 1126                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
 
 1129         template<
typename T, qualifier Q>
 
 1130         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyx(
const glm::vec<4, T, Q> &v) {
 
 1131                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.x);
 
 1135         template<
typename T, qualifier Q>
 
 1136         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyy(
const glm::vec<3, T, Q> &v) {
 
 1137                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
 
 1140         template<
typename T, qualifier Q>
 
 1141         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyy(
const glm::vec<4, T, Q> &v) {
 
 1142                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.y);
 
 1146         template<
typename T, qualifier Q>
 
 1147         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyz(
const glm::vec<3, T, Q> &v) {
 
 1148                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
 
 1151         template<
typename T, qualifier Q>
 
 1152         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyz(
const glm::vec<4, T, Q> &v) {
 
 1153                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.z);
 
 1157         template<
typename T, qualifier Q>
 
 1158         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzyw(
const glm::vec<4, T, Q> &v) {
 
 1159                 return glm::vec<4, T, Q>(v.x, v.z, v.y, v.w);
 
 1163         template<
typename T, qualifier Q>
 
 1164         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzx(
const glm::vec<3, T, Q> &v) {
 
 1165                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
 
 1168         template<
typename T, qualifier Q>
 
 1169         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzx(
const glm::vec<4, T, Q> &v) {
 
 1170                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.x);
 
 1174         template<
typename T, qualifier Q>
 
 1175         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzy(
const glm::vec<3, T, Q> &v) {
 
 1176                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
 
 1179         template<
typename T, qualifier Q>
 
 1180         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzy(
const glm::vec<4, T, Q> &v) {
 
 1181                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.y);
 
 1185         template<
typename T, qualifier Q>
 
 1186         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzz(
const glm::vec<3, T, Q> &v) {
 
 1187                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
 
 1190         template<
typename T, qualifier Q>
 
 1191         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzz(
const glm::vec<4, T, Q> &v) {
 
 1192                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.z);
 
 1196         template<
typename T, qualifier Q>
 
 1197         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzzw(
const glm::vec<4, T, Q> &v) {
 
 1198                 return glm::vec<4, T, Q>(v.x, v.z, v.z, v.w);
 
 1202         template<
typename T, qualifier Q>
 
 1203         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzwx(
const glm::vec<4, T, Q> &v) {
 
 1204                 return glm::vec<4, T, Q>(v.x, v.z, v.w, v.x);
 
 1208         template<
typename T, qualifier Q>
 
 1209         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzwy(
const glm::vec<4, T, Q> &v) {
 
 1210                 return glm::vec<4, T, Q>(v.x, v.z, v.w, v.y);
 
 1214         template<
typename T, qualifier Q>
 
 1215         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzwz(
const glm::vec<4, T, Q> &v) {
 
 1216                 return glm::vec<4, T, Q>(v.x, v.z, v.w, v.z);
 
 1220         template<
typename T, qualifier Q>
 
 1221         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xzww(
const glm::vec<4, T, Q> &v) {
 
 1222                 return glm::vec<4, T, Q>(v.x, v.z, v.w, v.w);
 
 1226         template<
typename T, qualifier Q>
 
 1227         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwxx(
const glm::vec<4, T, Q> &v) {
 
 1228                 return glm::vec<4, T, Q>(v.x, v.w, v.x, v.x);
 
 1232         template<
typename T, qualifier Q>
 
 1233         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwxy(
const glm::vec<4, T, Q> &v) {
 
 1234                 return glm::vec<4, T, Q>(v.x, v.w, v.x, v.y);
 
 1238         template<
typename T, qualifier Q>
 
 1239         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwxz(
const glm::vec<4, T, Q> &v) {
 
 1240                 return glm::vec<4, T, Q>(v.x, v.w, v.x, v.z);
 
 1244         template<
typename T, qualifier Q>
 
 1245         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwxw(
const glm::vec<4, T, Q> &v) {
 
 1246                 return glm::vec<4, T, Q>(v.x, v.w, v.x, v.w);
 
 1250         template<
typename T, qualifier Q>
 
 1251         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwyx(
const glm::vec<4, T, Q> &v) {
 
 1252                 return glm::vec<4, T, Q>(v.x, v.w, v.y, v.x);
 
 1256         template<
typename T, qualifier Q>
 
 1257         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwyy(
const glm::vec<4, T, Q> &v) {
 
 1258                 return glm::vec<4, T, Q>(v.x, v.w, v.y, v.y);
 
 1262         template<
typename T, qualifier Q>
 
 1263         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwyz(
const glm::vec<4, T, Q> &v) {
 
 1264                 return glm::vec<4, T, Q>(v.x, v.w, v.y, v.z);
 
 1268         template<
typename T, qualifier Q>
 
 1269         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwyw(
const glm::vec<4, T, Q> &v) {
 
 1270                 return glm::vec<4, T, Q>(v.x, v.w, v.y, v.w);
 
 1274         template<
typename T, qualifier Q>
 
 1275         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwzx(
const glm::vec<4, T, Q> &v) {
 
 1276                 return glm::vec<4, T, Q>(v.x, v.w, v.z, v.x);
 
 1280         template<
typename T, qualifier Q>
 
 1281         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwzy(
const glm::vec<4, T, Q> &v) {
 
 1282                 return glm::vec<4, T, Q>(v.x, v.w, v.z, v.y);
 
 1286         template<
typename T, qualifier Q>
 
 1287         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwzz(
const glm::vec<4, T, Q> &v) {
 
 1288                 return glm::vec<4, T, Q>(v.x, v.w, v.z, v.z);
 
 1292         template<
typename T, qualifier Q>
 
 1293         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwzw(
const glm::vec<4, T, Q> &v) {
 
 1294                 return glm::vec<4, T, Q>(v.x, v.w, v.z, v.w);
 
 1298         template<
typename T, qualifier Q>
 
 1299         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwwx(
const glm::vec<4, T, Q> &v) {
 
 1300                 return glm::vec<4, T, Q>(v.x, v.w, v.w, v.x);
 
 1304         template<
typename T, qualifier Q>
 
 1305         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwwy(
const glm::vec<4, T, Q> &v) {
 
 1306                 return glm::vec<4, T, Q>(v.x, v.w, v.w, v.y);
 
 1310         template<
typename T, qualifier Q>
 
 1311         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwwz(
const glm::vec<4, T, Q> &v) {
 
 1312                 return glm::vec<4, T, Q>(v.x, v.w, v.w, v.z);
 
 1316         template<
typename T, qualifier Q>
 
 1317         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> xwww(
const glm::vec<4, T, Q> &v) {
 
 1318                 return glm::vec<4, T, Q>(v.x, v.w, v.w, v.w);
 
 1322         template<
typename T, qualifier Q>
 
 1323         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxx(
const glm::vec<2, T, Q> &v) {
 
 1324                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
 
 1327         template<
typename T, qualifier Q>
 
 1328         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxx(
const glm::vec<3, T, Q> &v) {
 
 1329                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
 
 1332         template<
typename T, qualifier Q>
 
 1333         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxx(
const glm::vec<4, T, Q> &v) {
 
 1334                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.x);
 
 1338         template<
typename T, qualifier Q>
 
 1339         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxy(
const glm::vec<2, T, Q> &v) {
 
 1340                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
 
 1343         template<
typename T, qualifier Q>
 
 1344         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxy(
const glm::vec<3, T, Q> &v) {
 
 1345                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
 
 1348         template<
typename T, qualifier Q>
 
 1349         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxy(
const glm::vec<4, T, Q> &v) {
 
 1350                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.y);
 
 1354         template<
typename T, qualifier Q>
 
 1355         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxz(
const glm::vec<3, T, Q> &v) {
 
 1356                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
 
 1359         template<
typename T, qualifier Q>
 
 1360         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxz(
const glm::vec<4, T, Q> &v) {
 
 1361                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.z);
 
 1365         template<
typename T, qualifier Q>
 
 1366         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxxw(
const glm::vec<4, T, Q> &v) {
 
 1367                 return glm::vec<4, T, Q>(v.y, v.x, v.x, v.w);
 
 1371         template<
typename T, qualifier Q>
 
 1372         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyx(
const glm::vec<2, T, Q> &v) {
 
 1373                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
 
 1376         template<
typename T, qualifier Q>
 
 1377         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyx(
const glm::vec<3, T, Q> &v) {
 
 1378                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
 
 1381         template<
typename T, qualifier Q>
 
 1382         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyx(
const glm::vec<4, T, Q> &v) {
 
 1383                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.x);
 
 1387         template<
typename T, qualifier Q>
 
 1388         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyy(
const glm::vec<2, T, Q> &v) {
 
 1389                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
 
 1392         template<
typename T, qualifier Q>
 
 1393         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyy(
const glm::vec<3, T, Q> &v) {
 
 1394                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
 
 1397         template<
typename T, qualifier Q>
 
 1398         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyy(
const glm::vec<4, T, Q> &v) {
 
 1399                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.y);
 
 1403         template<
typename T, qualifier Q>
 
 1404         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyz(
const glm::vec<3, T, Q> &v) {
 
 1405                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
 
 1408         template<
typename T, qualifier Q>
 
 1409         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyz(
const glm::vec<4, T, Q> &v) {
 
 1410                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.z);
 
 1414         template<
typename T, qualifier Q>
 
 1415         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxyw(
const glm::vec<4, T, Q> &v) {
 
 1416                 return glm::vec<4, T, Q>(v.y, v.x, v.y, v.w);
 
 1420         template<
typename T, qualifier Q>
 
 1421         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzx(
const glm::vec<3, T, Q> &v) {
 
 1422                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
 
 1425         template<
typename T, qualifier Q>
 
 1426         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzx(
const glm::vec<4, T, Q> &v) {
 
 1427                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.x);
 
 1431         template<
typename T, qualifier Q>
 
 1432         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzy(
const glm::vec<3, T, Q> &v) {
 
 1433                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
 
 1436         template<
typename T, qualifier Q>
 
 1437         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzy(
const glm::vec<4, T, Q> &v) {
 
 1438                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.y);
 
 1442         template<
typename T, qualifier Q>
 
 1443         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzz(
const glm::vec<3, T, Q> &v) {
 
 1444                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
 
 1447         template<
typename T, qualifier Q>
 
 1448         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzz(
const glm::vec<4, T, Q> &v) {
 
 1449                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.z);
 
 1453         template<
typename T, qualifier Q>
 
 1454         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxzw(
const glm::vec<4, T, Q> &v) {
 
 1455                 return glm::vec<4, T, Q>(v.y, v.x, v.z, v.w);
 
 1459         template<
typename T, qualifier Q>
 
 1460         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxwx(
const glm::vec<4, T, Q> &v) {
 
 1461                 return glm::vec<4, T, Q>(v.y, v.x, v.w, v.x);
 
 1465         template<
typename T, qualifier Q>
 
 1466         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxwy(
const glm::vec<4, T, Q> &v) {
 
 1467                 return glm::vec<4, T, Q>(v.y, v.x, v.w, v.y);
 
 1471         template<
typename T, qualifier Q>
 
 1472         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxwz(
const glm::vec<4, T, Q> &v) {
 
 1473                 return glm::vec<4, T, Q>(v.y, v.x, v.w, v.z);
 
 1477         template<
typename T, qualifier Q>
 
 1478         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yxww(
const glm::vec<4, T, Q> &v) {
 
 1479                 return glm::vec<4, T, Q>(v.y, v.x, v.w, v.w);
 
 1483         template<
typename T, qualifier Q>
 
 1484         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxx(
const glm::vec<2, T, Q> &v) {
 
 1485                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
 
 1488         template<
typename T, qualifier Q>
 
 1489         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxx(
const glm::vec<3, T, Q> &v) {
 
 1490                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
 
 1493         template<
typename T, qualifier Q>
 
 1494         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxx(
const glm::vec<4, T, Q> &v) {
 
 1495                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.x);
 
 1499         template<
typename T, qualifier Q>
 
 1500         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxy(
const glm::vec<2, T, Q> &v) {
 
 1501                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
 
 1504         template<
typename T, qualifier Q>
 
 1505         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxy(
const glm::vec<3, T, Q> &v) {
 
 1506                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
 
 1509         template<
typename T, qualifier Q>
 
 1510         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxy(
const glm::vec<4, T, Q> &v) {
 
 1511                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.y);
 
 1515         template<
typename T, qualifier Q>
 
 1516         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxz(
const glm::vec<3, T, Q> &v) {
 
 1517                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
 
 1520         template<
typename T, qualifier Q>
 
 1521         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxz(
const glm::vec<4, T, Q> &v) {
 
 1522                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.z);
 
 1526         template<
typename T, qualifier Q>
 
 1527         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyxw(
const glm::vec<4, T, Q> &v) {
 
 1528                 return glm::vec<4, T, Q>(v.y, v.y, v.x, v.w);
 
 1532         template<
typename T, qualifier Q>
 
 1533         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyx(
const glm::vec<2, T, Q> &v) {
 
 1534                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
 
 1537         template<
typename T, qualifier Q>
 
 1538         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyx(
const glm::vec<3, T, Q> &v) {
 
 1539                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
 
 1542         template<
typename T, qualifier Q>
 
 1543         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyx(
const glm::vec<4, T, Q> &v) {
 
 1544                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.x);
 
 1548         template<
typename T, qualifier Q>
 
 1549         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyy(
const glm::vec<2, T, Q> &v) {
 
 1550                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
 
 1553         template<
typename T, qualifier Q>
 
 1554         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyy(
const glm::vec<3, T, Q> &v) {
 
 1555                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
 
 1558         template<
typename T, qualifier Q>
 
 1559         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyy(
const glm::vec<4, T, Q> &v) {
 
 1560                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.y);
 
 1564         template<
typename T, qualifier Q>
 
 1565         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyz(
const glm::vec<3, T, Q> &v) {
 
 1566                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
 
 1569         template<
typename T, qualifier Q>
 
 1570         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyz(
const glm::vec<4, T, Q> &v) {
 
 1571                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.z);
 
 1575         template<
typename T, qualifier Q>
 
 1576         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyyw(
const glm::vec<4, T, Q> &v) {
 
 1577                 return glm::vec<4, T, Q>(v.y, v.y, v.y, v.w);
 
 1581         template<
typename T, qualifier Q>
 
 1582         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzx(
const glm::vec<3, T, Q> &v) {
 
 1583                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
 
 1586         template<
typename T, qualifier Q>
 
 1587         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzx(
const glm::vec<4, T, Q> &v) {
 
 1588                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.x);
 
 1592         template<
typename T, qualifier Q>
 
 1593         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzy(
const glm::vec<3, T, Q> &v) {
 
 1594                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
 
 1597         template<
typename T, qualifier Q>
 
 1598         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzy(
const glm::vec<4, T, Q> &v) {
 
 1599                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.y);
 
 1603         template<
typename T, qualifier Q>
 
 1604         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzz(
const glm::vec<3, T, Q> &v) {
 
 1605                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
 
 1608         template<
typename T, qualifier Q>
 
 1609         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzz(
const glm::vec<4, T, Q> &v) {
 
 1610                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.z);
 
 1614         template<
typename T, qualifier Q>
 
 1615         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyzw(
const glm::vec<4, T, Q> &v) {
 
 1616                 return glm::vec<4, T, Q>(v.y, v.y, v.z, v.w);
 
 1620         template<
typename T, qualifier Q>
 
 1621         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yywx(
const glm::vec<4, T, Q> &v) {
 
 1622                 return glm::vec<4, T, Q>(v.y, v.y, v.w, v.x);
 
 1626         template<
typename T, qualifier Q>
 
 1627         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yywy(
const glm::vec<4, T, Q> &v) {
 
 1628                 return glm::vec<4, T, Q>(v.y, v.y, v.w, v.y);
 
 1632         template<
typename T, qualifier Q>
 
 1633         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yywz(
const glm::vec<4, T, Q> &v) {
 
 1634                 return glm::vec<4, T, Q>(v.y, v.y, v.w, v.z);
 
 1638         template<
typename T, qualifier Q>
 
 1639         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yyww(
const glm::vec<4, T, Q> &v) {
 
 1640                 return glm::vec<4, T, Q>(v.y, v.y, v.w, v.w);
 
 1644         template<
typename T, qualifier Q>
 
 1645         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxx(
const glm::vec<3, T, Q> &v) {
 
 1646                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
 
 1649         template<
typename T, qualifier Q>
 
 1650         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxx(
const glm::vec<4, T, Q> &v) {
 
 1651                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.x);
 
 1655         template<
typename T, qualifier Q>
 
 1656         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxy(
const glm::vec<3, T, Q> &v) {
 
 1657                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
 
 1660         template<
typename T, qualifier Q>
 
 1661         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxy(
const glm::vec<4, T, Q> &v) {
 
 1662                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.y);
 
 1666         template<
typename T, qualifier Q>
 
 1667         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxz(
const glm::vec<3, T, Q> &v) {
 
 1668                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
 
 1671         template<
typename T, qualifier Q>
 
 1672         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxz(
const glm::vec<4, T, Q> &v) {
 
 1673                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.z);
 
 1677         template<
typename T, qualifier Q>
 
 1678         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzxw(
const glm::vec<4, T, Q> &v) {
 
 1679                 return glm::vec<4, T, Q>(v.y, v.z, v.x, v.w);
 
 1683         template<
typename T, qualifier Q>
 
 1684         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyx(
const glm::vec<3, T, Q> &v) {
 
 1685                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
 
 1688         template<
typename T, qualifier Q>
 
 1689         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyx(
const glm::vec<4, T, Q> &v) {
 
 1690                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.x);
 
 1694         template<
typename T, qualifier Q>
 
 1695         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyy(
const glm::vec<3, T, Q> &v) {
 
 1696                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
 
 1699         template<
typename T, qualifier Q>
 
 1700         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyy(
const glm::vec<4, T, Q> &v) {
 
 1701                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.y);
 
 1705         template<
typename T, qualifier Q>
 
 1706         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyz(
const glm::vec<3, T, Q> &v) {
 
 1707                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
 
 1710         template<
typename T, qualifier Q>
 
 1711         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyz(
const glm::vec<4, T, Q> &v) {
 
 1712                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.z);
 
 1716         template<
typename T, qualifier Q>
 
 1717         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzyw(
const glm::vec<4, T, Q> &v) {
 
 1718                 return glm::vec<4, T, Q>(v.y, v.z, v.y, v.w);
 
 1722         template<
typename T, qualifier Q>
 
 1723         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzx(
const glm::vec<3, T, Q> &v) {
 
 1724                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
 
 1727         template<
typename T, qualifier Q>
 
 1728         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzx(
const glm::vec<4, T, Q> &v) {
 
 1729                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.x);
 
 1733         template<
typename T, qualifier Q>
 
 1734         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzy(
const glm::vec<3, T, Q> &v) {
 
 1735                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
 
 1738         template<
typename T, qualifier Q>
 
 1739         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzy(
const glm::vec<4, T, Q> &v) {
 
 1740                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.y);
 
 1744         template<
typename T, qualifier Q>
 
 1745         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzz(
const glm::vec<3, T, Q> &v) {
 
 1746                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
 
 1749         template<
typename T, qualifier Q>
 
 1750         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzz(
const glm::vec<4, T, Q> &v) {
 
 1751                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.z);
 
 1755         template<
typename T, qualifier Q>
 
 1756         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzzw(
const glm::vec<4, T, Q> &v) {
 
 1757                 return glm::vec<4, T, Q>(v.y, v.z, v.z, v.w);
 
 1761         template<
typename T, qualifier Q>
 
 1762         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzwx(
const glm::vec<4, T, Q> &v) {
 
 1763                 return glm::vec<4, T, Q>(v.y, v.z, v.w, v.x);
 
 1767         template<
typename T, qualifier Q>
 
 1768         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzwy(
const glm::vec<4, T, Q> &v) {
 
 1769                 return glm::vec<4, T, Q>(v.y, v.z, v.w, v.y);
 
 1773         template<
typename T, qualifier Q>
 
 1774         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzwz(
const glm::vec<4, T, Q> &v) {
 
 1775                 return glm::vec<4, T, Q>(v.y, v.z, v.w, v.z);
 
 1779         template<
typename T, qualifier Q>
 
 1780         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> yzww(
const glm::vec<4, T, Q> &v) {
 
 1781                 return glm::vec<4, T, Q>(v.y, v.z, v.w, v.w);
 
 1785         template<
typename T, qualifier Q>
 
 1786         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywxx(
const glm::vec<4, T, Q> &v) {
 
 1787                 return glm::vec<4, T, Q>(v.y, v.w, v.x, v.x);
 
 1791         template<
typename T, qualifier Q>
 
 1792         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywxy(
const glm::vec<4, T, Q> &v) {
 
 1793                 return glm::vec<4, T, Q>(v.y, v.w, v.x, v.y);
 
 1797         template<
typename T, qualifier Q>
 
 1798         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywxz(
const glm::vec<4, T, Q> &v) {
 
 1799                 return glm::vec<4, T, Q>(v.y, v.w, v.x, v.z);
 
 1803         template<
typename T, qualifier Q>
 
 1804         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywxw(
const glm::vec<4, T, Q> &v) {
 
 1805                 return glm::vec<4, T, Q>(v.y, v.w, v.x, v.w);
 
 1809         template<
typename T, qualifier Q>
 
 1810         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywyx(
const glm::vec<4, T, Q> &v) {
 
 1811                 return glm::vec<4, T, Q>(v.y, v.w, v.y, v.x);
 
 1815         template<
typename T, qualifier Q>
 
 1816         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywyy(
const glm::vec<4, T, Q> &v) {
 
 1817                 return glm::vec<4, T, Q>(v.y, v.w, v.y, v.y);
 
 1821         template<
typename T, qualifier Q>
 
 1822         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywyz(
const glm::vec<4, T, Q> &v) {
 
 1823                 return glm::vec<4, T, Q>(v.y, v.w, v.y, v.z);
 
 1827         template<
typename T, qualifier Q>
 
 1828         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywyw(
const glm::vec<4, T, Q> &v) {
 
 1829                 return glm::vec<4, T, Q>(v.y, v.w, v.y, v.w);
 
 1833         template<
typename T, qualifier Q>
 
 1834         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywzx(
const glm::vec<4, T, Q> &v) {
 
 1835                 return glm::vec<4, T, Q>(v.y, v.w, v.z, v.x);
 
 1839         template<
typename T, qualifier Q>
 
 1840         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywzy(
const glm::vec<4, T, Q> &v) {
 
 1841                 return glm::vec<4, T, Q>(v.y, v.w, v.z, v.y);
 
 1845         template<
typename T, qualifier Q>
 
 1846         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywzz(
const glm::vec<4, T, Q> &v) {
 
 1847                 return glm::vec<4, T, Q>(v.y, v.w, v.z, v.z);
 
 1851         template<
typename T, qualifier Q>
 
 1852         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywzw(
const glm::vec<4, T, Q> &v) {
 
 1853                 return glm::vec<4, T, Q>(v.y, v.w, v.z, v.w);
 
 1857         template<
typename T, qualifier Q>
 
 1858         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywwx(
const glm::vec<4, T, Q> &v) {
 
 1859                 return glm::vec<4, T, Q>(v.y, v.w, v.w, v.x);
 
 1863         template<
typename T, qualifier Q>
 
 1864         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywwy(
const glm::vec<4, T, Q> &v) {
 
 1865                 return glm::vec<4, T, Q>(v.y, v.w, v.w, v.y);
 
 1869         template<
typename T, qualifier Q>
 
 1870         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywwz(
const glm::vec<4, T, Q> &v) {
 
 1871                 return glm::vec<4, T, Q>(v.y, v.w, v.w, v.z);
 
 1875         template<
typename T, qualifier Q>
 
 1876         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> ywww(
const glm::vec<4, T, Q> &v) {
 
 1877                 return glm::vec<4, T, Q>(v.y, v.w, v.w, v.w);
 
 1881         template<
typename T, qualifier Q>
 
 1882         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxx(
const glm::vec<3, T, Q> &v) {
 
 1883                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
 
 1886         template<
typename T, qualifier Q>
 
 1887         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxx(
const glm::vec<4, T, Q> &v) {
 
 1888                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.x);
 
 1892         template<
typename T, qualifier Q>
 
 1893         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxy(
const glm::vec<3, T, Q> &v) {
 
 1894                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
 
 1897         template<
typename T, qualifier Q>
 
 1898         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxy(
const glm::vec<4, T, Q> &v) {
 
 1899                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.y);
 
 1903         template<
typename T, qualifier Q>
 
 1904         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxz(
const glm::vec<3, T, Q> &v) {
 
 1905                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
 
 1908         template<
typename T, qualifier Q>
 
 1909         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxz(
const glm::vec<4, T, Q> &v) {
 
 1910                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.z);
 
 1914         template<
typename T, qualifier Q>
 
 1915         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxxw(
const glm::vec<4, T, Q> &v) {
 
 1916                 return glm::vec<4, T, Q>(v.z, v.x, v.x, v.w);
 
 1920         template<
typename T, qualifier Q>
 
 1921         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyx(
const glm::vec<3, T, Q> &v) {
 
 1922                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
 
 1925         template<
typename T, qualifier Q>
 
 1926         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyx(
const glm::vec<4, T, Q> &v) {
 
 1927                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.x);
 
 1931         template<
typename T, qualifier Q>
 
 1932         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyy(
const glm::vec<3, T, Q> &v) {
 
 1933                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
 
 1936         template<
typename T, qualifier Q>
 
 1937         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyy(
const glm::vec<4, T, Q> &v) {
 
 1938                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.y);
 
 1942         template<
typename T, qualifier Q>
 
 1943         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyz(
const glm::vec<3, T, Q> &v) {
 
 1944                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
 
 1947         template<
typename T, qualifier Q>
 
 1948         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyz(
const glm::vec<4, T, Q> &v) {
 
 1949                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.z);
 
 1953         template<
typename T, qualifier Q>
 
 1954         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxyw(
const glm::vec<4, T, Q> &v) {
 
 1955                 return glm::vec<4, T, Q>(v.z, v.x, v.y, v.w);
 
 1959         template<
typename T, qualifier Q>
 
 1960         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzx(
const glm::vec<3, T, Q> &v) {
 
 1961                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
 
 1964         template<
typename T, qualifier Q>
 
 1965         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzx(
const glm::vec<4, T, Q> &v) {
 
 1966                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.x);
 
 1970         template<
typename T, qualifier Q>
 
 1971         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzy(
const glm::vec<3, T, Q> &v) {
 
 1972                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
 
 1975         template<
typename T, qualifier Q>
 
 1976         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzy(
const glm::vec<4, T, Q> &v) {
 
 1977                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.y);
 
 1981         template<
typename T, qualifier Q>
 
 1982         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzz(
const glm::vec<3, T, Q> &v) {
 
 1983                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
 
 1986         template<
typename T, qualifier Q>
 
 1987         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzz(
const glm::vec<4, T, Q> &v) {
 
 1988                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.z);
 
 1992         template<
typename T, qualifier Q>
 
 1993         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxzw(
const glm::vec<4, T, Q> &v) {
 
 1994                 return glm::vec<4, T, Q>(v.z, v.x, v.z, v.w);
 
 1998         template<
typename T, qualifier Q>
 
 1999         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxwx(
const glm::vec<4, T, Q> &v) {
 
 2000                 return glm::vec<4, T, Q>(v.z, v.x, v.w, v.x);
 
 2004         template<
typename T, qualifier Q>
 
 2005         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxwy(
const glm::vec<4, T, Q> &v) {
 
 2006                 return glm::vec<4, T, Q>(v.z, v.x, v.w, v.y);
 
 2010         template<
typename T, qualifier Q>
 
 2011         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxwz(
const glm::vec<4, T, Q> &v) {
 
 2012                 return glm::vec<4, T, Q>(v.z, v.x, v.w, v.z);
 
 2016         template<
typename T, qualifier Q>
 
 2017         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zxww(
const glm::vec<4, T, Q> &v) {
 
 2018                 return glm::vec<4, T, Q>(v.z, v.x, v.w, v.w);
 
 2022         template<
typename T, qualifier Q>
 
 2023         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxx(
const glm::vec<3, T, Q> &v) {
 
 2024                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
 
 2027         template<
typename T, qualifier Q>
 
 2028         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxx(
const glm::vec<4, T, Q> &v) {
 
 2029                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.x);
 
 2033         template<
typename T, qualifier Q>
 
 2034         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxy(
const glm::vec<3, T, Q> &v) {
 
 2035                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
 
 2038         template<
typename T, qualifier Q>
 
 2039         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxy(
const glm::vec<4, T, Q> &v) {
 
 2040                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.y);
 
 2044         template<
typename T, qualifier Q>
 
 2045         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxz(
const glm::vec<3, T, Q> &v) {
 
 2046                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
 
 2049         template<
typename T, qualifier Q>
 
 2050         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxz(
const glm::vec<4, T, Q> &v) {
 
 2051                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.z);
 
 2055         template<
typename T, qualifier Q>
 
 2056         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyxw(
const glm::vec<4, T, Q> &v) {
 
 2057                 return glm::vec<4, T, Q>(v.z, v.y, v.x, v.w);
 
 2061         template<
typename T, qualifier Q>
 
 2062         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyx(
const glm::vec<3, T, Q> &v) {
 
 2063                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
 
 2066         template<
typename T, qualifier Q>
 
 2067         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyx(
const glm::vec<4, T, Q> &v) {
 
 2068                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.x);
 
 2072         template<
typename T, qualifier Q>
 
 2073         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyy(
const glm::vec<3, T, Q> &v) {
 
 2074                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
 
 2077         template<
typename T, qualifier Q>
 
 2078         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyy(
const glm::vec<4, T, Q> &v) {
 
 2079                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.y);
 
 2083         template<
typename T, qualifier Q>
 
 2084         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyz(
const glm::vec<3, T, Q> &v) {
 
 2085                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
 
 2088         template<
typename T, qualifier Q>
 
 2089         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyz(
const glm::vec<4, T, Q> &v) {
 
 2090                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.z);
 
 2094         template<
typename T, qualifier Q>
 
 2095         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyyw(
const glm::vec<4, T, Q> &v) {
 
 2096                 return glm::vec<4, T, Q>(v.z, v.y, v.y, v.w);
 
 2100         template<
typename T, qualifier Q>
 
 2101         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzx(
const glm::vec<3, T, Q> &v) {
 
 2102                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
 
 2105         template<
typename T, qualifier Q>
 
 2106         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzx(
const glm::vec<4, T, Q> &v) {
 
 2107                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.x);
 
 2111         template<
typename T, qualifier Q>
 
 2112         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzy(
const glm::vec<3, T, Q> &v) {
 
 2113                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
 
 2116         template<
typename T, qualifier Q>
 
 2117         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzy(
const glm::vec<4, T, Q> &v) {
 
 2118                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.y);
 
 2122         template<
typename T, qualifier Q>
 
 2123         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzz(
const glm::vec<3, T, Q> &v) {
 
 2124                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
 
 2127         template<
typename T, qualifier Q>
 
 2128         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzz(
const glm::vec<4, T, Q> &v) {
 
 2129                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.z);
 
 2133         template<
typename T, qualifier Q>
 
 2134         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyzw(
const glm::vec<4, T, Q> &v) {
 
 2135                 return glm::vec<4, T, Q>(v.z, v.y, v.z, v.w);
 
 2139         template<
typename T, qualifier Q>
 
 2140         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zywx(
const glm::vec<4, T, Q> &v) {
 
 2141                 return glm::vec<4, T, Q>(v.z, v.y, v.w, v.x);
 
 2145         template<
typename T, qualifier Q>
 
 2146         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zywy(
const glm::vec<4, T, Q> &v) {
 
 2147                 return glm::vec<4, T, Q>(v.z, v.y, v.w, v.y);
 
 2151         template<
typename T, qualifier Q>
 
 2152         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zywz(
const glm::vec<4, T, Q> &v) {
 
 2153                 return glm::vec<4, T, Q>(v.z, v.y, v.w, v.z);
 
 2157         template<
typename T, qualifier Q>
 
 2158         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zyww(
const glm::vec<4, T, Q> &v) {
 
 2159                 return glm::vec<4, T, Q>(v.z, v.y, v.w, v.w);
 
 2163         template<
typename T, qualifier Q>
 
 2164         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxx(
const glm::vec<3, T, Q> &v) {
 
 2165                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
 
 2168         template<
typename T, qualifier Q>
 
 2169         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxx(
const glm::vec<4, T, Q> &v) {
 
 2170                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.x);
 
 2174         template<
typename T, qualifier Q>
 
 2175         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxy(
const glm::vec<3, T, Q> &v) {
 
 2176                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
 
 2179         template<
typename T, qualifier Q>
 
 2180         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxy(
const glm::vec<4, T, Q> &v) {
 
 2181                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.y);
 
 2185         template<
typename T, qualifier Q>
 
 2186         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxz(
const glm::vec<3, T, Q> &v) {
 
 2187                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
 
 2190         template<
typename T, qualifier Q>
 
 2191         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxz(
const glm::vec<4, T, Q> &v) {
 
 2192                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.z);
 
 2196         template<
typename T, qualifier Q>
 
 2197         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzxw(
const glm::vec<4, T, Q> &v) {
 
 2198                 return glm::vec<4, T, Q>(v.z, v.z, v.x, v.w);
 
 2202         template<
typename T, qualifier Q>
 
 2203         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyx(
const glm::vec<3, T, Q> &v) {
 
 2204                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
 
 2207         template<
typename T, qualifier Q>
 
 2208         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyx(
const glm::vec<4, T, Q> &v) {
 
 2209                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.x);
 
 2213         template<
typename T, qualifier Q>
 
 2214         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyy(
const glm::vec<3, T, Q> &v) {
 
 2215                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
 
 2218         template<
typename T, qualifier Q>
 
 2219         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyy(
const glm::vec<4, T, Q> &v) {
 
 2220                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.y);
 
 2224         template<
typename T, qualifier Q>
 
 2225         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyz(
const glm::vec<3, T, Q> &v) {
 
 2226                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
 
 2229         template<
typename T, qualifier Q>
 
 2230         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyz(
const glm::vec<4, T, Q> &v) {
 
 2231                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.z);
 
 2235         template<
typename T, qualifier Q>
 
 2236         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzyw(
const glm::vec<4, T, Q> &v) {
 
 2237                 return glm::vec<4, T, Q>(v.z, v.z, v.y, v.w);
 
 2241         template<
typename T, qualifier Q>
 
 2242         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzx(
const glm::vec<3, T, Q> &v) {
 
 2243                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
 
 2246         template<
typename T, qualifier Q>
 
 2247         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzx(
const glm::vec<4, T, Q> &v) {
 
 2248                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.x);
 
 2252         template<
typename T, qualifier Q>
 
 2253         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzy(
const glm::vec<3, T, Q> &v) {
 
 2254                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
 
 2257         template<
typename T, qualifier Q>
 
 2258         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzy(
const glm::vec<4, T, Q> &v) {
 
 2259                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.y);
 
 2263         template<
typename T, qualifier Q>
 
 2264         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzz(
const glm::vec<3, T, Q> &v) {
 
 2265                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
 
 2268         template<
typename T, qualifier Q>
 
 2269         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzz(
const glm::vec<4, T, Q> &v) {
 
 2270                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.z);
 
 2274         template<
typename T, qualifier Q>
 
 2275         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzzw(
const glm::vec<4, T, Q> &v) {
 
 2276                 return glm::vec<4, T, Q>(v.z, v.z, v.z, v.w);
 
 2280         template<
typename T, qualifier Q>
 
 2281         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzwx(
const glm::vec<4, T, Q> &v) {
 
 2282                 return glm::vec<4, T, Q>(v.z, v.z, v.w, v.x);
 
 2286         template<
typename T, qualifier Q>
 
 2287         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzwy(
const glm::vec<4, T, Q> &v) {
 
 2288                 return glm::vec<4, T, Q>(v.z, v.z, v.w, v.y);
 
 2292         template<
typename T, qualifier Q>
 
 2293         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzwz(
const glm::vec<4, T, Q> &v) {
 
 2294                 return glm::vec<4, T, Q>(v.z, v.z, v.w, v.z);
 
 2298         template<
typename T, qualifier Q>
 
 2299         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zzww(
const glm::vec<4, T, Q> &v) {
 
 2300                 return glm::vec<4, T, Q>(v.z, v.z, v.w, v.w);
 
 2304         template<
typename T, qualifier Q>
 
 2305         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwxx(
const glm::vec<4, T, Q> &v) {
 
 2306                 return glm::vec<4, T, Q>(v.z, v.w, v.x, v.x);
 
 2310         template<
typename T, qualifier Q>
 
 2311         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwxy(
const glm::vec<4, T, Q> &v) {
 
 2312                 return glm::vec<4, T, Q>(v.z, v.w, v.x, v.y);
 
 2316         template<
typename T, qualifier Q>
 
 2317         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwxz(
const glm::vec<4, T, Q> &v) {
 
 2318                 return glm::vec<4, T, Q>(v.z, v.w, v.x, v.z);
 
 2322         template<
typename T, qualifier Q>
 
 2323         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwxw(
const glm::vec<4, T, Q> &v) {
 
 2324                 return glm::vec<4, T, Q>(v.z, v.w, v.x, v.w);
 
 2328         template<
typename T, qualifier Q>
 
 2329         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwyx(
const glm::vec<4, T, Q> &v) {
 
 2330                 return glm::vec<4, T, Q>(v.z, v.w, v.y, v.x);
 
 2334         template<
typename T, qualifier Q>
 
 2335         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwyy(
const glm::vec<4, T, Q> &v) {
 
 2336                 return glm::vec<4, T, Q>(v.z, v.w, v.y, v.y);
 
 2340         template<
typename T, qualifier Q>
 
 2341         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwyz(
const glm::vec<4, T, Q> &v) {
 
 2342                 return glm::vec<4, T, Q>(v.z, v.w, v.y, v.z);
 
 2346         template<
typename T, qualifier Q>
 
 2347         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwyw(
const glm::vec<4, T, Q> &v) {
 
 2348                 return glm::vec<4, T, Q>(v.z, v.w, v.y, v.w);
 
 2352         template<
typename T, qualifier Q>
 
 2353         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwzx(
const glm::vec<4, T, Q> &v) {
 
 2354                 return glm::vec<4, T, Q>(v.z, v.w, v.z, v.x);
 
 2358         template<
typename T, qualifier Q>
 
 2359         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwzy(
const glm::vec<4, T, Q> &v) {
 
 2360                 return glm::vec<4, T, Q>(v.z, v.w, v.z, v.y);
 
 2364         template<
typename T, qualifier Q>
 
 2365         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwzz(
const glm::vec<4, T, Q> &v) {
 
 2366                 return glm::vec<4, T, Q>(v.z, v.w, v.z, v.z);
 
 2370         template<
typename T, qualifier Q>
 
 2371         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwzw(
const glm::vec<4, T, Q> &v) {
 
 2372                 return glm::vec<4, T, Q>(v.z, v.w, v.z, v.w);
 
 2376         template<
typename T, qualifier Q>
 
 2377         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwwx(
const glm::vec<4, T, Q> &v) {
 
 2378                 return glm::vec<4, T, Q>(v.z, v.w, v.w, v.x);
 
 2382         template<
typename T, qualifier Q>
 
 2383         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwwy(
const glm::vec<4, T, Q> &v) {
 
 2384                 return glm::vec<4, T, Q>(v.z, v.w, v.w, v.y);
 
 2388         template<
typename T, qualifier Q>
 
 2389         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwwz(
const glm::vec<4, T, Q> &v) {
 
 2390                 return glm::vec<4, T, Q>(v.z, v.w, v.w, v.z);
 
 2394         template<
typename T, qualifier Q>
 
 2395         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> zwww(
const glm::vec<4, T, Q> &v) {
 
 2396                 return glm::vec<4, T, Q>(v.z, v.w, v.w, v.w);
 
 2400         template<
typename T, qualifier Q>
 
 2401         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxxx(
const glm::vec<4, T, Q> &v) {
 
 2402                 return glm::vec<4, T, Q>(v.w, v.x, v.x, v.x);
 
 2406         template<
typename T, qualifier Q>
 
 2407         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxxy(
const glm::vec<4, T, Q> &v) {
 
 2408                 return glm::vec<4, T, Q>(v.w, v.x, v.x, v.y);
 
 2412         template<
typename T, qualifier Q>
 
 2413         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxxz(
const glm::vec<4, T, Q> &v) {
 
 2414                 return glm::vec<4, T, Q>(v.w, v.x, v.x, v.z);
 
 2418         template<
typename T, qualifier Q>
 
 2419         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxxw(
const glm::vec<4, T, Q> &v) {
 
 2420                 return glm::vec<4, T, Q>(v.w, v.x, v.x, v.w);
 
 2424         template<
typename T, qualifier Q>
 
 2425         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxyx(
const glm::vec<4, T, Q> &v) {
 
 2426                 return glm::vec<4, T, Q>(v.w, v.x, v.y, v.x);
 
 2430         template<
typename T, qualifier Q>
 
 2431         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxyy(
const glm::vec<4, T, Q> &v) {
 
 2432                 return glm::vec<4, T, Q>(v.w, v.x, v.y, v.y);
 
 2436         template<
typename T, qualifier Q>
 
 2437         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxyz(
const glm::vec<4, T, Q> &v) {
 
 2438                 return glm::vec<4, T, Q>(v.w, v.x, v.y, v.z);
 
 2442         template<
typename T, qualifier Q>
 
 2443         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxyw(
const glm::vec<4, T, Q> &v) {
 
 2444                 return glm::vec<4, T, Q>(v.w, v.x, v.y, v.w);
 
 2448         template<
typename T, qualifier Q>
 
 2449         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxzx(
const glm::vec<4, T, Q> &v) {
 
 2450                 return glm::vec<4, T, Q>(v.w, v.x, v.z, v.x);
 
 2454         template<
typename T, qualifier Q>
 
 2455         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxzy(
const glm::vec<4, T, Q> &v) {
 
 2456                 return glm::vec<4, T, Q>(v.w, v.x, v.z, v.y);
 
 2460         template<
typename T, qualifier Q>
 
 2461         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxzz(
const glm::vec<4, T, Q> &v) {
 
 2462                 return glm::vec<4, T, Q>(v.w, v.x, v.z, v.z);
 
 2466         template<
typename T, qualifier Q>
 
 2467         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxzw(
const glm::vec<4, T, Q> &v) {
 
 2468                 return glm::vec<4, T, Q>(v.w, v.x, v.z, v.w);
 
 2472         template<
typename T, qualifier Q>
 
 2473         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxwx(
const glm::vec<4, T, Q> &v) {
 
 2474                 return glm::vec<4, T, Q>(v.w, v.x, v.w, v.x);
 
 2478         template<
typename T, qualifier Q>
 
 2479         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxwy(
const glm::vec<4, T, Q> &v) {
 
 2480                 return glm::vec<4, T, Q>(v.w, v.x, v.w, v.y);
 
 2484         template<
typename T, qualifier Q>
 
 2485         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxwz(
const glm::vec<4, T, Q> &v) {
 
 2486                 return glm::vec<4, T, Q>(v.w, v.x, v.w, v.z);
 
 2490         template<
typename T, qualifier Q>
 
 2491         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wxww(
const glm::vec<4, T, Q> &v) {
 
 2492                 return glm::vec<4, T, Q>(v.w, v.x, v.w, v.w);
 
 2496         template<
typename T, qualifier Q>
 
 2497         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyxx(
const glm::vec<4, T, Q> &v) {
 
 2498                 return glm::vec<4, T, Q>(v.w, v.y, v.x, v.x);
 
 2502         template<
typename T, qualifier Q>
 
 2503         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyxy(
const glm::vec<4, T, Q> &v) {
 
 2504                 return glm::vec<4, T, Q>(v.w, v.y, v.x, v.y);
 
 2508         template<
typename T, qualifier Q>
 
 2509         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyxz(
const glm::vec<4, T, Q> &v) {
 
 2510                 return glm::vec<4, T, Q>(v.w, v.y, v.x, v.z);
 
 2514         template<
typename T, qualifier Q>
 
 2515         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyxw(
const glm::vec<4, T, Q> &v) {
 
 2516                 return glm::vec<4, T, Q>(v.w, v.y, v.x, v.w);
 
 2520         template<
typename T, qualifier Q>
 
 2521         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyyx(
const glm::vec<4, T, Q> &v) {
 
 2522                 return glm::vec<4, T, Q>(v.w, v.y, v.y, v.x);
 
 2526         template<
typename T, qualifier Q>
 
 2527         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyyy(
const glm::vec<4, T, Q> &v) {
 
 2528                 return glm::vec<4, T, Q>(v.w, v.y, v.y, v.y);
 
 2532         template<
typename T, qualifier Q>
 
 2533         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyyz(
const glm::vec<4, T, Q> &v) {
 
 2534                 return glm::vec<4, T, Q>(v.w, v.y, v.y, v.z);
 
 2538         template<
typename T, qualifier Q>
 
 2539         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyyw(
const glm::vec<4, T, Q> &v) {
 
 2540                 return glm::vec<4, T, Q>(v.w, v.y, v.y, v.w);
 
 2544         template<
typename T, qualifier Q>
 
 2545         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyzx(
const glm::vec<4, T, Q> &v) {
 
 2546                 return glm::vec<4, T, Q>(v.w, v.y, v.z, v.x);
 
 2550         template<
typename T, qualifier Q>
 
 2551         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyzy(
const glm::vec<4, T, Q> &v) {
 
 2552                 return glm::vec<4, T, Q>(v.w, v.y, v.z, v.y);
 
 2556         template<
typename T, qualifier Q>
 
 2557         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyzz(
const glm::vec<4, T, Q> &v) {
 
 2558                 return glm::vec<4, T, Q>(v.w, v.y, v.z, v.z);
 
 2562         template<
typename T, qualifier Q>
 
 2563         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyzw(
const glm::vec<4, T, Q> &v) {
 
 2564                 return glm::vec<4, T, Q>(v.w, v.y, v.z, v.w);
 
 2568         template<
typename T, qualifier Q>
 
 2569         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wywx(
const glm::vec<4, T, Q> &v) {
 
 2570                 return glm::vec<4, T, Q>(v.w, v.y, v.w, v.x);
 
 2574         template<
typename T, qualifier Q>
 
 2575         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wywy(
const glm::vec<4, T, Q> &v) {
 
 2576                 return glm::vec<4, T, Q>(v.w, v.y, v.w, v.y);
 
 2580         template<
typename T, qualifier Q>
 
 2581         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wywz(
const glm::vec<4, T, Q> &v) {
 
 2582                 return glm::vec<4, T, Q>(v.w, v.y, v.w, v.z);
 
 2586         template<
typename T, qualifier Q>
 
 2587         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wyww(
const glm::vec<4, T, Q> &v) {
 
 2588                 return glm::vec<4, T, Q>(v.w, v.y, v.w, v.w);
 
 2592         template<
typename T, qualifier Q>
 
 2593         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzxx(
const glm::vec<4, T, Q> &v) {
 
 2594                 return glm::vec<4, T, Q>(v.w, v.z, v.x, v.x);
 
 2598         template<
typename T, qualifier Q>
 
 2599         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzxy(
const glm::vec<4, T, Q> &v) {
 
 2600                 return glm::vec<4, T, Q>(v.w, v.z, v.x, v.y);
 
 2604         template<
typename T, qualifier Q>
 
 2605         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzxz(
const glm::vec<4, T, Q> &v) {
 
 2606                 return glm::vec<4, T, Q>(v.w, v.z, v.x, v.z);
 
 2610         template<
typename T, qualifier Q>
 
 2611         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzxw(
const glm::vec<4, T, Q> &v) {
 
 2612                 return glm::vec<4, T, Q>(v.w, v.z, v.x, v.w);
 
 2616         template<
typename T, qualifier Q>
 
 2617         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzyx(
const glm::vec<4, T, Q> &v) {
 
 2618                 return glm::vec<4, T, Q>(v.w, v.z, v.y, v.x);
 
 2622         template<
typename T, qualifier Q>
 
 2623         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzyy(
const glm::vec<4, T, Q> &v) {
 
 2624                 return glm::vec<4, T, Q>(v.w, v.z, v.y, v.y);
 
 2628         template<
typename T, qualifier Q>
 
 2629         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzyz(
const glm::vec<4, T, Q> &v) {
 
 2630                 return glm::vec<4, T, Q>(v.w, v.z, v.y, v.z);
 
 2634         template<
typename T, qualifier Q>
 
 2635         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzyw(
const glm::vec<4, T, Q> &v) {
 
 2636                 return glm::vec<4, T, Q>(v.w, v.z, v.y, v.w);
 
 2640         template<
typename T, qualifier Q>
 
 2641         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzzx(
const glm::vec<4, T, Q> &v) {
 
 2642                 return glm::vec<4, T, Q>(v.w, v.z, v.z, v.x);
 
 2646         template<
typename T, qualifier Q>
 
 2647         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzzy(
const glm::vec<4, T, Q> &v) {
 
 2648                 return glm::vec<4, T, Q>(v.w, v.z, v.z, v.y);
 
 2652         template<
typename T, qualifier Q>
 
 2653         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzzz(
const glm::vec<4, T, Q> &v) {
 
 2654                 return glm::vec<4, T, Q>(v.w, v.z, v.z, v.z);
 
 2658         template<
typename T, qualifier Q>
 
 2659         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzzw(
const glm::vec<4, T, Q> &v) {
 
 2660                 return glm::vec<4, T, Q>(v.w, v.z, v.z, v.w);
 
 2664         template<
typename T, qualifier Q>
 
 2665         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzwx(
const glm::vec<4, T, Q> &v) {
 
 2666                 return glm::vec<4, T, Q>(v.w, v.z, v.w, v.x);
 
 2670         template<
typename T, qualifier Q>
 
 2671         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzwy(
const glm::vec<4, T, Q> &v) {
 
 2672                 return glm::vec<4, T, Q>(v.w, v.z, v.w, v.y);
 
 2676         template<
typename T, qualifier Q>
 
 2677         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzwz(
const glm::vec<4, T, Q> &v) {
 
 2678                 return glm::vec<4, T, Q>(v.w, v.z, v.w, v.z);
 
 2682         template<
typename T, qualifier Q>
 
 2683         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wzww(
const glm::vec<4, T, Q> &v) {
 
 2684                 return glm::vec<4, T, Q>(v.w, v.z, v.w, v.w);
 
 2688         template<
typename T, qualifier Q>
 
 2689         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwxx(
const glm::vec<4, T, Q> &v) {
 
 2690                 return glm::vec<4, T, Q>(v.w, v.w, v.x, v.x);
 
 2694         template<
typename T, qualifier Q>
 
 2695         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwxy(
const glm::vec<4, T, Q> &v) {
 
 2696                 return glm::vec<4, T, Q>(v.w, v.w, v.x, v.y);
 
 2700         template<
typename T, qualifier Q>
 
 2701         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwxz(
const glm::vec<4, T, Q> &v) {
 
 2702                 return glm::vec<4, T, Q>(v.w, v.w, v.x, v.z);
 
 2706         template<
typename T, qualifier Q>
 
 2707         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwxw(
const glm::vec<4, T, Q> &v) {
 
 2708                 return glm::vec<4, T, Q>(v.w, v.w, v.x, v.w);
 
 2712         template<
typename T, qualifier Q>
 
 2713         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwyx(
const glm::vec<4, T, Q> &v) {
 
 2714                 return glm::vec<4, T, Q>(v.w, v.w, v.y, v.x);
 
 2718         template<
typename T, qualifier Q>
 
 2719         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwyy(
const glm::vec<4, T, Q> &v) {
 
 2720                 return glm::vec<4, T, Q>(v.w, v.w, v.y, v.y);
 
 2724         template<
typename T, qualifier Q>
 
 2725         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwyz(
const glm::vec<4, T, Q> &v) {
 
 2726                 return glm::vec<4, T, Q>(v.w, v.w, v.y, v.z);
 
 2730         template<
typename T, qualifier Q>
 
 2731         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwyw(
const glm::vec<4, T, Q> &v) {
 
 2732                 return glm::vec<4, T, Q>(v.w, v.w, v.y, v.w);
 
 2736         template<
typename T, qualifier Q>
 
 2737         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwzx(
const glm::vec<4, T, Q> &v) {
 
 2738                 return glm::vec<4, T, Q>(v.w, v.w, v.z, v.x);
 
 2742         template<
typename T, qualifier Q>
 
 2743         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwzy(
const glm::vec<4, T, Q> &v) {
 
 2744                 return glm::vec<4, T, Q>(v.w, v.w, v.z, v.y);
 
 2748         template<
typename T, qualifier Q>
 
 2749         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwzz(
const glm::vec<4, T, Q> &v) {
 
 2750                 return glm::vec<4, T, Q>(v.w, v.w, v.z, v.z);
 
 2754         template<
typename T, qualifier Q>
 
 2755         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwzw(
const glm::vec<4, T, Q> &v) {
 
 2756                 return glm::vec<4, T, Q>(v.w, v.w, v.z, v.w);
 
 2760         template<
typename T, qualifier Q>
 
 2761         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwwx(
const glm::vec<4, T, Q> &v) {
 
 2762                 return glm::vec<4, T, Q>(v.w, v.w, v.w, v.x);
 
 2766         template<
typename T, qualifier Q>
 
 2767         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwwy(
const glm::vec<4, T, Q> &v) {
 
 2768                 return glm::vec<4, T, Q>(v.w, v.w, v.w, v.y);
 
 2772         template<
typename T, qualifier Q>
 
 2773         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwwz(
const glm::vec<4, T, Q> &v) {
 
 2774                 return glm::vec<4, T, Q>(v.w, v.w, v.w, v.z);
 
 2778         template<
typename T, qualifier Q>
 
 2779         GLM_FUNC_QUALIFIER glm::vec<4, T, Q> wwww(
const glm::vec<4, T, Q> &v) {
 
 2780                 return glm::vec<4, T, Q>(v.w, v.w, v.w, v.w);