Eigen-Contrib  5.0.1
 
Loading...
Searching...
No Matches
OpenGLSupport
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2010 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// SPDX-License-Identifier: MPL-2.0
10
11#ifndef EIGEN_OPENGL_MODULE_H
12#define EIGEN_OPENGL_MODULE_H
13
14#include "../../Eigen/Geometry"
15
16#if defined(__APPLE_CC__)
17#include <OpenGL/gl.h>
18#else
19#include <GL/gl.h>
20#endif
21
22#include "../../Eigen/src/Core/util/DisableStupidWarnings.h"
23
24namespace Eigen {
25
50
51#define EIGEN_GL_FUNC_DECLARATION(FUNC) \
52 namespace internal { \
53 template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
54 int Cols = XprType::ColsAtCompileTime, \
55 bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) && \
56 bool(XprType::Flags & DirectAccessBit) && \
57 (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)> \
58 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl); \
59 \
60 template <typename XprType, typename Scalar, int Rows, int Cols> \
61 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> { \
62 inline static void run(const XprType& p) { \
63 EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(p); \
64 } \
65 }; \
66 } \
67 \
68 template <typename Derived> \
69 inline void FUNC(const Eigen::DenseBase<Derived>& p) { \
70 EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(p.derived()); \
71 }
72
73#define EIGEN_GL_FUNC_SPECIALIZATION_MAT(FUNC, SCALAR, ROWS, COLS, SUFFIX) \
74 namespace internal { \
75 template <typename XprType> \
76 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> { \
77 inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
78 }; \
79 }
80
81#define EIGEN_GL_FUNC_SPECIALIZATION_VEC(FUNC, SCALAR, SIZE, SUFFIX) \
82 namespace internal { \
83 template <typename XprType> \
84 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> { \
85 inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
86 }; \
87 template <typename XprType> \
88 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> { \
89 inline static void run(const XprType& p) { FUNC##SUFFIX(p.data()); } \
90 }; \
91 }
92
93EIGEN_GL_FUNC_DECLARATION(glVertex)
94EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 2, 2iv)
95EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 2, 2sv)
96EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 2, 2fv)
97EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 2, 2dv)
98EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 3, 3iv)
99EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 3, 3sv)
100EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 3, 3fv)
101EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 3, 3dv)
102EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, int, 4, 4iv)
103EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, short, 4, 4sv)
104EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, float, 4, 4fv)
105EIGEN_GL_FUNC_SPECIALIZATION_VEC(glVertex, double, 4, 4dv)
106
107EIGEN_GL_FUNC_DECLARATION(glTexCoord)
108EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 2, 2iv)
109EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 2, 2sv)
110EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 2, 2fv)
111EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 2, 2dv)
112EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 3, 3iv)
113EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 3, 3sv)
114EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 3, 3fv)
115EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 3, 3dv)
116EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, int, 4, 4iv)
117EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, short, 4, 4sv)
118EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, float, 4, 4fv)
119EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTexCoord, double, 4, 4dv)
120
121EIGEN_GL_FUNC_DECLARATION(glColor)
122EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 2, 2iv)
123EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 2, 2sv)
124EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 2, 2fv)
125EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 2, 2dv)
126EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 3, 3iv)
127EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 3, 3sv)
128EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 3, 3fv)
129EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 3, 3dv)
130EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, int, 4, 4iv)
131EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, short, 4, 4sv)
132EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, float, 4, 4fv)
133EIGEN_GL_FUNC_SPECIALIZATION_VEC(glColor, double, 4, 4dv)
134
135EIGEN_GL_FUNC_DECLARATION(glNormal)
136EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, int, 3, 3iv)
137EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, short, 3, 3sv)
138EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, float, 3, 3fv)
139EIGEN_GL_FUNC_SPECIALIZATION_VEC(glNormal, double, 3, 3dv)
140
141inline void glScale2fv(const float* v) { glScalef(v[0], v[1], 1.f); }
142inline void glScale2dv(const double* v) { glScaled(v[0], v[1], 1.0); }
143inline void glScale3fv(const float* v) { glScalef(v[0], v[1], v[2]); }
144inline void glScale3dv(const double* v) { glScaled(v[0], v[1], v[2]); }
145
146EIGEN_GL_FUNC_DECLARATION(glScale)
147EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 2, 2fv)
148EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 2, 2dv)
149EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, float, 3, 3fv)
150EIGEN_GL_FUNC_SPECIALIZATION_VEC(glScale, double, 3, 3dv)
151
152template <typename Scalar>
153void glScale(const UniformScaling<Scalar>& s) {
154 glScale(Matrix<Scalar, 3, 1>::Constant(s.factor()));
155}
156
157inline void glTranslate2fv(const float* v) { glTranslatef(v[0], v[1], 0.f); }
158inline void glTranslate2dv(const double* v) { glTranslated(v[0], v[1], 0.0); }
159inline void glTranslate3fv(const float* v) { glTranslatef(v[0], v[1], v[2]); }
160inline void glTranslate3dv(const double* v) { glTranslated(v[0], v[1], v[2]); }
161
162EIGEN_GL_FUNC_DECLARATION(glTranslate)
163EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 2, 2fv)
164EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 2, 2dv)
165EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, float, 3, 3fv)
166EIGEN_GL_FUNC_SPECIALIZATION_VEC(glTranslate, double, 3, 3dv)
167
168template <typename Scalar>
169void glTranslate(const Translation<Scalar, 2>& t) {
170 glTranslate(t.vector());
171}
172template <typename Scalar>
173void glTranslate(const Translation<Scalar, 3>& t) {
174 glTranslate(t.vector());
175}
176
177EIGEN_GL_FUNC_DECLARATION(glMultMatrix)
178EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, float, 4, 4, f)
179EIGEN_GL_FUNC_SPECIALIZATION_MAT(glMultMatrix, double, 4, 4, d)
180
181template <typename Scalar>
182void glMultMatrix(const Transform<Scalar, 3, Affine>& t) {
183 glMultMatrix(t.matrix());
184}
185template <typename Scalar>
186void glMultMatrix(const Transform<Scalar, 3, Projective>& t) {
187 glMultMatrix(t.matrix());
188}
189template <typename Scalar>
190void glMultMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
191 glMultMatrix(Transform<Scalar, 3, Affine>(t).matrix());
192}
193
194EIGEN_GL_FUNC_DECLARATION(glLoadMatrix)
195EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, float, 4, 4, f)
196EIGEN_GL_FUNC_SPECIALIZATION_MAT(glLoadMatrix, double, 4, 4, d)
197
198template <typename Scalar>
199void glLoadMatrix(const Transform<Scalar, 3, Affine>& t) {
200 glLoadMatrix(t.matrix());
201}
202template <typename Scalar>
203void glLoadMatrix(const Transform<Scalar, 3, Projective>& t) {
204 glLoadMatrix(t.matrix());
205}
206template <typename Scalar>
207void glLoadMatrix(const Transform<Scalar, 3, AffineCompact>& t) {
208 glLoadMatrix(Transform<Scalar, 3, Affine>(t).matrix());
209}
210
211inline void glRotate(const Rotation2D<float>& rot) { glRotatef(rot.angle() * 180.f / float(EIGEN_PI), 0.f, 0.f, 1.f); }
212inline void glRotate(const Rotation2D<double>& rot) {
213 glRotated(rot.angle() * 180.0 / double(EIGEN_PI), 0.0, 0.0, 1.0);
214}
215
216template <typename Derived>
217void glRotate(const RotationBase<Derived, 3>& rot) {
218 Transform<typename Derived::Scalar, 3, Projective> tr(rot);
219 glMultMatrix(tr.matrix());
220}
221
222#define EIGEN_GL_MAKE_CONST_const const
223#define EIGEN_GL_MAKE_CONST__
224#define EIGEN_GL_EVAL(X) X
225
226#define EIGEN_GL_FUNC1_DECLARATION(FUNC, ARG1, CONST) \
227 namespace internal { \
228 template <typename XprType, typename Scalar = typename XprType::Scalar, int Rows = XprType::RowsAtCompileTime, \
229 int Cols = XprType::ColsAtCompileTime, \
230 bool IsGLCompatible = bool(internal::evaluator<XprType>::Flags & LinearAccessBit) && \
231 bool(XprType::Flags & DirectAccessBit) && \
232 (XprType::IsVectorAtCompileTime || (XprType::Flags & RowMajorBit) == 0)> \
233 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl); \
234 \
235 template <typename XprType, typename Scalar, int Rows, int Cols> \
236 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, Scalar, Rows, Cols, false> { \
237 inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
238 EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<typename plain_matrix_type_column_major<XprType>::type>::run(a, p); \
239 } \
240 }; \
241 } \
242 \
243 template <typename Derived> \
244 inline void FUNC(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) Eigen::DenseBase<Derived>& p) { \
245 EIGEN_CAT(EIGEN_CAT(internal::gl_, FUNC), _impl)<Derived>::run(a, p.derived()); \
246 }
247
248#define EIGEN_GL_FUNC1_SPECIALIZATION_MAT(FUNC, ARG1, CONST, SCALAR, ROWS, COLS, SUFFIX) \
249 namespace internal { \
250 template <typename XprType> \
251 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, ROWS, COLS, true> { \
252 inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
253 FUNC##SUFFIX(a, p.data()); \
254 } \
255 }; \
256 }
257
258#define EIGEN_GL_FUNC1_SPECIALIZATION_VEC(FUNC, ARG1, CONST, SCALAR, SIZE, SUFFIX) \
259 namespace internal { \
260 template <typename XprType> \
261 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, SIZE, 1, true> { \
262 inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
263 FUNC##SUFFIX(a, p.data()); \
264 } \
265 }; \
266 template <typename XprType> \
267 struct EIGEN_CAT(EIGEN_CAT(gl_, FUNC), _impl)<XprType, SCALAR, 1, SIZE, true> { \
268 inline static void run(ARG1 a, EIGEN_GL_EVAL(EIGEN_GL_MAKE_CONST_##CONST) XprType& p) { \
269 FUNC##SUFFIX(a, p.data()); \
270 } \
271 }; \
272 }
273
274EIGEN_GL_FUNC1_DECLARATION(glGet, GLenum, _)
275EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, float, 4, 4, Floatv)
276EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glGet, GLenum, _, double, 4, 4, Doublev)
277
278// glUniform API
279
280#ifdef GL_VERSION_2_0
281
282inline void glUniform2fv_ei(GLint loc, const float* v) { glUniform2fv(loc, 1, v); }
283inline void glUniform2iv_ei(GLint loc, const int* v) { glUniform2iv(loc, 1, v); }
284
285inline void glUniform3fv_ei(GLint loc, const float* v) { glUniform3fv(loc, 1, v); }
286inline void glUniform3iv_ei(GLint loc, const int* v) { glUniform3iv(loc, 1, v); }
287
288inline void glUniform4fv_ei(GLint loc, const float* v) { glUniform4fv(loc, 1, v); }
289inline void glUniform4iv_ei(GLint loc, const int* v) { glUniform4iv(loc, 1, v); }
290
291inline void glUniformMatrix2fv_ei(GLint loc, const float* v) { glUniformMatrix2fv(loc, 1, false, v); }
292inline void glUniformMatrix3fv_ei(GLint loc, const float* v) { glUniformMatrix3fv(loc, 1, false, v); }
293inline void glUniformMatrix4fv_ei(GLint loc, const float* v) { glUniformMatrix4fv(loc, 1, false, v); }
294
295EIGEN_GL_FUNC1_DECLARATION(glUniform, GLint, const)
296EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 2, 2fv_ei)
297EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 2, 2iv_ei)
298EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 3, 3fv_ei)
299EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 3, 3iv_ei)
300EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, float, 4, 4fv_ei)
301EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, int, 4, 4iv_ei)
302
303EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 2, Matrix2fv_ei)
304EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 3, Matrix3fv_ei)
305EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 4, Matrix4fv_ei)
306
307#endif
308
309#ifdef GL_VERSION_2_1
310
311inline void glUniformMatrix2x3fv_ei(GLint loc, const float* v) { glUniformMatrix2x3fv(loc, 1, false, v); }
312inline void glUniformMatrix3x2fv_ei(GLint loc, const float* v) { glUniformMatrix3x2fv(loc, 1, false, v); }
313inline void glUniformMatrix2x4fv_ei(GLint loc, const float* v) { glUniformMatrix2x4fv(loc, 1, false, v); }
314inline void glUniformMatrix4x2fv_ei(GLint loc, const float* v) { glUniformMatrix4x2fv(loc, 1, false, v); }
315inline void glUniformMatrix3x4fv_ei(GLint loc, const float* v) { glUniformMatrix3x4fv(loc, 1, false, v); }
316inline void glUniformMatrix4x3fv_ei(GLint loc, const float* v) { glUniformMatrix4x3fv(loc, 1, false, v); }
317
318EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 3, Matrix2x3fv_ei)
319EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 2, Matrix3x2fv_ei)
320EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 2, 4, Matrix2x4fv_ei)
321EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 2, Matrix4x2fv_ei)
322EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 3, 4, Matrix3x4fv_ei)
323EIGEN_GL_FUNC1_SPECIALIZATION_MAT(glUniform, GLint, const, float, 4, 3, Matrix4x3fv_ei)
324
325#endif
326
327#ifdef GL_VERSION_3_0
328
329inline void glUniform2uiv_ei(GLint loc, const unsigned int* v) { glUniform2uiv(loc, 1, v); }
330inline void glUniform3uiv_ei(GLint loc, const unsigned int* v) { glUniform3uiv(loc, 1, v); }
331inline void glUniform4uiv_ei(GLint loc, const unsigned int* v) { glUniform4uiv(loc, 1, v); }
332
333EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 2, 2uiv_ei)
334EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 3, 3uiv_ei)
335EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, unsigned int, 4, 4uiv_ei)
336
337#endif
338
339#ifdef GL_ARB_gpu_shader_fp64
340inline void glUniform2dv_ei(GLint loc, const double* v) { glUniform2dv(loc, 1, v); }
341inline void glUniform3dv_ei(GLint loc, const double* v) { glUniform3dv(loc, 1, v); }
342inline void glUniform4dv_ei(GLint loc, const double* v) { glUniform4dv(loc, 1, v); }
343
344EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 2, 2dv_ei)
345EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 3, 3dv_ei)
346EIGEN_GL_FUNC1_SPECIALIZATION_VEC(glUniform, GLint, const, double, 4, 4dv_ei)
347#endif
348
350
351} // namespace Eigen
352
353#include "../../Eigen/src/Core/util/ReenableStupidWarnings.h"
354
355#endif // EIGEN_OPENGL_MODULE_H
Eigen
Namespace containing all symbols from the Eigen library.