eulerAngles?

#region Assembly SharpDX.dll, v2.6.2.0
// b:\__DIP\dev\_main_dev\EyeOut\EyeOut\packages\SharpDX.2.6.2\Bin\DirectX11-Signed-net40\SharpDX.dll
#endregion

using SharpDX.Serialization;
using System;
using System.Reflection;

namespace SharpDX
{
    // Summary:
    //     Represents a four dimensional mathematical quaternion.
    public struct Quaternion : IEquatable<Quaternion>, IFormattable, IDataSerializable
    {
        // Summary:
        //     The identity SharpDX.Quaternion (0, 0, 0, 1).
        public static readonly Quaternion Identity;
        //
        // Summary:
        //     A SharpDX.Quaternion with all of its components set to one.
        public static readonly Quaternion One;
        //
        // Summary:
        //     The size of the SharpDX.Quaternion type, in bytes.
        public static readonly int SizeInBytes;
        //
        // Summary:
        //     The W component of the quaternion.
        public float W;
        //
        // Summary:
        //     The X component of the quaternion.
        public float X;
        //
        // Summary:
        //     The Y component of the quaternion.
        public float Y;
        //
        // Summary:
        //     The Z component of the quaternion.
        public float Z;
        //
        // Summary:
        //     A SharpDX.Quaternion with all of its components set to zero.
        public static readonly Quaternion Zero;

        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   value:
        //     The value that will be assigned to all components.
        public Quaternion(float value);
        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   values:
        //     The values to assign to the X, Y, Z, and W components of the quaternion.
        //     This must be an array with four elements.
        //
        // Exceptions:
        //   System.ArgumentNullException:
        //     Thrown when values is null.
        //
        //   System.ArgumentOutOfRangeException:
        //     Thrown when values contains more or less than four elements.
        public Quaternion(float[] values);
        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   value:
        //     A vector containing the values with which to initialize the components.
        public Quaternion(Vector4 value);
        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   value:
        //     A vector containing the values with which to initialize the X, Y, and Z components.
        //
        //   w:
        //     Initial value for the W component of the quaternion.
        public Quaternion(Vector3 value, float w);
        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   value:
        //     A vector containing the values with which to initialize the X and Y components.
        //
        //   z:
        //     Initial value for the Z component of the quaternion.
        //
        //   w:
        //     Initial value for the W component of the quaternion.
        public Quaternion(Vector2 value, float z, float w);
        //
        // Summary:
        //     Initializes a new instance of the SharpDX.Quaternion struct.
        //
        // Parameters:
        //   x:
        //     Initial value for the X component of the quaternion.
        //
        //   y:
        //     Initial value for the Y component of the quaternion.
        //
        //   z:
        //     Initial value for the Z component of the quaternion.
        //
        //   w:
        //     Initial value for the W component of the quaternion.
        public Quaternion(float x, float y, float z, float w);

        // Summary:
        //     Reverses the direction of a given quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to negate.
        //
        // Returns:
        //     A quaternion facing in the opposite direction.
        public static Quaternion operator -(Quaternion value);
        //
        // Summary:
        //     Subtracts two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to subtract.
        //
        //   right:
        //     The second quaternion to subtract.
        //
        // Returns:
        //     The difference of the two quaternions.
        public static Quaternion operator -(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Tests for inequality between two objects.
        //
        // Parameters:
        //   left:
        //     The first value to compare.
        //
        //   right:
        //     The second value to compare.
        //
        // Returns:
        //     true if left has a different value than right; otherwise, false.
        public static bool operator !=(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Scales a quaternion by the given value.
        //
        // Parameters:
        //   value:
        //     The quaternion to scale.
        //
        //   scale:
        //     The amount by which to scale the quaternion.
        //
        // Returns:
        //     The scaled quaternion.
        public static Quaternion operator *(float scale, Quaternion value);
        //
        // Summary:
        //     Scales a quaternion by the given value.
        //
        // Parameters:
        //   value:
        //     The quaternion to scale.
        //
        //   scale:
        //     The amount by which to scale the quaternion.
        //
        // Returns:
        //     The scaled quaternion.
        public static Quaternion operator *(Quaternion value, float scale);
        //
        // Summary:
        //     Multiplies a quaternion by another.
        //
        // Parameters:
        //   left:
        //     The first quaternion to multiply.
        //
        //   right:
        //     The second quaternion to multiply.
        //
        // Returns:
        //     The multiplied quaternion.
        public static Quaternion operator *(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Adds two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to add.
        //
        //   right:
        //     The second quaternion to add.
        //
        // Returns:
        //     The sum of the two quaternions.
        public static Quaternion operator +(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Tests for equality between two objects.
        //
        // Parameters:
        //   left:
        //     The first value to compare.
        //
        //   right:
        //     The second value to compare.
        //
        // Returns:
        //     true if left has the same value as right; otherwise, false.
        public static bool operator ==(Quaternion left, Quaternion right);

        // Summary:
        //     Gets the angle of the quaternion.
        public float Angle { get; }
        //
        // Summary:
        //     Gets the axis components of the quaternion.
        public Vector3 Axis { get; }
        //
        // Summary:
        //     Gets a value indicating whether this instance is equivalent to the identity
        //     quaternion.
        public bool IsIdentity { get; }
        //
        // Summary:
        //     Gets a value indicting whether this instance is normalized.
        public bool IsNormalized { get; }

        // Summary:
        //     Gets or sets the component at the specified index.
        //
        // Parameters:
        //   index:
        //     The index of the component to access. Use 0 for the X component, 1 for the
        //     Y component, 2 for the Z component, and 3 for the W component.
        //
        // Returns:
        //     The value of the component at the specified index.
        //
        // Exceptions:
        //   System.ArgumentOutOfRangeException:
        //     Thrown when the index is out of the range [0, 3].
        public float this[int index] { get; set; }

        // Summary:
        //     Adds two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to add.
        //
        //   right:
        //     The second quaternion to add.
        //
        // Returns:
        //     The sum of the two quaternions.
        public static Quaternion Add(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Adds two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to add.
        //
        //   right:
        //     The second quaternion to add.
        //
        //   result:
        //     When the method completes, contains the sum of the two quaternions.
        public static void Add(ref Quaternion left, ref Quaternion right, out Quaternion result);
        //
        // Summary:
        //     Returns a SharpDX.Quaternion containing the 4D Cartesian coordinates of a
        //     point specified in Barycentric coordinates relative to a 2D triangle.
        //
        // Parameters:
        //   value1:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 1
        //     of the triangle.
        //
        //   value2:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 2
        //     of the triangle.
        //
        //   value3:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 3
        //     of the triangle.
        //
        //   amount1:
        //     Barycentric coordinate b2, which expresses the weighting factor toward vertex
        //     2 (specified in value2).
        //
        //   amount2:
        //     Barycentric coordinate b3, which expresses the weighting factor toward vertex
        //     3 (specified in value3).
        //
        // Returns:
        //     A new SharpDX.Quaternion containing the 4D Cartesian coordinates of the specified
        //     point.
        public static Quaternion Barycentric(Quaternion value1, Quaternion value2, Quaternion value3, float amount1, float amount2);
        //
        // Summary:
        //     Returns a SharpDX.Quaternion containing the 4D Cartesian coordinates of a
        //     point specified in Barycentric coordinates relative to a 2D triangle.
        //
        // Parameters:
        //   value1:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 1
        //     of the triangle.
        //
        //   value2:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 2
        //     of the triangle.
        //
        //   value3:
        //     A SharpDX.Quaternion containing the 4D Cartesian coordinates of vertex 3
        //     of the triangle.
        //
        //   amount1:
        //     Barycentric coordinate b2, which expresses the weighting factor toward vertex
        //     2 (specified in value2).
        //
        //   amount2:
        //     Barycentric coordinate b3, which expresses the weighting factor toward vertex
        //     3 (specified in value3).
        //
        //   result:
        //     When the method completes, contains a new SharpDX.Quaternion containing the
        //     4D Cartesian coordinates of the specified point.
        public static void Barycentric(ref Quaternion value1, ref Quaternion value2, ref Quaternion value3, float amount1, float amount2, out Quaternion result);
        //
        // Summary:
        //     Creates a left-handed spherical billboard that rotates around a specified
        //     object position.
        //
        // Parameters:
        //   objectPosition:
        //     The position of the object around which the billboard will rotate.
        //
        //   cameraPosition:
        //     The position of the camera.
        //
        //   cameraUpVector:
        //     The up vector of the camera.
        //
        //   cameraForwardVector:
        //     The forward vector of the camera.
        //
        // Returns:
        //     When the method completes, contains the created billboard quaternion.
        public static Quaternion BillboardLH(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector);
        //
        // Summary:
        //     Creates a left-handed spherical billboard that rotates around a specified
        //     object position.
        //
        // Parameters:
        //   objectPosition:
        //     The position of the object around which the billboard will rotate.
        //
        //   cameraPosition:
        //     The position of the camera.
        //
        //   cameraUpVector:
        //     The up vector of the camera.
        //
        //   cameraForwardVector:
        //     The forward vector of the camera.
        //
        //   result:
        //     When the method completes, contains the created billboard quaternion.
        public static void BillboardLH(ref Vector3 objectPosition, ref Vector3 cameraPosition, ref Vector3 cameraUpVector, ref Vector3 cameraForwardVector, out Quaternion result);
        //
        // Summary:
        //     Creates a left-handed spherical billboard that rotates around a specified
        //     object position.
        //
        // Parameters:
        //   objectPosition:
        //     The position of the object around which the billboard will rotate.
        //
        //   cameraPosition:
        //     The position of the camera.
        //
        //   cameraUpVector:
        //     The up vector of the camera.
        //
        //   cameraForwardVector:
        //     The forward vector of the camera.
        //
        // Returns:
        //     When the method completes, contains the created billboard quaternion.
        public static Quaternion BillboardRH(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Vector3 cameraForwardVector);
        //
        // Summary:
        //     Creates a left-handed spherical billboard that rotates around a specified
        //     object position.
        //
        // Parameters:
        //   objectPosition:
        //     The position of the object around which the billboard will rotate.
        //
        //   cameraPosition:
        //     The position of the camera.
        //
        //   cameraUpVector:
        //     The up vector of the camera.
        //
        //   cameraForwardVector:
        //     The forward vector of the camera.
        //
        //   result:
        //     When the method completes, contains the created billboard quaternion.
        public static void BillboardRH(ref Vector3 objectPosition, ref Vector3 cameraPosition, ref Vector3 cameraUpVector, ref Vector3 cameraForwardVector, out Quaternion result);
        //
        // Summary:
        //     Conjugates the quaternion.
        public void Conjugate();
        //
        // Summary:
        //     Conjugates a quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to conjugate.
        //
        // Returns:
        //     The conjugated quaternion.
        public static Quaternion Conjugate(Quaternion value);
        //
        // Summary:
        //     Conjugates a quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to conjugate.
        //
        //   result:
        //     When the method completes, contains the conjugated quaternion.
        public static void Conjugate(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Calculates the dot product of two quaternions.
        //
        // Parameters:
        //   left:
        //     First source quaternion.
        //
        //   right:
        //     Second source quaternion.
        //
        // Returns:
        //     The dot product of the two quaternions.
        public static float Dot(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Calculates the dot product of two quaternions.
        //
        // Parameters:
        //   left:
        //     First source quaternion.
        //
        //   right:
        //     Second source quaternion.
        //
        //   result:
        //     When the method completes, contains the dot product of the two quaternions.
        public static void Dot(ref Quaternion left, ref Quaternion right, out float result);
        //
        // Summary:
        //     Determines whether the specified System.Object is equal to this instance.
        //
        // Parameters:
        //   value:
        //     The System.Object to compare with this instance.
        //
        // Returns:
        //     true if the specified System.Object is equal to this instance; otherwise,
        //     false.
        public override bool Equals(object value);
        //
        // Summary:
        //     Determines whether the specified SharpDX.Quaternion is equal to this instance.
        //
        // Parameters:
        //   other:
        //     The SharpDX.Quaternion to compare with this instance.
        //
        // Returns:
        //     true if the specified SharpDX.Quaternion is equal to this instance; otherwise,
        //     false.
        public bool Equals(Quaternion other);
        //
        // Summary:
        //     Determines whether the specified SharpDX.Quaternion is equal to this instance.
        //
        // Parameters:
        //   other:
        //     The SharpDX.Quaternion to compare with this instance.
        //
        // Returns:
        //     true if the specified SharpDX.Quaternion is equal to this instance; otherwise,
        //     false.
        public bool Equals(ref Quaternion other);
        //
        // Summary:
        //     Exponentiates a quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to exponentiate.
        //
        // Returns:
        //     The exponentiated quaternion.
        public static Quaternion Exponential(Quaternion value);
        //
        // Summary:
        //     Exponentiates a quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to exponentiate.
        //
        //   result:
        //     When the method completes, contains the exponentiated quaternion.
        public static void Exponential(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Returns a hash code for this instance.
        //
        // Returns:
        //     A hash code for this instance, suitable for use in hashing algorithms and
        //     data structures like a hash table.
        public override int GetHashCode();
        //
        // Summary:
        //     Conjugates and renormalizes the quaternion.
        public void Invert();
        //
        // Summary:
        //     Conjugates and renormalizes the quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to conjugate and renormalize.
        //
        // Returns:
        //     The conjugated and renormalized quaternion.
        public static Quaternion Invert(Quaternion value);
        //
        // Summary:
        //     Conjugates and renormalizes the quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to conjugate and renormalize.
        //
        //   result:
        //     When the method completes, contains the conjugated and renormalized quaternion.
        public static void Invert(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Calculates the length of the quaternion.
        //
        // Returns:
        //     The length of the quaternion.
        //
        // Remarks:
        //     SharpDX.Quaternion.LengthSquared() may be preferred when only the relative
        //     length is needed and speed is of the essence.
        public float Length();
        //
        // Summary:
        //     Calculates the squared length of the quaternion.
        //
        // Returns:
        //     The squared length of the quaternion.
        //
        // Remarks:
        //     This method may be preferred to SharpDX.Quaternion.Length() when only a relative
        //     length is needed and speed is of the essence.
        public float LengthSquared();
        //
        // Summary:
        //     Performs a linear interpolation between two quaternion.
        //
        // Parameters:
        //   start:
        //     Start quaternion.
        //
        //   end:
        //     End quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of end.
        //
        // Returns:
        //     The linear interpolation of the two quaternions.
        //
        // Remarks:
        //     This method performs the linear interpolation based on the following formula.
        //      start + (end - start) * amount Passing amount a value of 0 will cause start
        //     to be returned; a value of 1 will cause end to be returned.
        public static Quaternion Lerp(Quaternion start, Quaternion end, float amount);
        //
        // Summary:
        //     Performs a linear interpolation between two quaternions.
        //
        // Parameters:
        //   start:
        //     Start quaternion.
        //
        //   end:
        //     End quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of end.
        //
        //   result:
        //     When the method completes, contains the linear interpolation of the two quaternions.
        //
        // Remarks:
        //     This method performs the linear interpolation based on the following formula.
        //      start + (end - start) * amount Passing amount a value of 0 will cause start
        //     to be returned; a value of 1 will cause end to be returned.
        public static void Lerp(ref Quaternion start, ref Quaternion end, float amount, out Quaternion result);
        //
        // Summary:
        //     Calculates the natural logarithm of the specified quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion whose logarithm will be calculated.
        //
        // Returns:
        //     The natural logarithm of the quaternion.
        public static Quaternion Logarithm(Quaternion value);
        //
        // Summary:
        //     Calculates the natural logarithm of the specified quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion whose logarithm will be calculated.
        //
        //   result:
        //     When the method completes, contains the natural logarithm of the quaternion.
        public static void Logarithm(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Scales a quaternion by the given value.
        //
        // Parameters:
        //   value:
        //     The quaternion to scale.
        //
        //   scale:
        //     The amount by which to scale the quaternion.
        //
        // Returns:
        //     The scaled quaternion.
        public static Quaternion Multiply(Quaternion value, float scale);
        //
        // Summary:
        //     Multiplies a quaternion by another.
        //
        // Parameters:
        //   left:
        //     The first quaternion to multiply.
        //
        //   right:
        //     The second quaternion to multiply.
        //
        // Returns:
        //     The multiplied quaternion.
        public static Quaternion Multiply(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Scales a quaternion by the given value.
        //
        // Parameters:
        //   value:
        //     The quaternion to scale.
        //
        //   scale:
        //     The amount by which to scale the quaternion.
        //
        //   result:
        //     When the method completes, contains the scaled quaternion.
        public static void Multiply(ref Quaternion value, float scale, out Quaternion result);
        //
        // Summary:
        //     Multiplies a quaternion by another.
        //
        // Parameters:
        //   left:
        //     The first quaternion to multiply.
        //
        //   right:
        //     The second quaternion to multiply.
        //
        //   result:
        //     When the method completes, contains the multiplied quaternion.
        public static void Multiply(ref Quaternion left, ref Quaternion right, out Quaternion result);
        //
        // Summary:
        //     Reverses the direction of a given quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to negate.
        //
        // Returns:
        //     A quaternion facing in the opposite direction.
        public static Quaternion Negate(Quaternion value);
        //
        // Summary:
        //     Reverses the direction of a given quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to negate.
        //
        //   result:
        //     When the method completes, contains a quaternion facing in the opposite direction.
        public static void Negate(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Converts the quaternion into a unit quaternion.
        public void Normalize();
        //
        // Summary:
        //     Converts the quaternion into a unit quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to normalize.
        //
        // Returns:
        //     The normalized quaternion.
        public static Quaternion Normalize(Quaternion value);
        //
        // Summary:
        //     Converts the quaternion into a unit quaternion.
        //
        // Parameters:
        //   value:
        //     The quaternion to normalize.
        //
        //   result:
        //     When the method completes, contains the normalized quaternion.
        public static void Normalize(ref Quaternion value, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given a rotation and an axis.
        //
        // Parameters:
        //   axis:
        //     The axis of rotation.
        //
        //   angle:
        //     The angle of rotation.
        //
        // Returns:
        //     The newly created quaternion.
        public static Quaternion RotationAxis(Vector3 axis, float angle);
        //
        // Summary:
        //     Creates a quaternion given a rotation and an axis.
        //
        // Parameters:
        //   axis:
        //     The axis of rotation.
        //
        //   angle:
        //     The angle of rotation.
        //
        //   result:
        //     When the method completes, contains the newly created quaternion.
        public static void RotationAxis(ref Vector3 axis, float angle, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        //   right:
        //     The right vector of the quaternion
        //
        // Returns:
        //     The newly created quaternion
        public static Quaternion RotationLookAt(Vector3 forward, Vector3 up, Vector3 right);
        //
        // Summary:
        //     Creates a quaternion given forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        //   right:
        //     The right vector of the quaternion (must be perpendicular to forward vector)
        //
        //   result:
        //     The newly created quaternion
        public static void RotationLookAt(ref Vector3 forward, ref Vector3 up, ref Vector3 right, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given left-handed forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        // Returns:
        //     The newly created quaternion
        public static Quaternion RotationLookAtLH(Vector3 forward, Vector3 up);
        //
        // Summary:
        //     Creates a quaternion given left-handed forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        //   result:
        //     The newly created quaternion
        public static void RotationLookAtLH(ref Vector3 forward, ref Vector3 up, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given right-handed forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        // Returns:
        //     The newly created quaternion
        public static Quaternion RotationLookAtRH(Vector3 forward, Vector3 up);
        //
        // Summary:
        //     Creates a quaternion given right-handed forward and up vectors
        //
        // Parameters:
        //   forward:
        //     The forward vector the quaternion should look at
        //
        //   up:
        //     The up vector of the quaternion (must be perpendicular to forward vector)
        //
        //   result:
        //     The newly created quaternion
        public static void RotationLookAtRH(ref Vector3 forward, ref Vector3 up, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given a rotation matrix.
        //
        // Parameters:
        //   matrix:
        //     The rotation matrix.
        //
        // Returns:
        //     The newly created quaternion.
        public static Quaternion RotationMatrix(Matrix matrix);
        //
        // Summary:
        //     Creates a quaternion given a rotation matrix.
        //
        // Parameters:
        //   matrix:
        //     The rotation matrix.
        //
        //   result:
        //     When the method completes, contains the newly created quaternion.
        public static void RotationMatrix(ref Matrix matrix, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given a rotation matrix.
        //
        // Parameters:
        //   matrix:
        //     The rotation matrix.
        //
        //   result:
        //     When the method completes, contains the newly created quaternion.
        public static void RotationMatrix(ref Matrix3x3 matrix, out Quaternion result);
        //
        // Summary:
        //     Creates a quaternion given a yaw, pitch, and roll value.
        //
        // Parameters:
        //   yaw:
        //     The yaw of rotation.
        //
        //   pitch:
        //     The pitch of rotation.
        //
        //   roll:
        //     The roll of rotation.
        //
        // Returns:
        //     The newly created quaternion.
        public static Quaternion RotationYawPitchRoll(float yaw, float pitch, float roll);
        //
        // Summary:
        //     Creates a quaternion given a yaw, pitch, and roll value.
        //
        // Parameters:
        //   yaw:
        //     The yaw of rotation.
        //
        //   pitch:
        //     The pitch of rotation.
        //
        //   roll:
        //     The roll of rotation.
        //
        //   result:
        //     When the method completes, contains the newly created quaternion.
        public static void RotationYawPitchRoll(float yaw, float pitch, float roll, out Quaternion result);
        //
        // Summary:
        //     Interpolates between two quaternions, using spherical linear interpolation.
        //
        // Parameters:
        //   start:
        //     Start quaternion.
        //
        //   end:
        //     End quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of end.
        //
        // Returns:
        //     The spherical linear interpolation of the two quaternions.
        public static Quaternion Slerp(Quaternion start, Quaternion end, float amount);
        //
        // Summary:
        //     Interpolates between two quaternions, using spherical linear interpolation.
        //
        // Parameters:
        //   start:
        //     Start quaternion.
        //
        //   end:
        //     End quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of end.
        //
        //   result:
        //     When the method completes, contains the spherical linear interpolation of
        //     the two quaternions.
        public static void Slerp(ref Quaternion start, ref Quaternion end, float amount, out Quaternion result);
        //
        // Summary:
        //     Interpolates between quaternions, using spherical quadrangle interpolation.
        //
        // Parameters:
        //   value1:
        //     First source quaternion.
        //
        //   value2:
        //     Second source quaternion.
        //
        //   value3:
        //     Third source quaternion.
        //
        //   value4:
        //     Fourth source quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of interpolation.
        //
        // Returns:
        //     The spherical quadrangle interpolation of the quaternions.
        public static Quaternion Squad(Quaternion value1, Quaternion value2, Quaternion value3, Quaternion value4, float amount);
        //
        // Summary:
        //     Interpolates between quaternions, using spherical quadrangle interpolation.
        //
        // Parameters:
        //   value1:
        //     First source quaternion.
        //
        //   value2:
        //     Second source quaternion.
        //
        //   value3:
        //     Third source quaternion.
        //
        //   value4:
        //     Fourth source quaternion.
        //
        //   amount:
        //     Value between 0 and 1 indicating the weight of interpolation.
        //
        //   result:
        //     When the method completes, contains the spherical quadrangle interpolation
        //     of the quaternions.
        public static void Squad(ref Quaternion value1, ref Quaternion value2, ref Quaternion value3, ref Quaternion value4, float amount, out Quaternion result);
        //
        // Summary:
        //     Sets up control points for spherical quadrangle interpolation.
        //
        // Parameters:
        //   value1:
        //     First source quaternion.
        //
        //   value2:
        //     Second source quaternion.
        //
        //   value3:
        //     Third source quaternion.
        //
        //   value4:
        //     Fourth source quaternion.
        //
        // Returns:
        //     An array of three quaternions that represent control points for spherical
        //     quadrangle interpolation.
        public static Quaternion[] SquadSetup(Quaternion value1, Quaternion value2, Quaternion value3, Quaternion value4);
        //
        // Summary:
        //     Subtracts two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to subtract.
        //
        //   right:
        //     The second quaternion to subtract.
        //
        // Returns:
        //     The difference of the two quaternions.
        public static Quaternion Subtract(Quaternion left, Quaternion right);
        //
        // Summary:
        //     Subtracts two quaternions.
        //
        // Parameters:
        //   left:
        //     The first quaternion to subtract.
        //
        //   right:
        //     The second quaternion to subtract.
        //
        //   result:
        //     When the method completes, contains the difference of the two quaternions.
        public static void Subtract(ref Quaternion left, ref Quaternion right, out Quaternion result);
        //
        // Summary:
        //     Creates an array containing the elements of the quaternion.
        //
        // Returns:
        //     A four-element array containing the components of the quaternion.
        public float[] ToArray();
        //
        // Summary:
        //     Returns a System.String that represents this instance.
        //
        // Returns:
        //     A System.String that represents this instance.
        public override string ToString();
        //
        // Summary:
        //     Returns a System.String that represents this instance.
        //
        // Parameters:
        //   formatProvider:
        //     The format provider.
        //
        // Returns:
        //     A System.String that represents this instance.
        public string ToString(IFormatProvider formatProvider);
        //
        // Summary:
        //     Returns a System.String that represents this instance.
        //
        // Parameters:
        //   format:
        //     The format.
        //
        // Returns:
        //     A System.String that represents this instance.
        public string ToString(string format);
        //
        // Summary:
        //     Returns a System.String that represents this instance.
        //
        // Parameters:
        //   format:
        //     The format.
        //
        //   formatProvider:
        //     The format provider.
        //
        // Returns:
        //     A System.String that represents this instance.
        public string ToString(string format, IFormatProvider formatProvider);
    }
}