Merging

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.
Merged Rectangle extensions with the type itself as read-only methods.
Merged Image extensions with the type itself.
Merged Texture2D extensions with the type itself.
New file "Raymath.Utils" with some useful methods taken from Unity.
Added "MoveTowards" extensions to RaylibExtensions.
Added "TranslateLocal" and "TranslateGlobal" to Transform.
Added "Load", "Export", "ExportAsCode", "Format", "Crop", and "Unload" shortcut methods to Wave.
Added "IsValid" property to Wave, Texture2D, Sound, Shader, RenderTexture2D, Music, Image, Model, Material, Font, and AudioStream.
Added "IsPlaying" and "IsProcessed" properties to AudioStream.
Added "Load", "Play", "Stop", "Pause", "Resume", "SetBufferSizeDefault", "SetPan", "SetPitch", "SetVolume", and "Unload" shortcut methods to AudioStream.
Added "Load", "Export", and "Unload" methods to AutomationEventList.
Added "Default" property to Font.
Added "Load", "GetMaterial", "GetTexture", "SetTexture", "SetShader", and "Unload" methods to material.
Added "Draw", "DrawInstanced", "Export", "ExportAsCode", "Upload", and "Unload" methods to Mesh.
Added "Load", "LoadFromMesh", "Unload", and a lot of "Draw" overloads.
Added "Load", "Play", "Pause", "Stop", "SetPan", "SetPitch", "SetVolume", "Seek", and "Unload" methods to Music.
Added "Load" and "Unload" methods to RenderTexture2D.
Added "Load", "LoadFromMemory", "GetLocationAttrib", "SetValue", "SetTexture", "SetMatrix", and "Unload" methods to Shader.
Removed unnecessary "partial" declarations.

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<Vector2> points, Color color)
     {
         Vector2[] pointArray = System.Linq.Enumerable.ToArray<Vector2>(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<T>(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
 }

Raylib-cs/interop/Raymath.cs

@@ -37,12 +37,9 @@ public static unsafe partial class Raymath
 
     /// <summary>Remap input value within input range to output range</summary>
     [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
     );
 
     /// <summary>Wrap input value from min to max</summary>

Raylib-cs/runtimes/linux-x64/native/.keep

@@ -0,0 +1 @@
+ 

Raylib-cs/runtimes/osx-arm64/native/.keep

@@ -0,0 +1 @@
+

Raylib-cs/runtimes/win-x86/native/.keep

@@ -0,0 +1 @@
+ 

Raylib-cs/types/AudioStream.cs

@@ -35,4 +35,68 @@ public partial struct AudioStream
     /// Number of channels (1-mono, 2-stereo)
     /// </summary>
     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);
+    }
+
+    /// <summary>
+    /// Set pan for this audio stream where 0.5 is centered
+    /// </summary>
+    /// <param name="pan"></param>
+    public void SetPan(float pan)
+    {
+        Raylib.SetAudioStreamPan(this, pan);
+    }
+
+    /// <summary>
+    /// Set pitch for this audio stream where 1.0 si base level
+    /// </summary>
+    public void SetPitch(float pitch)
+    {
+        Raylib.SetAudioStreamPitch(this, pitch);
+    }
+
+    /// <summary>
+    /// Set the volume from 0.0 to 1.0
+    /// </summary>
+    public void SetVolume(float volume)
+    {
+        Raylib.SetAudioStreamVolume(this, volume);
+    }
+
+    public void Unload()
+    {
+        Raylib.UnloadAudioStream(this);
+    }
 }

Raylib-cs/types/Automation.cs

@@ -15,6 +15,11 @@ public unsafe struct AutomationEvent
 
     /// <summary>Event parameters (if required)</summary>
     public fixed int Params[4];
+
+    public readonly void Play()
+    {
+        Raylib.PlayAutomationEvent(this);
+    }
 }
 
 /// <summary>Automation event list</summary>
@@ -31,5 +36,21 @@ public unsafe struct AutomationEventList
     public AutomationEvent* Events;
 
     /// <inheritdoc cref="Events"/>
-    public ReadOnlySpan<AutomationEvent> EventsAsSpan => new(Events, (int)Count);
+    public readonly ReadOnlySpan<AutomationEvent> EventsAsSpan => new ReadOnlySpan<AutomationEvent>(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);
+    }
+
 }

Raylib-cs/types/Camera2D.cs

@@ -7,7 +7,7 @@ namespace Raylib_cs;
 /// Camera2D, defines position/orientation in 2d space
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public partial struct Camera2D
+public struct Camera2D
 {
     /// <summary>
     /// Camera offset (displacement from target)

Raylib-cs/types/Camera3D.cs

@@ -28,7 +28,7 @@ public enum CameraProjection
 /// Camera3D, defines position/orientation in 3d space
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public partial struct Camera3D
+public struct Camera3D
 {
     /// <summary>
     /// Camera position

Raylib-cs/types/Color.cs

@@ -7,7 +7,7 @@ namespace Raylib_cs;
 /// Color type, RGBA (32bit)
 /// </summary>
 [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}}}";
     }

Raylib-cs/types/Font.cs

@@ -59,7 +59,7 @@ public partial struct GlyphInfo
 /// Font, font texture and GlyphInfo array data
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Font
+public unsafe struct Font
 {
     /// <summary>
     /// Base size (default chars height)
@@ -90,4 +90,8 @@ public unsafe partial struct Font
     /// Glyphs info data
     /// </summary>
     public GlyphInfo* Glyphs;
+
+    public readonly CBool IsValid => Raylib.IsFontValid(this);
+
+    public static Font Default => Raylib.GetFontDefault();
 }

Raylib-cs/types/Image.cs

@@ -134,7 +134,7 @@ public enum PixelFormat
 /// Image, pixel data stored in CPU memory (RAM)
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Image
+public unsafe struct Image
 {
     /// <summary>
     /// Image raw data
@@ -164,11 +164,117 @@ public unsafe partial struct Image
     /// <summary>
     /// Get width and height packed in a Vector2
     /// </summary>
-    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);
+    }
+
+    /// <summary>
+    /// Create an image from text using the default font
+    /// </summary>
+    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);
     }
 }

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<VaListLinuxX64>(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))
         {

Raylib-cs/types/Material.cs

@@ -48,7 +48,7 @@ public enum MaterialMapIndex
 /// Material texture map
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public partial struct MaterialMap
+public struct MaterialMap
 {
     /// <summary>
     /// Material map texture
@@ -70,7 +70,7 @@ public partial struct MaterialMap
 /// Material type (generic)
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Material
+public unsafe struct Material
 {
     /// <summary>
     /// Material shader
@@ -87,4 +87,55 @@ public unsafe partial struct Material
     /// Material generic parameters (if required)
     /// </summary>
     public fixed float Param[4];
+
+    public readonly CBool IsValid => Raylib.IsMaterialValid(this);
+
+    /// <summary>
+    /// Load default material
+    /// </summary>
+    public static Material Load()
+    {
+        return Raylib.LoadMaterialDefault();
+    }
+
+    /// <summary>
+    /// Load materials from model file
+    /// </summary>
+    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);
+    }
 }

Raylib-cs/types/Mesh.cs

@@ -9,7 +9,7 @@ namespace Raylib_cs;
 /// NOTE: Data stored in CPU memory (and GPU)
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Mesh
+public unsafe struct Mesh
 {
     /// <summary>
     ///  Creates a mesh ready for default vertex data allocation
@@ -30,6 +30,36 @@ public unsafe partial struct Mesh
     /// </summary>
     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
 
     /// <summary>

Raylib-cs/types/Model.cs

@@ -8,7 +8,7 @@ namespace Raylib_cs;
 /// Bone information
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct BoneInfo
+public unsafe struct BoneInfo
 {
     /// <summary>
     /// Bone name (char[32])
@@ -25,7 +25,7 @@ public unsafe partial struct BoneInfo
 /// Model type
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Model
+public unsafe struct Model
 {
     /// <summary>
     /// Local transform matrix
@@ -73,13 +73,105 @@ public unsafe partial struct Model
     /// Bones base transformation (pose, Transform *)
     /// </summary>
     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);
+    }
 }
 
 /// <summary>
 /// Model animation
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct ModelAnimation
+public unsafe struct ModelAnimation
 {
     /// <summary>
     /// Number of bones
@@ -110,7 +202,7 @@ public unsafe partial struct ModelAnimation
     public fixed sbyte Name[32];
 
     /// <inheritdoc cref="FramePoses"/>
-    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

Raylib-cs/types/Music.cs

@@ -7,7 +7,7 @@ namespace Raylib_cs;
 /// NOTE: Anything longer than ~10 seconds should be streamed
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public unsafe partial struct Music
+public unsafe struct Music
 {
     /// <summary>
     /// Audio stream
@@ -34,4 +34,63 @@ public unsafe partial struct Music
     /// Audio context data, depends on type
     /// </summary>
     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);
+    }
+
+    /// <summary>
+    /// Set pan of this music where 0.5 is centered
+    /// </summary>
+    public void SetPan(float pan)
+    {
+        Raylib.SetMusicPan(this, pan);
+    }
+
+    /// <summary>
+    /// Set pitch for this music where 1.0 is base level
+    /// </summary>}
+    public void SetPitch(float pitch)
+    {
+        Raylib.SetMusicPitch(this, pitch);
+    }
+
+    /// <summary>
+    /// Set music volume from 0.0 to 1.0
+    /// </summary>
+    public void SetVolume(float volume)
+    {
+        Raylib.SetMusicVolume(this, volume);
+    }
+
+    /// <summary>
+    /// Seek music to a position (in seconds)
+    /// </summary>
+    public void Seek(float position)
+    {
+        Raylib.SeekMusicStream(this, position);
+    }
+
+    public void Unload()
+    {
+        Raylib.UnloadMusicStream(this);
+    }
 }

Raylib-cs/types/NPatchInfo.cs

@@ -27,7 +27,7 @@ public enum NPatchLayout
 /// N-Patch layout info
 /// </summary>
 [StructLayout(LayoutKind.Sequential)]
-public partial struct NPatchInfo
+public struct NPatchInfo
 {
     /// <summary>
     /// Texture source rectangle