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

Revision 7890, 25.9 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_MATRIXF
15#define OSG_MATRIXF 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 Matrixf
27{
28    public:
29   
30        typedef float value_type;
31
32        inline Matrixf() { makeIdentity(); }
33        inline Matrixf( const Matrixf& mat) { set(mat.ptr()); }
34        Matrixf( const Matrixd& mat );
35        inline explicit Matrixf( float const * const ptr ) { set(ptr); }
36        inline explicit Matrixf( double const * const ptr ) { set(ptr); }
37        inline explicit Matrixf( const Quat& quat ) { makeRotate(quat); }
38
39        Matrixf( 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        ~Matrixf() {}
45
46        int compare(const Matrixf& m) const;
47
48        bool operator < (const Matrixf& m) const { return compare(m)<0; }
49        bool operator == (const Matrixf& m) const { return compare(m)==0; }
50        bool operator != (const Matrixf& 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 Matrixf& operator = (const Matrixf& rhs)
62        {
63            if( &rhs == this ) return *this;
64            set(rhs.ptr());
65            return *this;
66        }
67       
68        Matrixf& operator = (const Matrixd& other);
69
70        inline void set(const Matrixf& rhs) { set(rhs.ptr()); }
71
72        void set(const Matrixd& 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.0f && _mat[0][1]==0.0f && _mat[0][2]==0.0f &&  _mat[0][3]==0.0f &&
97                   _mat[1][0]==0.0f && _mat[1][1]==1.0f && _mat[1][2]==0.0f &&  _mat[1][3]==0.0f &&
98                   _mat[2][0]==0.0f && _mat[2][1]==0.0f && _mat[2][2]==1.0f &&  _mat[2][3]==0.0f &&
99                   _mat[3][0]==0.0f && _mat[3][1]==0.0f && _mat[3][2]==0.0f &&  _mat[3][3]==1.0f;
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 Matrixf& rhs)
218        {
219            bool is_4x3 = (rhs._mat[0][3]==0.0f && rhs._mat[1][3]==0.0f &&  rhs._mat[2][3]==0.0f && rhs._mat[3][3]==1.0f);
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 Matrixf& rhs);
225
226        /** full 4x4 matrix invert. */
227        bool invert_4x4( const Matrixf& rhs);
228
229        /** ortho-normalize the 3x3 rotation & scale matrix */
230        void orthoNormalize(const Matrixf& rhs);
231
232        //basic utility functions to create new matrices
233        inline static Matrixf identity( void );
234        inline static Matrixf scale( const Vec3f& sv);
235        inline static Matrixf scale( const Vec3d& sv);
236        inline static Matrixf scale( value_type sx, value_type sy, value_type sz);
237        inline static Matrixf translate( const Vec3f& dv);
238        inline static Matrixf translate( const Vec3d& dv);
239        inline static Matrixf translate( value_type x, value_type y, value_type z);
240        inline static Matrixf rotate( const Vec3f& from, const Vec3f& to);
241        inline static Matrixf rotate( const Vec3d& from, const Vec3d& to);
242        inline static Matrixf rotate( value_type angle, value_type x, value_type y, value_type z);
243        inline static Matrixf rotate( value_type angle, const Vec3f& axis);
244        inline static Matrixf rotate( value_type angle, const Vec3d& axis);
245        inline static Matrixf rotate( value_type angle1, const Vec3f& axis1,
246                                      value_type angle2, const Vec3f& axis2,
247                                      value_type angle3, const Vec3f& axis3);
248        inline static Matrixf rotate( value_type angle1, const Vec3d& axis1,
249                                      value_type angle2, const Vec3d& axis2,
250                                      value_type angle3, const Vec3d& axis3);
251        inline static Matrixf rotate( const Quat& quat);
252        inline static Matrixf inverse( const Matrixf& matrix);
253        inline static Matrixf orthoNormal(const Matrixf& matrix);
254       
255        /** Create an orthographic projection matrix.
256          * See glOrtho for further details.
257        */
258        inline static Matrixf ortho(double left,   double right,
259                                    double bottom, double top,
260                                    double zNear,  double zFar);
261
262        /** Create a 2D orthographic projection.
263          * See glOrtho for further details.
264        */
265        inline static Matrixf ortho2D(double left,   double right,
266                                      double bottom, double top);
267
268        /** Create a perspective projection.
269          * See glFrustum for further details.
270        */
271        inline static Matrixf frustum(double left,   double right,
272                                      double bottom, double top,
273                                      double zNear,  double zFar);
274
275        /** Create a symmetrical perspective projection.
276          * See gluPerspective for further details.
277          * Aspect ratio is defined as width/height.
278        */
279        inline static Matrixf perspective(double fovy,  double aspectRatio,
280                                          double zNear, double zFar);
281
282        /** Create the position and orientation as per a camera,
283          * using the same convention as gluLookAt.
284        */
285        inline static Matrixf lookAt(const Vec3f& eye,
286                                     const Vec3f& center,
287                                     const Vec3f& up);
288
289        /** Create the position and orientation as per a camera,
290          * using the same convention as gluLookAt.
291        */
292        inline static Matrixf lookAt(const Vec3d& eye,
293                                     const Vec3d& center,
294                                     const Vec3d& up);
295
296        inline Vec3f preMult( const Vec3f& v ) const;
297        inline Vec3d preMult( const Vec3d& v ) const;
298        inline Vec3f postMult( const Vec3f& v ) const;
299        inline Vec3d postMult( const Vec3d& v ) const;
300        inline Vec3f operator* ( const Vec3f& v ) const;
301        inline Vec3d operator* ( const Vec3d& v ) const;
302        inline Vec4f preMult( const Vec4f& v ) const;
303        inline Vec4d preMult( const Vec4d& v ) const;
304        inline Vec4f postMult( const Vec4f& v ) const;
305        inline Vec4d postMult( const Vec4d& v ) const;
306        inline Vec4f operator* ( const Vec4f& v ) const;
307        inline Vec4d operator* ( const Vec4d& v ) const;
308
309#ifdef USE_DEPRECATED_API
310        inline void set(const Quat& q) { makeRotate(q); }
311        inline void get(Quat& q) const { q = getRotate(); }
312#endif
313
314        void setRotate(const Quat& q);
315        /** Get the matrix rotation as a Quat. Note that this function
316          * assumes a non-scaled matrix and will return incorrect results
317          * for scaled matrixces. Consider decompose() instead.
318          */
319        Quat getRotate() const;
320
321
322        void setTrans( value_type tx, value_type ty, value_type tz );
323        void setTrans( const Vec3f& v );
324        void setTrans( const Vec3d& v );
325       
326        inline Vec3d getTrans() const { return Vec3d(_mat[3][0],_mat[3][1],_mat[3][2]); }
327       
328        inline Vec3d getScale() const {
329          Vec3d x_vec(_mat[0][0],_mat[1][0],_mat[2][0]);
330          Vec3d y_vec(_mat[0][1],_mat[1][1],_mat[2][1]);
331          Vec3d z_vec(_mat[0][2],_mat[1][2],_mat[2][2]);
332          return Vec3d(x_vec.length(), y_vec.length(), z_vec.length());
333        }
334       
335        /** apply a 3x3 transform of v*M[0..2,0..2]. */
336        inline static Vec3f transform3x3(const Vec3f& v,const Matrixf& m);
337
338        /** apply a 3x3 transform of v*M[0..2,0..2]. */
339        inline static Vec3d transform3x3(const Vec3d& v,const Matrixf& m);
340
341        /** apply a 3x3 transform of M[0..2,0..2]*v. */
342        inline static Vec3f transform3x3(const Matrixf& m,const Vec3f& v);
343
344        /** apply a 3x3 transform of M[0..2,0..2]*v. */
345        inline static Vec3d transform3x3(const Matrixf& m,const Vec3d& v);
346
347        // basic Matrixf multiplication, our workhorse methods.
348        void mult( const Matrixf&, const Matrixf& );
349        void preMult( const Matrixf& );
350        void postMult( const Matrixf& );
351
352        inline void operator *= ( const Matrixf& other )
353        {    if( this == &other ) {
354                Matrixf temp(other);
355                postMult( temp );
356            }
357            else postMult( other );
358        }
359
360        inline Matrixf operator * ( const Matrixf &m ) const
361        {
362            osg::Matrixf r;
363            r.mult(*this,m);
364            return  r;
365        }
366
367    protected:
368        value_type _mat[4][4];
369
370};
371
372class RefMatrixf : public Object, public Matrixf
373{
374    public:
375   
376        RefMatrixf():Object(false), Matrixf() {}
377        RefMatrixf( const Matrixf& other) : Object(false), Matrixf(other) {}
378        RefMatrixf( const Matrixd& other) : Object(false), Matrixf(other) {}
379        RefMatrixf( const RefMatrixf& other) : Object(other), Matrixf(other) {}
380        explicit RefMatrixf( Matrixf::value_type const * const def ):Object(false), Matrixf(def) {}
381        RefMatrixf( Matrixf::value_type a00, Matrixf::value_type a01, Matrixf::value_type a02, Matrixf::value_type a03,
382            Matrixf::value_type a10, Matrixf::value_type a11, Matrixf::value_type a12, Matrixf::value_type a13,
383            Matrixf::value_type a20, Matrixf::value_type a21, Matrixf::value_type a22, Matrixf::value_type a23,
384            Matrixf::value_type a30, Matrixf::value_type a31, Matrixf::value_type a32, Matrixf::value_type a33):
385            Object(false),
386            Matrixf(a00, a01, a02, a03,
387                   a10, a11, a12, a13,
388                   a20, a21, a22, a23,
389                   a30, a31, a32, a33) {}
390
391        virtual Object* cloneType() const { return new RefMatrixf(); }
392        virtual Object* clone(const CopyOp&) const { return new RefMatrixf(*this); }
393        virtual bool isSameKindAs(const Object* obj) const { return dynamic_cast<const RefMatrixf*>(obj)!=NULL; }
394        virtual const char* libraryName() const { return "osg"; }
395        virtual const char* className() const { return "Matrix"; }
396       
397       
398    protected:
399   
400        virtual ~RefMatrixf() {}
401};
402
403
404//static utility methods
405inline Matrixf Matrixf::identity(void)
406{
407    Matrixf m;
408    m.makeIdentity();
409    return m;
410}
411
412inline Matrixf Matrixf::scale(value_type sx, value_type sy, value_type sz)
413{
414    Matrixf m;
415    m.makeScale(sx,sy,sz);
416    return m;
417}
418
419inline Matrixf Matrixf::scale(const Vec3f& v )
420{
421    return scale(v.x(), v.y(), v.z() );
422}
423
424inline Matrixf Matrixf::scale(const Vec3d& v )
425{
426    return scale(v.x(), v.y(), v.z() );
427}
428
429inline Matrixf Matrixf::translate(value_type tx, value_type ty, value_type tz)
430{
431    Matrixf m;
432    m.makeTranslate(tx,ty,tz);
433    return m;
434}
435
436inline Matrixf Matrixf::translate(const Vec3f& v )
437{
438    return translate(v.x(), v.y(), v.z() );
439}
440
441inline Matrixf Matrixf::translate(const Vec3d& v )
442{
443    return translate(v.x(), v.y(), v.z() );
444}
445
446inline Matrixf Matrixf::rotate( const Quat& q )
447{
448    return Matrixf(q);
449}
450inline Matrixf Matrixf::rotate(value_type angle, value_type x, value_type y, value_type z )
451{
452    Matrixf m;
453    m.makeRotate(angle,x,y,z);
454    return m;
455}
456inline Matrixf Matrixf::rotate(value_type angle, const Vec3f& axis )
457{
458    Matrixf m;
459    m.makeRotate(angle,axis);
460    return m;
461}
462inline Matrixf Matrixf::rotate(value_type angle, const Vec3d& axis )
463{
464    Matrixf m;
465    m.makeRotate(angle,axis);
466    return m;
467}
468inline Matrixf Matrixf::rotate( value_type angle1, const Vec3f& axis1,
469                              value_type angle2, const Vec3f& axis2,
470                              value_type angle3, const Vec3f& axis3)
471{
472    Matrixf m;
473    m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
474    return m;
475}
476inline Matrixf Matrixf::rotate( value_type angle1, const Vec3d& axis1,
477                              value_type angle2, const Vec3d& axis2,
478                              value_type angle3, const Vec3d& axis3)
479{
480    Matrixf m;
481    m.makeRotate(angle1,axis1,angle2,axis2,angle3,axis3);
482    return m;
483}
484inline Matrixf Matrixf::rotate(const Vec3f& from, const Vec3f& to )
485{
486    Matrixf m;
487    m.makeRotate(from,to);
488    return m;
489}
490inline Matrixf Matrixf::rotate(const Vec3d& from, const Vec3d& to )
491{
492    Matrixf m;
493    m.makeRotate(from,to);
494    return m;
495}
496
497inline Matrixf Matrixf::inverse( const Matrixf& matrix)
498{
499    Matrixf m;
500    m.invert(matrix);
501    return m;
502}
503
504inline Matrixf Matrixf::orthoNormal(const Matrixf& matrix)
505{
506  Matrixf m;
507  m.orthoNormalize(matrix);
508  return m;
509}
510
511inline Matrixf Matrixf::ortho(double left, double right,
512                            double bottom, double top,
513                            double zNear, double zFar)
514{
515    Matrixf m;
516    m.makeOrtho(left,right,bottom,top,zNear,zFar);
517    return m;
518}
519
520inline Matrixf Matrixf::ortho2D(double left, double right,
521                              double bottom, double top)
522{
523    Matrixf m;
524    m.makeOrtho2D(left,right,bottom,top);
525    return m;
526}
527
528inline Matrixf Matrixf::frustum(double left, double right,
529                              double bottom, double top,
530                              double zNear, double zFar)
531{
532    Matrixf m;
533    m.makeFrustum(left,right,bottom,top,zNear,zFar);
534    return m;
535}
536
537inline Matrixf Matrixf::perspective(double fovy,double aspectRatio,
538                                  double zNear, double zFar)
539{
540    Matrixf m;
541    m.makePerspective(fovy,aspectRatio,zNear,zFar);
542    return m;
543}
544
545inline Matrixf Matrixf::lookAt(const Vec3f& eye,const Vec3f& center,const Vec3f& up)
546{
547    Matrixf m;
548    m.makeLookAt(eye,center,up);
549    return m;
550}
551
552inline Matrixf Matrixf::lookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up)
553{
554    Matrixf m;
555    m.makeLookAt(eye,center,up);
556    return m;
557}
558
559inline Vec3f Matrixf::postMult( const Vec3f& v ) const
560{
561    value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
562    return Vec3f( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
563        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
564        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
565}
566inline Vec3d Matrixf::postMult( const Vec3d& v ) const
567{
568    value_type d = 1.0f/(_mat[3][0]*v.x()+_mat[3][1]*v.y()+_mat[3][2]*v.z()+_mat[3][3]) ;
569    return Vec3d( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3])*d,
570        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3])*d,
571        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3])*d) ;
572}
573
574inline Vec3f Matrixf::preMult( const Vec3f& v ) const
575{
576    value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
577    return Vec3f( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
578        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
579        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
580}
581inline Vec3d Matrixf::preMult( const Vec3d& v ) const
582{
583    value_type d = 1.0f/(_mat[0][3]*v.x()+_mat[1][3]*v.y()+_mat[2][3]*v.z()+_mat[3][3]) ;
584    return Vec3d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0])*d,
585        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1])*d,
586        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2])*d);
587}
588
589inline Vec4f Matrixf::postMult( const Vec4f& v ) const
590{
591    return Vec4f( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
592        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
593        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
594        (_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
595}
596inline Vec4d Matrixf::postMult( const Vec4d& v ) const
597{
598    return Vec4d( (_mat[0][0]*v.x() + _mat[0][1]*v.y() + _mat[0][2]*v.z() + _mat[0][3]*v.w()),
599        (_mat[1][0]*v.x() + _mat[1][1]*v.y() + _mat[1][2]*v.z() + _mat[1][3]*v.w()),
600        (_mat[2][0]*v.x() + _mat[2][1]*v.y() + _mat[2][2]*v.z() + _mat[2][3]*v.w()),
601        (_mat[3][0]*v.x() + _mat[3][1]*v.y() + _mat[3][2]*v.z() + _mat[3][3]*v.w())) ;
602}
603
604inline Vec4f Matrixf::preMult( const Vec4f& v ) const
605{
606    return Vec4f( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
607        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
608        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
609        (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
610}
611inline Vec4d Matrixf::preMult( const Vec4d& v ) const
612{
613    return Vec4d( (_mat[0][0]*v.x() + _mat[1][0]*v.y() + _mat[2][0]*v.z() + _mat[3][0]*v.w()),
614        (_mat[0][1]*v.x() + _mat[1][1]*v.y() + _mat[2][1]*v.z() + _mat[3][1]*v.w()),
615        (_mat[0][2]*v.x() + _mat[1][2]*v.y() + _mat[2][2]*v.z() + _mat[3][2]*v.w()),
616        (_mat[0][3]*v.x() + _mat[1][3]*v.y() + _mat[2][3]*v.z() + _mat[3][3]*v.w()));
617}
618inline Vec3f Matrixf::transform3x3(const Vec3f& v,const Matrixf& m)
619{
620    return Vec3f( (m._mat[0][0]*v.x() + m._mat[1][0]*v.y() + m._mat[2][0]*v.z()),
621                 (m._mat[0][1]*v.x() + m._mat[1][1]*v.y() + m._mat[2][1]*v.z()),
622                 (m._mat[0][2]*v.x() + m._mat[1][2]*v.y() + m._mat[2][2]*v.z()));
623}
624inline Vec3d Matrixf::transform3x3(const Vec3d& v,const Matrixf& m)
625{
626    return Vec3d( (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}
630
631inline Vec3f Matrixf::transform3x3(const Matrixf& m,const Vec3f& v)
632{
633    return Vec3f( (m._mat[0][0]*v.x() + m._mat[0][1]*v.y() + m._mat[0][2]*v.z()),
634                 (m._mat[1][0]*v.x() + m._mat[1][1]*v.y() + m._mat[1][2]*v.z()),
635                 (m._mat[2][0]*v.x() + m._mat[2][1]*v.y() + m._mat[2][2]*v.z()) ) ;
636}
637inline Vec3d Matrixf::transform3x3(const Matrixf& m,const Vec3d& v)
638{
639    return Vec3d( (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}
643
644
645inline Vec3f operator* (const Vec3f& v, const Matrixf& m )
646{
647    return m.preMult(v);
648}
649inline Vec3d operator* (const Vec3d& v, const Matrixf& m )
650{
651    return m.preMult(v);
652}
653inline Vec4f operator* (const Vec4f& v, const Matrixf& m )
654{
655    return m.preMult(v);
656}
657inline Vec4d operator* (const Vec4d& v, const Matrixf& m )
658{
659    return m.preMult(v);
660}
661
662inline Vec3f Matrixf::operator* (const Vec3f& v) const
663{
664    return postMult(v);
665}
666inline Vec3d Matrixf::operator* (const Vec3d& v) const
667{
668    return postMult(v);
669}
670inline Vec4f Matrixf::operator* (const Vec4f& v) const
671{
672    return postMult(v);
673}
674inline Vec4d Matrixf::operator* (const Vec4d& v) const
675{
676    return postMult(v);
677}
678
679
680} //namespace osg
681
682
683#endif
Note: See TracBrowser for help on using the browser.