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
17using namespace Eigen;
18
19typedef Vector4f Color;
20
21class 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    */
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
99protected:
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*/
111extern GpuHelper gpu;
112
113
114/** \internal
115*/
116template<bool RowMajor, int _Flags> struct GlMatrixHelper;
117
118template<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
126template<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
134inline void GpuHelper::setMatrixTarget(GLenum matrixTarget)
135{
136    if (matrixTarget != mCurrentMatrixTarget)
137        glMatrixMode(mCurrentMatrixTarget=matrixTarget);
138}
139
140template<typename Scalar, int _Flags>
141void 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
147template<typename Scalar, typename Derived>
148void GpuHelper::loadMatrix(
149    const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
150    GLenum matrixTarget)
151{
152    setMatrixTarget(matrixTarget);
153    glLoadIdentity();
154}
155
156template<typename Scalar, int _Flags>
157void 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
163inline void GpuHelper::pushMatrix(GLenum matrixTarget)
164{
165    setMatrixTarget(matrixTarget);
166    glPushMatrix();
167}
168
169template<typename Scalar, int _Flags>
170inline 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
176template<typename Scalar, typename Derived>
177void GpuHelper::pushMatrix(
178    const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
179    GLenum matrixTarget)
180{
181    pushMatrix(matrixTarget);
182    glLoadIdentity();
183}
184
185inline void GpuHelper::popMatrix(GLenum matrixTarget)
186{
187    setMatrixTarget(matrixTarget);
188    glPopMatrix();
189}
190
191inline void GpuHelper::draw(GLenum mode, uint nofElement)
192{
193    glDrawArrays(mode, 0, nofElement);
194}
195
196
197inline void GpuHelper::draw(GLenum mode, const std::vector<uint>* pIndexes)
198{
199    glDrawElements(mode, pIndexes->size(), GL_UNSIGNED_INT, &(pIndexes->front()));
200}
201
202inline void GpuHelper::draw(GLenum mode, uint start, uint end)
203{
204    glDrawArrays(mode, start, end-start);
205}
206
207#endif // EIGEN_GPUHELPER_H
208