ryujinx-backup/Opentk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Improved documentation.

Browse source
This commit is contained in:
Jarl Gullberg 2017-06-02 20:31:54 +02:00
parent bea15cd250
commit 809e7b4379
No known key found for this signature in database
GPG key ID: 750FF6F6BDA72D23
6 changed files with 526 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
src/OpenTK/Math/Vector2.cs
View file

@ -709,6 +709,64 @@ namespace OpenTK
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector2 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector2</returns>
public static Vector2 MagnitudeMin(Vector2 left, Vector2 right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector2 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector2</returns>
public static void MagnitudeMin(ref Vector2 left, ref Vector2 right, out Vector2 result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector2 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The maximum Vector2</returns>
public static Vector2 MagnitudeMax(Vector2 left, Vector2 right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector2 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector2</returns>
public static void MagnitudeMax(ref Vector2 left, ref Vector2 right, out Vector2 result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Min
/// <summary>

112
src/OpenTK/Math/Vector2d.cs
View file

@ -631,6 +631,118 @@ namespace OpenTK
#endregion
#region ComponentMin
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise minimum</returns>
public static Vector2d ComponentMin(Vector2d a, Vector2d b)
{
a.X = a.X < b.X ? a.X : b.X;
a.Y = a.Y < b.Y ? a.Y : b.Y;
return a;
}
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise minimum</param>
public static void ComponentMin(ref Vector2d a, ref Vector2d b, out Vector2d result)
{
result.X = a.X < b.X ? a.X : b.X;
result.Y = a.Y < b.Y ? a.Y : b.Y;
}
#endregion
#region ComponentMax
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise maximum</returns>
public static Vector2d ComponentMax(Vector2d a, Vector2d b)
{
a.X = a.X > b.X ? a.X : b.X;
a.Y = a.Y > b.Y ? a.Y : b.Y;
return a;
}
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise maximum</param>
public static void ComponentMax(ref Vector2d a, ref Vector2d b, out Vector2d result)
{
result.X = a.X > b.X ? a.X : b.X;
result.Y = a.Y > b.Y ? a.Y : b.Y;
}
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector2d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector2d</returns>
public static Vector2d MagnitudeMin(Vector2d left, Vector2d right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector2d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector2d</returns>
public static void MagnitudeMin(ref Vector2d left, ref Vector2d right, out Vector2d result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector2d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector2d</returns>
public static Vector2d MagnitudeMax(Vector2d left, Vector2d right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector2d with the maximum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector2d</returns>
public static void MagnitudeMax(ref Vector2d left, ref Vector2d right, out Vector2d result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Clamp
/// <summary>

58
src/OpenTK/Math/Vector3.cs
View file

@ -719,6 +719,64 @@ namespace OpenTK
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector3 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector3</returns>
public static Vector3 MagnitudeMin(Vector3 left, Vector3 right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector3 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector3</returns>
public static void MagnitudeMin(ref Vector3 left, ref Vector3 right, out Vector3 result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector3 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The maximum Vector3</returns>
public static Vector3 MagnitudeMax(Vector3 left, Vector3 right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector3 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector3</returns>
public static void MagnitudeMax(ref Vector3 left, ref Vector3 right, out Vector3 result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Min
/// <summary>

54
src/OpenTK/Math/Vector3d.cs
View file

@ -717,6 +717,60 @@ namespace OpenTK
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector3d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector3d</returns>
public static Vector3d MagnitudeMin(Vector3d left, Vector3d right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector3d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector3d</returns>
public static void MagnitudeMin(ref Vector3d left, ref Vector3d right, out Vector3d result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector3d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector3d</returns>
public static Vector3d MagnitudeMax(Vector3d left, Vector3d right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector3d with the maximum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector3d</returns>
public static void MagnitudeMax(ref Vector3d left, ref Vector3d right, out Vector3d result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Min
/// <summary>

124
src/OpenTK/Math/Vector4.cs
View file

@ -765,6 +765,130 @@ namespace OpenTK
#endregion
#region ComponentMin
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise minimum</returns>
public static Vector4 ComponentMin(Vector4 a, Vector4 b)
{
a.X = a.X < b.X ? a.X : b.X;
a.Y = a.Y < b.Y ? a.Y : b.Y;
a.Z = a.Z < b.Z ? a.Z : b.Z;
a.W = a.W < b.W ? a.W : b.W;
return a;
}
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise minimum</param>
public static void ComponentMin(ref Vector4 a, ref Vector4 b, out Vector4 result)
{
result.X = a.X < b.X ? a.X : b.X;
result.Y = a.Y < b.Y ? a.Y : b.Y;
result.Z = a.Z < b.Z ? a.Z : b.Z;
result.W = a.W < b.W ? a.W : b.W;
}
#endregion
#region ComponentMax
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise maximum</returns>
public static Vector4 ComponentMax(Vector4 a, Vector4 b)
{
a.X = a.X > b.X ? a.X : b.X;
a.Y = a.Y > b.Y ? a.Y : b.Y;
a.Z = a.Z > b.Z ? a.Z : b.Z;
a.W = a.W > b.W ? a.W : b.W;
return a;
}
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise maximum</param>
public static void ComponentMax(ref Vector4 a, ref Vector4 b, out Vector4 result)
{
result.X = a.X > b.X ? a.X : b.X;
result.Y = a.Y > b.Y ? a.Y : b.Y;
result.Z = a.Z > b.Z ? a.Z : b.Z;
result.W = a.W > b.W ? a.W : b.W;
}
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector4 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector4</returns>
public static Vector4 MagnitudeMin(Vector4 left, Vector4 right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector4 with the minimum magnitude. If the magnitudes are equal, the second vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector4</returns>
public static void MagnitudeMin(ref Vector4 left, ref Vector4 right, out Vector4 result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector4 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The maximum Vector4</returns>
public static Vector4 MagnitudeMax(Vector4 left, Vector4 right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector4 with the maximum magnitude. If the magnitudes are equal, the first vector
/// is selected.
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector4</returns>
public static void MagnitudeMax(ref Vector4 left, ref Vector4 right, out Vector4 result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Clamp
/// <summary>

120
src/OpenTK/Math/Vector4d.cs
View file

@ -767,6 +767,126 @@ namespace OpenTK
#endregion
#region ComponentMin
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise minimum</returns>
public static Vector4d ComponentMin(Vector4d a, Vector4d b)
{
a.X = a.X < b.X ? a.X : b.X;
a.Y = a.Y < b.Y ? a.Y : b.Y;
a.Z = a.Z < b.Z ? a.Z : b.Z;
a.W = a.W < b.W ? a.W : b.W;
return a;
}
/// <summary>
/// Calculate the component-wise minimum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise minimum</param>
public static void ComponentMin(ref Vector4d a, ref Vector4d b, out Vector4d result)
{
result.X = a.X < b.X ? a.X : b.X;
result.Y = a.Y < b.Y ? a.Y : b.Y;
result.Z = a.Z < b.Z ? a.Z : b.Z;
result.W = a.W < b.W ? a.W : b.W;
}
#endregion
#region ComponentMax
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <returns>The component-wise maximum</returns>
public static Vector4d ComponentMax(Vector4d a, Vector4d b)
{
a.X = a.X > b.X ? a.X : b.X;
a.Y = a.Y > b.Y ? a.Y : b.Y;
a.Z = a.Z > b.Z ? a.Z : b.Z;
a.W = a.W > b.W ? a.W : b.W;
return a;
}
/// <summary>
/// Calculate the component-wise maximum of two vectors
/// </summary>
/// <param name="a">First operand</param>
/// <param name="b">Second operand</param>
/// <param name="result">The component-wise maximum</param>
public static void ComponentMax(ref Vector4d a, ref Vector4d b, out Vector4d result)
{
result.X = a.X > b.X ? a.X : b.X;
result.Y = a.Y > b.Y ? a.Y : b.Y;
result.Z = a.Z > b.Z ? a.Z : b.Z;
result.W = a.W > b.W ? a.W : b.W;
}
#endregion
#region MagnitudeMin
/// <summary>
/// Returns the Vector4d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector4d</returns>
public static Vector4d MagnitudeMin(Vector4d left, Vector4d right)
{
return left.LengthSquared < right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector4d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise minimum</param>
/// <returns>The minimum Vector4d</returns>
public static void MagnitudeMin(ref Vector4d left, ref Vector4d right, out Vector4d result)
{
result = left.LengthSquared < right.LengthSquared ? left : right;
}
#endregion
#region MagnitudeMax
/// <summary>
/// Returns the Vector4d with the minimum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <returns>The minimum Vector4d</returns>
public static Vector4d MagnitudeMax(Vector4d left, Vector4d right)
{
return left.LengthSquared >= right.LengthSquared ? left : right;
}
/// <summary>
/// Returns the Vector4d with the maximum magnitude
/// </summary>
/// <param name="left">Left operand</param>
/// <param name="right">Right operand</param>
/// <param name="result">The magnitude-wise maximum</param>
/// <returns>The maximum Vector4d</returns>
public static void MagnitudeMax(ref Vector4d left, ref Vector4d right, out Vector4d result)
{
result = left.LengthSquared >= right.LengthSquared ? left : right;
}
#endregion
#region Clamp
/// <summary>