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
10 #include <main.h>
11 #include <iostream>
12 #include <GL/glew.h>
13 #include <Eigen/OpenGLSupport>
14 #include <GL/glut.h>
15 using namespace Eigen;
16
17
18
19
20 #define VERIFY_MATRIX(CODE,REF) { \
21 glLoadIdentity(); \
22 CODE; \
23 Matrix<float,4,4,ColMajor> m; m.setZero(); \
24 glGet(GL_MODELVIEW_MATRIX, m); \
25 if(!(REF).cast<float>().isApprox(m)) { \
26 std::cerr << "Expected:\n" << ((REF).cast<float>()) << "\n" << "got\n" << m << "\n\n"; \
27 } \
28 VERIFY_IS_APPROX((REF).cast<float>(), m); \
29 }
30
31 #define VERIFY_UNIFORM(SUFFIX,NAME,TYPE) { \
32 TYPE value; value.setRandom(); \
33 TYPE data; \
34 int loc = glGetUniformLocation(prg_id, #NAME); \
35 VERIFY((loc!=-1) && "uniform not found"); \
36 glUniform(loc,value); \
37 EIGEN_CAT(glGetUniform,SUFFIX)(prg_id,loc,data.data()); \
38 if(!value.isApprox(data)) { \
39 std::cerr << "Expected:\n" << value << "\n" << "got\n" << data << "\n\n"; \
40 } \
41 VERIFY_IS_APPROX(value, data); \
42 }
43
44 #define VERIFY_UNIFORMi(NAME,TYPE) { \
45 TYPE value = TYPE::Random().eval().cast<float>().cast<TYPE::Scalar>(); \
46 TYPE data; \
47 int loc = glGetUniformLocation(prg_id, #NAME); \
48 VERIFY((loc!=-1) && "uniform not found"); \
49 glUniform(loc,value); \
50 glGetUniformiv(prg_id,loc,(GLint*)data.data()); \
51 if(!value.isApprox(data)) { \
52 std::cerr << "Expected:\n" << value << "\n" << "got\n" << data << "\n\n"; \
53 } \
54 VERIFY_IS_APPROX(value, data); \
55 }
56
printInfoLog(GLuint objectID)57 void printInfoLog(GLuint objectID)
58 {
59 int infologLength, charsWritten;
60 GLchar *infoLog;
61 glGetProgramiv(objectID,GL_INFO_LOG_LENGTH, &infologLength);
62 if(infologLength > 0)
63 {
64 infoLog = new GLchar[infologLength];
65 glGetProgramInfoLog(objectID, infologLength, &charsWritten, infoLog);
66 if (charsWritten>0)
67 std::cerr << "Shader info : \n" << infoLog << std::endl;
68 delete[] infoLog;
69 }
70 }
71
createShader(const char * vtx,const char * frg)72 GLint createShader(const char* vtx, const char* frg)
73 {
74 GLint prg_id = glCreateProgram();
75 GLint vtx_id = glCreateShader(GL_VERTEX_SHADER);
76 GLint frg_id = glCreateShader(GL_FRAGMENT_SHADER);
77 GLint ok;
78
79 glShaderSource(vtx_id, 1, &vtx, 0);
80 glCompileShader(vtx_id);
81 glGetShaderiv(vtx_id,GL_COMPILE_STATUS,&ok);
82 if(!ok)
83 {
84 std::cerr << "vtx compilation failed\n";
85 }
86
87 glShaderSource(frg_id, 1, &frg, 0);
88 glCompileShader(frg_id);
89 glGetShaderiv(frg_id,GL_COMPILE_STATUS,&ok);
90 if(!ok)
91 {
92 std::cerr << "frg compilation failed\n";
93 }
94
95 glAttachShader(prg_id, vtx_id);
96 glAttachShader(prg_id, frg_id);
97 glLinkProgram(prg_id);
98 glGetProgramiv(prg_id,GL_LINK_STATUS,&ok);
99 if(!ok)
100 {
101 std::cerr << "linking failed\n";
102 }
103 printInfoLog(prg_id);
104
105 glUseProgram(prg_id);
106 return prg_id;
107 }
108
test_openglsupport()109 void test_openglsupport()
110 {
111 int argc = 0;
112 glutInit(&argc, 0);
113 glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
114 glutInitWindowPosition (0,0);
115 glutInitWindowSize(10, 10);
116
117 if(glutCreateWindow("Eigen") <= 0)
118 {
119 std::cerr << "Error: Unable to create GLUT Window.\n";
120 exit(1);
121 }
122
123 glewExperimental = GL_TRUE;
124 if(glewInit() != GLEW_OK)
125 {
126 std::cerr << "Warning: Failed to initialize GLEW\n";
127 }
128
129 Vector3f v3f;
130 Matrix3f rot;
131 glBegin(GL_POINTS);
132
133 glVertex(v3f);
134 glVertex(2*v3f+v3f);
135 glVertex(rot*v3f);
136
137 glEnd();
138
139 // 4x4 matrices
140 Matrix4f mf44; mf44.setRandom();
141 VERIFY_MATRIX(glLoadMatrix(mf44), mf44);
142 VERIFY_MATRIX(glMultMatrix(mf44), mf44);
143 Matrix4d md44; md44.setRandom();
144 VERIFY_MATRIX(glLoadMatrix(md44), md44);
145 VERIFY_MATRIX(glMultMatrix(md44), md44);
146
147 // Quaternion
148 Quaterniond qd(AngleAxisd(internal::random<double>(), Vector3d::Random()));
149 VERIFY_MATRIX(glRotate(qd), Projective3d(qd).matrix());
150
151 Quaternionf qf(AngleAxisf(internal::random<double>(), Vector3f::Random()));
152 VERIFY_MATRIX(glRotate(qf), Projective3f(qf).matrix());
153
154 // 3D Transform
155 Transform<float,3,AffineCompact> acf3; acf3.matrix().setRandom();
156 VERIFY_MATRIX(glLoadMatrix(acf3), Projective3f(acf3).matrix());
157 VERIFY_MATRIX(glMultMatrix(acf3), Projective3f(acf3).matrix());
158
159 Transform<float,3,Affine> af3(acf3);
160 VERIFY_MATRIX(glLoadMatrix(af3), Projective3f(af3).matrix());
161 VERIFY_MATRIX(glMultMatrix(af3), Projective3f(af3).matrix());
162
163 Transform<float,3,Projective> pf3; pf3.matrix().setRandom();
164 VERIFY_MATRIX(glLoadMatrix(pf3), Projective3f(pf3).matrix());
165 VERIFY_MATRIX(glMultMatrix(pf3), Projective3f(pf3).matrix());
166
167 Transform<double,3,AffineCompact> acd3; acd3.matrix().setRandom();
168 VERIFY_MATRIX(glLoadMatrix(acd3), Projective3d(acd3).matrix());
169 VERIFY_MATRIX(glMultMatrix(acd3), Projective3d(acd3).matrix());
170
171 Transform<double,3,Affine> ad3(acd3);
172 VERIFY_MATRIX(glLoadMatrix(ad3), Projective3d(ad3).matrix());
173 VERIFY_MATRIX(glMultMatrix(ad3), Projective3d(ad3).matrix());
174
175 Transform<double,3,Projective> pd3; pd3.matrix().setRandom();
176 VERIFY_MATRIX(glLoadMatrix(pd3), Projective3d(pd3).matrix());
177 VERIFY_MATRIX(glMultMatrix(pd3), Projective3d(pd3).matrix());
178
179 // translations (2D and 3D)
180 {
181 Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 0;
182 VERIFY_MATRIX(glTranslate(vf2), Projective3f(Translation3f(vf23)).matrix());
183 Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 0;
184 VERIFY_MATRIX(glTranslate(vd2), Projective3d(Translation3d(vd23)).matrix());
185
186 Vector3f vf3; vf3.setRandom();
187 VERIFY_MATRIX(glTranslate(vf3), Projective3f(Translation3f(vf3)).matrix());
188 Vector3d vd3; vd3.setRandom();
189 VERIFY_MATRIX(glTranslate(vd3), Projective3d(Translation3d(vd3)).matrix());
190
191 Translation<float,3> tf3; tf3.vector().setRandom();
192 VERIFY_MATRIX(glTranslate(tf3), Projective3f(tf3).matrix());
193
194 Translation<double,3> td3; td3.vector().setRandom();
195 VERIFY_MATRIX(glTranslate(td3), Projective3d(td3).matrix());
196 }
197
198 // scaling (2D and 3D)
199 {
200 Vector2f vf2; vf2.setRandom(); Vector3f vf23; vf23 << vf2, 1;
201 VERIFY_MATRIX(glScale(vf2), Projective3f(Scaling(vf23)).matrix());
202 Vector2d vd2; vd2.setRandom(); Vector3d vd23; vd23 << vd2, 1;
203 VERIFY_MATRIX(glScale(vd2), Projective3d(Scaling(vd23)).matrix());
204
205 Vector3f vf3; vf3.setRandom();
206 VERIFY_MATRIX(glScale(vf3), Projective3f(Scaling(vf3)).matrix());
207 Vector3d vd3; vd3.setRandom();
208 VERIFY_MATRIX(glScale(vd3), Projective3d(Scaling(vd3)).matrix());
209
210 UniformScaling<float> usf(internal::random<float>());
211 VERIFY_MATRIX(glScale(usf), Projective3f(usf).matrix());
212
213 UniformScaling<double> usd(internal::random<double>());
214 VERIFY_MATRIX(glScale(usd), Projective3d(usd).matrix());
215 }
216
217 // uniform
218 {
219 const char* vtx = "void main(void) { gl_Position = gl_Vertex; }\n";
220
221 if(GLEW_VERSION_2_0)
222 {
223 #ifdef GL_VERSION_2_0
224 const char* frg = ""
225 "uniform vec2 v2f;\n"
226 "uniform vec3 v3f;\n"
227 "uniform vec4 v4f;\n"
228 "uniform ivec2 v2i;\n"
229 "uniform ivec3 v3i;\n"
230 "uniform ivec4 v4i;\n"
231 "uniform mat2 m2f;\n"
232 "uniform mat3 m3f;\n"
233 "uniform mat4 m4f;\n"
234 "void main(void) { gl_FragColor = vec4(v2f[0]+v3f[0]+v4f[0])+vec4(v2i[0]+v3i[0]+v4i[0])+vec4(m2f[0][0]+m3f[0][0]+m4f[0][0]); }\n";
235
236 GLint prg_id = createShader(vtx,frg);
237
238 VERIFY_UNIFORM(fv,v2f, Vector2f);
239 VERIFY_UNIFORM(fv,v3f, Vector3f);
240 VERIFY_UNIFORM(fv,v4f, Vector4f);
241 VERIFY_UNIFORMi(v2i, Vector2i);
242 VERIFY_UNIFORMi(v3i, Vector3i);
243 VERIFY_UNIFORMi(v4i, Vector4i);
244 VERIFY_UNIFORM(fv,m2f, Matrix2f);
245 VERIFY_UNIFORM(fv,m3f, Matrix3f);
246 VERIFY_UNIFORM(fv,m4f, Matrix4f);
247 #endif
248 }
249 else
250 std::cerr << "Warning: opengl 2.0 was not tested\n";
251
252 if(GLEW_VERSION_2_1)
253 {
254 #ifdef GL_VERSION_2_1
255 const char* frg = "#version 120\n"
256 "uniform mat2x3 m23f;\n"
257 "uniform mat3x2 m32f;\n"
258 "uniform mat2x4 m24f;\n"
259 "uniform mat4x2 m42f;\n"
260 "uniform mat3x4 m34f;\n"
261 "uniform mat4x3 m43f;\n"
262 "void main(void) { gl_FragColor = vec4(m23f[0][0]+m32f[0][0]+m24f[0][0]+m42f[0][0]+m34f[0][0]+m43f[0][0]); }\n";
263
264 GLint prg_id = createShader(vtx,frg);
265
266 typedef Matrix<float,2,3> Matrix23f;
267 typedef Matrix<float,3,2> Matrix32f;
268 typedef Matrix<float,2,4> Matrix24f;
269 typedef Matrix<float,4,2> Matrix42f;
270 typedef Matrix<float,3,4> Matrix34f;
271 typedef Matrix<float,4,3> Matrix43f;
272
273 VERIFY_UNIFORM(fv,m23f, Matrix23f);
274 VERIFY_UNIFORM(fv,m32f, Matrix32f);
275 VERIFY_UNIFORM(fv,m24f, Matrix24f);
276 VERIFY_UNIFORM(fv,m42f, Matrix42f);
277 VERIFY_UNIFORM(fv,m34f, Matrix34f);
278 VERIFY_UNIFORM(fv,m43f, Matrix43f);
279 #endif
280 }
281 else
282 std::cerr << "Warning: opengl 2.1 was not tested\n";
283
284 if(GLEW_VERSION_3_0)
285 {
286 #ifdef GL_VERSION_3_0
287 const char* frg = "#version 150\n"
288 "uniform uvec2 v2ui;\n"
289 "uniform uvec3 v3ui;\n"
290 "uniform uvec4 v4ui;\n"
291 "out vec4 data;\n"
292 "void main(void) { data = vec4(v2ui[0]+v3ui[0]+v4ui[0]); }\n";
293
294 GLint prg_id = createShader(vtx,frg);
295
296 typedef Matrix<unsigned int,2,1> Vector2ui;
297 typedef Matrix<unsigned int,3,1> Vector3ui;
298 typedef Matrix<unsigned int,4,1> Vector4ui;
299
300 VERIFY_UNIFORMi(v2ui, Vector2ui);
301 VERIFY_UNIFORMi(v3ui, Vector3ui);
302 VERIFY_UNIFORMi(v4ui, Vector4ui);
303 #endif
304 }
305 else
306 std::cerr << "Warning: opengl 3.0 was not tested\n";
307
308 #ifdef GLEW_ARB_gpu_shader_fp64
309 if(GLEW_ARB_gpu_shader_fp64)
310 {
311 #ifdef GL_ARB_gpu_shader_fp64
312 const char* frg = "#version 150\n"
313 "uniform dvec2 v2d;\n"
314 "uniform dvec3 v3d;\n"
315 "uniform dvec4 v4d;\n"
316 "out vec4 data;\n"
317 "void main(void) { data = vec4(v2d[0]+v3d[0]+v4d[0]); }\n";
318
319 GLint prg_id = createShader(vtx,frg);
320
321 typedef Vector2d Vector2d;
322 typedef Vector3d Vector3d;
323 typedef Vector4d Vector4d;
324
325 VERIFY_UNIFORM(dv,v2d, Vector2d);
326 VERIFY_UNIFORM(dv,v3d, Vector3d);
327 VERIFY_UNIFORM(dv,v4d, Vector4d);
328 #endif
329 }
330 else
331 std::cerr << "Warning: GLEW_ARB_gpu_shader_fp64 was not tested\n";
332 #else
333 std::cerr << "Warning: GLEW_ARB_gpu_shader_fp64 was not tested\n";
334 #endif
335 }
336
337 }
338