292 lines
6.9 KiB
Rust
292 lines
6.9 KiB
Rust
//! C functions for interacting with [SPBitmap]s
|
|
//!
|
|
//! prefix `sp_bitmap_`
|
|
//!
|
|
//! A grid of pixels.
|
|
//!
|
|
//! # Examples
|
|
//!
|
|
//! ```C
|
|
//! Cp437Grid grid = sp_bitmap_new(8, 3);
|
|
//! sp_bitmap_fill(grid, true);
|
|
//! sp_bitmap_set(grid, 0, 0, false);
|
|
//! sp_bitmap_free(grid);
|
|
//! ```
|
|
|
|
use servicepoint::{Bitmap, DataRef, Grid};
|
|
use std::ptr::NonNull;
|
|
|
|
use crate::byte_slice::SPByteSlice;
|
|
|
|
/// 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, or NULL in case of an error.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// In the following cases, this function will return NULL:
|
|
///
|
|
/// - 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`.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_new(
|
|
width: usize,
|
|
height: usize,
|
|
) -> *mut Bitmap {
|
|
if let Some(bitmap) = Bitmap::new(width, height) {
|
|
Box::leak(Box::new(bitmap))
|
|
} else {
|
|
std::ptr::null_mut()
|
|
}
|
|
}
|
|
|
|
/// Creates a new [SPBitmap] with a size matching the screen.
|
|
///
|
|
/// returns: [SPBitmap] initialized to all pixels off. 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_bitmap_free].
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_new_screen_sized() -> NonNull<Bitmap> {
|
|
let result = Box::new(Bitmap::max_sized());
|
|
NonNull::from(Box::leak(result))
|
|
}
|
|
|
|
/// 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, or NULL in case of an error.
|
|
///
|
|
/// # Errors
|
|
///
|
|
/// In the following cases, this function will return NULL:
|
|
///
|
|
/// - when the dimensions and data size do not match exactly.
|
|
/// - when the width is not dividable by 8
|
|
///
|
|
/// # 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_bitmap_free`.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_load(
|
|
width: usize,
|
|
height: usize,
|
|
data: SPByteSlice,
|
|
) -> *mut Bitmap {
|
|
let data = unsafe { data.as_slice() };
|
|
if let Ok(bitmap) = Bitmap::load(width, height, data) {
|
|
Box::leak(Box::new(bitmap))
|
|
} else {
|
|
std::ptr::null_mut()
|
|
}
|
|
}
|
|
|
|
/// 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`.
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_clone(
|
|
bitmap: NonNull<Bitmap>,
|
|
) -> NonNull<Bitmap> {
|
|
let result = Box::new(unsafe { bitmap.as_ref().clone() });
|
|
NonNull::from(Box::leak(result))
|
|
}
|
|
|
|
/// Deallocates a [SPBitmap].
|
|
///
|
|
/// # Panics
|
|
///
|
|
/// - when `bitmap` is NULL
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// The caller has to make sure that:
|
|
///
|
|
/// - `bitmap` points to a valid [SPBitmap]
|
|
///
|
|
/// [SPCommand]: [crate::SPCommand]
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_free(bitmap: NonNull<Bitmap>) {
|
|
_ = unsafe { Box::from_raw(bitmap.as_ptr()) };
|
|
}
|
|
|
|
/// 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
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_get(
|
|
bitmap: NonNull<Bitmap>,
|
|
x: usize,
|
|
y: usize,
|
|
) -> bool {
|
|
unsafe { bitmap.as_ref().get(x, 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
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_set(
|
|
bitmap: NonNull<Bitmap>,
|
|
x: usize,
|
|
y: usize,
|
|
value: bool,
|
|
) {
|
|
unsafe { (*bitmap.as_ptr()).set(x, y, 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
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_fill(bitmap: NonNull<Bitmap>, value: bool) {
|
|
unsafe { (*bitmap.as_ptr()).fill(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]
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_width(bitmap: NonNull<Bitmap>) -> usize {
|
|
unsafe { bitmap.as_ref().width() }
|
|
}
|
|
|
|
/// 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]
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_height(bitmap: NonNull<Bitmap>) -> usize {
|
|
unsafe { bitmap.as_ref().height() }
|
|
}
|
|
|
|
/// 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
|
|
#[no_mangle]
|
|
pub unsafe extern "C" fn sp_bitmap_unsafe_data_ref(
|
|
mut bitmap: NonNull<Bitmap>,
|
|
) -> SPByteSlice {
|
|
unsafe { SPByteSlice::from_slice(bitmap.as_mut().data_ref_mut()) }
|
|
}
|