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

- File List

_detail.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_detail
    00030 #define glm_core_detail
    00031
    00032 #include "setup.hpp"
    00033 #include <cassert>
    00034 #if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))
    00035 #include <cstdint>
    00036 #endif
    00037
    00038 namespace glm{
    00039 namespace detail
    00040 {
    00041         class half;
    00042
    00043 #if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
    00044         typedef int64_t                                                         sint64;
    00045         typedef uint64_t                                                        uint64;
    00046 #elif(GLM_COMPILER & GLM_COMPILER_VC)
    00047         typedef signed __int64                                          sint64;
    00048         typedef unsigned __int64                                        uint64;
    00049 #elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
    00050         __extension__ typedef signed long long          sint64;
    00051         __extension__ typedef unsigned long long        uint64;
    00052 #elif(GLM_COMPILER & GLM_COMPILER_BC)
    00053         typedef Int64                                                           sint64;
    00054         typedef Uint64                                                          uint64;
    00055 #else//unknown compiler
    00056         typedef signed long     long                                    sint64;
    00057         typedef unsigned long long                                      uint64;
    00058 #endif//GLM_COMPILER
    00059
    00060         template<bool C>
    00061         struct If
    00062         {
    00063                 template<typename F, typename T>
    00064                 static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
    00065                 {
    00066                         return functor(val);
    00067                 }
    00068         };
    00069
    00070         template<>
    00071         struct If<false>
    00072         {
    00073                 template<typename F, typename T>
    00074                 static GLM_FUNC_QUALIFIER T apply(F, const T& val)
    00075                 {
    00076                         return val;
    00077                 }
    00078         };
    00079
    00080         //template <typename T>
    00081         //struct traits
    00082         //{
    00083         //      static const bool is_signed = false;
    00084         //      static const bool is_float = false;
    00085         //      static const bool is_vector = false;
    00086         //      static const bool is_matrix = false;
    00087         //      static const bool is_genType = false;
    00088         //      static const bool is_genIType = false;
    00089         //      static const bool is_genUType = false;
    00090         //};
    00091
    00092         //template <>
    00093         //struct traits<half>
    00094         //{
    00095         //      static const bool is_float = true;
    00096         //      static const bool is_genType = true;
    00097         //};
    00098
    00099         //template <>
    00100         //struct traits<float>
    00101         //{
    00102         //      static const bool is_float = true;
    00103         //      static const bool is_genType = true;
    00104         //};
    00105
    00106         //template <>
    00107         //struct traits<double>
    00108         //{
    00109         //      static const bool is_float = true;
    00110         //      static const bool is_genType = true;
    00111         //};
    00112
    00113         //template <typename genType>
    00114         //struct desc
    00115         //{
    00116         //      typedef genType                                                 type;
    00117         //      typedef genType *                                               pointer;
    00118         //      typedef genType const*                                  const_pointer;
    00119         //      typedef genType const *const                    const_pointer_const;
    00120         //      typedef genType *const                                  pointer_const;
    00121         //      typedef genType &                                               reference;
    00122         //      typedef genType const&                                  const_reference;
    00123         //      typedef genType const&                                  param_type;
    00124
    00125         //      typedef typename genType::value_type    value_type;
    00126         //      typedef typename genType::size_type             size_type;
    00127         //      static const typename size_type                 value_size;
    00128         //};
    00129
    00130         //template <typename genType>
    00131         //const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
    00132
    00133         union uif32
    00134         {
    00135                 GLM_FUNC_QUALIFIER uif32() :
    00136                         i(0)
    00137                 {}
    00138
    00139                 GLM_FUNC_QUALIFIER uif32(float f) :
    00140                         f(f)
    00141                 {}
    00142
    00143                 GLM_FUNC_QUALIFIER uif32(unsigned int i) :
    00144                         i(i)
    00145                 {}
    00146
    00147                 float f;
    00148                 unsigned int i;
    00149         };
    00150
    00151         union uif64
    00152         {
    00153                 GLM_FUNC_QUALIFIER uif64() :
    00154                         i(0)
    00155                 {}
    00156
    00157                 GLM_FUNC_QUALIFIER uif64(double f) :
    00158                         f(f)
    00159                 {}
    00160
    00161                 GLM_FUNC_QUALIFIER uif64(uint64 i) :
    00162                         i(i)
    00163                 {}
    00164
    00165                 double f;
    00166                 uint64 i;
    00167         };
    00168
    00169         typedef uif32 uif;
    00170
    00172         // int
    00173
    00174         template <typename T>
    00175         struct is_int
    00176         {
    00177                 enum is_int_enum
    00178                 {
    00179                         _YES = 0,
    00180                         _NO = 1
    00181                 };
    00182         };
    00183
    00184 #define GLM_DETAIL_IS_INT(T)    \
    00185         template <>                                     \
    00186         struct is_int<T>                        \
    00187         {                                                       \
    00188                 enum is_int_enum                \
    00189                 {                                               \
    00190                         _YES = 1,                       \
    00191                         _NO = 0                         \
    00192                 };                                              \
    00193         }
    00194
    00196         // uint
    00197
    00198         template <typename T>
    00199         struct is_uint
    00200         {
    00201                 enum is_uint_enum
    00202                 {
    00203                         _YES = 0,
    00204                         _NO = 1
    00205                 };
    00206         };
    00207
    00208 #define GLM_DETAIL_IS_UINT(T)   \
    00209         template <>                                     \
    00210         struct is_uint<T>                       \
    00211         {                                                       \
    00212                 enum is_uint_enum               \
    00213                 {                                               \
    00214                         _YES = 1,                       \
    00215                         _NO = 0                         \
    00216                 };                                              \
    00217         }
    00218
    00219         //GLM_DETAIL_IS_UINT(unsigned long long)
    00220
    00222         // float
    00223
    00224         template <typename T>
    00225         struct is_float
    00226         {
    00227                 enum is_float_enum
    00228                 {
    00229                         _YES = 0,
    00230                         _NO = 1
    00231                 };
    00232         };
    00233
    00234 #define GLM_DETAIL_IS_FLOAT(T)  \
    00235         template <>                                     \
    00236         struct is_float<T>                      \
    00237         {                                                       \
    00238                 enum is_float_enum              \
    00239                 {                                               \
    00240                         _YES = 1,                       \
    00241                         _NO = 0                         \
    00242                 };                                              \
    00243         }
    00244
    00245         GLM_DETAIL_IS_FLOAT(detail::half);
    00246         GLM_DETAIL_IS_FLOAT(float);
    00247         GLM_DETAIL_IS_FLOAT(double);
    00248         GLM_DETAIL_IS_FLOAT(long double);
    00249
    00251         // bool
    00252
    00253         template <typename T>
    00254         struct is_bool
    00255         {
    00256                 enum is_bool_enum
    00257                 {
    00258                         _YES = 0,
    00259                         _NO = 1
    00260                 };
    00261         };
    00262
    00263         template <>
    00264         struct is_bool<bool>
    00265         {
    00266                 enum is_bool_enum
    00267                 {
    00268                         _YES = 1,
    00269                         _NO = 0
    00270                 };
    00271         };
    00272
    00274         // vector
    00275
    00276         template <typename T>
    00277         struct is_vector
    00278         {
    00279                 enum is_vector_enum
    00280                 {
    00281                         _YES = 0,
    00282                         _NO = 1
    00283                 };
    00284         };
    00285
    00286 #       define GLM_DETAIL_IS_VECTOR(TYPE) \
    00287                 template <typename T> \
    00288                 struct is_vector<TYPE<T> > \
    00289                 { \
    00290                         enum is_vector_enum \
    00291                         { \
    00292                                 _YES = 1, \
    00293                                 _NO = 0 \
    00294                         }; \
    00295                 }
    00296
    00298         // matrix
    00299
    00300         template <typename T>
    00301         struct is_matrix
    00302         {
    00303                 enum is_matrix_enum
    00304                 {
    00305                         _YES = 0,
    00306                         _NO = 1
    00307                 };
    00308         };
    00309
    00310 #define GLM_DETAIL_IS_MATRIX(T) \
    00311         template <>                                     \
    00312         struct is_matrix                        \
    00313         {                                                       \
    00314                 enum is_matrix_enum             \
    00315                 {                                               \
    00316                         _YES = 1,                       \
    00317                         _NO = 0                         \
    00318                 };                                              \
    00319         }
    00320
    00322         // type
    00323
    00324         template <typename T>
    00325         struct type
    00326         {
    00327                 enum type_enum
    00328                 {
    00329                         is_float = is_float<T>::_YES,
    00330                         is_int = is_int<T>::_YES,
    00331                         is_uint = is_uint<T>::_YES,
    00332                         is_bool = is_bool<T>::_YES
    00333                 };
    00334         };
    00335
    00337         // type
    00338
    00339         typedef signed char                                                     int8;
    00340         typedef signed short                                            int16;
    00341         typedef signed int                                                      int32;
    00342         typedef detail::sint64                                          int64;
    00343
    00344         typedef unsigned char                                           uint8;
    00345         typedef unsigned short                                          uint16;
    00346         typedef unsigned int                                            uint32;
    00347         typedef detail::uint64                                          uint64;
    00348
    00349         typedef detail::half                                            float16;
    00350         typedef float                                                           float32;
    00351         typedef double                                                          float64;
    00352
    00354         // float_or_int_trait
    00355
    00356         struct float_or_int_value
    00357         {
    00358                 enum
    00359                 {
    00360                         ERROR,
    00361                         FLOAT,
    00362                         INT
    00363                 };
    00364         };
    00365
    00366         template <typename T>
    00367         struct float_or_int_trait
    00368         {
    00369                 enum{ID = float_or_int_value::ERROR};
    00370         };
    00371
    00372         template <>
    00373         struct float_or_int_trait<int8>
    00374         {
    00375                 enum{ID = float_or_int_value::INT};
    00376         };
    00377
    00378         template <>
    00379         struct float_or_int_trait<int16>
    00380         {
    00381                 enum{ID = float_or_int_value::INT};
    00382         };
    00383
    00384         template <>
    00385         struct float_or_int_trait<int32>
    00386         {
    00387                 enum{ID = float_or_int_value::INT};
    00388         };
    00389
    00390         template <>
    00391         struct float_or_int_trait<int64>
    00392         {
    00393                 enum{ID = float_or_int_value::INT};
    00394         };
    00395
    00396         template <>
    00397         struct float_or_int_trait<uint8>
    00398         {
    00399                 enum{ID = float_or_int_value::INT};
    00400         };
    00401
    00402         template <>
    00403         struct float_or_int_trait<uint16>
    00404         {
    00405                 enum{ID = float_or_int_value::INT};
    00406         };
    00407
    00408         template <>
    00409         struct float_or_int_trait<uint32>
    00410         {
    00411                 enum{ID = float_or_int_value::INT};
    00412         };
    00413
    00414         template <>
    00415         struct float_or_int_trait<uint64>
    00416         {
    00417                 enum{ID = float_or_int_value::INT};
    00418         };
    00419
    00420         template <>
    00421         struct float_or_int_trait<float16>
    00422         {
    00423                 enum{ID = float_or_int_value::FLOAT};
    00424         };
    00425
    00426         template <>
    00427         struct float_or_int_trait<float32>
    00428         {
    00429                 enum{ID = float_or_int_value::FLOAT};
    00430         };
    00431
    00432         template <>
    00433         struct float_or_int_trait<float64>
    00434         {
    00435                 enum{ID = float_or_int_value::FLOAT};
    00436         };
    00437
    00438 }//namespace detail
    00439 }//namespace glm
    00440
    00441 #if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
    00442 #       define GLM_DEPRECATED __declspec(deprecated)
    00443 #       define GLM_ALIGN(x) __declspec(align(x))
    00444 #       define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
    00445 #       define GLM_RESTRICT __declspec(restrict)
    00446 #       define GLM_RESTRICT_VAR __restrict
    00447 #elif((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31))
    00448 #       define GLM_DEPRECATED __attribute__((__deprecated__))
    00449 #       define GLM_ALIGN(x) __attribute__((aligned(x)))
    00450 #       define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
    00451 #       if(GLM_COMPILER >= GLM_COMPILER_GCC33)
    00452 #               define GLM_RESTRICT __restrict__
    00453 #               define GLM_RESTRICT_VAR __restrict__
    00454 #       else
    00455 #               define GLM_RESTRICT
    00456 #               define GLM_RESTRICT_VAR
    00457 #       endif
    00458 #       define GLM_RESTRICT __restrict__
    00459 #       define GLM_RESTRICT_VAR __restrict__
    00460 #else
    00461 #       define GLM_DEPRECATED
    00462 #       define GLM_ALIGN
    00463 #       define GLM_ALIGNED_STRUCT(x)
    00464 #       define GLM_RESTRICT
    00465 #       define GLM_RESTRICT_VAR
    00466 #endif//GLM_COMPILER
    00467
    00468 #endif//glm_core_detail