7 #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED 
    8 #       if GLM_HAS_UNRESTRICTED_UNIONS 
   18         template <
typename T, precision P = defaultp>
 
   24                 typedef tvec4<T, P> type;
 
   25                 typedef tvec4<bool, P> bool_type;
 
   29 #               if GLM_HAS_ALIGNED_TYPE 
   30 #                       if GLM_COMPILER & GLM_COMPILER_GCC 
   31 #                               pragma GCC diagnostic push 
   32 #                               pragma GCC diagnostic ignored "-Wpedantic" 
   34 #                       if GLM_COMPILER & GLM_COMPILER_CLANG 
   35 #                               pragma clang diagnostic push 
   36 #                               pragma clang diagnostic ignored "-Wgnu-anonymous-struct" 
   37 #                               pragma clang diagnostic ignored "-Wnested-anon-types" 
   42                                 struct { T x, y, z, w;};
 
   43                                 struct { T r, g, b, a; };
 
   44                                 struct { T s, t, p, q; };
 
   46                                 typename detail::storage<T, sizeof(T) * 4, detail::is_aligned<P>::value>::type data;
 
   48 #                               if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED 
   49                                         _GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, x, y, z, w)
 
   50                                         _GLM_SWIZZLE4_2_MEMBERS(T, P, 
glm::tvec2, r, g, b, a)
 
   51                                         _GLM_SWIZZLE4_2_MEMBERS(T, P, 
glm::tvec2, s, t, p, q)
 
   52                                         _GLM_SWIZZLE4_3_MEMBERS(T, P, 
glm::tvec3, x, y, z, w)
 
   53                                         _GLM_SWIZZLE4_3_MEMBERS(T, P, 
glm::tvec3, r, g, b, a)
 
   54                                         _GLM_SWIZZLE4_3_MEMBERS(T, P, 
glm::tvec3, s, t, p, q)
 
   55                                         _GLM_SWIZZLE4_4_MEMBERS(T, P, 
glm::tvec4, x, y, z, w)
 
   56                                         _GLM_SWIZZLE4_4_MEMBERS(T, P, 
glm::tvec4, r, g, b, a)
 
   57                                         _GLM_SWIZZLE4_4_MEMBERS(T, P, 
glm::tvec4, s, t, p, q)
 
   61 #                       if GLM_COMPILER & GLM_COMPILER_CLANG 
   62 #                               pragma clang diagnostic pop 
   64 #                       if GLM_COMPILER & GLM_COMPILER_GCC 
   65 #                               pragma GCC diagnostic pop 
   73 #                       if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED 
   74                                 GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
 
   81                 typedef length_t length_type;
 
   82                 GLM_FUNC_DECL 
static length_type 
length(){
return 4;}
 
   84                 GLM_FUNC_DECL T & operator[](length_type i);
 
   85                 GLM_FUNC_DECL T 
const & operator[](length_type i) 
const;
 
   89                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4() GLM_DEFAULT_CTOR;
 
   90                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(tvec4<T, P> const& v) GLM_DEFAULT;
 
   91                 template <precision Q>
 
   92                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(tvec4<T, Q> const& v);
 
   96                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec4(ctor);
 
   97                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD explicit tvec4(T scalar);
 
   98                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(T a, T b, T c, T d);
 
  103                 template <typename A, typename B, typename C, typename D>
 
  104                 GLM_FUNC_DECL GLM_CONSTEXPR_SIMD tvec4(A a, B b, C c, D d);
 
  105                 template <typename A, typename B, typename C, typename D>
 
  106                 GLM_FUNC_DECL GLM_CONSTEXPR_CTOR tvec4(tvec1<A, P> const& a, tvec1<B, P> const& b, tvec1<C, P> const& c, tvec1<D, P> const& d);
 
  111                 template <typename A, typename B, typename C, precision Q>
 
  112                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, B b, C c);
 
  114                 template <typename A, typename B, typename C, precision Q>
 
  115                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, tvec1<B, Q> const & b, tvec1<C, Q> const & c);
 
  117                 template <typename A, typename B, typename C, precision Q>
 
  118                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, tvec2<B, Q> const & b, C c);
 
  120                 template <typename A, typename B, typename C, precision Q>
 
  121                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec2<B, Q> const & b, tvec1<C, Q> const & c);
 
  123                 template <typename A, typename B, typename C, precision Q>
 
  124                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, B b, tvec2<C, Q> const & c);
 
  126                 template <typename A, typename B, typename C, precision Q>
 
  127                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec1<B, Q> const & b, tvec2<C, Q> const & c);
 
  129                 template <typename A, typename B, precision Q>
 
  130                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec3<A, Q> const & a, B b);
 
  132                 template <typename A, typename B, precision Q>
 
  133                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec3<A, Q> const & a, tvec1<B, Q> const & b);
 
  135                 template <typename A, typename B, precision Q>
 
  136                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(A a, tvec3<B, Q> const & b);
 
  138                 template <typename A, typename B, precision Q>
 
  139                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec1<A, Q> const & a, tvec3<B, Q> const & b);
 
  141                 template <typename A, typename B, precision Q>
 
  142                 GLM_FUNC_DECL GLM_CONSTEXPR tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b);
 
  145                 template <typename U, precision Q>
 
  146                 GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec4(tvec4<U, Q> const& v);
 
  149 #               if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) 
  150                         template <
int E0, 
int E1, 
int E2, 
int E3>
 
  151                         GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, glm::tvec4, E0, E1, E2, E3> 
const & that)
 
  156                         template <
int E0, 
int E1, 
int F0, 
int F1>
 
  157                         GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> 
const & v, detail::_swizzle<2, T, P, glm::tvec2, F0, F1, -1, -2> 
const & u)
 
  159                                 *
this = tvec4<T, P>(v(), u());
 
  162                         template <
int E0, 
int E1>
 
  163                         GLM_FUNC_DECL tvec4(T 
const & x, T 
const & y, detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> 
const & v)
 
  165                                 *
this = tvec4<T, P>(x, y, v());
 
  168                         template <
int E0, 
int E1>
 
  169                         GLM_FUNC_DECL tvec4(T 
const & x, detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> 
const & v, T 
const & w)
 
  171                                 *
this = tvec4<T, P>(x, v(), w);
 
  174                         template <
int E0, 
int E1>
 
  175                         GLM_FUNC_DECL tvec4(detail::_swizzle<2, T, P, glm::tvec2, E0, E1, -1, -2> 
const & v, T 
const & z, T 
const & w)
 
  177                                 *
this = tvec4<T, P>(v(), z, w);
 
  180                         template <
int E0, 
int E1, 
int E2>
 
  181                         GLM_FUNC_DECL tvec4(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> 
const & v, T 
const & w)
 
  183                                 *
this = tvec4<T, P>(v(), w);
 
  186                         template <
int E0, 
int E1, 
int E2>
 
  187                         GLM_FUNC_DECL tvec4(T 
const & x, detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> 
const & v)
 
  189                                 *
this = tvec4<T, P>(x, v());
 
  191 #               endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED) 
  195                 GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<T, P> 
const & v) GLM_DEFAULT;
 
  197                 template <
typename U>
 
  198                 GLM_FUNC_DECL tvec4<T, P> & operator=(tvec4<U, P> 
const & v);
 
  199                 template <
typename U>
 
  200                 GLM_FUNC_DECL tvec4<T, P> & operator+=(U scalar);
 
  201                 template <
typename U>
 
  202                 GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec1<U, P> 
const & v);
 
  203                 template <
typename U>
 
  204                 GLM_FUNC_DECL tvec4<T, P> & operator+=(tvec4<U, P> 
const & v);
 
  205                 template <
typename U>
 
  206                 GLM_FUNC_DECL tvec4<T, P> & operator-=(U scalar);
 
  207                 template <
typename U>
 
  208                 GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec1<U, P> 
const & v);
 
  209                 template <
typename U>
 
  210                 GLM_FUNC_DECL tvec4<T, P> & operator-=(tvec4<U, P> 
const & v);
 
  211                 template <
typename U>
 
  212                 GLM_FUNC_DECL tvec4<T, P> & operator*=(U scalar);
 
  213                 template <
typename U>
 
  214                 GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec1<U, P> 
const& v);
 
  215                 template <
typename U>
 
  216                 GLM_FUNC_DECL tvec4<T, P> & operator*=(tvec4<U, P> 
const& v);
 
  217                 template <
typename U>
 
  218                 GLM_FUNC_DECL tvec4<T, P> & operator/=(U scalar);
 
  219                 template <
typename U>
 
  220                 GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec1<U, P> 
const & v);
 
  221                 template <
typename U>
 
  222                 GLM_FUNC_DECL tvec4<T, P> & operator/=(tvec4<U, P> 
const & v);
 
  226                 GLM_FUNC_DECL tvec4<T, P> & operator++();
 
  227                 GLM_FUNC_DECL tvec4<T, P> & operator--();
 
  228                 GLM_FUNC_DECL tvec4<T, P> operator++(
int);
 
  229                 GLM_FUNC_DECL tvec4<T, P> operator--(
int);
 
  233                 template <
typename U>
 
  234                 GLM_FUNC_DECL tvec4<T, P> & operator%=(U scalar);
 
  235                 template <
typename U>
 
  236                 GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec1<U, P> 
const & v);
 
  237                 template <
typename U>
 
  238                 GLM_FUNC_DECL tvec4<T, P> & operator%=(tvec4<U, P> 
const & v);
 
  239                 template <
typename U>
 
  240                 GLM_FUNC_DECL tvec4<T, P> & operator&=(U scalar);
 
  241                 template <
typename U>
 
  242                 GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec1<U, P> 
const & v);
 
  243                 template <
typename U>
 
  244                 GLM_FUNC_DECL tvec4<T, P> & operator&=(tvec4<U, P> 
const & v);
 
  245                 template <
typename U>
 
  246                 GLM_FUNC_DECL tvec4<T, P> & operator|=(U scalar);
 
  247                 template <
typename U>
 
  248                 GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec1<U, P> 
const & v);
 
  249                 template <
typename U>
 
  250                 GLM_FUNC_DECL tvec4<T, P> & operator|=(tvec4<U, P> 
const & v);
 
  251                 template <
typename U>
 
  252                 GLM_FUNC_DECL tvec4<T, P> & operator^=(U scalar);
 
  253                 template <
typename U>
 
  254                 GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec1<U, P> 
const & v);
 
  255                 template <
typename U>
 
  256                 GLM_FUNC_DECL tvec4<T, P> & operator^=(tvec4<U, P> 
const & v);
 
  257                 template <
typename U>
 
  258                 GLM_FUNC_DECL tvec4<T, P> & operator<<=(U scalar);
 
  259                 template <
typename U>
 
  260                 GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec1<U, P> 
const & v);
 
  261                 template <
typename U>
 
  262                 GLM_FUNC_DECL tvec4<T, P> & operator<<=(tvec4<U, P> 
const & v);
 
  263                 template <
typename U>
 
  264                 GLM_FUNC_DECL tvec4<T, P> & operator>>=(U scalar);
 
  265                 template <
typename U>
 
  266                 GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec1<U, P> 
const & v);
 
  267                 template <
typename U>
 
  268                 GLM_FUNC_DECL tvec4<T, P> & operator>>=(tvec4<U, P> 
const & v);
 
  273         template <
typename T, precision P>
 
  274         GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> 
const & v);
 
  276         template <
typename T, precision P>
 
  277         GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> 
const & v);
 
  281         template <
typename T, precision P>
 
  282         GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> 
const & v, T scalar);
 
  284         template <
typename T, precision P>
 
  285         GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> 
const & v1, tvec1<T, P> 
const & v2);
 
  287         template <
typename T, precision P>
 
  288         GLM_FUNC_DECL tvec4<T, P> operator+(T scalar, tvec4<T, P> 
const & v);
 
  290         template <
typename T, precision P>
 
  291         GLM_FUNC_DECL tvec4<T, P> operator+(tvec1<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  293         template <
typename T, precision P>
 
  294         GLM_FUNC_DECL tvec4<T, P> operator+(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  296         template <
typename T, precision P>
 
  297         GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> 
const & v, T scalar);
 
  299         template <
typename T, precision P>
 
  300         GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> 
const & v1, tvec1<T, P> 
const & v2);
 
  302         template <
typename T, precision P>
 
  303         GLM_FUNC_DECL tvec4<T, P> operator-(T scalar, tvec4<T, P> 
const & v);
 
  305         template <
typename T, precision P>
 
  306         GLM_FUNC_DECL tvec4<T, P> operator-(tvec1<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  308         template <
typename T, precision P>
 
  309         GLM_FUNC_DECL tvec4<T, P> operator-(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  311         template <
typename T, precision P>
 
  312         GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> 
const & v, T scalar);
 
  314         template <
typename T, precision P>
 
  315         GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> 
const & v1, tvec1<T, P> 
const & v2);
 
  317         template <
typename T, precision P>
 
  318         GLM_FUNC_DECL tvec4<T, P> operator*(T scalar, tvec4<T, P> 
const & v);
 
  320         template <
typename T, precision P>
 
  321         GLM_FUNC_DECL tvec4<T, P> operator*(tvec1<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  323         template <
typename T, precision P>
 
  324         GLM_FUNC_DECL tvec4<T, P> operator*(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  326         template <
typename T, precision P>
 
  327         GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> 
const & v, T scalar);
 
  329         template <
typename T, precision P>
 
  330         GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> 
const & v1, tvec1<T, P> 
const & v2);
 
  332         template <
typename T, precision P>
 
  333         GLM_FUNC_DECL tvec4<T, P> operator/(T scalar, tvec4<T, P> 
const & v);
 
  335         template <
typename T, precision P>
 
  336         GLM_FUNC_DECL tvec4<T, P> operator/(tvec1<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  338         template <
typename T, precision P>
 
  339         GLM_FUNC_DECL tvec4<T, P> operator/(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  341         template <
typename T, precision P>
 
  342         GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> 
const & v, T scalar);
 
  344         template <
typename T, precision P>
 
  345         GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  347         template <
typename T, precision P>
 
  348         GLM_FUNC_DECL tvec4<T, P> operator%(T scalar, tvec4<T, P> 
const & v);
 
  350         template <
typename T, precision P>
 
  351         GLM_FUNC_DECL tvec4<T, P> operator%(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  353         template <
typename T, precision P>
 
  354         GLM_FUNC_DECL tvec4<T, P> operator%(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  356         template <
typename T, precision P>
 
  357         GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> 
const & v, T scalar);
 
  359         template <
typename T, precision P>
 
  360         GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  362         template <
typename T, precision P>
 
  363         GLM_FUNC_DECL tvec4<T, P> operator&(T scalar, tvec4<T, P> 
const & v);
 
  365         template <
typename T, precision P>
 
  366         GLM_FUNC_DECL tvec4<T, P> operator&(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  368         template <
typename T, precision P>
 
  369         GLM_FUNC_DECL tvec4<T, P> operator&(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  371         template <
typename T, precision P>
 
  372         GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> 
const & v, T scalar);
 
  374         template <
typename T, precision P>
 
  375         GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  377         template <
typename T, precision P>
 
  378         GLM_FUNC_DECL tvec4<T, P> operator|(T scalar, tvec4<T, P> 
const & v);
 
  380         template <
typename T, precision P>
 
  381         GLM_FUNC_DECL tvec4<T, P> operator|(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  383         template <
typename T, precision P>
 
  384         GLM_FUNC_DECL tvec4<T, P> operator|(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  386         template <
typename T, precision P>
 
  387         GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> 
const & v, T scalar);
 
  389         template <
typename T, precision P>
 
  390         GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  392         template <
typename T, precision P>
 
  393         GLM_FUNC_DECL tvec4<T, P> operator^(T scalar, tvec4<T, P> 
const & v);
 
  395         template <
typename T, precision P>
 
  396         GLM_FUNC_DECL tvec4<T, P> operator^(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  398         template <
typename T, precision P>
 
  399         GLM_FUNC_DECL tvec4<T, P> operator^(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  401         template <
typename T, precision P>
 
  402         GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> 
const & v, T scalar);
 
  404         template <
typename T, precision P>
 
  405         GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  407         template <
typename T, precision P>
 
  408         GLM_FUNC_DECL tvec4<T, P> operator<<(T scalar, tvec4<T, P> 
const & v);
 
  410         template <
typename T, precision P>
 
  411         GLM_FUNC_DECL tvec4<T, P> operator<<(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  413         template <
typename T, precision P>
 
  414         GLM_FUNC_DECL tvec4<T, P> operator<<(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  416         template <
typename T, precision P>
 
  417         GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> 
const & v, T scalar);
 
  419         template <
typename T, precision P>
 
  420         GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> 
const & v, tvec1<T, P> 
const & scalar);
 
  422         template <
typename T, precision P>
 
  423         GLM_FUNC_DECL tvec4<T, P> operator>>(T scalar, tvec4<T, P> 
const & v);
 
  425         template <
typename T, precision P>
 
  426         GLM_FUNC_DECL tvec4<T, P> operator>>(tvec1<T, P> 
const & scalar, tvec4<T, P> 
const & v);
 
  428         template <
typename T, precision P>
 
  429         GLM_FUNC_DECL tvec4<T, P> operator>>(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  431         template <
typename T, precision P> 
 
  432         GLM_FUNC_DECL tvec4<T, P> operator~(tvec4<T, P> 
const & v);
 
  436         template <
typename T, precision P>
 
  437         GLM_FUNC_DECL 
bool operator==(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  439         template <
typename T, precision P>
 
  440         GLM_FUNC_DECL 
bool operator!=(tvec4<T, P> 
const & v1, tvec4<T, P> 
const & v2);
 
  442         template <precision P>
 
  443         GLM_FUNC_DECL tvec4<bool, P> operator&&(tvec4<bool, P> 
const & v1, tvec4<bool, P> 
const & v2);
 
  445         template <precision P>
 
  446         GLM_FUNC_DECL tvec4<bool, P> operator||(tvec4<bool, P> 
const & v1, tvec4<bool, P> 
const & v2);
 
  449 #ifndef GLM_EXTERNAL_TEMPLATE 
  450 #include "type_vec4.inl" 
  451 #endif//GLM_EXTERNAL_TEMPLATE 
GLM_FUNC_DECL T length(vecType< T, P > const &x)
Returns the length of x, i.e., sqrt(x * x).