eigen/unsupported/Eigen/OpenGLSupport

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// Eigen is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 3 of the License, or (at your option) any later version.
//
// Alternatively, you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.

#ifndef EIGEN_OPENGL_MODULE
#define EIGEN_OPENGL_MODULE

#include <Eigen/Geometry>
#include <GL/gl.h>

namespace Eigen {

/** \ingroup Unsupported_modules
  * \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.
  * Here is an exmaple:
  * 
  * \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)                                                                             \
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(const XprType& p) {                                                                        \
    EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<typename ei_plain_matrix_type_column_major<XprType>::type>::run(p); }   \
};                                                                                                                  \
                                                                                                                    \
template<typename Derived> inline void FUNC(const Eigen::DenseBase<Derived>& p) {                                   \
  EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<Derived>::run(p.derived());                                               \
}


#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC,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(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
  };

  
#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC,SCALAR,SIZE,SUFFIX)                                                   \
  template< typename XprType> struct EIGEN_CAT(EIGEN_CAT(ei_gl_,FUNC),_impl)<XprType, SCALAR, SIZE, 1, true> {      \
    inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); }                                            \
  };                                                                                                                \
  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)
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)

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]); }

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)

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)

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)

void glRotate(const Rotation2D<float>& rot)
{
  glRotatef(rot.angle()*180.f/float(M_PI), 0.f, 0.f, 1.f);
}
void glRotate(const Rotation2D<double>& rot)
{
  glRotated(rot.angle()*180.0/M_PI, 0.0, 0.0, 1.0);
}

template<typename Derived> void glRotate(const RotationBase<Derived,3>& rot)
{  
  Transform<typename Derived::Scalar,3,Projective> tr(rot);
  glMultMatrix(tr.matrix());
}

//@}

}

#endif // EIGEN_OPENGL_MODULE