From b817d3102cb18f1422f644c1c6c7e3b9cf3fbb2d Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 19 Nov 2023 15:51:59 +1000
Subject: [PATCH 01/25] start of additional math api proposal


From 406240727147c4059bbeb339f6954b39f2feb0f0 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 19 Nov 2023 16:20:39 +1000
Subject: [PATCH 02/25] Create proposal with summary.

---
 .../Proposal - 3.0 Additional math types.md   | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 documentation/proposals/Proposal - 3.0 Additional math types.md

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
new file mode 100644
index 0000000000..9cc7645082
--- /dev/null
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -0,0 +1,19 @@
+# Summary
+Proposal API for additional math types to bring it up to feature parity with other popular math libraries i.e. `SlimDX`, `SharpDX`, or `Stride3D`. Leveraging modern .NET features such as `INumber<T>` and vectorization.
+
+# Contributors
+- Daniel Keenan (dfkeenan)
+
+# Current Status
+- [x] Proposed
+- [ ] Discussed with API Review Board (ARB)
+- [ ] Approved
+- [ ] Implemented
+
+# Design Decisions
+
+
+# Proposed API
+
+```cs
+```

From 30c708cc2632d731c2c403bcf67b2982f527c0e6 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Thu, 23 Nov 2023 15:33:26 +1000
Subject: [PATCH 03/25] Reference decisions from 3.0 math proposal.

---
 .../proposals/Proposal - 3.0 Additional math types.md    | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 9cc7645082..299414007c 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -11,7 +11,16 @@ Proposal API for additional math types to bring it up to feature parity with oth
 - [ ] Implemented
 
 # Design Decisions
+- This proposal should compliment/augment the proposed 3.0 implementation of `Silk.Net.Maths`, matching `System.Numerics` where possible, with concessions for design oversights in that api.
+- This proposal assumes no knowledge of the 2.x Math library.
+- Text herein marked **INFORMATIVE** does not form a normative part of this proposal, and is for background only.
+- Within this proposal, the key words **must**, **required**, **shall**, **should**, **recommended**, **may**, **could**, and **optional** are to be interpreted as described in [RFC 2119 - Key words for use in RFCs to Indicate Requirement Levels](https://www.ietf.org/rfc/rfc2119.txt). The additional key word **optionally** is an alternate form of **optional**, for use where grammatically appropriate. These key words are highlighted in the proposal for clarity.
 
+# **INFORMATIVE** Integer and Floating Point Types
+While investigating the use of generic math it was decided to provide both an integer and floating point variant for each vector type and every type built from them. See [Generic Math](Proposal%20-%20Generic%20Math.md) proposal for more details.
+
+# I types versus F Types
+Where it is appropriate for a type in this proposal to have both integer and floating point variants they will have a name that ends in I or F, defining whether it is an integer type or floating point type. Integer types **must** use a generic type argument `T` with the constraint of `IBinaryInteger<T>`. On the other hand, floating point types **must** use a generic type argument `T` with the constraint of `IFloatingPointIeee754<T>`.
 
 # Proposed API
 

From f68e2bc493c9aa0d93e0b784b0ec281dd70f26bd Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Thu, 23 Nov 2023 16:48:00 +1000
Subject: [PATCH 04/25] Add headings for types under consideration.

---
 .../Proposal - 3.0 Additional math types.md   | 29 +++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 299414007c..7c103aaedc 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -24,5 +24,30 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 # Proposed API
 
-```cs
-```
+## Angle
+
+## "Collision" types.
+
+DirectX and other APIs include "collision shapes" that can be used for such things as culling. `Silk.Net.Maths` already includes some types i.e. `BoxF`, `PlaneF`. These are additional.
+
+### Frustum
+
+### OrientedBox
+
+### CollisionHelper
+
+### PlaneIntersectionType
+
+### ContainmentType
+
+## Color types.
+
+### Color
+
+### ColorBGRA
+
+### ColorHSV
+
+### Color3
+
+### Color4

From b2734fe94046ac0b6e8b2bde01b421515412ec3b Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 25 Nov 2023 19:00:38 +1000
Subject: [PATCH 05/25] Add rough cut of Angle struct

---
 .../Proposal - 3.0 Additional math types.md   | 201 ++++++++++++++++++
 1 file changed, 201 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 7c103aaedc..91ed4922e5 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -26,6 +26,207 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 ## Angle
 
+Interface implementations not included for brevity.
+
+```csharp
+public readonly struct Angle<T> 
+    : IEquatable<Angle<T>>
+    , IEqualityOperators<Angle<T>,Angle<T>, bool>
+    , IComparable<Angle<T>>
+    , IComparisonOperators<Angle<T>,Angle<T>, bool>
+    , IAdditionOperators<Angle<T>,Angle<T>,Angle<T>>
+    , IDivisionOperators<Angle<T>, T, Angle<T>>
+    , IDivisionOperators<T, Angle<T>, Angle<T>>
+    , IMultiplyOperators<Angle<T>, T, Angle<T>>
+    , IMultiplyOperators<T, Angle<T>, Angle<T>>
+    , IModulusOperators<Angle<T>, Angle<T>, Angle<T>>
+    , ISubtractionOperators<Angle<T>,Angle<T>,Angle<T>>
+    where T : IFloatingPointIeee754<T>
+{
+
+    public readonly T Radians;
+
+    public Angle(T radians) { }
+
+    
+    public T Degrees { get; }
+    public T Gradians { get; }
+    public T Milliradians { get; }
+    public T Minutes { get; }
+    public T Seconds { get; }
+
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is a right angle (i.e. 90° or π/2).
+    /// </summary>    
+    public bool IsRight { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is a straight angle (i.e. 180° or π).
+    /// </summary>    
+    public bool IsStraight { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is a full rotation angle (i.e. 360° or 2π).
+    /// </summary>    
+    public bool IsFullRotation { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is an oblique angle (i.e. is not 90° or a multiple of 90°).
+    /// </summary>    
+    public bool IsOblique { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is an acute angle (i.e. less than 90° but greater than 0°).
+    /// </summary>    
+    public bool IsAcute { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is an obtuse angle (i.e. greater than 90° but less than 180°).
+    /// </summary>    
+    public bool IsObtuse { get; }
+
+    /// <summary>
+    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// is a reflex angle (i.e. greater than 180° but less than 360°).
+    /// </summary>    
+    public bool IsReflex { get; }
+
+    /// <summary>
+    /// Gets a Angle<T> instance that complements this angle (i.e. the two angles add to 90°).
+    /// </summary>    
+    public Angle<T> Complement { get; }
+
+    /// <summary>
+    /// Gets a Angle<T> instance that supplements this angle (i.e. the two angles add to 180°).
+    /// </summary>    
+    public Angle<T> Supplement { get; }
+
+    /// <summary>
+    /// Wraps this Angle<T> to be in the range [π, -π].
+    /// </summary>
+    public Angle<T> Wrap() => default;
+
+    /// <summary>
+    /// Wraps this Angle<T> to be in the range [0, 2π).
+    /// </summary>
+    public Angle<T> WrapPositive() => default;
+
+
+    /// <summary>Computes the arc-cosine of a value.</summary>
+    public T Acos()  => default;
+
+    /// <summary>Computes the arc-cosine of a value and divides the result by <c>pi</c>.</summary>
+    public T AcosPi()  => default;
+
+    /// <summary>Computes the arc-sine of a value.</summary>
+    public T Asin()  => default;
+
+    /// <summary>Computes the arc-sine of a value and divides the result by <c>pi</c>.</summary>
+    public T AsinPi()  => default;
+
+    /// <summary>Computes the arc-tangent of a value.</summary>
+    public T Atan()  => default;
+
+    /// <summary>Computes the arc-tangent of a value and divides the result by pi.</summary>
+    public T AtanPi()  => default;
+
+    /// <summary>Computes the cosine of a value.</summary>
+    public T Cos()  => default;
+
+    /// <summary>Computes the cosine of a value that has been multipled by <c>pi</c>.</summary>
+    public T CosPi()  => default;
+
+    /// <summary>Computes the sine of a value.</summary>
+    /// <param name="x">The value, in radians, whose sine is to be computed.</param>
+    /// <returns>The sine of <paramref name="x" />.</returns>
+    /// <remarks>This computes <c>sin(x)</c>.</remarks>
+    public T Sin()  => default;
+
+    /// <summary>Computes the sine and cosine of a value.</summary>
+    public (T Sin, T Cos) SinCos()  => default;
+
+    /// <summary>Computes the sine and cosine of a value that has been multiplied by <c>pi</c>.</summary>
+    public (T SinPi, T CosPi) SinCosPi()  => default;
+
+    /// <summary>Computes the sine of a value that has been multiplied by <c>pi</c>.</summary>
+    public T SinPi()  => default;
+
+    /// <summary>Computes the tangent of a value.</summary>
+    public T Tan()  => default;
+
+    /// <summary>Computes the tangent of a value that has been multipled by <c>pi</c>.</summary>
+    public T TanPi()  => default;
+
+    /// <summary>Implicit cast in radians</summary>
+    public static implicit operator T(Angle<T> angle) => default;
+}
+
+public static class Angle
+{
+    public static Angle<T> FromRadians<T>(T radians)
+        where T : IFloatingPointIeee754<T>
+        => default;
+    public static Angle<T> FromDegrees<T>(T degrees)
+        where T : IFloatingPointIeee754<T>
+         => default;
+    public static Angle<T> FromGradians<T>(T gradians)
+        where T : IFloatingPointIeee754<T>
+         => default;
+    public static Angle<T> FromMilliradians<T>(T milliradians)
+        where T : IFloatingPointIeee754<T>
+         => default;
+    public static Angle<T> FromMinutes<T>(T minutes)
+        where T : IFloatingPointIeee754<T>
+         => default;
+    public static Angle<T> FromSeconds<T>(T seconds)
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> Min<T>(Angle<T> left, Angle<T> right) 
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+    public static Angle<T> Max<T>(Angle<T> left, Angle<T> right)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+    public static Angle<T> Clamp<T>(Angle<T> value, Angle<T> min, Angle<T> max)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+    public static Angle<T> Atan2<T>(T y, T x)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+    public static Angle<T> ArcTan<T>(T y, T x)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+    public static Angle<T> ArcSin<T>(T sin)
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> ArcCos<T>(T cos)
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> Between<T>(Vector2F<T> left, Vector2F<T> right)
+       where T : IFloatingPointIeee754<T>
+       => default;
+
+    public static Angle<T> Between<T>(Vector3F<T> left, Vector3F<T> right)
+       where T : IFloatingPointIeee754<T>
+       => default;
+}
+```
+
 ## "Collision" types.
 
 DirectX and other APIs include "collision shapes" that can be used for such things as culling. `Silk.Net.Maths` already includes some types i.e. `BoxF`, `PlaneF`. These are additional.

From c030275fa7dcb6042ff5f25bc6df2cfe37eb5a6f Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 25 Nov 2023 19:18:48 +1000
Subject: [PATCH 06/25] add parsable interfaces to Angle

---
 documentation/proposals/Proposal - 3.0 Additional math types.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 91ed4922e5..0490aeb1f8 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -41,6 +41,8 @@ public readonly struct Angle<T>
     , IMultiplyOperators<T, Angle<T>, Angle<T>>
     , IModulusOperators<Angle<T>, Angle<T>, Angle<T>>
     , ISubtractionOperators<Angle<T>,Angle<T>,Angle<T>>
+    , IParsable<Angle<T>>
+    , ISpanParsable<Angle<T>>
     where T : IFloatingPointIeee754<T>
 {
 

From d4c84a42d2debf078dbd9c6475da08a4ff984884 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 25 Nov 2023 19:24:57 +1000
Subject: [PATCH 07/25] Add more angle methods.

---
 .../Proposal - 3.0 Additional math types.md      | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 0490aeb1f8..6997b7261e 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -226,6 +226,22 @@ public static class Angle
     public static Angle<T> Between<T>(Vector3F<T> left, Vector3F<T> right)
        where T : IFloatingPointIeee754<T>
        => default;
+
+    public static Angle<T> ZeroAngle<T>()
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> RightAngle<T>()
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> StraightAngle<T>()
+        where T : IFloatingPointIeee754<T>
+         => default;
+
+    public static Angle<T> FullRotationAngle<T>()
+        where T : IFloatingPointIeee754<T>
+         => default;
 }
 ```
 

From 4b4798a5c72639d53b0ebf920f899269b3af587a Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 25 Nov 2023 19:55:06 +1000
Subject: [PATCH 08/25] add more angle helper methods.

---
 .../proposals/Proposal - 3.0 Additional math types.md     | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types.md
index 6997b7261e..325810403e 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types.md	
@@ -203,6 +203,14 @@ public static class Angle
         where T : IFloatingPointIeee754<T>
         => default;
 
+     public static Angle<T> Lerp<T>(Angle<T> start, Angle<T> end, T amount)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
+     public static Angle<T> SmoothStep<T>(Angle<T> start, Angle<T> end, T amount)
+        where T : IFloatingPointIeee754<T>
+        => default;
+
     public static Angle<T> Atan2<T>(T y, T x)
         where T : IFloatingPointIeee754<T>
         => default;

From 9f65f5bb9c781626056871de5ab9abfac0d10464 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 26 Nov 2023 11:35:28 +1000
Subject: [PATCH 09/25] Split proposal into 3

---
 ...al - 3.0 Additional math types - Angle.md} | 41 +++++--------------
 ...- 3.0 Additional math types - Collision.md | 41 +++++++++++++++++++
 ...sal - 3.0 Additional math types - Color.md | 37 +++++++++++++++++
 3 files changed, 89 insertions(+), 30 deletions(-)
 rename documentation/proposals/{Proposal - 3.0 Additional math types.md => Proposal - 3.0 Additional math types - Angle.md} (95%)
 create mode 100644 documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
 create mode 100644 documentation/proposals/Proposal - 3.0 Additional math types - Color.md

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
similarity index 95%
rename from documentation/proposals/Proposal - 3.0 Additional math types.md
rename to documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index 325810403e..934649a16d 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -46,13 +46,14 @@ public readonly struct Angle<T>
     where T : IFloatingPointIeee754<T>
 {
 
-    public readonly T Radians;
+    public readonly T TotalRadians;
 
-    public Angle(T radians) { }
+    public Angle(T totalRadians) { }
 
     
     public T Degrees { get; }
-    public T Gradians { get; }
+    public T TotalDegrees { get; }
+    public T TotalRdians { get; }
     public T Milliradians { get; }
     public T Minutes { get; }
     public T Seconds { get; }
@@ -170,6 +171,12 @@ public readonly struct Angle<T>
     public static implicit operator T(Angle<T> angle) => default;
 }
 
+```
+
+
+
+```csharp
+
 public static class Angle
 {
     public static Angle<T> FromRadians<T>(T radians)
@@ -251,30 +258,4 @@ public static class Angle
         where T : IFloatingPointIeee754<T>
          => default;
 }
-```
-
-## "Collision" types.
-
-DirectX and other APIs include "collision shapes" that can be used for such things as culling. `Silk.Net.Maths` already includes some types i.e. `BoxF`, `PlaneF`. These are additional.
-
-### Frustum
-
-### OrientedBox
-
-### CollisionHelper
-
-### PlaneIntersectionType
-
-### ContainmentType
-
-## Color types.
-
-### Color
-
-### ColorBGRA
-
-### ColorHSV
-
-### Color3
-
-### Color4
+```
\ No newline at end of file
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
new file mode 100644
index 0000000000..fb1a638bb5
--- /dev/null
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -0,0 +1,41 @@
+# Summary
+Proposal API for additional math types to bring it up to feature parity with other popular math libraries i.e. `SlimDX`, `SharpDX`, or `Stride3D`. Leveraging modern .NET features such as `INumber<T>` and vectorization.
+
+This proposal is regarding "collision shapes" for containment and intersection tests.
+
+# Contributors
+- Daniel Keenan (dfkeenan)
+
+# Current Status
+- [x] Proposed
+- [ ] Discussed with API Review Board (ARB)
+- [ ] Approved
+- [ ] Implemented
+
+# Design Decisions
+- This proposal should compliment/augment the proposed 3.0 implementation of `Silk.Net.Maths`, matching `System.Numerics` where possible, with concessions for design oversights in that api.
+- This proposal assumes no knowledge of the 2.x Math library.
+- Text herein marked **INFORMATIVE** does not form a normative part of this proposal, and is for background only.
+- Within this proposal, the key words **must**, **required**, **shall**, **should**, **recommended**, **may**, **could**, and **optional** are to be interpreted as described in [RFC 2119 - Key words for use in RFCs to Indicate Requirement Levels](https://www.ietf.org/rfc/rfc2119.txt). The additional key word **optionally** is an alternate form of **optional**, for use where grammatically appropriate. These key words are highlighted in the proposal for clarity.
+
+# **INFORMATIVE** Integer and Floating Point Types
+While investigating the use of generic math it was decided to provide both an integer and floating point variant for each vector type and every type built from them. See [Generic Math](Proposal%20-%20Generic%20Math.md) proposal for more details.
+
+# I types versus F Types
+Where it is appropriate for a type in this proposal to have both integer and floating point variants they will have a name that ends in I or F, defining whether it is an integer type or floating point type. Integer types **must** use a generic type argument `T` with the constraint of `IBinaryInteger<T>`. On the other hand, floating point types **must** use a generic type argument `T` with the constraint of `IFloatingPointIeee754<T>`.
+
+# Proposed API
+
+DirectX and other APIs include "collision shapes" that can be used for such things as culling. `Silk.Net.Maths` already includes some types i.e. `BoxF`, `PlaneF`. These are additional.
+
+### Frustum
+
+### OrientedBox
+
+### CollisionHelper
+
+### PlaneIntersectionType
+
+### ContainmentType
+
+
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md
new file mode 100644
index 0000000000..79853831b0
--- /dev/null
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md	
@@ -0,0 +1,37 @@
+# Summary
+Proposal API for additional math types to bring it up to feature parity with other popular math libraries i.e. `SlimDX`, `SharpDX`, or `Stride3D`. Leveraging modern .NET features such as `INumber<T>` and vectorization.
+
+This proposal is regarding color type structs.
+
+# Contributors
+- Daniel Keenan (dfkeenan)
+
+# Current Status
+- [x] Proposed
+- [ ] Discussed with API Review Board (ARB)
+- [ ] Approved
+- [ ] Implemented
+
+# Design Decisions
+- This proposal should compliment/augment the proposed 3.0 implementation of `Silk.Net.Maths`, matching `System.Numerics` where possible, with concessions for design oversights in that api.
+- This proposal assumes no knowledge of the 2.x Math library.
+- Text herein marked **INFORMATIVE** does not form a normative part of this proposal, and is for background only.
+- Within this proposal, the key words **must**, **required**, **shall**, **should**, **recommended**, **may**, **could**, and **optional** are to be interpreted as described in [RFC 2119 - Key words for use in RFCs to Indicate Requirement Levels](https://www.ietf.org/rfc/rfc2119.txt). The additional key word **optionally** is an alternate form of **optional**, for use where grammatically appropriate. These key words are highlighted in the proposal for clarity.
+
+# **INFORMATIVE** Integer and Floating Point Types
+While investigating the use of generic math it was decided to provide both an integer and floating point variant for each vector type and every type built from them. See [Generic Math](Proposal%20-%20Generic%20Math.md) proposal for more details.
+
+# I types versus F Types
+Where it is appropriate for a type in this proposal to have both integer and floating point variants they will have a name that ends in I or F, defining whether it is an integer type or floating point type. Integer types **must** use a generic type argument `T` with the constraint of `IBinaryInteger<T>`. On the other hand, floating point types **must** use a generic type argument `T` with the constraint of `IFloatingPointIeee754<T>`.
+
+# Proposed API
+
+### Color
+
+### ColorBGRA
+
+### ColorHSV
+
+### Color3
+
+### Color4

From b5013c0122656ba41fcd5a4a3225b6dc7807d4e4 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 26 Nov 2023 11:46:51 +1000
Subject: [PATCH 10/25] Tweak angles

---
 ...sal - 3.0 Additional math types - Angle.md | 21 ++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index 934649a16d..d6cdaf0ddb 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -43,6 +43,9 @@ public readonly struct Angle<T>
     , ISubtractionOperators<Angle<T>,Angle<T>,Angle<T>>
     , IParsable<Angle<T>>
     , ISpanParsable<Angle<T>>
+    , IUtf8SpanParsable<Angle<T>>
+    , IFormattable
+    , IUtf8SpanFormattable
     where T : IFloatingPointIeee754<T>
 {
 
@@ -50,11 +53,14 @@ public readonly struct Angle<T>
 
     public Angle(T totalRadians) { }
 
-    
+    /// <summary>Angle in degrees in the range [0, 360].</summary>
     public T Degrees { get; }
+    /// <summary>Total angle in degrees.</summary>
     public T TotalDegrees { get; }
-    public T TotalRdians { get; }
-    public T Milliradians { get; }
+    /// <summary>Angle in radians in range [π, -π].</summary>
+    public T Radians { get; }
+
+    public T Hours { get; }
     public T Minutes { get; }
     public T Seconds { get; }
 
@@ -185,10 +191,7 @@ public static class Angle
     public static Angle<T> FromDegrees<T>(T degrees)
         where T : IFloatingPointIeee754<T>
          => default;
-    public static Angle<T> FromGradians<T>(T gradians)
-        where T : IFloatingPointIeee754<T>
-         => default;
-    public static Angle<T> FromMilliradians<T>(T milliradians)
+    public static Angle<T> FromHours<T>(T hours)
         where T : IFloatingPointIeee754<T>
          => default;
     public static Angle<T> FromMinutes<T>(T minutes)
@@ -198,6 +201,10 @@ public static class Angle
         where T : IFloatingPointIeee754<T>
          => default;
 
+    public static Angle<T> FromTimeSpan<T>(TimeSpan timeSpan)
+        where T : IFloatingPointIeee754<T>
+         => default;
+
     public static Angle<T> Min<T>(Angle<T> left, Angle<T> right) 
         where T : IFloatingPointIeee754<T>
         => default;

From de5f43c046c35520649f004485dc28cbcb4cbc8a Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 26 Nov 2023 14:33:47 +1000
Subject: [PATCH 11/25] More collisions

---
 ...posal - 3.0 Additional math types - Collision.md | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index fb1a638bb5..00af0cabbf 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -1,7 +1,7 @@
 # Summary
 Proposal API for additional math types to bring it up to feature parity with other popular math libraries i.e. `SlimDX`, `SharpDX`, or `Stride3D`. Leveraging modern .NET features such as `INumber<T>` and vectorization.
 
-This proposal is regarding "collision shapes" for containment and intersection tests.
+DirectX and other APIs include "collision shapes" that can be used for such things as culling. This proposal covers the addition of similar "Bounding{Shape}" types and their corresponding containment and intersection test.
 
 # Contributors
 - Daniel Keenan (dfkeenan)
@@ -26,16 +26,19 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 # Proposed API
 
-DirectX and other APIs include "collision shapes" that can be used for such things as culling. `Silk.Net.Maths` already includes some types i.e. `BoxF`, `PlaneF`. These are additional.
+`BoundingOrientedBox` is defined with a quaternion as it's orientation. `Quaternion<T>` is constrained by the `IBinaryFloatingPointIeee754<T>` scalar type. Therefore all bounding shapes with be constrained by the `IBinaryFloatingPointIeee754<T>` scalar type.
 
-### Frustum
+### BoundingBox
 
-### OrientedBox
+### BoundingOrientedBox
 
-### CollisionHelper
+### BoundingFrustum
+
+### BoundingSphere
 
 ### PlaneIntersectionType
 
 ### ContainmentType
 
+### CollisionHelper
 

From 2765624590de16c65e05ad654d48b7c6f009f59a Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 26 Nov 2023 16:02:46 +1000
Subject: [PATCH 12/25] Angle - rename T to TScalar

---
 ...sal - 3.0 Additional math types - Angle.md | 192 +++++++++---------
 1 file changed, 96 insertions(+), 96 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index d6cdaf0ddb..3a8296eea4 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -29,152 +29,152 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 Interface implementations not included for brevity.
 
 ```csharp
-public readonly struct Angle<T> 
-    : IEquatable<Angle<T>>
-    , IEqualityOperators<Angle<T>,Angle<T>, bool>
-    , IComparable<Angle<T>>
-    , IComparisonOperators<Angle<T>,Angle<T>, bool>
-    , IAdditionOperators<Angle<T>,Angle<T>,Angle<T>>
-    , IDivisionOperators<Angle<T>, T, Angle<T>>
-    , IDivisionOperators<T, Angle<T>, Angle<T>>
-    , IMultiplyOperators<Angle<T>, T, Angle<T>>
-    , IMultiplyOperators<T, Angle<T>, Angle<T>>
-    , IModulusOperators<Angle<T>, Angle<T>, Angle<T>>
-    , ISubtractionOperators<Angle<T>,Angle<T>,Angle<T>>
-    , IParsable<Angle<T>>
-    , ISpanParsable<Angle<T>>
-    , IUtf8SpanParsable<Angle<T>>
+public readonly struct Angle<TScalar> 
+    : IEquatable<Angle<TScalar>>
+    , IEqualityOperators<Angle<TScalar>,Angle<TScalar>, bool>
+    , IComparable<Angle<TScalar>>
+    , IComparisonOperators<Angle<TScalar>,Angle<TScalar>, bool>
+    , IAdditionOperators<Angle<TScalar>,Angle<TScalar>,Angle<TScalar>>
+    , IDivisionOperators<Angle<TScalar>, TScalar, Angle<TScalar>>
+    , IDivisionOperators<TScalar, Angle<TScalar>, Angle<TScalar>>
+    , IMultiplyOperators<Angle<TScalar>, TScalar, Angle<TScalar>>
+    , IMultiplyOperators<TScalar, Angle<TScalar>, Angle<TScalar>>
+    , IModulusOperators<Angle<TScalar>, Angle<TScalar>, Angle<TScalar>>
+    , ISubtractionOperators<Angle<TScalar>,Angle<TScalar>,Angle<TScalar>>
+    , IParsable<Angle<TScalar>>
+    , ISpanParsable<Angle<TScalar>>
+    , IUtf8SpanParsable<Angle<TScalar>>
     , IFormattable
     , IUtf8SpanFormattable
-    where T : IFloatingPointIeee754<T>
+    where TScalar : IFloatingPointIeee754<TScalar>
 {
 
-    public readonly T TotalRadians;
+    public readonly TScalar TotalRadians;
 
-    public Angle(T totalRadians) { }
+    public Angle(TScalar totalRadians) { }
 
     /// <summary>Angle in degrees in the range [0, 360].</summary>
-    public T Degrees { get; }
+    public TScalar Degrees { get; }
     /// <summary>Total angle in degrees.</summary>
-    public T TotalDegrees { get; }
+    public TScalar TotalDegrees { get; }
     /// <summary>Angle in radians in range [π, -π].</summary>
-    public T Radians { get; }
+    public TScalar Radians { get; }
 
-    public T Hours { get; }
-    public T Minutes { get; }
-    public T Seconds { get; }
+    public TScalar Hours { get; }
+    public TScalar Minutes { get; }
+    public TScalar Seconds { get; }
 
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is a right angle (i.e. 90° or π/2).
     /// </summary>    
     public bool IsRight { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is a straight angle (i.e. 180° or π).
     /// </summary>    
     public bool IsStraight { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is a full rotation angle (i.e. 360° or 2π).
     /// </summary>    
     public bool IsFullRotation { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is an oblique angle (i.e. is not 90° or a multiple of 90°).
     /// </summary>    
     public bool IsOblique { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is an acute angle (i.e. less than 90° but greater than 0°).
     /// </summary>    
     public bool IsAcute { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is an obtuse angle (i.e. greater than 90° but less than 180°).
     /// </summary>    
     public bool IsObtuse { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<T>
+    /// Gets a System.Boolean that determines whether this Angle<TScalar>
     /// is a reflex angle (i.e. greater than 180° but less than 360°).
     /// </summary>    
     public bool IsReflex { get; }
 
     /// <summary>
-    /// Gets a Angle<T> instance that complements this angle (i.e. the two angles add to 90°).
+    /// Gets a Angle<TScalar> instance that complements this angle (i.e. the two angles add to 90°).
     /// </summary>    
-    public Angle<T> Complement { get; }
+    public Angle<TScalar> Complement { get; }
 
     /// <summary>
-    /// Gets a Angle<T> instance that supplements this angle (i.e. the two angles add to 180°).
+    /// Gets a Angle<TScalar> instance that supplements this angle (i.e. the two angles add to 180°).
     /// </summary>    
-    public Angle<T> Supplement { get; }
+    public Angle<TScalar> Supplement { get; }
 
     /// <summary>
-    /// Wraps this Angle<T> to be in the range [π, -π].
+    /// Wraps this Angle<TScalar> to be in the range [π, -π].
     /// </summary>
-    public Angle<T> Wrap() => default;
+    public Angle<TScalar> Wrap() => default;
 
     /// <summary>
-    /// Wraps this Angle<T> to be in the range [0, 2π).
+    /// Wraps this Angle<TScalar> to be in the range [0, 2π).
     /// </summary>
-    public Angle<T> WrapPositive() => default;
+    public Angle<TScalar> WrapPositive() => default;
 
 
     /// <summary>Computes the arc-cosine of a value.</summary>
-    public T Acos()  => default;
+    public TScalar Acos()  => default;
 
     /// <summary>Computes the arc-cosine of a value and divides the result by <c>pi</c>.</summary>
-    public T AcosPi()  => default;
+    public TScalar AcosPi()  => default;
 
     /// <summary>Computes the arc-sine of a value.</summary>
-    public T Asin()  => default;
+    public TScalar Asin()  => default;
 
     /// <summary>Computes the arc-sine of a value and divides the result by <c>pi</c>.</summary>
-    public T AsinPi()  => default;
+    public TScalar AsinPi()  => default;
 
     /// <summary>Computes the arc-tangent of a value.</summary>
-    public T Atan()  => default;
+    public TScalar Atan()  => default;
 
     /// <summary>Computes the arc-tangent of a value and divides the result by pi.</summary>
-    public T AtanPi()  => default;
+    public TScalar AtanPi()  => default;
 
     /// <summary>Computes the cosine of a value.</summary>
-    public T Cos()  => default;
+    public TScalar Cos()  => default;
 
     /// <summary>Computes the cosine of a value that has been multipled by <c>pi</c>.</summary>
-    public T CosPi()  => default;
+    public TScalar CosPi()  => default;
 
     /// <summary>Computes the sine of a value.</summary>
     /// <param name="x">The value, in radians, whose sine is to be computed.</param>
     /// <returns>The sine of <paramref name="x" />.</returns>
     /// <remarks>This computes <c>sin(x)</c>.</remarks>
-    public T Sin()  => default;
+    public TScalar Sin()  => default;
 
     /// <summary>Computes the sine and cosine of a value.</summary>
-    public (T Sin, T Cos) SinCos()  => default;
+    public (TScalar Sin, TScalar Cos) SinCos()  => default;
 
     /// <summary>Computes the sine and cosine of a value that has been multiplied by <c>pi</c>.</summary>
-    public (T SinPi, T CosPi) SinCosPi()  => default;
+    public (TScalar SinPi, TScalar CosPi) SinCosPi()  => default;
 
     /// <summary>Computes the sine of a value that has been multiplied by <c>pi</c>.</summary>
-    public T SinPi()  => default;
+    public TScalar SinPi()  => default;
 
     /// <summary>Computes the tangent of a value.</summary>
-    public T Tan()  => default;
+    public TScalar Tan()  => default;
 
     /// <summary>Computes the tangent of a value that has been multipled by <c>pi</c>.</summary>
-    public T TanPi()  => default;
+    public TScalar TanPi()  => default;
 
     /// <summary>Implicit cast in radians</summary>
-    public static implicit operator T(Angle<T> angle) => default;
+    public static implicit operator TScalar(Angle<TScalar> angle) => default;
 }
 
 ```
@@ -185,84 +185,84 @@ public readonly struct Angle<T>
 
 public static class Angle
 {
-    public static Angle<T> FromRadians<T>(T radians)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromRadians<TScalar>(TScalar radians)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
-    public static Angle<T> FromDegrees<T>(T degrees)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromDegrees<TScalar>(TScalar degrees)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
-    public static Angle<T> FromHours<T>(T hours)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromHours<TScalar>(TScalar hours)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
-    public static Angle<T> FromMinutes<T>(T minutes)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromMinutes<TScalar>(TScalar minutes)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
-    public static Angle<T> FromSeconds<T>(T seconds)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromSeconds<TScalar>(TScalar seconds)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> FromTimeSpan<T>(TimeSpan timeSpan)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FromTimeSpan<TScalar>(TimeSpan timeSpan)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> Min<T>(Angle<T> left, Angle<T> right) 
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Min<TScalar>(Angle<TScalar> left, Angle<TScalar> right) 
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<T> Max<T>(Angle<T> left, Angle<T> right)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Max<TScalar>(Angle<TScalar> left, Angle<TScalar> right)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<T> Clamp<T>(Angle<T> value, Angle<T> min, Angle<T> max)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Clamp<TScalar>(Angle<TScalar> value, Angle<TScalar> min, Angle<TScalar> max)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-     public static Angle<T> Lerp<T>(Angle<T> start, Angle<T> end, T amount)
-        where T : IFloatingPointIeee754<T>
+     public static Angle<TScalar> Lerp<TScalar>(Angle<TScalar> start, Angle<TScalar> end, TScalar amount)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-     public static Angle<T> SmoothStep<T>(Angle<T> start, Angle<T> end, T amount)
-        where T : IFloatingPointIeee754<T>
+     public static Angle<TScalar> SmoothStep<TScalar>(Angle<TScalar> start, Angle<TScalar> end, TScalar amount)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<T> Atan2<T>(T y, T x)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Atan2<TScalar>(TScalar y, TScalar x)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<T> ArcTan<T>(T y, T x)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> ArcTan<TScalar>(TScalar y, TScalar x)
+        where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<T> ArcSin<T>(T sin)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> ArcSin<TScalar>(TScalar sin)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> ArcCos<T>(T cos)
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> ArcCos<TScalar>(TScalar cos)
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> Between<T>(Vector2F<T> left, Vector2F<T> right)
-       where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Between<TScalar>(Vector2F<TScalar> left, Vector2F<TScalar> right)
+       where TScalar : IFloatingPointIeee754<TScalar>
        => default;
 
-    public static Angle<T> Between<T>(Vector3F<T> left, Vector3F<T> right)
-       where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> Between<TScalar>(Vector3F<TScalar> left, Vector3F<TScalar> right)
+       where TScalar : IFloatingPointIeee754<TScalar>
        => default;
 
-    public static Angle<T> ZeroAngle<T>()
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> ZeroAngle<TScalar>()
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> RightAngle<T>()
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> RightAngle<TScalar>()
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> StraightAngle<T>()
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> StraightAngle<TScalar>()
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<T> FullRotationAngle<T>()
-        where T : IFloatingPointIeee754<T>
+    public static Angle<TScalar> FullRotationAngle<TScalar>()
+        where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 }
 ```
\ No newline at end of file

From a675423cf9dd89966bf7e1360b6f267a0a338790 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 2 Dec 2023 15:45:10 +1000
Subject: [PATCH 13/25] More angles

---
 ...sal - 3.0 Additional math types - Angle.md | 129 ++++++------------
 1 file changed, 43 insertions(+), 86 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index 3a8296eea4..8dae115305 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -16,19 +16,27 @@ Proposal API for additional math types to bring it up to feature parity with oth
 - Text herein marked **INFORMATIVE** does not form a normative part of this proposal, and is for background only.
 - Within this proposal, the key words **must**, **required**, **shall**, **should**, **recommended**, **may**, **could**, and **optional** are to be interpreted as described in [RFC 2119 - Key words for use in RFCs to Indicate Requirement Levels](https://www.ietf.org/rfc/rfc2119.txt). The additional key word **optionally** is an alternate form of **optional**, for use where grammatically appropriate. These key words are highlighted in the proposal for clarity.
 
-# **INFORMATIVE** Integer and Floating Point Types
-While investigating the use of generic math it was decided to provide both an integer and floating point variant for each vector type and every type built from them. See [Generic Math](Proposal%20-%20Generic%20Math.md) proposal for more details.
 
-# I types versus F Types
-Where it is appropriate for a type in this proposal to have both integer and floating point variants they will have a name that ends in I or F, defining whether it is an integer type or floating point type. Integer types **must** use a generic type argument `T` with the constraint of `IBinaryInteger<T>`. On the other hand, floating point types **must** use a generic type argument `T` with the constraint of `IFloatingPointIeee754<T>`.
 
 # Proposed API
 
 ## Angle
 
+* `IParsable<TSelf>`, `ISpanParsable<TSelf>`, `IUtf8SpanParsable<TSelf>`
+    * must parse angle in degrees using `IParsable<TScalar>`, `ISpanParsable<TScalar>`, `IUtf8SpanParsable<TSelf>`
+    * optional handle `°` character
+
+* `IFormattable`, `IUtf8SpanFormattable`
+    * must produce text in degrees with default format of 2 decimal places. i.e. format string `0.##`
+    * optional include `°` character. i.e. format string `0.##°`
+
 Interface implementations not included for brevity.
 
 ```csharp
+/// <summary>
+/// Represents a unit independant angle using a floating-point
+/// internal representation.
+/// </summary>
 public readonly struct Angle<TScalar> 
     : IEquatable<Angle<TScalar>>
     , IEqualityOperators<Angle<TScalar>,Angle<TScalar>, bool>
@@ -48,131 +56,76 @@ public readonly struct Angle<TScalar>
     , IUtf8SpanFormattable
     where TScalar : IFloatingPointIeee754<TScalar>
 {
-
-    public readonly TScalar TotalRadians;
-
-    public Angle(TScalar totalRadians) { }
+    public Angle(TScalar radians) { }
 
     /// <summary>Angle in degrees in the range [0, 360].</summary>
     public TScalar Degrees { get; }
-    /// <summary>Total angle in degrees.</summary>
-    public TScalar TotalDegrees { get; }
+
     /// <summary>Angle in radians in range [π, -π].</summary>
     public TScalar Radians { get; }
 
-    public TScalar Hours { get; }
+    /// <summary>Angle in radians in range [0, 2π].</summary>
+    public TScalar PositiveRadians { get; }
+
+    /// <summary>Gets or sets the minutes component of the degrees this Silk.NET.Maths.Angle<TScalar> represents.</summary>
     public TScalar Minutes { get; }
+
+    /// <summary>Gets or sets the seconds of the degrees this Silk.NET.Maths.Angle<TScalar> represents.</summary>
     public TScalar Seconds { get; }
 
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is a right angle (i.e. 90° or π/2).
     /// </summary>    
     public bool IsRight { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is a straight angle (i.e. 180° or π).
     /// </summary>    
     public bool IsStraight { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is a full rotation angle (i.e. 360° or 2π).
     /// </summary>    
     public bool IsFullRotation { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is an oblique angle (i.e. is not 90° or a multiple of 90°).
     /// </summary>    
     public bool IsOblique { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is an acute angle (i.e. less than 90° but greater than 0°).
     /// </summary>    
     public bool IsAcute { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is an obtuse angle (i.e. greater than 90° but less than 180°).
     /// </summary>    
     public bool IsObtuse { get; }
 
     /// <summary>
-    /// Gets a System.Boolean that determines whether this Angle<TScalar>
+    /// Gets a System.Boolean that determines whether this Silk.NET.Maths.Angle<TScalar>
     /// is a reflex angle (i.e. greater than 180° but less than 360°).
     /// </summary>    
     public bool IsReflex { get; }
 
     /// <summary>
-    /// Gets a Angle<TScalar> instance that complements this angle (i.e. the two angles add to 90°).
+    /// Gets a Silk.NET.Maths.Angle<TScalar> instance that complements this angle (i.e. the two angles add to 90°).
     /// </summary>    
     public Angle<TScalar> Complement { get; }
 
     /// <summary>
-    /// Gets a Angle<TScalar> instance that supplements this angle (i.e. the two angles add to 180°).
+    /// Gets a Silk.NET.Maths.Angle<TScalar> instance that supplements this angle (i.e. the two angles add to 180°).
     /// </summary>    
     public Angle<TScalar> Supplement { get; }
 
-    /// <summary>
-    /// Wraps this Angle<TScalar> to be in the range [π, -π].
-    /// </summary>
-    public Angle<TScalar> Wrap() => default;
-
-    /// <summary>
-    /// Wraps this Angle<TScalar> to be in the range [0, 2π).
-    /// </summary>
-    public Angle<TScalar> WrapPositive() => default;
-
-
-    /// <summary>Computes the arc-cosine of a value.</summary>
-    public TScalar Acos()  => default;
-
-    /// <summary>Computes the arc-cosine of a value and divides the result by <c>pi</c>.</summary>
-    public TScalar AcosPi()  => default;
-
-    /// <summary>Computes the arc-sine of a value.</summary>
-    public TScalar Asin()  => default;
-
-    /// <summary>Computes the arc-sine of a value and divides the result by <c>pi</c>.</summary>
-    public TScalar AsinPi()  => default;
-
-    /// <summary>Computes the arc-tangent of a value.</summary>
-    public TScalar Atan()  => default;
-
-    /// <summary>Computes the arc-tangent of a value and divides the result by pi.</summary>
-    public TScalar AtanPi()  => default;
-
-    /// <summary>Computes the cosine of a value.</summary>
-    public TScalar Cos()  => default;
-
-    /// <summary>Computes the cosine of a value that has been multipled by <c>pi</c>.</summary>
-    public TScalar CosPi()  => default;
-
-    /// <summary>Computes the sine of a value.</summary>
-    /// <param name="x">The value, in radians, whose sine is to be computed.</param>
-    /// <returns>The sine of <paramref name="x" />.</returns>
-    /// <remarks>This computes <c>sin(x)</c>.</remarks>
-    public TScalar Sin()  => default;
-
-    /// <summary>Computes the sine and cosine of a value.</summary>
-    public (TScalar Sin, TScalar Cos) SinCos()  => default;
-
-    /// <summary>Computes the sine and cosine of a value that has been multiplied by <c>pi</c>.</summary>
-    public (TScalar SinPi, TScalar CosPi) SinCosPi()  => default;
-
-    /// <summary>Computes the sine of a value that has been multiplied by <c>pi</c>.</summary>
-    public TScalar SinPi()  => default;
-
-    /// <summary>Computes the tangent of a value.</summary>
-    public TScalar Tan()  => default;
-
-    /// <summary>Computes the tangent of a value that has been multipled by <c>pi</c>.</summary>
-    public TScalar TanPi()  => default;
-
     /// <summary>Implicit cast in radians</summary>
     public static implicit operator TScalar(Angle<TScalar> angle) => default;
 }
@@ -188,20 +141,16 @@ public static class Angle
     public static Angle<TScalar> FromRadians<TScalar>(TScalar radians)
         where TScalar : IFloatingPointIeee754<TScalar>
         => default;
+
     public static Angle<TScalar> FromDegrees<TScalar>(TScalar degrees)
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
-    public static Angle<TScalar> FromHours<TScalar>(TScalar hours)
-        where TScalar : IFloatingPointIeee754<TScalar>
-         => default;
+
     public static Angle<TScalar> FromMinutes<TScalar>(TScalar minutes)
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
-    public static Angle<TScalar> FromSeconds<TScalar>(TScalar seconds)
-        where TScalar : IFloatingPointIeee754<TScalar>
-         => default;
 
-    public static Angle<TScalar> FromTimeSpan<TScalar>(TimeSpan timeSpan)
+    public static Angle<TScalar> FromSeconds<TScalar>(TScalar seconds)
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
@@ -213,15 +162,23 @@ public static class Angle
         where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-    public static Angle<TScalar> Clamp<TScalar>(Angle<TScalar> value, Angle<TScalar> min, Angle<TScalar> max)
+    public static Angle<TScalar> Add<TScalar>(Angle<TScalar> left, Angle<TScalar> right)
+        where TScalar : IFloatingPointIeee754<TScalar>
+        => default;
+
+    public static Angle<TScalar> Subtract<TScalar>(Angle<TScalar> left, Angle<TScalar> right)
         where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-     public static Angle<TScalar> Lerp<TScalar>(Angle<TScalar> start, Angle<TScalar> end, TScalar amount)
+    public static Angle<TScalar> Multiply<TScalar>(Angle<TScalar> left, TScalar right)
         where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 
-     public static Angle<TScalar> SmoothStep<TScalar>(Angle<TScalar> start, Angle<TScalar> end, TScalar amount)
+    public static Angle<TScalar> Divide<TScalar>(Angle<TScalar> left, TScalar right)
+        where TScalar : IFloatingPointIeee754<TScalar>
+        => default;
+
+    public static Angle<TScalar> Clamp<TScalar>(Angle<TScalar> value, Angle<TScalar> min, Angle<TScalar> max)
         where TScalar : IFloatingPointIeee754<TScalar>
         => default;
 

From ad2a860215d5ea9e675e950836511f9fcec1f72f Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 9 Dec 2023 20:50:07 +1000
Subject: [PATCH 14/25] Add some collision shape interfaces.

---
 ...- 3.0 Additional math types - Collision.md | 188 +++++++++++++++++-
 1 file changed, 184 insertions(+), 4 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index 00af0cabbf..f03f41ee9a 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -26,19 +26,199 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 # Proposed API
 
-`BoundingOrientedBox` is defined with a quaternion as it's orientation. `Quaternion<T>` is constrained by the `IBinaryFloatingPointIeee754<T>` scalar type. Therefore all bounding shapes with be constrained by the `IBinaryFloatingPointIeee754<T>` scalar type.
+`BoundingOrientedBox<T>` is defined with a quaternion as it's orientation. `Quaternion<T>` is constrained by the `IBinaryFloatingPointIeee754<T>` scalar type. Therefore all bounding shapes with be constrained by the `IBinaryFloatingPointIeee754<T>` scalar type.
+
+### PlaneIntersectionType
+
+```csharp
+ public enum PlaneIntersectionType
+ {
+     Back,
+     Front,
+     Intersecting,
+ }
+```
+
+### ContainmentType
+```csharp
+public enum ContainmentType
+{
+    Disjoint,
+    Contains,
+    Intersects,
+}
+```
+
+### IIntersectWithRay
+```csharp
+public interface IIntersectWithRay<TSelf, TScalar>
+    where TScalar : IFloatingPointIeee754<TScalar>
+{
+    public bool Intersects(ref readonly Ray3F<TScalar> ray);
+
+    public static abstract bool Intersects(ref readonly TSelf shape, ref readonly Ray3F<TScalar> ray);
+
+    public bool Intersects(ref readonly Ray3F<TScalar> ray, out float distance);
+
+    public static abstract bool Intersects(ref readonly TSelf shape, ref readonly Ray3F<TScalar> ray, out float distance);
+
+    public bool Intersects(ref readonly Ray3F<TScalar> ray, out Vector3F<TScalar> point);
+
+    public static abstract bool Intersects(ref readonly TSelf shape, ref readonly Ray3F<TScalar> ray, out Vector3F<TScalar> point);
+}
+```
+
+### IIntersectWithPlane
+```csharp
+public interface IIntersectWithPlane<TSelf, TScalar>
+    where TScalar : IFloatingPointIeee754<TScalar>
+{
+   
+    public PlaneIntersectionType Intersects(ref readonly PlaneF<TScalar> plane);
+    public static abstract PlaneIntersectionType Intersects(ref readonly TSelf shape, ref readonly PlaneF<TScalar> plane);
+}
+```
+
+### IIntersect
+```csharp
+public interface IIntersect<TSelf, TOther>
+{
+    public bool Intersects(ref readonly TOther other);
+
+    public static abstract bool Intersects(ref readonly TSelf shape, ref readonly TOther other);
+}
+```
+
+### IContainPoint
+```csharp
+public interface IContainPoint<TSelf, TScalar>
+    where TScalar : IFloatingPointIeee754<TScalar>
+{
+
+    public ContainmentType Contains(ref readonly Vector3F<TScalar> point);
+
+    public static abstract ContainmentType Contains(ref readonly TSelf shape, ref readonly Vector3F<TScalar> point);
+
+    public ContainmentType Contains(ref readonly Vector3F<TScalar> vertex1, ref readonly Vector3F<TScalar> vertex2, ref readonly Vector3F<TScalar> vertex3);
+
+    public static abstract ContainmentType Contains(ref readonly TSelf shape, ref readonly Vector3F<TScalar> vertex1, ref readonly Vector3F<TScalar> vertex2, ref readonly Vector3F<TScalar> vertex3);
+}
+```
+
+### IContain
+```csharp
+public interface IContain<TSelf, TOther>
+{
+    public ContainmentType Contains(ref readonly TOther other);
+
+    public static abstract ContainmentType Contains(ref readonly TSelf shape, ref readonly TOther other);
+}
+```
+
+### IColliderShape
+```csharp
+public interface IColliderShape<TSelf, TScalar>
+    where TScalar : IFloatingPointIeee754<TScalar>
+{
+    public static abstract void FromPoints(ReadOnlySpan<Vector3F<TScalar>> points, out TSelf result);
+    public static abstract TSelf FromPoints(ReadOnlySpan<Vector3F<TScalar>> points);
+
+    public static abstract void Merge(ref readonly TSelf value1, ref readonly TSelf value2, out TSelf result);
+
+    public static abstract TSelf Merge(TSelf value1, TSelf value2);
+
+    public static abstract void Transform(ref readonly TSelf value, ref readonly Matrix4x4F<TScalar> transform);
+    public static abstract void Transform(ref readonly TSelf value, ref readonly Matrix4x4F<TScalar> transform, out TSelf result);
+}
+```
 
 ### BoundingBox
 
+Access aligned box
+
+```csharp
+public struct BoundingBox<TScalar>
+    : IEquatable<BoundingBox<TScalar>>
+    , IEqualityOperators<BoundingBox<TScalar>, BoundingBox<TScalar>, bool>
+    , IIntersectWithRay<BoundingBox<TScalar>, TScalar>
+    , IIntersectWithPlane<BoundingBox<TScalar>, TScalar>
+    , IColliderShape<BoundingBox<TScalar>, TScalar>
+    , IContainPoint<BoundingBox<TScalar>, TScalar>
+    , IIntersect<BoundingBox<TScalar>, BoundingBox<TScalar>>
+    //Implement IIntersect for other shapes
+    , IContain<BoundingBox<TScalar>, BoundingBox<TScalar>>
+    //Implement IContain for other shapes
+    , IFormattable
+    where TScalar: IBinaryFloatingPointIeee754<TScalar>
+{
+
+}
+```
+
+### BoundingBoxExtent
+
+Access aligned box for fast frustum culling.
+
+```csharp
+
+```
+
 ### BoundingOrientedBox
 
+Box with orientation
+
+```csharp
+public struct BoundingOrientedBox<TScalar>
+    : IEquatable<BoundingOrientedBox<TScalar>>
+    , IEqualityOperators<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>, bool>
+    , IIntersectWithRay<BoundingOrientedBox<TScalar>, TScalar>
+    , IIntersectWithPlane<BoundingOrientedBox<TScalar>, TScalar>
+    , IColliderShape<BoundingOrientedBox<TScalar>, TScalar>
+    , IContainPoint<BoundingOrientedBox<TScalar>, TScalar>
+    , IIntersect<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>>
+    //Implement IIntersect for other shapes
+    , IContain<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>>
+    //Implement IContain for other shapes
+    , IFormattable
+    where TScalar : IBinaryFloatingPointIeee754<TScalar>
+{
+
+}
+```
+
 ### BoundingFrustum
 
-### BoundingSphere
+Frustum
 
-### PlaneIntersectionType
+```csharp
 
-### ContainmentType
+```
+
+### BoundingSphere
+
+Sphere
+
+```csharp
+public struct BoundingSphere<TScalar>
+    : IEquatable<BoundingSphere<TScalar>>
+    , IEqualityOperators<BoundingSphere<TScalar>, BoundingSphere<TScalar>, bool>
+    , IIntersectWithRay<BoundingSphere<TScalar>, TScalar>
+    , IIntersectWithPlane<BoundingSphere<TScalar>, TScalar>
+    , IColliderShape<BoundingSphere<TScalar>, TScalar>
+    , IContainPoint<BoundingSphere<TScalar>, TScalar>
+    , IIntersect<BoundingSphere<TScalar>, BoundingSphere<TScalar>>
+    //Implement IIntersect for other shapes
+    , IContain<BoundingSphere<TScalar>, BoundingSphere<TScalar>>
+    //Implement IContain for other shapes
+    , IFormattable
+    where TScalar : IBinaryFloatingPointIeee754<TScalar>
+{
+
+}
+```
 
 ### CollisionHelper
 
+```csharp
+
+```
\ No newline at end of file

From 3fccc873d87291c0367b4b7d5b4dca01fa01d499 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 30 Mar 2024 17:10:35 +1000
Subject: [PATCH 15/25] Angel changes

---
 .../Proposal - 3.0 Additional math types - Angle.md | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index 8dae115305..bac6593adc 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -58,9 +58,12 @@ public readonly struct Angle<TScalar>
 {
     public Angle(TScalar radians) { }
 
-    /// <summary>Angle in degrees in the range [0, 360].</summary>
+    /// <summary>Angle in degrees in the range [0, 360]. Without fractional component.</summary>
     public TScalar Degrees { get; }
 
+    /// <summary>Angle in degrees in the range [0, 360]. With fractional component.</summary>
+    public TScalar TotalDegrees { get; }
+
     /// <summary>Angle in radians in range [π, -π].</summary>
     public TScalar Radians { get; }
 
@@ -146,13 +149,9 @@ public static class Angle
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<TScalar> FromMinutes<TScalar>(TScalar minutes)
-        where TScalar : IFloatingPointIeee754<TScalar>
-         => default;
-
-    public static Angle<TScalar> FromSeconds<TScalar>(TScalar seconds)
+    public static Angle<TScalar> FromDegrees<TScalar>(TScalar degrees, TScalar minutes, TScalar seconds)
         where TScalar : IFloatingPointIeee754<TScalar>
-         => default;
+        => default;
 
     public static Angle<TScalar> Min<TScalar>(Angle<TScalar> left, Angle<TScalar> right) 
         where TScalar : IFloatingPointIeee754<TScalar>

From bca07ec1b8c674c44c2ddbc1db0c1d248a15b18d Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 31 Mar 2024 16:56:06 +1000
Subject: [PATCH 16/25] More collision updates.

---
 ...- 3.0 Additional math types - Collision.md | 81 +++++++++----------
 1 file changed, 39 insertions(+), 42 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index f03f41ee9a..e2d3f259f2 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -26,7 +26,9 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 # Proposed API
 
-`BoundingOrientedBox<T>` is defined with a quaternion as it's orientation. `Quaternion<T>` is constrained by the `IBinaryFloatingPointIeee754<T>` scalar type. Therefore all bounding shapes with be constrained by the `IBinaryFloatingPointIeee754<T>` scalar type.
+`Silk.NET.Math` and the generic math proposal for 3.0 already contain "geometric types that would be suitable to use for collision/intersection types. i.e. Box3F.
+
+This proposal is to add additional APIs for the purpose of intersection tests.
 
 ### PlaneIntersectionType
 
@@ -132,52 +134,39 @@ public interface IColliderShape<TSelf, TScalar>
 }
 ```
 
-### BoundingBox
+### BoxF
 
-Access aligned box
+Additional interfaces/members for BoxF. Interface implementations not included for brevity.
 
 ```csharp
-public struct BoundingBox<TScalar>
-    : IEquatable<BoundingBox<TScalar>>
-    , IEqualityOperators<BoundingBox<TScalar>, BoundingBox<TScalar>, bool>
-    , IIntersectWithRay<BoundingBox<TScalar>, TScalar>
+public struct BoxF<TScalar>
+    : IIntersectWithRay<BoundingBox<TScalar>, TScalar>
     , IIntersectWithPlane<BoundingBox<TScalar>, TScalar>
     , IColliderShape<BoundingBox<TScalar>, TScalar>
     , IContainPoint<BoundingBox<TScalar>, TScalar>
-    , IIntersect<BoundingBox<TScalar>, BoundingBox<TScalar>>
+    , IIntersect<BoxF<TScalar>, BoxF<TScalar>>
     //Implement IIntersect for other shapes
-    , IContain<BoundingBox<TScalar>, BoundingBox<TScalar>>
+    , IContain<BoxF<TScalar>, BoxF<TScalar>>
     //Implement IContain for other shapes
-    , IFormattable
     where TScalar: IBinaryFloatingPointIeee754<TScalar>
 {
 
 }
 ```
 
-### BoundingBoxExtent
-
-Access aligned box for fast frustum culling.
-
-```csharp
-
-```
-
-### BoundingOrientedBox
+### SphereF
 
-Box with orientation
+Additional interfaces/members for SphereF. Interface implementations not included for brevity.
 
 ```csharp
-public struct BoundingOrientedBox<TScalar>
-    : IEquatable<BoundingOrientedBox<TScalar>>
-    , IEqualityOperators<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>, bool>
-    , IIntersectWithRay<BoundingOrientedBox<TScalar>, TScalar>
-    , IIntersectWithPlane<BoundingOrientedBox<TScalar>, TScalar>
-    , IColliderShape<BoundingOrientedBox<TScalar>, TScalar>
-    , IContainPoint<BoundingOrientedBox<TScalar>, TScalar>
-    , IIntersect<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>>
+public struct SphereF<TScalar>
+    , IIntersectWithRay<SphereF<TScalar>, TScalar>
+    , IIntersectWithPlane<SphereF<TScalar>, TScalar>
+    , IColliderShape<SphereF<TScalar>, TScalar>
+    , IContainPoint<SphereF<TScalar>, TScalar>
+    , IIntersect<SphereF<TScalar>, SphereF<TScalar>>
     //Implement IIntersect for other shapes
-    , IContain<BoundingOrientedBox<TScalar>, BoundingOrientedBox<TScalar>>
+    , IContain<SphereF<TScalar>, SphereF<TScalar>>
     //Implement IContain for other shapes
     , IFormattable
     where TScalar : IBinaryFloatingPointIeee754<TScalar>
@@ -186,29 +175,29 @@ public struct BoundingOrientedBox<TScalar>
 }
 ```
 
-### BoundingFrustum
+### BoxFExtent
 
-Frustum
+Access aligned box for fast frustum culling. Interface implementations not included for brevity.
 
 ```csharp
 
 ```
 
-### BoundingSphere
+### OrientedBoxF
 
-Sphere
+Box with orientation. Interface implementations not included for brevity.
 
 ```csharp
-public struct BoundingSphere<TScalar>
-    : IEquatable<BoundingSphere<TScalar>>
-    , IEqualityOperators<BoundingSphere<TScalar>, BoundingSphere<TScalar>, bool>
-    , IIntersectWithRay<BoundingSphere<TScalar>, TScalar>
-    , IIntersectWithPlane<BoundingSphere<TScalar>, TScalar>
-    , IColliderShape<BoundingSphere<TScalar>, TScalar>
-    , IContainPoint<BoundingSphere<TScalar>, TScalar>
-    , IIntersect<BoundingSphere<TScalar>, BoundingSphere<TScalar>>
+public struct OrientedBoxF<TScalar>
+    : IEquatable<OrientedBoxF<TScalar>>
+    , IEqualityOperators<OrientedBoxF<TScalar>, OrientedBoxF<TScalar>, bool>
+    , IIntersectWithRay<OrientedBoxF<TScalar>, TScalar>
+    , IIntersectWithPlane<OrientedBoxF<TScalar>, TScalar>
+    , IColliderShape<OrientedBoxF<TScalar>, TScalar>
+    , IContainPoint<OrientedBoxF<TScalar>, TScalar>
+    , IIntersect<OrientedBoxF<TScalar>, OrientedBoxF<TScalar>>
     //Implement IIntersect for other shapes
-    , IContain<BoundingSphere<TScalar>, BoundingSphere<TScalar>>
+    , IContain<OrientedBoxF<TScalar>, OrientedBoxF<TScalar>>
     //Implement IContain for other shapes
     , IFormattable
     where TScalar : IBinaryFloatingPointIeee754<TScalar>
@@ -217,6 +206,14 @@ public struct BoundingSphere<TScalar>
 }
 ```
 
+### FrustumF
+
+Frustum
+
+```csharp
+
+```
+
 ### CollisionHelper
 
 ```csharp

From 272a2bf115c3c838b7f325144c1b9eb05c7ae83a Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 4 May 2024 14:42:32 +1000
Subject: [PATCH 17/25] Make Angle constructor internal

---
 .../proposals/Proposal - 3.0 Additional math types - Angle.md   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index bac6593adc..b30072df84 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -56,7 +56,7 @@ public readonly struct Angle<TScalar>
     , IUtf8SpanFormattable
     where TScalar : IFloatingPointIeee754<TScalar>
 {
-    public Angle(TScalar radians) { }
+    internal Angle(TScalar radians) { }
 
     /// <summary>Angle in degrees in the range [0, 360]. Without fractional component.</summary>
     public TScalar Degrees { get; }

From b655ee72712ea117e9e06af097c747c3ab0b2cd9 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 4 May 2024 15:28:02 +1000
Subject: [PATCH 18/25] Add some Frustum details

---
 ...- 3.0 Additional math types - Collision.md | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index e2d3f259f2..2c5ea61b3c 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -211,6 +211,36 @@ public struct OrientedBoxF<TScalar>
 Frustum
 
 ```csharp
+public struct FrustumF<TScalar>
+    , IIntersectWithRay<FrustumF<TScalar>, TScalar>
+    , IIntersectWithPlane<FrustumF<TScalar>, TScalar>
+    , IColliderShape<FrustumF<TScalar>, TScalar>
+    , IContainPoint<FrustumF<TScalar>, TScalar>
+    , IIntersect<FrustumF<TScalar>, FrustumF<TScalar>>
+    //Implement IIntersect for other shapes
+    , IContain<FrustumF<TScalar>, FrustumF<TScalar>>
+    //Implement IContain for other shapes
+    , IFormattable
+    , IEquatable<FrustumF<TScalar>>
+    where TScalar : IBinaryFloatingPointIeee754<TScalar>
+{
+    public PlaneF<TScaler> LeftPlane;
+    public PlaneF<TScaler> RightPlane;
+    public PlaneF<TScaler> TopPlane;
+    public PlaneF<TScaler> BottomPlane;
+    public PlaneF<TScaler> NearPlane;
+    public PlaneF<TScaler> FarPlane;
+}
+
+```
+
+```csharp
+public static class Frustum
+{
+    public static FrustumF<TScalar> FromMatrix(Matrix4x4F<TScaler>)
+        where TScalar : IBinaryFloatingPointIeee754<TScalar>
+        => default;
+}
 
 ```
 

From 2b448aeb8d5859519c5a48c26e4443c52ba44d70 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 4 May 2024 15:28:30 +1000
Subject: [PATCH 19/25] Add meeting agenda/notes sections

---
 .../proposals/Proposal - 3.0 Additional math types - Angle.md | 4 +++-
 .../Proposal - 3.0 Additional math types - Collision.md       | 4 +++-
 .../proposals/Proposal - 3.0 Additional math types - Color.md | 2 ++
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index b30072df84..e46c0574c3 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -221,4 +221,6 @@ public static class Angle
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 }
-```
\ No newline at end of file
+```
+
+# Meeting Agenda/Notes
\ No newline at end of file
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index 2c5ea61b3c..4d3887186e 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -248,4 +248,6 @@ public static class Frustum
 
 ```csharp
 
-```
\ No newline at end of file
+```
+
+# Meeting Agenda/Notes
\ No newline at end of file
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md
index 79853831b0..50ceef73c6 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md	
@@ -35,3 +35,5 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 ### Color3
 
 ### Color4
+
+# Meeting Agenda/Notes

From 6ed4e0bd82b6a64902421847180ec7a0adc4ad35 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 4 May 2024 15:40:34 +1000
Subject: [PATCH 20/25] Add discussion notes to angle

---
 .../Proposal - 3.0 Additional math types - Angle.md | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index e46c0574c3..a834fb014f 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -223,4 +223,15 @@ public static class Angle
 }
 ```
 
-# Meeting Agenda/Notes
\ No newline at end of file
+# Meeting Agenda/Notes
+## TDB
+* Degrees, minutes and seconds are not fractional. Should they be changed to an integer type (`int`)?
+    *   ```csharp
+        public int Degrees { get; }
+        public int Minutes { get; }
+        public int Seconds { get; }
+
+        public static Angle<TScalar> FromDegrees<TScalar>(int degrees, int minutes, int seconds)
+            where TScalar : IFloatingPointIeee754<TScalar>
+            => default;
+        ```
\ No newline at end of file

From 302c108dd418c30069209355e455eec06801a0a7 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 4 May 2024 15:58:54 +1000
Subject: [PATCH 21/25] Add Empty to IColliderShape

---
 .../Proposal - 3.0 Additional math types - Collision.md         | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index 4d3887186e..c0c2cae23a 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -122,6 +122,8 @@ public interface IContain<TSelf, TOther>
 public interface IColliderShape<TSelf, TScalar>
     where TScalar : IFloatingPointIeee754<TScalar>
 {
+    public static abstract TSelf Empty { get; }
+
     public static abstract void FromPoints(ReadOnlySpan<Vector3F<TScalar>> points, out TSelf result);
     public static abstract TSelf FromPoints(ReadOnlySpan<Vector3F<TScalar>> points);
 

From c8ef63d4bbcc204359ba3564497c9e737e32d568 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sun, 5 May 2024 00:10:32 +1000
Subject: [PATCH 22/25] Make a start on color types. (Copying Stride 3D.)

---
 ...sal - 3.0 Additional math types - Color.md | 2808 +++++++++++++++++
 1 file changed, 2808 insertions(+)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md
index 50ceef73c6..9a7e115ebd 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Color.md	
@@ -28,12 +28,2820 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 ### Color
 
+```csharp
+    [StructLayout(LayoutKind.Sequential, Size = 4)]
+    public partial struct Color : IEquatable<Color>
+    {
+        public byte R;
+        public byte G;
+        public byte B;
+        public byte A;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public Color(byte value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public Color(float value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color(byte red, byte green, byte blue, byte alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.  Alpha is set to 255.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        public Color(byte red, byte green, byte blue)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color(float red, float green, float blue, float alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.  Alpha is set to 255.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        public Color(float red, float green, float blue)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, blue, and alpha components of the color.</param>
+        public Color(Vector4F<TScalar> value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, and blue components of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color(Vector3F<TScalar> value, float alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct. Alpha is set to 255.
+        /// </summary>
+        /// <param name = "value">The red, green, and blue components of the color.</param>
+        public Color(Vector3F<TScalar> value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "rgba">A packed integer containing all four color components in RGBA order.</param>
+        public Color(uint rgba)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "rgba">A packed integer containing all four color components in RGBA order.</param>
+        public Color(int rgba)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, and blue, alpha components of the color. This must be an array with four elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public Color(float[] values)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, blue, or alpha components of the color. This must be an array with four elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public Color(byte[] values)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the component at the specified index.
+        /// </summary>
+        /// <value>The value of the red, green, blue, or alpha component, depending on the index.</value>
+        /// <param name = "index">The index of the component to access. Use 0 for the red(R) component, 1 for the green(G) component, 2 for the blue(B) component, and 3 for the alpha(A) component.</param>
+        /// <returns>The value of the component at the specified index.</returns>
+        /// <exception cref = "System.ArgumentOutOfRangeException">Thrown when the <paramref name = "index"/> is out of the range [0, 3].</exception>
+        public byte this[int index] { get; set; }
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToBgra() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToRgba() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToArgb() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToAbgr() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a three component vector.
+        /// </summary>
+        /// <returns>A three component vector containing the red, green, and blue components of the color.</returns>
+        public Vector3F<TScalar> ToVector3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a three component color.
+        /// </summary>
+        /// <returns>A three component color containing the red, green, and blue components of the color.</returns>
+        public Color3<TScalar> ToColor3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a four component vector.
+        /// </summary>
+        /// <returns>A four component vector containing all four color components.</returns>
+        public Vector4F<TScalar> ToVector4<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Creates an array containing the elements of the color.
+        /// </summary>
+        /// <returns>A four-element array containing the components of the color in RGBA order.</returns>
+        public byte[] ToArray() 
+            => default;
+
+        /// <summary>
+        /// Gets the brightness.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetBrightness() 
+            => default;
+
+        /// <summary>
+        /// Gets the hue.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetHue() 
+            => default;
+
+        /// <summary>
+        /// Gets the saturation.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetSaturation() 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <param name = "result">When the method completes, completes the sum of the two colors.</param>
+        public static void Add(ref readonly Color left, ref readonly Color right, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color Add(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <param name = "result">WHen the method completes, contains the difference of the two colors.</param>
+        public static void Subtract(ref readonly Color left, ref readonly Color right, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color Subtract(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <param name = "result">When the method completes, contains the modulated color.</param>
+        public static void Modulate(ref readonly Color left, ref readonly Color right, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color Modulate(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <param name = "result">When the method completes, contains the scaled color.</param>
+        public static void Scale(ref readonly Color value, float scale, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color Scale(Color value, float scale) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <param name = "result">When the method completes, contains the negated color.</param>
+        public static void Negate(ref readonly Color value, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>The negated color.</returns>
+        public static Color Negate(Color value) 
+            => default;
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <param name = "result">When the method completes, contains the clamped value.</param>
+        public static void Clamp(ref readonly Color value, ref readonly Color min, ref readonly Color max, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Converts the color from a packed BGRA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in BGRA order</param>
+        /// <returns>A color.</returns>
+        public static Color FromBgra(int color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed BGRA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in BGRA order</param>
+        /// <returns>A color.</returns>
+        public static Color FromBgra(uint color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed ABGR integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in ABGR order</param>
+        /// <returns>A color.</returns>
+        public static Color FromAbgr(int color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed ABGR integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in ABGR order</param>
+        /// <returns>A color.</returns>
+        public static Color FromAbgr(uint color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed RGBA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in RGBA order</param>
+        /// <returns>A color.</returns>
+        public static Color FromRgba(int color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed RGBA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in RGBA order</param>
+        /// <returns>A color.</returns>
+        public static Color FromRgba(uint color) 
+            => default;
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Color Clamp(Color value, Color min, Color max) 
+            => default;
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the linear interpolation of the two colors.</param>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static void Lerp(ref readonly Color start, ref readonly Color end, float amount, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The linear interpolation of the two colors.</returns>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static Color Lerp(Color start, Color end, float amount) 
+            => default;
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the cubic interpolation of the two colors.</param>
+        public static void SmoothStep(ref readonly Color start, ref readonly Color end, float amount, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The cubic interpolation of the two colors.</returns>
+        public static Color SmoothStep(Color start, Color end, float amount) 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the largest components of the source colors.</param>
+        public static void Max(ref readonly Color left, ref readonly Color right, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the largest components of the specified colorss.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the largest components of the source colors.</returns>
+        public static Color Max(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the smallest components of the source colors.</param>
+        public static void Min(ref readonly Color left, ref readonly Color right, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the smallest components of the source colors.</returns>
+        public static Color Min(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustContrast(ref readonly Color value, float contrast, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color AdjustContrast(Color value, float contrast) 
+            => default;
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustSaturation(ref readonly Color value, float saturation, out Color result)
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color AdjustSaturation(Color value, float saturation) 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color operator +(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Assert a color (return it unchanged).
+        /// </summary>
+        /// <param name = "value">The color to assert (unchanged).</param>
+        /// <returns>The asserted (unchanged) color.</returns>
+        public static Color operator +(Color value) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color operator -(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>A negated color.</returns>
+        public static Color operator -(Color value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "scale">The factor by which to scale the color.</param>
+        /// <param name = "value">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color operator *(float scale, Color value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The factor by which to scale the color.</param>
+        /// <param name = "scale">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color operator *(Color value, float scale) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color operator *(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Tests for equality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has the same value as <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Tests for inequality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has a different value than <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(Color left, Color right) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color"/> to <see cref = "Color3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color3<TScalar>(Color value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color"/> to <see cref = "Vector3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector3F<TScalar>(Color value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color"/> to <see cref = "Vector4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector4F<TScalar>(Color value) 
+            => default;
+
+        /// <summary>
+        /// Convert this instance to a <see cref = "Color4"/>
+        /// </summary>
+        /// <returns>The result of the conversion.</returns>
+        public Color4<TScalar> ToColor4<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref = "Color"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static implicit operator Color4<TScalar>(Color value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector3"/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color(Vector3F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color3"/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector4"/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color(Vector4F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color4"/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "int "/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator int (Color value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "int "/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator Color(int value) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public override string ToString() 
+            => default;
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode() 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "Color"/> is equal to this instance.
+        /// </summary>
+        /// <param name = "other">The <see cref = "Color"/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "Color"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals(Color other) 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "object "/> is equal to this instance.
+        /// </summary>
+        /// <param name = "value">The <see cref = "object "/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "object "/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object value) 
+            => default;
+
+    }
+```
 ### ColorBGRA
 
+```csharp
+    [StructLayout(LayoutKind.Sequential, Size = 4)]
+    public partial struct ColorBGRA : IEquatable<ColorBGRA>, IFormattable
+    {
+        public byte B;
+        public byte G;
+        public byte R;
+        public byte A;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public ColorBGRA(byte value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public ColorBGRA(float value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public ColorBGRA(byte red, byte green, byte blue, byte alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public ColorBGRA(float red, float green, float blue, float alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, blue, and alpha components of the color.</param>
+        public ColorBGRA(Vector4F<TScalar> value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, and blue components of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public ColorBGRA(Vector3F<TScalar> value, float alpha)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "bgra">A packed integer containing all four color components in BGRA order.</param>
+        public ColorBGRA(uint bgra)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "bgra">A packed integer containing all four color components in BGRA.</param>
+        public ColorBGRA(int bgra)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, and blue, alpha components of the color. This must be an array with four elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public ColorBGRA(float[] values)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorBGRA"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, and blue, alpha components of the color. This must be an array with four elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public ColorBGRA(byte[] values)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the component at the specified index.
+        /// </summary>
+        /// <value>The value of the alpha, red, green, or blue component, depending on the index.</value>
+        /// <param name = "index">The index of the component to access. Use 0 for the alpha component, 1 for the red component, 2 for the green component, and 3 for the blue component.</param>
+        /// <returns>The value of the component at the specified index.</returns>
+        /// <exception cref = "System.ArgumentOutOfRangeException">Thrown when the <paramref name = "index"/> is out of the range [0, 3].</exception>
+        public byte this[int index] { get; set; }
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToBgra() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToRgba() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a three component vector.
+        /// </summary>
+        /// <returns>A three component vector containing the red, green, and blue components of the color.</returns>
+        public Vector3F<TScalar> ToVector3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a three component color.
+        /// </summary>
+        /// <returns>A three component color containing the red, green, and blue components of the color.</returns>
+        public Color3<TScalar> ToColor3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a four component vector.
+        /// </summary>
+        /// <returns>A four component vector containing all four color components.</returns>
+        public Vector4F<TScalar> ToVector4<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Creates an array containing the elements of the color.
+        /// </summary>
+        /// <returns>A four-element array containing the components of the color in BGRA order.</returns>
+        public byte[] ToArray() 
+            => default;
+
+        /// <summary>
+        /// Gets the brightness.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetBrightness() 
+            => default;
+
+        /// <summary>
+        /// Gets the hue.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetHue() 
+            => default;
+
+        /// <summary>
+        /// Gets the saturation.
+        /// </summary>
+        /// <returns>The Hue-Saturation-Brightness (HSB) saturation for this <see cref = "Color"/></returns>
+        public float GetSaturation() 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed BGRA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in BGRA order</param>
+        /// <returns>A color.</returns>
+        public static ColorBGRA FromBgra(int color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed BGRA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in BGRA order</param>
+        /// <returns>A color.</returns>
+        public static ColorBGRA FromBgra(uint color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed RGBA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in RGBA order</param>
+        /// <returns>A color.</returns>
+        public static ColorBGRA FromRgba(int color) 
+            => default;
+
+        /// <summary>
+        /// Converts the color from a packed RGBA integer.
+        /// </summary>
+        /// <param name = "color">A packed integer containing all four color components in RGBA order</param>
+        /// <returns>A color.</returns>
+        public static ColorBGRA FromRgba(uint color) 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <param name = "result">When the method completes, completes the sum of the two colors.</param>
+        public static void Add(ref readonly ColorBGRA left, ref readonly ColorBGRA right, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static ColorBGRA Add(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <param name = "result">WHen the method completes, contains the difference of the two colors.</param>
+        public static void Subtract(ref readonly ColorBGRA left, ref readonly ColorBGRA right, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static ColorBGRA Subtract(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <param name = "result">When the method completes, contains the modulated color.</param>
+        public static void Modulate(ref readonly ColorBGRA left, ref readonly ColorBGRA right, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static ColorBGRA Modulate(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <param name = "result">When the method completes, contains the scaled color.</param>
+        public static void Scale(ref readonly ColorBGRA value, float scale, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static ColorBGRA Scale(ColorBGRA value, float scale) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <param name = "result">When the method completes, contains the negated color.</param>
+        public static void Negate(ref readonly ColorBGRA value, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>The negated color.</returns>
+        public static ColorBGRA Negate(ColorBGRA value) 
+            => default;
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <param name = "result">When the method completes, contains the clamped value.</param>
+        public static void Clamp(ref readonly ColorBGRA value, ref readonly ColorBGRA min, ref readonly ColorBGRA max, out ColorBGRA result)
+        {
+        }
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <returns>The clamped value.</returns>
+        public static ColorBGRA Clamp(ColorBGRA value, ColorBGRA min, ColorBGRA max) 
+            => default;
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the linear interpolation of the two colors.</param>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static void Lerp(ref readonly ColorBGRA start, ref readonly ColorBGRA end, float amount, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The linear interpolation of the two colors.</returns>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static ColorBGRA Lerp(ColorBGRA start, ColorBGRA end, float amount) 
+            => default;
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the cubic interpolation of the two colors.</param>
+        public static void SmoothStep(ref readonly ColorBGRA start, ref readonly ColorBGRA end, float amount, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The cubic interpolation of the two colors.</returns>
+        public static ColorBGRA SmoothStep(ColorBGRA start, ColorBGRA end, float amount) 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colorss.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the largest components of the source colorss.</param>
+        public static void Max(ref readonly ColorBGRA left, ref readonly ColorBGRA right, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the largest components of the specified colorss.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the largest components of the source colors.</returns>
+        public static ColorBGRA Max(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the smallest components of the source colors.</param>
+        public static void Min(ref readonly ColorBGRA left, ref readonly ColorBGRA right, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the smallest components of the source colors.</returns>
+        public static ColorBGRA Min(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustContrast(ref readonly ColorBGRA value, float contrast, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <returns>The adjusted color.</returns>
+        public static ColorBGRA AdjustContrast(ColorBGRA value, float contrast) 
+            => default;
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustSaturation(ref readonly ColorBGRA value, float saturation, out ColorBGRA result)
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <returns>The adjusted color.</returns>
+        public static ColorBGRA AdjustSaturation(ColorBGRA value, float saturation) 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static ColorBGRA operator +(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Assert a color (return it unchanged).
+        /// </summary>
+        /// <param name = "value">The color to assert (unchange).</param>
+        /// <returns>The asserted (unchanged) color.</returns>
+        public static ColorBGRA operator +(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static ColorBGRA operator -(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>A negated color.</returns>
+        public static ColorBGRA operator -(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "scale">The factor by which to scale the color.</param>
+        /// <param name = "value">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static ColorBGRA operator *(float scale, ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The factor by which to scale the color.</param>
+        /// <param name = "scale">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static ColorBGRA operator *(ColorBGRA value, float scale) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static ColorBGRA operator *(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Tests for equality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has the same value as <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Tests for inequality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has a different value than <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(ColorBGRA left, ColorBGRA right) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "ColorBGRA"/> to <see cref = "Color3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color3<TScalar>(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "ColorBGRA"/> to <see cref = "Vector3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector3F<TScalar>(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "ColorBGRA"/> to <see cref = "Vector4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector4F<TScalar>(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "ColorBGRA"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color4<TScalar>(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector3"/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator ColorBGRA(Vector3F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color3"/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator ColorBGRA(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector4"/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator ColorBGRA(Vector4F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color4"/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator ColorBGRA(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref = "Color"/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static implicit operator ColorBGRA(Color value) 
+            => default;
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref = "ColorBGRA"/> to <see cref = "Color"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static implicit operator Color(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "ColorBGRA"/> to <see cref = "int "/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator int (ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "int "/> to <see cref = "ColorBGRA"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator ColorBGRA(int value) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public override string ToString() 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format to apply to each channel (byte).</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format to apply to each channel (byte).</param>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format, IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode() 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "ColorBGRA"/> is equal to this instance.
+        /// </summary>
+        /// <param name = "other">The <see cref = "ColorBGRA"/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "ColorBGRA"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals(ColorBGRA other) 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "object "/> is equal to this instance.
+        /// </summary>
+        /// <param name = "value">The <see cref = "object "/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "object "/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object value) 
+            => default;
+
+        /// <summary>
+        /// Deconstructs the vector's components into named variables.
+        /// </summary>
+        /// <param name = "r">The R component</param>
+        /// <param name = "g">The G component</param>
+        /// <param name = "b">The B component</param>
+        /// <param name = "a">The A component</param>
+        public void Deconstruct(out byte r, out byte g, out byte b, out byte a)
+        {
+        }
+
+    }
+```
 ### ColorHSV
 
+```csharp
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    public struct ColorHSV : IEquatable<ColorHSV>, IFormattable
+    {
+        public float H;
+        public float S;
+        public float V;
+        public float A;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "ColorHSV"/> struct.
+        /// </summary>
+        /// <param name = "h">The h.</param>
+        /// <param name = "s">The s.</param>
+        /// <param name = "v">The v.</param>
+        /// <param name = "a">A.</param>
+        public ColorHSV(float h, float s, float v, float a)
+        {
+        }
+
+        /// <summary>
+        /// Converts the color into a three component vector.
+        /// </summary>
+        /// <returns>A three component vector containing the red, green, and blue components of the color.</returns>
+        public Color4<TScalar> ToColor<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <inheritdoc/>
+        public bool Equals(ColorHSV other) 
+            => default;
+
+        /// <inheritdoc/>
+        public override bool Equals(object obj) 
+            => default;
+
+        /// <inheritdoc/>
+        public override int GetHashCode() 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public override string ToString() 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format.</param>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format, IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Deconstructs the vector's components into named variables.
+        /// </summary>
+        /// <param name = "h">The H component</param>
+        /// <param name = "s">The S component</param>
+        /// <param name = "v">The V component</param>
+        /// <param name = "a">The A component</param>
+        public void Deconstruct(out float h, out float s, out float v, out float a)
+        {
+        }
+
+    }
+```
 ### Color3
+```csharp
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    public struct Color3<TScalar> : IEquatable<Color3<TScalar>>, IFormattable where TScalar : IFloatingPointIeee754<TScalar>
+    {
+        public TScalar R;
+        public TScalar G;
+        public TScalar B;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public Color3(TScalar value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        public Color3(TScalar red, TScalar green, TScalar blue)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, and blue components of the color.</param>
+        public Color3(Vector3F<TScalar> value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "rgb">A packed integer containing all three color components.
+        /// The alpha component is ignored.</param>
+        public Color3(int rgb)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "rgb">A packed unsigned integer containing all three color components.
+        /// The alpha component is ignored.</param>
+        public Color3(uint rgb)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color3"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, and blue components of the color. This must be an array with three elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public Color3(TScalar[] values)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the component at the specified index.
+        /// </summary>
+        /// <value>The value of the red, green, or blue component, depending on the index.</value>
+        /// <param name = "index">The index of the component to access. Use 0 for the red component, 1 for the green component, and 2 for the blue component.</param>
+        /// <returns>The value of the component at the specified index.</returns>
+        /// <exception cref = "System.ArgumentOutOfRangeException">Thrown when the <paramref name = "index"/> is out of the range [0, 2].</exception>
+        public TScalar this[int index] { get; set; }
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all three color components.
+        /// The alpha channel is set to 255.</returns>
+        public int ToRgb() 
+            => default;
+
+        /// <summary>
+        /// Raises the exponent for each components.
+        /// </summary>
+        /// <param name = "exponent">The exponent.</param>
+        public void Pow(TScalar exponent)
+        {
+        }
+
+        /// <summary>
+        /// Converts the color into a three component vector.
+        /// </summary>
+        /// <returns>A three component vector containing the red, green, and blue components of the color.</returns>
+        public Vector3F<TScalar> ToVector3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Creates an array containing the elements of the color.
+        /// </summary>
+        /// <returns>A three-element array containing the components of the color.</returns>
+        public TScalar[] ToArray() 
+            => default;
+
+        /// <summary>
+        /// Converts this color from linear space to sRGB space.
+        /// </summary>
+        /// <returns>A color3 in sRGB space.</returns>
+        public Color3<TScalar> ToSRgb<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts this color from sRGB space to linear space.
+        /// </summary>
+        /// <returns>Color3.</returns>
+        public Color3<TScalar> ToLinear<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color3<TScalar> operator +(Color3<TScalar> left, Color3<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Assert a color (return it unchanged).
+        /// </summary>
+        /// <param name = "value">The color to assert (unchange).</param>
+        /// <returns>The asserted (unchanged) color.</returns>
+        public static Color3<TScalar> operator +(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color3<TScalar> operator -(Color3<TScalar> left, Color3<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>A negated color.</returns>
+        public static Color3<TScalar> operator -(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "scale">The factor by which to scale the color.</param>
+        /// <param name = "value">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color3<TScalar> operator *(TScalar scale, Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The factor by which to scale the color.</param>
+        /// <param name = "scale">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color3<TScalar> operator *(Color3<TScalar> value, TScalar scale) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color3<TScalar> operator *(Color3<TScalar> left, Color3<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Tests for equality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has the same value as <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(Color3<TScalar> left, Color3<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Tests for inequality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has a different value than <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(Color3<TScalar> left, Color3<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color3"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color4<TScalar>(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color3"/> to <see cref = "Stride.Core.Mathematics.Vector3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector3F<TScalar>(Color3<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Stride.Core.Mathematics.Vector3"/> to <see cref = "Color3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color3<TScalar>(Vector3F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "int "/> to <see cref = "Color3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color3<TScalar>(int value) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public override string ToString() 
+            => default;
+
+        /// <summary>
+        /// Convert this color to an equivalent <see cref = "Color4"/> with an opaque alpha.
+        /// </summary>
+        /// <returns>An equivalent <see cref = "Color4"/> with an opaque alpha.</returns>
+        public Color4<TScalar> ToColor4<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format.</param>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format, IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode() 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "Color3"/> is equal to this instance.
+        /// </summary>
+        /// <param name = "other">The <see cref = "Color3"/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "Color3"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals<TScalar>(Color3<TScalar> other)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "object "/> is equal to this instance.
+        /// </summary>
+        /// <param name = "value">The <see cref = "object "/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "object "/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object value) 
+            => default;
+
+        /// <summary>
+        /// Deconstructs the vector's components into named variables.
+        /// </summary>
+        /// <param name = "r">The R component</param>
+        /// <param name = "g">The G component</param>
+        /// <param name = "b">The B component</param>
+        public void Deconstruct(out TScalar r, out TScalar g, out TScalar b)
+        {
+        }
+
+    }
+```
+```csharp
+    public static class Color3
+    {
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <param name = "result">When the method completes, completes the sum of the two colors.</param>
+        public static void Add<TScalar>(ref readonly Color3<TScalar> left, ref readonly Color3<TScalar> right, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color3<TScalar> Add<TScalar>(Color3<TScalar> left, Color3<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <param name = "result">WHen the method completes, contains the difference of the two colors.</param>
+        public static void Subtract<TScalar>(ref readonly Color3<TScalar> left, ref readonly Color3<TScalar> right, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color3<TScalar> Subtract<TScalar>(Color3<TScalar> left, Color3<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <param name = "result">When the method completes, contains the modulated color.</param>
+        public static void Modulate<TScalar>(ref readonly Color3<TScalar> left, ref readonly Color3<TScalar> right, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color3<TScalar> Modulate<TScalar>(Color3<TScalar> left, Color3<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <param name = "result">When the method completes, contains the scaled color.</param>
+        public static void Scale<TScalar>(ref readonly Color3<TScalar> value, TScalar scale, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color3<TScalar> Scale<TScalar>(Color3<TScalar> value, TScalar scale)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <param name = "result">When the method completes, contains the negated color.</param>
+        public static void Negate<TScalar>(ref readonly Color3<TScalar> value, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>The negated color.</returns>
+        public static Color3<TScalar> Negate<TScalar>(Color3<TScalar> value)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <param name = "result">When the method completes, contains the clamped value.</param>
+        public static void Clamp<TScalar>(ref readonly Color3<TScalar> value, ref readonly Color3<TScalar> min, ref readonly Color3<TScalar> max, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Color3<TScalar> Clamp<TScalar>(Color3<TScalar> value, Color3<TScalar> min, Color3<TScalar> max)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the linear interpolation of the two colors.</param>
+        /// <remarks>
+        /// This method performs the linear interpolation based on the following formula.
+        /// <code>start + (end - start) * amount</code>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static void Lerp<TScalar>(ref readonly Color3<TScalar> start, ref readonly Color3<TScalar> end, TScalar amount, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The linear interpolation of the two colors.</returns>
+        /// <remarks>
+        /// This method performs the linear interpolation based on the following formula.
+        /// <code>start + (end - start) * amount</code>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static Color3<TScalar> Lerp<TScalar>(Color3<TScalar> start, Color3<TScalar> end, TScalar amount)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the cubic interpolation of the two colors.</param>
+        public static void SmoothStep<TScalar>(ref readonly Color3<TScalar> start, ref readonly Color3<TScalar> end, TScalar amount, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The cubic interpolation of the two colors.</returns>
+        public static Color3<TScalar> SmoothStep<TScalar>(Color3<TScalar> start, Color3<TScalar> end, TScalar amount)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colorss.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the largest components of the source colorss.</param>
+        public static void Max<TScalar>(ref readonly Color3<TScalar> left, ref readonly Color3<TScalar> right, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the largest components of the specified colorss.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the largest components of the source colors.</returns>
+        public static Color3<TScalar> Max<TScalar>(Color3<TScalar> left, Color3<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the smallest components of the source colors.</param>
+        public static void Min<TScalar>(ref readonly Color3<TScalar> left, ref readonly Color3<TScalar> right, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the smallest components of the source colors.</returns>
+        public static Color3<TScalar> Min<TScalar>(Color3<TScalar> left, Color3<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustContrast<TScalar>(ref readonly Color3<TScalar> value, TScalar contrast, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color3<TScalar> AdjustContrast<TScalar>(Color3<TScalar> value, TScalar contrast)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustSaturation<TScalar>(ref readonly Color3<TScalar> value, TScalar saturation, out Color3<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
 
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color3<TScalar> AdjustSaturation<TScalar>(Color3<TScalar> value, TScalar saturation)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+    }
+```
 ### Color4
+```csharp
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
+    public struct Color4<TScalar> : IEquatable<Color4<TScalar>>, IFormattable where TScalar : IFloatingPointIeee754<TScalar>
+    {
+        /// <summary>
+        /// The Black color (0, 0, 0, 1).
+        /// </summary>
+        public static readonly Color4<TScalar> Black = new Color4<TScalar>(0.0f, 0.0f, 0.0f, 1.0f);
+        /// <summary>
+        /// The White color (1, 1, 1, 1).
+        /// </summary>
+        public static readonly Color4<TScalar> White = new Color4<TScalar>(1.0f, 1.0f, 1.0f, 1.0f);
+        public TScalar R;
+        public TScalar G;
+        public TScalar B;
+        public TScalar A;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "value">The value that will be assigned to all components.</param>
+        public Color4(TScalar value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "red">The red component of the color.</param>
+        /// <param name = "green">The green component of the color.</param>
+        /// <param name = "blue">The blue component of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color4(TScalar red, TScalar green, TScalar blue, TScalar alpha = 1f)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, blue, and alpha components of the color.</param>
+        public Color4(Vector4F<TScalar> value)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "value">The red, green, and blue components of the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color4(Vector3F<TScalar> value, TScalar alpha = 1f)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "rgba">A packed integer containing all four color components in RGBA order.</param>
+        public Color4(uint rgba)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "rgba">A packed integer containing all four color components in RGBA order.</param>
+        public Color4(int rgba)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "values">The values to assign to the red, green, blue, and alpha components of the color. This must be an array with four elements.</param>
+        /// <exception cref = "ArgumentNullException">Thrown when <paramref name = "values"/> is <c>null</c>.</exception>
+        /// <exception cref = "ArgumentOutOfRangeException">Thrown when <paramref name = "values"/> contains more or less than four elements.</exception>
+        public Color4(TScalar[] values)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "color"><see cref = "Color3"/> used to initialize the color.</param>
+        public Color4(Color3<TScalar> color)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "color"><see cref = "Color"/> used to initialize the color.</param>
+        public Color4(Color color)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "color"><see cref = "Color"/> used to initialize the color.</param>
+        public Color4(ColorBGRA color)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref = "Color4"/> struct.
+        /// </summary>
+        /// <param name = "color"><see cref = "Color3"/> used to initialize the color.</param>
+        /// <param name = "alpha">The alpha component of the color.</param>
+        public Color4(Color3<TScalar> color, TScalar alpha = 1f)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the component at the specified index.
+        /// </summary>
+        /// <value>The value of the red, green, blue, and alpha components, depending on the index.</value>
+        /// <param name = "index">The index of the component to access. Use 0 for the alpha component, 1 for the red component, 2 for the green component, and 3 for the blue component.</param>
+        /// <returns>The value of the component at the specified index.</returns>
+        /// <exception cref = "System.ArgumentOutOfRangeException">Thrown when the <paramref name = "index"/> is out of the range [0, 3].</exception>
+        public TScalar this[int index] { get; set; }
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToBgra() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        public void ToBgra(out byte r, out byte g, out byte b, out byte a)
+        {
+        }
+
+        /// <summary>
+        /// Converts the color into a packed integer.
+        /// </summary>
+        /// <returns>A packed integer containing all four color components.</returns>
+        public int ToRgba() 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a three component vector.
+        /// </summary>
+        /// <returns>A three component vector containing the red, green, and blue components of the color.</returns>
+        public Vector3F<TScalar> ToVector3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts the color into a four component vector.
+        /// </summary>
+        /// <returns>A four component vector containing all four color components.</returns>
+        public Vector4F<TScalar> ToVector4<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Creates an array containing the elements of the color.
+        /// </summary>
+        /// <returns>A four-element array containing the components of the color.</returns>
+        public TScalar[] ToArray() 
+            => default;
+
+        /// <summary>
+        /// Converts this color from linear space to sRGB space.
+        /// </summary>
+        /// <returns>A color3 in sRGB space.</returns>
+        public Color4<TScalar> ToSRgb<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Converts this color from sRGB space to linear space.
+        /// </summary>
+        /// <returns>A color4 in linear space.</returns>
+        public Color4<TScalar> ToLinear<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color4<TScalar> operator +(Color4<TScalar> left, Color4<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Assert a color (return it unchanged).
+        /// </summary>
+        /// <param name = "value">The color to assert (unchanged).</param>
+        /// <returns>The asserted (unchanged) color.</returns>
+        public static Color4<TScalar> operator +(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color4<TScalar> operator -(Color4<TScalar> left, Color4<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>A negated color.</returns>
+        public static Color4<TScalar> operator -(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "scale">The factor by which to scale the color.</param>
+        /// <param name = "value">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color4<TScalar> operator *(TScalar scale, Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The factor by which to scale the color.</param>
+        /// <param name = "scale">The color to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color4<TScalar> operator *(Color4<TScalar> value, TScalar scale) 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color4<TScalar> operator *(Color4<TScalar> left, Color4<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Tests for equality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has the same value as <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator ==(Color4<TScalar> left, Color4<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Tests for inequality between two objects.
+        /// </summary>
+        /// <param name = "left">The first value to compare.</param>
+        /// <param name = "right">The second value to compare.</param>
+        /// <returns><c>true</c> if <paramref name = "left"/> has a different value than <paramref name = "right"/>; otherwise, <c>false</c>.</returns>
+        public static bool operator !=(Color4<TScalar> left, Color4<TScalar> right) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color4"/> to <see cref = "Color3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color3<TScalar>(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color4"/> to <see cref = "Vector3"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Vector3F<TScalar>(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref = "Color4"/> to <see cref = "Vector4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static implicit operator Vector4F<TScalar>(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector3"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color4<TScalar>(Vector3F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector4"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color4<TScalar>(Vector4F<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector3"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator Color4<TScalar>(ColorBGRA value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Vector4"/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>The result of the conversion.</returns>
+        public static explicit operator ColorBGRA(Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "Color4"/> to <see cref = "int "/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator int (Color4<TScalar> value) 
+            => default;
+
+        /// <summary>
+        /// Performs an explicit conversion from <see cref = "int "/> to <see cref = "Color4"/>.
+        /// </summary>
+        /// <param name = "value">The value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static explicit operator Color4<TScalar>(int value) 
+            => default;
+
+        /// <summary>
+        /// Converts this color to an equivalent <see cref = "Color3"/>, discarding the alpha channel.
+        /// </summary>
+        /// <returns>An equivalent <see cref = "Color3"/>, discarding the alpha channel.</returns>
+        public Color3<TScalar> ToColor3<TScalar>()
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public override string ToString() 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format to apply to each channel (float).</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a <see cref = "string "/> that represents this instance.
+        /// </summary>
+        /// <param name = "format">The format to apply to each channel (float).</param>
+        /// <param name = "formatProvider">The format provider.</param>
+        /// <returns>
+        /// A <see cref = "string "/> that represents this instance.
+        /// </returns>
+        public string ToString(string format, IFormatProvider formatProvider) 
+            => default;
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode() 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "Color4"/> is equal to this instance.
+        /// </summary>
+        /// <param name = "other">The <see cref = "Color4"/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "Color4"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public bool Equals<TScalar>(Color4<TScalar> other)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Determines whether the specified <see cref = "object "/> is equal to this instance.
+        /// </summary>
+        /// <param name = "value">The <see cref = "object "/> to compare with this instance.</param>
+        /// <returns>
+        /// <c>true</c> if the specified <see cref = "object "/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        public override bool Equals(object value) 
+            => default;
+
+        /// <summary>
+        /// Deconstructs the vector's components into named variables.
+        /// </summary>
+        /// <param name = "r">The R component</param>
+        /// <param name = "g">The G component</param>
+        /// <param name = "b">The B component</param>
+        /// <param name = "a">The A component</param>
+        public void Deconstruct(out TScalar r, out TScalar g, out TScalar b, out TScalar a)
+        {
+        }
+
+    }
+```
+```csharp
+    public static class Color4
+    {
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <param name = "result">When the method completes, completes the sum of the two colors.</param>
+        public static void Add<TScalar>(ref readonly Color4<TScalar> left, ref readonly Color4<TScalar> right, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Adds two colors.
+        /// </summary>
+        /// <param name = "left">The first color to add.</param>
+        /// <param name = "right">The second color to add.</param>
+        /// <returns>The sum of the two colors.</returns>
+        public static Color4<TScalar> Add<TScalar>(Color4<TScalar> left, Color4<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract.</param>
+        /// <param name = "result">WHen the method completes, contains the difference of the two colors.</param>
+        public static void Subtract<TScalar>(ref readonly Color4<TScalar> left, ref readonly Color4<TScalar> right, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Subtracts two colors.
+        /// </summary>
+        /// <param name = "left">The first color to subtract.</param>
+        /// <param name = "right">The second color to subtract</param>
+        /// <returns>The difference of the two colors.</returns>
+        public static Color4<TScalar> Subtract<TScalar>(Color4<TScalar> left, Color4<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <param name = "result">When the method completes, contains the modulated color.</param>
+        public static void Modulate<TScalar>(ref readonly Color4<TScalar> left, ref readonly Color4<TScalar> right, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Modulates two colors.
+        /// </summary>
+        /// <param name = "left">The first color to modulate.</param>
+        /// <param name = "right">The second color to modulate.</param>
+        /// <returns>The modulated color.</returns>
+        public static Color4<TScalar> Modulate<TScalar>(Color4<TScalar> left, Color4<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <param name = "result">When the method completes, contains the scaled color.</param>
+        public static void Scale<TScalar>(ref readonly Color4<TScalar> value, TScalar scale, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Scales a color.
+        /// </summary>
+        /// <param name = "value">The color to scale.</param>
+        /// <param name = "scale">The amount by which to scale.</param>
+        /// <returns>The scaled color.</returns>
+        public static Color4<TScalar> Scale<TScalar>(Color4<TScalar> value, TScalar scale)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <param name = "result">When the method completes, contains the negated color.</param>
+        public static void Negate<TScalar>(ref readonly Color4<TScalar> value, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Negates a color.
+        /// </summary>
+        /// <param name = "value">The color to negate.</param>
+        /// <returns>The negated color.</returns>
+        public static Color4<TScalar> Negate<TScalar>(Color4<TScalar> value)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <param name = "result">When the method completes, contains the clamped value.</param>
+        public static void Clamp<TScalar>(ref readonly Color4<TScalar> value, ref readonly Color4<TScalar> min, ref readonly Color4<TScalar> max, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <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>
+        /// <param name = "max">The maximum value.</param>
+        /// <returns>The clamped value.</returns>
+        public static Color4<TScalar> Clamp<TScalar>(Color4<TScalar> value, Color4<TScalar> min, Color4<TScalar> max)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the linear interpolation of the two colors.</param>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static void Lerp<TScalar>(ref readonly Color4<TScalar> start, ref readonly Color4<TScalar> end, TScalar amount, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Performs a linear interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The linear interpolation of the two colors.</returns>
+        /// <remarks>
+        /// Passing <paramref name = "amount"/> a value of 0 will cause <paramref name = "start"/> to be returned; a value of 1 will cause <paramref name = "end"/> to be returned. 
+        /// </remarks>
+        public static Color4<TScalar> Lerp<TScalar>(Color4<TScalar> start, Color4<TScalar> end, TScalar amount)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <param name = "result">When the method completes, contains the cubic interpolation of the two colors.</param>
+        public static void SmoothStep<TScalar>(ref readonly Color4<TScalar> start, ref readonly Color4<TScalar> end, TScalar amount, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Performs a cubic interpolation between two colors.
+        /// </summary>
+        /// <param name = "start">Start color.</param>
+        /// <param name = "end">End color.</param>
+        /// <param name = "amount">Value between 0 and 1 indicating the weight of <paramref name = "end"/>.</param>
+        /// <returns>The cubic interpolation of the two colors.</returns>
+        public static Color4<TScalar> SmoothStep<TScalar>(Color4<TScalar> start, Color4<TScalar> end, TScalar amount)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the largest components of the source colors.</param>
+        public static void Max<TScalar>(ref readonly Color4<TScalar> left, ref readonly Color4<TScalar> right, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the largest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the largest components of the source colors.</returns>
+        public static Color4<TScalar> Max<TScalar>(Color4<TScalar> left, Color4<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <param name = "result">When the method completes, contains an new color composed of the smallest components of the source colors.</param>
+        public static void Min<TScalar>(ref readonly Color4<TScalar> left, ref readonly Color4<TScalar> right, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Returns a color containing the smallest components of the specified colors.
+        /// </summary>
+        /// <param name = "left">The first source color.</param>
+        /// <param name = "right">The second source color.</param>
+        /// <returns>A color containing the smallest components of the source colors.</returns>
+        public static Color4<TScalar> Min<TScalar>(Color4<TScalar> left, Color4<TScalar> right)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustContrast<TScalar>(ref readonly Color4<TScalar> value, TScalar contrast, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the contrast of a color.
+        /// </summary>
+        /// <param name = "value">The color whose contrast is to be adjusted.</param>
+        /// <param name = "contrast">The amount by which to adjust the contrast.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color4<TScalar> AdjustContrast<TScalar>(Color4<TScalar> value, TScalar contrast)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <param name = "result">When the method completes, contains the adjusted color.</param>
+        public static void AdjustSaturation<TScalar>(ref readonly Color4<TScalar> value, TScalar saturation, out Color4<TScalar> result)
+            where TScalar : IFloatingPointIeee754<TScalar>
+        {
+        }
+
+        /// <summary>
+        /// Adjusts the saturation of a color.
+        /// </summary>
+        /// <param name = "value">The color whose saturation is to be adjusted.</param>
+        /// <param name = "saturation">The amount by which to adjust the saturation.</param>
+        /// <returns>The adjusted color.</returns>
+        public static Color4<TScalar> AdjustSaturation<TScalar>(Color4<TScalar> value, TScalar saturation)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+        /// <summary>
+        /// Premultiplies the color components by the alpha value.
+        /// </summary>
+        /// <param name = "value">The color to premultiply.</param>
+        /// <returns>A color with premultiplied alpha.</returns>
+        public static Color4<TScalar> PremultiplyAlpha<TScalar>(Color4<TScalar> value)
+            where TScalar : IFloatingPointIeee754<TScalar> 
+            => default;
+
+    }
+```
+
 
 # Meeting Agenda/Notes
+## TBD
+* Started with an initial rough cut by copying the API of Stride color types. IF we want to move forward with these we can just copy and attribute.
\ No newline at end of file

From 34034942c7b1c9fcbef2dc17eeeea6a62e00cbd1 Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 30 Nov 2024 14:09:45 +1000
Subject: [PATCH 23/25] propsal - angle: change: add "in" modifier to some
 methods.

---
 .../proposals/Proposal - 3.0 Additional math types - Angle.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
index a834fb014f..375fbc8f96 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md	
@@ -197,11 +197,11 @@ public static class Angle
         where TScalar : IFloatingPointIeee754<TScalar>
          => default;
 
-    public static Angle<TScalar> Between<TScalar>(Vector2F<TScalar> left, Vector2F<TScalar> right)
+    public static Angle<TScalar> Between<TScalar>(in Vector2F<TScalar> left, in Vector2F<TScalar> right)
        where TScalar : IFloatingPointIeee754<TScalar>
        => default;
 
-    public static Angle<TScalar> Between<TScalar>(Vector3F<TScalar> left, Vector3F<TScalar> right)
+    public static Angle<TScalar> Between<TScalar>(in Vector3F<TScalar> left, in Vector3F<TScalar> right)
        where TScalar : IFloatingPointIeee754<TScalar>
        => default;
 

From 103d95b1b9b690e578496020434b845de649e9db Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 30 Nov 2024 14:11:03 +1000
Subject: [PATCH 24/25] proposal - collision: add more details for BoxExtentF
 and OrientedBoxF

---
 ...- 3.0 Additional math types - Collision.md | 41 +++++++++++++++----
 1 file changed, 33 insertions(+), 8 deletions(-)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
index c0c2cae23a..a5d2f094d5 100644
--- a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
+++ b/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md	
@@ -26,7 +26,7 @@ Where it is appropriate for a type in this proposal to have both integer and flo
 
 # Proposed API
 
-`Silk.NET.Math` and the generic math proposal for 3.0 already contain "geometric types that would be suitable to use for collision/intersection types. i.e. Box3F.
+`Silk.NET.Math` and the generic math proposal for 3.0 already contain "geometric types" that would be suitable to use for collision/intersection types. i.e. Box3F.
 
 This proposal is to add additional APIs for the purpose of intersection tests.
 
@@ -177,11 +177,36 @@ public struct SphereF<TScalar>
 }
 ```
 
-### BoxFExtent
+### BoxExtentF
 
 Access aligned box for fast frustum culling. Interface implementations not included for brevity.
 
+* Must include the same members as mentioned in the Generic Math proposal in the `Geometric Types` section 
+
 ```csharp
+public struct BoxExtentF<TScalar>
+    : IEquatable<BoxExtentF<TScalar>>
+    , IEqualityOperators<BoxExtentF<TScalar>, BoxExtentF<TScalar>, bool>
+    , IIntersectWithRay<BoxExtentF<TScalar>, TScalar>
+    , IIntersectWithPlane<BoxExtentF<TScalar>, TScalar>
+    , IColliderShape<BoxExtentF<TScalar>, TScalar>
+    , IContainPoint<BoxExtentF<TScalar>, TScalar>
+    , IIntersect<BoxExtentF<TScalar>, BoxExtentF<TScalar>>
+    //Implement IIntersect for other shapes
+    , IContain<BoxExtentF<TScalar>, BoxExtentF<TScalar>>
+    //Implement IContain for other shapes
+    , IFormattable
+    where TScalar : IBinaryFloatingPointIeee754<TScalar>
+{
+    public Vector3F<TScalar> Center;
+    public Vector3F<TScalar> Extents;
+
+    public BoxExtentF(BoxF<TScalar> box);
+    public BoxExtentF(Vector3F<TScalar> minimum, Vector3F<TScalar> maximum);
+
+    public static explicit operator BoxF<TScalar>(BoxExtentF<TScalar> boxExtent);
+    public static explicit operator BoxExtentF<TScalar>(BoxF<TScalar> box)
+}
 
 ```
 
@@ -189,6 +214,8 @@ Access aligned box for fast frustum culling. Interface implementations not inclu
 
 Box with orientation. Interface implementations not included for brevity.
 
+* Must include the same members as mentioned in the Generic Math proposal in the `Geometric Types` section 
+
 ```csharp
 public struct OrientedBoxF<TScalar>
     : IEquatable<OrientedBoxF<TScalar>>
@@ -204,7 +231,11 @@ public struct OrientedBoxF<TScalar>
     , IFormattable
     where TScalar : IBinaryFloatingPointIeee754<TScalar>
 {
+    public Vector3F<TScalar> Center;
+    public Vector3F<TScalar> Extents;
+    public Quaternion Orientation;
 
+    public OrientedBoxF(Vector3F<TScalar> center, Vector3F<TScalar> extents, Quaternion orientation);
 }
 ```
 
@@ -246,10 +277,4 @@ public static class Frustum
 
 ```
 
-### CollisionHelper
-
-```csharp
-
-```
-
 # Meeting Agenda/Notes
\ No newline at end of file

From ed05289ddb718a9f8c49afda9bd2a51a82cde27f Mon Sep 17 00:00:00 2001
From: Daniel Keenan <dfkeenan@gmail.com>
Date: Sat, 30 Nov 2024 21:15:15 +1000
Subject: [PATCH 25/25] Rename additional math type proposals to WIP

---
 ...e.md => (WIP) Proposal - 3.0 Additional math types - Angle.md} | 0
 ... => (WIP) Proposal - 3.0 Additional math types - Collision.md} | 0
 ...r.md => (WIP) Proposal - 3.0 Additional math types - Color.md} | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename documentation/proposals/{Proposal - 3.0 Additional math types - Angle.md => (WIP) Proposal - 3.0 Additional math types - Angle.md} (100%)
 rename documentation/proposals/{Proposal - 3.0 Additional math types - Collision.md => (WIP) Proposal - 3.0 Additional math types - Collision.md} (100%)
 rename documentation/proposals/{Proposal - 3.0 Additional math types - Color.md => (WIP) Proposal - 3.0 Additional math types - Color.md} (100%)

diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Angle.md b/documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Angle.md
similarity index 100%
rename from documentation/proposals/Proposal - 3.0 Additional math types - Angle.md
rename to documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Angle.md
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Collision.md b/documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Collision.md
similarity index 100%
rename from documentation/proposals/Proposal - 3.0 Additional math types - Collision.md
rename to documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Collision.md
diff --git a/documentation/proposals/Proposal - 3.0 Additional math types - Color.md b/documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Color.md
similarity index 100%
rename from documentation/proposals/Proposal - 3.0 Additional math types - Color.md
rename to documentation/proposals/(WIP) Proposal - 3.0 Additional math types - Color.md