| 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 |
|
|---|
| 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 |
|
|---|
| 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 |
|
|---|
| 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 | }
|
|---|
