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 #include <cstring>
00019 
00020 #if(defined(GLM_MESSAGES) && !defined(glm_ext))
00021 #       pragma message("GLM: GLM_GTC_type_ptr extension included")
00022 #endif
00023 
00024 namespace glm
00025 {
00026         namespace test{
00027                 void main_gtc_type_ptr();
00028         }//namespace test
00029 
00030         namespace gtc{
00032         namespace type_ptr{
00033 
00036 
00039                 template<typename T>
00040                 GLM_FUNC_QUALIFIER T const * value_ptr
00041                 (
00042                         detail::tvec2<T> const & vec
00043                 )
00044                 {
00045                         return &(vec.x);
00046                 }
00047 
00050                 template<typename T>
00051                 GLM_FUNC_QUALIFIER T * value_ptr
00052                 (
00053                         detail::tvec2<T> & vec
00054                 )
00055                 {
00056                         return &(vec.x);
00057                 }
00058 
00061                 template<typename T>
00062                 GLM_FUNC_QUALIFIER T const * value_ptr
00063                 (
00064                         detail::tvec3<T> const & vec
00065                 )
00066                 {
00067                         return &(vec.x);
00068                 }
00069 
00072                 template<typename T>
00073                 GLM_FUNC_QUALIFIER T * value_ptr
00074                 (
00075                         detail::tvec3<T> & vec
00076                 )
00077                 {
00078                         return &(vec.x);
00079                 }
00080                 
00083                 template<typename T>
00084                 GLM_FUNC_QUALIFIER T const * value_ptr
00085                 (       
00086                         detail::tvec4<T> const & vec
00087                 )
00088                 {
00089                         return &(vec.x);
00090                 }
00091 
00094                 template<typename T>
00095                 GLM_FUNC_QUALIFIER T * value_ptr
00096                 (       
00097                         detail::tvec4<T> & vec
00098                 )
00099                 {
00100                         return &(vec.x);
00101                 }
00102 
00105                 template<typename T>
00106                 GLM_FUNC_QUALIFIER T const * value_ptr
00107                 (
00108                         detail::tmat2x2<T> const & mat
00109                 )
00110                 {
00111                         return &(mat[0].x);
00112                 }
00113 
00116                 template<typename T>
00117                 GLM_FUNC_QUALIFIER T * value_ptr
00118                 (
00119                         detail::tmat2x2<T> & mat
00120                 )
00121                 {
00122                         return &(mat[0].x);
00123                 }
00124                 
00127                 template<typename T>
00128                 GLM_FUNC_QUALIFIER T const * value_ptr
00129                 (
00130                         detail::tmat3x3<T> const & mat
00131                 )
00132                 {
00133                         return &(mat[0].x);
00134                 }
00135 
00138                 template<typename T>
00139                 GLM_FUNC_QUALIFIER T * value_ptr
00140                 (
00141                         detail::tmat3x3<T> & mat
00142                 )
00143                 {
00144                         return &(mat[0].x);
00145                 }
00146                 
00149                 template<typename T>
00150                 GLM_FUNC_QUALIFIER T const * value_ptr
00151                 (
00152                         detail::tmat4x4<T> const & mat
00153                 )
00154                 {
00155                         return &(mat[0].x);
00156                 }
00157 
00160                 template<typename T>
00161                 GLM_FUNC_QUALIFIER T * value_ptr
00162                 (
00163                         detail::tmat4x4<T> & mat
00164                 )
00165                 {
00166                         return &(mat[0].x);
00167                 }
00168 
00171                 template<typename T>
00172                 GLM_FUNC_QUALIFIER T const * value_ptr
00173                 (
00174                         detail::tmat2x3<T> const & mat
00175                 )
00176                 {
00177                         return &(mat[0].x);
00178                 }
00179 
00182                 template<typename T>
00183                 GLM_FUNC_QUALIFIER T * value_ptr
00184                 (
00185                         detail::tmat2x3<T> & mat
00186                 )
00187                 {
00188                         return &(mat[0].x);
00189                 }
00190                 
00193                 template<typename T>
00194                 GLM_FUNC_QUALIFIER T const * value_ptr
00195                 (
00196                         detail::tmat3x2<T> const & mat
00197                 )
00198                 {
00199                         return &(mat[0].x);
00200                 }
00201 
00204                 template<typename T>
00205                 GLM_FUNC_QUALIFIER T * value_ptr
00206                 (
00207                         detail::tmat3x2<T> & mat
00208                 )
00209                 {
00210                         return &(mat[0].x);
00211                 }
00212                 
00215                 template<typename T>
00216                 GLM_FUNC_QUALIFIER T const * value_ptr
00217                 (
00218                         detail::tmat2x4<T> const & mat
00219                 )
00220                 {
00221                         return &(mat[0].x);
00222                 }
00223 
00226                 template<typename T>
00227                 GLM_FUNC_QUALIFIER T * value_ptr
00228                 (
00229                         detail::tmat2x4<T> & mat
00230                 )
00231                 {
00232                         return &(mat[0].x);
00233                 }
00234                 
00237                 template<typename T>
00238                 GLM_FUNC_QUALIFIER T const * value_ptr
00239                 (
00240                         detail::tmat4x2<T> const & mat
00241                 )
00242                 {
00243                         return &(mat[0].x);
00244                 }
00245 
00248                 template<typename T>
00249                 GLM_FUNC_QUALIFIER T * value_ptr
00250                 (       
00251                         detail::tmat4x2<T> & mat
00252                 )
00253                 {
00254                         return &(mat[0].x);
00255                 }
00256                 
00259                 template<typename T>
00260                 GLM_FUNC_QUALIFIER T const * value_ptr
00261                 (
00262                         detail::tmat3x4<T> const & mat
00263                 )
00264                 {
00265                         return &(mat[0].x);
00266                 }
00267 
00270                 template<typename T>
00271                 GLM_FUNC_QUALIFIER T * value_ptr
00272                 (
00273                         detail::tmat3x4<T> & mat
00274                 )
00275                 {
00276                         return &(mat[0].x);
00277                 }
00278                 
00281                 template<typename T>
00282                 GLM_FUNC_QUALIFIER T const * value_ptr
00283                 (
00284                         detail::tmat4x3<T> const & mat
00285                 )
00286                 {
00287                         return &(mat[0].x);
00288                 }
00289 
00292                 template<typename T>
00293                 GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
00294                 {
00295                         return &(mat[0].x);
00296                 }
00297 
00300                 template<typename T>
00301                 GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
00302                 {
00303                         detail::tvec2<T> Result;
00304                         memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
00305                         return Result;
00306                 }
00307 
00310                 template<typename T>
00311                 GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
00312                 {
00313                         detail::tvec3<T> Result;
00314                         memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
00315                         return Result;
00316                 }
00317 
00320                 template<typename T>
00321                 GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
00322                 {
00323                         detail::tvec4<T> Result;
00324                         memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
00325                         return Result;
00326                 }
00327 
00330                 template<typename T>
00331                 GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
00332                 {
00333                         detail::tmat2x2<T> Result;
00334                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
00335                         return Result;
00336                 }
00337         
00340                 template<typename T>
00341                 GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
00342                 {
00343                         detail::tmat2x3<T> Result;
00344                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
00345                         return Result;
00346                 }
00347         
00350                 template<typename T>
00351                 GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
00352                 {
00353                         detail::tmat2x4<T> Result;
00354                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
00355                         return Result;
00356                 }
00357         
00360                 template<typename T>
00361                 GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
00362                 {
00363                         detail::tmat3x2<T> Result;
00364                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
00365                         return Result;
00366                 }
00367         
00370                 template<typename T>
00371                 GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
00372                 {
00373                         detail::tmat3x3<T> Result;
00374                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
00375                         return Result;
00376                 }
00377 
00380                 template<typename T>
00381                 GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
00382                 {
00383                         detail::tmat3x4<T> Result;
00384                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
00385                         return Result;
00386                 }
00387 
00388         
00391                 template<typename T>
00392                 GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
00393                 {
00394                         detail::tmat4x2<T> Result;
00395                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
00396                         return Result;
00397                 }
00398         
00401                 template<typename T>
00402                 GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
00403                 {
00404                         detail::tmat4x3<T> Result;
00405                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
00406                         return Result;
00407                 }
00408         
00411                 template<typename T>
00412                 GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
00413                 {
00414                         detail::tmat4x4<T> Result;
00415                         memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
00416                         return Result;
00417                 }
00418         
00421                 template<typename T>
00422                 GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
00423                 {
00424                         return make_mat2x2(ptr);
00425                 }
00426         
00429                 template<typename T>
00430                 GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
00431                 {
00432                         return make_mat3x3(ptr);
00433                 }
00434                 
00437                 template<typename T>
00438                 GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
00439                 {
00440                         return make_mat4x4(ptr);
00441                 }
00442         
00444 
00445         }//namespace type_ptr
00446         }//namespace gtc
00447 }//namespace glm
00448 
00449 #include "type_ptr.inl"
00450 
00451 namespace glm{using namespace gtc::type_ptr;}
00452 
00453 #endif//glm_gtx_type_ptr
00454