- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List

_detail.hpp

    00001
    00002 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
    00004 // Created : 2008-07-24
    00005 // Updated : 2008-08-31
    00006 // Licence : This source is under MIT License
    00007 // File    : glm/core/_detail.hpp
    00009
    00010 #ifndef glm_core_detail
    00011 #define glm_core_detail
    00012
    00013 #include "setup.hpp"
    00014 #include <cassert>
    00015
    00016 namespace glm{
    00017 namespace detail
    00018 {
    00019         class thalf;
    00020
    00021 #if(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) // C99 detected, 64 bit types available
    00022         typedef int64_t                                                         sint64;
    00023         typedef uint64_t                                                        uint64;
    00024 #elif(GLM_COMPILER & GLM_COMPILER_VC)
    00025         typedef signed __int64                                          sint64;
    00026         typedef unsigned __int64                                        uint64;
    00027 #elif(GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC | GLM_COMPILER_CLANG))
    00028         __extension__ typedef signed long long          sint64;
    00029         __extension__ typedef unsigned long long        uint64;
    00030 #elif(GLM_COMPILER & GLM_COMPILER_BC)
    00031         typedef Int64                                                           sint64;
    00032         typedef Uint64                                                          uint64;
    00033 #else//unknown compiler
    00034         typedef signed long     long                                    sint64;
    00035         typedef unsigned long long                                      uint64;
    00036 #endif//GLM_COMPILER
    00037
    00038         template<bool C>
    00039         struct If
    00040         {
    00041                 template<typename F, typename T>
    00042                 static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
    00043                 {
    00044                         return functor(val);
    00045                 }
    00046         };
    00047
    00048         template<>
    00049         struct If<false>
    00050         {
    00051                 template<typename F, typename T>
    00052                 static GLM_FUNC_QUALIFIER T apply(F, const T& val)
    00053                 {
    00054                         return val;
    00055                 }
    00056         };
    00057
    00058         //template <typename T>
    00059         //struct traits
    00060         //{
    00061         //      static const bool is_signed = false;
    00062         //      static const bool is_float = false;
    00063         //      static const bool is_vector = false;
    00064         //      static const bool is_matrix = false;
    00065         //      static const bool is_genType = false;
    00066         //      static const bool is_genIType = false;
    00067         //      static const bool is_genUType = false;
    00068         //};
    00069
    00070         //template <>
    00071         //struct traits<half>
    00072         //{
    00073         //      static const bool is_float = true;
    00074         //      static const bool is_genType = true;
    00075         //};
    00076
    00077         //template <>
    00078         //struct traits<float>
    00079         //{
    00080         //      static const bool is_float = true;
    00081         //      static const bool is_genType = true;
    00082         //};
    00083
    00084         //template <>
    00085         //struct traits<double>
    00086         //{
    00087         //      static const bool is_float = true;
    00088         //      static const bool is_genType = true;
    00089         //};
    00090
    00091         //template <typename genType>
    00092         //struct desc
    00093         //{
    00094         //      typedef genType                                                 type;
    00095         //      typedef genType *                                               pointer;
    00096         //      typedef genType const*                                  const_pointer;
    00097         //      typedef genType const *const                    const_pointer_const;
    00098         //      typedef genType *const                                  pointer_const;
    00099         //      typedef genType &                                               reference;
    00100         //      typedef genType const&                                  const_reference;
    00101         //      typedef genType const&                                  param_type;
    00102
    00103         //      typedef typename genType::value_type    value_type;
    00104         //      typedef typename genType::size_type             size_type;
    00105         //      static const typename size_type                 value_size;
    00106         //};
    00107
    00108         //template <typename genType>
    00109         //const typename desc<genType>::size_type desc<genType>::value_size = genType::value_size();
    00110
    00111         union uif32
    00112         {
    00113                 GLM_FUNC_QUALIFIER uif32() :
    00114                         i(0)
    00115                 {}
    00116
    00117                 GLM_FUNC_QUALIFIER uif32(float f) :
    00118                         f(f)
    00119                 {}
    00120
    00121                 GLM_FUNC_QUALIFIER uif32(unsigned int i) :
    00122                         i(i)
    00123                 {}
    00124
    00125                 float f;
    00126                 unsigned int i;
    00127         };
    00128
    00129         union uif64
    00130         {
    00131                 GLM_FUNC_QUALIFIER uif64() :
    00132                         i(0)
    00133                 {}
    00134
    00135                 GLM_FUNC_QUALIFIER uif64(double f) :
    00136                         f(f)
    00137                 {}
    00138
    00139                 GLM_FUNC_QUALIFIER uif64(uint64 i) :
    00140                         i(i)
    00141                 {}
    00142
    00143                 double f;
    00144                 uint64 i;
    00145         };
    00146
    00147         typedef uif32 uif;
    00148
    00150         // int
    00151
    00152         template <typename T>
    00153         struct is_int
    00154         {
    00155                 enum is_int_enum
    00156                 {
    00157                         _YES = 0,
    00158                         _NO = 1
    00159                 };
    00160         };
    00161
    00162 #define GLM_DETAIL_IS_INT(T)    \
    00163         template <>                                     \
    00164         struct is_int<T>                        \
    00165         {                                                       \
    00166                 enum is_int_enum                \
    00167                 {                                               \
    00168                         _YES = 1,                       \
    00169                         _NO = 0                         \
    00170                 };                                              \
    00171         }
    00172
    00174         // uint
    00175
    00176         template <typename T>
    00177         struct is_uint
    00178         {
    00179                 enum is_uint_enum
    00180                 {
    00181                         _YES = 0,
    00182                         _NO = 1
    00183                 };
    00184         };
    00185
    00186 #define GLM_DETAIL_IS_UINT(T)   \
    00187         template <>                                     \
    00188         struct is_uint<T>                       \
    00189         {                                                       \
    00190                 enum is_uint_enum               \
    00191                 {                                               \
    00192                         _YES = 1,                       \
    00193                         _NO = 0                         \
    00194                 };                                              \
    00195         }
    00196
    00197         //GLM_DETAIL_IS_UINT(unsigned long long)
    00198
    00200         // float
    00201
    00202         template <typename T>
    00203         struct is_float
    00204         {
    00205                 enum is_float_enum
    00206                 {
    00207                         _YES = 0,
    00208                         _NO = 1
    00209                 };
    00210         };
    00211
    00212 #define GLM_DETAIL_IS_FLOAT(T)  \
    00213         template <>                                     \
    00214         struct is_float<T>                      \
    00215         {                                                       \
    00216                 enum is_float_enum              \
    00217                 {                                               \
    00218                         _YES = 1,                       \
    00219                         _NO = 0                         \
    00220                 };                                              \
    00221         }
    00222
    00224         // bool
    00225
    00226         template <typename T>
    00227         struct is_bool
    00228         {
    00229                 enum is_bool_enum
    00230                 {
    00231                         _YES = 0,
    00232                         _NO = 1
    00233                 };
    00234         };
    00235
    00236         template <>
    00237         struct is_bool<bool>
    00238         {
    00239                 enum is_bool_enum
    00240                 {
    00241                         _YES = 1,
    00242                         _NO = 0
    00243                 };
    00244         };
    00245
    00247         // vector
    00248
    00249         template <typename T>
    00250         struct is_vector
    00251         {
    00252                 enum is_vector_enum
    00253                 {
    00254                         _YES = 0,
    00255                         _NO = 1
    00256                 };
    00257         };
    00258
    00259 #       define GLM_DETAIL_IS_VECTOR(TYPE) \
    00260                 template <typename T> \
    00261                 struct is_vector<TYPE<T> > \
    00262                 { \
    00263                         enum is_vector_enum \
    00264                         { \
    00265                                 _YES = 1, \
    00266                                 _NO = 0 \
    00267                         }; \
    00268                 }
    00269
    00271         // matrix
    00272
    00273         template <typename T>
    00274         struct is_matrix
    00275         {
    00276                 enum is_matrix_enum
    00277                 {
    00278                         _YES = 0,
    00279                         _NO = 1
    00280                 };
    00281         };
    00282
    00283 #define GLM_DETAIL_IS_MATRIX(T) \
    00284         template <>                                     \
    00285         struct is_matrix                        \
    00286         {                                                       \
    00287                 enum is_matrix_enum             \
    00288                 {                                               \
    00289                         _YES = 1,                       \
    00290                         _NO = 0                         \
    00291                 };                                              \
    00292         }
    00293
    00295         // type
    00296
    00297         template <typename T>
    00298         struct type
    00299         {
    00300                 enum type_enum
    00301                 {
    00302                         is_float = is_float<T>::_YES,
    00303                         is_int = is_int<T>::_YES,
    00304                         is_uint = is_uint<T>::_YES,
    00305                         is_bool = is_bool<T>::_YES
    00306                 };
    00307         };
    00308
    00310         // type
    00311
    00312         typedef signed char                                                     int8;
    00313         typedef signed short                                            int16;
    00314         typedef signed int                                                      int32;
    00315         typedef detail::sint64                                          int64;
    00316
    00317         typedef unsigned char                                           uint8;
    00318         typedef unsigned short                                          uint16;
    00319         typedef unsigned int                                            uint32;
    00320         typedef detail::uint64                                          uint64;
    00321
    00322         typedef detail::thalf                                           float16;
    00323         typedef float                                                           float32;
    00324         typedef double                                                          float64;
    00325
    00326 }//namespace detail
    00327 }//namespace glm
    00328
    00329 #if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC2005))
    00330 #       define GLM_DEPRECATED __declspec(deprecated)
    00331 #       define GLM_ALIGN(x) __declspec(align(x))
    00332 #       define GLM_ALIGNED_STRUCT(x) __declspec(align(x)) struct
    00333 #       define GLM_RESTRICT __declspec(restrict)
    00334 #       define GLM_RESTRICT_VAR __restrict
    00335 #elif((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31))
    00336 #       define GLM_DEPRECATED __attribute__((__deprecated__))
    00337 #       define GLM_ALIGN(x) __attribute__((aligned(x)))
    00338 #       define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))
    00339 #       if(GLM_COMPILER >= GLM_COMPILER_GCC33)
    00340 #               define GLM_RESTRICT __restrict__
    00341 #               define GLM_RESTRICT_VAR __restrict__
    00342 #       else
    00343 #               define GLM_RESTRICT
    00344 #               define GLM_RESTRICT_VAR
    00345 #       endif
    00346 #       define GLM_RESTRICT __restrict__
    00347 #       define GLM_RESTRICT_VAR __restrict__
    00348 #else
    00349 #       define GLM_DEPRECATED
    00350 #       define GLM_ALIGN
    00351 #       define GLM_ALIGNED_STRUCT(x)
    00352 #       define GLM_RESTRICT
    00353 #       define GLM_RESTRICT_VAR
    00354 #endif//GLM_COMPILER
    00355
    00356 #endif//glm_core_detail