type_ptr.hpp Source File

- Main Page
- Modules
- Namespaces
- Classes
- Files

- File List

# 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 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
    00020 #       pragma message("GLM: GLM_GTC_type_ptr extension included")
    00021 #endif
    00022
    00023 namespace glm
    00024 {
    00025         namespace test{
    00026                 void main_gtc_type_ptr();
    00027         }//namespace test
    00028
    00029         namespace gtc{
    00031         namespace type_ptr{
    00032
    00035
    00038                 template<typename T>
    00039                 inline T const * value_ptr
    00040                 (
    00041                         detail::tvec2<T> const & vec
    00042                 )
    00043                 {
    00044                         return &(vec.x);
    00045                 }
    00046
    00049                 template<typename T>
    00050                 inline T * value_ptr
    00051                 (
    00052                         detail::tvec2<T> & vec
    00053                 )
    00054                 {
    00055                         return &(vec.x);
    00056                 }
    00057
    00060                 template<typename T>
    00061                 inline T const * value_ptr
    00062                 (
    00063                         detail::tvec3<T> const & vec
    00064                 )
    00065                 {
    00066                         return &(vec.x);
    00067                 }
    00068
    00071                 template<typename T>
    00072                 inline T * value_ptr
    00073                 (
    00074                         detail::tvec3<T> & vec
    00075                 )
    00076                 {
    00077                         return &(vec.x);
    00078                 }
    00079
    00082                 template<typename T>
    00083                 inline T const * value_ptr
    00084                 (
    00085                         detail::tvec4<T> const & vec
    00086                 )
    00087                 {
    00088                         return &(vec.x);
    00089                 }
    00090
    00093                 template<typename T>
    00094                 inline T * value_ptr
    00095                 (
    00096                         detail::tvec4<T> & vec
    00097                 )
    00098                 {
    00099                         return &(vec.x);
    00100                 }
    00101
    00104                 template<typename T>
    00105                 inline T const * value_ptr
    00106                 (
    00107                         detail::tmat2x2<T> const & mat
    00108                 )
    00109                 {
    00110                         return &(mat[0].x);
    00111                 }
    00112
    00115                 template<typename T>
    00116                 inline T * value_ptr
    00117                 (
    00118                         detail::tmat2x2<T> & mat
    00119                 )
    00120                 {
    00121                         return &(mat[0].x);
    00122                 }
    00123
    00126                 template<typename T>
    00127                 inline T const * value_ptr
    00128                 (
    00129                         detail::tmat3x3<T> const & mat
    00130                 )
    00131                 {
    00132                         return &(mat[0].x);
    00133                 }
    00134
    00137                 template<typename T>
    00138                 inline T * value_ptr
    00139                 (
    00140                         detail::tmat3x3<T> & mat
    00141                 )
    00142                 {
    00143                         return &(mat[0].x);
    00144                 }
    00145
    00148                 template<typename T>
    00149                 inline T const * value_ptr
    00150                 (
    00151                         detail::tmat4x4<T> const & mat
    00152                 )
    00153                 {
    00154                         return &(mat[0].x);
    00155                 }
    00156
    00159                 template<typename T>
    00160                 inline T * value_ptr
    00161                 (
    00162                         detail::tmat4x4<T> & mat
    00163                 )
    00164                 {
    00165                         return &(mat[0].x);
    00166                 }
    00167
    00170                 template<typename T>
    00171                 inline T const * value_ptr
    00172                 (
    00173                         detail::tmat2x3<T> const & mat
    00174                 )
    00175                 {
    00176                         return &(mat[0].x);
    00177                 }
    00178
    00181                 template<typename T>
    00182                 inline T * value_ptr
    00183                 (
    00184                         detail::tmat2x3<T> & mat
    00185                 )
    00186                 {
    00187                         return &(mat[0].x);
    00188                 }
    00189
    00192                 template<typename T>
    00193                 inline T const * value_ptr
    00194                 (
    00195                         detail::tmat3x2<T> const & mat
    00196                 )
    00197                 {
    00198                         return &(mat[0].x);
    00199                 }
    00200
    00203                 template<typename T>
    00204                 inline T * value_ptr
    00205                 (
    00206                         detail::tmat3x2<T> & mat
    00207                 )
    00208                 {
    00209                         return &(mat[0].x);
    00210                 }
    00211
    00214                 template<typename T>
    00215                 inline T const * value_ptr
    00216                 (
    00217                         detail::tmat2x4<T> const & mat
    00218                 )
    00219                 {
    00220                         return &(mat[0].x);
    00221                 }
    00222
    00225                 template<typename T>
    00226                 inline T * value_ptr
    00227                 (
    00228                         detail::tmat2x4<T> & mat
    00229                 )
    00230                 {
    00231                         return &(mat[0].x);
    00232                 }
    00233
    00236                 template<typename T>
    00237                 inline T const * value_ptr
    00238                 (
    00239                         detail::tmat4x2<T> const & mat
    00240                 )
    00241                 {
    00242                         return &(mat[0].x);
    00243                 }
    00244
    00247                 template<typename T>
    00248                 inline T * value_ptr
    00249                 (
    00250                         detail::tmat4x2<T> & mat
    00251                 )
    00252                 {
    00253                         return &(mat[0].x);
    00254                 }
    00255
    00258                 template<typename T>
    00259                 inline T const * value_ptr
    00260                 (
    00261                         detail::tmat3x4<T> const & mat
    00262                 )
    00263                 {
    00264                         return &(mat[0].x);
    00265                 }
    00266
    00269                 template<typename T>
    00270                 inline T * value_ptr
    00271                 (
    00272                         detail::tmat3x4<T> & mat
    00273                 )
    00274                 {
    00275                         return &(mat[0].x);
    00276                 }
    00277
    00280                 template<typename T>
    00281                 inline T const * value_ptr
    00282                 (
    00283                         detail::tmat4x3<T> const & mat
    00284                 )
    00285                 {
    00286                         return &(mat[0].x);
    00287                 }
    00288
    00291                 template<typename T>
    00292                 inline T * value_ptr(detail::tmat4x3<T> & mat)
    00293                 {
    00294                         return &(mat[0].x);
    00295                 }
    00296
    00298
    00299         }//namespace type_ptr
    00300         }//namespace gtc
    00301 }//namespace glm
    00302
    00303 #include "type_ptr.inl"
    00304
    00305 namespace glm{using namespace gtc::type_ptr;}
    00306
    00307 #endif//glm_gtx_type_ptr
    00308