diff --git a/Raylib-cs/interop/RaylibExtensions.cs b/Raylib-cs/interop/RaylibExtensions.cs index 2fae0dd..a1c449d 100644 --- a/Raylib-cs/interop/RaylibExtensions.cs +++ b/Raylib-cs/interop/RaylibExtensions.cs @@ -1,367 +1,26 @@ using System.Collections.Generic; -using static Raylib_cs.Raylib; using System.Numerics; namespace Raylib_cs; public static class RaylibExtensions { - #region Rectangle - - public static void Draw(this Rectangle rectangle, Color color) - { - DrawRectangleRec(rectangle, color); - } - - public static void Draw(this Rectangle rec, Vector2 origin, Color color) - { - rec.Draw(origin, 0.0f, color); - } - - public static void Draw(this Rectangle rec, Vector2 origin, float rotation, Color color) - { - DrawRectanglePro(rec, origin, rotation, color); - } - - public static void GetIntegerPosition(this Rectangle rec, out int x, out int y) - { - x = (int)rec.X; - y = (int)rec.Y; - } - - public static void GetIntegerDimentions(this Rectangle rec, out int width, out int height) - { - width = (int)rec.Width; - height = (int)rec.Height; - } - - public static void GetIntegerValues(this Rectangle rec, out int x, out int y, out int width, out int height) - { - x = (int)rec.X; - y = (int)rec.Y; - width = (int)rec.Width; - height = (int)rec.Height; - } - - public static void DrawLines(this Rectangle rectangle, Color color) - { - rectangle.GetIntegerValues(out int x, out int y, out int w, out int h); - DrawRectangleLines(x, y, w, h, color); - } - - public static void DrawLines(this Rectangle rectangle, float thickness, Color color) - { - DrawRectangleLinesEx(rectangle, thickness, color); - } - - public static void DrawGradient(this Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight) - { - DrawRectangleGradientEx(rec, topLeft, bottomLeft, topRight, bottomRight); - } - - public static void DrawGradientV(this Rectangle rectangle, Color top, Color bottom) - { - rectangle.GetIntegerValues(out int x, out int y, out int w, out int h); - DrawRectangleGradientV(x, y, w, h, top, bottom); - } - - public static void DrawGradientH(this Rectangle rec, Color left, Color right) - { - rec.GetIntegerValues(out int x, out int y, out int w, out int h); - DrawRectangleGradientH(x, y, w, h, left, right); - } - - public static void DrawRounded(this Rectangle rec, float roundness, Color color) - { - DrawRectangleRounded(rec, roundness, 10, color); - } - - public static void DrawRounded(this Rectangle rec, float roundness, int segments, Color color) - { - DrawRectangleRounded(rec, roundness, segments, color); - } - - public static void DrawRoundedLines(this Rectangle rec, float roundness, Color color) - { - DrawRectangleRoundedLines(rec, roundness, 10, color); - } - - public static void DrawRoundedLines(this Rectangle rec, float roundness, int segments, Color color) - { - DrawRectangleRoundedLines(rec, roundness, segments, color); - } - - public static void DrawRoundedLines(this Rectangle rec, float roundness, float thickness, Color color) - { - DrawRectangleRoundedLinesEx(rec, roundness, 10, thickness, color); - } - - public static void DrawRoundedLines(this Rectangle rec, float roundness, int segments, float thickness, Color color) - { - DrawRectangleRoundedLinesEx(rec, roundness, segments, thickness, color); - } - - public static CBool CheckCollision(this Rectangle rec, Rectangle rectangle) - { - return CheckCollisionRecs(rec, rectangle); - } - - public static CBool CheckCollision(this Rectangle rec, Vector2 point) - { - return CheckCollisionPointRec(point, rec); - } - - public static CBool CheckCircleCollision(this Rectangle rec, Vector2 center, float radius) - { - return CheckCollisionCircleRec(center, radius, rec); - } - - public static CBool CheckColllisionCircle(this Rectangle rec, Vector2 position, float radius) - { - return CheckCollisionCircleRec(position, radius, rec); - } - - public static Rectangle GetCollisionRectangle(this Rectangle rectangle, Rectangle rectangle2) - { - return GetCollisionRec(rectangle, rectangle2); - } - - #endregion - public static void DrawLines(this IEnumerable points, Color color) { Vector2[] pointArray = System.Linq.Enumerable.ToArray(points); - DrawLineStrip(pointArray, pointArray.Length, color); + Raylib.DrawLineStrip(pointArray, pointArray.Length, color); } - #region Image - - public static void Load(this ref Image image, string fileName) + public static void Log(this TraceLogLevel logLevel, string message) { - image = LoadImage(fileName); + Raylib.TraceLog(logLevel, message); } - public static void Load(this ref Image image, string fileType, byte[] data) + public static byte Lerp(this byte a, byte b, float t) { - image = LoadImageFromMemory(fileType, data); + return (byte)(a + (b - a) * t); } - public static void Load(this ref Image image, Texture2D texture) - { - image = LoadImageFromTexture(texture); - } - - public static void Load(this ref Image image, string fileName, int width, int height, PixelFormat format, int headerSize) - { - image = LoadImageRaw(fileName, width, height, format, headerSize); - } - - public static void Unload(this Image image) - { - UnloadImage(image); - } - - public static unsafe Color[] GetPalette(this Image image, int maxPaletteSize) - { - int colorCount = 0; - Color* colors = LoadImagePalette(image, maxPaletteSize, &colorCount); - Color[] palette = new Color[colorCount]; - for (int i = 0; i < colorCount; i++) - { - palette[i] = colors[i]; - } - UnloadImagePalette(colors); - return palette; - } - - public static void LoadFromScreen(this ref Image image) - { - image = LoadImageFromScreen(); - } - - public static void DrawLine(this ref Image image, Vector2 start, Vector2 end, Color color) - { - ImageDrawLineV(ref image, start, end, color); - } - - public static void DrawLine(this ref Image image, Vector2 start, Vector2 end, int thickness, Color color) - { - ImageDrawLineEx(ref image, start, end, thickness, color); - } - - public static void DrawCircle(this ref Image image, Vector2 position, float radius, Color color) - { - ImageDrawCircle(ref image, (int)position.X, (int)position.Y, (int)radius, color); - } - - public static void Draw(this ref Image image, Rectangle rectangle, Color color) - { - ImageDrawRectangleRec(ref image, rectangle, color); - } - - public static void Draw(this ref Image image, string text, Vector2 position, int fontSize, Color color) - { - ImageDrawText(ref image, text, (int)position.X, (int)position.Y, fontSize, color); - } - - public static void Draw(this ref Image image, Font font, string text, Vector2 position, int fontSize, float spacing, Color color) - { - ImageDrawTextEx(ref image, font, text, position, fontSize, spacing, color); - } - - public static unsafe void DrawCircleLines(this ref Image image, Vector2 position, float radius, Color color) - { - ImageDrawCircleLinesV(ref image, position, (int)radius, color); - } - - public static void DrawTriangle(this ref Image image, Vector2 p1, Vector2 p2, Vector2 p3, Color color) - { - ImageDrawTriangle(ref image, p1, p2, p3, color); - } - - public static void DrawTriangle(this ref Image image, Vector2 p1, Vector2 p2, Vector2 p3, Color c1, Color c2, Color c3) - { - ImageDrawTriangleEx(ref image, p1, p2, p3, c1, c2, c3); - } - - public static void DrawLines(this ref Image image, Rectangle rectangle, Color color) - { - ImageDrawRectangleLines(ref image, rectangle, 1, color); - } - - public static void DrawLines(this ref Image image, Rectangle rectangle, int thickness, Color color) - { - ImageDrawRectangleLines(ref image, rectangle, thickness, color); - } - - #endregion - - #region Texture2D - - public static void Load(this ref Texture2D texture, string fileName) - { - texture = LoadTexture(fileName); - } - - public static void Load(this ref Texture2D texture, Image image) - { - texture = LoadTextureFromImage(image); - } - - public static void Load(this ref Texture2D texture, string fileType, byte[] fileData) - { - Image img = LoadImageFromMemory(fileType, fileData); - texture.Load(img); - UnloadImage(img); - } - - public static void Unload(this Texture2D texture) - { - UnloadTexture(texture); - } - - public static void SetFilter(this Texture2D texture, TextureFilter filter) - { - SetTextureFilter(texture, filter); - } - - public static void SetWrap(this Texture2D texture, TextureWrap wrap) - { - SetTextureWrap(texture, wrap); - } - - public static void Update(this Texture2D texture, T[] pixels) where T : unmanaged - { - UpdateTexture(texture, pixels); - } - - public static Rectangle GetSourceRectangle(this Texture2D texture) - { - return new Rectangle(Vector2.Zero, texture.Width, texture.Height); - } - - public static void Draw(this Texture2D texture, int x, int y) - { - DrawTexture(texture, x, y, Color.White); - } - - public static void Draw(this Texture2D texture, int x, int y, Color color) - { - DrawTexture(texture, x, y, color); - } - - public static void Draw(this Texture2D texture, Vector2 position) - { - DrawTexture(texture, (int)position.X, (int)position.Y, Color.White); - } - - public static void Draw(this Texture2D texture, Vector2 position, Vector2 origin) - { - Vector2 size = texture.Dimensions; - Rectangle source = new Rectangle(Vector2.Zero, size); - Rectangle target = new Rectangle(position, size); - DrawTexturePro(texture, source, target, origin, 0, Color.White); - } - - public static void Draw(this Texture2D texture, Vector2 position, Vector2 origin, Color color) - { - Vector2 size = texture.Dimensions; - Rectangle source = new Rectangle(Vector2.Zero, size); - Rectangle target = new Rectangle(position, size); - DrawTexturePro(texture, source, target, origin, 0, color); - } - - public static void Draw(this Texture2D texture, Vector2 position, Color color) - { - DrawTexture(texture, (int)position.X, (int)position.Y, color); - } - - public static void Draw(this Texture2D texture, Vector2 position, float rotation, float scale) - { - DrawTextureEx(texture, position, rotation, scale, Color.White); - } - - public static void Draw(this Texture2D texture, Vector2 position, float rotation, float scale, Color color) - { - DrawTextureEx(texture, position, rotation, scale, color); - } - - public static void Draw(this Texture2D texture, Vector2 position, float rotation, Vector2 scale) - { - Draw(texture, position, rotation, scale, Color.White); - } - - public static void Draw(this Texture2D texture, Vector2 position, float rotation, Vector2 scale, Color color) - { - Vector2 size = new Vector2(texture.Width, texture.Height); - Rectangle source = new Rectangle(Vector2.Zero, size); - Rectangle target = new Rectangle(position, size); - target.Size *= scale; - DrawTexturePro(texture, source, target, Vector2.Zero, rotation, color); - } - - public static void Draw(this Texture2D texture, Rectangle source, Rectangle dest) - { - DrawTexturePro(texture, source, dest, Vector2.Zero, 0, Color.White); - } - - public static void Draw(this Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin) - { - DrawTexturePro(texture, source, dest, origin, 0, Color.White); - } - - public static void Draw(this Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation) - { - DrawTexturePro(texture, source, dest, origin, rotation, Color.White); - } - - public static void Draw(this Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color color) - { - DrawTexturePro(texture, source, dest, origin, rotation, color); - } - - #endregion - #region Vector public static void Normalize(this ref Vector2 vector) @@ -414,5 +73,15 @@ public static class RaylibExtensions return Raymath.Vector3Lerp(v1, v2, amount); } + public static Vector2 MoveTowards(this Vector2 v1, Vector2 v2, float t) + { + return Raymath.Vector2MoveTowards(v1, v2, t); + } + + public static Vector3 MoveTowards(this Vector3 v1, Vector3 v2, float t) + { + return Raymath.Vector3MoveTowards(v1, v2, t); + } + #endregion } diff --git a/Raylib-cs/interop/Raymath.cs b/Raylib-cs/interop/Raymath.cs index b61fa98..1435898 100644 --- a/Raylib-cs/interop/Raymath.cs +++ b/Raylib-cs/interop/Raymath.cs @@ -37,12 +37,9 @@ public static unsafe partial class Raymath /// Remap input value within input range to output range [DllImport(NativeLibName, CallingConvention = CallingConvention.Cdecl)] - public static extern float Remap( - float value, - float inputStart, - float inputEnd, - float outputStart, - float outputEnd + public static extern float Remap(float value, + float inputStart, float inputEnd, + float outputStart, float outputEnd ); /// Wrap input value from min to max diff --git a/Raylib-cs/runtimes/linux-x64/native/.keep b/Raylib-cs/runtimes/linux-x64/native/.keep new file mode 100644 index 0000000..8d1c8b6 --- /dev/null +++ b/Raylib-cs/runtimes/linux-x64/native/.keep @@ -0,0 +1 @@ + diff --git a/Raylib-cs/runtimes/osx-arm64/native/.keep b/Raylib-cs/runtimes/osx-arm64/native/.keep new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Raylib-cs/runtimes/osx-arm64/native/.keep @@ -0,0 +1 @@ + diff --git a/Raylib-cs/runtimes/osx-x64/native/.keep b/Raylib-cs/runtimes/osx-x64/native/.keep new file mode 100644 index 0000000..e69de29 diff --git a/Raylib-cs/runtimes/win-x64/native/.keep b/Raylib-cs/runtimes/win-x64/native/.keep new file mode 100644 index 0000000..e69de29 diff --git a/Raylib-cs/runtimes/win-x86/native/.keep b/Raylib-cs/runtimes/win-x86/native/.keep new file mode 100644 index 0000000..8d1c8b6 --- /dev/null +++ b/Raylib-cs/runtimes/win-x86/native/.keep @@ -0,0 +1 @@ + diff --git a/Raylib-cs/types/AudioStream.cs b/Raylib-cs/types/AudioStream.cs index 454a155..8098018 100644 --- a/Raylib-cs/types/AudioStream.cs +++ b/Raylib-cs/types/AudioStream.cs @@ -35,4 +35,68 @@ public partial struct AudioStream /// Number of channels (1-mono, 2-stereo) /// public uint Channels; + + public readonly CBool IsValid => Raylib.IsAudioStreamValid(this); + public readonly CBool IsPlaying => Raylib.IsAudioStreamPlaying(this); + public readonly CBool IsProcessed => Raylib.IsAudioStreamProcessed(this); + + public static AudioStream Load(uint sampleRate, uint sampleSize, uint channels) + { + return Raylib.LoadAudioStream(sampleRate, sampleSize, channels); + } + + public readonly void Play() + { + Raylib.PlayAudioStream(this); + } + + public readonly void Pause() + { + Raylib.PauseAudioStream(this); + } + + public readonly void Resume() + { + Raylib.ResumeAudioStream(this); + } + + public readonly void Stop() + { + Raylib.StopAudioStream(this); + } + + public static void SetBufferSizeDefault(int size) + { + Raylib.SetAudioStreamBufferSizeDefault(size); + } + + /// + /// Set pan for this audio stream where 0.5 is centered + /// + /// + public void SetPan(float pan) + { + Raylib.SetAudioStreamPan(this, pan); + } + + /// + /// Set pitch for this audio stream where 1.0 si base level + /// + public void SetPitch(float pitch) + { + Raylib.SetAudioStreamPitch(this, pitch); + } + + /// + /// Set the volume from 0.0 to 1.0 + /// + public void SetVolume(float volume) + { + Raylib.SetAudioStreamVolume(this, volume); + } + + public void Unload() + { + Raylib.UnloadAudioStream(this); + } } diff --git a/Raylib-cs/types/Automation.cs b/Raylib-cs/types/Automation.cs index 21b7cd6..0fcb178 100644 --- a/Raylib-cs/types/Automation.cs +++ b/Raylib-cs/types/Automation.cs @@ -15,6 +15,11 @@ public unsafe struct AutomationEvent /// Event parameters (if required) public fixed int Params[4]; + + public readonly void Play() + { + Raylib.PlayAutomationEvent(this); + } } /// Automation event list @@ -31,5 +36,21 @@ public unsafe struct AutomationEventList public AutomationEvent* Events; /// - public ReadOnlySpan EventsAsSpan => new(Events, (int)Count); + public readonly ReadOnlySpan EventsAsSpan => new ReadOnlySpan(Events, (int)Count); + + public static AutomationEventList Load(string fileName) + { + return Raylib.LoadAutomationEventList(fileName); + } + + public readonly CBool Export(string fileName) + { + return Raylib.ExportAutomationEventList(this, fileName); + } + + public void Unload() + { + Raylib.UnloadAutomationEventList(this); + } + } diff --git a/Raylib-cs/types/Camera2D.cs b/Raylib-cs/types/Camera2D.cs index f26f6e4..7902111 100644 --- a/Raylib-cs/types/Camera2D.cs +++ b/Raylib-cs/types/Camera2D.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// Camera2D, defines position/orientation in 2d space /// [StructLayout(LayoutKind.Sequential)] -public partial struct Camera2D +public struct Camera2D { /// /// Camera offset (displacement from target) diff --git a/Raylib-cs/types/Camera3D.cs b/Raylib-cs/types/Camera3D.cs index 935f6fa..b9065d9 100644 --- a/Raylib-cs/types/Camera3D.cs +++ b/Raylib-cs/types/Camera3D.cs @@ -28,7 +28,7 @@ public enum CameraProjection /// Camera3D, defines position/orientation in 3d space /// [StructLayout(LayoutKind.Sequential)] -public partial struct Camera3D +public struct Camera3D { /// /// Camera position diff --git a/Raylib-cs/types/Color.cs b/Raylib-cs/types/Color.cs index b3f9dc0..5d73bef 100644 --- a/Raylib-cs/types/Color.cs +++ b/Raylib-cs/types/Color.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// Color type, RGBA (32bit) /// [StructLayout(LayoutKind.Sequential)] -public partial struct Color +public struct Color { public byte R; public byte G; @@ -115,7 +115,108 @@ public partial struct Color this.A = 255; } - public override string ToString() + public readonly void GetHSV(out float h, out float s, out float v) + { + float rf = this.R / 255f; + float gf = this.G / 255f; + float bf = this.B / 255f; + + float max = MathF.Max(rf, MathF.Max(gf, bf)); + float min = MathF.Min(rf, MathF.Min(gf, bf)); + float delta = max - min; + + // Value + v = max; + + // Saturation + s = (max == 0f) ? 0f : delta / max; + + // Hue + if (delta == 0f) + { + h = 0f; + } + else if (max == rf) + { + h = 60f * (((gf - bf) / delta) % 6f); + } + else if (max == gf) + { + h = 60f * (((bf - rf) / delta) + 2f); + } + else // max == bf + { + h = 60f * (((rf - gf) / delta) + 4f); + } + + // Keep h inside 0 and 360 + if (h < 0f) + { + h += 360f; + } + } + + public static Color FromHSV(float h, float s, float v) + { + float c = v * s; + float x = c * (1f - MathF.Abs((h / 60f) % 2f - 1f)); + float m = v - c; + + float rf, gf, bf; + + if (h < 60f) + { + rf = c; + gf = x; + bf = 0; + } + else if (h < 120f) + { + rf = x; + gf = c; + bf = 0; + } + else if (h < 180f) + { + rf = 0; + gf = c; + bf = x; + } + else if (h < 240f) + { + rf = 0; + gf = x; + bf = c; + } + else if (h < 300f) + { + rf = x; + gf = 0; + bf = c; + } + else + { + rf = c; + gf = 0; + bf = x; + } + + byte r = (byte)((rf + m) * 255f + 0.5f); + byte g = (byte)((gf + m) * 255f + 0.5f); + byte b = (byte)((bf + m) * 255f + 0.5f); + return new Color(r, g, b, byte.MaxValue); + } + + public static Color Lerp(Color origin, Color target, float t) + { + byte r = origin.R.Lerp(target.R, t); + byte g = origin.G.Lerp(target.G, t); + byte b = origin.B.Lerp(target.B, t); + byte a = origin.A.Lerp(target.A, t); + return new Color(r, g, b, a); + } + + public readonly override string ToString() { return $"{{R:{R} G:{G} B:{B} A:{A}}}"; } diff --git a/Raylib-cs/types/Font.cs b/Raylib-cs/types/Font.cs index 1b4ed41..1524de2 100644 --- a/Raylib-cs/types/Font.cs +++ b/Raylib-cs/types/Font.cs @@ -59,7 +59,7 @@ public partial struct GlyphInfo /// Font, font texture and GlyphInfo array data /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Font +public unsafe struct Font { /// /// Base size (default chars height) @@ -90,4 +90,8 @@ public unsafe partial struct Font /// Glyphs info data /// public GlyphInfo* Glyphs; + + public readonly CBool IsValid => Raylib.IsFontValid(this); + + public static Font Default => Raylib.GetFontDefault(); } diff --git a/Raylib-cs/types/Image.cs b/Raylib-cs/types/Image.cs index ec11acf..e8baad3 100644 --- a/Raylib-cs/types/Image.cs +++ b/Raylib-cs/types/Image.cs @@ -134,7 +134,7 @@ public enum PixelFormat /// Image, pixel data stored in CPU memory (RAM) /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Image +public unsafe struct Image { /// /// Image raw data @@ -164,11 +164,117 @@ public unsafe partial struct Image /// /// Get width and height packed in a Vector2 /// - public Vector2 Dimensions + public readonly Vector2 Dimensions => new Vector2(Width, Height); + public readonly CBool IsValid => Raylib.IsImageValid(this); + + public static Image Load(string fileName) { - get + return Raylib.LoadImage(fileName); + } + + /// + /// Create an image from text using the default font + /// + public static Image CreateFromText(string text, int fontSize, Color color) + { + return Raylib.ImageText(text, fontSize, color); + } + + public static Image CreateFromText(Font font, string text, int fontSize, float spacing, Color color) + { + return Raylib.ImageTextEx(font, text, fontSize, spacing, color); + } + + public static Image LoadFromMemory(string fileType, byte[] data) + { + return Raylib.LoadImageFromMemory(fileType, data); + } + + public static Image LoadFromTexture(Texture2D texture) + { + return Raylib.LoadImageFromTexture(texture); + } + + public static Image LoadRaw(string fileName, int width, int height, PixelFormat format, int headerSize) + { + return Raylib.LoadImageRaw(fileName, width, height, format, headerSize); + } + + public readonly void Unload() + { + Raylib.UnloadImage(this); + } + + public readonly unsafe Color[] GetPalette(int maxPaletteSize) + { + int colorCount = 0; + Color* colors = Raylib.LoadImagePalette(this, maxPaletteSize, &colorCount); + Color[] palette = new Color[colorCount]; + for (int i = 0; i < colorCount; i++) { - return new Vector2(Width, Height); + palette[i] = colors[i]; } + Raylib.UnloadImagePalette(colors); + return palette; + } + + public static Image LoadFromScreen() + { + return Raylib.LoadImageFromScreen(); + } + + public void DrawLine(Vector2 start, Vector2 end, Color color) + { + Raylib.ImageDrawLineV(ref this, start, end, color); + } + + public void DrawLine(Vector2 start, Vector2 end, int thickness, Color color) + { + Raylib.ImageDrawLineEx(ref this, start, end, thickness, color); + } + + public void DrawCircle(Vector2 position, float radius, Color color) + { + Raylib.ImageDrawCircle(ref this, (int)position.X, (int)position.Y, (int)radius, color); + } + + public void DrawRectangle(Rectangle rectangle, Color color) + { + Raylib.ImageDrawRectangleRec(ref this, rectangle, color); + } + + public void DrawText(string text, Vector2 position, int fontSize, Color color) + { + Raylib.ImageDrawText(ref this, text, (int)position.X, (int)position.Y, fontSize, color); + } + + public void DrawText(Font font, string text, Vector2 position, int fontSize, float spacing, Color color) + { + Raylib.ImageDrawTextEx(ref this, font, text, position, fontSize, spacing, color); + } + + public unsafe void DrawCircleLines(Vector2 position, float radius, Color color) + { + Raylib.ImageDrawCircleLinesV(ref this, position, (int)radius, color); + } + + public void DrawTriangle(Vector2 p1, Vector2 p2, Vector2 p3, Color color) + { + Raylib.ImageDrawTriangle(ref this, p1, p2, p3, color); + } + + public void DrawTriangle(Vector2 p1, Vector2 p2, Vector2 p3, Color c1, Color c2, Color c3) + { + Raylib.ImageDrawTriangleEx(ref this, p1, p2, p3, c1, c2, c3); + } + + public void DrawRectangleLines(Rectangle rectangle, Color color) + { + Raylib.ImageDrawRectangleLines(ref this, rectangle, 1, color); + } + + public void DrawRectangleLines(Rectangle rectangle, int thickness, Color color) + { + Raylib.ImageDrawRectangleLines(ref this, rectangle, thickness, color); } } diff --git a/Raylib-cs/types/Logging.cs b/Raylib-cs/types/Logging.cs index d9a1606..3c51234 100644 --- a/Raylib-cs/types/Logging.cs +++ b/Raylib-cs/types/Logging.cs @@ -29,7 +29,7 @@ internal readonly struct Native } [StructLayout(LayoutKind.Sequential, Pack = 4)] -struct VaListLinuxX64 +internal struct VaListLinuxX64 { uint _gpOffset; uint _fpOffset; @@ -95,7 +95,7 @@ public static unsafe class Logging } } - static string LinuxX64LogCallback(IntPtr format, IntPtr args) + private static string LinuxX64LogCallback(IntPtr format, IntPtr args) { // The args pointer cannot be reused between two calls. We need to make a copy of the underlying structure. VaListLinuxX64 listStructure = Marshal.PtrToStructure(args); @@ -125,7 +125,7 @@ public static unsafe class Logging } // https://github.com/dotnet/runtime/issues/51052 - static int VsnPrintf(IntPtr buffer, UIntPtr size, IntPtr format, IntPtr args) + private static int VsnPrintf(IntPtr buffer, UIntPtr size, IntPtr format, IntPtr args) { OperatingSystem os = Environment.OSVersion; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) @@ -144,7 +144,7 @@ public static unsafe class Logging } // https://github.com/dotnet/runtime/issues/51052 - static int VsPrintf(IntPtr buffer, IntPtr format, IntPtr args) + private static int VsPrintf(IntPtr buffer, IntPtr format, IntPtr args) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { diff --git a/Raylib-cs/types/Material.cs b/Raylib-cs/types/Material.cs index 45de7c5..56d3ba0 100644 --- a/Raylib-cs/types/Material.cs +++ b/Raylib-cs/types/Material.cs @@ -48,7 +48,7 @@ public enum MaterialMapIndex /// Material texture map /// [StructLayout(LayoutKind.Sequential)] -public partial struct MaterialMap +public struct MaterialMap { /// /// Material map texture @@ -70,7 +70,7 @@ public partial struct MaterialMap /// Material type (generic) /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Material +public unsafe struct Material { /// /// Material shader @@ -87,4 +87,55 @@ public unsafe partial struct Material /// Material generic parameters (if required) /// public fixed float Param[4]; + + public readonly CBool IsValid => Raylib.IsMaterialValid(this); + + /// + /// Load default material + /// + public static Material Load() + { + return Raylib.LoadMaterialDefault(); + } + + /// + /// Load materials from model file + /// + public static Material[] Load(string fileName) + { + using AnsiBuffer buffer = fileName.ToAnsiBuffer(); + int count = 0; + Material* materials = Raylib.LoadMaterials(buffer.AsPointer(), &count); + Material[] output = new Material[count]; + for (int i = 0; i < count; i++) + { + output[i] = materials[i]; + } + return output; + } + + public static Material GetMaterial(ref Model model, int materialIndex) + { + return Raylib.GetMaterial(ref model, materialIndex); + } + + public static Texture2D GetTexture(ref Model model, int materialIndex, MaterialMapIndex mapIndex) + { + return Raylib.GetMaterialTexture(ref model, materialIndex, mapIndex); + } + + public void SetTexture(MaterialMapIndex mapIndex, Texture2D texture) + { + Raylib.SetMaterialTexture(ref this, mapIndex, texture); + } + + public static void SetShader(ref Model model, int materialIndex, ref Shader shader) + { + Raylib.SetMaterialShader(ref model, materialIndex, ref shader); + } + + public void Unload() + { + Raylib.UnloadMaterial(this); + } } diff --git a/Raylib-cs/types/Mesh.cs b/Raylib-cs/types/Mesh.cs index 16733c4..7001a32 100644 --- a/Raylib-cs/types/Mesh.cs +++ b/Raylib-cs/types/Mesh.cs @@ -9,7 +9,7 @@ namespace Raylib_cs; /// NOTE: Data stored in CPU memory (and GPU) /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Mesh +public unsafe struct Mesh { /// /// Creates a mesh ready for default vertex data allocation @@ -30,6 +30,36 @@ public unsafe partial struct Mesh /// public int TriangleCount; + public readonly void Draw(Material material, Matrix4x4 transform) + { + Raylib.DrawMesh(this, material, transform); + } + + public readonly void DrawInstanced(Material material, Matrix4x4[] transforms, int instances) + { + Raylib.DrawMeshInstanced(this, material, transforms, instances); + } + + public readonly void Export(string fileName) + { + Raylib.ExportMesh(this, fileName); + } + + public readonly void ExportAsCode(string fileName) + { + Raylib.ExportMeshAsCode(this, fileName); + } + + public void Upload(CBool dynamic) + { + Raylib.UploadMesh(ref this, dynamic); + } + + public void Unload() + { + Raylib.UnloadMesh(this); + } + #region Default vertex data /// diff --git a/Raylib-cs/types/Model.cs b/Raylib-cs/types/Model.cs index 6b64dd7..0373476 100644 --- a/Raylib-cs/types/Model.cs +++ b/Raylib-cs/types/Model.cs @@ -8,7 +8,7 @@ namespace Raylib_cs; /// Bone information /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct BoneInfo +public unsafe struct BoneInfo { /// /// Bone name (char[32]) @@ -25,7 +25,7 @@ public unsafe partial struct BoneInfo /// Model type /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Model +public unsafe struct Model { /// /// Local transform matrix @@ -73,13 +73,105 @@ public unsafe partial struct Model /// Bones base transformation (pose, Transform *) /// public Transform* BindPose; + + public readonly CBool IsValid => Raylib.IsModelValid(this); + + public static Model Load(string fileName) + { + return Raylib.LoadModel(fileName); + } + + public static Model LoadFromMesh(Mesh mesh) + { + return Raylib.LoadModelFromMesh(mesh); + } + + public readonly void Draw(Vector3 position) + { + Raylib.DrawModel(this, position, 1.0f, Color.White); + } + + public readonly void Draw(Vector3 position, float scale) + { + Raylib.DrawModel(this, position, scale, Color.White); + } + + public readonly void Draw(Vector3 position, float scale, Color color) + { + Raylib.DrawModel(this, position, scale, color); + } + + public readonly void Draw(Vector3 position, Vector3 rotationAxis, float rotationAngle) + { + Raylib.DrawModelEx(this, position, rotationAxis, rotationAngle, Vector3.One, Color.White); + } + + public readonly void Draw(Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale) + { + Raylib.DrawModelEx(this, position, rotationAxis, rotationAngle, scale, Color.White); + } + + public readonly void Draw(Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color color) + { + Raylib.DrawModelEx(this, position, rotationAxis, rotationAngle, scale, color); + } + + public readonly void DrawWires(Vector3 position, Color color) + { + Raylib.DrawModelWires(this, position, 1.0f, color); + } + + public readonly void DrawWires(Vector3 position, float scale) + { + Raylib.DrawModelWires(this, position, scale, Color.White); + } + + public readonly void DrawWires(Vector3 position, float scale, Color color) + { + Raylib.DrawModelWires(this, position, scale, color); + } + + public readonly void DrawWires(Vector3 position, Vector3 rotationAxis, float rotationAngle, Color color) + { + Raylib.DrawModelWiresEx(this, position, rotationAxis, rotationAngle, Vector3.One, color); + } + + public readonly void DrawWires(Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color color) + { + Raylib.DrawModelWiresEx(this, position, rotationAxis, rotationAngle, scale, color); + } + + public readonly void DrawPoints(Vector3 position, Color color) + { + Raylib.DrawModelPoints(this, position, 1.0f, color); + } + + public readonly void DrawPoints(Vector3 position, float scale, Color color) + { + Raylib.DrawModelPoints(this, position, scale, color); + } + + public readonly void DrawPoints(Vector3 position, Vector3 rotationAxis, float rotationAngle, Color color) + { + Raylib.DrawModelPointsEx(this, position, rotationAxis, rotationAngle, Vector3.One, color); + } + + public readonly void DrawPoints(Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color color) + { + Raylib.DrawModelPointsEx(this, position, rotationAxis, rotationAngle, scale, color); + } + + public void Unload() + { + Raylib.UnloadModel(this); + } } /// /// Model animation /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct ModelAnimation +public unsafe struct ModelAnimation { /// /// Number of bones @@ -110,7 +202,7 @@ public unsafe partial struct ModelAnimation public fixed sbyte Name[32]; /// - public FramePosesCollection FramePosesColl => new(FramePoses, FrameCount, BoneCount); + public readonly FramePosesCollection FramePosesColl => new FramePosesCollection(FramePoses, FrameCount, BoneCount); public struct FramePosesCollection { @@ -120,9 +212,9 @@ public unsafe partial struct ModelAnimation readonly int _boneCount; - public FramePoses this[int index] => new(_framePoses[index], _boneCount); + public readonly FramePoses this[int index] => new FramePoses(_framePoses[index], _boneCount); - public Transform this[int index1, int index2] => new FramePoses(_framePoses[index1], _boneCount)[index2]; + public readonly Transform this[int index1, int index2] => new FramePoses(_framePoses[index1], _boneCount)[index2]; internal FramePosesCollection(Transform** framePoses, int frameCount, int boneCount) { @@ -131,6 +223,31 @@ public unsafe partial struct ModelAnimation this._boneCount = boneCount; } } + + public static ModelAnimation[] LoadAnimations(string fileName) + { + int count = 0; + ModelAnimation* animations = Raylib.LoadModelAnimations(fileName, ref count); + ModelAnimation[] output = new ModelAnimation[count]; + for (int i = 0; i < count; i++) + { + output[i] = animations[i]; + } + return output; + } + + public static void UnloadAnimations(ModelAnimation[] modelAnimations) + { + fixed (ModelAnimation* ptr = modelAnimations) + { + Raylib.UnloadModelAnimations(ptr, modelAnimations.Length); + } + } + + public void Unload() + { + Raylib.UnloadModelAnimation(this); + } } public unsafe struct FramePoses diff --git a/Raylib-cs/types/Music.cs b/Raylib-cs/types/Music.cs index 91e52d3..49399ea 100644 --- a/Raylib-cs/types/Music.cs +++ b/Raylib-cs/types/Music.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// NOTE: Anything longer than ~10 seconds should be streamed /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Music +public unsafe struct Music { /// /// Audio stream @@ -34,4 +34,63 @@ public unsafe partial struct Music /// Audio context data, depends on type /// public void* CtxData; + + public readonly CBool IsValid => Raylib.IsMusicValid(this); + + public static Music Load(string fileName) + { + return Raylib.LoadMusicStream(fileName); + } + + public readonly void Play() + { + Raylib.PlayMusicStream(this); + } + + public readonly void Pause() + { + Raylib.PauseMusicStream(this); + } + + public readonly void Stop() + { + Raylib.StopMusicStream(this); + } + + /// + /// Set pan of this music where 0.5 is centered + /// + public void SetPan(float pan) + { + Raylib.SetMusicPan(this, pan); + } + + /// + /// Set pitch for this music where 1.0 is base level + /// } + public void SetPitch(float pitch) + { + Raylib.SetMusicPitch(this, pitch); + } + + /// + /// Set music volume from 0.0 to 1.0 + /// + public void SetVolume(float volume) + { + Raylib.SetMusicVolume(this, volume); + } + + /// + /// Seek music to a position (in seconds) + /// + public void Seek(float position) + { + Raylib.SeekMusicStream(this, position); + } + + public void Unload() + { + Raylib.UnloadMusicStream(this); + } } diff --git a/Raylib-cs/types/NPatchInfo.cs b/Raylib-cs/types/NPatchInfo.cs index cee694b..54efba9 100644 --- a/Raylib-cs/types/NPatchInfo.cs +++ b/Raylib-cs/types/NPatchInfo.cs @@ -27,7 +27,7 @@ public enum NPatchLayout /// N-Patch layout info /// [StructLayout(LayoutKind.Sequential)] -public partial struct NPatchInfo +public struct NPatchInfo { /// /// Texture source rectangle diff --git a/Raylib-cs/types/Ray.cs b/Raylib-cs/types/Ray.cs index 768dd6a..23b47ee 100644 --- a/Raylib-cs/types/Ray.cs +++ b/Raylib-cs/types/Ray.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// Ray, ray for raycasting /// [StructLayout(LayoutKind.Sequential)] -public partial struct Ray +public struct Ray { /// /// Ray position (origin) @@ -30,7 +30,7 @@ public partial struct Ray /// Raycast hit information /// [StructLayout(LayoutKind.Sequential)] -public partial struct RayCollision +public struct RayCollision { /// /// Did the ray hit something? diff --git a/Raylib-cs/types/Raymath.Utils.cs b/Raylib-cs/types/Raymath.Utils.cs new file mode 100644 index 0000000..35b734d --- /dev/null +++ b/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); + + /// + /// Loops the value, so that it is never larger than length and never smaller than 0 + /// + public static float Repeat(float value, float length) + { + return Clamp(value - MathF.Floor(value / length) * length, 0f, length); + } + + /// + /// Same as Lerp but makes sure the values interpolate correctly when they wrap around + /// 360 degrees. + /// + /// The start angle. A float expressed in degrees. + /// The end angle. A float expressed in degrees. + /// The interpolation value between the start and end angles. + /// This value is clamped to the range [0, 1]. + /// Returns the interpolated float result between angle a and angle b, + /// based on the interpolation value t. + 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); + + /// + /// 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. + /// + public static float PingPong(float t, float length) + { + t = Repeat(t, length * 2f); + return length - MathF.Abs(t - length); + } + + /// + /// Moves a value current towards target. + /// + /// The current value. + /// The value to move towards. + /// The maximum change applied to the current value. + public static float MoveTowards(float current, float target, float maxDelta) + { + if (MathF.Abs(target - current) <= maxDelta) + { + return target; + } + + return current + Sign(target - current) * maxDelta; + } + + /// + /// Calculates the shortest difference between two angles. + /// + /// The current angle in degrees. + /// The target angle in degrees. + /// A value between -179 and 180, in degrees. + public static float DeltaAngle(float current, float target) + { + float num = Repeat(target - current, 360f); + if (num > 180f) + { + num -= 360f; + } + + return num; + } + + /// + /// Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees. + /// + 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); + } +} diff --git a/Raylib-cs/types/Rectangle.cs b/Raylib-cs/types/Rectangle.cs index c870bcf..232c940 100644 --- a/Raylib-cs/types/Rectangle.cs +++ b/Raylib-cs/types/Rectangle.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// Rectangle type /// [StructLayout(LayoutKind.Sequential)] -public partial struct Rectangle +public struct Rectangle { public float X; public float Y; @@ -72,7 +72,108 @@ public partial struct Rectangle } } - public override string ToString() + public readonly void Draw(Color color) + { + Raylib.DrawRectangleRec(this, color); + } + + public readonly void Draw(Vector2 origin, Color color) + { + Draw(origin, 0.0f, color); + } + + public readonly void Draw(Vector2 origin, float rotation, Color color) + { + Raylib.DrawRectanglePro(this, origin, rotation, color); + } + + public readonly void GetIntegerValues(out int x, out int y, out int width, out int height) + { + x = (int)this.X; + y = (int)this.Y; + width = (int)this.Width; + height = (int)this.Height; + } + + public readonly void DrawLines(Color color) + { + GetIntegerValues(out int x, out int y, out int w, out int h); + Raylib.DrawRectangleLines(x, y, w, h, color); + } + + public readonly void DrawLines(float thickness, Color color) + { + Raylib.DrawRectangleLinesEx(this, thickness, color); + } + + public readonly void DrawGradient(Color topLeft, Color bottomLeft, Color topRight, Color bottomRight) + { + Raylib.DrawRectangleGradientEx(this, topLeft, bottomLeft, topRight, bottomRight); + } + + public readonly void DrawGradientV(Color top, Color bottom) + { + GetIntegerValues(out int x, out int y, out int w, out int h); + Raylib.DrawRectangleGradientV(x, y, w, h, top, bottom); + } + + public readonly void DrawGradientH(Color left, Color right) + { + GetIntegerValues(out int x, out int y, out int w, out int h); + Raylib.DrawRectangleGradientH(x, y, w, h, left, right); + } + + public readonly void DrawRounded(float roundness, Color color) + { + Raylib.DrawRectangleRounded(this, roundness, 10, color); + } + + public readonly void DrawRounded(float roundness, int segments, Color color) + { + Raylib.DrawRectangleRounded(this, roundness, segments, color); + } + + public readonly void DrawRoundedLines(float roundness, Color color) + { + Raylib.DrawRectangleRoundedLines(this, roundness, 10, color); + } + + public readonly void DrawRoundedLines(float roundness, int segments, Color color) + { + Raylib.DrawRectangleRoundedLines(this, roundness, segments, color); + } + + public readonly void DrawRoundedLines(float roundness, float thickness, Color color) + { + Raylib.DrawRectangleRoundedLinesEx(this, roundness, 10, thickness, color); + } + + public readonly void DrawRoundedLines(float roundness, int segments, float thickness, Color color) + { + Raylib.DrawRectangleRoundedLinesEx(this, roundness, segments, thickness, color); + } + + public readonly CBool CheckCollisionRec(Rectangle rectangle) + { + return Raylib.CheckCollisionRecs(this, rectangle); + } + + public readonly CBool CheckCollisionPoint(Vector2 point) + { + return Raylib.CheckCollisionPointRec(point, this); + } + + public readonly CBool CheckCollisionCircle(Vector2 center, float radius) + { + return Raylib.CheckCollisionCircleRec(center, radius, this); + } + + public readonly Rectangle GetCollisionRectangle(Rectangle rectangle2) + { + return Raylib.GetCollisionRec(this, rectangle2); + } + + public readonly override string ToString() { return $"{{X:{X} Y:{Y} Width:{Width} Height:{Height}}}"; } diff --git a/Raylib-cs/types/RenderBatch.cs b/Raylib-cs/types/RenderBatch.cs index cfc1615..18cd57a 100644 --- a/Raylib-cs/types/RenderBatch.cs +++ b/Raylib-cs/types/RenderBatch.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// RenderBatch type /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct RenderBatch +public unsafe struct RenderBatch { /// /// Number of vertex buffers (multi-buffering support) @@ -44,7 +44,7 @@ public unsafe partial struct RenderBatch /// Dynamic vertex buffers (position + texcoords + colors + indices arrays) /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct VertexBuffer +public unsafe struct VertexBuffer { /// /// Number of elements in the buffer (QUADS) diff --git a/Raylib-cs/types/RenderTexture2D.cs b/Raylib-cs/types/RenderTexture2D.cs index 65d7849..20279b0 100644 --- a/Raylib-cs/types/RenderTexture2D.cs +++ b/Raylib-cs/types/RenderTexture2D.cs @@ -6,7 +6,7 @@ namespace Raylib_cs; /// RenderTexture2D type, for texture rendering /// [StructLayout(LayoutKind.Sequential)] -public partial struct RenderTexture2D +public struct RenderTexture2D { /// /// OpenGL Framebuffer Object (FBO) id @@ -22,4 +22,16 @@ public partial struct RenderTexture2D /// Depth buffer attachment texture /// public Texture2D Depth; + + public readonly CBool IsValid => Raylib.IsRenderTextureValid(this); + + public static RenderTexture2D Load(int width, int height) + { + return Raylib.LoadRenderTexture(width, height); + } + + public void Unload() + { + Raylib.UnloadRenderTexture(this); + } } diff --git a/Raylib-cs/types/Shader.cs b/Raylib-cs/types/Shader.cs index eb32614..95e69e8 100644 --- a/Raylib-cs/types/Shader.cs +++ b/Raylib-cs/types/Shader.cs @@ -76,7 +76,7 @@ public enum ShaderUniformDataType /// Shader type (generic) /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Shader +public unsafe struct Shader { /// /// Shader program id @@ -87,4 +87,47 @@ public unsafe partial struct Shader /// Shader locations array (MAX_SHADER_LOCATIONS, int *) /// public int* Locs; + + public readonly CBool IsValid => Raylib.IsShaderValid(this); + + public static Shader Load(string vsFileName, string fsFileName) + { + return Raylib.LoadShader(vsFileName, fsFileName); + } + + public static Shader LoadFromMemory(string vsCode, string fsCode) + { + return Raylib.LoadShaderFromMemory(vsCode, fsCode); + } + + public void GetLocationAttrib(string attribName) + { + Raylib.GetShaderLocationAttrib(this, attribName); + } + + public void SetValue(int locationIndex, T value, ShaderUniformDataType uniformDataType) where T : unmanaged + { + void* val = &value; + Raylib.SetShaderValue(this, locationIndex, val, uniformDataType); + } + + public void SetValues(int locationIndex, T[] values, ShaderUniformDataType uniformDataType) where T : unmanaged + { + Raylib.SetShaderValueV(this, locationIndex, values, uniformDataType, values.Length); + } + + public void SetTexture(int locationIndex, Texture2D texture) + { + Raylib.SetShaderValueTexture(this, locationIndex, texture); + } + + public void SetMatrix(int locationIndex, System.Numerics.Matrix4x4 matrix) + { + Raylib.SetShaderValueMatrix(this, locationIndex, matrix); + } + + public void Unload() + { + Raylib.UnloadShader(this); + } } diff --git a/Raylib-cs/types/Sound.cs b/Raylib-cs/types/Sound.cs index b537fc1..75af04b 100644 --- a/Raylib-cs/types/Sound.cs +++ b/Raylib-cs/types/Sound.cs @@ -6,7 +6,7 @@ namespace Raylib_cs; /// Sound source type /// [StructLayout(LayoutKind.Sequential)] -public partial struct Sound +public struct Sound { /// /// Audio stream @@ -17,4 +17,61 @@ public partial struct Sound /// Total number of frames (considering channels) /// public uint FrameCount; + + public readonly CBool IsValid => Raylib.IsSoundValid(this); + public readonly CBool IsPlaying => Raylib.IsSoundPlaying(this); + + public static Sound Load(string fileName) + { + return Raylib.LoadSound(fileName); + } + + public static Sound LoadFromWave(Wave wave) + { + return Raylib.LoadSoundFromWave(wave); + } + + public readonly void Play() + { + Raylib.PlaySound(this); + } + + public readonly void Pause() + { + Raylib.PauseSound(this); + } + + public readonly void Resume() + { + Raylib.ResumeSound(this); + } + + /// + /// Set pan where 0.5 is center + /// + public void SetPan(float pan) + { + Raylib.SetSoundPan(this, pan); + } + + /// + /// Set pitch where 1.0 is base level + /// + public void SetPitch(float pitch) + { + Raylib.SetSoundPitch(this, pitch); + } + + /// + /// Set volume from 0.0 to 1.0 + /// + public void SetVolume(float volume) + { + Raylib.SetSoundVolume(this, volume); + } + + public void Unload() + { + Raylib.UnloadSound(this); + } } diff --git a/Raylib-cs/types/Texture2D.cs b/Raylib-cs/types/Texture2D.cs index df2ce19..d0728dc 100644 --- a/Raylib-cs/types/Texture2D.cs +++ b/Raylib-cs/types/Texture2D.cs @@ -103,7 +103,7 @@ public enum CubemapLayout /// NOTE: Data stored in GPU memory /// [StructLayout(LayoutKind.Sequential)] -public partial struct Texture2D +public struct Texture2D { /// /// OpenGL texture id @@ -133,11 +133,124 @@ public partial struct Texture2D /// /// Get width and height packed in a Vector2 /// - public Vector2 Dimensions + public readonly Vector2 Dimensions => new Vector2(Width, Height); + public readonly CBool IsValid => Raylib.IsTextureValid(this); + + public static Texture2D Load(string fileName) { - get - { - return new Vector2(Width, Height); - } + return Raylib.LoadTexture(fileName); + } + + public static Texture2D LoadFromImage(Image image) + { + return Raylib.LoadTextureFromImage(image); + } + + public static Texture2D LoadFromMemory(string fileType, byte[] fileData) + { + Image img = Raylib.LoadImageFromMemory(fileType, fileData); + Texture2D texture = Raylib.LoadTextureFromImage(img); + Raylib.UnloadImage(img); + return texture; + } + + public void Unload() + { + Raylib.UnloadTexture(this); + } + + public void SetFilter(TextureFilter filter) + { + Raylib.SetTextureFilter(this, filter); + } + + public void SetWrap(TextureWrap wrap) + { + Raylib.SetTextureWrap(this, wrap); + } + + public void Update(T[] pixels) where T : unmanaged + { + Raylib.UpdateTexture(this, pixels); + } + + public readonly void Draw(int x, int y) + { + Raylib.DrawTexture(this, x, y, Color.White); + } + + public readonly void Draw(int x, int y, Color color) + { + Raylib.DrawTexture(this, x, y, color); + } + + public readonly void Draw(Vector2 position) + { + Raylib.DrawTexture(this, (int)position.X, (int)position.Y, Color.White); + } + + public readonly void Draw(Vector2 position, Vector2 origin) + { + Vector2 size = this.Dimensions; + Rectangle source = new Rectangle(Vector2.Zero, size); + Rectangle target = new Rectangle(position, size); + Raylib.DrawTexturePro(this, source, target, origin, 0, Color.White); + } + + public readonly void Draw(Vector2 position, Vector2 origin, Color color) + { + Vector2 size = this.Dimensions; + Rectangle source = new Rectangle(Vector2.Zero, size); + Rectangle target = new Rectangle(position, size); + Raylib.DrawTexturePro(this, source, target, origin, 0, color); + } + + public readonly void Draw(Vector2 position, Color color) + { + Raylib.DrawTexture(this, (int)position.X, (int)position.Y, color); + } + + public readonly void Draw(Vector2 position, float rotation, float scale) + { + Raylib.DrawTextureEx(this, position, rotation, scale, Color.White); + } + + public readonly void Draw(Vector2 position, float rotation, float scale, Color color) + { + Raylib.DrawTextureEx(this, position, rotation, scale, color); + } + + public readonly void Draw(Vector2 position, float rotation, Vector2 scale) + { + Draw(position, rotation, scale, Color.White); + } + + public readonly void Draw(Vector2 position, float rotation, Vector2 scale, Color color) + { + Vector2 size = this.Dimensions; + Rectangle source = new Rectangle(Vector2.Zero, size); + Rectangle target = new Rectangle(position, size); + target.Size *= scale; + Raylib.DrawTexturePro(this, source, target, Vector2.Zero, rotation, color); + } + + public readonly void Draw(Rectangle source, Rectangle dest) + { + Raylib.DrawTexturePro(this, source, dest, Vector2.Zero, 0, Color.White); + } + + public readonly void Draw(Rectangle source, Rectangle dest, Vector2 origin) + { + Raylib.DrawTexturePro(this, source, dest, origin, 0, Color.White); + } + + public readonly void Draw(Rectangle source, Rectangle dest, Vector2 origin, float rotation) + { + Raylib.DrawTexturePro(this, source, dest, origin, rotation, Color.White); + } + + public readonly void Draw(Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color color) + { + Raylib.DrawTexturePro(this, source, dest, origin, rotation, color); } } diff --git a/Raylib-cs/types/Transform.cs b/Raylib-cs/types/Transform.cs index 2ccaace..10b15ab 100644 --- a/Raylib-cs/types/Transform.cs +++ b/Raylib-cs/types/Transform.cs @@ -7,7 +7,7 @@ namespace Raylib_cs; /// Transform, vertex transformation data /// [StructLayout(LayoutKind.Sequential)] -public partial struct Transform +public struct Transform { /// /// Translation @@ -23,4 +23,14 @@ public partial struct Transform /// Scale /// public Vector3 Scale; + + public void TranslateLocal(Vector3 translation) + { + Translation += Vector3.Transform(translation, Rotation); + } + + public void TranslateGlobal(Vector3 translation) + { + Translation += translation; + } } diff --git a/Raylib-cs/types/Wave.cs b/Raylib-cs/types/Wave.cs index adcd390..bb03a82 100644 --- a/Raylib-cs/types/Wave.cs +++ b/Raylib-cs/types/Wave.cs @@ -6,7 +6,7 @@ namespace Raylib_cs; /// Wave type, defines audio wave data /// [StructLayout(LayoutKind.Sequential)] -public unsafe partial struct Wave +public unsafe struct Wave { /// /// Number of samples @@ -33,4 +33,36 @@ public unsafe partial struct Wave /// Buffer data pointer /// public void* Data; + + public readonly CBool IsValid => Raylib.IsWaveValid(this); + + public static Wave Load(string fileName) + { + return Raylib.LoadWave(fileName); + } + + public CBool Export(string fileName) + { + return Raylib.ExportWave(this, fileName); + } + + public CBool ExportAsCode(string fileName) + { + return Raylib.ExportWaveAsCode(this, fileName); + } + + public void Format(int sampleRate, int sampleSize, int channels) + { + Raylib.WaveFormat(ref this, sampleRate, sampleSize, channels); + } + + public void Crop(int initFrame, int finalFrame) + { + Raylib.WaveCrop(ref this, initFrame, finalFrame); + } + + public void Unload() + { + Raylib.UnloadWave(this); + } } diff --git a/Raylib-cs/types/native/FilePathList.cs b/Raylib-cs/types/native/FilePathList.cs index 6aa1517..9c50a3b 100644 --- a/Raylib-cs/types/native/FilePathList.cs +++ b/Raylib-cs/types/native/FilePathList.cs @@ -27,7 +27,14 @@ public unsafe struct FilePathList { get { - return Marshal.PtrToStringUTF8((System.IntPtr)Paths[i]); + if (i >= 0 && i < Count) + { + return Marshal.PtrToStringUTF8((System.IntPtr)Paths[i]); + } + else + { + throw new System.IndexOutOfRangeException(); + } } } }