Author: dhudson
Date: 2006-11-15 17:28:38 -0500 (Wed, 15 Nov 2006)
New Revision: 67956
Modified:
trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector2.cs
trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector3.cs
trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector4.cs
Log:
stubbed out vectors
Modified: trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector2.cs
===================================================================
--- trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector2.cs 2006-11-15
22:21:52 UTC (rev 67955)
+++ trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector2.cs 2006-11-15
22:28:38 UTC (rev 67956)
@@ -123,9 +123,13 @@
{
Vector2 vector1 = value1 - value2;
return vector1.Length();
- }
+ }
+ public static void Distance(ref Vector2 value1, ref Vector2 value2,
out float result)
+ {
+ throw new NotImplementedException();
+ }
+
-
/// <summary>Calculates the distance between two vectors
squared.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -134,9 +138,13 @@
{
Vector2 vector1 = value1 - value2;
return vector1.LengthSquared();
- }
+ }
+ public static void DistanceSquared(ref Vector2 value1, ref Vector2
value2, out float result)
+ {
+ throw new NotImplementedException();
+ }
+
-
/// <summary>Calculates the dot product of two vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -144,17 +152,24 @@
public static float Dot(Vector2 value1, Vector2 value2)
{
return ((value1.X * value2.X) + (value1.Y * value2.Y));
- }
-
+ }
+ public static void Dot(ref Vector2 value1, ref Vector2 value2, out
float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Creates a unit vector from the specified vector.</summary>
/// <param name="value">Source Vector2.</param>
/// <returns>The created unit vector.</returns>
public static Vector2 Normalize(Vector2 value)
{
return (Vector2)(value / value.Length());
- }
-
-
+ }
+ public static void Normalize(ref Vector2 value, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Creates a unit vector from the specified vector.</summary>
public void Normalize()
{
@@ -171,8 +186,12 @@
public static Vector2 Min(Vector2 value1, Vector2 value2)
{
return new Vector2(Math.Min(value1.X, value2.X),
Math.Min(value1.Y, value2.Y));
- }
-
+ }
+ public static void Min(ref Vector2 value1, ref Vector2 value2, out
Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector that contains the highest value from
each matching pair of components.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -180,9 +199,13 @@
public static Vector2 Max(Vector2 value1, Vector2 value2)
{
return new Vector2(Math.Max(value1.X, value2.X),
Math.Max(value1.Y, value2.Y));
- }
+ }
+ public static void Max(ref Vector2 value1, ref Vector2 value2, out
Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
-
/// <summary>Restricts a value to be within a specified
range.</summary>
/// <param name="value1">The value to clamp.</param>
/// <param name="min">The minimum value.</param>
@@ -191,8 +214,12 @@
public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max)
{
return new Vector2(MathHelper.Clamp(value1.X, min.X, max.X),
MathHelper.Clamp(value1.Y, min.Y, max.Y));
- }
-
+ }
+ public static void Clamp(ref Vector2 value1, ref Vector2 min, ref
Vector2 max, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a linear interpolation between two
vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -201,7 +228,12 @@
public static Vector2 Lerp(Vector2 value1, Vector2 value2, float
amount)
{
return new Vector2(value1.X + ((value2.X - value1.X) * amount),
value1.Y + ((value2.Y - value1.Y) * amount));
- }
+ }
+ public static void Lerp(ref Vector2 value1, ref Vector2 value2, float
amount, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a point in Barycentric coordinates, using the
specified values.</summary>
/// <param name="value1">One point making up a triangle.</param>
@@ -228,8 +260,12 @@
{
amount = MathHelper.Clamp(amount, 0f, 1f);
return Vector2.Lerp(value1, value2, (amount * amount) * (3f - (2f
* amount)));
- }
-
+ }
+ public static void SmoothStep(ref Vector2 value1, ref Vector2 value2,
float amount, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Catmull-Rom interpolation using the specified
positions.</summary>
/// <param name="value1">The first position in the
interpolation.</param>
/// <param name="value2">The second position in the
interpolation.</param>
@@ -242,8 +278,12 @@
float single1 = amount * amount;
float single2 = amount * single1;
return (Vector2)(0.5f * ((((2f * value2) + ((-value1) + value3) *
amount)) + (((((2f * value1) - (5f * value2)) + (4f * value3)) - value4) *
single1)) + ((((-value1) + (3f * value2)) - (3f * value3)) + value4) * single2);
- }
-
+ }
+ public static void CatmullRom(ref Vector2 value1, ref Vector2 value2,
ref Vector2 value3, ref Vector2 value4, float amount, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Hermite spline interpolation.</summary>
/// <param name="value1">Source position vector.</param>
/// <param name="tangent1">Source tangent vector.</param>
@@ -260,7 +300,12 @@
float single4 = (single2 - (2f * single1)) + amount;
float single3 = single2 - single1;
return (Vector2)((((value1 * single6) + (value2 * single5)) +
(tangent1 * single4)) + (tangent2 * single3));
- }
+ }
+ public static void Hermite(ref Vector2 value1, ref Vector2 tangent1,
ref Vector2 value2, ref Vector2 tangent2, float amount, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Transforms the vector (x, y, 0, 1) by the specified
matrix.</summary>
/// <param name="position">The source vector.</param>
/// <param name="matrix">The transformation matrix.</param>
@@ -268,7 +313,12 @@
public static Vector2 Transform(Vector2 position, Matrix matrix)
{
return new Vector2(((position.X * matrix.M11) + (position.Y *
matrix.M21)) + matrix.M41, ((position.X * matrix.M12) + (position.Y *
matrix.M22)) + matrix.M42);
- }
+ }
+ public static void Transform(ref Vector2 position, ref Matrix matrix,
out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Transforms a 2D vector normal by a matrix.</summary>
/// <param name="normal">The source vector.</param>
/// <param name="matrix">The transformation matrix.</param>
@@ -276,8 +326,12 @@
public static Vector2 TransformNormal(Vector2 normal, Matrix matrix)
{
return new Vector2((normal.X * matrix.M11) + (normal.Y *
matrix.M21), (normal.X * matrix.M12) + (normal.Y * matrix.M22));
- }
-
+ }
+ public static void TransformNormal(ref Vector2 normal, ref Matrix
matrix, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
/// <param name="value">Source vector.</param>
/// <returns>Vector pointing in the opposite direction.</returns>
@@ -286,7 +340,12 @@
value.X *= -1f;
value.Y *= -1f;
return value;
- }
+ }
+ public static void Negate(ref Vector2 value, out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Adds two vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -311,7 +370,12 @@
value1.X -= value2.X;
value1.Y -= value2.Y;
return value1;
- }
+ }
+ public static void Subtract(ref Vector2 value1, ref Vector2 value2,
out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Multiplies the components of two vectors by each
other.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -331,7 +395,17 @@
value1.X *= scaleFactor;
value1.Y *= scaleFactor;
return value1;
- }
+ }
+ public static void Multiply(ref Vector2 value1, float scaleFactor, out
Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static void Multiply(ref Vector2 value1, ref Vector2 value2,
out Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Divides the components of a vector by the components of
another vector.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Divisor vector.</param>
@@ -351,7 +425,17 @@
value1.X /= divider;
value1.Y /= divider;
return value1;
- }
+ }
+ public static void Divide(ref Vector2 value1, float divider, out
Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static void Divide(ref Vector2 value1, ref Vector2 value2, out
Vector2 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
/// <param name="value">Source vector.</param>
/// <returns>Vector pointing in the opposite direction.</returns>
Modified: trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector3.cs
===================================================================
--- trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector3.cs 2006-11-15
22:21:52 UTC (rev 67955)
+++ trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector3.cs 2006-11-15
22:28:38 UTC (rev 67956)
@@ -178,7 +178,12 @@
{
Vector3 vector1 = value1 - value2;
return vector1.Length();
- }
+ }
+ public static void Distance(ref Vector3 value1, ref Vector3 value2,
out float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Calculates the distance between two vectors
squared.</summary>
/// <param name="value1">Source vector.</param>
@@ -188,7 +193,12 @@
{
Vector3 vector1 = value1 - value2;
return vector1.LengthSquared();
- }
+ }
+ public static void DistanceSquared(ref Vector3 value1, ref Vector3
value2, out float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Calculates the dot product of two vectors.</summary>
/// <param name="vector1">Source vector.</param>
/// <param name="vector2">Source vector.</param>
@@ -196,8 +206,12 @@
public static float Dot(Vector3 vector1, Vector3 vector2)
{
return (((vector1.X * vector2.X) + (vector1.Y * vector2.Y)) +
(vector1.Z * vector2.Z));
- }
-
+ }
+ public static void Dot(ref Vector3 vector1, ref Vector3 vector2, out
float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Creates a unit vector from the specified vector.</summary>
public void Normalize()
{
@@ -205,7 +219,12 @@
this.X *= single1;
this.Y *= single1;
this.Z *= single1;
- }
+ }
+ public static void Normalize(ref Vector3 value, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Creates a unit vector from the specified vector.</summary>
/// <param name="vector">The source Vector3.</param>
@@ -222,9 +241,13 @@
public static Vector3 Cross(Vector3 vector1, Vector3 vector2)
{
return new Vector3((vector1.Y * vector2.Z) - (vector1.Z *
vector2.Y), (vector1.Z * vector2.X) - (vector1.X * vector2.Z), (vector1.X *
vector2.Y) - (vector1.Y * vector2.X));
- }
+ }
+ public static void Cross(ref Vector3 vector1, ref Vector3 vector2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
-
/// <summary>Returns the reflect vector of a vector and a
normal.</summary>
/// <param name="vector">Source vector.</param>
/// <param name="normal">Source normal.</param>
@@ -232,7 +255,12 @@
public static Vector3 Reflect(Vector3 vector, Vector3 normal)
{
return (vector - ((Vector3)((2f * Vector3.Dot(vector, normal)) *
normal)));
- }
+ }
+ public static void Reflect(ref Vector3 vector, ref Vector3 normal, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector that contains the lowest value from each
matching pair of components.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -240,8 +268,12 @@
public static Vector3 Min(Vector3 value1, Vector3 value2)
{
return new Vector3(Math.Min(value1.X, value2.X),
Math.Min(value1.Y, value2.Y), Math.Min(value1.Z, value2.Z));
- }
-
+ }
+ public static void Min(ref Vector3 value1, ref Vector3 value2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector that contains the highest value from
each matching pair of components.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -249,8 +281,12 @@
public static Vector3 Max(Vector3 value1, Vector3 value2)
{
return new Vector3(Math.Max(value1.X, value2.X),
Math.Max(value1.Y, value2.Y), Math.Max(value1.Z, value2.Z));
- }
-
+ }
+ public static void Max(ref Vector3 value1, ref Vector3 value2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Restricts a value to be within a specified
range.</summary>
/// <param name="value">The value to clamp.</param>
/// <param name="min">The minimum value.</param>
@@ -259,7 +295,13 @@
public static Vector3 Clamp(Vector3 value, Vector3 min, Vector3 max)
{
return new Vector3(MathHelper.Clamp(value.X, min.X, max.X),
MathHelper.Clamp(value.Y, min.Y, max.Y), MathHelper.Clamp(value.Z, min.Z,
max.Z));
- }
+ }
+
+ public static void Clamp(ref Vector3 value1, ref Vector3 min, ref
Vector3 max, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a linear interpolation between two
vectors.</summary>
/// <param name="value1">Source vector.</param>
@@ -269,8 +311,12 @@
public static Vector3 Lerp(Vector3 value1, Vector3 value2, float
amount)
{
return new Vector3(value1.X + ((value2.X - value1.X) * amount),
value1.Y + ((value2.Y - value1.Y) * amount), value1.Z + ((value2.Z - value1.Z)
* amount));
- }
-
+ }
+ public static void Lerp(ref Vector3 value1, ref Vector3 value2, float
amount, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a point in barycentric coordinates, using the
specified values.</summary>
/// <param name="value1">One point making up a triangle.</param>
/// <param name="value2">One point making up a triangle.</param>
@@ -281,7 +327,12 @@
public static Vector3 Barycentric(Vector3 value1, Vector3 value2,
Vector3 value3, float amount1, float amount2)
{
return (Vector3)((value1 + (amount1 * (value2 - value1))) +
(amount2 * (value3 - value1)));
- }
+ }
+ public static void Barycentric(ref Vector3 value1, ref Vector3 value2,
ref Vector3 value3, float amount1, float amount2, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Interpolates between two values using a cubic
equation.</summary>
/// <param name="value1">Source value.</param>
/// <param name="value2">Source value.</param>
@@ -291,9 +342,12 @@
{
float single1 = MathHelper.Clamp(amount, 0f, 1f);
return Vector3.Lerp(value1, value2, (single1 * single1) * (3f -
(2f * single1)));
- }
-
-
+ }
+ public static void SmoothStep(ref Vector3 value1, ref Vector3 value2,
float amount, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Catmull-Rom interpolation using the specified
positions.</summary>
/// <param name="value1">The first position in the
interpolation.</param>
/// <param name="value2">The second position in the
interpolation.</param>
@@ -306,7 +360,12 @@
float single1 = amount * amount;
float single2 = amount * single1;
return (Vector3)(0.5f * ((((2f * value2) + ((-value1 + value3) *
amount)) + (((((2f * value1) - (5f * value2)) + (4f * value3)) - value4) *
single1)) + ((((-value1 + (3f * value2)) - (3f * value3)) + value4) *
single2)));
- }
+ }
+ public static void CatmullRom(ref Vector3 value1, ref Vector3 value2,
ref Vector3 value3, ref Vector3 value4, float amount, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Hermite spline interpolation.</summary>
/// <param name="value1">Source position vector.</param>
@@ -324,9 +383,13 @@
float single4 = (single2 - (2f * single1)) + amount;
float single3 = single2 - single1;
return (Vector3)((((value1 * single6) + (value2 * single5)) +
(tangent1 * single4)) + (tangent2 * single3));
- }
+ }
+ public static void Hermite(ref Vector3 value1, ref Vector3 tangent1,
ref Vector3 value2, ref Vector3 tangent2, float amount, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
-
/// <summary>Transforms a 3D vector by the given matrix.</summary>
/// <param name="position">The source vector.</param>
/// <param name="matrix">The transformation matrix.</param>
@@ -334,9 +397,12 @@
public static Vector3 Transform(Vector3 position, Matrix matrix)
{
return new Vector3((((position.X * matrix.M11) + (position.Y *
matrix.M21)) + (position.Z * matrix.M31)) + matrix.M41, (((position.X *
matrix.M12) + (position.Y * matrix.M22)) + (position.Z * matrix.M32)) +
matrix.M42, (((position.X * matrix.M13) + (position.Y * matrix.M23)) +
(position.Z * matrix.M33)) + matrix.M43);
- }
-
-
+ }
+ public static void Transform(ref Vector3 position, ref Matrix matrix,
out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Transforms a 3D vector normal by a matrix.</summary>
/// <param name="normal">The source vector.</param>
/// <param name="matrix">The transformation matrix.</param>
@@ -344,10 +410,12 @@
public static Vector3 TransformNormal(Vector3 normal, Matrix matrix)
{
return new Vector3(((normal.X * matrix.M11) + (normal.Y *
matrix.M21)) + (normal.Z * matrix.M31), ((normal.X * matrix.M12) + (normal.Y *
matrix.M22)) + (normal.Z * matrix.M32), ((normal.X * matrix.M13) + (normal.Y *
matrix.M23)) + (normal.Z * matrix.M33));
+ }
+ public static void TransformNormal(ref Vector3 normal, ref Matrix
matrix, out Vector3 result)
+ {
+ throw new NotImplementedException();
}
-
-
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
/// <param name="value">Source vector.</param>
/// <returns>Vector pointing in the opposite direction.</returns>
@@ -357,7 +425,12 @@
value.Y *= -1f;
value.Z *= -1f;
return value;
- }
+ }
+ public static void Negate(ref Vector3 value, out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Adds two vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -368,7 +441,12 @@
value1.Y += value2.Y;
value1.Z += value2.Z;
return value1;
- }
+ }
+ public static void Add(ref Vector3 value1, ref Vector3 value2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Subtracts a vector from a vector.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -379,7 +457,12 @@
value1.Y -= value2.Y;
value1.Z -= value2.Z;
return value1;
- }
+ }
+ public static void Subtract(ref Vector3 value1, ref Vector3 value2,
out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Multiplies the components of two vectors by each
other.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -401,7 +484,17 @@
value1.Y *= value2;
value1.Z *= value2;
return value1;
- }
+ }
+ public static void Multiply(ref Vector3 value1, float scaleFactor, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static void Multiply(ref Vector3 value1, ref Vector3 value2,
out Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Divides the components of a vector by the components of
another vector.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Divisor vector.</param>
@@ -423,7 +516,17 @@
value1.Y /= value2;
value1.Z /= value2;
return value1;
- }
+ }
+ public static void Divide(ref Vector3 value1, float value2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
+ public static void Divide(ref Vector3 value1, ref Vector3 value2, out
Vector3 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
/// <param name="value">Source vector.</param>
/// <returns>Vector pointing in the opposite direction.</returns>
Modified: trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector4.cs
===================================================================
--- trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector4.cs 2006-11-15
22:21:52 UTC (rev 67955)
+++ trunk/Mono.Xna/src/Microsoft.Xna.Framework/Vector4.cs 2006-11-15
22:28:38 UTC (rev 67956)
@@ -25,14 +25,14 @@
*/
#endregion License
-using System;
-using System.Runtime.InteropServices;
-using System.Globalization;
+using System;
+using System.ComponentModel;
namespace Microsoft.Xna.Framework
{
/// <summary>Defines a vector with four components.</summary>
- [Serializable, StructLayout(LayoutKind.Sequential)]
+ [Serializable]
+ [TypeConverter("Microsoft.Xna.Framework.Design.Vector4Converter,
Microsoft.Xna.Framework, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ff")]
public struct Vector4 : IEquatable<Vector4>
{
/// <summary>Gets or sets the x component of the vector.</summary>
@@ -131,8 +131,8 @@
/// <summary>Retrieves a string representation of the current
instance.</summary>
/// <returns>String that represents the object.</returns>
public override string ToString()
- {
- CultureInfo info1 = CultureInfo.CurrentCulture;
+ {
+ System.Globalization.CultureInfo info1 =
System.Globalization.CultureInfo.CurrentCulture;
return string.Format(info1, "{{X:{0} Y:{1} Z:{2} W:{3}}}", new
object[] { this.X.ToString(info1), this.Y.ToString(info1),
this.Z.ToString(info1), this.W.ToString(info1) });
}
@@ -193,8 +193,12 @@
{
Vector4 vector1 = value1 - value2;
return vector1.Length();
- }
-
+ }
+ public static void Distance(ref Vector4 value1, ref Vector4 value2,
out float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Calculates the distance between two vectors
squared.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -203,8 +207,12 @@
{
Vector4 vector1 = value1 - value2;
return vector1.LengthSquared();
- }
-
+ }
+ public static void DistanceSquared(ref Vector4 value1, ref Vector4
value2, out float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Calculates the dot product of two vectors.</summary>
/// <param name="vector1">Source vector.</param>
/// <param name="vector2">Source vector.</param>
@@ -212,8 +220,12 @@
public static float Dot(Vector4 vector1, Vector4 vector2)
{
return ((((vector1.X * vector2.X) + (vector1.Y * vector2.Y)) +
(vector1.Z * vector2.Z)) + (vector1.W * vector2.W));
- }
-
+ }
+ public static void Dot(ref Vector4 vector1, ref Vector4 vector2, out
float result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Creates a unit vector from the specified vector.</summary>
public void Normalize()
{
@@ -230,7 +242,12 @@
public static Vector4 Normalize(Vector4 vector)
{
return (Vector4)(vector / vector.Length());
- }
+ }
+ public static void Normalize(ref Vector4 vector, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector that contains the lowest value from each
matching pair of components.</summary>
/// <param name="value1">Source vector.</param>
@@ -239,9 +256,12 @@
public static Vector4 Min(Vector4 value1, Vector4 value2)
{
return new Vector4(Math.Min(value1.X, value2.X),
Math.Min(value1.Y, value2.Y), Math.Min(value1.Z, value2.Z), Math.Min(value1.W,
value2.W));
- }
-
-
+ }
+ public static void Min(ref Vector4 value1, ref Vector4 value2, out
Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector that contains the highest value from
each matching pair of components.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -249,8 +269,12 @@
public static Vector4 Max(Vector4 value1, Vector4 value2)
{
return new Vector4(Math.Max(value1.X, value2.X),
Math.Max(value1.Y, value2.Y), Math.Max(value1.Z, value2.Z), Math.Max(value1.W,
value2.W));
- }
-
+ }
+ public static void Max(ref Vector4 value1, ref Vector4 value2, out
Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Restricts a value to be within a specified
range.</summary>
/// <param name="value1">The value to clamp.</param>
/// <param name="min">The minimum value.</param>
@@ -259,9 +283,12 @@
public static Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max)
{
return new Vector4(MathHelper.Clamp(value1.X, min.X, max.X),
MathHelper.Clamp(value1.Y, min.Y, max.Y), MathHelper.Clamp(value1.Z, min.Z,
max.Z), MathHelper.Clamp(value1.W, min.W, max.W));
- }
-
-
+ }
+ public static void Clamp(ref Vector4 value1, ref Vector4 min, ref
Vector4 max, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a linear interpolation between two
vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -270,8 +297,12 @@
public static Vector4 Lerp(Vector4 value1, Vector4 value2, float
amount)
{
return new Vector4(value1.X + ((value2.X - value1.X) * amount),
value1.Y + ((value2.Y - value1.Y) * amount), value1.Z + ((value2.Z - value1.Z)
* amount), value1.W + ((value2.W - value1.W) * amount));
- }
-
+ }
+ public static void Lerp(ref Vector4 value1, ref Vector4 value2, float
amount, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a point in barycentric coordinates, using the
specified values.</summary>
/// <param name="value1">One point making up a triangle.</param>
/// <param name="value2">One point making up a triangle.</param>
@@ -282,9 +313,12 @@
public static Vector4 Barycentric(Vector4 value1, Vector4 value2,
Vector4 value3, float amount1, float amount2)
{
return (Vector4)((value1 + (amount1 * (value2 - value1))) +
(amount2 * (value3 - value1)));
- }
-
-
+ }
+ public static void Barycentric(ref Vector4 value1, ref Vector4 value2,
ref Vector4 value3, float amount1, float amount2, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Interpolates between two values using a cubic
equation.</summary>
/// <param name="value1">Source value.</param>
/// <param name="value2">Source value.</param>
@@ -294,8 +328,12 @@
{
amount = MathHelper.Clamp(amount, 0f, 1f);
return Vector4.Lerp(value1, value2, (amount * amount) * (3f - (2f
* amount)));
- }
-
+ }
+ public static void SmoothStep(ref Vector4 value1, ref Vector4 value2,
float amount, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Catmull-Rom interpolation using the specified
positions.</summary>
/// <param name="value1">The first position in the
interpolation.</param>
/// <param name="value2">The second position in the
interpolation.</param>
@@ -308,8 +346,12 @@
float single1 = amount * amount;
float single2 = amount * single1;
return (Vector4)(0.5f * ((((2f * value2) + ((-value1 + value3) *
amount)) + (((((2f * value1) - (5f * value2)) + (4f * value3)) - value4) *
single1)) + ((((-value1 + (3f * value2)) - (3f * value3)) + value4) *
single2)));
- }
-
+ }
+ public static void CatmullRom(ref Vector4 value1, ref Vector4 value2,
ref Vector4 value3, ref Vector4 value4, float amount, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Performs a Hermite spline interpolation.</summary>
/// <param name="value1">Source position vector.</param>
/// <param name="tangent1">Source tangent vector.</param>
@@ -326,8 +368,12 @@
float single4 = (single2 - (2f * single1)) + amount;
float single3 = single2 - single1;
return (Vector4)((((value1 * single6) + (value2 * single5)) +
(tangent1 * single4)) + (tangent2 * single3));
- }
-
+ }
+ public static void Hermite(ref Vector4 value1, ref Vector4 tangent1,
ref Vector4 value2, ref Vector4 tangent2, float amount, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>
/// Transforms a Vector2 by the given Matrix.
/// </summary>
@@ -360,7 +406,20 @@
public static Vector4 Transform(Vector4 vector, Matrix matrix)
{
return new Vector4((((vector.X * matrix.M11) + (vector.Y *
matrix.M21)) + (vector.Z * matrix.M31)) + (vector.W * matrix.M41), (((vector.X
* matrix.M12) + (vector.Y * matrix.M22)) + (vector.Z * matrix.M32)) + (vector.W
* matrix.M42), (((vector.X * matrix.M13) + (vector.Y * matrix.M23)) + (vector.Z
* matrix.M33)) + (vector.W * matrix.M43), (((vector.X * matrix.M14) + (vector.Y
* matrix.M24)) + (vector.Z * matrix.M34)) + (vector.W * matrix.M44));
- }
+ }
+ public static void Transform(ref Vector2 position, ref Matrix matrix,
out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+ public static void Transform(ref Vector3 position, ref Matrix matrix,
out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+ public static void Transform(ref Vector4 vector, ref Matrix matrix,
out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
/// <param name="value">Source vector.</param>
@@ -369,8 +428,12 @@
{
return new Vector4(-value.X, -value.Y, -value.Z, -value.W);
- }
-
+ }
+ public static void Negate(ref Vector4 value, out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Adds two vectors.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -378,8 +441,12 @@
public static Vector4 Add(Vector4 value1, Vector4 value2)
{
return (value1 + value2);
- }
-
+ }
+ public static void Add(ref Vector4 value1, ref Vector4 value2, out
Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Subtracts a vector from a vector.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -387,8 +454,12 @@
public static Vector4 Subtract(Vector4 value1, Vector4 value2)
{
return (value1 - value2);
- }
-
+ }
+ public static void Subtract(ref Vector4 value1, ref Vector4 value2,
out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Multiplies the components of two vectors by each
other.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Source vector.</param>
@@ -405,8 +476,16 @@
public static Vector4 Multiply(Vector4 value1, float scaleFactor)
{
return (Vector4)(value1 * scaleFactor);
- }
-
+ }
+ public static void Multiply(ref Vector4 value1, float scaleFactor, out
Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+ public static void Multiply(ref Vector4 value1, ref Vector4 value2,
out Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+
/// <summary>Divides the components of a vector by the components of
another vector.</summary>
/// <param name="value1">Source vector.</param>
/// <param name="value2">Divisor vector.</param>
@@ -423,6 +502,14 @@
public static Vector4 Divide(Vector4 value1, float divider)
{
return (Vector4)(value1 / divider);
+ }
+ public static void Divide(ref Vector4 value1, float divider, out
Vector4 result)
+ {
+ throw new NotImplementedException();
+ }
+ public static void Divide(ref Vector4 value1, ref Vector4 value2, out
Vector4 result)
+ {
+ throw new NotImplementedException();
}
/// <summary>Returns a vector pointing in the opposite
direction.</summary>
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
