root/OpenSceneGraph/trunk/include/osg/Matrixd @ 7890

Revision 7890, 26.0 kB (checked in by robert, 7 years ago)

From Paul Martz, "Per the discussion in osg-users, this change adds code comments to the Matrix* headers to document assumptions in the getRotate() method."

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2004 Robert Osfield
2 *
3 * This library is open source and may be redistributed and/or modified under 
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12*/
13
14#ifndef OSG_MATRIXD
15#define OSG_MATRIXD 1
16
17#include <osg/Object>
18#include <osg/Vec3d>
19#include <osg/Vec4d>
20#include <osg/Quat>
21
22namespace osg {
23
24class Matrixf;
25
26class OSG_EXPORT Matrixd
27{
28    public:
29   
30        typedef double value_type;
31
32        inline Matrixd() { makeIdentity(); }
33        inline Matrixd( const Matrixd& mat) { set(mat.ptr()); }
34        Matrixd( const Matrixf& mat );
35        inline explicit Matrixd( float const * const ptr ) { set(ptr); }
36        inline explicit Matrixd( double const * const ptr ) { set(ptr); }
37        inline explicit Matrixd( const Quat& quat ) { makeRotate(quat); }
38
39        Matrixd(value_type a00, value_type a01, value_type a02, value_type a03,
40                value_type a10, value_type a11, value_type a12, value_type a13,
41                value_type a20, value_type a21, value_type a22, value_type a23,
42                value_type a30, value_type a31, value_type a32, value_type a33);
43
44        ~Matrixd() {}
45
46        int compare(const Matrixd& m) const;
47
48        bool operator < (const Matrixd& m) const { return compare(m)<0; }
49        bool operator == (const Matrixd& m) const { return compare(m)==0; }
50        bool operator != (const Matrixd& m) const { return compare(m)!=0; }
51
52        inline value_type& operator()(int row, int col) { return _mat[row][col]; }
53        inline value_type operator()(int row, int col) const { return _mat[row][col]; }
54
55        inline bool valid() const { return !isNaN(); }
56        inline bool isNaN() const { return osg::isNaN(_mat[0][0]) || osg::isNaN(_mat[0][1]) || osg::isNaN(_mat[0][2]) || osg::isNaN(_mat[0][3]) ||
57                                                 osg::isNaN(_mat[1][0]) || osg::isNaN(_mat[1][1]) || osg::isNaN(_mat[1][2]) || osg::isNaN(_mat[1][3]) ||
58                                                 osg::isNaN(_mat[2][0]) || osg::isNaN(_mat[2][1]) || osg::isNaN(_mat[2][2]) || osg::isNaN(_mat[2][3]) ||
59                                                 osg::isNaN(_mat[3][0]) || osg::isNaN(_mat[3][1]) || osg::isNaN(_mat[3][2]) || osg::isNaN(_mat[3][3]); }
60
61        inline Matrixd& operator = (const Matrixd& rhs)
62        {
63            if( &rhs == this ) return *this;
64            set(rhs.ptr());
65            return *this;
66        }
67       
68        Matrixd& operator = (const Matrixf& other);
69
70        inline void set(const Matrixd& rhs) { set(rhs.ptr()); }
71
72        void set(const Matrixf& rhs);
73
74        inline void set(float const * const ptr)
75        {
76            value_type* local_ptr = (value_type*)_mat;
77            for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i];
78        }
79       
80        inline void set(double const * const ptr)
81        {
82            value_type* local_ptr = (value_type*)_mat;
83            for(int i=0;i<16;++i) local_ptr[i]=(value_type)ptr[i];
84        }
85
86        void set(value_type a00, value_type a01, value_type a02,value_type a03,
87                 value_type a10, value_type a11, value_type a12,value_type a13,
88                 value_type a20, value_type a21, value_type a22,value_type a23,
89                 value_type a30, value_type a31, value_type a32,value_type a33);
90                 
91        value_type * ptr() { return (value_type*)_mat; }
92        const value_type * ptr() const { return (const value_type *)_mat; }
93
94        bool isIdentity() const
95        {
96            return _mat[0][0]==1.0 && _mat[0][1]==0.0 && _mat[0][2]==0.0 &&  _mat[0][3]==0.0 &&
97                   _mat[1][0]==0.0 && _mat[1][1]==1.0 && _mat[1][2]==0.0 &&  _mat[1][3]==0.0 &&
98                   _mat[2][0]==0.0 && _mat[2][1]==0.0 && _mat[2][2]==1.0 &&  _mat[2][3]==0.0 &&
99                   _mat[3][0]==0.0 && _mat[3][1]==0.0 && _mat[3][2]==0.0 &&  _mat[3][3]==1.0;
100        }
101
102        void makeIdentity();
103       
104        void makeScale( const Vec3f& );
105        void makeScale( const Vec3d& );
106        void makeScale( value_type, value_type, value_type );
107       
108        void makeTranslate( const Vec3f& );
109        void makeTranslate( const Vec3d& );
110        void makeTranslate( value_type, value_type, value_type );
111       
112        void makeRotate( const Vec3f& from, const Vec3f& to );
113        void makeRotate( const Vec3d& from, const Vec3d& to );
114        void makeRotate( value_type angle, const Vec3f& axis );
115        void makeRotate( value_type angle, const Vec3d& axis );
116        void makeRotate( value_type angle, value_type x, value_type y, value_type z );
117        void makeRotate( const Quat& );
118        void makeRotate( value_type angle1, const Vec3f& axis1,
119                         value_type angle2, const Vec3f& axis2,
120                         value_type angle3, const Vec3f& axis3);
121        void makeRotate( value_type angle1, const Vec3d& axis1,
122                         value_type angle2, const Vec3d& axis2,
123                         value_type angle3, const Vec3d& axis3);
124
125
126        /** decompose the matrix into translation, rotation, scale and scale orientation.*/       
127        void decompose( osg::Vec3f& translation,
128                        osg::Quat& rotation,
129                        osg::Vec3f& scale,
130                        osg::Quat& so ) const;
131
132        /** decompose the matrix into translation, rotation, scale and scale orientation.*/       
133        void decompose( osg::Vec3d& translation,
134                        osg::Quat& rotation,
135                        osg::Vec3d& scale,
136                        osg::Quat& so ) const;
137
138
139        /** Set to an orthographic projection.
140         * See glOrtho for further details.
141        */
142        void makeOrtho(double left,   double right,
143                       double bottom, double top,
144                       double zNear,  double zFar);
145
146        /** Get the orthographic settings of the orthographic projection matrix.
147          * Note, if matrix is not an orthographic matrix then invalid values
148          * will be returned.
149        */
150        bool getOrtho(double& left,   double& right,
151                      double& bottom, double& top,
152                      double& zNear,  double& zFar) const;
153
154        /** Set to a 2D orthographic projection.
155          * See glOrtho2D for further details.
156        */
157        inline void makeOrtho2D(double left,   double right,
158                                double bottom, double top)
159        {
160            makeOrtho(left,right,bottom,top,-1.0,1.0);
161        }
162
163
164        /** Set to a perspective projection.
165          * See glFrustum for further details.
166        */
167        void makeFrustum(double left,   double right,
168                         double bottom, double top,
169                         double zNear,  double zFar);
170
171        /** Get the frustum settings of a perspective projection matrix.
172          * Note, if matrix is not a perspective matrix then invalid values
173          * will be returned.
174        */
175        bool getFrustum(double& left,   double& right,
176                        double& bottom, double& top,
177                        double& zNear,  double& zFar) const;
178
179        /** Set to a symmetrical perspective projection.
180          * See gluPerspective for further details.
181          * Aspect ratio is defined as width/height.
182        */
183        void makePerspective(double fovy,  double aspectRatio,
184                             double zNear, double zFar);
185
186        /** Get the frustum settings of a symmetric perspective projection
187          * matrix.
188          * Return false if matrix is not a perspective matrix,
189          * where parameter values are undefined.
190          * Note, if matrix is not a symmetric perspective matrix then the
191          * shear will be lost.
192          * Asymmetric matrices occur when stereo, power walls, caves and
193          * reality center display are used.
194          * In these configuration one should use the AsFrustum method instead.
195        */
196        bool getPerspective(double& fovy,  double& aspectRatio,
197                            double& zNear, double& zFar) const;
198
199        /** Set the position and orientation to be a view matrix,
200          * using the same convention as gluLookAt.
201        */
202        void makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up);
203
204        /** Get to the position and orientation of a modelview matrix,
205          * using the same convention as gluLookAt.
206        */
207        void getLookAt(Vec3f& eye,Vec3f& center,Vec3f& up,
208                       value_type lookDistance=1.0f) const;
209
210        /** Get to the position and orientation of a modelview matrix,
211          * using the same convention as gluLookAt.
212        */
213        void getLookAt(Vec3d& eye,Vec3d& center,Vec3d& up,
214                       value_type lookDistance=1.0f) const;
215
216        /** invert the matrix rhs, automatically select invert_4x3 or invert_4x4. */
217        inline bool invert( const Matrixd& rhs)
218        {
219            bool is_4x3 = (rhs._mat[0][3]==0.0 && rhs._mat[1][3]==0.0 &&  rhs._mat[2][3]==0.0 && rhs._mat[3][3]==1.0);
220            return is_4x3 ? invert_4x3(rhs) :  invert_4x4(rhs);
221        }
222
223        /** 4x3 matrix invert, not right hand column is assumed to be 0,0,0,1. */
224        bool invert_4x3( const Matrixd& rhs);
225
226        /** full 4x4 matrix invert. */
227        bool invert_4x4( const Matrixd& rhs);
228
229        /** ortho-normalize the 3x3 rotation & scale matrix */
230        void orthoNormalize(const Matrixd& rhs);
231
232        // basic utility functions to create new matrices
233        inline static Matrixd identity( void );
234        inline static Matrixd scale( const Vec3f& sv);
235        inline static Matrixd scale( const Vec3d& sv);
236        inline static Matrixd scale( value_type sx, value_type sy, value_type sz);
237        inline static Matrixd translate( const Vec3f& dv);
238        inline static Matrixd translate( const Vec3d& dv);
239        inline static Matrixd translate( value_type x, value_type y, value_type z);
240        inline static Matrixd rotate( const Vec3f& from, const Vec3f& to);
241        inline static Matrixd rotate( const Vec3d& from, const Vec3d& to);
242        inline static Matrixd rotate( value_type angle, value_type x, value_type y, value_type z);
243        inline static Matrixd rotate( value_type angle, const Vec3f& axis);
244        inline static Matrixd rotate( value_type angle, const Vec3d& axis);
245        inline static Matrixd rotate( value_type angle1, const Vec3f& axis1,
246                                      value_type angle2, const Vec3f& axis2,
247                                      value_type angle3, const Vec3f& axis3);
248        inline static Matrixd rotate( value_type angle1, const Vec3d& axis1,
249                                      value_type angle2, const Vec3d& axis2,
250                                      value_type angle3, const Vec3d& axis3);
251        inline static Matrixd rotate( const Quat& quat);
252        inline static Matrixd inverse( const Matrixd& matrix);
253        inline static Matrixd orthoNormal(const Matrixd& matrix);
254        /** Create an orthographic projection matrix.
255          * See glOrtho for further details.
256        */
257        inline static Matrixd ortho(double left,   double right,
258                                    double bottom, double top,
259                                    double zNear,  double zFar);
260
261        /** Create a 2D orthographic projection.
262          * See glOrtho for further details.
263        */
264        inline static Matrixd ortho2D(double left,   double right,
265                                      double bottom, double top);
266
267        /** Create a perspective projection.
268          * See glFrustum for further details.
269        */
270        inline static Matrixd frustum(double left,   double right,
271                                      double bottom, double top,
272                                      double zNear,  double zFar);
273
274        /** Create a symmetrical perspective projection.
275          * See gluPerspective for further details.
276          * Aspect ratio is defined as width/height.
277        */
278        inline static Matrixd perspective(double fovy,  double aspectRatio,
279                                          double zNear, double zFar);
280
281        /** Create the position and orientation as per a camera,
282          * using the same convention as gluLookAt.
283        */
284        inline static Matrixd lookAt(const Vec3f& eye,
285                                     const Vec3f& center,
286                                     const Vec3f& up);
287
288        /** Create the position and orientation as per a camera,
289          * using the same convention as gluLookAt.
290        */
291        inline static Matrixd lookAt(const Vec3d& eye,
292                                     const Vec3d& center,
293                                     const Vec3d& up);
294
295        inline Vec3f preMult( const Vec3f& v ) const;
296        inline Vec3d preMult( const Vec3d& v ) const;
297        inline Vec3f postMult( const Vec3f& v ) const;
298        inline Vec3d postMult( const Vec3d& v ) const;
299        inline Vec3f operator* ( const Vec3f& v ) const;
300        inline Vec3d operator* ( const Vec3d& v ) const;
301        inline Vec4f preMult( const Vec4f& v ) const;
302        inline Vec4d preMult( const Vec4d& v ) const;
303        inline Vec4f postMult( const Vec4f& v ) const;
304        inline Vec4d postMult( const Vec4d& v ) const;
305        inline Vec4f operator* ( const Vec4f& v ) const;
306        inline Vec4d operator* ( const Vec4d& v ) const;
307
308#ifdef USE_DEPRECATED_API
309        inline void set(const Quat& q) { makeRotate(q); }
310        inline void get(Quat& q) const { q = getRotate(); }
311#endif
312
313        void setRotate(const Quat& q);
314        /** Get the matrix rotation as a Quat. Note that this function
315          * assumes a non-scaled matrix and will return incorrect results
316          * for scaled matrixces. Consider decompose() instead.
317          */
318        Quat getRotate() const;
319
320        void setTrans( value_type tx, value_type ty, value_type tz );
321        void setTrans( const Vec3f& v );
322        void setTrans( const Vec3d& v );
323       
324        inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); }
325       
326        inline Vec3d getScale() const {
327          Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]);
328          Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]);
329          Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]);
330          return Vec3d(x_vec.length(), y_vec.length(), z_vec.length());
331        }
332       
333        /** apply a 3x3 transform of v*M[0..2,0..2]. */
334        inline static Vec3f transform3x3(const Vec3f& v,const Matrixd& m);
335
336        /** apply a 3x3 transform of v*M[0..2,0..2]. */
337        inline static Vec3d transform3x3(const Vec3d& v,const Matrixd& m);
338
339        /** apply a 3x3 transform of M[0..2,0..2]*v. */
340        inline static Vec3f transform3x3(const Matrixd& m,const Vec3f& v);
341
342        /** apply a 3x3 transform of M[0..2,0..2]*v. */
343        inline static Vec3d transform3x3(const Matrixd& m,const Vec3d& v);
344
345        // basic Matrixd multiplication, our workhorse methods.
346        void mult( const Matrixd&, const Matrixd& );
347        void preMult( const Matrixd& );
348        void postMult( const Matrixd& );
349
350        inline void operator *= ( const Matrixd& other )
351        {    if( this == &other ) {
352                Matrixd temp(other);
353                postMult( temp );
354            }
355            else postMult( other );
356        }
357
358        inline Matrixd operator * ( const Matrixd &m ) const
359        {
360            osg::Matrixd r;
361            r.mult(*this,m);
362            return  r;
363        }
364
365    protected:
366        value_type _mat[4][4];
367
368};
369
370class RefMatrixd : public Object, public Matrixd
371{
372    public:
373   
374        RefMatrixd():Object(false), Matrixd() {}
375        RefMatrixd( const Matrixd& other) : Object(false), Matrixd(other) {}
376        RefMatrixd( const Matrixf& other) : Object(false), Matrixd(other) {}
377        RefMatrixd( const RefMatrixd& other) : Object(other), Matrixd(other) {}
378        explicit RefMatrixd( Matrixd::value_type const * const def ):Object(false), Matrixd(def) {}
379        RefMatrixd( Matrixd::value_type a00, Matrixd::value_type a01, Matrixd::value_type a02, Matrixd::value_type a03,
380            Matrixd::value_type a10, Matrixd::value_type a11, Matrixd::value_type a12, Matrixd::value_type a13,
381            Matrixd::value_type a20, Matrixd::value_type a21, Matrixd::value_type a22, Matrixd::value_type a23,
382            Matrixd::value_type a30, Matrixd::value_type a31, Matrixd::value_type a32, Matrixd::value_type a33):
383            Object(false),
384            Matrixd(a00, a01, a02, a03,
385                    a10, a11, a12, a13,
386                    a20, a21, a22, a23,
387                    a30, a31, a32, a33) {}
388
389        virtual Object* cloneType() const { return new RefMatrixd(); }
390        virtual Object* clone(const CopyOp&) const { return new RefMatrixd(*this); }
391        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixd*>(obj)!=NULL; }
392        virtual const char* libraryName() const { return "osg"; }
393        virtual const char* className() const { return "Matrix"; }
394       
395       
396    protected:
397   
398        virtual ~RefMatrixd() {}
399};
400
401
402// static utility methods
403inline Matrixd Matrixd::identity(void)
404{
405    Matrixd m;
406    m.makeIdentity();
407    return m;
408}
409
410inline Matrixd Matrixd::scale(value_type sx, value_type sy, value_type sz)
411{
412    Matrixd m;
413    m.makeScale(sx,sy,sz);
414    return m;
415}
416
417inline Matrixd Matrixd::scale(const Vec3f& v )
418{
419    return scale(v.x(), v.y(), v.z() );
420}
421
422inline Matrixd Matrixd::scale(const Vec3d& v )
423{
424    return scale(v.x(), v.y(), v.z() );
425}
426
427inline Matrixd Matrixd::translate(value_type tx, value_type ty, value_type tz)
428{
429    Matrixd m;
430    m.makeTranslate(tx,ty,tz);
431    return m;
432}
433
434inline Matrixd Matrixd::translate(const Vec3f& v )
435{
436    return translate(v.x(), v.y(), v.z() );
437}
438
439inline Matrixd Matrixd::translate(const Vec3d& v )
440{
441    return translate(v.x(), v.y(), v.z() );
442}
443
444inline Matrixd Matrixd::rotate( const Quat& q )
445{
446    return Matrixd(q);
447}
448inline Matrixd Matrixd::rotate(value_type angle, value_type x, value_type y, value_type z )
449{
450    Matrixd m;
451    m.makeRotate(angle,x,y,z);
452    return m;
453}
454inline Matrixd Matrixd::rotate(value_type angle, const Vec3f& axis )
455{
456    Matrixd m;
457    m.makeRotate(angle,axis);
458    return m;
459}
460inline Matrixd Matrixd::rotate(value_type angle, const Vec3d& axis )
461{
462    Matrixd m;
463    m.makeRotate(angle,axis);
464    return m;
465}
466inline Matrixd Matrixd::rotate( value_type angle1, const Vec3f& axis1,
467                                value_type angle2, const Vec3f& axis2,
468                                value_type angle3, const Vec3f& axis3)
469{
470    Matrixd m;
471    m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
472    return m;
473}
474inline Matrixd Matrixd::rotate( value_type angle1, const Vec3d& axis1,
475                                value_type angle2, const Vec3d& axis2,
476                                value_type angle3, const Vec3d& axis3)
477{
478    Matrixd m;
479    m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
480    return m;
481}
482inline Matrixd Matrixd::rotate(const Vec3f& from, const Vec3f& to )
483{
484    Matrixd m;
485    m.makeRotate(from,to);
486    return m;
487}
488inline Matrixd Matrixd::rotate(const Vec3d& from, const Vec3d& to )
489{
490    Matrixd m;
491    m.makeRotate(from,to);
492    return m;
493}
494
495inline Matrixd Matrixd::inverse( const Matrixd& matrix)
496{
497    Matrixd m;
498    m.invert(matrix);
499    return m;
500}
501
502inline Matrixd Matrixd::orthoNormal(const Matrixd& matrix)
503{
504  Matrixd m;
505  m.orthoNormalize(matrix);
506  return m;
507}
508
509inline Matrixd Matrixd::ortho(double left,   double right,
510                              double bottom, double top,
511                              double zNear,  double zFar)
512{
513    Matrixd m;
514    m.makeOrtho(left,right,bottom,top,zNear,zFar);
515    return m;
516}
517
518inline Matrixd Matrixd::ortho2D(double left,   double right,
519                                double bottom, double top)
520{
521    Matrixd m;
522    m.makeOrtho2D(left,right,bottom,top);
523    return m;
524}
525
526inline Matrixd Matrixd::frustum(double left,   double right,
527                                double bottom, double top,
528                                double zNear,  double zFar)
529{
530    Matrixd m;
531    m.makeFrustum(left,right,bottom,top,zNear,zFar);
532    return m;
533}
534
535inline Matrixd Matrixd::perspective(double fovy,  double aspectRatio,
536                                    double zNear, double zFar)
537{
538    Matrixd m;
539    m.makePerspective(fovy,aspectRatio,zNear,zFar);
540    return m;
541}
542
543inline Matrixd Matrixd::lookAt(const Vec3f& eye,
544                               const Vec3f& center,
545                               const Vec3f& up)
546{
547    Matrixd m;
548    m.makeLookAt(eye,center,up);
549    return m;
550}
551
552inline Matrixd Matrixd::lookAt(const Vec3d& eye,
553                               const Vec3d& center,
554                               const Vec3d& up)
555{
556    Matrixd m;
557    m.makeLookAt(eye,center,up);
558    return m;
559}
560
561inline Vec3f Matrixd::postMult( const Vec3f& v ) const
562{
563    value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
564    return Vec3f( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
565        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
566        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
567}
568
569inline Vec3d Matrixd::postMult( const Vec3d& v ) const
570{
571    value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
572    return Vec3d( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
573        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
574        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
575}
576
577inline Vec3f Matrixd::preMult( const Vec3f& v ) const
578{
579    value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
580    return Vec3f( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
581        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
582        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
583}
584
585inline Vec3d Matrixd::preMult( const Vec3d& v ) const
586{
587    value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
588    return Vec3d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
589        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
590        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
591}
592
593inline Vec4f Matrixd::postMult( const Vec4f& v ) const
594{
595    return Vec4f( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
596        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
597        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
598        (_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
599}
600inline Vec4d Matrixd::postMult( const Vec4d& v ) const
601{
602    return Vec4d( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
603        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
604        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
605        (_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
606}
607
608inline Vec4f Matrixd::preMult( const Vec4f& v ) const
609{
610    return Vec4f( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
611        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
612        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
613        (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
614}
615
616inline Vec4d Matrixd::preMult( const Vec4d& v ) const
617{
618    return Vec4d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
619        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
620        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
621        (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
622}
623
624inline Vec3f Matrixd::transform3x3(const Vec3f& v,const Matrixd& m)
625{
626    return Vec3f( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
627                 (m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
628                 (m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
629}
630inline Vec3d Matrixd::transform3x3(const Vec3d& v,const Matrixd& m)
631{
632    return Vec3d( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
633                 (m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
634                 (m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
635}
636
637inline Vec3f Matrixd::transform3x3(const Matrixd& m,const Vec3f& v)
638{
639    return Vec3f( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
640                 (m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
641                 (m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
642}
643inline Vec3d Matrixd::transform3x3(const Matrixd& m,const Vec3d& v)
644{
645    return Vec3d( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
646                 (m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
647                 (m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
648}
649
650inline Vec3f operator* (const Vec3f& v, const Matrixd& m )
651{
652    return m.preMult(v);
653}
654
655inline Vec3d operator* (const Vec3d& v, const Matrixd& m )
656{
657    return m.preMult(v);
658}
659
660inline Vec4f operator* (const Vec4f& v, const Matrixd& m )
661{
662    return m.preMult(v);
663}
664
665inline Vec4d operator* (const Vec4d& v, const Matrixd& m )
666{
667    return m.preMult(v);
668}
669
670inline Vec3f Matrixd::operator* (const Vec3f& v) const
671{
672    return postMult(v);
673}
674
675inline Vec3d Matrixd::operator* (const Vec3d& v) const
676{
677    return postMult(v);
678}
679
680inline Vec4f Matrixd::operator* (const Vec4f& v) const
681{
682    return postMult(v);
683}
684
685inline Vec4d Matrixd::operator* (const Vec4d& v) const
686{
687    return postMult(v);
688}
689
690
691} //namespace osg
692
693
694#endif
Note: See TracBrowser for help on using the browser.