Explicit core types and autonomous types. (#304)

* All the "var" variables were changed to explicit types on the raylib class
* "MakeDirectory" overload, and string version of "GetApplicationDirectory" and "GetWorkingDirectory" methods
* Added "Dimensions" property to "Texture2D"
* New overloads for the "LoadFileData" and "SaveFileData" methods
* Raymath's const "NativeLibName" is now referencing to "Raylib.NativeLibName"
* Color constructors are more readable
* Added "Dimensions" property to "Image"
* Changed all the "var" for explicit types on the "Logging" class
* Changed "Int64" for "long" on CBool, and using constructor on the operators instead setting the value manually
* Added indexer to "FilePathLists"
* Changed all "var" for explicit types on "Utf8Buffer"
* New "GetRandomSequence" method overloads in "Raylib.Utils" acepting "int" and "float"
* Added new extension "byte.Lerp"
* Added new extension "Log" for "TraceLogLevel"
* Constructors on Color no longer just truncate the float value, but also round it (+ 0.5f)
* New static method on Color, "Color.Lerp"
* Added static method "FromHSV" to Color
* Added new getter method "GetHSV" on Color
* Added index security on the FilePathList indexer
* Added Rectangle extension
* Added "MoveTowards" extensions to RaylibExtensions
* Added "TranslateLocal" and "TranslateGlobal" to Transform
* Removed unnecessary "partial" declarations
* Updating calls and docs
* Moved the "AudioCallback" delegate into the "AudioMixed.cs" File
* Properties and structs marked as read-only on the "Model.cs" file
* Updated the "README.md" to mentions Raylib-cs targets net6.0 and net8.0 (and also explicitly added that the
"STAThread" attribute comes from the "System" namespace)
* Added a few sizing utils to "Rectangle"
* Added "GetScreenCenter" to "Raylib.Utils"

Raylib-cs/types/Raymath.Utils.cs

@@ -0,0 +1,98 @@
+using System;
+
+namespace Raylib_cs;
+
+public static partial class Raymath
+{
+    public static float Clamp01(float value) => Clamp(value, 0.0f, 1.0f);
+
+    /// <summary>
+    /// Loops the value, so that it is never larger than length and never smaller than 0
+    /// </summary>
+    public static float Repeat(float value, float length)
+    {
+        return Clamp(value - MathF.Floor(value / length) * length, 0f, length);
+    }
+
+    /// <summary>
+    /// Same as Lerp but makes sure the values interpolate correctly when they wrap around
+    /// 360 degrees.
+    /// </summary>
+    /// <param name="a">The start angle. A float expressed in degrees.</param>
+    /// <param name="b">The end angle. A float expressed in degrees.</param>
+    /// <param name="t">The interpolation value between the start and end angles.
+    /// This value is clamped to the range [0, 1].</param>
+    /// <returns>Returns the interpolated float result between angle a and angle b,
+    /// based on the interpolation value t.</returns>
+    public static float LerpAngle(float a, float b, float t)
+    {
+        float num = Repeat(b - a, 360f);
+        if (num > 180f)
+        {
+            num -= 360f;
+        }
+
+        return a + num * Clamp01(t);
+    }
+
+    public static int Sign(float value) => MathF.Sign(value);
+
+    /// <summary>
+    /// Returns a value that increments and decrements between zero and the
+    /// length. It follows the triangle wave formula where the bottom is set to zero
+    /// and the peak is set to length.
+    /// </summary>
+    public static float PingPong(float t, float length)
+    {
+        t = Repeat(t, length * 2f);
+        return length - MathF.Abs(t - length);
+    }
+
+    /// <summary>
+    /// Moves a value current towards target.
+    /// </summary>
+    /// <param name="current">The current value.</param>
+    /// <param name="target">The value to move towards.</param>
+    /// <param name="maxDelta">The maximum change applied to the current value.</param>
+    public static float MoveTowards(float current, float target, float maxDelta)
+    {
+        if (MathF.Abs(target - current) <= maxDelta)
+        {
+            return target;
+        }
+
+        return current + Sign(target - current) * maxDelta;
+    }
+
+    /// <summary>
+    /// Calculates the shortest difference between two angles.
+    /// </summary>
+    /// <param name="current">The current angle in degrees.</param>
+    /// <param name="target">The target angle in degrees.</param>
+    /// <returns>A value between -179 and 180, in degrees.</returns>
+    public static float DeltaAngle(float current, float target)
+    {
+        float num = Repeat(target - current, 360f);
+        if (num > 180f)
+        {
+            num -= 360f;
+        }
+
+        return num;
+    }
+
+    /// <summary>
+    /// Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.
+    /// </summary>
+    public static float MoveTowardsAngle(float current, float target, float maxDelta)
+    {
+        float num = DeltaAngle(current, target);
+        if (0f - maxDelta < num && num < maxDelta)
+        {
+            return target;
+        }
+
+        target = current + num;
+        return MoveTowards(current, target, maxDelta);
+    }
+}