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

- File List

# type_vec2.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_gentype2
    00030 #define glm_core_type_gentype2
    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 tvec3;
    00045         template <typename T> struct tvec4;
    00046
    00049         template <typename T>
    00050         struct tvec2
    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 tvec2<T> type;
    00060                 typedef tvec2<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_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y)
    00070                         _GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g)
    00071                         _GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t)
    00072                         _GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y)
    00073                         _GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g)
    00074                         _GLM_SWIZZLE2_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t)
    00075                         _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y)
    00076                         _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g)
    00077                         _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t)
    00078 #               endif//(defined(GLM_SWIZZLE))
    00079
    00080                         struct{value_type r, g;};
    00081                         struct{value_type s, t;};
    00082                         struct{value_type x, y;};
    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
    00088 #               if(defined(GLM_SWIZZLE))
    00089                         // Defines all he swizzle operator as functions
    00090                         GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, detail::tvec2, detail::tref2)
    00091                         GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
    00092 #               endif//(defined(GLM_SWIZZLE))
    00093 #       else
    00094                 value_type x, y;
    00095
    00096 #               if(defined(GLM_SWIZZLE))
    00097                         // Defines all he swizzle operator as functions
    00098                         GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y)
    00099                         GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y)
    00100 #               endif//(defined(GLM_SWIZZLE))
    00101 #       endif//GLM_COMPONENT
    00102
    00104                 // Accesses
    00105
    00106                 GLM_FUNC_DECL value_type & operator[](size_type i);
    00107                 GLM_FUNC_DECL value_type const & operator[](size_type i) const;
    00108
    00110                 // Implicit basic constructors
    00111
    00112                 GLM_FUNC_DECL tvec2();
    00113                 GLM_FUNC_DECL tvec2(tvec2<T> const & v);
    00114
    00116                 // Explicit basic constructors
    00117
    00118                 GLM_FUNC_DECL explicit tvec2(
    00119                         ctor);
    00120                 GLM_FUNC_DECL explicit tvec2(
    00121                         value_type const & s);
    00122                 GLM_FUNC_DECL explicit tvec2(
    00123                         value_type const & s1,
    00124                         value_type const & s2);
    00125
    00127                 // Swizzle constructors
    00128
    00129                 tvec2(tref2<T> const & r);
    00130
    00131         template <int E0, int E1>
    00132         GLM_FUNC_DECL tvec2(const glm::detail::swizzle<2,T,tvec2<T>,E0,E1,-1,-2>& that)
    00133         {
    00134             *this = that();
    00135         }
    00136
    00138                 // Convertion constructors
    00139
    00141                 template <typename U>
    00142                 GLM_FUNC_DECL explicit tvec2(
    00143                         U const & x);
    00145                 template <typename U, typename V>
    00146                 GLM_FUNC_DECL explicit tvec2(
    00147                         U const & x,
    00148                         V const & y);
    00149
    00151                 // Convertion vector constructors
    00152
    00154                 template <typename U>
    00155                 GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
    00157                 template <typename U>
    00158                 GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
    00160                 template <typename U>
    00161                 GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
    00162
    00164                 // Unary arithmetic operators
    00165
    00166                 GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
    00167                 template <typename U>
    00168                 GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
    00169
    00170                 template <typename U>
    00171                 GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
    00172                 template <typename U>
    00173                 GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
    00174                 template <typename U>
    00175                 GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
    00176                 template <typename U>
    00177                 GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
    00178                 template <typename U>
    00179                 GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
    00180                 template <typename U>
    00181                 GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
    00182                 template <typename U>
    00183                 GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
    00184                 template <typename U>
    00185                 GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
    00186                 GLM_FUNC_DECL tvec2<T> & operator++();
    00187                 GLM_FUNC_DECL tvec2<T> & operator--();
    00188
    00190                 // Unary bit operators
    00191
    00192                 template <typename U>
    00193                 GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
    00194                 template <typename U>
    00195                 GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
    00196                 template <typename U>
    00197                 GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
    00198                 template <typename U>
    00199                 GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
    00200                 template <typename U>
    00201                 GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
    00202                 template <typename U>
    00203                 GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
    00204                 template <typename U>
    00205                 GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
    00206                 template <typename U>
    00207                 GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
    00208                 template <typename U>
    00209                 GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
    00210                 template <typename U>
    00211                 GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
    00212                 template <typename U>
    00213                 GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
    00214                 template <typename U>
    00215                 GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
    00216
    00218                 // Swizzle operators
    00219
    00220                 GLM_FUNC_DECL value_type swizzle(comp X) const;
    00221                 GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
    00222                 GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
    00223                 GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
    00224                 GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
    00225         };
    00226
    00227         template <typename T>
    00228         struct tref2
    00229         {
    00230                 GLM_FUNC_DECL tref2(T & x, T & y);
    00231                 GLM_FUNC_DECL tref2(tref2<T> const & r);
    00232                 GLM_FUNC_DECL explicit tref2(tvec2<T> const & v);
    00233
    00234                 GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
    00235                 GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
    00236
    00237                 GLM_FUNC_DECL tvec2<T> operator() ();
    00238
    00239                 T & x;
    00240                 T & y;
    00241         };
    00242
    00243         GLM_DETAIL_IS_VECTOR(tvec2);
    00244
    00245 } //namespace detail
    00246
    00251         typedef detail::tvec2<highp_float>              highp_vec2;
    00252
    00257         typedef detail::tvec2<mediump_float>    mediump_vec2;
    00258
    00263         typedef detail::tvec2<lowp_float>               lowp_vec2;
    00264
    00269         typedef detail::tvec2<highp_int>                highp_ivec2;
    00270
    00275         typedef detail::tvec2<mediump_int>              mediump_ivec2;
    00276
    00281         typedef detail::tvec2<lowp_int>                 lowp_ivec2;
    00282
    00287         typedef detail::tvec2<highp_uint>               highp_uvec2;
    00288
    00293         typedef detail::tvec2<mediump_uint>             mediump_uvec2;
    00294
    00299         typedef detail::tvec2<lowp_uint>                lowp_uvec2;
    00300
    00301 }//namespace glm
    00302
    00303 #ifndef GLM_EXTERNAL_TEMPLATE
    00304 #include "type_vec2.inl"
    00305 #endif//GLM_EXTERNAL_TEMPLATE
    00306
    00307 #endif//glm_core_type_gentype2