Squashed 'third_party/eigen/' content from commit 61d72f6
Change-Id: Iccc90fa0b55ab44037f018046d2fcffd90d9d025
git-subtree-dir: third_party/eigen
git-subtree-split: 61d72f6383cfa842868c53e30e087b0258177257
diff --git a/demos/opengl/gpuhelper.h b/demos/opengl/gpuhelper.h
new file mode 100644
index 0000000..9ff98e9
--- /dev/null
+++ b/demos/opengl/gpuhelper.h
@@ -0,0 +1,207 @@
+// This file is part of Eigen, a lightweight C++ template library
+// for linear algebra.
+//
+// Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
+//
+// 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/.
+
+#ifndef EIGEN_GPUHELPER_H
+#define EIGEN_GPUHELPER_H
+
+#include <Eigen/Geometry>
+#include <GL/gl.h>
+#include <vector>
+
+using namespace Eigen;
+
+typedef Vector4f Color;
+
+class GpuHelper
+{
+ public:
+
+ GpuHelper();
+
+ ~GpuHelper();
+
+ enum ProjectionMode2D { PM_Normalized = 1, PM_Viewport = 2 };
+ void pushProjectionMode2D(ProjectionMode2D pm);
+ void popProjectionMode2D();
+
+ /** Multiply the OpenGL matrix \a matrixTarget by the matrix \a mat.
+ Essentially, this helper function automatically calls glMatrixMode(matrixTarget) if required
+ and does a proper call to the right glMultMatrix*() function according to the scalar type
+ and storage order.
+ \warning glMatrixMode() must never be called directly. If your're unsure, use forceMatrixMode().
+ \sa Matrix, loadMatrix(), forceMatrixMode()
+ */
+ template<typename Scalar, int _Flags>
+ void multMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
+
+ /** Load the matrix \a mat to the OpenGL matrix \a matrixTarget.
+ Essentially, this helper function automatically calls glMatrixMode(matrixTarget) if required
+ and does a proper call to the right glLoadMatrix*() or glLoadIdentity() function according to the scalar type
+ and storage order.
+ \warning glMatrixMode() must never be called directly. If your're unsure, use forceMatrixMode().
+ \sa Matrix, multMatrix(), forceMatrixMode()
+ */
+ template<typename Scalar, int _Flags>
+ void loadMatrix(const Eigen::Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
+
+ template<typename Scalar, typename Derived>
+ void loadMatrix(
+ const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
+ GLenum matrixTarget);
+
+ /** Make the matrix \a matrixTarget the current OpenGL matrix target.
+ Call this function before loadMatrix() or multMatrix() if you cannot guarantee that glMatrixMode()
+ has never been called after the last loadMatrix() or multMatrix() calls.
+ \todo provides a debug mode checking the sanity of the cached matrix mode.
+ */
+ inline void forceMatrixTarget(GLenum matrixTarget) {glMatrixMode(mCurrentMatrixTarget=matrixTarget);}
+
+ inline void setMatrixTarget(GLenum matrixTarget);
+
+ /** Push the OpenGL matrix \a matrixTarget and load \a mat.
+ */
+ template<typename Scalar, int _Flags>
+ inline void pushMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget);
+
+ template<typename Scalar, typename Derived>
+ void pushMatrix(
+ const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
+ GLenum matrixTarget);
+
+ /** Push and clone the OpenGL matrix \a matrixTarget
+ */
+ inline void pushMatrix(GLenum matrixTarget);
+
+ /** Pop the OpenGL matrix \a matrixTarget
+ */
+ inline void popMatrix(GLenum matrixTarget);
+
+ void drawVector(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect = 50.);
+ void drawVectorBox(const Vector3f& position, const Vector3f& vec, const Color& color, float aspect = 50.);
+ void drawUnitCube(void);
+ void drawUnitSphere(int level=0);
+
+ /// draw the \a nofElement first elements
+ inline void draw(GLenum mode, uint nofElement);
+
+ /// draw a range of elements
+ inline void draw(GLenum mode, uint start, uint end);
+
+ /// draw an indexed subset
+ inline void draw(GLenum mode, const std::vector<uint>* pIndexes);
+
+protected:
+
+ void update(void);
+
+ GLuint mColorBufferId;
+ int mVpWidth, mVpHeight;
+ GLenum mCurrentMatrixTarget;
+ bool mInitialized;
+};
+
+/** Singleton shortcut
+*/
+extern GpuHelper gpu;
+
+
+/** \internal
+*/
+template<bool RowMajor, int _Flags> struct GlMatrixHelper;
+
+template<int _Flags> struct GlMatrixHelper<false,_Flags>
+{
+ static void loadMatrix(const Matrix<float, 4,4, _Flags, 4,4>& mat) { glLoadMatrixf(mat.data()); }
+ static void loadMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glLoadMatrixd(mat.data()); }
+ static void multMatrix(const Matrix<float, 4,4, _Flags, 4,4>& mat) { glMultMatrixf(mat.data()); }
+ static void multMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glMultMatrixd(mat.data()); }
+};
+
+template<int _Flags> struct GlMatrixHelper<true,_Flags>
+{
+ static void loadMatrix(const Matrix<float, 4,4, _Flags, 4,4>& mat) { glLoadMatrixf(mat.transpose().eval().data()); }
+ static void loadMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glLoadMatrixd(mat.transpose().eval().data()); }
+ static void multMatrix(const Matrix<float, 4,4, _Flags, 4,4>& mat) { glMultMatrixf(mat.transpose().eval().data()); }
+ static void multMatrix(const Matrix<double,4,4, _Flags, 4,4>& mat) { glMultMatrixd(mat.transpose().eval().data()); }
+};
+
+inline void GpuHelper::setMatrixTarget(GLenum matrixTarget)
+{
+ if (matrixTarget != mCurrentMatrixTarget)
+ glMatrixMode(mCurrentMatrixTarget=matrixTarget);
+}
+
+template<typename Scalar, int _Flags>
+void GpuHelper::multMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
+{
+ setMatrixTarget(matrixTarget);
+ GlMatrixHelper<_Flags&Eigen::RowMajorBit, _Flags>::multMatrix(mat);
+}
+
+template<typename Scalar, typename Derived>
+void GpuHelper::loadMatrix(
+ const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
+ GLenum matrixTarget)
+{
+ setMatrixTarget(matrixTarget);
+ glLoadIdentity();
+}
+
+template<typename Scalar, int _Flags>
+void GpuHelper::loadMatrix(const Eigen::Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
+{
+ setMatrixTarget(matrixTarget);
+ GlMatrixHelper<(_Flags&Eigen::RowMajorBit)!=0, _Flags>::loadMatrix(mat);
+}
+
+inline void GpuHelper::pushMatrix(GLenum matrixTarget)
+{
+ setMatrixTarget(matrixTarget);
+ glPushMatrix();
+}
+
+template<typename Scalar, int _Flags>
+inline void GpuHelper::pushMatrix(const Matrix<Scalar,4,4, _Flags, 4,4>& mat, GLenum matrixTarget)
+{
+ pushMatrix(matrixTarget);
+ GlMatrixHelper<_Flags&Eigen::RowMajorBit,_Flags>::loadMatrix(mat);
+}
+
+template<typename Scalar, typename Derived>
+void GpuHelper::pushMatrix(
+ const Eigen::CwiseNullaryOp<Eigen::internal::scalar_identity_op<Scalar>,Derived>&,
+ GLenum matrixTarget)
+{
+ pushMatrix(matrixTarget);
+ glLoadIdentity();
+}
+
+inline void GpuHelper::popMatrix(GLenum matrixTarget)
+{
+ setMatrixTarget(matrixTarget);
+ glPopMatrix();
+}
+
+inline void GpuHelper::draw(GLenum mode, uint nofElement)
+{
+ glDrawArrays(mode, 0, nofElement);
+}
+
+
+inline void GpuHelper::draw(GLenum mode, const std::vector<uint>* pIndexes)
+{
+ glDrawElements(mode, pIndexes->size(), GL_UNSIGNED_INT, &(pIndexes->front()));
+}
+
+inline void GpuHelper::draw(GLenum mode, uint start, uint end)
+{
+ glDrawArrays(mode, start, end-start);
+}
+
+#endif // EIGEN_GPUHELPER_H