Matrix3D.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Core / System / Windows / Media3D / Generated / Matrix3D.cs / 1 / Matrix3D.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// This file was generated, please do not edit it directly. 
// 
// Please see [....]/default.aspx/Microsoft.Projects.Avalon/MilCodeGen.html for more information.
// 
//---------------------------------------------------------------------------

using MS.Internal;
using MS.Internal.Collections; 
using MS.Internal.PresentationCore;
using MS.Utility; 
using System; 
using System.Collections;
using System.Collections.Generic; 
using System.ComponentModel;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization; 
using System.Reflection;
using System.Runtime.InteropServices; 
using System.Text; 
using System.Windows.Markup;
using System.Windows.Media.Media3D.Converters; 
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Composition;
using System.Security; 
using System.Security.Permissions;
using SR=MS.Internal.PresentationCore.SR; 
using SRID=MS.Internal.PresentationCore.SRID; 
using System.Windows.Media.Imaging;
// These types are aliased to match the unamanaged names used in interop 
using BOOL = System.UInt32;
using WORD = System.UInt16;
using Float = System.Single;
 
namespace System.Windows.Media.Media3D
{ 
 

    [Serializable] 
    [TypeConverter(typeof(Matrix3DConverter))]
    [ValueSerializer(typeof(Matrix3DValueSerializer))] // Used by MarkupWriter
    partial struct Matrix3D : IFormattable
    { 
        #region Constructors
 
        //----------------------------------------------------- 
        //
        //  Constructors 
        //
        //-----------------------------------------------------

 

 
        #endregion Constructors 

        //------------------------------------------------------ 
        //
        //  Public Methods
        //
        //----------------------------------------------------- 

        #region Public Methods 
 

 

        /// 
        /// Compares two Matrix3D instances for exact equality.
        /// Note that double values can acquire error when operated upon, such that 
        /// an exact comparison between two values which are logically equal may fail.
        /// Furthermore, using this equality operator, Double.NaN is not equal to itself. 
        ///  
        /// 
        /// bool - true if the two Matrix3D instances are exactly equal, false otherwise 
        /// 
        /// The first Matrix3D to compare
        /// The second Matrix3D to compare
        public static bool operator == (Matrix3D matrix1, Matrix3D matrix2) 
        {
            if (matrix1.IsDistinguishedIdentity || matrix2.IsDistinguishedIdentity) 
            { 
                return matrix1.IsIdentity == matrix2.IsIdentity;
            } 
            else
            {
                return matrix1.M11 == matrix2.M11 &&
                       matrix1.M12 == matrix2.M12 && 
                       matrix1.M13 == matrix2.M13 &&
                       matrix1.M14 == matrix2.M14 && 
                       matrix1.M21 == matrix2.M21 && 
                       matrix1.M22 == matrix2.M22 &&
                       matrix1.M23 == matrix2.M23 && 
                       matrix1.M24 == matrix2.M24 &&
                       matrix1.M31 == matrix2.M31 &&
                       matrix1.M32 == matrix2.M32 &&
                       matrix1.M33 == matrix2.M33 && 
                       matrix1.M34 == matrix2.M34 &&
                       matrix1.OffsetX == matrix2.OffsetX && 
                       matrix1.OffsetY == matrix2.OffsetY && 
                       matrix1.OffsetZ == matrix2.OffsetZ &&
                       matrix1.M44 == matrix2.M44; 
            }
        }

        ///  
        /// Compares two Matrix3D instances for exact inequality.
        /// Note that double values can acquire error when operated upon, such that 
        /// an exact comparison between two values which are logically equal may fail. 
        /// Furthermore, using this equality operator, Double.NaN is not equal to itself.
        ///  
        /// 
        /// bool - true if the two Matrix3D instances are exactly unequal, false otherwise
        /// 
        /// The first Matrix3D to compare 
        /// The second Matrix3D to compare
        public static bool operator != (Matrix3D matrix1, Matrix3D matrix2) 
        { 
            return !(matrix1 == matrix2);
        } 
        /// 
        /// Compares two Matrix3D instances for object equality.  In this equality
        /// Double.NaN is equal to itself, unlike in numeric equality.
        /// Note that double values can acquire error when operated upon, such that 
        /// an exact comparison between two values which
        /// are logically equal may fail. 
        ///  
        /// 
        /// bool - true if the two Matrix3D instances are exactly equal, false otherwise 
        /// 
        /// The first Matrix3D to compare
        /// The second Matrix3D to compare
        public static bool Equals (Matrix3D matrix1, Matrix3D matrix2) 
        {
            if (matrix1.IsDistinguishedIdentity || matrix2.IsDistinguishedIdentity) 
            { 
                return matrix1.IsIdentity == matrix2.IsIdentity;
            } 
            else
            {
                return matrix1.M11.Equals(matrix2.M11) &&
                       matrix1.M12.Equals(matrix2.M12) && 
                       matrix1.M13.Equals(matrix2.M13) &&
                       matrix1.M14.Equals(matrix2.M14) && 
                       matrix1.M21.Equals(matrix2.M21) && 
                       matrix1.M22.Equals(matrix2.M22) &&
                       matrix1.M23.Equals(matrix2.M23) && 
                       matrix1.M24.Equals(matrix2.M24) &&
                       matrix1.M31.Equals(matrix2.M31) &&
                       matrix1.M32.Equals(matrix2.M32) &&
                       matrix1.M33.Equals(matrix2.M33) && 
                       matrix1.M34.Equals(matrix2.M34) &&
                       matrix1.OffsetX.Equals(matrix2.OffsetX) && 
                       matrix1.OffsetY.Equals(matrix2.OffsetY) && 
                       matrix1.OffsetZ.Equals(matrix2.OffsetZ) &&
                       matrix1.M44.Equals(matrix2.M44); 
            }
        }

        ///  
        /// Equals - compares this Matrix3D with the passed in object.  In this equality
        /// Double.NaN is equal to itself, unlike in numeric equality. 
        /// Note that double values can acquire error when operated upon, such that 
        /// an exact comparison between two values which
        /// are logically equal may fail. 
        /// 
        /// 
        /// bool - true if the object is an instance of Matrix3D and if it's equal to "this".
        ///  
        /// The object to compare to "this"
        public override bool Equals(object o) 
        { 
            if ((null == o) || !(o is Matrix3D))
            { 
                return false;
            }

            Matrix3D value = (Matrix3D)o; 
            return Matrix3D.Equals(this,value);
        } 
 
        /// 
        /// Equals - compares this Matrix3D with the passed in object.  In this equality 
        /// Double.NaN is equal to itself, unlike in numeric equality.
        /// Note that double values can acquire error when operated upon, such that
        /// an exact comparison between two values which
        /// are logically equal may fail. 
        /// 
        ///  
        /// bool - true if "value" is equal to "this". 
        /// 
        /// The Matrix3D to compare to "this" 
        public bool Equals(Matrix3D value)
        {
            return Matrix3D.Equals(this, value);
        } 
        /// 
        /// Returns the HashCode for this Matrix3D 
        ///  
        /// 
        /// int - the HashCode for this Matrix3D 
        /// 
        public override int GetHashCode()
        {
            if (IsDistinguishedIdentity) 
            {
                return c_identityHashCode; 
            } 
            else
            { 
                // Perform field-by-field XOR of HashCodes
                return M11.GetHashCode() ^
                       M12.GetHashCode() ^
                       M13.GetHashCode() ^ 
                       M14.GetHashCode() ^
                       M21.GetHashCode() ^ 
                       M22.GetHashCode() ^ 
                       M23.GetHashCode() ^
                       M24.GetHashCode() ^ 
                       M31.GetHashCode() ^
                       M32.GetHashCode() ^
                       M33.GetHashCode() ^
                       M34.GetHashCode() ^ 
                       OffsetX.GetHashCode() ^
                       OffsetY.GetHashCode() ^ 
                       OffsetZ.GetHashCode() ^ 
                       M44.GetHashCode();
            } 
        }

        /// 
        /// Parse - returns an instance converted from the provided string using 
        /// the culture "en-US"
        ///  string with Matrix3D data  
        ///  
        public static Matrix3D Parse(string source)
        { 
            IFormatProvider formatProvider = CultureInfo.GetCultureInfo("en-us");

            TokenizerHelper th = new TokenizerHelper(source, formatProvider);
 
            Matrix3D value;
 
            String firstToken = th.NextTokenRequired(); 

            // The token will already have had whitespace trimmed so we can do a 
            // simple string compare.
            if (firstToken == "Identity")
            {
                value = Identity; 
            }
            else 
            { 
                value = new Matrix3D(
                    Convert.ToDouble(firstToken, formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider), 
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider),
                    Convert.ToDouble(th.NextTokenRequired(), formatProvider)); 
            } 

            // There should be no more tokens in this string. 
            th.LastTokenRequired();

            return value;
        } 

        #endregion Public Methods 
 
        //------------------------------------------------------
        // 
        //  Public Properties
        //
        //------------------------------------------------------
 

 
 
        #region Public Properties
 


        #endregion Public Properties
 
        //-----------------------------------------------------
        // 
        //  Protected Methods 
        //
        //------------------------------------------------------ 

        #region Protected Methods

 

 
 
        #endregion ProtectedMethods
 
        //-----------------------------------------------------
        //
        //  Internal Methods
        // 
        //-----------------------------------------------------
 
        #region Internal Methods 

 



 

 
 
        #endregion Internal Methods
 
        //-----------------------------------------------------
        //
        //  Internal Properties
        // 
        //------------------------------------------------------
 
        #region Internal Properties 

 
        /// 
        /// Creates a string representation of this object based on the current culture.
        /// 
        ///  
        /// A string representation of this object.
        ///  
        public override string ToString() 
        {
 
            // Delegate to the internal method which implements all ToString calls.
            return ConvertToString(null /* format string */, null /* format provider */);
        }
 
        /// 
        /// Creates a string representation of this object based on the IFormatProvider 
        /// passed in.  If the provider is null, the CurrentCulture is used. 
        /// 
        ///  
        /// A string representation of this object.
        /// 
        public string ToString(IFormatProvider provider)
        { 

            // Delegate to the internal method which implements all ToString calls. 
            return ConvertToString(null /* format string */, provider); 
        }
 
        /// 
        /// Creates a string representation of this object based on the format string
        /// and IFormatProvider passed in.
        /// If the provider is null, the CurrentCulture is used. 
        /// See the documentation for IFormattable for more information.
        ///  
        ///  
        /// A string representation of this object.
        ///  
        string IFormattable.ToString(string format, IFormatProvider provider)
        {

            // Delegate to the internal method which implements all ToString calls. 
            return ConvertToString(format, provider);
        } 
 
        /// 
        /// Creates a string representation of this object based on the format string 
        /// and IFormatProvider passed in.
        /// If the provider is null, the CurrentCulture is used.
        /// See the documentation for IFormattable for more information.
        ///  
        /// 
        /// A string representation of this object. 
        ///  
        internal string ConvertToString(string format, IFormatProvider provider)
        { 
            if (IsIdentity)
            {
                return "Identity";
            } 

            // Helper to get the numeric list separator for a given culture. 
            char separator = MS.Internal.TokenizerHelper.GetNumericListSeparator(provider); 
            return String.Format(provider,
                                 "{1:" + format + "}{0}{2:" + format + "}{0}{3:" + format + "}{0}{4:" + format + "}{0}{5:" + format + "}{0}{6:" + format + "}{0}{7:" + format + "}{0}{8:" + format + "}{0}{9:" + format + "}{0}{10:" + format + "}{0}{11:" + format + "}{0}{12:" + format + "}{0}{13:" + format + "}{0}{14:" + format + "}{0}{15:" + format + "}{0}{16:" + format + "}", 
                                 separator,
                                 _m11,
                                 _m12,
                                 _m13, 
                                 _m14,
                                 _m21, 
                                 _m22, 
                                 _m23,
                                 _m24, 
                                 _m31,
                                 _m32,
                                 _m33,
                                 _m34, 
                                 _offsetX,
                                 _offsetY, 
                                 _offsetZ, 
                                 _m44);
        } 



        #endregion Internal Properties 

        //----------------------------------------------------- 
        // 
        //  Dependency Properties
        // 
        //------------------------------------------------------

        #region Dependency Properties
 

 
        #endregion Dependency Properties 

        //------------------------------------------------------ 
        //
        //  Internal Fields
        //
        //----------------------------------------------------- 

        #region Internal Fields 
 

 



 
        #endregion Internal Fields
 
 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK