type_vec3.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_gentype3
00030 #define glm_core_type_gentype3
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 tvec4;
00046 
00049         template <typename T>
00050         struct tvec3
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 tvec3<T> type;
00060                 typedef tvec3<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_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, x, y, z)
00070                         _GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, r, g, b)
00071                         _GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2<value_type>, s, t, p)
00072                         _GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, x, y, z)
00073                         _GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, r, g, b)
00074                         _GLM_SWIZZLE3_3_MEMBERS(value_type, glm::detail::tvec3<value_type>, s, t, p)
00075                         _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, x, y, z)
00076                         _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, r, g, b)
00077                         _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4<value_type>, s, t, p)
00078 #               endif//(defined(GLM_SWIZZLE))
00079 
00080                         struct{value_type r, g, b;};
00081                         struct{value_type s, t, p;};
00082                         struct{value_type x, y, z;};
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 
00089 #               if(defined(GLM_SWIZZLE))
00090                         // Defines all he swizzle operator as functions
00091                         GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, detail::tvec3, detail::tref2, detail::tref3)
00092                         GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
00093 #               endif//(defined(GLM_SWIZZLE))
00094 #       else
00095                 value_type x, y, z;
00096 
00097 #               if(defined(GLM_SWIZZLE))
00098                         // Defines all he swizzle operator as functions
00099                         GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z)
00100                         GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z)
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 tvec3();
00114                 GLM_FUNC_DECL tvec3(tvec3<T> const & v);
00115 
00117                 // Explicit basic constructors
00118 
00119                 GLM_FUNC_DECL explicit tvec3(
00120                         ctor);
00121                 GLM_FUNC_DECL explicit tvec3(
00122                         value_type const & s);
00123                 GLM_FUNC_DECL explicit tvec3(
00124                         value_type const & s1, 
00125                         value_type const & s2, 
00126                         value_type const & s3);
00127 
00129                 // Convertion scalar constructors
00130 
00132                 template <typename U> 
00133                 GLM_FUNC_DECL explicit tvec3(
00134                         U const & x);
00136                 template <typename U, typename V, typename W> 
00137                 GLM_FUNC_DECL explicit tvec3(
00138                         U const & x, 
00139                         V const & y, 
00140                         W const & z);                   
00141 
00143                 // Convertion vector constructors
00144 
00146                 template <typename A, typename B> 
00147                 GLM_FUNC_DECL explicit tvec3(tvec2<A> const & v, B const & s);
00149                 template <typename A, typename B> 
00150                 GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B> const & v);
00152                 template <typename U> 
00153                 GLM_FUNC_DECL explicit tvec3(tvec3<U> const & v);
00155                 template <typename U> 
00156                 GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
00157 
00159                 // Swizzle constructors
00160 
00161                 GLM_FUNC_DECL tvec3(tref3<T> const & r);
00162 
00163                 template <typename A, typename B> 
00164                 GLM_FUNC_DECL explicit tvec3(tref2<A> const & v, B const & s);
00165 
00166                 template <typename A, typename B> 
00167                 GLM_FUNC_DECL explicit tvec3(A const & s, tref2<B> const & v);
00168 
00169         template <int E0, int E1, int E2>
00170         GLM_FUNC_DECL tvec3(glm::detail::swizzle<3, T, tvec3<T>, E0, E1, E2, -1> const & that)
00171         {
00172             *this = that();
00173         }
00174 
00175         template <int E0, int E1>
00176         GLM_FUNC_DECL tvec3(glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v, T const & s)
00177         {
00178             *this = tvec3<T>(v(), s);
00179         }
00180 
00181         template <int E0, int E1>
00182         GLM_FUNC_DECL tvec3(T const & s, glm::detail::swizzle<2, T, tvec2<T>, E0, E1, -1, -2> const & v)
00183         {
00184             *this = tvec3<T>(s, v());
00185         }
00186 
00188                 // Unary arithmetic operators
00189 
00190                 GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
00191                 template <typename U> 
00192                 GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
00193 
00194                 template <typename U> 
00195                 GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
00196                 template <typename U> 
00197                 GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
00198                 template <typename U> 
00199                 GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
00200                 template <typename U> 
00201                 GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
00202                 template <typename U> 
00203                 GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
00204                 template <typename U> 
00205                 GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
00206                 template <typename U> 
00207                 GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
00208                 template <typename U> 
00209                 GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
00210                 GLM_FUNC_DECL tvec3<T> & operator++();
00211                 GLM_FUNC_DECL tvec3<T> & operator--();
00212 
00214                 // Unary bit operators
00215 
00216                 template <typename U>
00217                 GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
00218                 template <typename U>
00219                 GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
00220                 template <typename U>
00221                 GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
00222                 template <typename U>
00223                 GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
00224                 template <typename U>
00225                 GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
00226                 template <typename U>
00227                 GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
00228                 template <typename U>
00229                 GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
00230                 template <typename U>
00231                 GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
00232                 template <typename U>
00233                 GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
00234                 template <typename U>
00235                 GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
00236                 template <typename U>
00237                 GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
00238                 template <typename U>
00239                 GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
00240 
00242                 // Swizzle operators
00243 
00244                 GLM_FUNC_DECL value_type swizzle(comp X) const;
00245                 GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
00246                 GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
00247                 GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
00248                 GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
00249                 GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
00250         };
00251 
00252         template <typename T>
00253         struct tref3
00254         {
00255                 GLM_FUNC_DECL tref3(T & x, T & y, T & z);
00256                 GLM_FUNC_DECL tref3(tref3<T> const & r);
00257                 GLM_FUNC_DECL explicit tref3(tvec3<T> const & v);
00258 
00259                 GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
00260                 GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
00261 
00262                 GLM_FUNC_DECL tvec3<T> operator() ();
00263 
00264                 T & x;
00265                 T & y;
00266                 T & z;
00267         };
00268 
00269         GLM_DETAIL_IS_VECTOR(tvec3);
00270 } //namespace detail
00271 
00276         typedef detail::tvec3<highp_float>              highp_vec3;
00277 
00282         typedef detail::tvec3<mediump_float>    mediump_vec3;
00283 
00288         typedef detail::tvec3<lowp_float>               lowp_vec3;
00289 
00294         typedef detail::tvec3<highp_int>                highp_ivec3;
00295 
00300         typedef detail::tvec3<mediump_int>              mediump_ivec3;
00301 
00306         typedef detail::tvec3<lowp_int>                 lowp_ivec3;
00307 
00312         typedef detail::tvec3<highp_uint>               highp_uvec3;
00313 
00318         typedef detail::tvec3<mediump_uint>             mediump_uvec3;
00319 
00324         typedef detail::tvec3<lowp_uint>                lowp_uvec3;
00325 
00326 }//namespace glm
00327 
00328 #ifndef GLM_EXTERNAL_TEMPLATE
00329 #include "type_vec3.inl"
00330 #endif//GLM_EXTERNAL_TEMPLATE
00331 
00332 #endif//glm_core_type_gentype3