- Main Page
- Namespaces
- Files

- File List

# type_ptr.hpp

    00001
    00002 // OpenGL Mathematics Copyright (c) 2005 - 2010 G-Truc Creation (www.g-truc.net)
    00004 // Created : 2009-05-06
    00005 // Updated : 2010-04-30
    00006 // Licence : This source is under MIT License
    00007 // File    : glm/gtc/type_ptr.hpp
    00009 // Dependency:
    00010 // - GLM core
    00012
    00013 #ifndef glm_gtc_type_ptr
    00014 #define glm_gtc_type_ptr
    00015
    00016 // Dependency:
    00017 #include "../glm.hpp"
    00018
    00019 namespace glm
    00020 {
    00021         namespace test{
    00022                 void main_gtc_type_ptr();
    00023         }//namespace test
    00024
    00025         namespace gtc{
    00027         namespace type_ptr{
    00028
    00031                 template<typename T>
    00032                 inline T const * value_ptr
    00033                 (
    00034                         detail::tvec2<T> const & vec
    00035                 )
    00036                 {
    00037                         return &(vec.x);
    00038                 }
    00039
    00042                 template<typename T>
    00043                 inline T * value_ptr
    00044                 (
    00045                         detail::tvec2<T> & vec
    00046                 )
    00047                 {
    00048                         return &(vec.x);
    00049                 }
    00050
    00053                 template<typename T>
    00054                 inline T const * value_ptr
    00055                 (
    00056                         detail::tvec3<T> const & vec
    00057                 )
    00058                 {
    00059                         return &(vec.x);
    00060                 }
    00061
    00064                 template<typename T>
    00065                 inline T * value_ptr
    00066                 (
    00067                         detail::tvec3<T> & vec
    00068                 )
    00069                 {
    00070                         return &(vec.x);
    00071                 }
    00072
    00075                 template<typename T>
    00076                 inline T const * value_ptr
    00077                 (
    00078                         detail::tvec4<T> const & vec
    00079                 )
    00080                 {
    00081                         return &(vec.x);
    00082                 }
    00083
    00086                 template<typename T>
    00087                 inline T * value_ptr
    00088                 (
    00089                         detail::tvec4<T> & vec
    00090                 )
    00091                 {
    00092                         return &(vec.x);
    00093                 }
    00094
    00097                 template<typename T>
    00098                 inline T const * value_ptr
    00099                 (
    00100                         detail::tmat2x2<T> const & mat
    00101                 )
    00102                 {
    00103                         return &(mat[0].x);
    00104                 }
    00105
    00108                 template<typename T>
    00109                 inline T * value_ptr
    00110                 (
    00111                         detail::tmat2x2<T> & mat
    00112                 )
    00113                 {
    00114                         return &(mat[0].x);
    00115                 }
    00116
    00119                 template<typename T>
    00120                 inline T const * value_ptr
    00121                 (
    00122                         detail::tmat3x3<T> const & mat
    00123                 )
    00124                 {
    00125                         return &(mat[0].x);
    00126                 }
    00127
    00130                 template<typename T>
    00131                 inline T * value_ptr
    00132                 (
    00133                         detail::tmat3x3<T> & mat
    00134                 )
    00135                 {
    00136                         return &(mat[0].x);
    00137                 }
    00138
    00141                 template<typename T>
    00142                 inline T const * value_ptr
    00143                 (
    00144                         detail::tmat4x4<T> const & mat
    00145                 )
    00146                 {
    00147                         return &(mat[0].x);
    00148                 }
    00149
    00152                 template<typename T>
    00153                 inline T * value_ptr
    00154                 (
    00155                         detail::tmat4x4<T> & mat
    00156                 )
    00157                 {
    00158                         return &(mat[0].x);
    00159                 }
    00160
    00163                 template<typename T>
    00164                 inline T const * value_ptr
    00165                 (
    00166                         detail::tmat2x3<T> const & mat
    00167                 )
    00168                 {
    00169                         return &(mat[0].x);
    00170                 }
    00171
    00174                 template<typename T>
    00175                 inline T * value_ptr
    00176                 (
    00177                         detail::tmat2x3<T> & mat
    00178                 )
    00179                 {
    00180                         return &(mat[0].x);
    00181                 }
    00182
    00185                 template<typename T>
    00186                 inline T const * value_ptr
    00187                 (
    00188                         detail::tmat3x2<T> const & mat
    00189                 )
    00190                 {
    00191                         return &(mat[0].x);
    00192                 }
    00193
    00196                 template<typename T>
    00197                 inline T * value_ptr
    00198                 (
    00199                         detail::tmat3x2<T> & mat
    00200                 )
    00201                 {
    00202                         return &(mat[0].x);
    00203                 }
    00204
    00207                 template<typename T>
    00208                 inline T const * value_ptr
    00209                 (
    00210                         detail::tmat2x4<T> const & mat
    00211                 )
    00212                 {
    00213                         return &(mat[0].x);
    00214                 }
    00215
    00218                 template<typename T>
    00219                 inline T * value_ptr
    00220                 (
    00221                         detail::tmat2x4<T> & mat
    00222                 )
    00223                 {
    00224                         return &(mat[0].x);
    00225                 }
    00226
    00229                 template<typename T>
    00230                 inline T const * value_ptr
    00231                 (
    00232                         detail::tmat4x2<T> const & mat
    00233                 )
    00234                 {
    00235                         return &(mat[0].x);
    00236                 }
    00237
    00240                 template<typename T>
    00241                 inline T * value_ptr
    00242                 (
    00243                         detail::tmat4x2<T> & mat
    00244                 )
    00245                 {
    00246                         return &(mat[0].x);
    00247                 }
    00248
    00251                 template<typename T>
    00252                 inline T const * value_ptr
    00253                 (
    00254                         detail::tmat3x4<T> const & mat
    00255                 )
    00256                 {
    00257                         return &(mat[0].x);
    00258                 }
    00259
    00262                 template<typename T>
    00263                 inline T * value_ptr
    00264                 (
    00265                         detail::tmat3x4<T> & mat
    00266                 )
    00267                 {
    00268                         return &(mat[0].x);
    00269                 }
    00270
    00273                 template<typename T>
    00274                 inline T const * value_ptr
    00275                 (
    00276                         detail::tmat4x3<T> const & mat
    00277                 )
    00278                 {
    00279                         return &(mat[0].x);
    00280                 }
    00281
    00284                 template<typename T>
    00285                 inline T * value_ptr(detail::tmat4x3<T> & mat)
    00286                 {
    00287                         return &(mat[0].x);
    00288                 }
    00289
    00290         }//namespace type_ptr
    00291         }//namespace gtc
    00292 }//namespace glm
    00293
    00294 #include "type_ptr.inl"
    00295
    00296 namespace glm{using namespace gtc::type_ptr;}
    00297
    00298 #endif//glm_gtx_type_ptr
    00299