GLM Version 0.9.0

type_ptr.hpp

00001 
00002 // OpenGL Mathematics Copyright (c) 2005 - 2011 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