# GLM: address.hpp Source File

- Main Page
- Namespaces
- Files

- File List

# address.hpp

    00001 #ifndef GLM_EXT_VIRTREV_ADDRESS_HPP
    00002 #define GLM_EXT_VIRTREV_ADDRESS_HPP
    00003
    00005 // OpenGL Mathematics Copyright (c) 2005 - 2009 G-Truc Creation (www.g-truc.net)
    00006 // Virtrev SDK copyright matrem (matrem84.free.fr)
    00008 // Created : 2008-10-07
    00009 // Updated :
    00010 // Licence : This source is under MIT License
    00011 // File    : glm/ext/virtrev/address.h
    00013 // Dependency:
    00014 // - GLM core
    00016
    00017 #include "../glm.hpp"
    00018
    00019
    00020 namespace glm
    00021 {
    00022         namespace virtrev_glmext
    00023         {
    00025         namespace address
    00026         {
    00028                 template<typename T>
    00029                 T const * address(detail::tvec2<T> const & vec)
    00030                 {
    00031                         return &(vec.x);
    00032                 }
    00034                 template<typename T>
    00035                 T * address(detail::tvec2<T> & vec)
    00036                 {
    00037                         return &(vec.x);
    00038                 }
    00039
    00041                 template<typename T>
    00042                 T const * address(detail::tvec3<T> const & vec)
    00043                 {
    00044                         return &(vec.x);
    00045                 }
    00047                 template<typename T>
    00048                 T * address(detail::tvec3<T>  & vec)
    00049                 {
    00050                         return &(vec.x);
    00051                 }
    00052
    00054                 template<typename T>
    00055                 T const * address(detail::tvec4<T> const & vec)
    00056                 {
    00057                         return &(vec.x);
    00058                 }
    00060                 template<typename T>
    00061                 T * address(detail::tvec4<T> & vec)
    00062                 {
    00063                         return &(vec.x);
    00064                 }
    00065
    00067                 template<typename T>
    00068                 T const * address(detail::tmat2x2<T> const & mat)
    00069                 {
    00070                         return &(mat[0].x);
    00071                 }
    00073                 template<typename T>
    00074                 T * address(detail::tmat2x2<T> & mat)
    00075                 {
    00076                         return &(mat[0].x);
    00077                 }
    00078
    00080                 template<typename T>
    00081                 T const * address(detail::tmat3x3<T> const & mat)
    00082                 {
    00083                         return &(mat[0].x);
    00084                 }
    00086                 template<typename T>
    00087                 T * address(detail::tmat3x3<T> & mat)
    00088                 {
    00089                         return &(mat[0].x);
    00090                 }
    00091
    00093                 template<typename T>
    00094                 T const * address(detail::tmat4x4<T> const & mat)
    00095                 {
    00096                         return &(mat[0].x);
    00097                 }
    00099                 template<typename T>
    00100                 T * address(detail::tmat4x4<T> & mat)
    00101                 {
    00102                         return &(mat[0].x);
    00103                 }
    00104
    00106                 template<typename T>
    00107                 T const * address(detail::tmat2x3<T> const & mat)
    00108                 {
    00109                         return &(mat[0].x);
    00110                 }
    00112                 template<typename T>
    00113                 T * address(detail::tmat2x3<T> & mat)
    00114                 {
    00115                         return &(mat[0].x);
    00116                 }
    00117
    00119                 template<typename T>
    00120                 T const * address(detail::tmat3x2<T> const & mat)
    00121                 {
    00122                         return &(mat[0].x);
    00123                 }
    00125                 template<typename T>
    00126                 T * address(detail::tmat3x2<T> & mat)
    00127                 {
    00128                         return &(mat[0].x);
    00129                 }
    00130
    00132                 template<typename T>
    00133                 T const * address(detail::tmat2x4<T> const & mat)
    00134                 {
    00135                         return &(mat[0].x);
    00136                 }
    00138                 template<typename T>
    00139                 T * address(detail::tmat2x4<T> & mat)
    00140                 {
    00141                         return &(mat[0].x);
    00142                 }
    00143
    00145                 template<typename T>
    00146                 T const * address(detail::tmat4x2<T> const & mat)
    00147                 {
    00148                         return &(mat[0].x);
    00149                 }
    00151                 template<typename T>
    00152                 T * address(detail::tmat4x2<T> & mat)
    00153                 {
    00154                         return &(mat[0].x);
    00155                 }
    00156
    00158                 template<typename T>
    00159                 T const * address(detail::tmat3x4<T> const & mat)
    00160                 {
    00161                         return &(mat[0].x);
    00162                 }
    00164                 template<typename T>
    00165                 T * address(detail::tmat3x4<T> & mat)
    00166                 {
    00167                         return &(mat[0].x);
    00168                 }
    00169
    00171                 template<typename T>
    00172                 T const * address(detail::tmat4x3<T> const & mat)
    00173                 {
    00174                         return &(mat[0].x);
    00175                 }
    00177                 template<typename T>
    00178                 T * address(detail::tmat4x3<T> & mat)
    00179                 {
    00180                         return &(mat[0].x);
    00181                 }
    00182         }
    00183         }
    00184 }
    00185
    00186 #define GLM_VIRTREV_address namespace virtrev_glmext::address
    00187 #ifndef GLM_VIRTREV_GLOBAL
    00188 namespace glm {using GLM_VIRTREV_address;}
    00189 #endif//GLM_VIRTREV_GLOBAL
    00190
    00191 #endif//GLM_EXT_VIRTREV_ADDRESS_HPP
    00192