Add project files.

Author: JunaMeinhold

Hexa.NET.Math.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.10.35027.167
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Hexa.NET.Math", "Hexa.NET.Math\Hexa.NET.Math.csproj", "{E10B41FE-6667-423A-98D9-0E9400DBA1ED}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Minimal|Any CPU = Minimal|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Minimal|Any CPU.ActiveCfg = Minimal|Any CPU
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Minimal|Any CPU.Build.0 = Minimal|Any CPU
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E10B41FE-6667-423A-98D9-0E9400DBA1ED}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {CAE93244-8755-4AF0-BC21-41BD7BD5BA00}
+	EndGlobalSection
+EndGlobal

Hexa.NET.Math/AudioOrientation.cs

@@ -0,0 +1,33 @@
+#if !MINIMAL
+namespace HexaEngine.Mathematics
+{
+    using System.Numerics;
+
+    /// <summary>
+    /// Represents a 3D orientation for 3D Audio.
+    /// </summary>
+    public struct AudioOrientation
+    {
+        /// <summary>
+        /// The look at vector normalized also called forward vector.
+        /// </summary>
+        public Vector3 At;
+
+        /// <summary>
+        /// The up vector normalized.
+        /// </summary>
+        public Vector3 Up;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AudioOrientation"/> struct.
+        /// </summary>
+        /// <param name="at">The look at vector normalized also called forward vector.</param>
+        /// <param name="up">The up vector normalized.</param>
+        public AudioOrientation(Vector3 at, Vector3 up)
+        {
+            At = at;
+            Up = up;
+        }
+    }
+}
+#endif

Hexa.NET.Math/BezierCurve.cs

@@ -0,0 +1,52 @@
+namespace HexaEngine.Mathematics
+{
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Represents a Bezier curve with two control points.
+    /// </summary>
+    [InlineArray(2)]
+    public unsafe struct BezierCurve
+    {
+        private Vector2 _element0;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BezierCurve"/> struct.
+        /// </summary>
+        /// <param name="p0">Control point 0 of the curve.</param>
+        /// <param name="p1">Control point 1 of the curve.</param>
+        public BezierCurve(Vector2 p0, Vector2 p1)
+        {
+            this[0] = p0;
+            this[1] = p1;
+        }
+
+        /// <summary>
+        /// Computes a point on the Bezier curve at the given parameter <paramref name="t"/>.
+        /// </summary>
+        /// <param name="t">The parameter ranging from 0 to 1.</param>
+        /// <returns>The computed point on the Bezier curve.</returns>
+        public readonly Vector2 ComputePoint(float t)
+        {
+            float u = 1 - t;
+            float tt = t * t;
+            float uu = u * u;
+            float uuu = uu * u;
+            float ttt = tt * t;
+
+            float p0 = uuu;
+            float p1 = 3 * uu * t;
+            float p2 = 3 * u * tt;
+            float p3 = ttt;
+
+            Vector2* Q = stackalloc Vector2[] { new Vector2(0, 0), this[0], this[1], new Vector2(1, 1) };
+
+            Vector2 point = new(
+                p0 * Q[0].X + p1 * this[1].X + p2 * Q[2].X + p3 * Q[3].X,
+                p0 * Q[0].Y + p1 * this[1].Y + p2 * Q[2].Y + p3 * Q[3].Y);
+
+            return point;
+        }
+    }
+}

Hexa.NET.Math/BezierTable.cs

@@ -0,0 +1,135 @@
+namespace HexaEngine.Mathematics
+{
+    using System.Numerics;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Represents a structure for computing a Bezier table.
+    /// </summary>
+    public unsafe struct BezierTable
+    {
+        private readonly int steps;
+        private float* c;
+        private float* k;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BezierTable"/> struct with the specified number of steps.
+        /// </summary>
+        /// <param name="steps">The number of steps for the Bezier table.</param>
+        public BezierTable(int steps)
+        {
+            c = (float*)Marshal.AllocHGlobal((steps + 1) * 4 * sizeof(float));
+            this.steps = steps;
+        }
+
+        /// <summary>
+        /// Gets the Bezier control points array.
+        /// </summary>
+        public readonly float* C => C;
+
+        /// <summary>
+        /// Gets the number of steps in the Bezier table.
+        /// </summary>
+        public readonly int Steps => steps;
+
+        /// <summary>
+        /// Computes the Bezier curve given the control points.
+        /// </summary>
+        /// <param name="p">An array of four control points for the Bezier curve.</param>
+        /// <param name="results">An array to store the computed points on the Bezier curve.</param>
+        /// <remarks>
+        /// The <paramref name="p"/> array must be 4 elements long, and the <paramref name="results"/>
+        /// array must be equal to <see cref="Steps"/> + 1 in length.
+        /// </remarks>
+        public void Compute(Vector2* p /* must be 4 long */, Vector2* results /* must be equals to Steps + 1 long */)
+        {
+            if (k == null)
+            {
+                k = c;
+                for (uint step = 0; step <= steps; ++step)
+                {
+                    float t = (float)step / steps;
+                    c[step * 4 + 0] = (1 - t) * (1 - t) * (1 - t); // * P0
+                    c[step * 4 + 1] = 3 * (1 - t) * (1 - t) * t;   // * P1
+                    c[step * 4 + 2] = 3 * (1 - t) * t * t;         // * P2
+                    c[step * 4 + 3] = t * t * t;                   // * P3
+                }
+            }
+
+            for (uint step = 0; step <= steps; ++step)
+            {
+                Vector2 point = new(
+                k[step * 4 + 0] * p[0].X + k[step * 4 + 1] * p[1].X + k[step * 4 + 2] * p[2].X + k[step * 4 + 3] * p[3].X,
+                k[step * 4 + 0] * p[0].Y + k[step * 4 + 1] * p[1].Y + k[step * 4 + 2] * p[2].Y + k[step * 4 + 3] * p[3].Y);
+                results[step] = point;
+            }
+        }
+
+        /// <summary>
+        /// Computes points on the Bezier curve using the provided <paramref name="curve"/> and stores the results in the specified <paramref name="results"/>.
+        /// </summary>
+        /// <param name="curve">The Bezier curve with four control points.</param>
+        /// <param name="results">The array to store the computed points. Must be equal to <see cref="Steps"/> + 1 in length.</param>
+        public void Compute(BezierCurve curve, Vector2* results /* must be equals to Steps + 1 long */)
+        {
+            if (k == null)
+            {
+                k = c;
+                for (uint step = 0; step <= steps; ++step)
+                {
+                    float t = (float)step / steps;
+                    c[step * 4 + 0] = (1 - t) * (1 - t) * (1 - t); // * P0
+                    c[step * 4 + 1] = 3 * (1 - t) * (1 - t) * t;   // * P1
+                    c[step * 4 + 2] = 3 * (1 - t) * t * t;         // * P2
+                    c[step * 4 + 3] = t * t * t;                   // * P3
+                }
+            }
+
+            Vector2* Q = stackalloc Vector2[] { new Vector2(0, 0), curve[0], curve[1], new Vector2(1, 1) };
+
+            for (uint step = 0; step <= steps; ++step)
+            {
+                Vector2 point = new(
+                k[step * 4 + 0] * Q[0].X + k[step * 4 + 1] * Q[1].X + k[step * 4 + 2] * Q[2].X + k[step * 4 + 3] * Q[3].X,
+                k[step * 4 + 0] * Q[0].Y + k[step * 4 + 1] * Q[1].Y + k[step * 4 + 2] * Q[2].Y + k[step * 4 + 3] * Q[3].Y);
+                results[step] = point;
+            }
+        }
+
+        /// <summary>
+        /// Computes a single point on the Bezier curve given a parameter <paramref name="t"/>.
+        /// </summary>
+        /// <param name="p">Array of control points. It must be 4 long.</param>
+        /// <param name="t">Parameter value typically ranging from 0 to 1.</param>
+        /// <returns>The computed point on the Bezier curve.</returns>
+        public readonly Vector2 ComputePoint(Vector2* p, float t)
+        {
+            float u = 1 - t;
+            float tt = t * t;
+            float uu = u * u;
+            float uuu = uu * u;
+            float ttt = tt * t;
+
+            float p0 = uuu;
+            float p1 = 3 * uu * t;
+            float p2 = 3 * u * tt;
+            float p3 = ttt;
+
+            Vector2 point = new(
+                p0 * p[0].X + p1 * p[1].X + p2 * p[2].X + p3 * p[3].X,
+                p0 * p[0].Y + p1 * p[1].Y + p2 * p[2].Y + p3 * p[3].Y);
+
+            return point;
+        }
+
+        /// <summary>
+        /// Releases the resources associated with the Bezier table.
+        /// </summary>
+        public void Release()
+        {
+            Marshal.FreeHGlobal((nint)c);
+            c = null;
+            k = null;
+        }
+    }
+}