type_vec2.hpp
00001 
00002 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
00004 // Created : 2008-08-18
00005 // Updated : 2010-02-04
00006 // Licence : This source is under MIT License
00007 // File    : glm/core/type_tvec2.hpp
00009 
00010 #ifndef glm_core_type_gentype2
00011 #define glm_core_type_gentype2
00012 
00013 #include "type_vec.hpp"
00014 #include "type_float.hpp"
00015 #include "type_int.hpp"
00016 #include "type_size.hpp"
00017 #include "_swizzle.hpp"
00018 
00019 namespace glm
00020 {
00021         namespace test
00022         {
00023                 void main_vec2();
00024         }
00025         //namespace test
00026 
00027         namespace detail
00028         {
00029                 template <typename T> struct tref2;
00030                 template <typename T> struct tref3;
00031                 template <typename T> struct tref4;
00032                 template <typename T> struct tvec3;
00033                 template <typename T> struct tvec4;
00034 
00037                 template <typename T>
00038                 struct tvec2
00039                 {
00040                         enum ctor{null};
00041 
00042                         typedef T value_type;
00043                         typedef std::size_t size_type;
00044                         GLM_FUNC_DECL size_type length() const;
00045                         static GLM_FUNC_DECL size_type value_size();
00046 
00047                         typedef tvec2<T> type;
00048                         typedef tvec2<bool> bool_type;
00049 
00051                         // Data
00052 
00053 #               if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
00054                         value_type x, y;
00055 #               elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
00056                         union 
00057                         {
00058                                 struct{value_type x, y;};
00059                                 struct{value_type r, g;};
00060                                 struct{value_type s, t;};
00061                         };
00062 #               else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
00063                         union {value_type x, r, s;};
00064                         union {value_type y, g, t;};
00065 #               endif//GLM_COMPONENT
00066 
00068                         // Accesses
00069 
00070                         GLM_FUNC_DECL value_type & operator[](size_type i);
00071                         GLM_FUNC_DECL value_type const & operator[](size_type i) const;
00072 
00074                         // Implicit basic constructors
00075 
00076                         GLM_FUNC_DECL tvec2();
00077                         GLM_FUNC_DECL tvec2(tvec2<T> const & v);
00078 
00080                         // Explicit basic constructors
00081 
00082                         GLM_FUNC_DECL explicit tvec2(
00083                                 ctor);
00084                         GLM_FUNC_DECL explicit tvec2(
00085                                 value_type const & s);
00086                         GLM_FUNC_DECL explicit tvec2(
00087                                 value_type const & s1, 
00088                                 value_type const & s2);
00089 
00091                         // Swizzle constructors
00092 
00093                         tvec2(tref2<T> const & r);
00094 
00096                         // Convertion scalar constructors
00097 
00099                         template <typename U> 
00100                         GLM_FUNC_DECL explicit tvec2(
00101                                 U const & x);
00103                         template <typename U, typename V> 
00104                         GLM_FUNC_DECL explicit tvec2(
00105                                 U const & x, 
00106                                 V const & y);
00107 
00109                         // Convertion vector constructors
00110 
00112                         template <typename U> 
00113                         GLM_FUNC_DECL explicit tvec2(tvec2<U> const & v);
00115                         template <typename U> 
00116                         GLM_FUNC_DECL explicit tvec2(tvec3<U> const & v);
00118                         template <typename U> 
00119                         GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
00120 
00122                         // Unary arithmetic operators
00123 
00124                         GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
00125                         template <typename U> 
00126                         GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
00127 
00128                         template <typename U> 
00129                         GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
00130                         template <typename U> 
00131                         GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
00132                         template <typename U> 
00133                         GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
00134                         template <typename U> 
00135                         GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
00136                         template <typename U> 
00137                         GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
00138                         template <typename U> 
00139                         GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
00140                         template <typename U> 
00141                         GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
00142                         template <typename U> 
00143                         GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
00144                         GLM_FUNC_DECL tvec2<T> & operator++();
00145                         GLM_FUNC_DECL tvec2<T> & operator--();
00146 
00148                         // Unary bit operators
00149 
00150                         template <typename U> 
00151                         GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
00152                         template <typename U> 
00153                         GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
00154                         template <typename U> 
00155                         GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
00156                         template <typename U> 
00157                         GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
00158                         template <typename U> 
00159                         GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
00160                         template <typename U> 
00161                         GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
00162                         template <typename U> 
00163                         GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
00164                         template <typename U> 
00165                         GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
00166                         template <typename U> 
00167                         GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
00168                         template <typename U> 
00169                         GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
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 
00176                         // Swizzle operators
00177 
00178                         GLM_FUNC_DECL value_type swizzle(comp X) const;
00179                         GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
00180                         GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
00181                         GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
00182                         GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
00183                 };
00184 
00185                 template <typename T>
00186                 struct tref2
00187                 {
00188                         GLM_FUNC_DECL tref2(T & x, T & y);
00189                         GLM_FUNC_DECL tref2(tref2<T> const & r);
00190                         GLM_FUNC_DECL tref2(tvec2<T> const & v);
00191 
00192                         GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
00193                         GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
00194 
00195                         T& x;
00196                         T& y;
00197                 };
00198 
00199                 GLM_DETAIL_IS_VECTOR(tvec2);
00200 
00201         } //namespace detail
00202 
00203         namespace core{
00204         namespace type{
00205 
00206         namespace precision
00207         {
00212                 typedef detail::tvec2<highp_float>              highp_vec2;
00217                 typedef detail::tvec2<mediump_float>    mediump_vec2;
00222                 typedef detail::tvec2<lowp_float>               lowp_vec2;
00223 
00228                 typedef detail::tvec2<highp_int>                highp_ivec2;
00233                 typedef detail::tvec2<mediump_int>              mediump_ivec2;
00238                 typedef detail::tvec2<lowp_int>                 lowp_ivec2;
00239         
00244                 typedef detail::tvec2<highp_uint>               highp_uvec2;
00249                 typedef detail::tvec2<mediump_uint>             mediump_uvec2;
00254                 typedef detail::tvec2<lowp_uint>                lowp_uvec2;
00255         }
00256         //namespace precision
00257 
00258         }//namespace type
00259         }//namespace core
00260 }//namespace glm
00261 
00262 #ifndef GLM_EXTERNAL_TEMPLATE
00263 #include "type_vec2.inl"
00264 #endif
00265 
00266 #endif//glm_core_type_gentype2