mirror/eigen
2
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2024-12-21 07:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
c696dbcaa6
eigen/unsupported/Eigen/OpenGLSupport

323 lines
19 KiB
Plaintext
Raw Normal View History

add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
Automatic relicensing to MPL2 using Keirs script. Manual fixup follows.
2012-07-14 02:42:47 +08:00
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
#ifndef EIGEN_OPENGL_MODULE
#define EIGEN_OPENGL_MODULE
bug #1596: fix inclusion of Eigen's header within unsupported modules.
2018-09-17 15:54:29 +08:00
#include "../../Eigen/Geometry"
Fix bug #730: Path of OpenGL headers is different on MacOS
2014-01-30 05:05:39 +08:00
#if defined(__APPLE_CC__)
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
namespace Eigen {
remove the 'Unsupported Modules' meta module
2013-01-11 17:40:35 +08:00
/**
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
* \defgroup OpenGLSUpport_Module OpenGL Support module
*
* This module provides wrapper functions for a couple of OpenGL functions
* which simplify the way to pass Eigen's object to openGL.
Fix typos found using codespell
2018-06-07 20:43:02 +08:00
* Here is an example:
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
*
* \code
* // You need to add path_to_eigen/unsupported to your include path.
* #include <Eigen/OpenGLSupport>
* // ...
* Vector3f x, y;
* Matrix3f rot;
*
* glVertex(y + x * rot);
*
* Quaternion q;
* glRotate(q);
*
* // ...
* \endcode
*
*/
//@{
#define EIGEN_GL_FUNC_DECLARATION(FUNC) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType, \
typename Scalar = typename XprType::Scalar, \
int Rows = XprType::RowsAtCompileTime, \
int Cols = XprType::ColsAtCompileTime, \
Fix GL support wrt evaluators
2014-12-05 05:05:28 +08:00
bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags&LinearAccessBit) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
&& bool(XprType::Flags&DirectAccessBit) \
&& (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)> \
struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl); \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
\
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
template<typename XprType, typename Scalar, int Rows, int Cols> \
struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \
inline static void run(const XprType& p) { \
EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p); } \
}; \
} \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
\
template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p) { \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(p.derived()); \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
}
#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC,SCALAR,ROWS,COLS,SUFFIX) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> { \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
}; \
}
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC,SCALAR,SIZE,SUFFIX) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> { \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
}; \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> { \
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
}; \
}
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
EIGEN_GL_FUNC_DECLARATION (glVertex)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int, 2,2iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short, 2,2sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float, 2,2fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 2,2dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int, 3,3iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short, 3,3sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 3,3dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int, 4,4iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,short, 4,4sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,float, 4,4fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,double, 4,4dv)
EIGEN_GL_FUNC_DECLARATION (glTexCoord)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int, 2,2iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short, 2,2sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float, 2,2fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 2,2dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int, 3,3iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short, 3,3sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 3,3dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,int, 4,4iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,short, 4,4sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,float, 4,4fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord,double, 4,4dv)
EIGEN_GL_FUNC_DECLARATION (glColor)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int, 2,2iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short, 2,2sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float, 2,2fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 2,2dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int, 3,3iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short, 3,3sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 3,3dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,int, 4,4iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,short, 4,4sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,float, 4,4fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor,double, 4,4dv)
EIGEN_GL_FUNC_DECLARATION (glNormal)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,int, 3,3iv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,short, 3,3sv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal,double, 3,3dv)
inline void glScale2fv(const float* v) { glScalef(v[0], v[1], 1.f); }
inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0); }
inline void glScale3fv(const float* v) { glScalef(v[0], v[1], v[2]); }
inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
EIGEN_GL_FUNC_DECLARATION (glScale)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float, 2,2fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 2,2dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale,double, 3,3dv)
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
template<typename Scalar> void glScale(const UniformScaling<Scalar>& s) { glScale(Matrix<Scalar,3,1>::Constant(s.factor())); }
inline void glTranslate2fv(const float* v) { glTranslatef(v[0], v[1], 0.f); }
inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0); }
inline void glTranslate3fv(const float* v) { glTranslatef(v[0], v[1], v[2]); }
inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
EIGEN_GL_FUNC_DECLARATION (glTranslate)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float, 2,2fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 2,2dv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float, 3,3fv)
EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,double, 3,3dv)
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
template<typename Scalar> void glTranslate(const Translation<Scalar,2>& t) { glTranslate(t.vector()); }
template<typename Scalar> void glTranslate(const Translation<Scalar,3>& t) { glTranslate(t.vector()); }
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
EIGEN_GL_FUNC_DECLARATION (glMultMatrix)
EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,float, 4,4,f)
EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix,double, 4,4,d)
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Affine>& t) { glMultMatrix(t.matrix()); }
template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,Projective>& t) { glMultMatrix(t.matrix()); }
template<typename Scalar> void glMultMatrix(const Transform<Scalar,3,AffineCompact>& t) { glMultMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
EIGEN_GL_FUNC_DECLARATION (glLoadMatrix)
EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,float, 4,4,f)
EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix,double, 4,4,d)
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Affine>& t) { glLoadMatrix(t.matrix()); }
template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,Projective>& t) { glLoadMatrix(t.matrix()); }
template<typename Scalar> void glLoadMatrix(const Transform<Scalar,3,AffineCompact>& t) { glLoadMatrix(Transform<Scalar,3,Affine>(t).matrix()); }
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glRotate(const Rotation2D<float>& rot)
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
{
Replace all M_PI by EIGEN_PI and add a check to the testsuite.
2016-03-23 22:37:45 +08:00
glRotatef(rot.angle()*180.f/float(EIGEN_PI), 0.f, 0.f, 1.f);
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
}
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glRotate(const Rotation2D<double>& rot)
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
{
Silence double-promotion warning
2018-08-17 22:39:43 +08:00
glRotated(rot.angle()*180.0/double(EIGEN_PI), 0.0, 0.0, 1.0);
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
}
template<typename Derived> void glRotate(const RotationBase<Derived,3>& rot)
{
Transform<typename Derived::Scalar,3,Projective> tr(rot);
glMultMatrix(tr.matrix());
}
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
#define EIGEN_GL_MAKE_CONST_const const
#define EIGEN_GL_MAKE_CONST__
#define EIGEN_GL_EVAL(X) X
#define EIGEN_GL_FUNC1_DECLARATION(FUNC,ARG1,CONST) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType, \
typename Scalar = typename XprType::Scalar, \
int Rows = XprType::RowsAtCompileTime, \
int Cols = XprType::ColsAtCompileTime, \
Fix GL support wrt evaluators
2014-12-05 05:05:28 +08:00
bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags&LinearAccessBit) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
&& bool(XprType::Flags&DirectAccessBit) \
&& (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)> \
struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl); \
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
\
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
template<typename XprType, typename Scalar, int Rows, int Cols> \
struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType,Scalar,Rows,Cols,false> { \
inline static void run(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a,p); } \
}; \
} \
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
\
add support for uniforms
2010-10-12 16:39:28 +08:00
template<typename Derived> inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) { \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
EIGEN_CAT(EIGEN_CAT(internal::gl_,FUNC),_impl)<Derived>::run(a,p.derived()); \
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
}
#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC,ARG1,CONST,SCALAR,ROWS,COLS,SUFFIX) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> { \
add support for uniforms
2010-10-12 16:39:28 +08:00
inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); } \
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
}; \
}
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC,ARG1,CONST,SCALAR,SIZE,SUFFIX) \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
namespace internal { \
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> { \
add support for uniforms
2010-10-12 16:39:28 +08:00
inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); } \
}; \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> { \
add support for uniforms
2010-10-12 16:39:28 +08:00
inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); } \
fix compilation (bad internal:: stuff)
2010-10-26 22:38:51 +08:00
}; \
bug #86 : use internal:: namespace instead of ei_ prefix
2010-10-25 22:15:22 +08:00
}
extend OpenGL support module with true unit tests and support for Transform, Translation, etc.
2010-10-06 19:28:13 +08:00
EIGEN_GL_FUNC1_DECLARATION (glGet,GLenum,_)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,float, 4,4,Floatv)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet,GLenum,_,double, 4,4,Doublev)
add support for uniforms
2010-10-12 16:39:28 +08:00
// glUniform API
#ifdef GL_VERSION_2_0
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniform2fv_ei (GLint loc, const float* v) { glUniform2fv(loc,1,v); }
inline void glUniform2iv_ei (GLint loc, const int* v) { glUniform2iv(loc,1,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniform3fv_ei (GLint loc, const float* v) { glUniform3fv(loc,1,v); }
inline void glUniform3iv_ei (GLint loc, const int* v) { glUniform3iv(loc,1,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniform4fv_ei (GLint loc, const float* v) { glUniform4fv(loc,1,v); }
inline void glUniform4iv_ei (GLint loc, const int* v) { glUniform4iv(loc,1,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniformMatrix2fv_ei (GLint loc, const float* v) { glUniformMatrix2fv(loc,1,false,v); }
inline void glUniformMatrix3fv_ei (GLint loc, const float* v) { glUniformMatrix3fv(loc,1,false,v); }
inline void glUniformMatrix4fv_ei (GLint loc, const float* v) { glUniformMatrix4fv(loc,1,false,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
EIGEN_GL_FUNC1_DECLARATION (glUniform,GLint,const)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float, 2,2fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int, 2,2iv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float, 3,3fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int, 3,3iv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,float, 4,4fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,int, 4,4iv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 2,2,Matrix2fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 3,3,Matrix3fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 4,4,Matrix4fv_ei)
#endif
#ifdef GL_VERSION_2_1
Use inline versus static free functions.
2015-09-03 19:42:54 +08:00
inline void glUniformMatrix2x3fv_ei(GLint loc, const float* v) { glUniformMatrix2x3fv(loc,1,false,v); }
inline void glUniformMatrix3x2fv_ei(GLint loc, const float* v) { glUniformMatrix3x2fv(loc,1,false,v); }
inline void glUniformMatrix2x4fv_ei(GLint loc, const float* v) { glUniformMatrix2x4fv(loc,1,false,v); }
inline void glUniformMatrix4x2fv_ei(GLint loc, const float* v) { glUniformMatrix4x2fv(loc,1,false,v); }
inline void glUniformMatrix3x4fv_ei(GLint loc, const float* v) { glUniformMatrix3x4fv(loc,1,false,v); }
inline void glUniformMatrix4x3fv_ei(GLint loc, const float* v) { glUniformMatrix4x3fv(loc,1,false,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 2,3,Matrix2x3fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 3,2,Matrix3x2fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 2,4,Matrix2x4fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 4,2,Matrix4x2fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 3,4,Matrix3x4fv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform,GLint,const,float, 4,3,Matrix4x3fv_ei)
#endif
#ifdef GL_VERSION_3_0
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniform2uiv_ei (GLint loc, const unsigned int* v) { glUniform2uiv(loc,1,v); }
inline void glUniform3uiv_ei (GLint loc, const unsigned int* v) { glUniform3uiv(loc,1,v); }
inline void glUniform4uiv_ei (GLint loc, const unsigned int* v) { glUniform4uiv(loc,1,v); }
add support for uniforms
2010-10-12 16:39:28 +08:00
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 2,2uiv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 3,3uiv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,unsigned int, 4,4uiv_ei)
#endif
add support for uniform of double
2010-10-12 17:04:19 +08:00
#ifdef GL_ARB_gpu_shader_fp64
Free functions should only be declared as static in separate compilation units (grafted from d85abc89c5782eebe2b0f2c920d6c495b4dcc091 )
2014-12-12 19:01:03 +08:00
inline void glUniform2dv_ei (GLint loc, const double* v) { glUniform2dv(loc,1,v); }
inline void glUniform3dv_ei (GLint loc, const double* v) { glUniform3dv(loc,1,v); }
inline void glUniform4dv_ei (GLint loc, const double* v) { glUniform4dv(loc,1,v); }
add support for uniform of double
2010-10-12 17:04:19 +08:00
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double, 2,2dv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double, 3,3dv_ei)
EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform,GLint,const,double, 4,4dv_ei)
#endif
add an OpenGL module simplifying the way you can pass Eigen's objects to GL
2010-07-22 22:08:58 +08:00
//@}
}
#endif // EIGEN_OPENGL_MODULE
Reference in New Issue Copy Permalink