1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_GPUHELPER_H
11 #define EIGEN_GPUHELPER_H
12 
13 #include <Eigen/Geometry>
14 #include <GL/gl.h>
15 #include <vector>
16 
17 using namespace Eigen;
18 
19 typedef Vector4f Color;
20 
21 class GpuHelper
22 {
23   public:
24 
25     GpuHelper();
26 
27     ~GpuHelper();
28 
29     enum ProjectionMode2D { PM_Normalized = 1, PM_Viewport = 2 };
30     void pushProjectionMode2D(ProjectionMode2D pm);
31     void popProjectionMode2D();
32 
33     /** Multiply the OpenGL matrix \a matrixTarget by the matrix \a mat.
34         Essentially, this helper function automatically calls glMatrixMode(matrixTarget) if required
35         and does a proper call to the right glMultMatrix*() function according to the scalar type
36         and storage order.
37         \warning glMatrixMode() must never be called directly. If your're unsure, use forceMatrixMode().
38         \sa Matrix, loadMatrix(), forceMatrixMode()
39     */
40     template<typename Scalar, int _Flags>
41     void multMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
42 
43     /** Load the matrix \a mat to the OpenGL matrix \a matrixTarget.
44         Essentially, this helper function automatically calls glMatrixMode(matrixTarget) if required
45         and does a proper call to the right glLoadMatrix*() or glLoadIdentity() function according to the scalar type
46         and storage order.
47         \warning glMatrixMode() must never be called directly. If your're unsure, use forceMatrixMode().
48         \sa Matrix, multMatrix(), forceMatrixMode()
49     */
50     template<typename Scalar, int _Flags>
51     void loadMatrix(const Eigen::Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
52 
53     template<typename Scalar, typename Derived>
54     void loadMatrix(
55         const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
56         GLenum matrixTarget);
57 
58     /** Make the matrix \a matrixTarget the current OpenGL matrix target.
59         Call this function before loadMatrix() or multMatrix() if you cannot guarantee that glMatrixMode()
60         has never been called after the last loadMatrix() or multMatrix() calls.
61         \todo provides a debug mode checking the sanity of the cached matrix mode.
62     */
forceMatrixTarget(GLenum matrixTarget)63     inline void forceMatrixTarget(GLenum matrixTarget) {glMatrixMode(mCurrentMatrixTarget=matrixTarget);}
64 
65     inline void setMatrixTarget(GLenum matrixTarget);
66 
67     /** Push the OpenGL matrix \a matrixTarget and load \a mat.
68     */
69     template<typename Scalar, int _Flags>
70     inline void pushMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
71 
72     template<typename Scalar, typename Derived>
73     void pushMatrix(
74         const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
75         GLenum matrixTarget);
76 
77     /** Push and clone the OpenGL matrix \a matrixTarget
78     */
79     inline void pushMatrix(GLenum matrixTarget);
80 
81     /** Pop the OpenGL matrix \a matrixTarget
82     */
83     inline void popMatrix(GLenum matrixTarget);
84 
85     void drawVector(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect = 50.);
86     void drawVectorBox(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect = 50.);
87     void drawUnitCube(void);
88     void drawUnitSphere(int level=0);
89 
90     /// draw the \a nofElement first elements
91     inline void draw(GLenum mode, uint nofElement);
92 
93     /// draw a range of elements
94     inline void draw(GLenum mode, uint start, uint end);
95 
96     /// draw an indexed subset
97     inline void draw(GLenum mode, const std::vector<uint>* pIndexes);
98 
99 protected:
100 
101     void update(void);
102 
103     GLuint mColorBufferId;
104     int mVpWidth, mVpHeight;
105     GLenum mCurrentMatrixTarget;
106     bool mInitialized;
107 };
108 
109 /** Singleton shortcut
110 */
111 extern GpuHelper gpu;
112 
113 
114 /** \internal
115 */
116 template<bool RowMajor, int _Flags> struct GlMatrixHelper;
117 
118 template<int _Flags> struct GlMatrixHelper<false,_Flags>
119 {
120     static void loadMatrix(const Matrix<float, 4,4, _Flags, 4,4>&  mat) { glLoadMatrixf(mat.data()); }
121     static void loadMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glLoadMatrixd(mat.data()); }
122     static void multMatrix(const Matrix<float, 4,4, _Flags, 4,4>&  mat) { glMultMatrixf(mat.data()); }
123     static void multMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glMultMatrixd(mat.data()); }
124 };
125 
126 template<int _Flags> struct GlMatrixHelper<true,_Flags>
127 {
128     static void loadMatrix(const Matrix<float, 4,4, _Flags, 4,4>&  mat) { glLoadMatrixf(mat.transpose().eval().data()); }
129     static void loadMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glLoadMatrixd(mat.transpose().eval().data()); }
130     static void multMatrix(const Matrix<float, 4,4, _Flags, 4,4>&  mat) { glMultMatrixf(mat.transpose().eval().data()); }
131     static void multMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glMultMatrixd(mat.transpose().eval().data()); }
132 };
133 
134 inline void GpuHelper::setMatrixTarget(GLenum matrixTarget)
135 {
136     if (matrixTarget != mCurrentMatrixTarget)
137         glMatrixMode(mCurrentMatrixTarget=matrixTarget);
138 }
139 
140 template<typename Scalar, int _Flags>
141 void GpuHelper::multMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
142 {
143     setMatrixTarget(matrixTarget);
144     GlMatrixHelper<_Flags&Eigen::RowMajorBit, _Flags>::multMatrix(mat);
145 }
146 
147 template<typename Scalar, typename Derived>
148 void GpuHelper::loadMatrix(
149     const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
150     GLenum matrixTarget)
151 {
152     setMatrixTarget(matrixTarget);
153     glLoadIdentity();
154 }
155 
156 template<typename Scalar, int _Flags>
157 void GpuHelper::loadMatrix(const Eigen::Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
158 {
159     setMatrixTarget(matrixTarget);
160     GlMatrixHelper<(_Flags&Eigen::RowMajorBit)!=0, _Flags>::loadMatrix(mat);
161 }
162 
163 inline void GpuHelper::pushMatrix(GLenum matrixTarget)
164 {
165     setMatrixTarget(matrixTarget);
166     glPushMatrix();
167 }
168 
169 template<typename Scalar, int _Flags>
170 inline void GpuHelper::pushMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
171 {
172     pushMatrix(matrixTarget);
173     GlMatrixHelper<_Flags&Eigen::RowMajorBit,_Flags>::loadMatrix(mat);
174 }
175 
176 template<typename Scalar, typename Derived>
177 void GpuHelper::pushMatrix(
178     const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
179     GLenum matrixTarget)
180 {
181     pushMatrix(matrixTarget);
182     glLoadIdentity();
183 }
184 
185 inline void GpuHelper::popMatrix(GLenum matrixTarget)
186 {
187     setMatrixTarget(matrixTarget);
188     glPopMatrix();
189 }
190 
191 inline void GpuHelper::draw(GLenum mode, uint nofElement)
192 {
193     glDrawArrays(mode, 0, nofElement);
194 }
195 
196 
197 inline void GpuHelper::draw(GLenum mode, const std::vector<uint>* pIndexes)
198 {
199     glDrawElements(mode, pIndexes->size(), GL_UNSIGNED_INT, &(pIndexes->front()));
200 }
201 
202 inline void GpuHelper::draw(GLenum mode, uint start, uint end)
203 {
204     glDrawArrays(mode, start, end-start);
205 }
206 
207 #endif // EIGEN_GPUHELPER_H
208