CrystalSpace

Public API Reference

csgeom/matrix3.h
Go to the documentation of this file.
00001 /*
00002     Copyright (C) 1998,1999,2000 by Jorrit Tyberghein
00003     Largely rewritten by Ivan Avramovic <ivan@avramovic.com>
00004 
00005     This library is free software; you can redistribute it and/or
00006     modify it under the terms of the GNU Library General Public
00007     License as published by the Free Software Foundation; either
00008     version 2 of the License, or (at your option) any later version.
00009 
00010     This library is distributed in the hope that it will be useful,
00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013     Library General Public License for more details.
00014 
00015     You should have received a copy of the GNU Library General Public
00016     License along with this library; if not, write to the Free
00017     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00018 */
00019 
00020 #ifndef __CS_MATRIX3_H__
00021 #define __CS_MATRIX3_H__
00022 
00030 #include "csextern.h"
00031 #include "csgeom/vector3.h"
00032 
00033 class csQuaternion;
00034 
00038 class CS_CRYSTALSPACE_EXPORT csMatrix3
00039 {
00040 public:
00041   float m11, m12, m13;
00042   float m21, m22, m23;
00043   float m31, m32, m33;
00044 
00045 public:
00047   csMatrix3 ()
00048     : m11(1), m12(0), m13(0),
00049       m21(0), m22(1), m23(0),
00050       m31(0), m32(0), m33(1)
00051   {}
00052 
00054   csMatrix3 (float am11, float am12, float am13,
00055              float am21, float am22, float am23,
00056              float am31, float am32, float am33)
00057     : m11(am11), m12(am12), m13(am13),
00058       m21(am21), m22(am22), m23(am23),
00059       m31(am31), m32(am32), m33(am33)
00060   {}
00061 
00063   csMatrix3 (csMatrix3 const& o)
00064     : m11(o.m11), m12(o.m12), m13(o.m13),
00065       m21(o.m21), m22(o.m22), m23(o.m23),
00066       m31(o.m31), m32(o.m32), m33(o.m33)
00067   {}
00068 
00070   csMatrix3 (float x,float y, float z, float angle);
00071 
00073   explicit csMatrix3 (const csQuaternion &quat)
00074   { Set (quat); }
00075 
00077   csString Description() const;
00078 
00080   inline csVector3 Row1() const { return csVector3 (m11, m12, m13); }
00081   void SetRow1 (const csVector3& r) { m11 = r.x; m12 = r.y; m13 = r.z; }
00082 
00084   inline csVector3 Row2() const { return csVector3 (m21, m22, m23); }
00085   void SetRow2 (const csVector3& r) { m21 = r.x; m22 = r.y; m23 = r.z; }
00086 
00088   inline csVector3 Row3() const { return csVector3 (m31, m32, m33); }
00089   void SetRow3 (const csVector3& r) { m31 = r.x; m32 = r.y; m33 = r.z; }
00090 
00092   inline csVector3 Row(size_t n) const
00093   {
00094     return !n ? csVector3 (m11, m12, m13) :
00095       n&1 ? csVector3 (m21, m22, m23) :
00096       csVector3 (m31, m32, m33);
00097   }
00098   void SetRow (size_t n, const csVector3& r)
00099   {
00100     if (n == 0) SetRow1 (r);
00101     else if (n == 1) SetRow2 (r);
00102     else SetRow3 (r);
00103   }
00104 
00106   inline csVector3 Col1() const { return csVector3 (m11, m21, m31); }
00107   void SetCol1 (const csVector3& c) { m11 = c.x; m21 = c.y; m31 = c.z; }
00108 
00110   inline csVector3 Col2() const { return csVector3 (m12, m22, m32); }
00111   void SetCol2 (const csVector3& c) { m12 = c.x; m22 = c.y; m32 = c.z; }
00112 
00114   inline csVector3 Col3() const { return csVector3 (m13, m23, m33); }
00115   void SetCol3 (const csVector3& c) { m13 = c.x; m23 = c.y; m33 = c.z; }
00116 
00118   inline csVector3 Col(size_t n) const
00119   {
00120     return !n ? csVector3 (m11, m21, m31) :
00121       n&1 ? csVector3 (m12, m22, m32) :
00122       csVector3 (m13, m23, m33);
00123   }
00124   void SetCol (size_t n, const csVector3& c)
00125   {
00126     if (n == 0) SetCol1 (c);
00127     else if (n == 1) SetCol2 (c);
00128     else SetCol3 (c);
00129   }
00130 
00132   inline void Set (float o11, float o12, float o13,
00133                    float o21, float o22, float o23,
00134                    float o31, float o32, float o33)
00135   {
00136     m11 = o11; m12 = o12; m13 = o13;
00137     m21 = o21; m22 = o22; m23 = o23;
00138     m31 = o31; m32 = o32; m33 = o33;
00139   }
00140 
00142   inline void Set (csMatrix3 const &o)
00143   {
00144     m11 = o.m11; m12 = o.m12; m13 = o.m13;
00145     m21 = o.m21; m22 = o.m22; m23 = o.m23;
00146     m31 = o.m31; m32 = o.m32; m33 = o.m33;
00147   }
00148 
00150   void Set (const csQuaternion&);
00151 
00153   inline csMatrix3& operator= (const csMatrix3& o)
00154   { Set(o); return *this; }
00155 
00157   inline csMatrix3& operator+= (const csMatrix3& m)
00158   {
00159     m11 += m.m11; m12 += m.m12; m13 += m.m13;
00160     m21 += m.m21; m22 += m.m22; m23 += m.m23;
00161     m31 += m.m31; m32 += m.m32; m33 += m.m33;
00162     return *this;
00163   }
00164 
00166   inline csMatrix3& operator-= (const csMatrix3& m)
00167   {
00168     m11 -= m.m11; m12 -= m.m12; m13 -= m.m13;
00169     m21 -= m.m21; m22 -= m.m22; m23 -= m.m23;
00170     m31 -= m.m31; m32 -= m.m32; m33 -= m.m33;
00171     return *this;
00172   }
00173 
00175   inline csMatrix3& operator*= (const csMatrix3& m)
00176   {
00177     float old_m11 = m11;
00178     m11 = m11 * m.m11 + m12 * m.m21 + m13 * m.m31;
00179 
00180     float old_m12 = m12;
00181     m12 = old_m11 * m.m12 + m12 * m.m22 + m13 * m.m32;
00182     m13 = old_m11 * m.m13 + old_m12 * m.m23 + m13 * m.m33;
00183 
00184     float old_m21 = m21;
00185     m21 = m21 * m.m11 + m22 * m.m21 + m23 * m.m31;
00186 
00187     float old_m22 = m22;
00188     m22 = old_m21 * m.m12 + m22 * m.m22 + m23 * m.m32;
00189     m23 = old_m21 * m.m13 + old_m22 * m.m23 + m23 * m.m33;
00190 
00191     float old_m31 = m31;
00192     m31 = m31 * m.m11 + m32 * m.m21 + m33 * m.m31;
00193 
00194     float old_m32 = m32;
00195     m32 = old_m31 * m.m12 + m32 * m.m22 + m33 * m.m32;
00196     m33 = old_m31 * m.m13 + old_m32 * m.m23 + m33 * m.m33;
00197     return *this;
00198   }
00199 
00201   inline csMatrix3& operator*= (float s)
00202   {
00203     m11 *= s; m12 *= s; m13 *= s;
00204     m21 *= s; m22 *= s; m23 *= s;
00205     m31 *= s; m32 *= s; m33 *= s;
00206     return *this;
00207   }
00208 
00210   inline csMatrix3& operator/= (float s)
00211   {
00212     s = 1.0f/s;
00213     m11 *= s; m12 *= s; m13 *= s;
00214     m21 *= s; m22 *= s; m23 *= s;
00215     m31 *= s; m32 *= s; m33 *= s;
00216     return *this;
00217   }
00218 
00220   inline csMatrix3 operator+ () const
00221   { return *this; }
00222 
00224   inline csMatrix3 operator- () const
00225   {
00226     return csMatrix3(-m11,-m12,-m13,
00227                      -m21,-m22,-m23,
00228                      -m31,-m32,-m33);
00229   }
00230 
00232   inline void Transpose ()
00233   {
00234     float swap;
00235     swap = m12; m12 = m21; m21 = swap;
00236     swap = m13; m13 = m31; m31 = swap;
00237     swap = m23; m23 = m32; m32 = swap;
00238   }
00239 
00241   csMatrix3 GetTranspose () const
00242   {
00243     return csMatrix3 (
00244       m11, m21, m31,
00245       m12, m22, m32,
00246       m13, m23, m33);
00247   }
00248 
00250   inline csMatrix3 GetInverse () const
00251   {
00252     csMatrix3 C(
00253              (m22*m33 - m23*m32), -(m12*m33 - m13*m32),  (m12*m23 - m13*m22),
00254             -(m21*m33 - m23*m31),  (m11*m33 - m13*m31), -(m11*m23 - m13*m21),
00255              (m21*m32 - m22*m31), -(m11*m32 - m12*m31),  (m11*m22 - m12*m21));
00256     float s = (float)1./(m11*C.m11 + m12*C.m21 + m13*C.m31);
00257     C *= s;
00258     return C;
00259   }
00260 
00262   inline void Invert()
00263   { *this = GetInverse (); }
00264 
00266   float Determinant () const
00267   {
00268     return m11 * (m22 * m33 - m23 * m32)
00269          - m12 * (m21 * m33 - m23 * m31)
00270          + m13 * (m21 * m32 - m22 * m31);
00271   }
00272 
00274   inline void Identity ()
00275   {
00276     m11 = m22 = m33 = 1.0;
00277     m12 = m13 = m21 = m23 = m31 = m32 = 0.0;
00278   }
00279 
00281   inline bool IsIdentity () const
00282   {
00283     return (m11 == 1.0) && (m12 == 0.0) && (m13 == 0.0) &&
00284            (m21 == 0.0) && (m22 == 1.0) && (m23 == 0.0) &&
00285            (m31 == 0.0) && (m32 == 0.0) && (m33 == 1.0);
00286   }
00287 
00289   inline friend csMatrix3 operator+ (const csMatrix3& m1, const csMatrix3& m2)
00290   {
00291     return csMatrix3 (
00292       m1.m11 + m2.m11, m1.m12 + m2.m12, m1.m13 + m2.m13,
00293       m1.m21 + m2.m21, m1.m22 + m2.m22, m1.m23 + m2.m23,
00294       m1.m31 + m2.m31, m1.m32 + m2.m32, m1.m33 + m2.m33);
00295   }
00296 
00298   inline friend csMatrix3 operator- (const csMatrix3& m1, const csMatrix3& m2)
00299   {
00300     return csMatrix3 (
00301       m1.m11 - m2.m11, m1.m12 - m2.m12, m1.m13 - m2.m13,
00302       m1.m21 - m2.m21, m1.m22 - m2.m22, m1.m23 - m2.m23,
00303       m1.m31 - m2.m31, m1.m32 - m2.m32, m1.m33 - m2.m33);
00304   }
00305 
00307   inline friend csMatrix3 operator* (const csMatrix3& m1, const csMatrix3& m2)
00308   {
00309     return csMatrix3 (
00310       m1.m11 * m2.m11 + m1.m12 * m2.m21 + m1.m13 * m2.m31,
00311       m1.m11 * m2.m12 + m1.m12 * m2.m22 + m1.m13 * m2.m32,
00312       m1.m11 * m2.m13 + m1.m12 * m2.m23 + m1.m13 * m2.m33,
00313       m1.m21 * m2.m11 + m1.m22 * m2.m21 + m1.m23 * m2.m31,
00314       m1.m21 * m2.m12 + m1.m22 * m2.m22 + m1.m23 * m2.m32,
00315       m1.m21 * m2.m13 + m1.m22 * m2.m23 + m1.m23 * m2.m33,
00316       m1.m31 * m2.m11 + m1.m32 * m2.m21 + m1.m33 * m2.m31,
00317       m1.m31 * m2.m12 + m1.m32 * m2.m22 + m1.m33 * m2.m32,
00318       m1.m31 * m2.m13 + m1.m32 * m2.m23 + m1.m33 * m2.m33);
00319   }
00320 
00322   inline friend csVector3 operator* (const csMatrix3& m, const csVector3& v)
00323   {
00324     return csVector3 (m.m11*v.x + m.m12*v.y + m.m13*v.z,
00325                       m.m21*v.x + m.m22*v.y + m.m23*v.z,
00326                       m.m31*v.x + m.m32*v.y + m.m33*v.z);
00327   }
00328 
00330   inline friend csMatrix3 operator* (const csMatrix3& m, float f)
00331   {
00332     return csMatrix3 (
00333       m.m11 * f, m.m12 * f, m.m13 * f,
00334       m.m21 * f, m.m22 * f, m.m23 * f,
00335       m.m31 * f, m.m32 * f, m.m33 * f);
00336   }
00337 
00339   inline friend csMatrix3 operator* (float f, const csMatrix3& m)
00340   {
00341     return csMatrix3 (
00342       m.m11 * f, m.m12 * f, m.m13 * f,
00343       m.m21 * f, m.m22 * f, m.m23 * f,
00344       m.m31 * f, m.m32 * f, m.m33 * f);
00345   }
00346 
00348   inline friend csMatrix3 operator/ (const csMatrix3& m, float f)
00349   {
00350     float inv_f = 1 / f;
00351     return csMatrix3 (
00352       m.m11 * inv_f, m.m12 * inv_f, m.m13 * inv_f,
00353       m.m21 * inv_f, m.m22 * inv_f, m.m23 * inv_f,
00354       m.m31 * inv_f, m.m32 * inv_f, m.m33 * inv_f);
00355   }
00356 
00358   inline friend bool operator== (const csMatrix3& m1, const csMatrix3& m2)
00359   {
00360     if (m1.m11 != m2.m11 || m1.m12 != m2.m12 || m1.m13 != m2.m13)
00361       return false;
00362     if (m1.m21 != m2.m21 || m1.m22 != m2.m22 || m1.m23 != m2.m23)
00363       return false;
00364     if (m1.m31 != m2.m31 || m1.m32 != m2.m32 || m1.m33 != m2.m33)
00365       return false;
00366     return true;
00367   }
00368 
00370   inline friend bool operator!= (const csMatrix3& m1, const csMatrix3& m2)
00371   {
00372     if (m1.m11 != m2.m11 || m1.m12 != m2.m12 || m1.m13 != m2.m13) return true;
00373     if (m1.m21 != m2.m21 || m1.m22 != m2.m22 || m1.m23 != m2.m23) return true;
00374     if (m1.m31 != m2.m31 || m1.m32 != m2.m32 || m1.m33 != m2.m33) return true;
00375     return false;
00376   }
00377 
00379   inline friend bool operator< (const csMatrix3& m, float f)
00380   {
00381     return fabsf (m.m11) < f && fabsf (m.m12) < f && fabsf (m.m13) < f &&
00382            fabsf (m.m21) < f && fabsf (m.m22) < f && fabsf (m.m23) < f &&
00383            fabsf (m.m31) < f && fabsf (m.m32) < f && fabsf (m.m33) < f;
00384   }
00385 
00387   inline friend bool operator> (float f, const csMatrix3& m)
00388   {
00389     return !(m < f);
00390   }
00391 };
00392 
00394 class CS_CRYSTALSPACE_EXPORT csXRotMatrix3 : public csMatrix3
00395 {
00396 public:
00403   csXRotMatrix3 (float angle);
00404 };
00405 
00407 class CS_CRYSTALSPACE_EXPORT csYRotMatrix3 : public csMatrix3
00408 {
00409 public:
00416   csYRotMatrix3 (float angle);
00417 };
00418 
00420 class CS_CRYSTALSPACE_EXPORT csZRotMatrix3 : public csMatrix3
00421 {
00422 public:
00429   csZRotMatrix3 (float angle);
00430 };
00431 
00433 class CS_CRYSTALSPACE_EXPORT csXScaleMatrix3 : public csMatrix3
00434 {
00435 public:
00439   csXScaleMatrix3 (float scaler)
00440     : csMatrix3(scaler, 0, 0, 0, 1, 0, 0, 0, 1)
00441   {}
00442 };
00443 
00445 class CS_CRYSTALSPACE_EXPORT csYScaleMatrix3 : public csMatrix3
00446 {
00447 public:
00451   csYScaleMatrix3 (float scaler)
00452     : csMatrix3(1, 0, 0, 0, scaler, 0, 0, 0, 1)
00453   {}
00454 };
00455 
00457 class CS_CRYSTALSPACE_EXPORT csZScaleMatrix3 : public csMatrix3
00458 {
00459 public:
00463   csZScaleMatrix3 (float scaler)
00464     : csMatrix3(1, 0, 0, 0, 1, 0, 0, 0, scaler)
00465   {}
00466 };
00467 
00468 
00471 #endif // __CS_MATRIX3_H__

Generated for Crystal Space 2.0 by doxygen 1.7.6.1