From e57729bf120329e6139000d8ae3bd98759186b96 Mon Sep 17 00:00:00 2001
From: "SND\\xToast_cp" <SND\xToast_cp@7a4bfd9b-e295-4cbd-a51f-ab472bcf69b7>
Date: Tue, 8 Nov 2011 20:07:44 +0000
Subject: [PATCH] Structs from Anx.Framework namespace are now reported as
 complete by ANXStatusComparer. They are not yet implemented.

---
 ANX.Framework/Quaternion.cs | 223 +++++++++++++++++++++++++++++++++++-
 ANX.Framework/Vector2.cs    |  41 ++++++-
 ANX.Framework/Vector3.cs    |  69 +++++++++--
 3 files changed, 312 insertions(+), 21 deletions(-)

diff --git a/ANX.Framework/Quaternion.cs b/ANX.Framework/Quaternion.cs
index d06ccd5b..8ed6f1b0 100644
--- a/ANX.Framework/Quaternion.cs
+++ b/ANX.Framework/Quaternion.cs
@@ -92,14 +92,194 @@ namespace ANX.Framework
 
 
         #region public methods
+        public static Quaternion Add(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Add(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Concatenate(Quaternion value1, Quaternion value2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Concatenate(ref Quaternion value1, ref Quaternion value2, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Conjugate()
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Conjugate(Quaternion value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Conjugate(ref Quaternion value, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void CreateFromAxisAngle(ref Vector3 axis, float angle, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion CreateFromRotationMatrix(Matrix matrix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void CreateFromRotationMatrix(ref Matrix matrix, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion CreateFromYawPitchRoll(float yaw, float pitch, float roll)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void CreateFromYawPitchRoll(float yaw, float pitch, float roll, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Divide(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Divide(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, out float result)
+        {
+            throw new NotImplementedException();
+        }
+
         public override int GetHashCode()
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Inverse(Quaternion quaternion)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Inverse(ref Quaternion quaternion, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public float Length()
+        {
+            throw new NotImplementedException();
+        }
+
+        public float LengthSquared()
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Lerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Multiply(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Multiply(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Multiply(Quaternion quaternion1, float scaleFactor)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Multiply(ref Quaternion quaternion1, float scaleFactor, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Negate(Quaternion quaternion)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Negate(ref Quaternion quaternion, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Normalize()
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Normalize(Quaternion quaternion)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Normalize(ref Quaternion quaternion, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, float amount)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Slerp(ref Quaternion quaternion1, ref Quaternion quaternion2, float amount, out Quaternion result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion Subtract(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Subtract(ref Quaternion quaternion1, ref Quaternion quaternion2, out Quaternion result)
+        {
+            throw new NotImplementedException();
         }
 
         public override string ToString()
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         #endregion
 
@@ -115,9 +295,46 @@ namespace ANX.Framework
         }
         #endregion
 
-
         #region operator overloading
+        public static Quaternion operator +(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
 
+        public static Quaternion operator /(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static bool operator ==(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static bool operator !=(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion operator *(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion operator *(Quaternion quaternion1, float scaleFactor)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion operator -(Quaternion quaternion1, Quaternion quaternion2)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Quaternion operator -(Quaternion quaternion)
+        {
+            throw new NotImplementedException();
+        }
         #endregion
     }
 }
diff --git a/ANX.Framework/Vector2.cs b/ANX.Framework/Vector2.cs
index 1a313a73..6aeea1b4 100644
--- a/ANX.Framework/Vector2.cs
+++ b/ANX.Framework/Vector2.cs
@@ -430,27 +430,56 @@ namespace ANX.Framework
 
         public static Vector2 Transform(Vector2 value, Quaternion rotation)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         public static void Transform(ref Vector2 value, ref Quaternion rotation, out Vector2 result)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Matrix matrix, Vector2[] destinationArray, int destinationIndex, int length)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector2[] destinationArray, int destinationIndex, int length)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         public static void Transform(Vector2[] sourceArray, ref Matrix matrix, Vector2[] destinationArray)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
         }
         public static void Transform(Vector2[] sourceArray, ref Quaternion rotation, Vector2[] destinationArray)
         {
-            throw new Exception("method has not yet been implemented");
+            throw new NotImplementedException();
+        }
+
+        public static Vector2 TransformNormal(Vector2 normal, Matrix matrix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(ref Vector2 normal, ref Matrix matrix, out Vector2 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(
+            Vector2[] sourceArray, 
+            int sourceIndex, 
+            ref Matrix matrix,
+            Vector2[] destinationArray,
+            int destinationIndex,
+            int length)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(
+            Vector2[] sourceArray,
+            ref Matrix matrix,
+            Vector2[] destinationArray)
+        {
+            throw new NotImplementedException();
         }
         #endregion
 
diff --git a/ANX.Framework/Vector3.cs b/ANX.Framework/Vector3.cs
index eef2994a..1d7a3bcb 100644
--- a/ANX.Framework/Vector3.cs
+++ b/ANX.Framework/Vector3.cs
@@ -507,20 +507,65 @@ namespace ANX.Framework
 
 
         #region Transformations
+        public static Vector3 Transform(Vector3 position, Matrix matrix)
+        {
+            throw new NotImplementedException();
+        }
 
-        //public static Vector3 Transform(Vector3 position, Matrix matrix);
-        //public static Vector3 Transform(Vector3 value, Quaternion rotation);
-        //public static void Transform(ref Vector3 position, ref Matrix matrix, out Vector3 result);
-        //public static void Transform(ref Vector3 value, ref Quaternion rotation, out Vector3 result);
-        //public static void Transform(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray);
-        //public static void Transform(Vector3[] sourceArray, ref Quaternion rotation, Vector3[] destinationArray);
-        //public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Vector3[] destinationArray, int destinationIndex, int length);
-        //public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector3[] destinationArray, int destinationIndex, int length);
-        //public static Vector3 TransformNormal(Vector3 normal, Matrix matrix);
-        //public static void TransformNormal(ref Vector3 normal, ref Matrix matrix, out Vector3 result);
-        //public static void TransformNormal(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray);
-        //public static void TransformNormal(Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Vector3[] destinationArray, int destinationIndex, int length);
+        public static Vector3 Transform(Vector3 value, Quaternion rotation)
+        {
+            throw new NotImplementedException();
+        }
 
+        public static void Transform(ref Vector3 position, ref Matrix matrix, out Vector3 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Transform(ref Vector3 value, ref Quaternion rotation, out Vector3 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Transform(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Transform(Vector3[] sourceArray, ref Quaternion rotation, Vector3[] destinationArray)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Vector3[] destinationArray, int destinationIndex, int length)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void Transform(Vector3[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector3[] destinationArray, int destinationIndex, int length)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static Vector3 TransformNormal(Vector3 normal, Matrix matrix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(ref Vector3 normal, ref Matrix matrix, out Vector3 result)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(Vector3[] sourceArray, ref Matrix matrix, Vector3[] destinationArray)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void TransformNormal(Vector3[] sourceArray, int sourceIndex, ref Matrix matrix, Vector3[] destinationArray, int destinationIndex, int length)
+        {
+            throw new NotImplementedException();
+        }
         #endregion
 
         #endregion