use GroupedNativeMethods

crates/servicepoint_binding_c/src/lib.rs

@@ -25,7 +25,7 @@
 //! }
 //! ```
 
-pub use crate::bitvec::*;
+pub use crate::bit_vec::*;
 pub use crate::bitmap::*;
 pub use crate::brightness_grid::*;
 pub use crate::byte_slice::*;
@@ -35,7 +35,7 @@ pub use crate::constants::*;
 pub use crate::cp437_grid::*;
 pub use crate::packet::*;
 
-mod bitvec;
+mod bit_vec;
 mod bitmap;
 mod brightness_grid;
 mod byte_slice;

crates/servicepoint_binding_cs/Cargo.toml

@@ -11,6 +11,7 @@ test = false
 
 [build-dependencies]
 csbindgen = "1.9.3"
+convert_case = "0.6.0"
 
 [dependencies]
 servicepoint_binding_c = { version = "0.10.0", path = "../servicepoint_binding_c" }

crates/servicepoint_binding_cs/ServicePoint/BindGen/BitVecNative.g.cs

@@ -0,0 +1,247 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class BitVecNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Creates a new [SPBitVec] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `size`: size in bits.
+        ///
+        ///  returns: [SPBitVec] with all bits set to false. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `size` is not divisible by 8.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitvec_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BitVec* sp_bitvec_new(nuint size);
+
+        /// <summary>
+        ///  Interpret the data as a series of bits and load then into a new [SPBitVec] instance.
+        ///
+        ///  returns: [SPBitVec] instance containing data. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `data` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `data` points to a valid memory location of at least `data_length`
+        ///    bytes in size.
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitvec_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BitVec* sp_bitvec_load(byte* data, nuint data_length);
+
+        /// <summary>
+        ///  Clones a [SPBitVec].
+        ///
+        ///  returns: new [SPBitVec] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - `bit_vec` is not written to concurrently
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitvec_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BitVec* sp_bitvec_clone(BitVec* bit_vec);
+
+        /// <summary>
+        ///  Deallocates a [SPBitVec].
+        ///
+        ///  # Panics
+        ///
+        ///  - when `but_vec` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - `bit_vec` is not used concurrently or after this call
+        ///  - `bit_vec` was not passed to another consuming function, e.g. to create a [SPCommand]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitvec_free(BitVec* bit_vec);
+
+        /// <summary>
+        ///  Gets the value of a bit from the [SPBitVec].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to read from
+        ///  - `index`: the bit index to read
+        ///
+        ///  returns: value of the bit
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///  - when accessing `index` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - `bit_vec` is not written to concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.U1)]
+        public static extern bool sp_bitvec_get(BitVec* bit_vec, nuint index);
+
+        /// <summary>
+        ///  Sets the value of a bit in the [SPBitVec].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to write to
+        ///  - `index`: the bit index to edit
+        ///  - `value`: the value to set the bit to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///  - when accessing `index` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - `bit_vec` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitvec_set(BitVec* bit_vec, nuint index, [MarshalAs(UnmanagedType.U1)] bool value);
+
+        /// <summary>
+        ///  Sets the value of all bits in the [SPBitVec].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to write to
+        ///  - `value`: the value to set all bits to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - `bit_vec` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitvec_fill(BitVec* bit_vec, [MarshalAs(UnmanagedType.U1)] bool value);
+
+        /// <summary>
+        ///  Gets the length of the [SPBitVec] in bits.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to write to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_len", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_bitvec_len(BitVec* bit_vec);
+
+        /// <summary>
+        ///  Returns true if length is 0.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to write to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_is_empty", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.U1)]
+        public static extern bool sp_bitvec_is_empty(BitVec* bit_vec);
+
+        /// <summary>
+        ///  Gets an unsafe reference to the data of the [SPBitVec] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bit_vec`: instance to write to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is NULL
+        ///
+        ///  ## Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid [SPBitVec]
+        ///  - the returned memory range is never accessed after the passed [SPBitVec] has been freed
+        ///  - the returned memory range is never accessed concurrently, either via the [SPBitVec] or directly
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitvec_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ByteSlice sp_bitvec_unsafe_data_ref(BitVec* bit_vec);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct BitVec
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/BitmapNative.g.cs

@@ -0,0 +1,249 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class BitmapNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Creates a new [SPBitmap] with the specified dimensions.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `width`: size in pixels in x-direction
+        ///  - `height`: size in pixels in y-direction
+        ///
+        ///  returns: [SPBitmap] initialized to all pixels off. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when the width is not dividable by 8
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitmap_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Bitmap* sp_bitmap_new(nuint width, nuint height);
+
+        /// <summary>
+        ///  Loads a [SPBitmap] with the specified dimensions from the provided data.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `width`: size in pixels in x-direction
+        ///  - `height`: size in pixels in y-direction
+        ///
+        ///  returns: [SPBitmap] that contains a copy of the provided data. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `data` is NULL
+        ///  - when the dimensions and data size do not match exactly.
+        ///  - when the width is not dividable by 8
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `data` points to a valid memory location of at least `data_length` bytes in size.
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitmap_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Bitmap* sp_bitmap_load(nuint width, nuint height, byte* data, nuint data_length);
+
+        /// <summary>
+        ///  Clones a [SPBitmap].
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - `bitmap` is not written to concurrently
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_bitmap_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Bitmap* sp_bitmap_clone(Bitmap* bitmap);
+
+        /// <summary>
+        ///  Deallocates a [SPBitmap].
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - `bitmap` is not used concurrently or after bitmap call
+        ///  - `bitmap` was not passed to another consuming function, e.g. to create a [SPCommand]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitmap_free(Bitmap* bitmap);
+
+        /// <summary>
+        ///  Gets the current value at the specified position in the [SPBitmap].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bitmap`: instance to read from
+        ///  - `x` and `y`: position of the cell to read
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///  - when accessing `x` or `y` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - `bitmap` is not written to concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.U1)]
+        public static extern bool sp_bitmap_get(Bitmap* bitmap, nuint x, nuint y);
+
+        /// <summary>
+        ///  Sets the value of the specified position in the [SPBitmap].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bitmap`: instance to write to
+        ///  - `x` and `y`: position of the cell
+        ///  - `value`: the value to write to the cell
+        ///
+        ///  returns: old value of the cell
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///  - when accessing `x` or `y` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - `bitmap` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitmap_set(Bitmap* bitmap, nuint x, nuint y, [MarshalAs(UnmanagedType.U1)] bool value);
+
+        /// <summary>
+        ///  Sets the state of all pixels in the [SPBitmap].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bitmap`: instance to write to
+        ///  - `value`: the value to set all pixels to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - `bitmap` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_bitmap_fill(Bitmap* bitmap, [MarshalAs(UnmanagedType.U1)] bool value);
+
+        /// <summary>
+        ///  Gets the width in pixels of the [SPBitmap] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bitmap`: instance to read from
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_bitmap_width(Bitmap* bitmap);
+
+        /// <summary>
+        ///  Gets the height in pixels of the [SPBitmap] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `bitmap`: instance to read from
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_bitmap_height(Bitmap* bitmap);
+
+        /// <summary>
+        ///  Gets an unsafe reference to the data of the [SPBitmap] instance.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid [SPBitmap]
+        ///  - the returned memory range is never accessed after the passed [SPBitmap] has been freed
+        ///  - the returned memory range is never accessed concurrently, either via the [SPBitmap] or directly
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_bitmap_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ByteSlice sp_bitmap_unsafe_data_ref(Bitmap* bitmap);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct Bitmap
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/BrightnessGridNative.g.cs

@@ -0,0 +1,259 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class BrightnessGridNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+        public const byte SP_BRIGHTNESS_MIN = 0;
+        public const byte SP_BRIGHTNESS_MAX = 11;
+        public const byte SP_BRIGHTNESS_LEVELS = 12;
+
+
+        /// <summary>
+        ///  Creates a new [SPBrightnessGrid] with the specified dimensions.
+        ///
+        ///  returns: [SPBrightnessGrid] initialized to 0. Will never return NULL.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_brightness_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BrightnessGrid* sp_brightness_grid_new(nuint width, nuint height);
+
+        /// <summary>
+        ///  Loads a [SPBrightnessGrid] with the specified dimensions from the provided data.
+        ///
+        ///  returns: new [SPBrightnessGrid] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `data` is NULL
+        ///  - when the provided `data_length` does not match `height` and `width`
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `data` points to a valid memory location of at least `data_length`
+        ///    bytes in size.
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_brightness_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BrightnessGrid* sp_brightness_grid_load(nuint width, nuint height, byte* data, nuint data_length);
+
+        /// <summary>
+        ///  Clones a [SPBrightnessGrid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///
+        ///  returns: new [SPBrightnessGrid] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        ///  - `brightness_grid` is not written to concurrently
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_brightness_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern BrightnessGrid* sp_brightness_grid_clone(BrightnessGrid* brightness_grid);
+
+        /// <summary>
+        ///  Deallocates a [SPBrightnessGrid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        ///  - `brightness_grid` is not used concurrently or after this call
+        ///  - `brightness_grid` was not passed to another consuming function, e.g. to create a [SPCommand]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_brightness_grid_free(BrightnessGrid* brightness_grid);
+
+        /// <summary>
+        ///  Gets the current value at the specified position.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///  - `x` and `y`: position of the cell to read
+        ///
+        ///  returns: value at position
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///  - When accessing `x` or `y` out of bounds.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        ///  - `brightness_grid` is not written to concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern byte sp_brightness_grid_get(BrightnessGrid* brightness_grid, nuint x, nuint y);
+
+        /// <summary>
+        ///  Sets the value of the specified position in the [SPBrightnessGrid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to write to
+        ///  - `x` and `y`: position of the cell
+        ///  - `value`: the value to write to the cell
+        ///
+        ///  returns: old value of the cell
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///  - When accessing `x` or `y` out of bounds.
+        ///  - When providing an invalid brightness value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBitVec]
+        ///  - `brightness_grid` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_brightness_grid_set(BrightnessGrid* brightness_grid, nuint x, nuint y, byte value);
+
+        /// <summary>
+        ///  Sets the value of all cells in the [SPBrightnessGrid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to write to
+        ///  - `value`: the value to set all cells to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///  - When providing an invalid brightness value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        ///  - `brightness_grid` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_brightness_grid_fill(BrightnessGrid* brightness_grid, byte value);
+
+        /// <summary>
+        ///  Gets the width of the [SPBrightnessGrid] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///
+        ///  returns: width
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_brightness_grid_width(BrightnessGrid* brightness_grid);
+
+        /// <summary>
+        ///  Gets the height of the [SPBrightnessGrid] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///
+        ///  returns: height
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_brightness_grid_height(BrightnessGrid* brightness_grid);
+
+        /// <summary>
+        ///  Gets an unsafe reference to the data of the [SPBrightnessGrid] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `brightness_grid`: instance to read from
+        ///
+        ///  returns: slice of bytes underlying the `brightness_grid`.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `brightness_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
+        ///  - the returned memory range is never accessed after the passed [SPBrightnessGrid] has been freed
+        ///  - the returned memory range is never accessed concurrently, either via the [SPBrightnessGrid] or directly
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ByteSlice sp_brightness_grid_unsafe_data_ref(BrightnessGrid* brightness_grid);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct BrightnessGrid
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/ByteSliceNative.g.cs

@@ -0,0 +1,24 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct ByteSlice
+    {
+        public byte* start;
+        public nuint length;
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/CommandNative.g.cs

@@ -0,0 +1,364 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class CommandNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Tries to turn a [SPPacket] into a [SPCommand].
+        ///
+        ///  The packet is deallocated in the process.
+        ///
+        ///  Returns: pointer to new [SPCommand] instance or NULL if parsing failed.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `packet` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - [SPPacket] points to a valid instance of [SPPacket]
+        ///  - [SPPacket] is not used concurrently or after this call
+        ///  - the result is checked for NULL
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_try_from_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_try_from_packet(Packet* packet);
+
+        /// <summary>
+        ///  Clones a [SPCommand] instance.
+        ///
+        ///  returns: new [SPCommand] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `command` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `command` points to a valid instance of [SPCommand]
+        ///  - `command` is not written to concurrently
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_clone(Command* command);
+
+        /// <summary>
+        ///  Set all pixels to the off state.
+        ///
+        ///  Does not affect brightness.
+        ///
+        ///  Returns: a new [Command::Clear] instance. Will never return NULL.
+        ///
+        ///  # Examples
+        ///
+        ///  ```C
+        ///  sp_connection_send_command(connection, sp_command_clear());
+        ///  ```
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_clear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_clear();
+
+        /// <summary>
+        ///  Kills the udp daemon on the display, which usually results in a restart.
+        ///
+        ///  Please do not send this in your normal program flow.
+        ///
+        ///  Returns: a new [Command::HardReset] instance. Will never return NULL.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_hard_reset", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_hard_reset();
+
+        /// <summary>
+        ///  A yet-to-be-tested command.
+        ///
+        ///  Returns: a new `Command::FadeOut` instance. Will never return NULL.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_fade_out", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_fade_out();
+
+        /// <summary>
+        ///  Set the brightness of all tiles to the same value.
+        ///
+        ///  Returns: a new [Command::Brightness] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - When the provided brightness value is out of range (0-11).
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_brightness(byte brightness);
+
+        /// <summary>
+        ///  Set the brightness of individual tiles in a rectangular area of the display.
+        ///
+        ///  The passed [SPBrightnessGrid] gets consumed.
+        ///
+        ///  Returns: a new [Command::CharBrightness] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `grid` points to a valid instance of [SPBrightnessGrid]
+        ///  - `grid` is not used concurrently or after this call
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_char_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_char_brightness(nuint x, nuint y, BrightnessGrid* grid);
+
+        /// <summary>
+        ///  Set pixel data starting at the pixel offset on screen.
+        ///
+        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
+        ///  once the starting row is full, overwriting will continue on column 0.
+        ///
+        ///  The contained [SPBitVec] is always uncompressed.
+        ///
+        ///  The passed [SPBitVec] gets consumed.
+        ///
+        ///  Returns: a new [Command::BitmapLinear] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is null
+        ///  - when `compression_code` is not a valid value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid instance of [SPBitVec]
+        ///  - `bit_vec` is not used concurrently or after this call
+        ///  - `compression` matches one of the allowed enum values
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_bitmap_linear(nuint offset, BitVec* bit_vec, CompressionCode compression);
+
+        /// <summary>
+        ///  Set pixel data according to an and-mask starting at the offset.
+        ///
+        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
+        ///  once the starting row is full, overwriting will continue on column 0.
+        ///
+        ///  The contained [SPBitVec] is always uncompressed.
+        ///
+        ///  The passed [SPBitVec] gets consumed.
+        ///
+        ///  Returns: a new [Command::BitmapLinearAnd] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is null
+        ///  - when `compression_code` is not a valid value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid instance of [SPBitVec]
+        ///  - `bit_vec` is not used concurrently or after this call
+        ///  - `compression` matches one of the allowed enum values
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_and", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_bitmap_linear_and(nuint offset, BitVec* bit_vec, CompressionCode compression);
+
+        /// <summary>
+        ///  Set pixel data according to an or-mask starting at the offset.
+        ///
+        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
+        ///  once the starting row is full, overwriting will continue on column 0.
+        ///
+        ///  The contained [SPBitVec] is always uncompressed.
+        ///
+        ///  The passed [SPBitVec] gets consumed.
+        ///
+        ///  Returns: a new [Command::BitmapLinearOr] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is null
+        ///  - when `compression_code` is not a valid value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid instance of [SPBitVec]
+        ///  - `bit_vec` is not used concurrently or after this call
+        ///  - `compression` matches one of the allowed enum values
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_or", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_bitmap_linear_or(nuint offset, BitVec* bit_vec, CompressionCode compression);
+
+        /// <summary>
+        ///  Set pixel data according to a xor-mask starting at the offset.
+        ///
+        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
+        ///  once the starting row is full, overwriting will continue on column 0.
+        ///
+        ///  The contained [SPBitVec] is always uncompressed.
+        ///
+        ///  The passed [SPBitVec] gets consumed.
+        ///
+        ///  Returns: a new [Command::BitmapLinearXor] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bit_vec` is null
+        ///  - when `compression_code` is not a valid value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bit_vec` points to a valid instance of [SPBitVec]
+        ///  - `bit_vec` is not used concurrently or after this call
+        ///  - `compression` matches one of the allowed enum values
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_xor", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_bitmap_linear_xor(nuint offset, BitVec* bit_vec, CompressionCode compression);
+
+        /// <summary>
+        ///  Show text on the screen.
+        ///
+        ///  The passed [SPCp437Grid] gets consumed.
+        ///
+        ///  Returns: a new [Command::Cp437Data] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `grid` is null
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `grid` points to a valid instance of [SPCp437Grid]
+        ///  - `grid` is not used concurrently or after this call
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_cp437_data", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_cp437_data(nuint x, nuint y, Cp437Grid* grid);
+
+        /// <summary>
+        ///  Sets a window of pixels to the specified values.
+        ///
+        ///  The passed [SPBitmap] gets consumed.
+        ///
+        ///  Returns: a new [Command::BitmapLinearWin] instance. Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `bitmap` is null
+        ///  - when `compression_code` is not a valid value
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `bitmap` points to a valid instance of [SPBitmap]
+        ///  - `bitmap` is not used concurrently or after this call
+        ///  - `compression` matches one of the allowed enum values
+        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_command_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_win", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Command* sp_command_bitmap_linear_win(nuint x, nuint y, Bitmap* bitmap, CompressionCode compression_code);
+
+        /// <summary>
+        ///  Deallocates a [SPCommand].
+        ///
+        ///  # Examples
+        ///
+        ///  ```C
+        ///  SPCommand c = sp_command_clear();
+        ///  sp_command_free(c);
+        ///  ```
+        ///
+        ///  # Panics
+        ///
+        ///  - when `command` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `command` points to a valid [SPCommand]
+        ///  - `command` is not used concurrently or after this call
+        ///  - `command` was not passed to another consuming function, e.g. to create a [SPPacket]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_command_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_command_free(Command* command);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct Command
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/ConnectionNative.g.cs

@@ -0,0 +1,113 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class ConnectionNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Creates a new instance of [SPConnection].
+        ///
+        ///  returns: NULL if connection fails, or connected instance
+        ///
+        ///  # Panics
+        ///
+        ///  - when `host` is null or an invalid host
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_connection_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_connection_open", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Connection* sp_connection_open(byte* host);
+
+        /// <summary>
+        ///  Sends a [SPPacket] to the display using the [SPConnection].
+        ///
+        ///  The passed `packet` gets consumed.
+        ///
+        ///  returns: true in case of success
+        ///
+        ///  # Panics
+        ///
+        ///  - when `connection` is NULL
+        ///  - when `packet` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `connection` points to a valid instance of [SPConnection]
+        ///  - `packet` points to a valid instance of [SPPacket]
+        ///  - `packet` is not used concurrently or after this call
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_connection_send_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.U1)]
+        public static extern bool sp_connection_send_packet(Connection* connection, Packet* packet);
+
+        /// <summary>
+        ///  Sends a [SPCommand] to the display using the [SPConnection].
+        ///
+        ///  The passed `command` gets consumed.
+        ///
+        ///  returns: true in case of success
+        ///
+        ///  # Panics
+        ///
+        ///  - when `connection` is NULL
+        ///  - when `command` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `connection` points to a valid instance of [SPConnection]
+        ///  - `command` points to a valid instance of [SPPacket]
+        ///  - `command` is not used concurrently or after this call
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_connection_send_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.U1)]
+        public static extern bool sp_connection_send_command(Connection* connection, Command* command);
+
+        /// <summary>
+        ///  Closes and deallocates a [SPConnection].
+        ///
+        ///  # Panics
+        ///
+        ///  - when `connection` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `connection` points to a valid [SPConnection]
+        ///  - `connection` is not used concurrently or after this call
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_connection_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_connection_free(Connection* connection);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct Connection
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/ConstantsNative.g.cs

@@ -0,0 +1,36 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class ConstantsNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+        public const nuint SP_TILE_SIZE = 8;
+        public const nuint SP_TILE_WIDTH = 56;
+        public const nuint SP_TILE_HEIGHT = 20;
+
+
+
+    }
+
+
+    public enum CompressionCode : ushort
+    {
+        Uncompressed = 0,
+        Zlib = 26490,
+        Bzip2 = 25210,
+        Lzma = 27770,
+        Zstd = 31347,
+    }
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/Cp437GridNative.g.cs

@@ -0,0 +1,236 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class Cp437GridNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Creates a new [SPCp437Grid] with the specified dimensions.
+        ///
+        ///  returns: [SPCp437Grid] initialized to 0. Will never return NULL.
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_cp437_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Cp437Grid* sp_cp437_grid_new(nuint width, nuint height);
+
+        /// <summary>
+        ///  Loads a [SPCp437Grid] with the specified dimensions from the provided data.
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `data` is NULL
+        ///  - when the provided `data_length` does not match `height` and `width`
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `data` points to a valid memory location of at least `data_length`
+        ///    bytes in size.
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_cp437_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Cp437Grid* sp_cp437_grid_load(nuint width, nuint height, byte* data, nuint data_length);
+
+        /// <summary>
+        ///  Clones a [SPCp437Grid].
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        ///  - `cp437_grid` is not written to concurrently
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_cp437_grid_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Cp437Grid* sp_cp437_grid_clone(Cp437Grid* cp437_grid);
+
+        /// <summary>
+        ///  Deallocates a [SPCp437Grid].
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        ///  - `cp437_grid` is not used concurrently or after cp437_grid call
+        ///  - `cp437_grid` was not passed to another consuming function, e.g. to create a [SPCommand]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_cp437_grid_free(Cp437Grid* cp437_grid);
+
+        /// <summary>
+        ///  Gets the current value at the specified position.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `cp437_grid`: instance to read from
+        ///  - `x` and `y`: position of the cell to read
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///  - when accessing `x` or `y` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        ///  - `cp437_grid` is not written to concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern byte sp_cp437_grid_get(Cp437Grid* cp437_grid, nuint x, nuint y);
+
+        /// <summary>
+        ///  Sets the value of the specified position in the [SPCp437Grid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `cp437_grid`: instance to write to
+        ///  - `x` and `y`: position of the cell
+        ///  - `value`: the value to write to the cell
+        ///
+        ///  returns: old value of the cell
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///  - when accessing `x` or `y` out of bounds
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPBitVec]
+        ///  - `cp437_grid` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_cp437_grid_set(Cp437Grid* cp437_grid, nuint x, nuint y, byte value);
+
+        /// <summary>
+        ///  Sets the value of all cells in the [SPCp437Grid].
+        ///
+        ///  # Arguments
+        ///
+        ///  - `cp437_grid`: instance to write to
+        ///  - `value`: the value to set all cells to
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        ///  - `cp437_grid` is not written to or read from concurrently
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_cp437_grid_fill(Cp437Grid* cp437_grid, byte value);
+
+        /// <summary>
+        ///  Gets the width of the [SPCp437Grid] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `cp437_grid`: instance to read from
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_cp437_grid_width(Cp437Grid* cp437_grid);
+
+        /// <summary>
+        ///  Gets the height of the [SPCp437Grid] instance.
+        ///
+        ///  # Arguments
+        ///
+        ///  - `cp437_grid`: instance to read from
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern nuint sp_cp437_grid_height(Cp437Grid* cp437_grid);
+
+        /// <summary>
+        ///  Gets an unsafe reference to the data of the [SPCp437Grid] instance.
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `cp437_grid` is NULL
+        ///
+        ///  ## Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `cp437_grid` points to a valid [SPCp437Grid]
+        ///  - the returned memory range is never accessed after the passed [SPCp437Grid] has been freed
+        ///  - the returned memory range is never accessed concurrently, either via the [SPCp437Grid] or directly
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern ByteSlice sp_cp437_grid_unsafe_data_ref(Cp437Grid* cp437_grid);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct Cp437Grid
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/Extensions.cs

@@ -0,0 +1,49 @@
+using GroupedNativeMethodsGenerator;
+
+namespace ServicePoint.BindGen;
+
+[GroupedNativeMethods(removePrefix: "sp_bitmap_")]
+public static unsafe partial class BitmapNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_bitvec_")]
+public static unsafe partial class BitVecNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_brightness_grid")]
+public static unsafe partial class BrightnessGridNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_byte_slice")]
+public static unsafe partial class ByteSliceNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_command_")]
+public static unsafe partial class CommandNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_connection_")]
+public static unsafe partial class ConnectionNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_constants_")]
+public static unsafe partial class ConstantsNative
+{
+}
+
+
+[GroupedNativeMethods(removePrefix: "sp_cp437_grid_")]
+public static unsafe partial class Cp437GridNative
+{
+}
+
+[GroupedNativeMethods(removePrefix: "sp_packet_")]
+public static unsafe partial class PacketNative
+{
+}

crates/servicepoint_binding_cs/ServicePoint/BindGen/PacketNative.g.cs

@@ -0,0 +1,110 @@
+// <auto-generated>
+// This code is generated by csbindgen.
+// DON'T CHANGE THIS DIRECTLY.
+// </auto-generated>
+#pragma warning disable CS8500
+#pragma warning disable CS8981
+using System;
+using System.Runtime.InteropServices;
+
+
+namespace ServicePoint.BindGen
+{
+    public static unsafe partial class PacketNative
+    {
+        const string __DllName = "servicepoint_binding_c";
+
+
+
+        /// <summary>
+        ///  Turns a [SPCommand] into a [SPPacket].
+        ///  The [SPCommand] gets consumed.
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `command` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - [SPCommand] points to a valid instance of [SPCommand]
+        ///  - [SPCommand] is not used concurrently or after this call
+        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_packet_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_packet_from_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Packet* sp_packet_from_command(Command* command);
+
+        /// <summary>
+        ///  Tries to load a [SPPacket] from the passed array with the specified length.
+        ///
+        ///  returns: NULL in case of an error, pointer to the allocated packet otherwise
+        ///
+        ///  # Panics
+        ///
+        ///  - when `data` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `data` points to a valid memory region of at least `length` bytes
+        ///  - `data` is not written to concurrently
+        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_packet_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_packet_try_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Packet* sp_packet_try_load(byte* data, nuint length);
+
+        /// <summary>
+        ///  Clones a [SPPacket].
+        ///
+        ///  Will never return NULL.
+        ///
+        ///  # Panics
+        ///
+        ///  - when `packet` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `packet` points to a valid [SPPacket]
+        ///  - `packet` is not written to concurrently
+        ///  - the returned instance is freed in some way, either by using a consuming function or
+        ///    by explicitly calling `sp_packet_free`.
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_packet_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern Packet* sp_packet_clone(Packet* packet);
+
+        /// <summary>
+        ///  Deallocates a [SPPacket].
+        ///
+        ///  # Panics
+        ///
+        ///  - when `sp_packet_free` is NULL
+        ///
+        ///  # Safety
+        ///
+        ///  The caller has to make sure that:
+        ///
+        ///  - `packet` points to a valid [SPPacket]
+        ///  - `packet` is not used concurrently or after this call
+        /// </summary>
+        [DllImport(__DllName, EntryPoint = "sp_packet_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void sp_packet_free(Packet* packet);
+
+
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe partial struct Packet
+    {
+    }
+
+
+
+}

crates/servicepoint_binding_cs/ServicePoint/BitVec.cs

@@ -4,11 +4,11 @@ namespace ServicePoint;
 
 public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
 {
-    public static BitVec New(int size)
+    public static BitVec New(nuint size)
     {
         unsafe
         {
-            return new BitVec(NativeMethods.sp_bitvec_new((nuint)size));
+            return new BitVec(BitVecNative.sp_bitvec_new(size));
         }
     }
 
@@ -18,7 +18,7 @@ public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
         {
             fixed (byte* bytesPtr = bytes)
             {
-                return new BitVec(NativeMethods.sp_bitvec_load(bytesPtr, (nuint)bytes.Length));
+                return new BitVec(BitVecNative.sp_bitvec_load(bytesPtr, (nuint)bytes.Length));
             }
         }
     }
@@ -27,24 +27,24 @@ public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
     {
         unsafe
         {
-            return new BitVec(NativeMethods.sp_bitvec_clone(Instance));
+            return new BitVec(Instance->Clone());
         }
     }
 
-    public bool this[int index]
+    public bool this[nuint index]
     {
         get
         {
             unsafe
             {
-                return NativeMethods.sp_bitvec_get(Instance, (nuint)index);
+                return Instance->Get(index);
             }
         }
         set
         {
             unsafe
             {
-                NativeMethods.sp_bitvec_set(Instance, (nuint)index, value);
+                Instance->Set(index, value);
             }
         }
     }
@@ -53,17 +53,17 @@ public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
     {
         unsafe
         {
-            NativeMethods.sp_bitvec_fill(Instance, value);
+            Instance->Fill(value);
         }
     }
 
-    public int Length
+    public nuint Length
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_bitvec_len(Instance);
+                return Instance->Len();
             }
         }
     }
@@ -74,8 +74,7 @@ public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
         {
             unsafe
             {
-                var slice = NativeMethods.sp_bitvec_unsafe_data_ref(Instance);
-                return new Span<byte>(slice.start, (int)slice.length);
+                return Instance->UnsafeDataRef().AsSpan();
             }
         }
     }
@@ -84,5 +83,5 @@ public sealed class BitVec : SpNativeInstance<BindGen.BitVec>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_bitvec_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/Bitmap.cs

@@ -4,21 +4,21 @@ namespace ServicePoint;
 
 public sealed class Bitmap : SpNativeInstance<BindGen.Bitmap>
 {
-    public static Bitmap New(int width, int height)
+    public static Bitmap New(nuint width, nuint height)
     {
         unsafe
         {
-            return new Bitmap(NativeMethods.sp_bitmap_new((nuint)width, (nuint)height));
+            return new Bitmap(BitmapNative.sp_bitmap_new(width, height));
         }
     }
 
-    public static Bitmap Load(int width, int height, Span<byte> bytes)
+    public static Bitmap Load(nuint width, nuint height, Span<byte> bytes)
     {
         unsafe
         {
             fixed (byte* bytesPtr = bytes)
             {
-                return new Bitmap(NativeMethods.sp_bitmap_load((nuint)width, (nuint)height, bytesPtr,
+                return new Bitmap(BitmapNative.sp_bitmap_load(width, height, bytesPtr,
                     (nuint)bytes.Length));
             }
         }
@@ -28,24 +28,24 @@ public sealed class Bitmap : SpNativeInstance<BindGen.Bitmap>
     {
         unsafe
         {
-            return new Bitmap(NativeMethods.sp_bitmap_clone(Instance));
+            return new Bitmap(Instance->Clone());
         }
     }
 
-    public bool this[int x, int y]
+    public bool this[nuint x, nuint y]
     {
         get
         {
             unsafe
             {
-                return NativeMethods.sp_bitmap_get(Instance, (nuint)x, (nuint)y);
+                return Instance->Get(x, y);
             }
         }
         set
         {
             unsafe
             {
-                NativeMethods.sp_bitmap_set(Instance, (nuint)x, (nuint)y, value);
+                Instance->Set(x, y, value);
             }
         }
     }
@@ -54,28 +54,28 @@ public sealed class Bitmap : SpNativeInstance<BindGen.Bitmap>
     {
         unsafe
         {
-            NativeMethods.sp_bitmap_fill(Instance, value);
+            Instance->Fill(value);
         }
     }
 
-    public int Width
+    public nuint Width
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_bitmap_width(Instance);
+                return Instance->Width();
             }
         }
     }
 
-    public int Height
+    public nuint Height
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_bitmap_height(Instance);
+                return Instance->Height();
             }
         }
     }
@@ -86,7 +86,7 @@ public sealed class Bitmap : SpNativeInstance<BindGen.Bitmap>
         {
             unsafe
             {
-                var slice = NativeMethods.sp_bitmap_unsafe_data_ref(Instance);
+                var slice = Instance->UnsafeDataRef();
                 return new Span<byte>(slice.start, (int)slice.length);
             }
         }
@@ -96,5 +96,5 @@ public sealed class Bitmap : SpNativeInstance<BindGen.Bitmap>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_bitmap_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/BrightnessGrid.cs

@@ -4,21 +4,21 @@ namespace ServicePoint;
 
 public sealed class BrightnessGrid : SpNativeInstance<BindGen.BrightnessGrid>
 {
-    public static BrightnessGrid New(int width, int height)
+    public static BrightnessGrid New(nuint width, nuint height)
     {
         unsafe
         {
-            return new BrightnessGrid(NativeMethods.sp_brightness_grid_new((nuint)width, (nuint)height));
+            return new BrightnessGrid(BrightnessGridNative.sp_brightness_grid_new(width, height));
         }
     }
 
-    public static BrightnessGrid Load(int width, int height, Span<byte> bytes)
+    public static BrightnessGrid Load(nuint width, nuint height, Span<byte> bytes)
     {
         unsafe
         {
             fixed (byte* bytesPtr = bytes)
             {
-                return new BrightnessGrid(NativeMethods.sp_brightness_grid_load((nuint)width, (nuint)height, bytesPtr,
+                return new BrightnessGrid(BrightnessGridNative.sp_brightness_grid_load(width, height, bytesPtr,
                     (nuint)bytes.Length));
             }
         }
@@ -28,24 +28,24 @@ public sealed class BrightnessGrid : SpNativeInstance<BindGen.BrightnessGrid>
     {
         unsafe
         {
-            return new BrightnessGrid(NativeMethods.sp_brightness_grid_clone(Instance));
+            return new BrightnessGrid(Instance->Clone());
         }
     }
 
-    public byte this[int x, int y]
+    public byte this[nuint x, nuint y]
     {
         get
         {
             unsafe
             {
-                return NativeMethods.sp_brightness_grid_get(Instance, (nuint)x, (nuint)y);
+                return Instance->Get(x, y);
             }
         }
         set
         {
             unsafe
             {
-                NativeMethods.sp_brightness_grid_set(Instance, (nuint)x, (nuint)y, value);
+                Instance->Set(x, y, value);
             }
         }
     }
@@ -54,28 +54,28 @@ public sealed class BrightnessGrid : SpNativeInstance<BindGen.BrightnessGrid>
     {
         unsafe
         {
-            NativeMethods.sp_brightness_grid_fill(Instance, value);
+            Instance->Fill(value);
         }
     }
 
-    public int Width
+    public nuint Width
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_brightness_grid_width(Instance);
+                return Instance->Width();
             }
         }
     }
 
-    public int Height
+    public nuint Height
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_brightness_grid_height(Instance);
+                return Instance->Height();
             }
         }
     }
@@ -86,8 +86,7 @@ public sealed class BrightnessGrid : SpNativeInstance<BindGen.BrightnessGrid>
         {
             unsafe
             {
-                var slice = NativeMethods.sp_brightness_grid_unsafe_data_ref(Instance);
-                return new Span<byte>(slice.start, (int)slice.length);
+                return Instance->UnsafeDataRef().AsSpan();
             }
         }
     }
@@ -96,5 +95,5 @@ public sealed class BrightnessGrid : SpNativeInstance<BindGen.BrightnessGrid>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_brightness_grid_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/Command.cs

@@ -9,7 +9,7 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            var result = NativeMethods.sp_command_try_from_packet(packet.Into());
+            var result = CommandNative.sp_command_try_from_packet(packet.Into());
             if (result == null)
             {
                 command = null;
@@ -25,7 +25,7 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_clone(Instance));
+            return new Command(Instance->Clone());
         }
     }
 
@@ -33,7 +33,7 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_clear());
+            return new Command(CommandNative.sp_command_clear());
         }
     }
 
@@ -41,7 +41,7 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_hard_reset());
+            return new Command(CommandNative.sp_command_hard_reset());
         }
     }
 
@@ -49,7 +49,7 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_fade_out());
+            return new Command(CommandNative.sp_command_fade_out());
         }
     }
 
@@ -57,67 +57,67 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_brightness(brightness));
+            return new Command(CommandNative.sp_command_brightness(brightness));
         }
     }
 
-    public static Command CharBrightness(int x, int y, BrightnessGrid grid)
+    public static Command CharBrightness(ushort x, ushort y, BrightnessGrid grid)
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_char_brightness((ushort)x, (ushort)y, grid.Into()));
+            return new Command(CommandNative.sp_command_char_brightness(x, y, grid.Into()));
         }
     }
 
-    public static Command BitmapLinear(int offset, BitVec bitVec, CompressionCode compressionCode)
+    public static Command BitmapLinear(ushort offset, BitVec bitVec, CompressionCode compressionCode)
     {
         unsafe
         {
             return new Command(
-                NativeMethods.sp_command_bitmap_linear((ushort)offset, bitVec.Into(), compressionCode));
+                CommandNative.sp_command_bitmap_linear(offset, bitVec.Into(), compressionCode));
         }
     }
 
-    public static Command BitmapLinearAnd(int offset, BitVec bitVec, CompressionCode compressionCode)
+    public static Command BitmapLinearAnd(ushort offset, BitVec bitVec, CompressionCode compressionCode)
     {
         unsafe
         {
             return new Command(
-                NativeMethods.sp_command_bitmap_linear_and((ushort)offset, bitVec.Into(), compressionCode));
+                CommandNative.sp_command_bitmap_linear_and(offset, bitVec.Into(), compressionCode));
         }
     }
 
-    public static Command BitmapLinearOr(int offset, BitVec bitVec, CompressionCode compressionCode)
+    public static Command BitmapLinearOr(ushort offset, BitVec bitVec, CompressionCode compressionCode)
     {
         unsafe
         {
             return new Command(
-                NativeMethods.sp_command_bitmap_linear_or((ushort)offset, bitVec.Into(), compressionCode));
+                CommandNative.sp_command_bitmap_linear_or(offset, bitVec.Into(), compressionCode));
         }
     }
 
-    public static Command BitmapLinearXor(int offset, BitVec bitVec, CompressionCode compressionCode)
+    public static Command BitmapLinearXor(ushort offset, BitVec bitVec, CompressionCode compressionCode)
     {
         unsafe
         {
             return new Command(
-                NativeMethods.sp_command_bitmap_linear_xor((ushort)offset, bitVec.Into(), compressionCode));
+                CommandNative.sp_command_bitmap_linear_xor(offset, bitVec.Into(), compressionCode));
         }
     }
 
-    public static Command BitmapLinearWin(int x, int y, Bitmap bitmap, CompressionCode compression)
+    public static Command BitmapLinearWin(ushort x, ushort y, Bitmap bitmap, CompressionCode compression)
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_bitmap_linear_win((ushort)x, (ushort)y, bitmap.Into(), compression));
+            return new Command(CommandNative.sp_command_bitmap_linear_win(x, y, bitmap.Into(), compression));
         }
     }
 
-    public static Command Cp437Data(int x, int y, Cp437Grid byteGrid)
+    public static Command Cp437Data(ushort x, ushort y, Cp437Grid byteGrid)
     {
         unsafe
         {
-            return new Command(NativeMethods.sp_command_cp437_data((ushort)x, (ushort)y, byteGrid.Into()));
+            return new Command(CommandNative.sp_command_cp437_data(x, y, byteGrid.Into()));
         }
     }
 
@@ -125,5 +125,5 @@ public sealed class Command : SpNativeInstance<BindGen.Command>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_command_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/Connection.cs

@@ -11,7 +11,7 @@ public sealed class Connection : SpNativeInstance<BindGen.Connection>
         {
             fixed (byte* bytePtr = Encoding.UTF8.GetBytes(host))
             {
-                return new Connection(NativeMethods.sp_connection_open(bytePtr));
+                return new Connection(ConnectionNative.sp_connection_open(bytePtr));
             }
         }
     }
@@ -20,7 +20,7 @@ public sealed class Connection : SpNativeInstance<BindGen.Connection>
     {
         unsafe
         {
-            return NativeMethods.sp_connection_send_packet(Instance, packet.Into());
+            return Instance->SendPacket(packet.Into());
         }
     }
 
@@ -28,11 +28,11 @@ public sealed class Connection : SpNativeInstance<BindGen.Connection>
     {
         unsafe
         {
-            return NativeMethods.sp_connection_send_command(Instance, command.Into());
+            return Instance->SendCommand(command.Into());
         }
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_connection_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 
     private unsafe Connection(BindGen.Connection* instance) : base(instance)
     {

crates/servicepoint_binding_cs/ServicePoint/Constants.cs

@@ -5,13 +5,13 @@ namespace ServicePoint;
 public static class Constants
 {
     /// size of a single tile in one dimension
-    public const nuint TileSize = NativeMethods.SP_TILE_SIZE;
+    public const nuint TileSize = ConstantsNative.SP_TILE_SIZE;
 
     /// tile count in the x-direction
-    public const nuint TileWidth = NativeMethods.SP_TILE_WIDTH;
+    public const nuint TileWidth = ConstantsNative.SP_TILE_WIDTH;
 
     /// tile count in the y-direction
-    public const nuint TileHeight = NativeMethods.SP_TILE_SIZE;
+    public const nuint TileHeight = ConstantsNative.SP_TILE_SIZE;
 
     /// screen width in pixels
     public const nuint PixelWidth = TileWidth * TileSize;

crates/servicepoint_binding_cs/ServicePoint/Cp437Grid.cs

@@ -5,21 +5,21 @@ namespace ServicePoint;
 
 public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
 {
-    public static Cp437Grid New(int width, int height)
+    public static Cp437Grid New(nuint width, nuint height)
     {
         unsafe
         {
-            return new Cp437Grid(NativeMethods.sp_cp437_grid_new((nuint)width, (nuint)height));
+            return new Cp437Grid(Cp437GridNative.sp_cp437_grid_new(width, height));
         }
     }
 
-    public static Cp437Grid Load(int width, int height, Span<byte> bytes)
+    public static Cp437Grid Load(nuint width, nuint height, Span<byte> bytes)
     {
         unsafe
         {
             fixed (byte* bytesPtr = bytes)
             {
-                return new Cp437Grid(NativeMethods.sp_cp437_grid_load((nuint)width, (nuint)height, bytesPtr,
+                return new Cp437Grid(Cp437GridNative.sp_cp437_grid_load(width, height, bytesPtr,
                     (nuint)bytes.Length));
             }
         }
@@ -29,38 +29,38 @@ public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
     {
         unsafe
         {
-            return new Cp437Grid(NativeMethods.sp_cp437_grid_clone(Instance));
+            return new Cp437Grid(Instance->Clone());
         }
     }
 
-    public byte this[int x, int y]
+    public byte this[nuint x, nuint y]
     {
         get
         {
             unsafe
             {
-                return NativeMethods.sp_cp437_grid_get(Instance, (nuint)x, (nuint)y);
+                return Instance->Get(x, y);
             }
         }
         set
         {
             unsafe
             {
-                NativeMethods.sp_cp437_grid_set(Instance, (nuint)x, (nuint)y, value);
+                Instance->Set(x, y, value);
             }
         }
     }
 
-    public string this[int y]
+    public string this[nuint y]
     {
         set
         {
             var width = Width;
-            ArgumentOutOfRangeException.ThrowIfGreaterThan(value.Length, width);
+            ArgumentOutOfRangeException.ThrowIfGreaterThan((nuint)value.Length, width);
 
-            var x = 0;
-            for (; x < value.Length; x++)
-                this[x, y] = (byte)value[x];
+            nuint x = 0;
+            for (; x < (nuint)value.Length; x++)
+                this[x, y] = (byte)value[(int)x];
 
             for (; x < width; x++)
                 this[x, y] = 0;
@@ -69,7 +69,7 @@ public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
         get
         {
             var sb = new StringBuilder();
-            for (int x = 0; x < Width; x++)
+            for (nuint x = 0; x < Width; x++)
             {
                 var val = this[x, y];
                 if (val == 0)
@@ -85,28 +85,28 @@ public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
     {
         unsafe
         {
-            NativeMethods.sp_cp437_grid_fill(Instance, value);
+            Instance->Fill(value);
         }
     }
 
-    public int Width
+    public nuint Width
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_cp437_grid_width(Instance);
+                return Instance->Width();
             }
         }
     }
 
-    public int Height
+    public nuint Height
     {
         get
         {
             unsafe
             {
-                return (int)NativeMethods.sp_cp437_grid_height(Instance);
+                return Instance->Height();
             }
         }
     }
@@ -117,8 +117,7 @@ public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
         {
             unsafe
             {
-                var slice = NativeMethods.sp_cp437_grid_unsafe_data_ref(Instance);
-                return new Span<byte>(slice.start, (int)slice.length);
+                return Instance->UnsafeDataRef().AsSpan();
             }
         }
     }
@@ -127,5 +126,5 @@ public sealed class Cp437Grid : SpNativeInstance<BindGen.Cp437Grid>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_cp437_grid_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/GlobalUsings.cs

@@ -1 +1 @@
-global using System;
+global using System;

crates/servicepoint_binding_cs/ServicePoint/Packet.cs

@@ -9,7 +9,7 @@ public sealed class Packet : SpNativeInstance<BindGen.Packet>
     {
         unsafe
         {
-            return new Packet(NativeMethods.sp_packet_from_command(command.Into()));
+            return new Packet(PacketNative.sp_packet_from_command(command.Into()));
         }
     }
 
@@ -19,7 +19,7 @@ public sealed class Packet : SpNativeInstance<BindGen.Packet>
         {
             fixed (byte* bytesPtr = bytes)
             {
-                var instance = NativeMethods.sp_packet_try_load(bytesPtr, (nuint)bytes.Length);
+                var instance = PacketNative.sp_packet_try_load(bytesPtr, (nuint)bytes.Length);
                 packet = instance == null
                     ? null
                     : new Packet(instance);
@@ -32,5 +32,5 @@ public sealed class Packet : SpNativeInstance<BindGen.Packet>
     {
     }
 
-    private protected override unsafe void Free() => NativeMethods.sp_packet_free(Instance);
+    private protected override unsafe void Free() => Instance->Free();
 }

crates/servicepoint_binding_cs/ServicePoint/ServicePoint.csproj

@@ -9,6 +9,11 @@
         <DisableFastUpToDateCheck>true</DisableFastUpToDateCheck>
     </PropertyGroup>
 
+    <PropertyGroup>
+        <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+    </PropertyGroup>
+
+
     <PropertyGroup>
         <PackageId>ServicePoint</PackageId>
         <Version>0.10.0</Version>
@@ -26,11 +31,11 @@
     </PropertyGroup>
 
     <!-- generate C# bindings -->
-    <Target Name="BuildBindings" Condition="'$(Configuration)'=='Release'" BeforeTargets="PrepareForBuild">
+    <Target Name="BuildBindingsRelease" Condition="'$(Configuration)'=='Release'" BeforeTargets="PrepareForBuild">
         <Exec Command="cargo build --release"/>
         <Exec Command="cargo build --manifest-path ../../../crates/servicepoint_binding_c/Cargo.toml --release"/>
     </Target>
-    <Target Name="BuildBindings" Condition="'$(Configuration)'=='Debug'" BeforeTargets="PrepareForBuild">
+    <Target Name="BuildBindingsDebug" Condition="'$(Configuration)'=='Debug'" BeforeTargets="PrepareForBuild">
         <Exec Command="cargo build"/>
         <Exec Command="cargo build --manifest-path ../../../crates/servicepoint_binding_c/Cargo.toml"/>
     </Target>
@@ -47,6 +52,11 @@
         </Content>
     </ItemGroup>
 
+    <!--additional csbindgen code generators-->
+    <ItemGroup>
+        <PackageReference Include="csbindgen" Version="1.9.3" PrivateAssets="All"/>
+    </ItemGroup>
+
     <ItemGroup>
         <!-- include link to source code at revision -->
         <None Include="../README.md" Pack="true" PackagePath="\"/>

crates/servicepoint_binding_cs/ServicePoint/ServicePointExtensions.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
+using ServicePoint.BindGen;
 
 namespace ServicePoint;
 
@@ -13,4 +14,9 @@ public static class ServicePointExtensions
     {
         return Command.TryFromPacket(packet, out command);
     }
+
+    public unsafe static Span<byte> AsSpan(this ByteSlice slice)
+    {
+        return new Span<byte>(slice.start, (int)slice.length);
+    }
 }

crates/servicepoint_binding_cs/build.rs

@@ -1,39 +1,48 @@
 //! Build script generating the C# code needed to call methods from the `servicepoint` C library.
 
-use std::fs;
+use std::{fs, path::Path};
+
+use convert_case::{Case, Casing};
 
 fn main() {
     println!("cargo::rerun-if-changed=../servicepoint_binding_c/src");
     println!("cargo::rerun-if-changed=build.rs");
 
-    let mut builder = csbindgen::Builder::default();
-
-    let mut paths = fs::read_dir("../servicepoint_binding_c/src").unwrap()
+    let mut paths = fs::read_dir("../servicepoint_binding_c/src")
+        .unwrap()
         .map(|x| x.unwrap().path())
         .collect::<Vec<_>>();
     paths.sort();
 
-    for path in paths {
+    for path in &paths {
         println!("cargo:rerun-if-changed={}", path.display());
-        builder = builder.input_extern_file(path);
+        let file: &str = Path::new(path).file_stem().unwrap().to_str().unwrap();
+        if file == "lib"{
+            continue;
+        }
+
+        let class = file.to_case(Case::UpperCamel) + "Native";
+        csbindgen::Builder::default()
+            .input_extern_file(path)
+            .csharp_class_name(&class)
+            .csharp_dll_name("servicepoint_binding_c")
+            .csharp_namespace("ServicePoint.BindGen")
+            .csharp_use_nint_types(true)
+            .csharp_class_accessibility("public")
+            .csharp_generate_const_filter(|_| true)
+            .always_included_types(["SPByteSlice", "SPCompressionCode"])
+            .csharp_type_rename(move |name| {
+                if name.len() > 2
+                    && name.starts_with("SP")
+                    && name.chars().nth(2).unwrap().is_uppercase()
+                {
+                    name[2..].to_string()
+                } else {
+                    name
+                }
+            })
+            .generate_csharp_file(format!("ServicePoint/BindGen/{}.g.cs", &class))
+            .unwrap();
     }
 
-    builder
-        .csharp_dll_name("servicepoint_binding_c")
-        .csharp_namespace("ServicePoint.BindGen")
-        .csharp_use_nint_types(true)
-        .csharp_class_accessibility("public")
-        .csharp_generate_const_filter(|_| true)
-        .csharp_type_rename(move |name| {
-            if name.len() > 2
-                && name.starts_with("SP")
-                && name.chars().nth(2).unwrap().is_uppercase()
-            {
-                name[2..].to_string()
-            } else {
-                name
-            }
-        })
-        .generate_csharp_file("ServicePoint/BindGen/ServicePoint.g.cs")
-        .unwrap();
 }

crates/servicepoint_binding_cs/examples/lang_cs/Program.cs

@@ -8,11 +8,11 @@ connection.Send(Command.Brightness(128).IntoPacket());
 
 using var pixels = Bitmap.New(Constants.PixelWidth, Constants.PixelHeight);
 
-for (var offset = 0; offset < int.MaxValue; offset++)
+for (nuint offset = 0; offset < nuint.MaxValue; offset++)
 {
     pixels.Fill(false);
 
-    for (var y = 0; y < pixels.Height; y++)
+    for (nuint y = 0; y < pixels.Height; y++)
         pixels[(y + offset) % Constants.PixelWidth, y] = true;
 
     connection.Send(Command.BitmapLinearWin(0, 0, pixels.Clone(), CompressionCode.Lzma).IntoPacket());