- 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
    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                 static GLM_FUNC_DECL size_type value_size();
    00058
    00059                 typedef tvec4<T> type;
    00060                 typedef tvec4<bool> bool_type;
    00061
    00063                 // Data
    00064
    00065 #       if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
    00066                 union
    00067                 {
    00068 #               if(defined(GLM_SWIZZLE))
    00069                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z, w)
    00070                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b, a)
    00071                         _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p, q)
    00072                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z, w)
    00073                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b, a)
    00074                         _GLM_SWIZZLE4_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p, q)
    00075                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z, w)
    00076                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b, a)
    00077                         _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p, q)
    00078 #               endif//(defined(GLM_SWIZZLE))
    00079
    00080                         struct{value_type r, g, b, a;};
    00081                         struct{value_type s, t, p, q;};
    00082                         struct{value_type x, y, z, w;};
    00083                 };
    00084 #       elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW))
    00085                 union {value_type x, r, s;};
    00086                 union {value_type y, g, t;};
    00087                 union {value_type z, b, p;};
    00088                 union {value_type w, a, q;};
    00089
    00090 #               if(defined(GLM_SWIZZLE))
    00091                         // Defines all he swizzle operator as functions
    00092                         GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
    00093                         GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
    00094 #               endif//(defined(GLM_SWIZZLE))
    00095 #       else
    00096                 value_type x, y, z, w;
    00097
    00098 #               if(defined(GLM_SWIZZLE))
    00099                         // Defines all he swizzle operator as functions
    00100                         GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w)
    00101                         GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w)
    00102 #               endif//(defined(GLM_SWIZZLE))
    00103 #       endif//GLM_COMPONENT
    00104
    00106                 // Accesses
    00107
    00108                 GLM_FUNC_DECL value_type & operator[](size_type i);
    00109                 GLM_FUNC_DECL value_type const & operator[](size_type i) const;
    00110
    00112                 // Implicit basic constructors
    00113
    00114                 GLM_FUNC_DECL tvec4();
    00115                 GLM_FUNC_DECL tvec4(type const & v);
    00116
    00118                 // Explicit basic constructors
    00119
    00120                 GLM_FUNC_DECL explicit tvec4(
    00121                         ctor);
    00122                 GLM_FUNC_DECL explicit tvec4(
    00123                         value_type const & s);
    00124                 GLM_FUNC_DECL explicit tvec4(
    00125                         value_type const & s0,
    00126                         value_type const & s1,
    00127                         value_type const & s2,
    00128                         value_type const & s3);
    00129
    00131                 // Convertion scalar constructors
    00132
    00134                 template <typename U>
    00135                 GLM_FUNC_DECL explicit tvec4(
    00136                         U const & x);
    00138                 template <typename A, typename B, typename C, typename D>
    00139                 GLM_FUNC_DECL explicit tvec4(
    00140                         A const & x,
    00141                         B const & y,
    00142                         C const & z,
    00143                         D const & w);
    00144
    00146                 // Convertion vector constructors
    00147
    00149                 template <typename A, typename B, typename C>
    00150                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
    00152                 template <typename A, typename B, typename C>
    00153                 GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
    00155                 template <typename A, typename B, typename C>
    00156                 GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
    00158                 template <typename A, typename B>
    00159                 GLM_FUNC_DECL explicit tvec4(tvec3<A> const & v, B const & s);
    00161                 template <typename A, typename B>
    00162                 GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B> const & v);
    00164                 template <typename A, typename B>
    00165                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
    00167                 template <typename U>
    00168                 GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
    00169
    00170         template <int E0, int E1, int E2, int E3>
    00171         GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T>, E0, E1, E2, E3> const & that)
    00172         {
    00173             *this = that();
    00174         }
    00175
    00176         template <int E0, int E1, int F0, int F1>
    00177         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)
    00178         {
    00179             *this = tvec4<T>(v(), u());
    00180         }
    00181
    00182         template <int E0, int E1>
    00183         GLM_FUNC_DECL tvec4(T const & x, T const & y, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
    00184         {
    00185             *this = tvec4<T>(x, y, v());
    00186         }
    00187
    00188         template <int E0, int E1>
    00189         GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & w)
    00190         {
    00191             *this = tvec4<T>(x, v(), w);
    00192         }
    00193
    00194         template <int E0, int E1>
    00195         GLM_FUNC_DECL tvec4(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & z, T const & w)
    00196         {
    00197             *this = tvec4<T>(v(), z, w);
    00198         }
    00199
    00200         template <int E0, int E1, int E2>
    00201         GLM_FUNC_DECL tvec4(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v, T const & w)
    00202         {
    00203             *this = tvec4<T>(v(), w);
    00204         }
    00205
    00206         template <int E0, int E1, int E2>
    00207         GLM_FUNC_DECL tvec4(T const & x, glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & v)
    00208         {
    00209             *this = tvec4<T>(x, v());
    00210         }
    00211
    00213                 // Swizzle constructors
    00214
    00215                 GLM_FUNC_DECL tvec4(tref4<T> const & r);
    00216
    00218                 template <typename A, typename B, typename C>
    00219                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v, B const & s1, C const & s2);
    00221                 template <typename A, typename B, typename C>
    00222                 GLM_FUNC_DECL explicit tvec4(A const & s1, tref2<B> const & v, C const & s2);
    00224                 template <typename A, typename B, typename C>
    00225                 GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tref2<C> const & v);
    00227                 template <typename A, typename B>
    00228                 GLM_FUNC_DECL explicit tvec4(tref3<A> const & v, B const & s);
    00230                 template <typename A, typename B>
    00231                 GLM_FUNC_DECL explicit tvec4(A const & s, tref3<B> const & v);
    00233                 template <typename A, typename B>
    00234                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tref2<B> const & v2);
    00236                 template <typename A, typename B>
    00237                 GLM_FUNC_DECL explicit tvec4(tvec2<A> const & v1, tref2<B> const & v2);
    00239                 template <typename A, typename B>
    00240                 GLM_FUNC_DECL explicit tvec4(tref2<A> const & v1, tvec2<B> const & v2);
    00241
    00243                 // Unary arithmetic operators
    00244
    00245                 GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
    00246                 template <typename U>
    00247                 GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
    00248
    00249                 template <typename U>
    00250                 GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
    00251                 template <typename U>
    00252                 GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
    00253                 template <typename U>
    00254                 GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
    00255                 template <typename U>
    00256                 GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
    00257                 template <typename U>
    00258                 GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
    00259                 template <typename U>
    00260                 GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
    00261                 template <typename U>
    00262                 GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
    00263                 template <typename U>
    00264                 GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
    00265                 GLM_FUNC_DECL tvec4<T> & operator++();
    00266                 GLM_FUNC_DECL tvec4<T> & operator--();
    00267
    00269                 // Unary bit operators
    00270
    00271                 template <typename U>
    00272                 GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
    00273                 template <typename U>
    00274                 GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
    00275                 template <typename U>
    00276                 GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
    00277                 template <typename U>
    00278                 GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
    00279                 template <typename U>
    00280                 GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
    00281                 template <typename U>
    00282                 GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
    00283                 template <typename U>
    00284                 GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
    00285                 template <typename U>
    00286                 GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
    00287                 template <typename U>
    00288                 GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
    00289                 template <typename U>
    00290                 GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
    00291                 template <typename U>
    00292                 GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
    00293                 template <typename U>
    00294                 GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
    00295
    00297                 // Swizzle operators
    00298
    00299                 GLM_FUNC_DECL value_type swizzle(comp X) const;
    00300                 GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
    00301                 GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
    00302                 GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
    00303                 GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
    00304                 GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
    00305                 GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
    00306         };
    00307
    00308         template <typename T>
    00309         struct tref4
    00310         {
    00311                 GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
    00312                 GLM_FUNC_DECL tref4(tref4<T> const & r);
    00313                 GLM_FUNC_DECL explicit tref4(tvec4<T> const & v);
    00314
    00315                 GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
    00316                 GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
    00317
    00318                 GLM_FUNC_DECL tvec4<T> operator() ();
    00319
    00320                 T & x;
    00321                 T & y;
    00322                 T & z;
    00323                 T & w;
    00324         };
    00325
    00326         GLM_DETAIL_IS_VECTOR(tvec4);
    00327 }//namespace detail
    00328
    00333         typedef detail::tvec4<highp_float>              highp_vec4;
    00334
    00339         typedef detail::tvec4<mediump_float>    mediump_vec4;
    00340
    00345         typedef detail::tvec4<lowp_float>               lowp_vec4;
    00346
    00351         typedef detail::tvec4<highp_int>                highp_ivec4;
    00352
    00357         typedef detail::tvec4<mediump_int>              mediump_ivec4;
    00358
    00363         typedef detail::tvec4<lowp_int>                 lowp_ivec4;
    00364
    00369         typedef detail::tvec4<highp_uint>               highp_uvec4;
    00370
    00375         typedef detail::tvec4<mediump_uint>             mediump_uvec4;
    00376
    00381         typedef detail::tvec4<lowp_uint>                lowp_uvec4;
    00382
    00383 }//namespace glm
    00384
    00385 #ifndef GLM_EXTERNAL_TEMPLATE
    00386 #include "type_vec4.inl"
    00387 #endif//GLM_EXTERNAL_TEMPLATE
    00388
    00389 #endif//glm_core_type_gentype4