# GLM: type_ptr.hpp Source File

- Main Page
- Namespaces
- Files

- File List

# type_ptr.hpp

    00001
    00002 // OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
    00004 // Created : 2009-05-06
    00005 // Updated : 2009-05-06
    00006 // Licence : This source is under MIT License
    00007 // File    : glm/gtx/type_ptr.hpp
    00009 // Dependency:
    00010 // - GLM core
    00012
    00013 #ifndef glm_gtx_type_ptr
    00014 #define glm_gtx_type_ptr
    00015
    00016 // Dependency:
    00017 #include "../glm.hpp"
    00018
    00019 namespace glm
    00020 {
    00021         namespace test{
    00022                 void main_gtx_type_ptr();
    00023         }//namespace test
    00024
    00025         namespace gtx{
    00027         namespace type_ptr{
    00028
    00031                 template<typename valType>
    00032                 inline valType const * value_ptr(detail::tvec2<valType> const & vec)
    00033                 {
    00034                         return &(vec.x);
    00035                 }
    00036
    00039                 template<typename valType>
    00040                 inline valType * value_ptr(detail::tvec2<valType> & vec)
    00041                 {
    00042                         return &(vec.x);
    00043                 }
    00044
    00047                 template<typename valType>
    00048                 inline valType const * value_ptr(detail::tvec3<valType> const & vec)
    00049                 {
    00050                         return &(vec.x);
    00051                 }
    00052
    00055                 template<typename valType>
    00056                 inline valType * value_ptr(detail::tvec3<valType>  & vec)
    00057                 {
    00058                         return &(vec.x);
    00059                 }
    00060
    00063                 template<typename valType>
    00064                 inline valType const * value_ptr(detail::tvec4<valType> const & vec)
    00065                 {
    00066                         return &(vec.x);
    00067                 }
    00068
    00071                 template<typename valType>
    00072                 inline valType * value_ptr(detail::tvec4<valType> & vec)
    00073                 {
    00074                         return &(vec.x);
    00075                 }
    00076
    00079                 template<typename valType>
    00080                 inline valType const * value_ptr(detail::tmat2x2<valType> const & mat)
    00081                 {
    00082                         return &(mat[0].x);
    00083                 }
    00084
    00087                 template<typename valType>
    00088                 inline valType * value_ptr(detail::tmat2x2<valType> & mat)
    00089                 {
    00090                         return &(mat[0].x);
    00091                 }
    00092
    00095                 template<typename valType>
    00096                 inline valType const * value_ptr(detail::tmat3x3<valType> const & mat)
    00097                 {
    00098                         return &(mat[0].x);
    00099                 }
    00100
    00103                 template<typename valType>
    00104                 inline valType * value_ptr(detail::tmat3x3<valType> & mat)
    00105                 {
    00106                         return &(mat[0].x);
    00107                 }
    00108
    00111                 template<typename valType>
    00112                 inline valType const * value_ptr(detail::tmat4x4<valType> const & mat)
    00113                 {
    00114                         return &(mat[0].x);
    00115                 }
    00116
    00119                 template<typename valType>
    00120                 inline valType * value_ptr(detail::tmat4x4<valType> & mat)
    00121                 {
    00122                         return &(mat[0].x);
    00123                 }
    00124
    00127                 template<typename valType>
    00128                 inline valType const * value_ptr(detail::tmat2x3<valType> const & mat)
    00129                 {
    00130                         return &(mat[0].x);
    00131                 }
    00132
    00135                 template<typename valType>
    00136                 inline valType * value_ptr(detail::tmat2x3<valType> & mat)
    00137                 {
    00138                         return &(mat[0].x);
    00139                 }
    00140
    00143                 template<typename valType>
    00144                 inline valType const * value_ptr(detail::tmat3x2<valType> const & mat)
    00145                 {
    00146                         return &(mat[0].x);
    00147                 }
    00148
    00151                 template<typename valType>
    00152                 inline valType * value_ptr(detail::tmat3x2<valType> & mat)
    00153                 {
    00154                         return &(mat[0].x);
    00155                 }
    00156
    00159                 template<typename valType>
    00160                 inline valType const * value_ptr(detail::tmat2x4<valType> const & mat)
    00161                 {
    00162                         return &(mat[0].x);
    00163                 }
    00164
    00167                 template<typename valType>
    00168                 inline valType * value_ptr(detail::tmat2x4<valType> & mat)
    00169                 {
    00170                         return &(mat[0].x);
    00171                 }
    00172
    00175                 template<typename valType>
    00176                 inline valType const * value_ptr(detail::tmat4x2<valType> const & mat)
    00177                 {
    00178                         return &(mat[0].x);
    00179                 }
    00180
    00183                 template<typename valType>
    00184                 inline valType * value_ptr(detail::tmat4x2<valType> & mat)
    00185                 {
    00186                         return &(mat[0].x);
    00187                 }
    00188
    00191                 template<typename valType>
    00192                 inline valType const * value_ptr(detail::tmat3x4<valType> const & mat)
    00193                 {
    00194                         return &(mat[0].x);
    00195                 }
    00196
    00199                 template<typename valType>
    00200                 inline valType * value_ptr(detail::tmat3x4<valType> & mat)
    00201                 {
    00202                         return &(mat[0].x);
    00203                 }
    00204
    00207                 template<typename valType>
    00208                 inline valType const * value_ptr(detail::tmat4x3<valType> const & mat)
    00209                 {
    00210                         return &(mat[0].x);
    00211                 }
    00212
    00215                 template<typename valType>
    00216                 inline valType * value_ptr(detail::tmat4x3<valType> & mat)
    00217                 {
    00218                         return &(mat[0].x);
    00219                 }
    00220
    00221         }//namespace type_ptr
    00222         }//namespace gtx
    00223 }//namespace glm
    00224
    00225 #define GLM_GTX_type_ptr namespace gtx::type_ptr
    00226 #ifndef GLM_GTX_GLOBAL
    00227 namespace glm {using GLM_GTX_type_ptr;}
    00228 #endif//GLM_GTX_GLOBAL
    00229
    00230 #include "type_ptr.inl"
    00231
    00232 #endif//glm_gtx_type_ptr
    00233