extend OpenGL support module with true unit tests and support for Transform, Translation, etc.

2 files changed, 156 insertions, 12 deletions

diff --git a/unsupported/Eigen/OpenGLSupport b/unsupported/Eigen/OpenGLSupport
index 2a9de99b0..75e7ad48a 100644
--- a/unsupported/Eigen/OpenGLSupport
+++ b/unsupported/Eigen/OpenGLSupport
@@ -89,6 +89,7 @@ template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p)
   template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {      \
     inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
   };
+
   
 EIGEN_GL_FUNC_DECLARATION       (glVertex)
 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex,int,    2,2iv)
@@ -149,10 +150,12 @@ 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)
 
-inline void glTranslate2fv(const float*  v) { glScalef(v[0], v[1], 1.f);  }
-inline void glTranslate2dv(const double* v) { glScaled(v[0], v[1], 1.0);  }
-inline void glTranslate3fv(const float*  v) { glScalef(v[0], v[1], v[2]); }
-inline void glTranslate3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
+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]); }
 
 EIGEN_GL_FUNC_DECLARATION       (glTranslate)
 EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate,float,  2,2fv)
@@ -160,14 +163,25 @@ 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)
 
+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()); }
+
 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)
 
+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()); }
+
 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)
 
+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()); }
+
 void glRotate(const Rotation2D<float>& rot)
 {
   glRotatef(rot.angle()*180.f/float(M_PI), 0.f, 0.f, 1.f);
@@ -183,6 +197,50 @@ template<typename Derived> void glRotate(const RotationBase<Derived,3>& rot)
   glMultMatrix(tr.matrix());
 }
 
+#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)                                                                             \
+template< typename XprType,                                                                                         \
+          typename Scalar = typename XprType::Scalar,                                                               \
+          int Rows = XprType::RowsAtCompileTime,                                                                    \
+          int Cols = XprType::ColsAtCompileTime,                                                                    \
+          bool IsGLCompatible = bool(XprType::Flags&LinearAccessBit)                                                \
+                             && bool(XprType::Flags&DirectAccessBit)                                                \
+                             && (XprType::IsVectorAtCompileTime || (XprType::Flags&RowMajorBit)==0)>                \
+struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl);                                                                     \
+                                                                                                                    \
+template<typename XprType, typename Scalar, int Rows, int Cols>                                                     \
+struct EIGEN_CAT(EIGEN_CAT(ei_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(ei_gl_,FUNC),_impl)<typename ei_plain_matrix_type_column_major<XprType>::type>::run(a,p); }   \
+};                                                                                                                  \
+                                                                                                                    \
+template<typename Derived> inline void FUNC(ARG1 a,EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) {                                   \
+  EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<Derived>::run(a,p.derived());                                               \
+}
+
+
+#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC,ARG1,CONST,SCALAR,ROWS,COLS,SUFFIX)                                              \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, ROWS, COLS, true> {   \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }                                            \
+  };
+
+  
+#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC,ARG1,CONST,SCALAR,SIZE,SUFFIX)                                                   \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {      \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }                                            \
+  };                                                                                                                \
+  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, 1, SIZE, true> {      \
+    inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { FUNC##SUFFIX(a,p.data()); }                                            \
+  };
+
+
+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)
+
 //@}
 
 }
diff --git a/unsupported/test/openglsupport.cpp b/unsupported/test/openglsupport.cpp
index 83b476917..065679a40 100644
--- a/unsupported/test/openglsupport.cpp
+++ b/unsupported/test/openglsupport.cpp
@@ -22,14 +22,30 @@
 // License and a copy of the GNU General Public License along with
 // Eigen. If not, see <http://www.gnu.org/licenses/>.
 
+#include <main.h>
 #include <iostream>
 #include <GL/glut.h>
 #include <Eigen/OpenGLSupport>
 using namespace Eigen;
 
-int main(int argc, char **argv)
+
+
+
+#define VERIFY_MATRIX(CODE,REF) { \
+    glLoadIdentity(); \
+    CODE; \
+    Matrix4f m; m.setZero(); \
+    glGet(GL_MODELVIEW_MATRIX, m); \
+    if(!(REF).cast<float>().isApprox(m)) { \
+      std::cerr << "Expected:\n" << ((REF).cast<float>()) << "\n" << "got\n" << m << "\n\n"; \
+    } \
+    VERIFY_IS_APPROX((REF).cast<float>(), m); \
+  }
+
+void test_openglsupport()
 {
-  glutInit(&argc, argv);
+  int argc = 0;
+  glutInit(&argc, 0);
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowPosition (0,0);
   glutInitWindowSize(10, 10);
@@ -50,12 +66,82 @@ int main(int argc, char **argv)
   
   glEnd();
   
-  Quaterniond qd;
-  glRotate(qd);
+  // 4x4 matrices
+  Matrix4f mf44; mf44.setRandom();
+  VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
+  VERIFY_MATRIX(glMultMatrix(mf44), mf44);
+  Matrix4d md44; md44.setRandom();
+  VERIFY_MATRIX(glLoadMatrix(md44), md44);
+  VERIFY_MATRIX(glMultMatrix(md44), md44);
+  
+  // Quaternion
+  Quaterniond qd(AngleAxisd(ei_random<double>(), Vector3d::Random()));
+  VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
+  
+  Quaternionf qf(AngleAxisf(ei_random<double>(), Vector3f::Random()));
+  VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
+  
+  // 3D Transform
+  Transform<float,3,AffineCompact> acf3; acf3.matrix().setRandom();
+  VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
+  VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
+  
+  Transform<float,3,Affine> af3(acf3);
+  VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
+  VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
   
-  Matrix4f m44;
-  glLoadMatrix(m44);
-  glMultMatrix(m44);
+  Transform<float,3,Projective> pf3; pf3.matrix().setRandom();
+  VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
+  VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
+  
+  Transform<double,3,AffineCompact> acd3; acd3.matrix().setRandom();
+  VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
+  VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
+  
+  Transform<double,3,Affine> ad3(acd3);
+  VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
+  VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
+  
+  Transform<double,3,Projective> pd3; pd3.matrix().setRandom();
+  VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
+  VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
+  
+  // translations (2D and 3D)
+  {
+    Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 0;
+    VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
+    Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 0;
+    VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
+    
+    Vector3f vf3; vf3.setRandom();
+    VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
+    Vector3d vd3; vd3.setRandom();
+    VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
+    
+    Translation<float,3> tf3; tf3.vector().setRandom();
+    VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
+    
+    Translation<double,3> td3;  td3.vector().setRandom();
+    VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
+  }
+  
+  // scaling (2D and 3D)
+  {
+    Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 1;
+    VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
+    Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 1;
+    VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
+    
+    Vector3f vf3; vf3.setRandom();
+    VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
+    Vector3d vd3; vd3.setRandom();
+    VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
+    
+    UniformScaling<float> usf(ei_random<float>());
+    VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
+    
+    UniformScaling<double> usd(ei_random<double>());
+    VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
+  }
   
-  return 0;
 }