diff --git a/crates/servicepoint_binding_c/src/bitvec.rs b/crates/servicepoint_binding_c/src/bit_vec.rs similarity index 100% rename from crates/servicepoint_binding_c/src/bitvec.rs rename to crates/servicepoint_binding_c/src/bit_vec.rs diff --git a/crates/servicepoint_binding_c/src/lib.rs b/crates/servicepoint_binding_c/src/lib.rs index 0e0ddd0..2c9006d 100644 --- a/crates/servicepoint_binding_c/src/lib.rs +++ b/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; diff --git a/crates/servicepoint_binding_cs/Cargo.toml b/crates/servicepoint_binding_cs/Cargo.toml index caca7b9..ffceefd 100644 --- a/crates/servicepoint_binding_cs/Cargo.toml +++ b/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" } diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitVecNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitVecNative.g.cs new file mode 100644 index 0000000..9728486 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitVecNative.g.cs @@ -0,0 +1,247 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitVec* sp_bitvec_new(nuint size); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitVec* sp_bitvec_load(byte* data, nuint data_length); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitVec* sp_bitvec_clone(SPBitVec* bit_vec); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitvec_free(SPBitVec* bit_vec); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + [return: MarshalAs(UnmanagedType.U1)] + public static extern bool sp_bitvec_get(SPBitVec* bit_vec, nuint index); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitvec_set(SPBitVec* bit_vec, nuint index, [MarshalAs(UnmanagedType.U1)] bool value); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitvec_fill(SPBitVec* bit_vec, [MarshalAs(UnmanagedType.U1)] bool value); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_len", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_bitvec_len(SPBitVec* bit_vec); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_is_empty", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + [return: MarshalAs(UnmanagedType.U1)] + public static extern bool sp_bitvec_is_empty(SPBitVec* bit_vec); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitvec_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPByteSlice sp_bitvec_unsafe_data_ref(SPBitVec* bit_vec); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPBitVec + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitmapNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitmapNative.g.cs new file mode 100644 index 0000000..6a23f1a --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BitmapNative.g.cs @@ -0,0 +1,249 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitmap* sp_bitmap_new(nuint width, nuint height); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitmap* sp_bitmap_load(nuint width, nuint height, byte* data, nuint data_length); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBitmap* sp_bitmap_clone(SPBitmap* bitmap); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitmap_free(SPBitmap* bitmap); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + [return: MarshalAs(UnmanagedType.U1)] + public static extern bool sp_bitmap_get(SPBitmap* bitmap, nuint x, nuint y); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitmap_set(SPBitmap* bitmap, nuint x, nuint y, [MarshalAs(UnmanagedType.U1)] bool value); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_bitmap_fill(SPBitmap* bitmap, [MarshalAs(UnmanagedType.U1)] bool value); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_bitmap_width(SPBitmap* bitmap); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_bitmap_height(SPBitmap* bitmap); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_bitmap_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPByteSlice sp_bitmap_unsafe_data_ref(SPBitmap* bitmap); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPBitmap + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/BrightnessGridNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BrightnessGridNative.g.cs new file mode 100644 index 0000000..9b8e942 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/BrightnessGridNative.g.cs @@ -0,0 +1,259 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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; + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBrightnessGrid* sp_brightness_grid_new(nuint width, nuint height); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBrightnessGrid* sp_brightness_grid_load(nuint width, nuint height, byte* data, nuint data_length); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPBrightnessGrid* sp_brightness_grid_clone(SPBrightnessGrid* brightness_grid); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_brightness_grid_free(SPBrightnessGrid* brightness_grid); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern byte sp_brightness_grid_get(SPBrightnessGrid* brightness_grid, nuint x, nuint y); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_brightness_grid_set(SPBrightnessGrid* brightness_grid, nuint x, nuint y, byte value); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_brightness_grid_fill(SPBrightnessGrid* brightness_grid, byte value); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_brightness_grid_width(SPBrightnessGrid* brightness_grid); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_brightness_grid_height(SPBrightnessGrid* brightness_grid); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_brightness_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPByteSlice sp_brightness_grid_unsafe_data_ref(SPBrightnessGrid* brightness_grid); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPBrightnessGrid + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/ByteSliceNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ByteSliceNative.g.cs new file mode 100644 index 0000000..76bcc6f --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ByteSliceNative.g.cs @@ -0,0 +1,24 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#pragma warning disable CS8500 +#pragma warning disable CS8981 +using System; +using System.Runtime.InteropServices; + + +namespace ServicePoint.BindGen +{ + + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPByteSlice + { + public byte* start; + public nuint length; + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/CommandNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/CommandNative.g.cs new file mode 100644 index 0000000..4227659 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/CommandNative.g.cs @@ -0,0 +1,364 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_try_from_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_try_from_packet(SPPacket* packet); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_clone(SPCommand* command); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_clear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_clear(); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_hard_reset", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_hard_reset(); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_fade_out", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_fade_out(); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_brightness(byte brightness); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_char_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_char_brightness(nuint x, nuint y, SPBrightnessGrid* grid); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_bitmap_linear(nuint offset, SPBitVec* bit_vec, SPCompressionCode compression); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_and", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_bitmap_linear_and(nuint offset, SPBitVec* bit_vec, SPCompressionCode compression); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_or", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_bitmap_linear_or(nuint offset, SPBitVec* bit_vec, SPCompressionCode compression); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_xor", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_bitmap_linear_xor(nuint offset, SPBitVec* bit_vec, SPCompressionCode compression); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_cp437_data", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_cp437_data(nuint x, nuint y, SPCp437Grid* grid); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_win", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCommand* sp_command_bitmap_linear_win(nuint x, nuint y, SPBitmap* bitmap, SPCompressionCode compression_code); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_command_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_command_free(SPCommand* command); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPCommand + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConnectionNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConnectionNative.g.cs new file mode 100644 index 0000000..e4cdc1f --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConnectionNative.g.cs @@ -0,0 +1,113 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_connection_open", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPConnection* sp_connection_open(byte* host); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_connection_send_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + [return: MarshalAs(UnmanagedType.U1)] + public static extern bool sp_connection_send_packet(SPConnection* connection, SPPacket* packet); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_connection_send_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + [return: MarshalAs(UnmanagedType.U1)] + public static extern bool sp_connection_send_command(SPConnection* connection, SPCommand* command); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_connection_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_connection_free(SPConnection* connection); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPConnection + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConstantsNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConstantsNative.g.cs new file mode 100644 index 0000000..f4b50fb --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ConstantsNative.g.cs @@ -0,0 +1,36 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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 SPCompressionCode : ushort + { + Uncompressed = 0, + Zlib = 26490, + Bzip2 = 25210, + Lzma = 27770, + Zstd = 31347, + } + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/Cp437GridNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/Cp437GridNative.g.cs new file mode 100644 index 0000000..b654544 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/Cp437GridNative.g.cs @@ -0,0 +1,236 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCp437Grid* sp_cp437_grid_new(nuint width, nuint height); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCp437Grid* sp_cp437_grid_load(nuint width, nuint height, byte* data, nuint data_length); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPCp437Grid* sp_cp437_grid_clone(SPCp437Grid* cp437_grid); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_cp437_grid_free(SPCp437Grid* cp437_grid); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern byte sp_cp437_grid_get(SPCp437Grid* cp437_grid, nuint x, nuint y); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_cp437_grid_set(SPCp437Grid* cp437_grid, nuint x, nuint y, byte value); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_cp437_grid_fill(SPCp437Grid* cp437_grid, byte value); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_cp437_grid_width(SPCp437Grid* cp437_grid); + + /// + /// 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] + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern nuint sp_cp437_grid_height(SPCp437Grid* cp437_grid); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_cp437_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPByteSlice sp_cp437_grid_unsafe_data_ref(SPCp437Grid* cp437_grid); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPCp437Grid + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/LibNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/LibNative.g.cs new file mode 100644 index 0000000..f385863 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/LibNative.g.cs @@ -0,0 +1,17 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#pragma warning disable CS8500 +#pragma warning disable CS8981 +using System; +using System.Runtime.InteropServices; + + +namespace ServicePoint.BindGen +{ + + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/PacketNative.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/PacketNative.g.cs new file mode 100644 index 0000000..6e639e8 --- /dev/null +++ b/crates/servicepoint_binding_cs/ServicePoint/BindGen/PacketNative.g.cs @@ -0,0 +1,110 @@ +// +// This code is generated by csbindgen. +// DON'T CHANGE THIS DIRECTLY. +// +#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"; + + + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_packet_from_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPPacket* sp_packet_from_command(SPCommand* command); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_packet_try_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPPacket* sp_packet_try_load(byte* data, nuint length); + + /// + /// 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`. + /// + [DllImport(__DllName, EntryPoint = "sp_packet_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern SPPacket* sp_packet_clone(SPPacket* packet); + + /// + /// 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 + /// + [DllImport(__DllName, EntryPoint = "sp_packet_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] + public static extern void sp_packet_free(SPPacket* packet); + + + } + + [StructLayout(LayoutKind.Sequential)] + public unsafe partial struct SPPacket + { + } + + + +} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BindGen/ServicePoint.g.cs b/crates/servicepoint_binding_cs/ServicePoint/BindGen/ServicePoint.g.cs deleted file mode 100644 index c8bb0a2..0000000 --- a/crates/servicepoint_binding_cs/ServicePoint/BindGen/ServicePoint.g.cs +++ /dev/null @@ -1,1453 +0,0 @@ -// -// This code is generated by csbindgen. -// DON'T CHANGE THIS DIRECTLY. -// -#pragma warning disable CS8500 -#pragma warning disable CS8981 -using System; -using System.Runtime.InteropServices; - - -namespace ServicePoint.BindGen -{ - public static unsafe partial class NativeMethods - { - 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; - public const nuint SP_TILE_SIZE = 8; - public const nuint SP_TILE_WIDTH = 56; - public const nuint SP_TILE_HEIGHT = 20; - - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Bitmap* sp_bitmap_new(nuint width, nuint height); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Bitmap* sp_bitmap_clone(Bitmap* bitmap); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_bitmap_free(Bitmap* bitmap); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_bitmap_width(Bitmap* bitmap); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_bitmap_height(Bitmap* bitmap); - - /// - /// 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 - /// - [DllImport(__DllName, EntryPoint = "sp_bitmap_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern ByteSlice sp_bitmap_unsafe_data_ref(Bitmap* bitmap); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_bitvec_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern BitVec* sp_bitvec_new(nuint size); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_bitvec_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern BitVec* sp_bitvec_load(byte* data, nuint data_length); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_bitvec_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern BitVec* sp_bitvec_clone(BitVec* bit_vec); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_bitvec_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_bitvec_free(BitVec* bit_vec); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_bitvec_len", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_bitvec_len(BitVec* bit_vec); - - /// - /// 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] - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_brightness_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern BrightnessGrid* sp_brightness_grid_new(nuint width, nuint height); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_brightness_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern BrightnessGrid* sp_brightness_grid_clone(BrightnessGrid* brightness_grid); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_brightness_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_brightness_grid_free(BrightnessGrid* brightness_grid); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_brightness_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_brightness_grid_width(BrightnessGrid* brightness_grid); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_brightness_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_brightness_grid_height(BrightnessGrid* brightness_grid); - - /// - /// 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 - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_try_from_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_try_from_packet(Packet* packet); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_clone(Command* command); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_clear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_clear(); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_hard_reset", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_hard_reset(); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_fade_out", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_fade_out(); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_command_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Command* sp_command_brightness(byte brightness); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [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); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_command_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_command_free(Command* command); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_connection_open", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Connection* sp_connection_open(byte* host); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [DllImport(__DllName, EntryPoint = "sp_connection_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_connection_free(Connection* connection); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_cp437_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Cp437Grid* sp_cp437_grid_new(nuint width, nuint height); - - /// - /// 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`. - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_cp437_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Cp437Grid* sp_cp437_grid_clone(Cp437Grid* cp437_grid); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_cp437_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern void sp_cp437_grid_free(Cp437Grid* cp437_grid); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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 - /// - [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); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_cp437_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_cp437_grid_width(Cp437Grid* cp437_grid); - - /// - /// 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] - /// - [DllImport(__DllName, EntryPoint = "sp_cp437_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern nuint sp_cp437_grid_height(Cp437Grid* cp437_grid); - - /// - /// 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 - /// - [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); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_packet_from_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Packet* sp_packet_from_command(Command* command); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_packet_try_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Packet* sp_packet_try_load(byte* data, nuint length); - - /// - /// 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`. - /// - [DllImport(__DllName, EntryPoint = "sp_packet_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)] - public static extern Packet* sp_packet_clone(Packet* packet); - - /// - /// 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 - /// - [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 Bitmap - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct BitVec - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct BrightnessGrid - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct ByteSlice - { - public byte* start; - public nuint length; - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct Command - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct Connection - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct Cp437Grid - { - } - - [StructLayout(LayoutKind.Sequential)] - public unsafe partial struct Packet - { - } - - - public enum CompressionCode : ushort - { - Uncompressed = 0, - Zlib = 26490, - Bzip2 = 25210, - Lzma = 27770, - Zstd = 31347, - } - - -} diff --git a/crates/servicepoint_binding_cs/ServicePoint/BitVec.cs b/crates/servicepoint_binding_cs/ServicePoint/BitVec.cs index 158b1a9..48d7ab4 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/BitVec.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/BitVec.cs @@ -2,13 +2,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class BitVec : SpNativeInstance +public sealed class BitVec : SpNativeInstance { public static BitVec New(nuint size) { unsafe { - return new BitVec(NativeMethods.sp_bitvec_new(size)); + return new BitVec(BitVecNative.sp_bitvec_new(size)); } } @@ -18,7 +18,7 @@ public sealed class BitVec : SpNativeInstance { 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,7 +27,7 @@ public sealed class BitVec : SpNativeInstance { unsafe { - return new BitVec(NativeMethods.sp_bitvec_clone(Instance)); + return new BitVec(BitVecNative.sp_bitvec_clone(Instance)); } } @@ -37,14 +37,14 @@ public sealed class BitVec : SpNativeInstance { unsafe { - return NativeMethods.sp_bitvec_get(Instance, index); + return BitVecNative.sp_bitvec_get(Instance, index); } } set { unsafe { - NativeMethods.sp_bitvec_set(Instance, index, value); + BitVecNative.sp_bitvec_set(Instance, index, value); } } } @@ -53,7 +53,7 @@ public sealed class BitVec : SpNativeInstance { unsafe { - NativeMethods.sp_bitvec_fill(Instance, value); + BitVecNative.sp_bitvec_fill(Instance, value); } } @@ -63,7 +63,7 @@ public sealed class BitVec : SpNativeInstance { unsafe { - return NativeMethods.sp_bitvec_len(Instance); + return BitVecNative.sp_bitvec_len(Instance); } } } @@ -74,15 +74,15 @@ public sealed class BitVec : SpNativeInstance { unsafe { - var slice = NativeMethods.sp_bitvec_unsafe_data_ref(Instance); + var slice = BitVecNative.sp_bitvec_unsafe_data_ref(Instance); return new Span(slice.start, (int)slice.length); } } } - private unsafe BitVec(BindGen.BitVec* instance) : base(instance) + private unsafe BitVec(SPBitVec* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_bitvec_free(Instance); + private protected override unsafe void Free() => BitVecNative.sp_bitvec_free(Instance); } diff --git a/crates/servicepoint_binding_cs/ServicePoint/Bitmap.cs b/crates/servicepoint_binding_cs/ServicePoint/Bitmap.cs index cbef9d1..f81b542 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Bitmap.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/Bitmap.cs @@ -2,13 +2,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class Bitmap : SpNativeInstance +public sealed class Bitmap : SpNativeInstance { public static Bitmap New(nuint width, nuint height) { unsafe { - return new Bitmap(NativeMethods.sp_bitmap_new(width, height)); + return new Bitmap(BitmapNative.sp_bitmap_new(width, height)); } } @@ -18,7 +18,7 @@ public sealed class Bitmap : SpNativeInstance { fixed (byte* bytesPtr = bytes) { - return new Bitmap(NativeMethods.sp_bitmap_load(width, height, bytesPtr, + return new Bitmap(BitmapNative.sp_bitmap_load(width, height, bytesPtr, (nuint)bytes.Length)); } } @@ -28,7 +28,7 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - return new Bitmap(NativeMethods.sp_bitmap_clone(Instance)); + return new Bitmap(BitmapNative.sp_bitmap_clone(Instance)); } } @@ -38,14 +38,14 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - return NativeMethods.sp_bitmap_get(Instance, x, y); + return BitmapNative.sp_bitmap_get(Instance, x, y); } } set { unsafe { - NativeMethods.sp_bitmap_set(Instance, x, y, value); + BitmapNative.sp_bitmap_set(Instance, x, y, value); } } } @@ -54,7 +54,7 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - NativeMethods.sp_bitmap_fill(Instance, value); + BitmapNative.sp_bitmap_fill(Instance, value); } } @@ -64,7 +64,7 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - return NativeMethods.sp_bitmap_width(Instance); + return BitmapNative.sp_bitmap_width(Instance); } } } @@ -75,7 +75,7 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - return NativeMethods.sp_bitmap_height(Instance); + return BitmapNative.sp_bitmap_height(Instance); } } } @@ -86,15 +86,15 @@ public sealed class Bitmap : SpNativeInstance { unsafe { - var slice = NativeMethods.sp_bitmap_unsafe_data_ref(Instance); + var slice = BitmapNative.sp_bitmap_unsafe_data_ref(Instance); return new Span(slice.start, (int)slice.length); } } } - private unsafe Bitmap(BindGen.Bitmap* instance) : base(instance) + private unsafe Bitmap(SPBitmap* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_bitmap_free(Instance); + private protected override unsafe void Free() => BitmapNative.sp_bitmap_free(Instance); } diff --git a/crates/servicepoint_binding_cs/ServicePoint/BrightnessGrid.cs b/crates/servicepoint_binding_cs/ServicePoint/BrightnessGrid.cs index f2a3262..e1931c7 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/BrightnessGrid.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/BrightnessGrid.cs @@ -2,13 +2,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class BrightnessGrid : SpNativeInstance +public sealed class BrightnessGrid : SpNativeInstance { public static BrightnessGrid New(nuint width, nuint height) { unsafe { - return new BrightnessGrid(NativeMethods.sp_brightness_grid_new(width, height)); + return new BrightnessGrid(BrightnessGridNative.sp_brightness_grid_new(width, height)); } } @@ -18,7 +18,7 @@ public sealed class BrightnessGrid : SpNativeInstance { fixed (byte* bytesPtr = bytes) { - return new BrightnessGrid(NativeMethods.sp_brightness_grid_load(width, height, bytesPtr, + return new BrightnessGrid(BrightnessGridNative.sp_brightness_grid_load(width, height, bytesPtr, (nuint)bytes.Length)); } } @@ -28,7 +28,7 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - return new BrightnessGrid(NativeMethods.sp_brightness_grid_clone(Instance)); + return new BrightnessGrid(BrightnessGridNative.sp_brightness_grid_clone(Instance)); } } @@ -38,14 +38,14 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - return NativeMethods.sp_brightness_grid_get(Instance, x, y); + return BrightnessGridNative.sp_brightness_grid_get(Instance, x, y); } } set { unsafe { - NativeMethods.sp_brightness_grid_set(Instance, x, y, value); + BrightnessGridNative.sp_brightness_grid_set(Instance, x, y, value); } } } @@ -54,7 +54,7 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - NativeMethods.sp_brightness_grid_fill(Instance, value); + BrightnessGridNative.sp_brightness_grid_fill(Instance, value); } } @@ -64,7 +64,7 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - return NativeMethods.sp_brightness_grid_width(Instance); + return BrightnessGridNative.sp_brightness_grid_width(Instance); } } } @@ -75,7 +75,7 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - return NativeMethods.sp_brightness_grid_height(Instance); + return BrightnessGridNative.sp_brightness_grid_height(Instance); } } } @@ -86,15 +86,15 @@ public sealed class BrightnessGrid : SpNativeInstance { unsafe { - var slice = NativeMethods.sp_brightness_grid_unsafe_data_ref(Instance); + var slice = BrightnessGridNative.sp_brightness_grid_unsafe_data_ref(Instance); return new Span(slice.start, (int)slice.length); } } } - private unsafe BrightnessGrid(BindGen.BrightnessGrid* instance) : base(instance) + private unsafe BrightnessGrid(SPBrightnessGrid* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_brightness_grid_free(Instance); + private protected override unsafe void Free() => BrightnessGridNative.sp_brightness_grid_free(Instance); } diff --git a/crates/servicepoint_binding_cs/ServicePoint/Command.cs b/crates/servicepoint_binding_cs/ServicePoint/Command.cs index cf770cb..dd4ccc1 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Command.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/Command.cs @@ -3,13 +3,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class Command : SpNativeInstance +public sealed class Command : SpNativeInstance { public static bool TryFromPacket(Packet packet, [MaybeNullWhen(false)] out Command 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 { unsafe { - return new Command(NativeMethods.sp_command_clone(Instance)); + return new Command(CommandNative.sp_command_clone(Instance)); } } @@ -33,7 +33,7 @@ public sealed class Command : SpNativeInstance { unsafe { - return new Command(NativeMethods.sp_command_clear()); + return new Command(CommandNative.sp_command_clear()); } } @@ -41,7 +41,7 @@ public sealed class Command : SpNativeInstance { 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 { unsafe { - return new Command(NativeMethods.sp_command_fade_out()); + return new Command(CommandNative.sp_command_fade_out()); } } @@ -57,7 +57,7 @@ public sealed class Command : SpNativeInstance { unsafe { - return new Command(NativeMethods.sp_command_brightness(brightness)); + return new Command(CommandNative.sp_command_brightness(brightness)); } } @@ -65,7 +65,7 @@ public sealed class Command : SpNativeInstance { unsafe { - return new Command(NativeMethods.sp_command_char_brightness(x, y, grid.Into())); + return new Command(CommandNative.sp_command_char_brightness(x, y, grid.Into())); } } @@ -74,7 +74,7 @@ public sealed class Command : SpNativeInstance unsafe { return new Command( - NativeMethods.sp_command_bitmap_linear(offset, bitVec.Into(), compressionCode)); + CommandNative.sp_command_bitmap_linear(offset, bitVec.Into(), compressionCode)); } } @@ -83,7 +83,7 @@ public sealed class Command : SpNativeInstance unsafe { return new Command( - NativeMethods.sp_command_bitmap_linear_and(offset, bitVec.Into(), compressionCode)); + CommandNative.sp_command_bitmap_linear_and(offset, bitVec.Into(), compressionCode)); } } @@ -92,7 +92,7 @@ public sealed class Command : SpNativeInstance unsafe { return new Command( - NativeMethods.sp_command_bitmap_linear_or(offset, bitVec.Into(), compressionCode)); + CommandNative.sp_command_bitmap_linear_or(offset, bitVec.Into(), compressionCode)); } } @@ -101,7 +101,7 @@ public sealed class Command : SpNativeInstance unsafe { return new Command( - NativeMethods.sp_command_bitmap_linear_xor(offset, bitVec.Into(), compressionCode)); + CommandNative.sp_command_bitmap_linear_xor(offset, bitVec.Into(), compressionCode)); } } @@ -109,7 +109,7 @@ public sealed class Command : SpNativeInstance { unsafe { - return new Command(NativeMethods.sp_command_bitmap_linear_win(x, y, bitmap.Into(), compression)); + return new Command(CommandNative.sp_command_bitmap_linear_win(x, y, bitmap.Into(), compression)); } } @@ -117,13 +117,13 @@ public sealed class Command : SpNativeInstance { unsafe { - return new Command(NativeMethods.sp_command_cp437_data(x, y, byteGrid.Into())); + return new Command(CommandNative.sp_command_cp437_data(x, y, byteGrid.Into())); } } - private unsafe Command(BindGen.Command* instance) : base(instance) + private unsafe Command(SPCommand* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_command_free(Instance); + private protected override unsafe void Free() => CommandNative.sp_command_free(Instance); } diff --git a/crates/servicepoint_binding_cs/ServicePoint/Connection.cs b/crates/servicepoint_binding_cs/ServicePoint/Connection.cs index eff3b32..2eb4c60 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Connection.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/Connection.cs @@ -3,7 +3,7 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class Connection : SpNativeInstance +public sealed class Connection : SpNativeInstance { public static Connection Open(string host) { @@ -11,7 +11,7 @@ public sealed class Connection : SpNativeInstance { 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 { unsafe { - return NativeMethods.sp_connection_send_packet(Instance, packet.Into()); + return ConnectionNative.sp_connection_send_packet(Instance, packet.Into()); } } @@ -28,13 +28,13 @@ public sealed class Connection : SpNativeInstance { unsafe { - return NativeMethods.sp_connection_send_command(Instance, command.Into()); + return ConnectionNative.sp_connection_send_command(Instance, command.Into()); } } - private protected override unsafe void Free() => NativeMethods.sp_connection_free(Instance); + private protected override unsafe void Free() => ConnectionNative.sp_connection_free(Instance); - private unsafe Connection(BindGen.Connection* instance) : base(instance) + private unsafe Connection(SPConnection* instance) : base(instance) { } } diff --git a/crates/servicepoint_binding_cs/ServicePoint/Constants.cs b/crates/servicepoint_binding_cs/ServicePoint/Constants.cs index 14ea940..b0f0f06 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Constants.cs +++ b/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; diff --git a/crates/servicepoint_binding_cs/ServicePoint/Cp437Grid.cs b/crates/servicepoint_binding_cs/ServicePoint/Cp437Grid.cs index 905828b..4193c03 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Cp437Grid.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/Cp437Grid.cs @@ -3,13 +3,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class Cp437Grid : SpNativeInstance +public sealed class Cp437Grid : SpNativeInstance { public static Cp437Grid New(int width, int height) { unsafe { - return new Cp437Grid(NativeMethods.sp_cp437_grid_new((nuint)width, (nuint)height)); + return new Cp437Grid(Cp437GridNative.sp_cp437_grid_new((nuint)width, (nuint)height)); } } @@ -19,7 +19,7 @@ public sealed class Cp437Grid : SpNativeInstance { 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((nuint)width, (nuint)height, bytesPtr, (nuint)bytes.Length)); } } @@ -29,7 +29,7 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - return new Cp437Grid(NativeMethods.sp_cp437_grid_clone(Instance)); + return new Cp437Grid(Cp437GridNative.sp_cp437_grid_clone(Instance)); } } @@ -39,14 +39,14 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - return NativeMethods.sp_cp437_grid_get(Instance, (nuint)x, (nuint)y); + return Cp437GridNative.sp_cp437_grid_get(Instance, (nuint)x, (nuint)y); } } set { unsafe { - NativeMethods.sp_cp437_grid_set(Instance, (nuint)x, (nuint)y, value); + Cp437GridNative.sp_cp437_grid_set(Instance, (nuint)x, (nuint)y, value); } } } @@ -85,7 +85,7 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - NativeMethods.sp_cp437_grid_fill(Instance, value); + Cp437GridNative.sp_cp437_grid_fill(Instance, value); } } @@ -95,7 +95,7 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - return (int)NativeMethods.sp_cp437_grid_width(Instance); + return (int)Cp437GridNative.sp_cp437_grid_width(Instance); } } } @@ -106,7 +106,7 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - return (int)NativeMethods.sp_cp437_grid_height(Instance); + return (int)Cp437GridNative.sp_cp437_grid_height(Instance); } } } @@ -117,15 +117,15 @@ public sealed class Cp437Grid : SpNativeInstance { unsafe { - var slice = NativeMethods.sp_cp437_grid_unsafe_data_ref(Instance); + var slice = Cp437GridNative.sp_cp437_grid_unsafe_data_ref(Instance); return new Span(slice.start, (int)slice.length); } } } - private unsafe Cp437Grid(BindGen.Cp437Grid* instance) : base(instance) + private unsafe Cp437Grid(SPCp437Grid* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_cp437_grid_free(Instance); + private protected override unsafe void Free() => Cp437GridNative.sp_cp437_grid_free(Instance); } diff --git a/crates/servicepoint_binding_cs/ServicePoint/GlobalUsings.cs b/crates/servicepoint_binding_cs/ServicePoint/GlobalUsings.cs index 911a584..3c8a504 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/GlobalUsings.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/GlobalUsings.cs @@ -1 +1,2 @@ -global using System; \ No newline at end of file +global using System; +global using CompressionCode = ServicePoint.BindGen.SPCompressionCode; diff --git a/crates/servicepoint_binding_cs/ServicePoint/Packet.cs b/crates/servicepoint_binding_cs/ServicePoint/Packet.cs index 24c2c18..55569b8 100644 --- a/crates/servicepoint_binding_cs/ServicePoint/Packet.cs +++ b/crates/servicepoint_binding_cs/ServicePoint/Packet.cs @@ -3,13 +3,13 @@ using ServicePoint.BindGen; namespace ServicePoint; -public sealed class Packet : SpNativeInstance +public sealed class Packet : SpNativeInstance { public static Packet FromCommand(Command command) { 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 { 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); @@ -28,9 +28,9 @@ public sealed class Packet : SpNativeInstance } } - private unsafe Packet(BindGen.Packet* instance) : base(instance) + private unsafe Packet(SPPacket* instance) : base(instance) { } - private protected override unsafe void Free() => NativeMethods.sp_packet_free(Instance); + private protected override unsafe void Free() => PacketNative.sp_packet_free(Instance); } diff --git a/crates/servicepoint_binding_cs/build.rs b/crates/servicepoint_binding_cs/build.rs index 8caf589..4ea4337 100644 --- a/crates/servicepoint_binding_cs/build.rs +++ b/crates/servicepoint_binding_cs/build.rs @@ -1,39 +1,34 @@ //! 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::>(); paths.sort(); - for path in paths { + for path in &paths { println!("cargo:rerun-if-changed={}", path.display()); - builder = builder.input_extern_file(path); + let class = Path::new(path).file_stem().unwrap().to_str().unwrap(); + let class = class.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"]) + .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(); } diff --git a/crates/servicepoint_binding_cs/examples/lang_cs/Program.cs b/crates/servicepoint_binding_cs/examples/lang_cs/Program.cs index a1ff7fe..cdccc93 100644 --- a/crates/servicepoint_binding_cs/examples/lang_cs/Program.cs +++ b/crates/servicepoint_binding_cs/examples/lang_cs/Program.cs @@ -1,5 +1,6 @@ using ServicePoint; -using CompressionCode = ServicePoint.BindGen.CompressionCode; + +using CompressionCode = ServicePoint.BindGen.SPCompressionCode; using var connection = Connection.Open("127.0.0.1:2342");