Developer Documentation
GLMatrixT_impl.hh
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 
45 
46 //=============================================================================
47 //
48 // CLASS GLMatrixT - IMPLEMENTATION
49 //
50 //=============================================================================
51 
52 
53 #define ACG_GLMATRIX_C
54 
55 
56 //== INCLUDES =================================================================
57 
58 
59 #include "GLMatrixT.hh"
60 #include <cmath>
61 
62 
63 //== IMPLEMENTATION ==========================================================
64 
65 
66 namespace ACG {
67 
68 
69 //-----------------------------------------------------------------------------
70 
71 
72 template<typename Scalar>
73 void
74 GLMatrixT<Scalar>::
75 scale( Scalar _x, Scalar _y, Scalar _z,
76  MultiplyFrom _mult_from )
77 {
78  GLMatrixT<Scalar> m;
79  m.identity();
80 
81  m(0,0) = _x;
82  m(1,1) = _y;
83  m(2,2) = _z;
84 
85  if (_mult_from == MULT_FROM_RIGHT) *this *= m;
86  else leftMult(m);
87 }
88 
89 
90 //-----------------------------------------------------------------------------
91 
92 
93 template<typename Scalar>
94 void
95 GLMatrixT<Scalar>::
96 translate( Scalar _x, Scalar _y, Scalar _z,
97  MultiplyFrom _mult_from )
98 {
99  GLMatrixT<Scalar> m;
100  m.identity();
101 
102  m(0,3) = _x;
103  m(1,3) = _y;
104  m(2,3) = _z;
105 
106  if (_mult_from == MULT_FROM_RIGHT) *this *= m;
107  else leftMult(m);
108 }
109 
110 
111 //-----------------------------------------------------------------------------
112 
113 
114 template<typename Scalar>
115 void
116 GLMatrixT<Scalar>::
117 rotateXYZ( Axis _axis, Scalar _angle,
118  MultiplyFrom _mult_from )
119 {
120  GLMatrixT<Scalar> m;
121  m.identity();
122 
123  Scalar ca = cos(_angle * (M_PI/180.0));
124  Scalar sa = sin(_angle * (M_PI/180.0));
125 
126  switch (_axis)
127  {
128  case X:
129  m(1,1) = m(2,2) = ca; m(2,1) = sa; m(1,2) = -sa;
130  break;
131 
132  case Y:
133  m(0,0) = m(2,2) = ca; m(0,2) = sa; m(2,0) = -sa;
134  break;
135 
136  case Z:
137  m(0,0) = m(1,1) = ca; m(1,0) = sa; m(0,1) = -sa;
138  break;
139  }
140 
141 
142  if (_mult_from == MULT_FROM_RIGHT) *this *= m;
143  else leftMult(m);
144 }
145 
146 
147 //-----------------------------------------------------------------------------
148 
149 
150 /* Rotation matrix (taken from Mesa3.1)
151  original function contributed by Erich Boleyn (erich@uruk.org) */
152 template <typename Scalar>
153 void
154 GLMatrixT<Scalar>::
155 rotate( Scalar angle, Scalar x, Scalar y, Scalar z,
156  MultiplyFrom _mult_from )
157 {
158  GLMatrixT<Scalar> m;
159  Scalar mag, s, c;
160  Scalar xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c;
161 
162  mag = sqrt( x*x + y*y + z*z );
163  if(mag == 0.) {
164  return;
165  }
166 
167  s = sin( angle * ( Scalar(M_PI) / Scalar(180.) ) );
168  c = cos( angle * ( Scalar(M_PI) / Scalar(180.) ) );
169 
170  x /= mag;
171  y /= mag;
172  z /= mag;
173 
174  xx = x * x;
175  yy = y * y;
176  zz = z * z;
177  xy = x * y;
178  yz = y * z;
179  zx = z * x;
180  xs = x * s;
181  ys = y * s;
182  zs = z * s;
183  one_c = static_cast<Scalar>(1.0) - c;
184 
185  m(0,0) = (one_c * xx) + c;
186  m(0,1) = (one_c * xy) - zs;
187  m(0,2) = (one_c * zx) + ys;
188  m(0,3) = static_cast<Scalar>(0.0);
189 
190  m(1,0) = (one_c * xy) + zs;
191  m(1,1) = (one_c * yy) + c;
192  m(1,2) = (one_c * yz) - xs;
193  m(1,3) = static_cast<Scalar>(0.0);
194 
195  m(2,0) = (one_c * zx) - ys;
196  m(2,1) = (one_c * yz) + xs;
197  m(2,2) = (one_c * zz) + c;
198  m(2,3) = static_cast<Scalar>(0.0);
199 
200  m(3,0) = static_cast<Scalar>(0.0);
201  m(3,1) = static_cast<Scalar>(0.0);
202  m(3,2) = static_cast<Scalar>(0.0);
203  m(3,3) = static_cast<Scalar>(1.0);
204 
205  if (_mult_from == MULT_FROM_RIGHT) *this *= m;
206  else leftMult(m);
207 }
208 
209 
210 //-----------------------------------------------------------------------------
211 
212 
213 template<typename Scalar>
214 void
215 GLMatrixT<Scalar>::
216 lookAt(const VectorT<Scalar,3>& eye,
217  const VectorT<Scalar,3>& center,
218  const VectorT<Scalar,3>& up)
219 {
220  VectorT<Scalar,3> z(eye);
221  z -= center;
222  z.normalize();
223 
224  VectorT<Scalar,3> x(up % z);
225  x.normalize();
226 
227  VectorT<Scalar,3> y(z % x);
228  y.normalize();
229 
230  GLMatrixT<Scalar> m;
231  m(0,0)=x[0]; m(0,1)=x[1]; m(0,2)=x[2]; m(0,3)=0.0;
232  m(1,0)=y[0]; m(1,1)=y[1]; m(1,2)=y[2]; m(1,3)=0.0;
233  m(2,0)=z[0]; m(2,1)=z[1]; m(2,2)=z[2]; m(2,3)=0.0;
234  m(3,0)=static_cast<Scalar>(0.0); m(3,1)=static_cast<Scalar>(0.0); m(3,2)=static_cast<Scalar>(0.0); m(3,3)=static_cast<Scalar>(1.0);
235 
236  *this *= m;
237  translate(-eye[0], -eye[1], -eye[2]);
238 }
239 
240 
241 //-----------------------------------------------------------------------------
242 
243 
244 template<typename Scalar>
245 void
246 GLMatrixT<Scalar>::
247 inverse_lookAt(const VectorT<Scalar,3>& eye,
248  const VectorT<Scalar,3>& center,
249  const VectorT<Scalar,3>& up)
250 {
251  VectorT<Scalar,3> z(eye);
252  z -= center;
253  z.normalize();
254 
255  VectorT<Scalar,3> x(up % z);
256  x.normalize();
257 
258  VectorT<Scalar,3> y(z % x);
259  y.normalize();
260 
261  GLMatrixT<Scalar> m;
262  m(0,0)=x[0]; m(0,1)=y[0]; m(0,2)=z[0]; m(0,3)=eye[0];
263  m(1,0)=x[1]; m(1,1)=y[1]; m(1,2)=z[1]; m(1,3)=eye[1];
264  m(2,0)=x[2]; m(2,1)=y[2]; m(2,2)=z[2]; m(2,3)=eye[2];
265  m(3,0)=static_cast<Scalar>(0.0); m(3,1)=static_cast<Scalar>(0.0); m(3,2)=static_cast<Scalar>(0.0); m(3,3)=static_cast<Scalar>(1.0);
266 
267  leftMult(m);
268 }
269 
270 
271 //-----------------------------------------------------------------------------
272 
273 
274 template<typename Scalar>
275 void
276 GLMatrixT<Scalar>::
277 perspective(Scalar fovY, Scalar aspect,
278  Scalar near_plane, Scalar far_plane)
279 {
280  Scalar ymax = near_plane * tan( fovY * static_cast<Scalar>(M_PI) / static_cast<Scalar>(360.0) );
281  Scalar ymin = -ymax;
282  Scalar xmin = ymin * aspect;
283  Scalar xmax = ymax * aspect;
284  frustum(xmin, xmax, ymin, ymax, near_plane, far_plane);
285 }
286 
287 
288 //-----------------------------------------------------------------------------
289 
290 
291 template<typename Scalar>
292 void
293 GLMatrixT<Scalar>::
294 inverse_perspective(Scalar fovY, Scalar aspect,
295  Scalar near_plane, Scalar far_plane)
296 {
297  Scalar ymax = near_plane * tan( fovY * static_cast<Scalar>(M_PI) / static_cast<Scalar>(360.0) );
298  Scalar ymin = -ymax;
299  Scalar xmin = ymin * aspect;
300  Scalar xmax = ymax * aspect;
301  inverse_frustum(xmin, xmax, ymin, ymax, near_plane, far_plane);
302 }
303 
304 
305 //-----------------------------------------------------------------------------
306 
307 
308 template<typename Scalar>
309 void
310 GLMatrixT<Scalar>::
311 frustum( Scalar left,Scalar right,
312  Scalar bottom, Scalar top,
313  Scalar near_plane, Scalar far_plane )
314 {
315  assert(near_plane > static_cast<Scalar>(0.0) && far_plane > near_plane);
316 
317  GLMatrixT<Scalar> m;
318  Scalar x, y, a, b, c, d;
319 
320  x = (static_cast<Scalar>(2.0)*near_plane) / (right-left);
321  y = (static_cast<Scalar>(2.0)*near_plane) / (top-bottom);
322  a = (right+left) / (right-left);
323  b = (top+bottom) / (top-bottom);
324  c = -(far_plane+near_plane) / ( far_plane-near_plane);
325  d = -(static_cast<Scalar>(2.0)*far_plane*near_plane) / (far_plane-near_plane);
326 
327  m(0,0) = x; m(0,1) = static_cast<Scalar>(0.0); m(0,2) = a; m(0,3) = static_cast<Scalar>(0.0);
328  m(1,0) = static_cast<Scalar>(0.0); m(1,1) = y; m(1,2) = b; m(1,3) = static_cast<Scalar>(0.0);
329  m(2,0) = static_cast<Scalar>(0.0); m(2,1) = static_cast<Scalar>(0.0); m(2,2) = c; m(2,3) = d;
330  m(3,0) = static_cast<Scalar>(0.0); m(3,1) = static_cast<Scalar>(0.0); m(3,2) = static_cast<Scalar>(-1.0); m(3,3) = static_cast<Scalar>(0.0);
331 
332  *this *= m;
333 }
334 
335 
336 //-----------------------------------------------------------------------------
337 
338 
339 template<typename Scalar>
340 void
341 GLMatrixT<Scalar>::
342 inverse_frustum(Scalar left,Scalar right,
343  Scalar bottom, Scalar top,
344  Scalar near_plane, Scalar far_plane)
345 {
346  assert(near_plane > 0.0 && far_plane > near_plane);
347 
348  GLMatrixT<Scalar> m;
349  Scalar x, y, a, b, c, d;
350 
351  x = (right-left) / (static_cast<Scalar>(2.0)*near_plane);
352  y = (top-bottom) / (static_cast<Scalar>(2.0)*near_plane);
353  a = (right+left) / (static_cast<Scalar>(2.0)*near_plane);
354  b = (top+bottom) / (static_cast<Scalar>(2.0)*near_plane);
355  c = (far_plane+near_plane) / (static_cast<Scalar>(2.0)*far_plane*near_plane);
356  d = (near_plane-far_plane) / (static_cast<Scalar>(2.0)*far_plane*near_plane);
357 
358  m(0,0)=x; m(0,1)= static_cast<Scalar>(0.0); m(0,2)= static_cast<Scalar>(0.0); m(0,3)= a;
359  m(1,0)=static_cast<Scalar>(0.0); m(1,1)= y; m(1,2)= static_cast<Scalar>(0.0); m(1,3)= b;
360  m(2,0)=static_cast<Scalar>(0.0); m(2,1)= static_cast<Scalar>(0.0); m(2,2)= static_cast<Scalar>(0.0); m(2,3)= static_cast<Scalar>(-1.0);
361  m(3,0)=static_cast<Scalar>(0.0); m(3,1)= static_cast<Scalar>(0.0); m(3,2)= d; m(3,3)= c;
362 
363  leftMult(m);
364 }
365 
366 
367 //-----------------------------------------------------------------------------
368 
369 
370 template<typename Scalar>
371 void
372 GLMatrixT<Scalar>::
373 ortho(Scalar left, Scalar right,
374  Scalar bottom, Scalar top,
375  Scalar near_plane, Scalar far_plane)
376 {
377  GLMatrixT<Scalar> m;
378 
379  Scalar r_l = right-left;
380  Scalar t_b = top - bottom;
381  Scalar f_n = far_plane - near_plane;
382 
383 // assert(r_l > 0.0 && t_b > 0.0 && f_n > 0.0);
384 
385  m(1,0) = m(0,1) = m(0,2) =
386  m(2,0) = m(2,1) = m(1,2) =
387  m(3,0) = m(3,1) = m(3,2) = static_cast<Scalar>(0.0);
388 
389  m(0,0) = static_cast<Scalar>( 2.0) / r_l;
390  m(1,1) = static_cast<Scalar>( 2.0) / t_b;
391  m(2,2) = static_cast<Scalar>(-2.0) / f_n;
392 
393  m(0,3) = -(right + left) / r_l;
394  m(1,3) = -(top + bottom) / t_b;
395  m(2,3) = -(far_plane + near_plane) / f_n;
396 
397  m(3,3) = static_cast<Scalar>(1.0);
398 
399  *this *= m;
400 }
401 
402 
403 //-----------------------------------------------------------------------------
404 
405 template<typename Scalar>
406 void
407 GLMatrixT<Scalar>::
408 inverse_ortho(Scalar left, Scalar right,
409  Scalar bottom, Scalar top,
410  Scalar near_plane, Scalar far_plane)
411 {
412  GLMatrixT<Scalar> m;
413 
414  m(1,0) = m(0,1) = m(0,2) =
415  m(2,0) = m(2,1) = m(1,2) =
416  m(3,0) = m(3,1) = m(3,2) = static_cast<Scalar>(0.0);
417 
418 
419  m(0,0) = static_cast<Scalar>( 0.5) * (right - left);
420  m(1,1) = static_cast<Scalar>( 0.5) * (top - bottom);
421  m(2,2) = static_cast<Scalar>(-0.5) * (far_plane - near_plane);
422 
423  m(0,3) = static_cast<Scalar>( 0.5) * (right + left);
424  m(1,3) = static_cast<Scalar>( 0.5) * (top + bottom);
425  m(2,3) = static_cast<Scalar>(-0.5) * (far_plane + near_plane);
426 
427  m(3,3) = static_cast<Scalar>(1.0);
428 
429  leftMult(m);
430 }
431 
432 
433 //-----------------------------------------------------------------------------
434 
435 template<typename Scalar>
436 VectorT<Scalar, 2>
437  GLMatrixT<Scalar>::
438  extract_planes_perspective() const
439 {
440  Scalar a = (*this)(2,2);
441  Scalar b = (*this)(2,3);
442 
443  return VectorT<Scalar, 2>(b / (static_cast<Scalar>(-1.0) + a), b / (static_cast<Scalar>(1.0) + a));
444 }
445 
446 //-----------------------------------------------------------------------------
447 
448 template<typename Scalar>
449 VectorT<Scalar, 2>
450  GLMatrixT<Scalar>::
451  extract_planes_ortho() const
452 {
453  Scalar a = (*this)(2,2);
454  Scalar b = (*this)(2,3);
455 
456  return VectorT<Scalar, 2>((1.0 + b) / a, (-1.0 + b) / a);
457 }
458 
459 //-----------------------------------------------------------------------------
460 
461 template<typename Scalar>
462 bool
463  GLMatrixT<Scalar>::
464  isPerspective() const
465 {
466  // check if matrix matches the pattern of frustum()
467 
468  // expect at least 5 nonzeros
469  const int nnz = 5;
470 
471  // nonzero entries
472  const int nze[] =
473  {
474  0,0,
475  1,1,
476  2,2,
477  2,3,
478  3,2
479  };
480 
481  // expect at least 9 zeros
482  const int nz = 9;
483 
484  // zero entries
485  const int ze[] =
486  {
487  0,1,
488  0,3,
489  1,0,
490  1,3,
491  2,0,
492  2,1,
493  3,0,
494  3,1,
495  3,3,
496  };
497 
498  for (int i = 0; i < nnz; ++i)
499  {
500  if ( checkEpsilon( (*this)(nze[i*2],nze[i*2+1]) ) )
501  return false;
502  }
503 
504  // expect -1 at (3,2)
505  if ( !checkEpsilon( (*this)(3,2) + 1.0 ) )
506  return false;
507 
508  // check rest for zero
509  for (int i = 0; i < nz; ++i)
510  {
511  if ( !checkEpsilon( (*this)(ze[i*2],ze[i*2+1]) ) )
512  return false;
513  }
514 
515  return true;
516 }
517 
518 //-----------------------------------------------------------------------------
519 
520 template<typename Scalar>
521 bool
522  GLMatrixT<Scalar>::
523  isOrtho() const
524 {
525  // check if matrix matches the pattern of ortho()
526 
527  // expect at least 5 nonzeros (diagonal) and m(2,3)
528 
529  for (int i = 0; i < 3; ++i)
530  {
531  if ( checkEpsilon( (*this)(i,i) ) )
532  return false;
533  }
534 
535  // expect 1 at (3,3)
536  if ( !checkEpsilon( (*this)(3,3) - 1.0 ) )
537  return false;
538 
539  // m(2,3) must be nonzero
540  if ( checkEpsilon( (*this)(2,3) ) )
541  return false;
542 
543 
544  // expect at least 9 zeros
545  const int nz = 9;
546 
547  // zero entries
548  const int ze[] =
549  {
550  0,1,
551  0,2,
552  1,0,
553  1,2,
554  2,0,
555  2,1,
556  3,0,
557  3,1,
558  3,2,
559  };
560 
561  // check rest for zero (except last column)
562  for (int i = 0; i < nz; ++i)
563  {
564  if ( !checkEpsilon( (*this)(ze[i*2],ze[i*2+1]) ) )
565  return false;
566  }
567 
568  return true;
569 }
570 
571 //-----------------------------------------------------------------------------
572 
573 template<typename Scalar>
574 VectorT<Scalar, 2>
575  GLMatrixT<Scalar>::
576  extract_planes() const
577 {
578  if (isPerspective())
579  return extract_planes_perspective();
580 
581  if (isOrtho())
582  return extract_planes_ortho();
583 
584  // return invalid planes
585  return VectorT<Scalar,2>(1.0, -1.0);
586 }
587 
588 //-----------------------------------------------------------------------------
589 
590 
591 #undef MAT
592 #undef M
593 
594 
595 //=============================================================================
596 } // namespace ACG
597 //=============================================================================
ACG::GLMatrixT::rotate
void rotate(Scalar angle, Scalar x, Scalar y, Scalar z, MultiplyFrom _mult_from=MULT_FROM_RIGHT)
Definition: GLMatrixT_impl.hh:155
ACG::GLMatrixT::perspective
void perspective(Scalar fovY, Scalar aspect, Scalar near_plane, Scalar far_plane)
multiply self with a perspective projection matrix
Definition: GLMatrixT_impl.hh:277
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_impl.hh:342
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_impl.hh:408
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_impl.hh:373
ACG
Namespace providing different geometric functions concerning angles.
Definition: BaseObjectData.hh:68
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_impl.hh:96
ACG::Matrix4x4T::identity
void identity()
setup an identity matrix
Definition: Matrix4x4T_impl.hh:250
ACG::GLMatrixT::lookAt
void lookAt(const Vec3 &eye, const Vec3 &center, const Vec3 &up)
Definition: GLMatrixT_impl.hh:216
ACG::GLMatrixT::isOrtho
bool isOrtho() const
check if the matrix is an orthographic projection matrix
Definition: GLMatrixT_impl.hh:523
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_impl.hh:451
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_impl.hh:438
ACG::GLMatrixT
4x4 matrix implementing OpenGL commands.
Definition: GLMatrixT.hh:79
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_impl.hh:75
ACG::GLMatrixT::isPerspective
bool isPerspective() const
check if the matrix is a perspective projection matrix
Definition: GLMatrixT_impl.hh:464
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_impl.hh:294
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_impl.hh:311
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_impl.hh:247
OpenMesh::VectorT::normalize
auto normalize() -> decltype(*this/=std::declval< VectorT< S, DIM >>().norm())
Definition: Vector11T.hh:453
ACG::MultiplyFrom
MultiplyFrom
Definition: GLMatrixT.hh:73
ACG::GLMatrixT::extract_planes
VectorT< Scalar, 2 > extract_planes() const
detect type of projection matrix and extract near and far clipping planes
Definition: GLMatrixT_impl.hh:576