Developer Documentation

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
GLMatrixT.cc
1 /*===========================================================================*\
2 * *
3 * OpenFlipper *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openflipper.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenFlipper. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 \*===========================================================================*/
41
42 /*===========================================================================*\
43 * *
44 * $Revision$ *
45 * $Author$ *
46 * $Date$ *
47 * *
48 \*===========================================================================*/
49
50
51
52 //=============================================================================
53 //
54 // CLASS GLMatrixT - IMPLEMENTATION
55 //
56 //=============================================================================
57
58
59 #define ACG_GLMATRIX_C
60
61
62 //== INCLUDES =================================================================
63
64
65 #include "GLMatrixT.hh"
66 #include <cmath>
67
68
69 //== IMPLEMENTATION ==========================================================
70
71
72 namespace ACG {
73
74
75 //-----------------------------------------------------------------------------
76
77
78 template<typename Scalar>
79 void
80 GLMatrixT<Scalar>::
81 scale( Scalar _x, Scalar _y, Scalar _z,
82 MultiplyFrom _mult_from )
83 {
84 GLMatrixT<Scalar> m;
85 m.identity();
86
87 m(0,0) = _x;
88 m(1,1) = _y;
89 m(2,2) = _z;
90
91 if (_mult_from == MULT_FROM_RIGHT) *this *= m;
92 else leftMult(m);
93 }
94
95
96 //-----------------------------------------------------------------------------
97
98
99 template<typename Scalar>
100 void
101 GLMatrixT<Scalar>::
102 translate( Scalar _x, Scalar _y, Scalar _z,
103 MultiplyFrom _mult_from )
104 {
105 GLMatrixT<Scalar> m;
106 m.identity();
107
108 m(0,3) = _x;
109 m(1,3) = _y;
110 m(2,3) = _z;
111
112 if (_mult_from == MULT_FROM_RIGHT) *this *= m;
113 else leftMult(m);
114 }
115
116
117 //-----------------------------------------------------------------------------
118
119
120 template<typename Scalar>
121 void
122 GLMatrixT<Scalar>::
123 rotateXYZ( Axis _axis, Scalar _angle,
124 MultiplyFrom _mult_from )
125 {
126 GLMatrixT<Scalar> m;
127 m.identity();
128
129 Scalar ca = cos(_angle * (M_PI/180.0));
130 Scalar sa = sin(_angle * (M_PI/180.0));
131
132 switch (_axis)
133 {
134 case X:
135 m(1,1) = m(2,2) = ca; m(2,1) = sa; m(1,2) = -sa;
136 break;
137
138 case Y:
139 m(0,0) = m(2,2) = ca; m(0,2) = sa; m(2,0) = -sa;
140 break;
141
142 case Z:
143 m(0,0) = m(1,1) = ca; m(1,0) = sa; m(0,1) = -sa;
144 break;
145 }
146
147
148 if (_mult_from == MULT_FROM_RIGHT) *this *= m;
149 else leftMult(m);
150 }
151
152
153 //-----------------------------------------------------------------------------
154
155
156 /* Rotation matrix (taken from Mesa3.1)
157 original function contributed by Erich Boleyn (erich@uruk.org) */
158 template <typename Scalar>
159 void
160 GLMatrixT<Scalar>::
161 rotate( Scalar angle, Scalar x, Scalar y, Scalar z,
162 MultiplyFrom _mult_from )
163 {
164 GLMatrixT<Scalar> m;
165 Scalar mag, s, c;
166 Scalar xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
167
168 mag = sqrt( x*x + y*y + z*z );
169 if(mag == 0.) {
170 return;
171 }
172
173 s = sin( angle * ( Scalar(M_PI) / Scalar(180.) ) );
174 c = cos( angle * ( Scalar(M_PI) / Scalar(180.) ) );
175
176 x /= mag;
177 y /= mag;
178 z /= mag;
179
180 xx = x * x;
181 yy = y * y;
182 zz = z * z;
183 xy = x * y;
184 yz = y * z;
185 zx = z * x;
186 xs = x * s;
187 ys = y * s;
188 zs = z * s;
189 one_c = 1.0F - c;
190
191 m(0,0) = (one_c * xx) + c;
192 m(0,1) = (one_c * xy) - zs;
193 m(0,2) = (one_c * zx) + ys;
194 m(0,3) = 0.0F;
195
196 m(1,0) = (one_c * xy) + zs;
197 m(1,1) = (one_c * yy) + c;
198 m(1,2) = (one_c * yz) - xs;
199 m(1,3) = 0.0F;
200
201 m(2,0) = (one_c * zx) - ys;
202 m(2,1) = (one_c * yz) + xs;
203 m(2,2) = (one_c * zz) + c;
204 m(2,3) = 0.0F;
205
206 m(3,0) = 0.0F;
207 m(3,1) = 0.0F;
208 m(3,2) = 0.0F;
209 m(3,3) = 1.0F;
210
211 if (_mult_from == MULT_FROM_RIGHT) *this *= m;
212 else leftMult(m);
213 }
214
215
216 //-----------------------------------------------------------------------------
217
218
219 template<typename Scalar>
220 void
221 GLMatrixT<Scalar>::
222 lookAt(const VectorT<Scalar,3>& eye,
223 const VectorT<Scalar,3>& center,
224 const VectorT<Scalar,3>& up)
225 {
226 VectorT<Scalar,3> z(eye);
227 z -= center;
228 z.normalize();
229
230 VectorT<Scalar,3> x(up % z);
231 x.normalize();
232
233 VectorT<Scalar,3> y(z % x);
234 y.normalize();
235
236 GLMatrixT<Scalar> m;
237 m(0,0)=x[0]; m(0,1)=x[1]; m(0,2)=x[2]; m(0,3)=0.0;
238 m(1,0)=y[0]; m(1,1)=y[1]; m(1,2)=y[2]; m(1,3)=0.0;
239 m(2,0)=z[0]; m(2,1)=z[1]; m(2,2)=z[2]; m(2,3)=0.0;
240 m(3,0)=0.0; m(3,1)=0.0; m(3,2)=0.0; m(3,3)=1.0;
241
242 *this *= m;
243 translate(-eye[0], -eye[1], -eye[2]);
244 }
245
246
247 //-----------------------------------------------------------------------------
248
249
250 template<typename Scalar>
251 void
252 GLMatrixT<Scalar>::
253 inverse_lookAt(const VectorT<Scalar,3>& eye,
254 const VectorT<Scalar,3>& center,
255 const VectorT<Scalar,3>& up)
256 {
257 VectorT<Scalar,3> z(eye);
258 z -= center;
259 z.normalize();
260
261 VectorT<Scalar,3> x(up % z);
262 x.normalize();
263
264 VectorT<Scalar,3> y(z % x);
265 y.normalize();
266
267 GLMatrixT<Scalar> m;
268 m(0,0)=x[0]; m(0,1)=y[0]; m(0,2)=z[0]; m(0,3)=eye[0];
269 m(1,0)=x[1]; m(1,1)=y[1]; m(1,2)=z[1]; m(1,3)=eye[1];
270 m(2,0)=x[2]; m(2,1)=y[2]; m(2,2)=z[2]; m(2,3)=eye[2];
271 m(3,0)=0.0; m(3,1)=0.0; m(3,2)=0.0; m(3,3)=1.0;
272
273 leftMult(m);
274 }
275
276
277 //-----------------------------------------------------------------------------
278
279
280 template<typename Scalar>
281 void
282 GLMatrixT<Scalar>::
283 perspective(Scalar fovY, Scalar aspect,
284 Scalar near_plane, Scalar far_plane)
285 {
286 Scalar ymax = near_plane * tan( fovY * M_PI / 360.0 );
287 Scalar ymin = -ymax;
288 Scalar xmin = ymin * aspect;
289 Scalar xmax = ymax * aspect;
290 frustum(xmin, xmax, ymin, ymax, near_plane, far_plane);
291 }
292
293
294 //-----------------------------------------------------------------------------
295
296
297 template<typename Scalar>
298 void
299 GLMatrixT<Scalar>::
300 inverse_perspective(Scalar fovY, Scalar aspect,
301 Scalar near_plane, Scalar far_plane)
302 {
303 Scalar ymax = near_plane * tan( fovY * M_PI / 360.0 );
304 Scalar ymin = -ymax;
305 Scalar xmin = ymin * aspect;
306 Scalar xmax = ymax * aspect;
307 inverse_frustum(xmin, xmax, ymin, ymax, near_plane, far_plane);
308 }
309
310
311 //-----------------------------------------------------------------------------
312
313
314 template<typename Scalar>
315 void
316 GLMatrixT<Scalar>::
317 frustum( Scalar left,Scalar right,
318 Scalar bottom, Scalar top,
319 Scalar near_plane, Scalar far_plane )
320 {
321 assert(near_plane > 0.0 && far_plane > near_plane);
322
323 GLMatrixT<Scalar> m;
324 Scalar x, y, a, b, c, d;
325
326 x = (2.0*near_plane) / (right-left);
327 y = (2.0*near_plane) / (top-bottom);
328 a = (right+left) / (right-left);
329 b = (top+bottom) / (top-bottom);
330 c = -(far_plane+near_plane) / ( far_plane-near_plane);
331 d = -(2.0*far_plane*near_plane) / (far_plane-near_plane);
332
333 m(0,0) = x; m(0,1) = 0.0F; m(0,2) = a; m(0,3) = 0.0F;
334 m(1,0) = 0.0F; m(1,1) = y; m(1,2) = b; m(1,3) = 0.0F;
335 m(2,0) = 0.0F; m(2,1) = 0.0F; m(2,2) = c; m(2,3) = d;
336 m(3,0) = 0.0F; m(3,1) = 0.0F; m(3,2) = -1.0F; m(3,3) = 0.0F;
337
338 *this *= m;
339 }
340
341
342 //-----------------------------------------------------------------------------
343
344
345 template<typename Scalar>
346 void
347 GLMatrixT<Scalar>::
348 inverse_frustum(Scalar left,Scalar right,
349 Scalar bottom, Scalar top,
350 Scalar near_plane, Scalar far_plane)
351 {
352 assert(near_plane > 0.0 && far_plane > near_plane);
353
354 GLMatrixT<Scalar> m;
355 Scalar x, y, a, b, c, d;
356
357 x = (right-left) / (2.0*near_plane);
358 y = (top-bottom) / (2.0*near_plane);
359 a = (right+left) / (2.0*near_plane);
360 b = (top+bottom) / (2.0*near_plane);
361 c = (far_plane+near_plane) / (2.0*far_plane*near_plane);
362 d = (near_plane-far_plane) / (2.0*far_plane*near_plane);
363
364 m(0,0)=x; m(0,1)= 0.0F; m(0,2)= 0.0F; m(0,3)= a;
365 m(1,0)=0.0F; m(1,1)= y; m(1,2)= 0.0F; m(1,3)= b;
366 m(2,0)=0.0F; m(2,1)= 0.0F; m(2,2)= 0.0F; m(2,3)= -1.0;
367 m(3,0)=0.0F; m(3,1)= 0.0F; m(3,2)= d; m(3,3)= c;
368
369 leftMult(m);
370 }
371
372
373 //-----------------------------------------------------------------------------
374
375
376 template<typename Scalar>
377 void
378 GLMatrixT<Scalar>::
379 ortho(Scalar left, Scalar right,
380 Scalar bottom, Scalar top,
381 Scalar near_plane, Scalar far_plane)
382 {
383 GLMatrixT<Scalar> m;
384
385 Scalar r_l = right-left;
386 Scalar t_b = top - bottom;
387 Scalar f_n = far_plane - near_plane;
388
389 // assert(r_l > 0.0 && t_b > 0.0 && f_n > 0.0);
390
391 m(1,0) = m(0,1) = m(0,2) =
392 m(2,0) = m(2,1) = m(1,2) =
393 m(3,0) = m(3,1) = m(3,2) = 0.0;
394
395 m(0,0) = 2.0 / r_l;
396 m(1,1) = 2.0 / t_b;
397 m(2,2) = -2.0 / f_n;
398
399 m(0,3) = -(right + left) / r_l;
400 m(1,3) = -(top + bottom) / t_b;
401 m(2,3) = -(far_plane + near_plane) / f_n;
402
403 m(3,3) = 1.0;
404
405 *this *= m;
406 }
407
408
409 //-----------------------------------------------------------------------------
410
411 template<typename Scalar>
412 void
413 GLMatrixT<Scalar>::
414 inverse_ortho(Scalar left, Scalar right,
415 Scalar bottom, Scalar top,
416 Scalar near_plane, Scalar far_plane)
417 {
418 GLMatrixT<Scalar> m;
419
420 m(1,0) = m(0,1) = m(0,2) =
421 m(2,0) = m(2,1) = m(1,2) =
422 m(3,0) = m(3,1) = m(3,2) = 0.0;
423
424
425 m(0,0) = 0.5 * (right - left);
426 m(1,1) = 0.5 * (top - bottom);
427 m(2,2) = -0.5 * (far_plane - near_plane);
428
429 m(0,3) = 0.5 * (right + left);
430 m(1,3) = 0.5 * (top + bottom);
431 m(2,3) = -0.5 * (far_plane + near_plane);
432
433 m(3,3) = 1.0;
434
435 leftMult(m);
436 }
437
438
439 //-----------------------------------------------------------------------------
440
441 template<typename Scalar>
442 VectorT<Scalar, 2>
443 GLMatrixT<Scalar>::
444 extract_planes_perspective() const
445 {
446 Scalar a = (*this)(2,2);
447 Scalar b = (*this)(2,3);
448
449 return VectorT<Scalar, 2>(b / (-1.0 + a), b / (1.0 + a));
450 }
451
452 //-----------------------------------------------------------------------------
453
454 template<typename Scalar>
455 VectorT<Scalar, 2>
456 GLMatrixT<Scalar>::
457 extract_planes_ortho() const
458 {
459 Scalar a = (*this)(2,2);
460 Scalar b = (*this)(2,3);
461
462 return VectorT<Scalar, 2>((1.0 + b) / a, (-1.0 + b) / a);
463 }
464
465 //-----------------------------------------------------------------------------
466
467 template<typename Scalar>
468 bool
469 GLMatrixT<Scalar>::
470 isPerspective() const
471 {
472 // check if matrix matches the pattern of frustum()
473
474 // expect at least 5 nonzeros
475 const int nnz = 5;
476
477 // nonzero entries
478 const int nze[] =
479 {
480 0,0,
481 1,1,
482 2,2,
483 2,3,
484 3,2
485 };
486
487 // expect at least 9 zeros
488 const int nz = 9;
489
490 // zero entries
491 const int ze[] =
492 {
493 0,1,
494 0,3,
495 1,0,
496 1,3,
497 2,0,
498 2,1,
499 3,0,
500 3,1,
501 3,3,
502 };
503
504 for (int i = 0; i < nnz; ++i)
505 {
506 if ( checkEpsilon( (*this)(nze[i*2],nze[i*2+1]) ) )
507 return false;
508 }
509
510 // expect -1 at (3,2)
511 if ( !checkEpsilon( (*this)(3,2) + 1.0 ) )
512 return false;
513
514 // check rest for zero
515 for (int i = 0; i < nz; ++i)
516 {
517 if ( !checkEpsilon( (*this)(ze[i*2],ze[i*2+1]) ) )
518 return false;
519 }
520
521 return true;
522 }
523
524 //-----------------------------------------------------------------------------
525
526 template<typename Scalar>
527 bool
528 GLMatrixT<Scalar>::
529 isOrtho() const
530 {
531 // check if matrix matches the pattern of ortho()
532
533 // expect at least 5 nonzeros (diagonal) and m(2,3)
534
535 for (int i = 0; i < 3; ++i)
536 {
537 if ( checkEpsilon( (*this)(i,i) ) )
538 return false;
539 }
540
541 // expect 1 at (3,3)
542 if ( !checkEpsilon( (*this)(3,3) - 1.0 ) )
543 return false;
544
545 // m(2,3) must be nonzero
546 if ( checkEpsilon( (*this)(2,3) ) )
547 return false;
548
549
550 // expect at least 9 zeros
551 const int nz = 9;
552
553 // zero entries
554 const int ze[] =
555 {
556 0,1,
557 0,2,
558 1,0,
559 1,2,
560 2,0,
561 2,1,
562 3,0,
563 3,1,
564 3,2,
565 };
566
567 // check rest for zero (except last column)
568 for (int i = 0; i < nz; ++i)
569 {
570 if ( !checkEpsilon( (*this)(ze[i*2],ze[i*2+1]) ) )
571 return false;
572 }
573
574 return true;
575 }
576
577 //-----------------------------------------------------------------------------
578
579 template<typename Scalar>
580 VectorT<Scalar, 2>
581 GLMatrixT<Scalar>::
582 extract_planes() const
583 {
584 if (isPerspective())
585 return extract_planes_perspective();
586
587 if (isOrtho())
588 return extract_planes_ortho();
589
590 // return invalid planes
591 return VectorT<Scalar,2>(1.0, -1.0);
592 }
593
594 //-----------------------------------------------------------------------------
595
596
597 #undef MAT
598 #undef M
599
600
601 //=============================================================================
602 } // namespace ACG
603 //=============================================================================
ACG::GLMatrixT::isPerspective
bool isPerspective() const
check if the matrix is a perspective projection matrix
Definition: GLMatrixT.cc:470
ACG
Namespace providing different geometric functions concerning angles.
Definition: DBSCANT.cc:51
ACG::MultiplyFrom
MultiplyFrom
Definition: GLMatrixT.hh:79
ACG::GLMatrixT::inverse_lookAt
void inverse_lookAt(const Vec3 &eye, const Vec3 &center, const Vec3 &up)
multiply self from left with inverse lookAt matrix
Definition: GLMatrixT.cc:253
ACG::GLMatrixT::extract_planes_perspective
VectorT< Scalar, 2 > extract_planes_perspective() const
extract near and far clipping planes from a perspective projection matrix
Definition: GLMatrixT.cc:444
ACG::GLMatrixT::inverse_perspective
void inverse_perspective(Scalar fovY, Scalar aspect, Scalar near_plane, Scalar far_plane)
multiply self from left with inverse of perspective projection matrix
Definition: GLMatrixT.cc:300
ACG::GLMatrixT::isOrtho
bool isOrtho() const
check if the matrix is an orthographic projection matrix
Definition: GLMatrixT.cc:529
ACG::GLMatrixT::extract_planes
VectorT< Scalar, 2 > extract_planes() const
detect type of projection matrix and extract near and far clipping planes
Definition: GLMatrixT.cc:582
ACG::GLMatrixT::inverse_ortho
void inverse_ortho(Scalar left, Scalar right, Scalar bottom, Scalar top, Scalar near_plane, Scalar far_plane)
multiply self from left with inverse orthographic projection matrix
Definition: GLMatrixT.cc:414
ACG::GLMatrixT::translate
void translate(Scalar _x, Scalar _y, Scalar _z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
multiply self with translation matrix (x,y,z)
Definition: GLMatrixT.cc:102
ACG::GLMatrixT::extract_planes_ortho
VectorT< Scalar, 2 > extract_planes_ortho() const
extract near and far clipping planes from an orthographic projection matrix
Definition: GLMatrixT.cc:457
ACG::GLMatrixT
4x4 matrix implementing OpenGL commands.
Definition: GLMatrixT.hh:85
ACG::GLMatrixT::scale
void scale(Scalar _x, Scalar _y, Scalar _z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
multiply self with scaling matrix (x,y,z)
Definition: GLMatrixT.cc:81
OpenMesh::VectorT
Definition: Vector11T.hh:83
ACG::GLMatrixT::inverse_frustum
void inverse_frustum(Scalar left, Scalar right, Scalar bottom, Scalar top, Scalar near_plane, Scalar far_plane)
multiply self from left with inverse of perspective projection matrix
Definition: GLMatrixT.cc:348
ACG::GLMatrixT::rotate
void rotate(Scalar angle, Scalar x, Scalar y, Scalar z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
Definition: GLMatrixT.cc:161
ACG::GLMatrixT::frustum
void frustum(Scalar left, Scalar right, Scalar bottom, Scalar top, Scalar near_plane, Scalar far_plane)
multiply self with a perspective projection matrix
Definition: GLMatrixT.cc:317
ACG::GLMatrixT::perspective
void perspective(Scalar fovY, Scalar aspect, Scalar near_plane, Scalar far_plane)
multiply self with a perspective projection matrix
Definition: GLMatrixT.cc:283
ACG::Matrix4x4T::identity
void identity()
setup an identity matrix
Definition: Matrix4x4T.cc:256
ACG::GLMatrixT::lookAt
void lookAt(const Vec3 &eye, const Vec3 &center, const Vec3 &up)
Definition: GLMatrixT.cc:222
ACG::GLMatrixT::ortho
void ortho(Scalar left, Scalar right, Scalar bottom, Scalar top, Scalar near_plane, Scalar far_plane)
multiply self with orthographic projection matrix
Definition: GLMatrixT.cc:379