mirror of
https://github.com/raylib-cs/raylib-cs
synced 2025-10-13 04:51:53 -04:00
* 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"
99 lines
3.2 KiB
C#
99 lines
3.2 KiB
C#
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);
|
|
}
|
|
}
|