half_float.hpp

00001 
00002 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
00004 // Created : 2009-04-29
00005 // Updated : 2010-02-07
00006 // Licence : This source is under MIT License
00007 // File    : glm/gtc/half_float.hpp
00009 
00010 #ifndef glm_gtc_half_float
00011 #define glm_gtc_half_float
00012 
00013 // Dependency:
00014 #include "../glm.hpp"
00015 
00016 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
00017 #       pragma message("GLM: GLM_GTC_half_float extension included")
00018 #endif
00019 
00020 namespace glm
00021 {
00022         namespace test{
00023                 bool main_gtc_half_float();
00024         }//namespace 
00025         namespace detail
00026         {
00027 #ifndef _MSC_EXTENSIONS
00028                 template <>
00029                 struct tvec2<thalf>
00030                 {
00031                         enum ctor{null};
00032                         typedef thalf value_type;
00033                         typedef std::size_t size_type;
00034                         static size_type value_size();
00035 
00036                         typedef tvec2<thalf> type;
00037                         typedef tvec2<bool> bool_type;
00038 
00040                         // Data
00041 
00042                         thalf x, y;
00043 
00045                         // Accesses
00046 
00047                         thalf & operator[](size_type i);
00048                         thalf const & operator[](size_type i) const;
00049 
00051                         // Implicit basic constructors
00052 
00053                         tvec2();
00054                         tvec2(tvec2<thalf> const & v);
00055 
00057                         // Explicit basic constructors
00058 
00059                         explicit tvec2(ctor);
00060                         explicit tvec2(
00061                                 thalf const & s);
00062                         explicit tvec2(
00063                                 thalf const & s1, 
00064                                 thalf const & s2);
00065 
00067                         // Swizzle constructors
00068 
00069                         tvec2(tref2<thalf> const & r);
00070 
00072                         // Convertion scalar constructors
00073 
00075                         template <typename U> 
00076                         explicit tvec2(U const & x);
00078                         template <typename U, typename V> 
00079                         explicit tvec2(U const & x, V const & y);                       
00080 
00082                         // Convertion vector constructors
00083 
00085                         template <typename U> 
00086                         explicit tvec2(tvec2<U> const & v);
00088                         template <typename U> 
00089                         explicit tvec2(tvec3<U> const & v);
00091                         template <typename U> 
00092                         explicit tvec2(tvec4<U> const & v);
00093 
00095                         // Unary arithmetic operators
00096 
00097                         tvec2<thalf>& operator= (tvec2<thalf> const & v);
00098 
00099                         tvec2<thalf>& operator+=(thalf const & s);
00100                         tvec2<thalf>& operator+=(tvec2<thalf> const & v);
00101                         tvec2<thalf>& operator-=(thalf const & s);
00102                         tvec2<thalf>& operator-=(tvec2<thalf> const & v);
00103                         tvec2<thalf>& operator*=(thalf const & s);
00104                         tvec2<thalf>& operator*=(tvec2<thalf> const & v);
00105                         tvec2<thalf>& operator/=(thalf const & s);
00106                         tvec2<thalf>& operator/=(tvec2<thalf> const & v);
00107                         tvec2<thalf>& operator++();
00108                         tvec2<thalf>& operator--();
00109 
00111                         // Swizzle operators
00112 
00113                         thalf swizzle(comp X) const;
00114                         tvec2<thalf> swizzle(comp X, comp Y) const;
00115                         tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
00116                         tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
00117                         tref2<thalf> swizzle(comp X, comp Y);
00118                 };
00119 
00120                 template <>
00121                 struct tvec3<thalf>
00122                 {
00123                         enum ctor{null};
00124                         typedef thalf value_type;
00125                         typedef std::size_t size_type;
00126                         static size_type value_size();
00127 
00128                         typedef tvec3<thalf> type;
00129                         typedef tvec3<bool> bool_type;
00130 
00132                         // Data
00133 
00134                         thalf x, y, z;
00135 
00137                         // Accesses
00138 
00139                         thalf & operator[](size_type i);
00140                         thalf const & operator[](size_type i) const;
00141 
00143                         // Implicit basic constructors
00144 
00145                         tvec3();
00146                         tvec3(tvec3<thalf> const & v);
00147 
00149                         // Explicit basic constructors
00150 
00151                         explicit tvec3(ctor);
00152                         explicit tvec3(
00153                                 thalf const & s);
00154                         explicit tvec3(
00155                                 thalf const & s1, 
00156                                 thalf const & s2, 
00157                                 thalf const & s3);
00158 
00160                         // Swizzle constructors
00161 
00162                         tvec3(tref3<thalf> const & r);
00163 
00165                         // Convertion scalar constructors
00166 
00168                         template <typename U> 
00169                         explicit tvec3(U const & x);
00171                         template <typename U, typename V, typename W> 
00172                         explicit tvec3(U const & x, V const & y, W const & z);                  
00173 
00175                         // Convertion vector constructors
00176 
00178                         template <typename A, typename B> 
00179                         explicit tvec3(tvec2<A> const & v, B const & s);
00181                         template <typename A, typename B> 
00182                         explicit tvec3(A const & s, tvec2<B> const & v);
00184                         template <typename U> 
00185                         explicit tvec3(tvec3<U> const & v);
00187                         template <typename U> 
00188                         explicit tvec3(tvec4<U> const & v);
00189 
00191                         // Unary arithmetic operators
00192 
00193                         tvec3<thalf>& operator= (tvec3<thalf> const & v);
00194 
00195                         tvec3<thalf>& operator+=(thalf const & s);
00196                         tvec3<thalf>& operator+=(tvec3<thalf> const & v);
00197                         tvec3<thalf>& operator-=(thalf const & s);
00198                         tvec3<thalf>& operator-=(tvec3<thalf> const & v);
00199                         tvec3<thalf>& operator*=(thalf const & s);
00200                         tvec3<thalf>& operator*=(tvec3<thalf> const & v);
00201                         tvec3<thalf>& operator/=(thalf const & s);
00202                         tvec3<thalf>& operator/=(tvec3<thalf> const & v);
00203                         tvec3<thalf>& operator++();
00204                         tvec3<thalf>& operator--();
00205 
00207                         // Swizzle operators
00208 
00209                         thalf swizzle(comp X) const;
00210                         tvec2<thalf> swizzle(comp X, comp Y) const;
00211                         tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
00212                         tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
00213                         tref3<thalf> swizzle(comp X, comp Y, comp Z);
00214                 };
00215 
00216                 template <>
00217                 struct tvec4<thalf>
00218                 {
00219                         enum ctor{null};
00220                         typedef thalf value_type;
00221                         typedef std::size_t size_type;
00222                         static size_type value_size();
00223 
00224                         typedef tvec4<thalf> type;
00225                         typedef tvec4<bool> bool_type;
00226 
00228                         // Data
00229 
00230                         thalf x, y, z, w;
00231 
00233                         // Accesses
00234 
00235                         thalf & operator[](size_type i);
00236                         thalf const & operator[](size_type i) const;
00237 
00239                         // Implicit basic constructors
00240 
00241                         tvec4();
00242                         tvec4(tvec4<thalf> const & v);
00243 
00245                         // Explicit basic constructors
00246 
00247                         explicit tvec4(ctor);
00248                         explicit tvec4(
00249                                 thalf const & s);
00250                         explicit tvec4(
00251                                 thalf const & s0, 
00252                                 thalf const & s1, 
00253                                 thalf const & s2, 
00254                                 thalf const & s3);
00255 
00257                         // Swizzle constructors
00258 
00259                         tvec4(tref4<thalf> const & r);
00260 
00262                         // Convertion scalar constructors
00263 
00265                         template <typename U> 
00266                         explicit tvec4(U const & x);
00268                         template <typename A, typename B, typename C, typename D> 
00269                         explicit tvec4(A const & x, B const & y, C const & z, D const & w);                     
00270 
00272                         // Convertion vector constructors
00273 
00275                         template <typename A, typename B, typename C> 
00276                         explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
00278                         template <typename A, typename B, typename C> 
00279                         explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
00281                         template <typename A, typename B, typename C> 
00282                         explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
00284                         template <typename A, typename B> 
00285                         explicit tvec4(tvec3<A> const & v, B const & s);
00287                         template <typename A, typename B> 
00288                         explicit tvec4(A const & s, tvec3<B> const & v);
00290                         template <typename A, typename B> 
00291                         explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
00293                         template <typename U> 
00294                         explicit tvec4(tvec4<U> const & v);
00295 
00297                         // Unary arithmetic operators
00298 
00299                         tvec4<thalf>& operator= (tvec4<thalf> const & v);
00300 
00301                         tvec4<thalf>& operator+=(thalf const & s);
00302                         tvec4<thalf>& operator+=(tvec4<thalf> const & v);
00303                         tvec4<thalf>& operator-=(thalf const & s);
00304                         tvec4<thalf>& operator-=(tvec4<thalf> const & v);
00305                         tvec4<thalf>& operator*=(thalf const & s);
00306                         tvec4<thalf>& operator*=(tvec4<thalf> const & v);
00307                         tvec4<thalf>& operator/=(thalf const & s);
00308                         tvec4<thalf>& operator/=(tvec4<thalf> const & v);
00309                         tvec4<thalf>& operator++();
00310                         tvec4<thalf>& operator--();
00311 
00313                         // Swizzle operators
00314 
00315                         thalf swizzle(comp X) const;
00316                         tvec2<thalf> swizzle(comp X, comp Y) const;
00317                         tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
00318                         tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
00319                         tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
00320                 };
00321 #endif//_MSC_EXTENSIONS
00322         }
00323         //namespace detail
00324 
00325         namespace gtc{
00327         namespace half_float
00328         {
00331 
00334                 typedef detail::thalf                                   half;
00335 
00338                 typedef detail::tvec2<detail::thalf>    hvec2;
00339 
00342                 typedef detail::tvec3<detail::thalf>    hvec3;
00343 
00346                 typedef detail::tvec4<detail::thalf>    hvec4;
00347 
00350                 typedef detail::tmat2x2<detail::thalf>  hmat2;
00351 
00354                 typedef detail::tmat3x3<detail::thalf>  hmat3;
00355 
00358                 typedef detail::tmat4x4<detail::thalf>  hmat4;
00359 
00361 
00362         }//namespace half_float
00363         }//namespace gtc
00364 }//namespace glm
00365 
00366 #include "half_float.inl"
00367 
00368 namespace glm{using namespace gtc::half_float;}
00369 
00370 #endif//glm_gtc_half_float
Generated by  doxygen 1.7.3