The MRPT project: OpenGLSupport Source File

Go to the documentation of this file.
00001 // This file is part of Eigen, a lightweight C++ template library
00002 // for linear algebra.
00003 //
00004 // Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
00005 //
00006 // Eigen is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 3 of the License, or (at your option) any later version.
00010 //
00011 // Alternatively, you can redistribute it and/or
00012 // modify it under the terms of the GNU General Public License as
00013 // published by the Free Software Foundation; either version 2 of
00014 // the License, or (at your option) any later version.
00015 //
00016 // Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
00017 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00018 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
00019 // GNU General Public License for more details.
00020 //
00021 // You should have received a copy of the GNU Lesser General Public
00022 // License and a copy of the GNU General Public License along with
00023 // Eigen. If not, see <http://www.gnu.org/licenses/>.
00024 
00025 #ifndef EIGEN_OPENGL_MODULE
00026 #define EIGEN_OPENGL_MODULE
00027 
00028 #include <Eigen/Geometry>
00029 #include <GL/gl.h>
00030 
00031 namespace Eigen {
00032 
00033 /** \ingroup Unsupported_modules
00034   * \defgroup OpenGLSUpport_Module OpenGL Support module  
00035  * \ingroup eigen_grp
00036  * \ingroup eigen_grp
00037   *
00038   * This module provides wrapper functions for a couple of OpenGL functions
00039   * which simplify the way to pass Eigen's object to openGL.
00040   * Here is an exmaple:
00041   * 
00042   * \code
00043   * // You need to add path_to_eigen/unsupported to your include path.
00044   * #include <Eigen/OpenGLSupport>
00045   * // ...
00046   * Vector3f x, y;
00047   * Matrix3f rot;
00048   * 
00049   * glVertex(y + x * rot);
00050   * 
00051   * Quaternion q;
00052   * glRotate(q);
00053   * 
00054   * // ...
00055   * \endcode
00056   *
00057   */
00058 //@{
00059 
00060 #define EIGEN_GL_FUNC_DECLARATION(FUNC)                                                                             \
00061 namespace internal {                                                                                                \
00062   template< typename XprType,                                                                                       \
00063             typename Scalar = typename XprType::Scalar,                                                             \
00064             int Rows = XprType::RowsAtCompileTime,                                                                  \
00065             int Cols = XprType::ColsAtCompileTime,                                                                  \
00066             bool IsGLCompatible = bool(XprType::Flags&LinearAccessBit)                                              \
00067                               && bool(XprType::Flags&DirectAccessBit)                                               \
00068                               && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>               \
00069   struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl);                                                                      \
00070                                                                                                                     \
00071   template<typename XprType, typename Scalar, int Rows, int Cols>                                                   \
00072   struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> {                                     \
00073     inline static void run(const XprType& p) {                                                                      \
00074       EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p); }       \
00075   };                                                                                                                \
00076 }                                                                                                                   \
00077                                                                                                                     \
00078 template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p) {                                   \
00079   EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(p.derived());                                        \
00080 }
00081 
00082 
00083 #define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC,SCALAR,ROWS,COLS,SUFFIX)                                              \
00084 namespace internal {                                                                                                \
00085   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> {      \
00086     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
00087   };                                                                                                                \
00088 }
00089 
00090   
00091 #define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC,SCALAR,SIZE,SUFFIX)                                                   \
00092 namespace internal {                                                                                                \
00093   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {         \
00094     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
00095   };                                                                                                                \
00096   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {         \
00097     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
00098   };                                                                                                                \
00099 }
00100 
00101   
00102 EIGEN_GL_FUNC_DECLARATION       (glVertex)
00103 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    2,2iv)
00104 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  2,2sv)
00105 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  2,2fv)
00106 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 2,2dv)
00107 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    3,3iv)
00108 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  3,3sv)
00109 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  3,3fv)
00110 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 3,3dv)
00111 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    4,4iv)
00112 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short,  4,4sv)
00113 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float,  4,4fv)
00114 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 4,4dv)
00115 
00116 EIGEN_GL_FUNC_DECLARATION       (glTexCoord)
00117 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    2,2iv)
00118 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  2,2sv)
00119 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  2,2fv)
00120 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 2,2dv)
00121 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    3,3iv)
00122 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  3,3sv)
00123 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  3,3fv)
00124 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 3,3dv)
00125 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int,    4,4iv)
00126 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short,  4,4sv)
00127 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float,  4,4fv)
00128 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 4,4dv)
00129 
00130 EIGEN_GL_FUNC_DECLARATION       (glColor)
00131 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    2,2iv)
00132 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  2,2sv)
00133 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  2,2fv)
00134 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 2,2dv)
00135 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    3,3iv)
00136 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  3,3sv)
00137 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  3,3fv)
00138 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 3,3dv)
00139 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int,    4,4iv)
00140 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short,  4,4sv)
00141 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float,  4,4fv)
00142 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 4,4dv)
00143 
00144 EIGEN_GL_FUNC_DECLARATION       (glNormal)
00145 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,int,    3,3iv)
00146 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,short,  3,3sv)
00147 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,float,  3,3fv)
00148 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,double, 3,3dv)
00149 
00150 inline void glScale2fv(const float*  v) { glScalef(v[0], v[1], 1.f);  }
00151 inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0);  }
00152 inline void glScale3fv(const float*  v) { glScalef(v[0], v[1], v[2]); }
00153 inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
00154 
00155 EIGEN_GL_FUNC_DECLARATION       (glScale)
00156 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float,  2,2fv)
00157 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 2,2dv)
00158 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float,  3,3fv)
00159 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 3,3dv)
00160 
00161 template<typename Scalar> void glScale(const UniformScaling<Scalar>& s)  { glScale(Matrix<Scalar,3,1>::Constant(s.factor())); }
00162 
00163 inline void glTranslate2fv(const float*  v) { glTranslatef(v[0], v[1], 0.f);  }
00164 inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0);  }
00165 inline void glTranslate3fv(const float*  v) { glTranslatef(v[0], v[1], v[2]); }
00166 inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
00167 
00168 EIGEN_GL_FUNC_DECLARATION       (glTranslate)
00169 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float,  2,2fv)
00170 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 2,2dv)
00171 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float,  3,3fv)
00172 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 3,3dv)
00173 
00174 template<typename Scalar> void glTranslate(const Translation<Scalar,2>& t)  { glTranslate(t.vector()); }
00175 template<typename Scalar> void glTranslate(const Translation<Scalar,3>& t)  { glTranslate(t.vector()); }
00176 
00177 EIGEN_GL_FUNC_DECLARATION       (glMultMatrix)
00178 EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,float,  4,4,f)
00179 EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,double, 4,4,d)
00180 
00181 template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Affine>& t)        { glMultMatrix(t.matrix()); }
00182 template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Projective>& t)    { glMultMatrix(t.matrix()); }
00183 template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,AffineCompact>& t) { glMultMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
00184 
00185 EIGEN_GL_FUNC_DECLARATION       (glLoadMatrix)
00186 EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,float,  4,4,f)
00187 EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,double, 4,4,d)
00188 
00189 template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Affine>& t)        { glLoadMatrix(t.matrix()); }
00190 template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Projective>& t)    { glLoadMatrix(t.matrix()); }
00191 template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,AffineCompact>& t) { glLoadMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
00192 
00193 static void glRotate(const Rotation2D<float>& rot)
00194 {
00195   glRotatef(rot.angle()*180.f/float(M_PI), 0.f, 0.f, 1.f);
00196 }
00197 static void glRotate(const Rotation2D<double>& rot)
00198 {
00199   glRotated(rot.angle()*180.0/M_PI, 0.0, 0.0, 1.0);
00200 }
00201 
00202 template<typename Derived> void glRotate(const RotationBase<Derived,3>& rot)
00203 {  
00204   Transform<typename Derived::Scalar,3,Projective> tr(rot);
00205   glMultMatrix(tr.matrix());
00206 }
00207 
00208 #define EIGEN_GL_MAKE_CONST_const const
00209 #define EIGEN_GL_MAKE_CONST__ 
00210 #define EIGEN_GL_EVAL(X) X
00211 
00212 #define EIGEN_GL_FUNC1_DECLARATION(FUNC,ARG1,CONST)                                                                             \
00213 namespace internal {                                                                                                            \
00214   template< typename XprType,                                                                                                   \
00215             typename Scalar = typename XprType::Scalar,                                                                         \
00216             int Rows = XprType::RowsAtCompileTime,                                                                              \
00217             int Cols = XprType::ColsAtCompileTime,                                                                              \
00218             bool IsGLCompatible = bool(XprType::Flags&LinearAccessBit)                                                          \
00219                               && bool(XprType::Flags&DirectAccessBit)                                                           \
00220                               && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>                           \
00221   struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl);                                                                                  \
00222                                                                                                                                 \
00223   template<typename XprType, typename Scalar, int Rows, int Cols>                                                               \
00224   struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> {                                                 \
00225     inline static void run(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) {                                      \
00226       EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a,p); }                 \
00227   };                                                                                                                            \
00228 }                                                                                                                               \
00229                                                                                                                                 \
00230 template<typename Derived> inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) {   \
00231   EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(a,p.derived());                                                  \
00232 }
00233 
00234 
00235 #define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC,ARG1,CONST,SCALAR,ROWS,COLS,SUFFIX)                                              \
00236 namespace internal {                                                                                                            \
00237   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> {                  \
00238     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
00239   }; \
00240 }
00241 
00242   
00243 #define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC,ARG1,CONST,SCALAR,SIZE,SUFFIX)                                                   \
00244 namespace internal {                                                                                                            \
00245   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {                     \
00246     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
00247   };                                                                                                                            \
00248   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {                     \
00249     inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }         \
00250   };                                                                                                                            \
00251 }
00252 
00253 EIGEN_GL_FUNC1_DECLARATION       (glGet,GLenum,_)
00254 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,float,  4,4,Floatv)
00255 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,double, 4,4,Doublev)
00256 
00257 // glUniform API
00258 
00259 #ifdef GL_VERSION_2_0
00260 
00261 static void glUniform2fv_ei  (GLint loc, const float* v)         { glUniform2fv(loc,1,v); }
00262 static void glUniform2iv_ei  (GLint loc, const int* v)           { glUniform2iv(loc,1,v); }
00263 
00264 static void glUniform3fv_ei  (GLint loc, const float* v)         { glUniform3fv(loc,1,v); }
00265 static void glUniform3iv_ei  (GLint loc, const int* v)           { glUniform3iv(loc,1,v); }
00266 
00267 static void glUniform4fv_ei  (GLint loc, const float* v)         { glUniform4fv(loc,1,v); }
00268 static void glUniform4iv_ei  (GLint loc, const int* v)           { glUniform4iv(loc,1,v); }
00269 
00270 static void glUniformMatrix2fv_ei  (GLint loc, const float* v)         { glUniformMatrix2fv(loc,1,false,v); }
00271 static void glUniformMatrix3fv_ei  (GLint loc, const float* v)         { glUniformMatrix3fv(loc,1,false,v); }
00272 static void glUniformMatrix4fv_ei  (GLint loc, const float* v)         { glUniformMatrix4fv(loc,1,false,v); }
00273 
00274 
00275 EIGEN_GL_FUNC1_DECLARATION       (glUniform,GLint,const)
00276 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        2,2fv_ei)
00277 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          2,2iv_ei)
00278 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        3,3fv_ei)
00279 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          3,3iv_ei)
00280 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float,        4,4fv_ei)
00281 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int,          4,4iv_ei)
00282 
00283 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,2,Matrix2fv_ei)
00284 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,3,Matrix3fv_ei)
00285 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,4,Matrix4fv_ei)
00286 
00287 #endif
00288 
00289 #ifdef GL_VERSION_2_1
00290 
00291 static void glUniformMatrix2x3fv_ei(GLint loc, const float* v)         { glUniformMatrix2x3fv(loc,1,false,v); }
00292 static void glUniformMatrix3x2fv_ei(GLint loc, const float* v)         { glUniformMatrix3x2fv(loc,1,false,v); }
00293 static void glUniformMatrix2x4fv_ei(GLint loc, const float* v)         { glUniformMatrix2x4fv(loc,1,false,v); }
00294 static void glUniformMatrix4x2fv_ei(GLint loc, const float* v)         { glUniformMatrix4x2fv(loc,1,false,v); }
00295 static void glUniformMatrix3x4fv_ei(GLint loc, const float* v)         { glUniformMatrix3x4fv(loc,1,false,v); }
00296 static void glUniformMatrix4x3fv_ei(GLint loc, const float* v)         { glUniformMatrix4x3fv(loc,1,false,v); }
00297 
00298 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,3,Matrix2x3fv_ei)
00299 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,2,Matrix3x2fv_ei)
00300 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        2,4,Matrix2x4fv_ei)
00301 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,2,Matrix4x2fv_ei)
00302 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        3,4,Matrix3x4fv_ei)
00303 EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float,        4,3,Matrix4x3fv_ei)
00304 
00305 #endif
00306 
00307 #ifdef GL_VERSION_3_0
00308 
00309 static void glUniform2uiv_ei (GLint loc, const unsigned int* v)  { glUniform2uiv(loc,1,v); }
00310 static void glUniform3uiv_ei (GLint loc, const unsigned int* v)  { glUniform3uiv(loc,1,v); }
00311 static void glUniform4uiv_ei (GLint loc, const unsigned int* v)  { glUniform4uiv(loc,1,v); }
00312 
00313 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 2,2uiv_ei)
00314 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 3,3uiv_ei)
00315 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 4,4uiv_ei)
00316 
00317 #endif
00318 
00319 #ifdef GL_ARB_gpu_shader_fp64
00320 static void glUniform2dv_ei  (GLint loc, const double* v)        { glUniform2dv(loc,1,v); }
00321 static void glUniform3dv_ei  (GLint loc, const double* v)        { glUniform3dv(loc,1,v); }
00322 static void glUniform4dv_ei  (GLint loc, const double* v)        { glUniform4dv(loc,1,v); }
00323 
00324 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       2,2dv_ei)
00325 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       3,3dv_ei)
00326 EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double,       4,4dv_ei)
00327 #endif
00328 
00329 
00330 //@}
00331 
00332 }
00333 
00334 #endif // EIGEN_OPENGL_MODULE