_vectorize.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 #pragma once
00030 
00031 #include "type_vec1.hpp"
00032 #include "type_vec2.hpp"
00033 #include "type_vec3.hpp"
00034 #include "type_vec4.hpp"
00035 
00036 #define VECTORIZE1_VEC(func)                                            \
00037         template <typename T, precision P>                              \
00038         GLM_FUNC_QUALIFIER detail::tvec1<T, P> func(    \
00039                 detail::tvec1<T, P> const & v)                          \
00040         {                                                                                               \
00041                 return detail::tvec1<T, P>(                                     \
00042                         func(v.x));                                                             \
00043         }
00044 
00045 #define VECTORIZE2_VEC(func)                                            \
00046         template <typename T, precision P>                              \
00047         GLM_FUNC_QUALIFIER detail::tvec2<T, P> func(    \
00048                 detail::tvec2<T, P> const & v)                          \
00049         {                                                                                               \
00050                 return detail::tvec2<T, P>(                                     \
00051                         func(v.x),                                                              \
00052                         func(v.y));                                                             \
00053         }
00054 
00055 #define VECTORIZE3_VEC(func)                                            \
00056         template <typename T, precision P>                              \
00057         GLM_FUNC_QUALIFIER detail::tvec3<T, P> func(    \
00058                 detail::tvec3<T, P> const & v)                          \
00059         {                                                                                               \
00060                 return detail::tvec3<T, P>(                                     \
00061                         func(v.x),                                                              \
00062                         func(v.y),                                                              \
00063                         func(v.z));                                                             \
00064         }
00065 
00066 #define VECTORIZE4_VEC(func)                                            \
00067         template <typename T, precision P>                              \
00068         GLM_FUNC_QUALIFIER detail::tvec4<T, P> func(    \
00069                 detail::tvec4<T, P> const & v)                          \
00070         {                                                                                               \
00071                 return detail::tvec4<T, P>(                                     \
00072                         func(v.x),                                                              \
00073                         func(v.y),                                                              \
00074                         func(v.z),                                                              \
00075                         func(v.w));                                                             \
00076         }
00077 
00078 #define VECTORIZE_VEC(func)             \
00079         VECTORIZE1_VEC(func)            \
00080         VECTORIZE2_VEC(func)            \
00081         VECTORIZE3_VEC(func)            \
00082         VECTORIZE4_VEC(func)
00083 
00084 #define VECTORIZE1_VEC_SCA(func)                                                        \
00085         template <typename T, precision P>                                              \
00086         GLM_FUNC_QUALIFIER detail::tvec1<T, P> func                             \
00087         (                                                                                                               \
00088                 detail::tvec1<T, P> const & x,                                          \
00089                 typename detail::tvec1<T, P>::value_type const & y      \
00090         )                                                                                                               \
00091         {                                                                                                               \
00092                 return detail::tvec1<T, P>(                                                     \
00093                         func(x.x, y));                                                                  \
00094         }
00095 
00096 #define VECTORIZE2_VEC_SCA(func)                                                        \
00097         template <typename T, precision P>                                              \
00098         GLM_FUNC_QUALIFIER detail::tvec2<T, P> func                             \
00099         (                                                                                                               \
00100                 detail::tvec2<T, P> const & x,                                          \
00101                 typename detail::tvec2<T, P>::value_type const & y      \
00102         )                                                                                                               \
00103         {                                                                                                               \
00104                 return detail::tvec2<T, P>(                                                     \
00105                         func(x.x, y),                                                                   \
00106                         func(x.y, y));                                                                  \
00107         }
00108 
00109 #define VECTORIZE3_VEC_SCA(func)                                                        \
00110         template <typename T, precision P>                                              \
00111         GLM_FUNC_QUALIFIER detail::tvec3<T, P> func                             \
00112         (                                                                                                               \
00113                 detail::tvec3<T, P> const & x,                                          \
00114                 typename detail::tvec3<T, P>::value_type const & y      \
00115         )                                                                                                               \
00116         {                                                                                                               \
00117                 return detail::tvec3<T, P>(                                                     \
00118                         func(x.x, y),                                                                   \
00119                         func(x.y, y),                                                                   \
00120                         func(x.z, y));                                                                  \
00121         }
00122 
00123 #define VECTORIZE4_VEC_SCA(func)                                                        \
00124         template <typename T, precision P>                                              \
00125         GLM_FUNC_QUALIFIER detail::tvec4<T, P> func                             \
00126         (                                                                                                               \
00127                 detail::tvec4<T, P> const & x,                                          \
00128                 typename detail::tvec4<T, P>::value_type const & y      \
00129         )                                                                                                               \
00130         {                                                                                                               \
00131                 return detail::tvec4<T, P>(                                                     \
00132                         func(x.x, y),                                                                   \
00133                         func(x.y, y),                                                                   \
00134                         func(x.z, y),                                                                   \
00135                         func(x.w, y));                                                                  \
00136         }
00137 
00138 #define VECTORIZE_VEC_SCA(func)         \
00139         VECTORIZE1_VEC_SCA(func)                \
00140         VECTORIZE2_VEC_SCA(func)                \
00141         VECTORIZE3_VEC_SCA(func)                \
00142         VECTORIZE4_VEC_SCA(func)
00143 
00144 #define VECTORIZE1_VEC_VEC(func)                                        \
00145         template <typename T, precision P>                              \
00146         GLM_FUNC_QUALIFIER detail::tvec1<T, P> func             \
00147         (                                                                                               \
00148                 detail::tvec1<T, P> const & x,                          \
00149                 detail::tvec1<T, P> const & y                           \
00150         )                                                                                               \
00151         {                                                                                               \
00152                 return detail::tvec1<T, P>(                                     \
00153                         func(x.x, y.x));                                                \
00154         }
00155 
00156 #define VECTORIZE2_VEC_VEC(func)                                        \
00157         template <typename T, precision P>                              \
00158         GLM_FUNC_QUALIFIER detail::tvec2<T, P> func             \
00159         (                                                                                               \
00160                 detail::tvec2<T, P> const & x,                          \
00161                 detail::tvec2<T, P> const & y                           \
00162         )                                                                                               \
00163         {                                                                                               \
00164                 return detail::tvec2<T, P>(                                     \
00165                         func(x.x, y.x),                                                 \
00166                         func(x.y, y.y));                                                \
00167         }
00168 
00169 #define VECTORIZE3_VEC_VEC(func)                                        \
00170         template <typename T, precision P>                              \
00171         GLM_FUNC_QUALIFIER detail::tvec3<T, P> func             \
00172         (                                                                                               \
00173                 detail::tvec3<T, P> const & x,                          \
00174                 detail::tvec3<T, P> const & y                           \
00175         )                                                                                               \
00176         {                                                                                               \
00177                 return detail::tvec3<T, P>(                                     \
00178                         func(x.x, y.x),                                                 \
00179                         func(x.y, y.y),                                                 \
00180                         func(x.z, y.z));                                                \
00181         }
00182 
00183 #define VECTORIZE4_VEC_VEC(func)                                \
00184         template <typename T, precision P>                      \
00185         GLM_FUNC_QUALIFIER detail::tvec4<T, P> func     \
00186         (                                                                                       \
00187                 detail::tvec4<T, P> const & x,                  \
00188                 detail::tvec4<T, P> const & y                   \
00189         )                                                                                       \
00190         {                                                                                       \
00191                 return detail::tvec4<T, P>(                             \
00192                         func(x.x, y.x),                                         \
00193                         func(x.y, y.y),                                         \
00194                         func(x.z, y.z),                                         \
00195                         func(x.w, y.w));                                        \
00196         }
00197 
00198 #define VECTORIZE_VEC_VEC(func)         \
00199         VECTORIZE1_VEC_VEC(func)                \
00200         VECTORIZE2_VEC_VEC(func)                \
00201         VECTORIZE3_VEC_VEC(func)                \
00202         VECTORIZE4_VEC_VEC(func)
00203 
00204 namespace glm{
00205 namespace detail
00206 {
00207         template<bool C>
00208         struct If
00209         {
00210                 template<typename F, typename T>
00211                 static GLM_FUNC_QUALIFIER T apply(F functor, const T& val)
00212                 {
00213                         return functor(val);
00214                 }
00215         };
00216 
00217         template<>
00218         struct If<false>
00219         {
00220                 template<typename F, typename T>
00221                 static GLM_FUNC_QUALIFIER T apply(F, const T& val)
00222                 {
00223                         return val;
00224                 }
00225         };
00226 }//namespace detail
00227 }//namespace glm


rtabmap
Author(s): Mathieu Labbe
autogenerated on Thu Jun 6 2019 21:59:18