- Main Page
- Related Pages
- Modules
- Classes
- Files

- File List

type_vec4.hpp
Go to the documentation of this file.

    00001
    00002
    00003
    00004
    00005
    00006
    00007
    00008
    00009
    00010
    00011
    00012
    00013
    00014
    00015
    00016
    00017
    00018
    00019
    00020
    00021
    00022
    00023
    00024
    00025
    00026
    00027
    00028
    00029 #ifndef glm_core_type_gentype4
    00030 #define glm_core_type_gentype4
    00031
    00032 #include "type_vec.hpp"
    00033 #include "type_float.hpp"
    00034 #include "type_int.hpp"
    00035 #include "type_size.hpp"
    00036 #include "_swizzle.hpp"
    00037
    00038 namespace glm{
    00039 namespace detail
    00040 {
    00041         template <typename T> struct tref2;
    00042         template <typename T> struct tref3;
    00043         template <typename T> struct tref4;
    00044         template <typename T> struct tvec2;
    00045         template <typename T> struct tvec3;
    00046
    00047         // Basic 4D vector type.
    00048         // @ingroup core_template
    00049         template <typename T>
    00050         struct tvec4
    00051         {
    00052                 enum ctor{null};
    00053
    00054                 typedef T value_type;
    00055                 typedef std::size_t size_type;
    00056                 GLM_FUNC_DECL size_type length() const;
    00057
    00058                 typedef tvec4<T> type;
    00059                 typedef tvec4<bool> bool_type;
    00060
    00062                 // Data
    00063
    00064 #       if(GLM_COMPONENT == GLM_COMPONENT_CXX11)
    00065                 union
    00066                 {
    00067 #               if(defined(GLM_SWIZZLE))
    00068                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w)
    00069                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a)
    00070                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q)
    00071                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w)
    00072                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a)
    00073                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q)
    00074                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w)
    00075                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a)
    00076                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q)
    00077 #               endif//(defined(GLM_SWIZZLE))
    00078
    00079                         struct{value_type r, g, b, a;};
    00080                         struct{value_type s, t, p, q;};
    00081                         struct{value_type x, y, z, w;};
    00082                 };
    00083 #       elif(GLM_COMPONENT == GLM_COMPONENT_CXX98)
    00084                 union {value_type x, r, s;};
    00085                 union {value_type y, g, t;};
    00086                 union {value_type z, b, p;};
    00087                 union {value_type w, a, q;};
    00088
    00089 #               if(defined(GLM_SWIZZLE))
    00090                         // Defines all he swizzle operator as functions
    00091                         GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
    00092                         GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
    00093 #               endif//(defined(GLM_SWIZZLE))
    00094 #       else //(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
    00095                 value_type x, y, z, w;
    00096
    00097 #               if(defined(GLM_SWIZZLE))
    00098                         // Defines all he swizzle operator as functions
    00099                         GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
    00100                         GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
    00101 #               endif//(defined(GLM_SWIZZLE))
    00102 #       endif//GLM_COMPONENT
    00103
    00105                 // Accesses
    00106
    00107                 GLM_FUNC_DECL value_type & operator[](size_type i);
    00108                 GLM_FUNC_DECL value_type const & operator[](size_type i) const;
    00109
    00111                 // Implicit basic constructors
    00112
    00113                 GLM_FUNC_DECL tvec4();
    00114                 GLM_FUNC_DECL tvec4(type const & v);
    00115
    00117                 // Explicit basic constructors
    00118
    00119                 GLM_FUNC_DECL explicit tvec4(
    00120                         ctor);
    00121                 GLM_FUNC_DECL explicit tvec4(
    00122                         value_type const & s);
    00123                 GLM_FUNC_DECL explicit tvec4(
    00124                         value_type const & s0,
    00125                         value_type const & s1,
    00126                         value_type const & s2,
    00127                         value_type const & s3);
    00128
    00130                 // Convertion scalar constructors
    00131
    00133                 template <typename U>
    00134                 GLM_FUNC_DECL explicit tvec4(
    00135                         U const & x);
    00137                 template <typename A, typename B, typename C, typename D>
    00138                 GLM_FUNC_DECL explicit tvec4(
    00139                         A const & x,
    00140                         B const & y,
    00141                         C const & z,
    00142                         D const & w);
    00143
    00145                 // Convertion vector constructors
    00146
    00148                 template <typename A, typename B, typename C>
    00149                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
    00151                 template <typename A, typename B, typename C>
    00152                 GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
    00154                 template <typename A, typename B, typename C>
    00155                 GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
    00157                 template <typename A, typename B>
    00158                 GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
    00160                 template <typename A, typename B>
    00161                 GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
    00163                 template <typename A, typename B>
    00164                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
    00166                 template <typename U>
    00167                 GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
    00168
    00169         template <int E0, int E1, int E2, int E3>
    00170         GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
    00171         {
    00172             *this = that();
    00173         }
    00174
    00175         template <int E0, int E1, int F0, int F1>
    00176         GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, glm::detail::swizzle<2, T, tvec2<T>, F0, F1, -1, -2> const & u)
    00177         {
    00178             *this = tvec4<T>(v(), u());
    00179         }
    00180
    00181         template <int E0, int E1>
    00182         GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
    00183         {
    00184             *this = tvec4<T>(x, y, v());
    00185         }
    00186
    00187         template <int E0, int E1>
    00188         GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
    00189         {
    00190             *this = tvec4<T>(x, v(), w);
    00191         }
    00192
    00193         template <int E0, int E1>
    00194         GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
    00195         {
    00196             *this = tvec4<T>(v(), z, w);
    00197         }
    00198
    00199         template <int E0, int E1, int E2>
    00200         GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
    00201         {
    00202             *this = tvec4<T>(v(), w);
    00203         }
    00204
    00205         template <int E0, int E1, int E2>
    00206         GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
    00207         {
    00208             *this = tvec4<T>(x, v());
    00209         }
    00210
    00212                 // Swizzle constructors
    00213
    00214                 GLM_FUNC_DECL tvec4(tref4<T> const & r);
    00215
    00217                 template <typename A, typename B, typename C>
    00218                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
    00220                 template <typename A, typename B, typename C>
    00221                 GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
    00223                 template <typename A, typename B, typename C>
    00224                 GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
    00226                 template <typename A, typename B>
    00227                 GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
    00229                 template <typename A, typename B>
    00230                 GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
    00232                 template <typename A, typename B>
    00233                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
    00235                 template <typename A, typename B>
    00236                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
    00238                 template <typename A, typename B>
    00239                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
    00240
    00242                 // Unary arithmetic operators
    00243
    00244                 GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
    00245                 template <typename U>
    00246                 GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
    00247
    00248                 template <typename U>
    00249                 GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
    00250                 template <typename U>
    00251                 GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
    00252                 template <typename U>
    00253                 GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
    00254                 template <typename U>
    00255                 GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
    00256                 template <typename U>
    00257                 GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
    00258                 template <typename U>
    00259                 GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
    00260                 template <typename U>
    00261                 GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
    00262                 template <typename U>
    00263                 GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
    00264                 GLM_FUNC_DECL tvec4<T> & operator++();
    00265                 GLM_FUNC_DECL tvec4<T> & operator--();
    00266
    00268                 // Unary bit operators
    00269
    00270                 template <typename U>
    00271                 GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
    00272                 template <typename U>
    00273                 GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
    00274                 template <typename U>
    00275                 GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
    00276                 template <typename U>
    00277                 GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
    00278                 template <typename U>
    00279                 GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
    00280                 template <typename U>
    00281                 GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
    00282                 template <typename U>
    00283                 GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
    00284                 template <typename U>
    00285                 GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
    00286                 template <typename U>
    00287                 GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
    00288                 template <typename U>
    00289                 GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
    00290                 template <typename U>
    00291                 GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
    00292                 template <typename U>
    00293                 GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
    00294
    00296                 // Swizzle operators
    00297
    00298                 GLM_FUNC_DECL value_type swizzle(comp X) const;
    00299                 GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
    00300                 GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
    00301                 GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
    00302                 GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
    00303                 GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
    00304                 GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
    00305         };
    00306
    00307         template <typename T>
    00308         struct tref4
    00309         {
    00310                 GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
    00311                 GLM_FUNC_DECL tref4(tref4<T> const & r);
    00312                 GLM_FUNC_DECL explicit tref4(tvec4<T> const & v);
    00313
    00314                 GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
    00315                 GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
    00316
    00317                 GLM_FUNC_DECL tvec4<T> operator() ();
    00318
    00319                 T & x;
    00320                 T & y;
    00321                 T & z;
    00322                 T & w;
    00323         };
    00324
    00325         GLM_DETAIL_IS_VECTOR(tvec4);
    00326 }//namespace detail
    00327
    00330
    00336         typedef detail::tvec4<highp_float>              highp_vec4;
    00337
    00343         typedef detail::tvec4<mediump_float>    mediump_vec4;
    00344
    00350         typedef detail::tvec4<lowp_float>               lowp_vec4;
    00351
    00357         typedef detail::tvec4<highp_int>                highp_ivec4;
    00358
    00364         typedef detail::tvec4<mediump_int>              mediump_ivec4;
    00365
    00371         typedef detail::tvec4<lowp_int>                 lowp_ivec4;
    00372
    00378         typedef detail::tvec4<highp_uint>               highp_uvec4;
    00379
    00385         typedef detail::tvec4<mediump_uint>             mediump_uvec4;
    00386
    00392         typedef detail::tvec4<lowp_uint>                lowp_uvec4;
    00393
    00395 }//namespace glm
    00396
    00397 #ifndef GLM_EXTERNAL_TEMPLATE
    00398 #include "type_vec4.inl"
    00399 #endif//GLM_EXTERNAL_TEMPLATE
    00400
    00401 #endif//glm_core_type_gentype4