- 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 #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 namespace gtc{
    00026 namespace type_ptr
    00027 {
    00028
    00031
    00034         template<typename T>
    00035         GLM_FUNC_QUALIFIER T const * value_ptr
    00036         (
    00037                 detail::tvec2<T> const & vec
    00038         )
    00039         {
    00040                 return &(vec.x);
    00041         }
    00042
    00045         template<typename T>
    00046         GLM_FUNC_QUALIFIER T * value_ptr
    00047         (
    00048                 detail::tvec2<T> & vec
    00049         )
    00050         {
    00051                 return &(vec.x);
    00052         }
    00053
    00056         template<typename T>
    00057         GLM_FUNC_QUALIFIER T const * value_ptr
    00058         (
    00059                 detail::tvec3<T> const & vec
    00060         )
    00061         {
    00062                 return &(vec.x);
    00063         }
    00064
    00067         template<typename T>
    00068         GLM_FUNC_QUALIFIER T * value_ptr
    00069         (
    00070                 detail::tvec3<T> & vec
    00071         )
    00072         {
    00073                 return &(vec.x);
    00074         }
    00075
    00078         template<typename T>
    00079         GLM_FUNC_QUALIFIER T const * value_ptr
    00080         (
    00081                 detail::tvec4<T> const & vec
    00082         )
    00083         {
    00084                 return &(vec.x);
    00085         }
    00086
    00089         template<typename T>
    00090         GLM_FUNC_QUALIFIER T * value_ptr
    00091         (
    00092                 detail::tvec4<T> & vec
    00093         )
    00094         {
    00095                 return &(vec.x);
    00096         }
    00097
    00100         template<typename T>
    00101         GLM_FUNC_QUALIFIER T const * value_ptr
    00102         (
    00103                 detail::tmat2x2<T> const & mat
    00104         )
    00105         {
    00106                 return &(mat[0].x);
    00107         }
    00108
    00111         template<typename T>
    00112         GLM_FUNC_QUALIFIER T * value_ptr
    00113         (
    00114                 detail::tmat2x2<T> & mat
    00115         )
    00116         {
    00117                 return &(mat[0].x);
    00118         }
    00119
    00122         template<typename T>
    00123         GLM_FUNC_QUALIFIER T const * value_ptr
    00124         (
    00125                 detail::tmat3x3<T> const & mat
    00126         )
    00127         {
    00128                 return &(mat[0].x);
    00129         }
    00130
    00133         template<typename T>
    00134         GLM_FUNC_QUALIFIER T * value_ptr
    00135         (
    00136                 detail::tmat3x3<T> & mat
    00137         )
    00138         {
    00139                 return &(mat[0].x);
    00140         }
    00141
    00144         template<typename T>
    00145         GLM_FUNC_QUALIFIER T const * value_ptr
    00146         (
    00147                 detail::tmat4x4<T> const & mat
    00148         )
    00149         {
    00150                 return &(mat[0].x);
    00151         }
    00152
    00155         template<typename T>
    00156         GLM_FUNC_QUALIFIER T * value_ptr
    00157         (
    00158                 detail::tmat4x4<T> & mat
    00159         )
    00160         {
    00161                 return &(mat[0].x);
    00162         }
    00163
    00166         template<typename T>
    00167         GLM_FUNC_QUALIFIER T const * value_ptr
    00168         (
    00169                 detail::tmat2x3<T> const & mat
    00170         )
    00171         {
    00172                 return &(mat[0].x);
    00173         }
    00174
    00177         template<typename T>
    00178         GLM_FUNC_QUALIFIER T * value_ptr
    00179         (
    00180                 detail::tmat2x3<T> & mat
    00181         )
    00182         {
    00183                 return &(mat[0].x);
    00184         }
    00185
    00188         template<typename T>
    00189         GLM_FUNC_QUALIFIER T const * value_ptr
    00190         (
    00191                 detail::tmat3x2<T> const & mat
    00192         )
    00193         {
    00194                 return &(mat[0].x);
    00195         }
    00196
    00199         template<typename T>
    00200         GLM_FUNC_QUALIFIER T * value_ptr
    00201         (
    00202                 detail::tmat3x2<T> & mat
    00203         )
    00204         {
    00205                 return &(mat[0].x);
    00206         }
    00207
    00210         template<typename T>
    00211         GLM_FUNC_QUALIFIER T const * value_ptr
    00212         (
    00213                 detail::tmat2x4<T> const & mat
    00214         )
    00215         {
    00216                 return &(mat[0].x);
    00217         }
    00218
    00221         template<typename T>
    00222         GLM_FUNC_QUALIFIER T * value_ptr
    00223         (
    00224                 detail::tmat2x4<T> & mat
    00225         )
    00226         {
    00227                 return &(mat[0].x);
    00228         }
    00229
    00232         template<typename T>
    00233         GLM_FUNC_QUALIFIER T const * value_ptr
    00234         (
    00235                 detail::tmat4x2<T> const & mat
    00236         )
    00237         {
    00238                 return &(mat[0].x);
    00239         }
    00240
    00243         template<typename T>
    00244         GLM_FUNC_QUALIFIER T * value_ptr
    00245         (
    00246                 detail::tmat4x2<T> & mat
    00247         )
    00248         {
    00249                 return &(mat[0].x);
    00250         }
    00251
    00254         template<typename T>
    00255         GLM_FUNC_QUALIFIER T const * value_ptr
    00256         (
    00257                 detail::tmat3x4<T> const & mat
    00258         )
    00259         {
    00260                 return &(mat[0].x);
    00261         }
    00262
    00265         template<typename T>
    00266         GLM_FUNC_QUALIFIER T * value_ptr
    00267         (
    00268                 detail::tmat3x4<T> & mat
    00269         )
    00270         {
    00271                 return &(mat[0].x);
    00272         }
    00273
    00276         template<typename T>
    00277         GLM_FUNC_QUALIFIER T const * value_ptr
    00278         (
    00279                 detail::tmat4x3<T> const & mat
    00280         )
    00281         {
    00282                 return &(mat[0].x);
    00283         }
    00284
    00287         template<typename T>
    00288         GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
    00289         {
    00290                 return &(mat[0].x);
    00291         }
    00292
    00295         template<typename T>
    00296         GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
    00297         {
    00298                 detail::tvec2<T> Result;
    00299                 memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
    00300                 return Result;
    00301         }
    00302
    00305         template<typename T>
    00306         GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
    00307         {
    00308                 detail::tvec3<T> Result;
    00309                 memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
    00310                 return Result;
    00311         }
    00312
    00315         template<typename T>
    00316         GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
    00317         {
    00318                 detail::tvec4<T> Result;
    00319                 memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
    00320                 return Result;
    00321         }
    00322
    00325         template<typename T>
    00326         GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
    00327         {
    00328                 detail::tmat2x2<T> Result;
    00329                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
    00330                 return Result;
    00331         }
    00332
    00335         template<typename T>
    00336         GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
    00337         {
    00338                 detail::tmat2x3<T> Result;
    00339                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
    00340                 return Result;
    00341         }
    00342
    00345         template<typename T>
    00346         GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
    00347         {
    00348                 detail::tmat2x4<T> Result;
    00349                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
    00350                 return Result;
    00351         }
    00352
    00355         template<typename T>
    00356         GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
    00357         {
    00358                 detail::tmat3x2<T> Result;
    00359                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
    00360                 return Result;
    00361         }
    00362
    00365         template<typename T>
    00366         GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
    00367         {
    00368                 detail::tmat3x3<T> Result;
    00369                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
    00370                 return Result;
    00371         }
    00372
    00375         template<typename T>
    00376         GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
    00377         {
    00378                 detail::tmat3x4<T> Result;
    00379                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
    00380                 return Result;
    00381         }
    00382
    00383
    00386         template<typename T>
    00387         GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
    00388         {
    00389                 detail::tmat4x2<T> Result;
    00390                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
    00391                 return Result;
    00392         }
    00393
    00396         template<typename T>
    00397         GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
    00398         {
    00399                 detail::tmat4x3<T> Result;
    00400                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
    00401                 return Result;
    00402         }
    00403
    00406         template<typename T>
    00407         GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
    00408         {
    00409                 detail::tmat4x4<T> Result;
    00410                 memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
    00411                 return Result;
    00412         }
    00413
    00416         template<typename T>
    00417         GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
    00418         {
    00419                 return make_mat2x2(ptr);
    00420         }
    00421
    00424         template<typename T>
    00425         GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
    00426         {
    00427                 return make_mat3x3(ptr);
    00428         }
    00429
    00432         template<typename T>
    00433         GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
    00434         {
    00435                 return make_mat4x4(ptr);
    00436         }
    00437
    00439
    00440 }//namespace type_ptr
    00441 }//namespace gtc
    00442 }//namespace glm
    00443
    00444 #include "type_ptr.inl"
    00445
    00446 namespace glm{using namespace gtc::type_ptr;}
    00447
    00448 #endif//glm_gtx_type_ptr
    00449