The Open Toolkit library: Source/OpenTK/Math/Matrix3d.cs Source File

00001 #region --- License ---
00002 /*
00003 Copyright (c) 2006 - 2008 The Open Toolkit library.
00004 
00005 Permission is hereby granted, free of charge, to any person obtaining a copy of
00006 this software and associated documentation files (the "Software"), to deal in
00007 the Software without restriction, including without limitation the rights to
00008 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
00009 of the Software, and to permit persons to whom the Software is furnished to do
00010 so, subject to the following conditions:
00011 
00012 The above copyright notice and this permission notice shall be included in all
00013 copies or substantial portions of the Software.
00014 
00015 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00016 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00017 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00018 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00019 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00020 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
00021 SOFTWARE.
00022  */
00023 #endregion
00024 
00025 using System;
00026 using System.Runtime.InteropServices;
00027 
00028 namespace OpenTK
00029 {
00030     // Todo: Remove this warning when the code goes public.
00031     #pragma warning disable 3019
00032 #if false
00033     [Serializable]
00034     [StructLayout(LayoutKind.Sequential)]
00035     public struct Matrix3d : IEquatable<Matrix3d>
00036     {
00037         #region Fields & Access
00038 
00040         public double R0C0;
00041 
00043         public double R0C1;
00044 
00046         public double R0C2;
00047 
00049         public double R1C0;
00050 
00052         public double R1C1;
00053 
00055         public double R1C2;
00056 
00058         public double R2C0;
00059 
00061         public double R2C1;
00062 
00064         public double R2C2;
00065 
00070         public double this[int row, int column]
00071         {
00072             get
00073             {
00074                 switch( row )
00075                 {
00076                     case 0:
00077                         switch (column)
00078                         {
00079                             case 0: return R0C0;
00080                             case 1: return R0C1;
00081                             case 2: return R0C2;
00082                         }
00083                         break;
00084 
00085                     case 1:
00086                         switch (column)
00087                         {
00088                             case 0: return R1C0;
00089                             case 1: return R1C1;
00090                             case 2: return R1C2;
00091                         }
00092                         break;
00093 
00094                     case 2:
00095                         switch (column)
00096                         {
00097                             case 0: return R2C0;
00098                             case 1: return R2C1;
00099                             case 2: return R2C2;
00100                         }
00101                         break;
00102                 }
00103 
00104                 throw new IndexOutOfRangeException();
00105             }
00106             set
00107             {
00108                 switch( row )
00109                 {
00110                     case 0:
00111                         switch (column)
00112                         {
00113                             case 0: R0C0 = value; return;
00114                             case 1: R0C1 = value; return;
00115                             case 2: R0C2 = value; return;
00116                         }
00117                         break;
00118 
00119                     case 1:
00120                         switch (column)
00121                         {
00122                             case 0: R1C0 = value; return;
00123                             case 1: R1C1 = value; return;
00124                             case 2: R1C2 = value; return;
00125                         }
00126                         break;
00127 
00128                     case 2:
00129                         switch (column)
00130                         {
00131                             case 0: R2C0 = value; return;
00132                             case 1: R2C1 = value; return;
00133                             case 2: R2C2 = value; return;
00134                         }
00135                         break;
00136                 }
00137 
00138                 throw new IndexOutOfRangeException();
00139             }
00140         }
00141 
00145         public double this[int index]
00146         {
00147             get
00148             {
00149                 switch (index)
00150                 {
00151                     case 0: return R0C0;
00152                     case 1: return R0C1;
00153                     case 2: return R0C2;
00154                     case 3: return R1C0;
00155                     case 4: return R1C1;
00156                     case 5: return R1C2;
00157                     case 6: return R2C0;
00158                     case 7: return R2C1;
00159                     case 8: return R2C2;
00160                     default: throw new IndexOutOfRangeException();
00161                 }
00162             }
00163             set
00164             {
00165                 switch (index)
00166                 {
00167                     case 0: R0C0 = value; return;
00168                     case 1: R0C1 = value; return;
00169                     case 2: R0C2 = value; return;
00170                     case 3: R1C0 = value; return;
00171                     case 4: R1C1 = value; return;
00172                     case 5: R1C2 = value; return;
00173                     case 6: R2C0 = value; return;
00174                     case 7: R2C1 = value; return;
00175                     case 8: R2C2 = value; return;
00176                     default: throw new IndexOutOfRangeException();
00177                 }
00178             }
00179         }
00180 
00184         public static explicit operator IntPtr(Matrix3d matrix)
00185         {
00186             unsafe
00187             {
00188                 return (IntPtr)(&matrix.R0C0);
00189             }
00190         }
00191 
00195         [CLSCompliant(false)]
00196         unsafe public static explicit operator double*(Matrix3d matrix)
00197         {
00198             return &matrix.R0C0;
00199         }
00200 
00204         public static explicit operator double[](Matrix3d matrix)
00205         {
00206             return new double[9]
00207             {
00208                 matrix.R0C0,
00209                 matrix.R0C1,
00210                 matrix.R0C2,
00211                 matrix.R1C0,
00212                 matrix.R1C1,
00213                 matrix.R1C2,
00214                 matrix.R2C0,
00215                 matrix.R2C1,
00216                 matrix.R2C2
00217             };
00218         }
00219 
00220         #endregion
00221 
00222         #region Constructors
00223 
00226         public Matrix3d(ref Matrix3d matrix)
00227         {
00228             this.R0C0 = matrix.R0C0;
00229             this.R0C1 = matrix.R0C1;
00230             this.R0C2 = matrix.R0C2;
00231             this.R1C0 = matrix.R1C0;
00232             this.R1C1 = matrix.R1C1;
00233             this.R1C2 = matrix.R1C2;
00234             this.R2C0 = matrix.R2C0;
00235             this.R2C1 = matrix.R2C1;
00236             this.R2C2 = matrix.R2C2;
00237         }
00238 
00249         public Matrix3d
00250         (
00251             double r0c0,
00252             double r0c1,
00253             double r0c2,
00254             double r1c0,
00255             double r1c1,
00256             double r1c2,
00257             double r2c0,
00258             double r2c1,
00259             double r2c2
00260         )
00261         {
00262             this.R0C0 = r0c0;
00263             this.R0C1 = r0c1;
00264             this.R0C2 = r0c2;
00265             this.R1C0 = r1c0;
00266             this.R1C1 = r1c1;
00267             this.R1C2 = r1c2;
00268             this.R2C0 = r2c0;
00269             this.R2C1 = r2c1;
00270             this.R2C2 = r2c2;
00271         }
00272 
00275         public Matrix3d(double[] doubleArray)
00276         {
00277             if (doubleArray == null || doubleArray.GetLength(0) < 9) throw new MissingFieldException();
00278 
00279             this.R0C0 = doubleArray[0];
00280             this.R0C1 = doubleArray[1];
00281             this.R0C2 = doubleArray[2];
00282             this.R1C0 = doubleArray[3];
00283             this.R1C1 = doubleArray[4];
00284             this.R1C2 = doubleArray[5];
00285             this.R2C0 = doubleArray[6];
00286             this.R2C1 = doubleArray[7];
00287             this.R2C2 = doubleArray[8];
00288         }
00289 
00292         public Matrix3d(Quaterniond quaternion)
00293         {
00294             quaternion.Normalize();
00295 
00296             double xx = quaternion.X * quaternion.X;
00297             double yy = quaternion.Y * quaternion.Y;
00298             double zz = quaternion.Z * quaternion.Z;
00299             double xy = quaternion.X * quaternion.Y;
00300             double xz = quaternion.X * quaternion.Z;
00301             double yz = quaternion.Y * quaternion.Z;
00302             double wx = quaternion.W * quaternion.X;
00303             double wy = quaternion.W * quaternion.Y;
00304             double wz = quaternion.W * quaternion.Z;
00305 
00306             R0C0 = 1 - 2 * (yy + zz);
00307             R0C1 = 2 * (xy - wz);
00308             R0C2 = 2 * (xz + wy);
00309 
00310             R1C0 = 2 * (xy + wz);
00311             R1C1 = 1 - 2 * (xx + zz);
00312             R1C2 = 2 * (yz - wx);
00313 
00314             R2C0 = 2 * (xz - wy);
00315             R2C1 = 2 * (yz + wx);
00316             R2C2 = 1 - 2 * (xx + yy);
00317         }
00318 
00319         #endregion
00320 
00321         #region Equality
00322 
00326         [CLSCompliant(false)]
00327         public bool Equals(Matrix3d matrix)
00328         {
00329             return
00330                 R0C0 == matrix.R0C0 &&
00331                 R0C1 == matrix.R0C1 &&
00332                 R0C2 == matrix.R0C2 &&
00333                 R1C0 == matrix.R1C0 &&
00334                 R1C1 == matrix.R1C1 &&
00335                 R1C2 == matrix.R1C2 &&
00336                 R2C0 == matrix.R2C0 &&
00337                 R2C1 == matrix.R2C1 &&
00338                 R2C2 == matrix.R2C2;
00339         }
00340 
00344         public bool Equals(ref Matrix3d matrix)
00345         {
00346             return
00347                 R0C0 == matrix.R0C0 &&
00348                 R0C1 == matrix.R0C1 &&
00349                 R0C2 == matrix.R0C2 &&
00350                 R1C0 == matrix.R1C0 &&
00351                 R1C1 == matrix.R1C1 &&
00352                 R1C2 == matrix.R1C2 &&
00353                 R2C0 == matrix.R2C0 &&
00354                 R2C1 == matrix.R2C1 &&
00355                 R2C2 == matrix.R2C2;
00356         }
00357 
00362         public static bool Equals(ref Matrix3d left, ref Matrix3d right)
00363         {
00364             return
00365                 left.R0C0 == right.R0C0 &&
00366                 left.R0C1 == right.R0C1 &&
00367                 left.R0C2 == right.R0C2 &&
00368                 left.R1C0 == right.R1C0 &&
00369                 left.R1C1 == right.R1C1 &&
00370                 left.R1C2 == right.R1C2 &&
00371                 left.R2C0 == right.R2C0 &&
00372                 left.R2C1 == right.R2C1 &&
00373                 left.R2C2 == right.R2C2;
00374         }
00375 
00380         public bool EqualsApprox(ref Matrix3d matrix, double tolerance)
00381         {
00382             return
00383                 System.Math.Abs(R0C0 - matrix.R0C0) <= tolerance &&
00384                 System.Math.Abs(R0C1 - matrix.R0C1) <= tolerance &&
00385                 System.Math.Abs(R0C2 - matrix.R0C2) <= tolerance &&
00386                 System.Math.Abs(R1C0 - matrix.R1C0) <= tolerance &&
00387                 System.Math.Abs(R1C1 - matrix.R1C1) <= tolerance &&
00388                 System.Math.Abs(R1C2 - matrix.R1C2) <= tolerance &&
00389                 System.Math.Abs(R2C0 - matrix.R2C0) <= tolerance &&
00390                 System.Math.Abs(R2C1 - matrix.R2C1) <= tolerance &&
00391                 System.Math.Abs(R2C2 - matrix.R2C2) <= tolerance;
00392         }
00393 
00399         public static bool EqualsApprox(ref Matrix3d left, ref Matrix3d right, double tolerance)
00400         {
00401             return
00402                 System.Math.Abs(left.R0C0 - right.R0C0) <= tolerance &&
00403                 System.Math.Abs(left.R0C1 - right.R0C1) <= tolerance &&
00404                 System.Math.Abs(left.R0C2 - right.R0C2) <= tolerance &&
00405                 System.Math.Abs(left.R1C0 - right.R1C0) <= tolerance &&
00406                 System.Math.Abs(left.R1C1 - right.R1C1) <= tolerance &&
00407                 System.Math.Abs(left.R1C2 - right.R1C2) <= tolerance &&
00408                 System.Math.Abs(left.R2C0 - right.R2C0) <= tolerance &&
00409                 System.Math.Abs(left.R2C1 - right.R2C1) <= tolerance &&
00410                 System.Math.Abs(left.R2C2 - right.R2C2) <= tolerance;
00411         }
00412 
00413         #endregion
00414 
00415         #region Arithmetic Operators
00416 
00417 
00420         public void Add(ref Matrix3d matrix)
00421         {
00422             R0C0 = R0C0 + matrix.R0C0;
00423             R0C1 = R0C1 + matrix.R0C1;
00424             R0C2 = R0C2 + matrix.R0C2;
00425             R1C0 = R1C0 + matrix.R1C0;
00426             R1C1 = R1C1 + matrix.R1C1;
00427             R1C2 = R1C2 + matrix.R1C2;
00428             R2C0 = R2C0 + matrix.R2C0;
00429             R2C1 = R2C1 + matrix.R2C1;
00430             R2C2 = R2C2 + matrix.R2C2;
00431         }
00432 
00436         public void Add(ref Matrix3d matrix, out Matrix3d result)
00437         {
00438             result.R0C0 = R0C0 + matrix.R0C0;
00439             result.R0C1 = R0C1 + matrix.R0C1;
00440             result.R0C2 = R0C2 + matrix.R0C2;
00441             result.R1C0 = R1C0 + matrix.R1C0;
00442             result.R1C1 = R1C1 + matrix.R1C1;
00443             result.R1C2 = R1C2 + matrix.R1C2;
00444             result.R2C0 = R2C0 + matrix.R2C0;
00445             result.R2C1 = R2C1 + matrix.R2C1;
00446             result.R2C2 = R2C2 + matrix.R2C2;
00447         }
00448 
00453         public static void Add(ref Matrix3d left, ref Matrix3d right, out Matrix3d result)
00454         {
00455             result.R0C0 = left.R0C0 + right.R0C0;
00456             result.R0C1 = left.R0C1 + right.R0C1;
00457             result.R0C2 = left.R0C2 + right.R0C2;
00458             result.R1C0 = left.R1C0 + right.R1C0;
00459             result.R1C1 = left.R1C1 + right.R1C1;
00460             result.R1C2 = left.R1C2 + right.R1C2;
00461             result.R2C0 = left.R2C0 + right.R2C0;
00462             result.R2C1 = left.R2C1 + right.R2C1;
00463             result.R2C2 = left.R2C2 + right.R2C2;
00464         }
00465 
00466 
00469         public void Subtract(ref Matrix3d matrix)
00470         {
00471             R0C0 = R0C0 + matrix.R0C0;
00472             R0C1 = R0C1 + matrix.R0C1;
00473             R0C2 = R0C2 + matrix.R0C2;
00474             R1C0 = R1C0 + matrix.R1C0;
00475             R1C1 = R1C1 + matrix.R1C1;
00476             R1C2 = R1C2 + matrix.R1C2;
00477             R2C0 = R2C0 + matrix.R2C0;
00478             R2C1 = R2C1 + matrix.R2C1;
00479             R2C2 = R2C2 + matrix.R2C2;
00480         }
00481 
00485         public void Subtract(ref Matrix3d matrix, out Matrix3d result)
00486         {
00487             result.R0C0 = R0C0 + matrix.R0C0;
00488             result.R0C1 = R0C1 + matrix.R0C1;
00489             result.R0C2 = R0C2 + matrix.R0C2;
00490             result.R1C0 = R1C0 + matrix.R1C0;
00491             result.R1C1 = R1C1 + matrix.R1C1;
00492             result.R1C2 = R1C2 + matrix.R1C2;
00493             result.R2C0 = R2C0 + matrix.R2C0;
00494             result.R2C1 = R2C1 + matrix.R2C1;
00495             result.R2C2 = R2C2 + matrix.R2C2;
00496         }
00497 
00502         public static void Subtract(ref Matrix3d left, ref Matrix3d right, out Matrix3d result)
00503         {
00504             result.R0C0 = left.R0C0 + right.R0C0;
00505             result.R0C1 = left.R0C1 + right.R0C1;
00506             result.R0C2 = left.R0C2 + right.R0C2;
00507             result.R1C0 = left.R1C0 + right.R1C0;
00508             result.R1C1 = left.R1C1 + right.R1C1;
00509             result.R1C2 = left.R1C2 + right.R1C2;
00510             result.R2C0 = left.R2C0 + right.R2C0;
00511             result.R2C1 = left.R2C1 + right.R2C1;
00512             result.R2C2 = left.R2C2 + right.R2C2;
00513         }
00514 
00515 
00518         public void Multiply(ref Matrix3d matrix)
00519         {
00520             double r0c0 = matrix.R0C0 * R0C0 + matrix.R0C1 * R1C0 + matrix.R0C2 * R2C0;
00521             double r0c1 = matrix.R0C0 * R0C1 + matrix.R0C1 * R1C1 + matrix.R0C2 * R2C1;
00522             double r0c2 = matrix.R0C0 * R0C2 + matrix.R0C1 * R1C2 + matrix.R0C2 * R2C2;
00523 
00524             double r1c0 = matrix.R1C0 * R0C0 + matrix.R1C1 * R1C0 + matrix.R1C2 * R2C0;
00525             double r1c1 = matrix.R1C0 * R0C1 + matrix.R1C1 * R1C1 + matrix.R1C2 * R2C1;
00526             double r1c2 = matrix.R1C0 * R0C2 + matrix.R1C1 * R1C2 + matrix.R1C2 * R2C2;
00527 
00528             R2C0 = matrix.R2C0 * R0C0 + matrix.R2C1 * R1C0 + matrix.R2C2 * R2C0;
00529             R2C1 = matrix.R2C0 * R0C1 + matrix.R2C1 * R1C1 + matrix.R2C2 * R2C1;
00530             R2C2 = matrix.R2C0 * R0C2 + matrix.R2C1 * R1C2 + matrix.R2C2 * R2C2;
00531 
00532 
00533             R0C0 = r0c0;
00534             R0C1 = r0c1;
00535             R0C2 = r0c2;
00536 
00537             R1C0 = r1c0;
00538             R1C1 = r1c1;
00539             R1C2 = r1c2;
00540         }
00541 
00545         public void Multiply(ref Matrix3d matrix, out Matrix3d result)
00546         {
00547             result.R0C0 = matrix.R0C0 * R0C0 + matrix.R0C1 * R1C0 + matrix.R0C2 * R2C0;
00548             result.R0C1 = matrix.R0C0 * R0C1 + matrix.R0C1 * R1C1 + matrix.R0C2 * R2C1;
00549             result.R0C2 = matrix.R0C0 * R0C2 + matrix.R0C1 * R1C2 + matrix.R0C2 * R2C2;
00550             result.R1C0 = matrix.R1C0 * R0C0 + matrix.R1C1 * R1C0 + matrix.R1C2 * R2C0;
00551             result.R1C1 = matrix.R1C0 * R0C1 + matrix.R1C1 * R1C1 + matrix.R1C2 * R2C1;
00552             result.R1C2 = matrix.R1C0 * R0C2 + matrix.R1C1 * R1C2 + matrix.R1C2 * R2C2;
00553             result.R2C0 = matrix.R2C0 * R0C0 + matrix.R2C1 * R1C0 + matrix.R2C2 * R2C0;
00554             result.R2C1 = matrix.R2C0 * R0C1 + matrix.R2C1 * R1C1 + matrix.R2C2 * R2C1;
00555             result.R2C2 = matrix.R2C0 * R0C2 + matrix.R2C1 * R1C2 + matrix.R2C2 * R2C2;
00556         }
00557 
00562         public static void Multiply(ref Matrix3d left, ref Matrix3d right, out Matrix3d result)
00563         {
00564             result.R0C0 = right.R0C0 * left.R0C0 + right.R0C1 * left.R1C0 + right.R0C2 * left.R2C0;
00565             result.R0C1 = right.R0C0 * left.R0C1 + right.R0C1 * left.R1C1 + right.R0C2 * left.R2C1;
00566             result.R0C2 = right.R0C0 * left.R0C2 + right.R0C1 * left.R1C2 + right.R0C2 * left.R2C2;
00567             result.R1C0 = right.R1C0 * left.R0C0 + right.R1C1 * left.R1C0 + right.R1C2 * left.R2C0;
00568             result.R1C1 = right.R1C0 * left.R0C1 + right.R1C1 * left.R1C1 + right.R1C2 * left.R2C1;
00569             result.R1C2 = right.R1C0 * left.R0C2 + right.R1C1 * left.R1C2 + right.R1C2 * left.R2C2;
00570             result.R2C0 = right.R2C0 * left.R0C0 + right.R2C1 * left.R1C0 + right.R2C2 * left.R2C0;
00571             result.R2C1 = right.R2C0 * left.R0C1 + right.R2C1 * left.R1C1 + right.R2C2 * left.R2C1;
00572             result.R2C2 = right.R2C0 * left.R0C2 + right.R2C1 * left.R1C2 + right.R2C2 * left.R2C2;
00573         }
00574 
00575 
00578         public void Multiply(double scalar)
00579         {
00580             R0C0 = scalar * R0C0;
00581             R0C1 = scalar * R0C1;
00582             R0C2 = scalar * R0C2;
00583             R1C0 = scalar * R1C0;
00584             R1C1 = scalar * R1C1;
00585             R1C2 = scalar * R1C2;
00586             R2C0 = scalar * R2C0;
00587             R2C1 = scalar * R2C1;
00588             R2C2 = scalar * R2C2;
00589         }
00590 
00594         public void Multiply(double scalar, out Matrix3d result)
00595         {
00596             result.R0C0 = scalar * R0C0;
00597             result.R0C1 = scalar * R0C1;
00598             result.R0C2 = scalar * R0C2;
00599             result.R1C0 = scalar * R1C0;
00600             result.R1C1 = scalar * R1C1;
00601             result.R1C2 = scalar * R1C2;
00602             result.R2C0 = scalar * R2C0;
00603             result.R2C1 = scalar * R2C1;
00604             result.R2C2 = scalar * R2C2;
00605         }
00606 
00611         public static void Multiply(ref Matrix3d matrix, double scalar, out Matrix3d result)
00612         {
00613             result.R0C0 = scalar * matrix.R0C0;
00614             result.R0C1 = scalar * matrix.R0C1;
00615             result.R0C2 = scalar * matrix.R0C2;
00616             result.R1C0 = scalar * matrix.R1C0;
00617             result.R1C1 = scalar * matrix.R1C1;
00618             result.R1C2 = scalar * matrix.R1C2;
00619             result.R2C0 = scalar * matrix.R2C0;
00620             result.R2C1 = scalar * matrix.R2C1;
00621             result.R2C2 = scalar * matrix.R2C2;
00622         }
00623 
00624 
00625         #endregion
00626 
00627         #region Functions
00628 
00629         public double Determinant
00630         {
00631             get
00632             {
00633                 return R0C0 * R1C1 * R2C2 - R0C0 * R1C2 * R2C1 - R0C1 * R1C0 * R2C2 + R0C2 * R1C0 * R2C1 + R0C1 * R1C2 * R2C0 - R0C2 * R1C1 * R2C0;
00634             }
00635         }
00636 
00637         public void Transpose()
00638         {
00639             Functions.Swap(ref R0C1, ref R1C0);
00640             Functions.Swap(ref R0C2, ref R2C0);
00641             Functions.Swap(ref R1C2, ref R2C1);
00642         }
00643         public void Transpose(out Matrix3d result)
00644         {
00645             result.R0C0 = R0C0;
00646             result.R0C1 = R1C0;
00647             result.R0C2 = R2C0;
00648             result.R1C0 = R0C1;
00649             result.R1C1 = R1C1;
00650             result.R1C2 = R2C1;
00651             result.R2C0 = R0C2;
00652             result.R2C1 = R1C2;
00653             result.R2C2 = R2C2;
00654         }
00655         public static void Transpose(ref Matrix3d matrix, out Matrix3d result)
00656         {
00657             result.R0C0 = matrix.R0C0;
00658             result.R0C1 = matrix.R1C0;
00659             result.R0C2 = matrix.R2C0;
00660             result.R1C0 = matrix.R0C1;
00661             result.R1C1 = matrix.R1C1;
00662             result.R1C2 = matrix.R2C1;
00663             result.R2C0 = matrix.R0C2;
00664             result.R2C1 = matrix.R1C2;
00665             result.R2C2 = matrix.R2C2;
00666         }
00667 
00668         #endregion
00669 
00670         #region Transformation Functions
00671 
00672         public void Transform(ref Vector3d vector)
00673         {
00674             double x = R0C0 * vector.X + R0C1 * vector.Y + R0C2 * vector.Z;
00675             double y = R1C0 * vector.X + R1C1 * vector.Y + R1C2 * vector.Z;
00676             vector.Z = R2C0 * vector.X + R2C1 * vector.Y + R2C2 * vector.Z;
00677             vector.X = x;
00678             vector.Y = y;
00679         }
00680         public static void Transform(ref Matrix3d matrix, ref Vector3d vector)
00681         {
00682             double x = matrix.R0C0 * vector.X + matrix.R0C1 * vector.Y + matrix.R0C2 * vector.Z;
00683             double y = matrix.R1C0 * vector.X + matrix.R1C1 * vector.Y + matrix.R1C2 * vector.Z;
00684             vector.Z = matrix.R2C0 * vector.X + matrix.R2C1 * vector.Y + matrix.R2C2 * vector.Z;
00685             vector.X = x;
00686             vector.Y = y;
00687         }
00688         public void Transform(ref Vector3d vector, out Vector3d result)
00689         {
00690             result.X = R0C0 * vector.X + R0C1 * vector.Y + R0C2 * vector.Z;
00691             result.Y = R1C0 * vector.X + R1C1 * vector.Y + R1C2 * vector.Z;
00692             result.Z = R2C0 * vector.X + R2C1 * vector.Y + R2C2 * vector.Z;
00693         }
00694         public static void Transform(ref Matrix3d matrix, ref Vector3d vector, out Vector3d result)
00695         {
00696             result.X = matrix.R0C0 * vector.X + matrix.R0C1 * vector.Y + matrix.R0C2 * vector.Z;
00697             result.Y = matrix.R1C0 * vector.X + matrix.R1C1 * vector.Y + matrix.R1C2 * vector.Z;
00698             result.Z = matrix.R2C0 * vector.X + matrix.R2C1 * vector.Y + matrix.R2C2 * vector.Z;
00699         }
00700 
00701         public void Rotate(double angle)
00702         {
00703             double angleRadians = Functions.DTOR * angle;
00704             double sin = (double)System.Math.Sin(angleRadians);
00705             double cos = (double)System.Math.Cos(angleRadians);
00706 
00707             double r0c0 = cos * R0C0 + sin * R1C0;
00708             double r0c1 = cos * R0C1 + sin * R1C1;
00709             double r0c2 = cos * R0C2 + sin * R1C2;
00710 
00711             R1C0 = cos * R1C0 - sin * R0C0;
00712             R1C1 = cos * R1C1 - sin * R0C1;
00713             R1C2 = cos * R1C2 - sin * R0C2;
00714 
00715             R0C0 = r0c0;
00716             R0C1 = r0c1;
00717             R0C2 = r0c2;
00718         }
00719         public void Rotate(double angle, out Matrix3d result)
00720         {
00721             double angleRadians = Functions.DTOR * angle;
00722             double sin = (double)System.Math.Sin(angleRadians);
00723             double cos = (double)System.Math.Cos(angleRadians);
00724 
00725             result.R0C0 = cos * R0C0 + sin * R1C0;
00726             result.R0C1 = cos * R0C1 + sin * R1C1;
00727             result.R0C2 = cos * R0C2 + sin * R1C2;
00728             result.R1C0 = cos * R1C0 - sin * R0C0;
00729             result.R1C1 = cos * R1C1 - sin * R0C1;
00730             result.R1C2 = cos * R1C2 - sin * R0C2;
00731             result.R2C0 = R2C0;
00732             result.R2C1 = R2C1;
00733             result.R2C2 = R2C2;
00734         }
00735         public static void Rotate(ref Matrix3d matrix, double angle, out Matrix3d result)
00736         {
00737             double angleRadians = Functions.DTOR * angle;
00738             double sin = (double)System.Math.Sin(angleRadians);
00739             double cos = (double)System.Math.Cos(angleRadians);
00740 
00741             result.R0C0 = cos * matrix.R0C0 + sin * matrix.R1C0;
00742             result.R0C1 = cos * matrix.R0C1 + sin * matrix.R1C1;
00743             result.R0C2 = cos * matrix.R0C2 + sin * matrix.R1C2;
00744             result.R1C0 = cos * matrix.R1C0 - sin * matrix.R0C0;
00745             result.R1C1 = cos * matrix.R1C1 - sin * matrix.R0C1;
00746             result.R1C2 = cos * matrix.R1C2 - sin * matrix.R0C2;
00747             result.R2C0 = matrix.R2C0;
00748             result.R2C1 = matrix.R2C1;
00749             result.R2C2 = matrix.R2C2;
00750         }
00751         public static void RotateMatrix(double angle, out Matrix3d result)
00752         {
00753             double angleRadians = Functions.DTOR * angle;
00754             double sin = (double)System.Math.Sin(angleRadians);
00755             double cos = (double)System.Math.Cos(angleRadians);
00756 
00757             result.R0C0 = cos;
00758             result.R0C1 = sin;
00759             result.R0C2 = 0;
00760             result.R1C0 = -sin;
00761             result.R1C1 = cos;
00762             result.R1C2 = 0;
00763             result.R2C0 = 0;
00764             result.R2C1 = 0;
00765             result.R2C2 = 1;
00766         }
00767 
00768         public Quaterniond ToQuaternion()
00769         {
00770             //return new Quaterniond(ref this);
00771         }
00772 
00773         #endregion
00774 
00775         #region Constants
00776 
00778         public static readonly Matrix3d Identity = new Matrix3d
00779         (
00780             1, 0, 0,
00781             0, 1, 0,
00782             0, 0, 1
00783         );
00784 
00786         public static readonly Matrix3d Zero = new Matrix3d
00787         (
00788             0, 0, 0,
00789             0, 0, 0,
00790             0, 0, 0
00791         );
00792 
00793         #endregion
00794 
00795         #region HashCode
00796 
00799         public override int GetHashCode()
00800         {
00801             return
00802                 R0C0.GetHashCode() ^ R0C1.GetHashCode() ^ R0C2.GetHashCode() ^
00803                 R1C0.GetHashCode() ^ R1C1.GetHashCode() ^ R1C2.GetHashCode() ^
00804                 R2C0.GetHashCode() ^ R2C1.GetHashCode() ^ R2C2.GetHashCode();
00805         }
00806 
00807         #endregion
00808 
00809         #region String
00810 
00813         public override string ToString()
00814         {
00815             return String.Format(
00816                 "|{00}, {01}, {02}|\n" +
00817                 "|{03}, {04}, {05}|\n" +
00818                 "|{06}, {07}, {18}|\n" +
00819                 R0C0, R0C1, R0C2,
00820                 R1C0, R1C1, R1C2,
00821                 R2C0, R2C1, R2C2);
00822         }
00823 
00824         #endregion
00825     }
00826 #endif
00827     #pragma warning restore 3019
00828 }