Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
82696b2d1a | ||
|
|
39c7c27c86 | ||
|
|
0968605d0b | ||
|
|
e8f11c08ea | ||
|
|
664625402f | ||
|
|
5a849a87c7 | ||
|
|
323ba6128e | ||
|
|
e434130784 | ||
|
|
92ce27af68 | ||
|
|
7a836783e1 | ||
|
|
b4730ffdf3 | ||
|
|
5ecb84ed16 | ||
|
|
8116375fd0 | ||
|
|
8f13ba61f0 | ||
|
|
500cbbc872 | ||
|
|
1eb59d986a | ||
|
|
18f0be072a |
30 changed files with 1768 additions and 1720 deletions
|
|
@ -96,7 +96,7 @@ endif
|
|||
|
||||
# ADD NEW EXAMPLES HERE
|
||||
_c_src := src/announce.c src/brightness_tester.c src/header_logger.c \
|
||||
src/moving_line.c src/random_stuff.c src/wiping_clear.c
|
||||
src/moving_line.c src/random_stuff.c src/wiping_clear.c src/undefined.c
|
||||
_programs := $(basename $(notdir $(_c_src)))
|
||||
_bins := $(_programs)
|
||||
_unstripped_bins := $(addsuffix _unstripped, $(_bins))
|
||||
|
|
|
|||
|
|
@ -3,27 +3,27 @@
|
|||
int main(void) {
|
||||
sock_init();
|
||||
|
||||
sp_udp_send_header(sock, (Header) {.command_code = COMMAND_CODE_CLEAR});
|
||||
sp_udpsocket_send_header(sock, (Header) {.command_code = COMMAND_CODE_CLEAR});
|
||||
|
||||
CharGrid *grid = sp_char_grid_new(5, 2);
|
||||
CharGrid *grid = sp_chargrid_new(5, 2);
|
||||
if (grid == NULL)
|
||||
return 1;
|
||||
|
||||
sp_char_grid_set(grid, 0, 0, 'H');
|
||||
sp_char_grid_set(grid, 1, 0, 'e');
|
||||
sp_char_grid_set(grid, 2, 0, 'l');
|
||||
sp_char_grid_set(grid, 3, 0, 'l');
|
||||
sp_char_grid_set(grid, 4, 0, 'o');
|
||||
sp_char_grid_set(grid, 0, 1, 'W');
|
||||
sp_char_grid_set(grid, 1, 1, 'o');
|
||||
sp_char_grid_set(grid, 2, 1, 'r');
|
||||
sp_char_grid_set(grid, 3, 1, 'l');
|
||||
sp_char_grid_set(grid, 4, 1, 'd');
|
||||
sp_chargrid_set(grid, 0, 0, 'H');
|
||||
sp_chargrid_set(grid, 1, 0, 'e');
|
||||
sp_chargrid_set(grid, 2, 0, 'l');
|
||||
sp_chargrid_set(grid, 3, 0, 'l');
|
||||
sp_chargrid_set(grid, 4, 0, 'o');
|
||||
sp_chargrid_set(grid, 0, 1, 'W');
|
||||
sp_chargrid_set(grid, 1, 1, 'o');
|
||||
sp_chargrid_set(grid, 2, 1, 'r');
|
||||
sp_chargrid_set(grid, 3, 1, 'l');
|
||||
sp_chargrid_set(grid, 4, 1, 'd');
|
||||
|
||||
Packet *packet = sp_char_grid_into_packet(grid, 0, 0);
|
||||
Packet *packet = sp_chargrid_try_into_packet(grid, 0, 0);
|
||||
if (packet == NULL)
|
||||
return 1;
|
||||
sp_udp_send_packet(sock, packet);
|
||||
sp_udpsocket_send_packet(sock, packet);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,14 +5,14 @@ void enable_all_pixels(void) {
|
|||
Bitmap *all_on = sp_bitmap_new_max_sized();
|
||||
sp_bitmap_fill(all_on, true);
|
||||
|
||||
BitmapCommand *bitmapCommand = sp_cmd_bitmap_from_bitmap(all_on);
|
||||
Packet *packet = sp_cmd_bitmap_try_into_packet(bitmapCommand);
|
||||
BitmapCommand *bitmapCommand = sp_bitmapcommand_from_bitmap(all_on);
|
||||
Packet *packet = sp_bitmapcommand_try_into_packet(bitmapCommand);
|
||||
if (packet != NULL)
|
||||
sp_udp_send_packet(sock, packet);
|
||||
sp_udpsocket_send_packet(sock, packet);
|
||||
}
|
||||
|
||||
void make_brightness_pattern(BrightnessGrid *grid) {
|
||||
ByteSlice slice = sp_brightness_grid_data_ref_mut(grid);
|
||||
ByteSlice slice = sp_brightnessgrid_data_ref_mut(grid);
|
||||
for (size_t index = 0; index < slice.length; index++) {
|
||||
slice.start[index] = (uint8_t)(index % ((size_t) Brightness_MAX));
|
||||
}
|
||||
|
|
@ -23,13 +23,13 @@ int main(void) {
|
|||
|
||||
enable_all_pixels();
|
||||
|
||||
BrightnessGrid *grid = sp_brightness_grid_new(TILE_WIDTH, TILE_HEIGHT);
|
||||
BrightnessGrid *grid = sp_brightnessgrid_new(TILE_WIDTH, TILE_HEIGHT);
|
||||
make_brightness_pattern(grid);
|
||||
|
||||
Packet *packet = sp_cmd_brightness_grid_into_packet(sp_cmd_brightness_grid_from_grid(grid));
|
||||
Packet *packet = sp_brightnessgridcommand_try_into_packet(sp_brightnessgridcommand_from_grid(grid));
|
||||
if (packet == NULL)
|
||||
return -2;
|
||||
|
||||
sp_udp_send_packet(sock, packet);
|
||||
sp_udpsocket_send_packet(sock, packet);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ void handle_error(const char *msg) {
|
|||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
bool log_command(struct Command command) {
|
||||
switch (command.tag) {
|
||||
bool log_command(struct GenericCommand *command) {
|
||||
switch (command->tag) {
|
||||
case COMMAND_TAG_INVALID: {
|
||||
printf("-> this is an invalid command\n");
|
||||
break;
|
||||
|
|
@ -26,14 +26,14 @@ bool log_command(struct Command command) {
|
|||
return true;
|
||||
}
|
||||
case COMMAND_TAG_BITMAP: {
|
||||
BitmapCommand *bitmapCommand = command.data.bitmap;
|
||||
BitmapCommand *bitmapCommand = command->data.bitmap;
|
||||
|
||||
CompressionCode compression = sp_cmd_bitmap_get_compression(bitmapCommand);
|
||||
CompressionCode compression = sp_bitmapcommand_get_compression(bitmapCommand);
|
||||
|
||||
size_t x, y;
|
||||
sp_cmd_bitmap_get_origin(bitmapCommand, &x, &y);
|
||||
sp_bitmapcommand_get_origin(bitmapCommand, &x, &y);
|
||||
|
||||
Bitmap *bitmap = sp_cmd_bitmap_get(bitmapCommand);
|
||||
Bitmap *bitmap = sp_bitmapcommand_get_bitmap_mut(bitmapCommand);
|
||||
size_t w = sp_bitmap_width(bitmap);
|
||||
size_t h = sp_bitmap_height(bitmap);
|
||||
|
||||
|
|
@ -42,54 +42,54 @@ bool log_command(struct Command command) {
|
|||
break;
|
||||
}
|
||||
case COMMAND_TAG_BRIGHTNESS_GRID: {
|
||||
BrightnessGridCommand *gridCommand = command.data.brightness_grid;
|
||||
BrightnessGridCommand *gridCommand = command->data.brightness_grid;
|
||||
|
||||
size_t x, y;
|
||||
sp_cmd_brightness_grid_get_origin(gridCommand, &x, &y);
|
||||
sp_brightnessgridcommand_get_origin(gridCommand, &x, &y);
|
||||
|
||||
BrightnessGrid *grid = sp_cmd_brightness_grid_get(gridCommand);
|
||||
size_t w = sp_brightness_grid_width(grid);
|
||||
size_t h = sp_brightness_grid_height(grid);
|
||||
BrightnessGrid *grid = sp_brightnessgridcommand_get_grid_mut(gridCommand);
|
||||
size_t w = sp_brightnessgrid_width(grid);
|
||||
size_t h = sp_brightnessgrid_height(grid);
|
||||
|
||||
printf("-> BrightnessGridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
|
||||
x, y, w, h);
|
||||
break;
|
||||
}
|
||||
case COMMAND_TAG_CHAR_GRID: {
|
||||
CharGridCommand *gridCommand = command.data.char_grid;
|
||||
CharGridCommand *gridCommand = command->data.char_grid;
|
||||
|
||||
size_t x, y;
|
||||
sp_cmd_char_grid_get_origin(gridCommand, &x, &y);
|
||||
sp_chargridcommand_get_origin(gridCommand, &x, &y);
|
||||
|
||||
CharGrid *grid = sp_cmd_char_grid_get(gridCommand);
|
||||
size_t w = sp_char_grid_width(grid);
|
||||
size_t h = sp_char_grid_height(grid);
|
||||
CharGrid *grid = sp_chargridcommand_get_grid_mut(gridCommand);
|
||||
size_t w = sp_chargrid_width(grid);
|
||||
size_t h = sp_chargrid_height(grid);
|
||||
|
||||
printf("-> CharGridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
|
||||
x, y, w, h);
|
||||
break;
|
||||
}
|
||||
case COMMAND_TAG_CP437_GRID: {
|
||||
Cp437GridCommand *gridCommand = command.data.cp437_grid;
|
||||
Cp437GridCommand *gridCommand = command->data.cp437_grid;
|
||||
|
||||
size_t x, y;
|
||||
sp_cmd_cp437_grid_get_origin(gridCommand, &x, &y);
|
||||
sp_cp437gridcommand_get_origin(gridCommand, &x, &y);
|
||||
|
||||
Cp437Grid *grid = sp_cmd_cp437_grid_get(gridCommand);
|
||||
size_t w = sp_cp437_grid_width(grid);
|
||||
size_t h = sp_cp437_grid_height(grid);
|
||||
Cp437Grid *grid = sp_cp437gridcommand_get_grid_mut(gridCommand);
|
||||
size_t w = sp_cp437grid_width(grid);
|
||||
size_t h = sp_cp437grid_height(grid);
|
||||
|
||||
printf("-> Cp437GridCommand with params: x=%zu, y=%zu, w=%zu, h=%zu\n",
|
||||
x, y, w, h);
|
||||
break;
|
||||
}
|
||||
case COMMAND_TAG_BIT_VEC: {
|
||||
BitVecCommand *bitvecCommand = command.data.bitvec;
|
||||
BitVecCommand *bitvecCommand = command->data.bit_vec;
|
||||
|
||||
size_t offset = sp_cmd_bitvec_get_offset(bitvecCommand);
|
||||
CompressionCode compression = sp_cmd_bitvec_get_compression(bitvecCommand);
|
||||
size_t offset = sp_bitveccommand_get_offset(bitvecCommand);
|
||||
CompressionCode compression = sp_bitveccommand_get_compression(bitvecCommand);
|
||||
|
||||
BinaryOperation operation = sp_cmd_bitvec_get_operation(bitvecCommand);
|
||||
BinaryOperation operation = sp_bitveccommand_get_operation(bitvecCommand);
|
||||
char *operationText;
|
||||
switch (operation) {
|
||||
case BINARY_OPERATION_AND:
|
||||
|
|
@ -109,8 +109,8 @@ bool log_command(struct Command command) {
|
|||
break;
|
||||
}
|
||||
|
||||
BitVec *bitvec = sp_cmd_bitvec_get(bitvecCommand);
|
||||
size_t len = sp_bitvec_len(bitvec);
|
||||
DisplayBitVec *bitvec = sp_bitveccommand_get_bitvec_mut(bitvecCommand);
|
||||
size_t len = sp_displaybitvec_len(bitvec);
|
||||
|
||||
printf("-> BitVecCommand with params: offset=%zu, length=%zu, compression=%hu, operation=%s\n",
|
||||
offset, len, compression, operationText);
|
||||
|
|
@ -129,12 +129,12 @@ bool log_command(struct Command command) {
|
|||
break;
|
||||
}
|
||||
case COMMAND_TAG_GLOBAL_BRIGHTNESS: {
|
||||
Brightness brightness = sp_cmd_brightness_global_get_brightness(command.data.global_brightness);
|
||||
Brightness brightness = sp_globalbrightnesscommand_get_brightness(command->data.global_brightness);
|
||||
printf("-> GlobalBrightnessCommand with params: brightness=%hu\n", brightness);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
printf("-> unknown command tag %d\n", command.tag);
|
||||
printf("-> unknown command tag %d\n", command->tag);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -198,10 +198,10 @@ int main(int argc, char **argv) {
|
|||
header->command_code, header->a, header->b, header->c, header->d,
|
||||
payload.start, payload.length);
|
||||
|
||||
struct Command command = sp_cmd_generic_try_from_packet(packet);
|
||||
struct GenericCommand *command = sp_genericcommand_try_from_packet(packet);
|
||||
done = log_command(command);
|
||||
|
||||
sp_cmd_generic_free(command);
|
||||
sp_genericcommand_free(command);
|
||||
}
|
||||
|
||||
close(udp_socket);
|
||||
|
|
|
|||
|
|
@ -10,12 +10,12 @@
|
|||
static UdpSocket *sock = NULL;
|
||||
|
||||
void sock_free() {
|
||||
sp_udp_free(sock);
|
||||
sp_udpsocket_free(sock);
|
||||
}
|
||||
|
||||
void sock_init() {
|
||||
//sock = sp_udp_open_ipv4(127, 0, 0, 1, 2342);
|
||||
sock = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
|
||||
sock = sp_udpsocket_open_ipv4(127, 0, 0, 1, 2342);
|
||||
//sock = sp_udp_open_ipv4(172, 23, 42, 29, 2342);
|
||||
if (sock == NULL)
|
||||
exit(-1);
|
||||
atexit(sock_free);
|
||||
|
|
|
|||
|
|
@ -13,14 +13,14 @@ int main(void) {
|
|||
sp_bitmap_set(bitmap, (y + x) % PIXEL_WIDTH, y, true);
|
||||
}
|
||||
|
||||
BitmapCommand *command = sp_cmd_bitmap_from_bitmap(sp_bitmap_clone(bitmap));
|
||||
Packet *packet = sp_cmd_bitmap_try_into_packet(command);
|
||||
BitmapCommand *command = sp_bitmapcommand_from_bitmap(sp_bitmap_clone(bitmap));
|
||||
Packet *packet = sp_bitmapcommand_try_into_packet(command);
|
||||
if (packet == NULL) {
|
||||
result = -2;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if (!sp_udp_send_packet(sock, packet)) {
|
||||
if (!sp_udpsocket_send_packet(sock, packet)) {
|
||||
result = -3;
|
||||
goto exit;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,13 +11,13 @@ int main(void) {
|
|||
|
||||
sp_bitmap_fill(pixels, true);
|
||||
|
||||
Packet *packet = sp_bitmap_into_packet(pixels, 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
|
||||
Packet *packet = sp_bitmap_try_into_packet(pixels, 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
|
||||
if (packet == NULL)
|
||||
return 1;
|
||||
|
||||
Header *header = sp_packet_get_header_mut(packet);
|
||||
printf("[%d, %d, %d, %d, %d]\n", header->command_code, header->a, header->b, header->c, header->d);
|
||||
|
||||
sp_udp_send_packet(sock, packet);
|
||||
sp_udpsocket_send_packet(sock, packet);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
22
example/src/undefined.c
Normal file
22
example/src/undefined.c
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
#include <stdio.h>
|
||||
#include "servicepoint.h"
|
||||
#include "helpers.h"
|
||||
|
||||
/// DO NOT DO ANY OF THIS!
|
||||
int main(void) {
|
||||
BitmapCommand *bmcmd = sp_bitmapcommand_new(sp_bitmap_new_max_sized(), 0, 0, COMPRESSION_CODE_UNCOMPRESSED);
|
||||
BitVecCommand *bvcmd = (BitVecCommand *) bmcmd;
|
||||
sp_bitveccommand_free(bvcmd);
|
||||
|
||||
uint8_t *data = calloc(1024, 1);
|
||||
struct GenericCommand generic = {
|
||||
.tag = COMMAND_TAG_BRIGHTNESS_GRID,
|
||||
.data = {.null = data},
|
||||
};
|
||||
|
||||
sock_init();
|
||||
|
||||
sp_udpsocket_send_command(sock, &generic);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -13,14 +13,14 @@ int main() {
|
|||
sp_bitmap_set(enabled_pixels, x, y, false);
|
||||
}
|
||||
|
||||
BitVec *bitvec = sp_bitmap_into_bitvec(sp_bitmap_clone(enabled_pixels));
|
||||
BitVecCommand *command = sp_cmd_bitvec_new(bitvec, 0, BINARY_OPERATION_AND, COMPRESSION_CODE_LZMA);
|
||||
Packet *packet = sp_cmd_bitvec_try_into_packet(command);
|
||||
DisplayBitVec *bitvec = sp_bitmap_into_bitvec(sp_bitmap_clone(enabled_pixels));
|
||||
BitVecCommand *command = sp_bitveccommand_new(bitvec, 0, BINARY_OPERATION_AND, COMPRESSION_CODE_LZMA);
|
||||
Packet *packet = sp_bitveccommand_try_into_packet(command);
|
||||
if (packet == NULL) {
|
||||
result = -2;
|
||||
goto exit;
|
||||
}
|
||||
if (!sp_udp_send_packet(sock, packet)) {
|
||||
if (!sp_udpsocket_send_packet(sock, packet)) {
|
||||
result = -3;
|
||||
goto exit;
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,56 +1,43 @@
|
|||
use crate::{
|
||||
commands::wrap_origin_accessors,
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
|
||||
commands::{wrap_command, wrap_origin_accessors},
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{Bitmap, BitmapCommand, CompressionCode, Origin, Packet};
|
||||
use servicepoint::{Bitmap, BitmapCommand, CompressionCode, Origin};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_cmd_bitmap::BitmapCommand);
|
||||
wrap_free!(sp_cmd_bitmap::BitmapCommand);
|
||||
wrap_command!(Bitmap);
|
||||
|
||||
wrap_fields!(sp_cmd_bitmap::BitmapCommand;
|
||||
prop bitmap: Bitmap { mut get(); move set(value); };
|
||||
prop compression: CompressionCode { get(); set(value); };
|
||||
wrap_fields!(BitmapCommand;
|
||||
prop bitmap: Bitmap { get mut; set move; };
|
||||
prop compression: CompressionCode { get; set; };
|
||||
);
|
||||
|
||||
wrap_origin_accessors!(sp_cmd_bitmap::BitmapCommand);
|
||||
wrap_origin_accessors!(BitmapCommand);
|
||||
|
||||
wrap_functions!(sp_cmd_bitmap;
|
||||
wrap_functions!(associate BitmapCommand;
|
||||
/// Sets a window of pixels to the specified values.
|
||||
///
|
||||
/// The passed [Bitmap] gets consumed.
|
||||
///
|
||||
/// Returns: a new [BitmapCommand] instance.
|
||||
fn new(
|
||||
bitmap: NonNull<Bitmap>,
|
||||
origin_x: usize,
|
||||
origin_y: usize,
|
||||
compression: CompressionCode,
|
||||
) -> NonNull<BitmapCommand> {
|
||||
heap_move_nonnull(BitmapCommand {
|
||||
bitmap: unsafe { heap_remove(bitmap) },
|
||||
bitmap: move NonNull<Bitmap>,
|
||||
origin_x: val usize,
|
||||
origin_y: val usize,
|
||||
compression: val CompressionCode,
|
||||
) -> move NonNull<BitmapCommand> {
|
||||
BitmapCommand {
|
||||
bitmap,
|
||||
origin: Origin::new(origin_x, origin_y),
|
||||
compression,
|
||||
})
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/// Move the provided [Bitmap] into a new [BitmapCommand],
|
||||
/// leaving other fields as their default values.
|
||||
///
|
||||
/// Rust equivalent: `BitmapCommand::from(bitmap)`
|
||||
fn from_bitmap(
|
||||
bitmap: NonNull<Bitmap>,
|
||||
) -> NonNull<BitmapCommand> {
|
||||
heap_move_nonnull(unsafe { heap_remove(bitmap) }.into())
|
||||
}
|
||||
|
||||
/// Tries to turn a [BitmapCommand] into a [Packet].
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn try_into_packet(
|
||||
command: NonNull<BitmapCommand>,
|
||||
) -> *mut Packet {
|
||||
heap_move_ok(unsafe { heap_remove(command) }.try_into())
|
||||
}
|
||||
fn from_bitmap(bitmap: move NonNull<Bitmap>) -> move NonNull<BitmapCommand> {
|
||||
bitmap.into()
|
||||
};
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,25 +1,22 @@
|
|||
use crate::{
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
|
||||
commands::wrap_command,
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{
|
||||
BinaryOperation, BitVecCommand, CompressionCode, DisplayBitVec, Offset,
|
||||
Packet,
|
||||
};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_cmd_bitvec::BitVecCommand);
|
||||
wrap_free!(sp_cmd_bitvec::BitVecCommand);
|
||||
wrap_command!(BitVec);
|
||||
|
||||
wrap_fields!(sp_cmd_bitvec::BitVecCommand;
|
||||
prop bitvec: DisplayBitVec { mut get(); move set(value); };
|
||||
prop offset: Offset { get(); set(value); };
|
||||
prop operation: BinaryOperation { get(); set(value); };
|
||||
prop compression: CompressionCode { get(); set(value); };
|
||||
wrap_fields!(BitVecCommand;
|
||||
prop bitvec: DisplayBitVec { get mut; set move; };
|
||||
prop offset: Offset { get; set; };
|
||||
prop operation: BinaryOperation { get; set; };
|
||||
prop compression: CompressionCode { get; set; };
|
||||
);
|
||||
|
||||
wrap_functions!(sp_cmd_bitvec;
|
||||
|
||||
wrap_functions!(associate BitVecCommand;
|
||||
/// Set pixel data starting at the pixel offset on screen.
|
||||
///
|
||||
/// The screen will continuously overwrite more pixel data without regarding the offset, meaning
|
||||
|
|
@ -33,26 +30,16 @@ wrap_functions!(sp_cmd_bitvec;
|
|||
///
|
||||
/// The contained [`DisplayBitVec`] is always uncompressed.
|
||||
fn new(
|
||||
bitvec: NonNull<DisplayBitVec>,
|
||||
offset: usize,
|
||||
operation: BinaryOperation,
|
||||
compression: CompressionCode,
|
||||
) -> NonNull<BitVecCommand> {
|
||||
heap_move_nonnull(BitVecCommand {
|
||||
bitvec: unsafe { heap_remove(bitvec) },
|
||||
bitvec: move NonNull<DisplayBitVec>,
|
||||
offset: val usize,
|
||||
operation: val BinaryOperation,
|
||||
compression: val CompressionCode,
|
||||
) -> move NonNull<BitVecCommand> {
|
||||
BitVecCommand {
|
||||
bitvec,
|
||||
offset,
|
||||
operation,
|
||||
compression,
|
||||
})
|
||||
}
|
||||
|
||||
/// Tries to turn a [BitVecCommand] into a [Packet].
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn try_into_packet(
|
||||
command: NonNull<BitVecCommand>,
|
||||
) -> *mut Packet {
|
||||
heap_move_ok(unsafe { heap_remove(command) }.try_into())
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,53 +1,38 @@
|
|||
use crate::{
|
||||
commands::wrap_origin_accessors,
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
|
||||
commands::{wrap_command, wrap_origin_accessors},
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{BrightnessGrid, BrightnessGridCommand, Origin, Packet};
|
||||
use servicepoint::{BrightnessGrid, BrightnessGridCommand, Origin};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_cmd_brightness_grid::BrightnessGridCommand);
|
||||
wrap_free!(sp_cmd_brightness_grid::BrightnessGridCommand);
|
||||
wrap_command!(BrightnessGrid);
|
||||
|
||||
wrap_fields!(sp_cmd_brightness_grid::BrightnessGridCommand;
|
||||
prop grid: BrightnessGrid { mut get(); move set(grid); };
|
||||
wrap_fields!(BrightnessGridCommand;
|
||||
prop grid: BrightnessGrid { get mut; set move; };
|
||||
);
|
||||
|
||||
wrap_origin_accessors!(sp_cmd_brightness_grid::BrightnessGridCommand);
|
||||
|
||||
wrap_functions!(sp_cmd_brightness_grid;
|
||||
wrap_origin_accessors!(BrightnessGridCommand);
|
||||
|
||||
wrap_functions!(associate BrightnessGridCommand;
|
||||
/// Set the brightness of individual tiles in a rectangular area of the display.
|
||||
///
|
||||
/// The passed [BrightnessGrid] gets consumed.
|
||||
///
|
||||
/// Returns: a new [BrightnessGridCommand] instance.
|
||||
fn new(
|
||||
grid: NonNull<BrightnessGrid>,
|
||||
origin_x: usize,
|
||||
origin_y: usize,
|
||||
) -> NonNull<BrightnessGridCommand> {
|
||||
heap_move_nonnull(BrightnessGridCommand {
|
||||
grid: unsafe { heap_remove(grid) },
|
||||
grid: move NonNull<BrightnessGrid>,
|
||||
origin_x: val usize,
|
||||
origin_y: val usize
|
||||
) -> move NonNull<BrightnessGridCommand> {
|
||||
BrightnessGridCommand {
|
||||
grid,
|
||||
origin: Origin::new(origin_x, origin_y),
|
||||
})
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/// Moves the provided [BrightnessGrid] into a new [BrightnessGridCommand],
|
||||
/// leaving other fields as their default values.
|
||||
fn from_grid(
|
||||
grid: NonNull<BrightnessGrid>,
|
||||
) -> NonNull<BrightnessGridCommand> {
|
||||
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
|
||||
}
|
||||
|
||||
/// Tries to turn a [BrightnessGridCommand] into a [Packet].
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn into_packet(
|
||||
command: NonNull<BrightnessGridCommand>,
|
||||
) -> *mut Packet {
|
||||
heap_move_ok(unsafe { heap_remove(command) }.try_into())
|
||||
}
|
||||
|
||||
fn from_grid(grid: move NonNull<BrightnessGrid>) -> move NonNull<BrightnessGridCommand> {
|
||||
grid.into()
|
||||
};
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,37 +1,38 @@
|
|||
use crate::{
|
||||
macros::{wrap_free, wrap_functions},
|
||||
mem::heap_move_nonnull,
|
||||
};
|
||||
use crate::{commands::wrap_command, macros::wrap_functions};
|
||||
use servicepoint::{ClearCommand, FadeOutCommand, HardResetCommand};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
macro_rules! wrap_cc_only {
|
||||
($prefix:ident :: $typ:ident ; $(#[$meta:meta])*) => {
|
||||
wrap_functions!($prefix;
|
||||
$(#[$meta])*
|
||||
///
|
||||
#[doc = concat!(" Returns: a new [`",stringify!($typ),"`] instance.")]
|
||||
fn new() -> NonNull<$typ> {
|
||||
heap_move_nonnull($typ)
|
||||
}
|
||||
);
|
||||
($(#[$meta:meta])* $command:ident) => {
|
||||
::paste::paste!{
|
||||
wrap_command!($command);
|
||||
|
||||
wrap_free!($prefix :: $typ);
|
||||
wrap_functions!(associate [< $command Command >];
|
||||
$(#[$meta])*
|
||||
///
|
||||
#[doc = " Returns: a new [`" [< $command Command >] "`] instance."]
|
||||
fn new() -> move ::core::ptr::NonNull<[< $command Command >]> {
|
||||
[< $command Command >]
|
||||
};
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
wrap_cc_only!(sp_cmd_clear::ClearCommand;
|
||||
wrap_cc_only!(
|
||||
/// Set all pixels to the off state.
|
||||
///
|
||||
/// Does not affect brightness.
|
||||
Clear
|
||||
);
|
||||
|
||||
wrap_cc_only!(sp_cmd_hard_reset::HardResetCommand;
|
||||
wrap_cc_only!(
|
||||
/// Kills the udp daemon on the display, which usually results in a restart.
|
||||
///
|
||||
/// Please do not send this in your normal program flow.
|
||||
HardReset
|
||||
);
|
||||
|
||||
wrap_cc_only!(sp_cmd_fade_out::FadeOutCommand;
|
||||
wrap_cc_only!(
|
||||
/// A yet-to-be-tested command.
|
||||
FadeOut
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,53 +1,38 @@
|
|||
use crate::{
|
||||
commands::wrap_origin_accessors,
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
|
||||
commands::{wrap_command, wrap_origin_accessors},
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{CharGrid, CharGridCommand, Origin, Packet};
|
||||
use servicepoint::{CharGrid, CharGridCommand, Origin};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_cmd_char_grid::CharGridCommand);
|
||||
wrap_free!(sp_cmd_char_grid::CharGridCommand);
|
||||
wrap_command!(CharGrid);
|
||||
|
||||
wrap_fields!(sp_cmd_char_grid::CharGridCommand;
|
||||
prop grid: CharGrid { mut get(); move set(grid); };
|
||||
wrap_fields!(CharGridCommand;
|
||||
prop grid: CharGrid { get mut; set move; };
|
||||
);
|
||||
|
||||
wrap_origin_accessors!(sp_cmd_char_grid::CharGridCommand);
|
||||
|
||||
wrap_functions!(sp_cmd_char_grid;
|
||||
wrap_origin_accessors!(CharGridCommand);
|
||||
|
||||
wrap_functions!(associate CharGridCommand;
|
||||
/// Show UTF-8 encoded text on the screen.
|
||||
///
|
||||
/// The passed [CharGrid] gets consumed.
|
||||
///
|
||||
/// Returns: a new [CharGridCommand] instance.
|
||||
fn new(
|
||||
grid: NonNull<CharGrid>,
|
||||
origin_x: usize,
|
||||
origin_y: usize,
|
||||
) -> NonNull<CharGridCommand> {
|
||||
heap_move_nonnull(CharGridCommand {
|
||||
grid: unsafe { heap_remove(grid) },
|
||||
grid: move NonNull<CharGrid>,
|
||||
origin_x: val usize,
|
||||
origin_y: val usize,
|
||||
) -> move NonNull<CharGridCommand> {
|
||||
CharGridCommand {
|
||||
grid,
|
||||
origin: Origin::new(origin_x, origin_y),
|
||||
})
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/// Moves the provided [CharGrid] into a new [CharGridCommand],
|
||||
/// leaving other fields as their default values.
|
||||
fn from_grid(
|
||||
grid: NonNull<CharGrid>,
|
||||
) -> NonNull<CharGridCommand> {
|
||||
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
|
||||
}
|
||||
|
||||
/// Tries to turn a [CharGridCommand] into a [Packet].
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn try_into_packet(
|
||||
command: NonNull<CharGridCommand>,
|
||||
) -> *mut Packet {
|
||||
heap_move_ok(unsafe { heap_remove(command) }.try_into())
|
||||
}
|
||||
|
||||
fn from_grid(grid: move NonNull<CharGrid>) -> move NonNull<CharGridCommand> {
|
||||
grid.into()
|
||||
};
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,53 +1,38 @@
|
|||
use crate::{
|
||||
commands::wrap_origin_accessors,
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_remove},
|
||||
commands::{wrap_command, wrap_origin_accessors},
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{Cp437Grid, Cp437GridCommand, Origin, Packet};
|
||||
use servicepoint::{Cp437Grid, Cp437GridCommand, Origin};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_cmd_cp437_grid::Cp437GridCommand);
|
||||
wrap_free!(sp_cmd_cp437_grid::Cp437GridCommand);
|
||||
wrap_command!(Cp437Grid);
|
||||
|
||||
wrap_fields!(sp_cmd_cp437_grid::Cp437GridCommand;
|
||||
prop grid: Cp437Grid { mut get(); move set(grid); };
|
||||
wrap_fields!(Cp437GridCommand;
|
||||
prop grid: Cp437Grid { get mut; set move; };
|
||||
);
|
||||
|
||||
wrap_origin_accessors!(sp_cmd_cp437_grid::Cp437GridCommand);
|
||||
|
||||
wrap_functions!(sp_cmd_cp437_grid;
|
||||
wrap_origin_accessors!(Cp437GridCommand);
|
||||
|
||||
wrap_functions!(associate Cp437GridCommand;
|
||||
/// Show text on the screen.
|
||||
///
|
||||
/// The text is sent in the form of a 2D grid of [CP-437] encoded characters.
|
||||
///
|
||||
/// The origin is relative to the top-left of the display.
|
||||
fn new(
|
||||
grid: NonNull<Cp437Grid>,
|
||||
origin_x: usize,
|
||||
origin_y: usize,
|
||||
) -> NonNull<Cp437GridCommand> {
|
||||
heap_move_nonnull(Cp437GridCommand {
|
||||
grid: unsafe { heap_remove(grid) },
|
||||
grid: move NonNull<Cp437Grid>,
|
||||
origin_x: val usize,
|
||||
origin_y: val usize,
|
||||
) -> move NonNull<Cp437GridCommand> {
|
||||
Cp437GridCommand {
|
||||
grid,
|
||||
origin: Origin::new(origin_x, origin_y),
|
||||
})
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/// Moves the provided [Cp437Grid] into a new [Cp437GridCommand],
|
||||
/// leaving other fields as their default values.
|
||||
fn from_grid(
|
||||
grid: NonNull<Cp437Grid>,
|
||||
) -> NonNull<Cp437GridCommand> {
|
||||
heap_move_nonnull(unsafe { heap_remove(grid) }.into())
|
||||
}
|
||||
|
||||
/// Tries to turn a [Cp437GridCommand] into a [Packet].
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn try_into_packet(
|
||||
command: NonNull<Cp437GridCommand>,
|
||||
) -> *mut Packet {
|
||||
heap_move_ok(unsafe { heap_remove(command) }.try_into())
|
||||
}
|
||||
|
||||
fn from_grid(grid: move NonNull<Cp437Grid>) -> move NonNull<Cp437GridCommand> {
|
||||
grid.into()
|
||||
};
|
||||
);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
use crate::{
|
||||
macros::wrap_functions,
|
||||
macros::{derive_clone, derive_free, wrap_functions, wrap_methods},
|
||||
mem::{
|
||||
heap_clone, heap_drop, heap_move, heap_move_nonnull, heap_move_ok,
|
||||
heap_remove,
|
||||
|
|
@ -18,7 +18,7 @@ use std::ptr::{null_mut, NonNull};
|
|||
pub union CommandUnion {
|
||||
pub null: *mut u8,
|
||||
pub bitmap: NonNull<BitmapCommand>,
|
||||
pub bitvec: NonNull<BitVecCommand>,
|
||||
pub bit_vec: NonNull<BitVecCommand>,
|
||||
pub brightness_grid: NonNull<BrightnessGridCommand>,
|
||||
pub char_grid: NonNull<CharGridCommand>,
|
||||
pub cp437_grid: NonNull<Cp437GridCommand>,
|
||||
|
|
@ -55,221 +55,214 @@ pub enum CommandTag {
|
|||
///
|
||||
/// Rust equivalent: [TypedCommand].
|
||||
#[repr(C)]
|
||||
pub struct SPCommand {
|
||||
pub struct GenericCommand {
|
||||
/// Specifies which kind of command struct is contained in `data`
|
||||
pub tag: CommandTag,
|
||||
/// The pointer to the command struct
|
||||
pub data: CommandUnion,
|
||||
}
|
||||
|
||||
impl SPCommand {
|
||||
const INVALID: SPCommand = SPCommand {
|
||||
impl GenericCommand {
|
||||
pub(crate) const INVALID: GenericCommand = GenericCommand {
|
||||
tag: CommandTag::Invalid,
|
||||
data: CommandUnion { null: null_mut() },
|
||||
};
|
||||
}
|
||||
|
||||
wrap_functions!(sp_cmd_generic;
|
||||
derive_clone!(GenericCommand);
|
||||
|
||||
/// Tries to turn a [Packet] into a [SPCommand].
|
||||
impl Clone for GenericCommand {
|
||||
fn clone(&self) -> Self {
|
||||
unsafe {
|
||||
match self.tag {
|
||||
CommandTag::Clear => GenericCommand {
|
||||
tag: CommandTag::Clear,
|
||||
data: CommandUnion {
|
||||
clear: heap_clone(self.data.clear),
|
||||
},
|
||||
},
|
||||
CommandTag::CharGrid => GenericCommand {
|
||||
tag: CommandTag::CharGrid,
|
||||
data: CommandUnion {
|
||||
char_grid: heap_clone(self.data.char_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::Cp437Grid => GenericCommand {
|
||||
tag: CommandTag::Cp437Grid,
|
||||
data: CommandUnion {
|
||||
cp437_grid: heap_clone(self.data.cp437_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::Bitmap => GenericCommand {
|
||||
tag: CommandTag::Bitmap,
|
||||
data: CommandUnion {
|
||||
bitmap: heap_clone(self.data.bitmap),
|
||||
},
|
||||
},
|
||||
CommandTag::GlobalBrightness => GenericCommand {
|
||||
tag: CommandTag::GlobalBrightness,
|
||||
data: CommandUnion {
|
||||
global_brightness: heap_clone(
|
||||
self.data.global_brightness,
|
||||
),
|
||||
},
|
||||
},
|
||||
CommandTag::BrightnessGrid => GenericCommand {
|
||||
tag: CommandTag::BrightnessGrid,
|
||||
data: CommandUnion {
|
||||
brightness_grid: heap_clone(self.data.brightness_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::BitVec => GenericCommand {
|
||||
tag: CommandTag::BitVec,
|
||||
data: CommandUnion {
|
||||
bit_vec: heap_clone(self.data.bit_vec),
|
||||
},
|
||||
},
|
||||
CommandTag::HardReset => GenericCommand {
|
||||
tag: CommandTag::HardReset,
|
||||
data: CommandUnion {
|
||||
hard_reset: heap_clone(self.data.hard_reset),
|
||||
},
|
||||
},
|
||||
CommandTag::FadeOut => GenericCommand {
|
||||
tag: CommandTag::FadeOut,
|
||||
data: CommandUnion {
|
||||
fade_out: heap_clone(self.data.fade_out),
|
||||
},
|
||||
},
|
||||
#[allow(deprecated)]
|
||||
CommandTag::BitmapLegacy => GenericCommand {
|
||||
tag: CommandTag::BitmapLegacy,
|
||||
data: CommandUnion {
|
||||
bitmap_legacy: heap_clone(self.data.bitmap_legacy),
|
||||
},
|
||||
},
|
||||
CommandTag::Invalid => GenericCommand::INVALID,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
derive_free!(GenericCommand);
|
||||
|
||||
impl Drop for GenericCommand {
|
||||
fn drop(&mut self) {
|
||||
unsafe {
|
||||
match self.tag {
|
||||
CommandTag::Invalid => (),
|
||||
CommandTag::Bitmap => heap_drop(self.data.bitmap),
|
||||
CommandTag::BitVec => heap_drop(self.data.bit_vec),
|
||||
CommandTag::BrightnessGrid => {
|
||||
heap_drop(self.data.brightness_grid)
|
||||
}
|
||||
CommandTag::CharGrid => heap_drop(self.data.char_grid),
|
||||
CommandTag::Cp437Grid => heap_drop(self.data.cp437_grid),
|
||||
CommandTag::GlobalBrightness => {
|
||||
heap_drop(self.data.global_brightness)
|
||||
}
|
||||
CommandTag::Clear => heap_drop(self.data.clear),
|
||||
CommandTag::HardReset => heap_drop(self.data.hard_reset),
|
||||
CommandTag::FadeOut => heap_drop(self.data.fade_out),
|
||||
CommandTag::BitmapLegacy => heap_drop(self.data.bitmap_legacy),
|
||||
}
|
||||
}
|
||||
|
||||
*self = Self::INVALID;
|
||||
}
|
||||
}
|
||||
|
||||
wrap_functions!(associate GenericCommand;
|
||||
/// Tries to turn a [Packet] into a [GenericCommand].
|
||||
///
|
||||
/// The packet is dropped in the process.
|
||||
///
|
||||
/// Returns: pointer to new [SPCommand] instance or NULL if parsing failed.
|
||||
fn try_from_packet(
|
||||
packet: NonNull<Packet>,
|
||||
) -> SPCommand {
|
||||
let packet = *unsafe { Box::from_raw(packet.as_ptr()) };
|
||||
/// Returns: pointer to new [GenericCommand] instance or NULL if parsing failed.
|
||||
fn try_from_packet(packet: move NonNull<Packet>) -> move NonNull<GenericCommand> {
|
||||
servicepoint::TypedCommand::try_from(packet)
|
||||
.map(|value| match value {
|
||||
TypedCommand::Clear(clear) => SPCommand {
|
||||
TypedCommand::Clear(clear) => GenericCommand {
|
||||
tag: CommandTag::Clear,
|
||||
data: CommandUnion {
|
||||
clear: heap_move_nonnull(clear),
|
||||
},
|
||||
},
|
||||
TypedCommand::CharGrid(char_grid) => SPCommand {
|
||||
TypedCommand::CharGrid(char_grid) => GenericCommand {
|
||||
tag: CommandTag::CharGrid,
|
||||
data: CommandUnion {
|
||||
char_grid: heap_move_nonnull(char_grid),
|
||||
},
|
||||
},
|
||||
TypedCommand::Cp437Grid(cp437_grid) => SPCommand {
|
||||
TypedCommand::Cp437Grid(cp437_grid) => GenericCommand {
|
||||
tag: CommandTag::Cp437Grid,
|
||||
data: CommandUnion {
|
||||
cp437_grid: heap_move_nonnull(cp437_grid),
|
||||
},
|
||||
},
|
||||
TypedCommand::Bitmap(bitmap) => SPCommand {
|
||||
TypedCommand::Bitmap(bitmap) => GenericCommand {
|
||||
tag: CommandTag::Bitmap,
|
||||
data: CommandUnion {
|
||||
bitmap: heap_move_nonnull(bitmap),
|
||||
},
|
||||
},
|
||||
TypedCommand::Brightness(global_brightness) => SPCommand {
|
||||
TypedCommand::Brightness(global_brightness) => GenericCommand {
|
||||
tag: CommandTag::GlobalBrightness,
|
||||
data: CommandUnion {
|
||||
global_brightness: heap_move_nonnull(global_brightness),
|
||||
},
|
||||
},
|
||||
TypedCommand::BrightnessGrid(brightness_grid) => SPCommand {
|
||||
TypedCommand::BrightnessGrid(brightness_grid) => GenericCommand {
|
||||
tag: CommandTag::BrightnessGrid,
|
||||
data: CommandUnion {
|
||||
brightness_grid: heap_move_nonnull(brightness_grid),
|
||||
},
|
||||
},
|
||||
TypedCommand::BitVec(bitvec) => SPCommand {
|
||||
TypedCommand::BitVec(bitvec) => GenericCommand {
|
||||
tag: CommandTag::BitVec,
|
||||
data: CommandUnion {
|
||||
bitvec: heap_move_nonnull(bitvec),
|
||||
bit_vec: heap_move_nonnull(bitvec),
|
||||
},
|
||||
},
|
||||
TypedCommand::HardReset(hard_reset) => SPCommand {
|
||||
TypedCommand::HardReset(hard_reset) => GenericCommand {
|
||||
tag: CommandTag::HardReset,
|
||||
data: CommandUnion {
|
||||
hard_reset: heap_move_nonnull(hard_reset),
|
||||
},
|
||||
},
|
||||
TypedCommand::FadeOut(fade_out) => SPCommand {
|
||||
TypedCommand::FadeOut(fade_out) => GenericCommand {
|
||||
tag: CommandTag::FadeOut,
|
||||
data: CommandUnion {
|
||||
fade_out: heap_move_nonnull(fade_out),
|
||||
},
|
||||
},
|
||||
#[allow(deprecated)]
|
||||
TypedCommand::BitmapLegacy(bitmap_legacy) => SPCommand {
|
||||
TypedCommand::BitmapLegacy(bitmap_legacy) => GenericCommand {
|
||||
tag: CommandTag::BitmapLegacy,
|
||||
data: CommandUnion {
|
||||
bitmap_legacy: heap_move_nonnull(bitmap_legacy),
|
||||
},
|
||||
},
|
||||
})
|
||||
.unwrap_or_else(move |_| SPCommand {
|
||||
.unwrap_or_else(move |_| GenericCommand {
|
||||
tag: CommandTag::Invalid,
|
||||
data: CommandUnion { null: null_mut() },
|
||||
})
|
||||
}
|
||||
};
|
||||
);
|
||||
|
||||
/// Clones an [SPCommand] instance.
|
||||
///
|
||||
/// returns: a new [SPCommand] instance.
|
||||
fn clone(command: SPCommand) -> SPCommand {
|
||||
unsafe {
|
||||
match command.tag {
|
||||
CommandTag::Clear => SPCommand {
|
||||
tag: CommandTag::Clear,
|
||||
data: CommandUnion {
|
||||
clear: heap_clone(command.data.clear),
|
||||
},
|
||||
},
|
||||
CommandTag::CharGrid => SPCommand {
|
||||
tag: CommandTag::CharGrid,
|
||||
data: CommandUnion {
|
||||
char_grid: heap_clone(command.data.char_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::Cp437Grid => SPCommand {
|
||||
tag: CommandTag::Cp437Grid,
|
||||
data: CommandUnion {
|
||||
cp437_grid: heap_clone(command.data.cp437_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::Bitmap => SPCommand {
|
||||
tag: CommandTag::Bitmap,
|
||||
data: CommandUnion {
|
||||
bitmap: heap_clone(command.data.bitmap),
|
||||
},
|
||||
},
|
||||
CommandTag::GlobalBrightness => SPCommand {
|
||||
tag: CommandTag::GlobalBrightness,
|
||||
data: CommandUnion {
|
||||
global_brightness: heap_clone(
|
||||
command.data.global_brightness,
|
||||
),
|
||||
},
|
||||
},
|
||||
CommandTag::BrightnessGrid => SPCommand {
|
||||
tag: CommandTag::BrightnessGrid,
|
||||
data: CommandUnion {
|
||||
brightness_grid: heap_clone(command.data.brightness_grid),
|
||||
},
|
||||
},
|
||||
CommandTag::BitVec => SPCommand {
|
||||
tag: CommandTag::BitVec,
|
||||
data: CommandUnion {
|
||||
bitvec: heap_clone(command.data.bitvec),
|
||||
},
|
||||
},
|
||||
CommandTag::HardReset => SPCommand {
|
||||
tag: CommandTag::HardReset,
|
||||
data: CommandUnion {
|
||||
hard_reset: heap_clone(command.data.hard_reset),
|
||||
},
|
||||
},
|
||||
CommandTag::FadeOut => SPCommand {
|
||||
tag: CommandTag::FadeOut,
|
||||
data: CommandUnion {
|
||||
fade_out: heap_clone(command.data.fade_out),
|
||||
},
|
||||
},
|
||||
#[allow(deprecated)]
|
||||
CommandTag::BitmapLegacy => SPCommand {
|
||||
tag: CommandTag::BitmapLegacy,
|
||||
data: CommandUnion {
|
||||
bitmap_legacy: heap_clone(command.data.bitmap_legacy),
|
||||
},
|
||||
},
|
||||
CommandTag::Invalid => SPCommand::INVALID,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Deallocates an [SPCommand].
|
||||
///
|
||||
/// Commands with an invalid `tag` do not have to be freed as the `data` pointer should be null.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```C
|
||||
/// SPCommand c = sp_cmd_clear_into_generic(sp_cmd_clear_new());
|
||||
/// sp_command_free(c);
|
||||
/// ```
|
||||
fn free(command: SPCommand) {
|
||||
unsafe {
|
||||
match command.tag {
|
||||
CommandTag::Invalid => (),
|
||||
CommandTag::Bitmap => heap_drop(command.data.bitmap),
|
||||
CommandTag::BitVec => heap_drop(command.data.bitvec),
|
||||
CommandTag::BrightnessGrid => {
|
||||
heap_drop(command.data.brightness_grid)
|
||||
}
|
||||
CommandTag::CharGrid => heap_drop(command.data.char_grid),
|
||||
CommandTag::Cp437Grid => heap_drop(command.data.cp437_grid),
|
||||
CommandTag::GlobalBrightness => {
|
||||
heap_drop(command.data.global_brightness)
|
||||
}
|
||||
CommandTag::Clear => heap_drop(command.data.clear),
|
||||
CommandTag::HardReset => heap_drop(command.data.hard_reset),
|
||||
CommandTag::FadeOut => heap_drop(command.data.fade_out),
|
||||
CommandTag::BitmapLegacy => heap_drop(command.data.bitmap_legacy),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Tries to turn a [SPCommand] into a [Packet].
|
||||
/// The [SPCommand] gets consumed.
|
||||
wrap_methods! { GenericCommand;
|
||||
/// Tries to turn a [GenericCommand] into a [Packet].
|
||||
/// The [GenericCommand] gets consumed.
|
||||
///
|
||||
/// Returns tag [CommandTag::Invalid] in case of an error.
|
||||
fn into_packet(
|
||||
command: SPCommand,
|
||||
) -> *mut Packet {
|
||||
fn try_into_packet(move command) -> val *mut Packet {
|
||||
match command.tag {
|
||||
CommandTag::Invalid => null_mut(),
|
||||
CommandTag::Bitmap => {
|
||||
heap_move_ok(unsafe { heap_remove(command.data.bitmap).try_into() })
|
||||
}
|
||||
CommandTag::BitVec => {
|
||||
heap_move_ok(unsafe { heap_remove(command.data.bitvec).try_into() })
|
||||
heap_move_ok(unsafe { heap_remove(command.data.bit_vec).try_into() })
|
||||
}
|
||||
CommandTag::BrightnessGrid => heap_move_ok(unsafe {
|
||||
heap_remove(command.data.brightness_grid).try_into()
|
||||
|
|
@ -296,6 +289,5 @@ wrap_functions!(sp_cmd_generic;
|
|||
heap_move(unsafe { heap_remove(command.data.bitmap_legacy).into() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
);
|
||||
};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,33 +1,21 @@
|
|||
use crate::{
|
||||
macros::{wrap_clone, wrap_fields, wrap_free, wrap_functions},
|
||||
mem::{heap_move_nonnull, heap_remove},
|
||||
commands::wrap_command,
|
||||
macros::{wrap_fields, wrap_functions},
|
||||
};
|
||||
use servicepoint::{Brightness, GlobalBrightnessCommand, Packet};
|
||||
use servicepoint::{Brightness, GlobalBrightnessCommand};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_functions!(sp_cmd_brightness_global;
|
||||
|
||||
wrap_functions!(associate GlobalBrightnessCommand;
|
||||
/// Set the brightness of all tiles to the same value.
|
||||
///
|
||||
/// Returns: a new [GlobalBrightnessCommand] instance.
|
||||
fn new(brightness: Brightness) -> NonNull<GlobalBrightnessCommand> {
|
||||
heap_move_nonnull(GlobalBrightnessCommand::from(brightness))
|
||||
}
|
||||
|
||||
/// Turns the command into a packet
|
||||
fn into_packet(command: NonNull<GlobalBrightnessCommand>) -> NonNull<Packet> {
|
||||
heap_move_nonnull(unsafe { heap_remove(command) }.into())
|
||||
}
|
||||
|
||||
);
|
||||
|
||||
wrap_clone!(sp_cmd_brightness_global::GlobalBrightnessCommand);
|
||||
wrap_free!(sp_cmd_brightness_global::GlobalBrightnessCommand);
|
||||
|
||||
wrap_fields!(
|
||||
sp_cmd_brightness_global::GlobalBrightnessCommand;
|
||||
prop brightness: Brightness {
|
||||
get();
|
||||
set(value);
|
||||
fn new(brightness: val Brightness) -> move NonNull<GlobalBrightnessCommand> {
|
||||
GlobalBrightnessCommand::from(brightness)
|
||||
};
|
||||
);
|
||||
|
||||
wrap_command!(GlobalBrightness);
|
||||
|
||||
wrap_fields!(GlobalBrightnessCommand;
|
||||
prop brightness: Brightness { get; set; };
|
||||
);
|
||||
|
|
|
|||
|
|
@ -15,33 +15,76 @@ pub use cp437_grid_command::*;
|
|||
pub use generic_command::*;
|
||||
|
||||
macro_rules! wrap_origin_accessors {
|
||||
( $prefix:ident :: $object_type:ty ) => {
|
||||
$crate::macros::wrap_functions!($prefix;
|
||||
#[doc = concat!(" Reads the origin field of the [`", stringify!($object_type), "`].")]
|
||||
fn get_origin(
|
||||
command: NonNull<$object_type>,
|
||||
origin_x: NonNull<usize>,
|
||||
origin_y: NonNull<usize>,
|
||||
) {
|
||||
unsafe {
|
||||
let origin = &command.as_ref().origin;
|
||||
*origin_x.as_ptr() = origin.x;
|
||||
*origin_y.as_ptr() = origin.y;
|
||||
}
|
||||
}
|
||||
( $object_type:ident ) => {
|
||||
::paste::paste! {
|
||||
$crate::macros::wrap_methods!($object_type;
|
||||
#[doc = " Reads the origin field of the [`" $object_type "`]."]
|
||||
fn get_origin(
|
||||
ref command,
|
||||
origin_x: mut ::core::ptr::NonNull<usize>,
|
||||
origin_y: mut ::core::ptr::NonNull<usize>
|
||||
) {
|
||||
let origin = command.origin;
|
||||
*origin_x = origin.x;
|
||||
*origin_y = origin.y;
|
||||
};
|
||||
|
||||
#[doc = concat!(" Overwrites the origin field of the [`", stringify!($object_type), "`].")]
|
||||
fn set_origin(
|
||||
command: NonNull<$object_type>,
|
||||
origin_x: usize,
|
||||
origin_y: usize,
|
||||
) {
|
||||
unsafe {
|
||||
$crate::macros::nonnull_as_mut!(command).origin = ::servicepoint::Origin::new(origin_x, origin_y);
|
||||
}
|
||||
}
|
||||
);
|
||||
#[doc = " Overwrites the origin field of the [`" $object_type "`]."]
|
||||
fn set_origin(mut command, origin_x: val usize, origin_y: val usize) {
|
||||
command.origin = ::servicepoint::Origin::new(origin_x, origin_y);
|
||||
};
|
||||
);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub(crate) use wrap_origin_accessors;
|
||||
macro_rules! derive_command_from {
|
||||
($command:ident) => {
|
||||
::paste::paste! {
|
||||
impl From<::servicepoint::[< $command Command >]> for $crate::commands::GenericCommand {
|
||||
fn from(command: ::servicepoint::[< $command Command >]) -> Self {
|
||||
Self {
|
||||
tag: $crate::commands::CommandTag::$command,
|
||||
data: $crate::commands::CommandUnion {
|
||||
[< $command:snake >]: $crate::mem::heap_move_nonnull(command)
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! derive_command_into_packet {
|
||||
($command_type:ident) => {
|
||||
::paste::paste! {
|
||||
$crate::macros::wrap_method!($command_type;
|
||||
#[doc = "Tries to turn a [`" $command_type "`] into a [Packet]."]
|
||||
///
|
||||
/// Returns: NULL or a [Packet] containing the command.
|
||||
fn try_into_packet(move instance) -> move_ok *mut ::servicepoint::Packet {
|
||||
instance.try_into()
|
||||
};
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! wrap_command {
|
||||
($command:ident, $object_type:ident) => {
|
||||
$crate::macros::derive_clone!($object_type);
|
||||
$crate::macros::derive_free!($object_type);
|
||||
$crate::commands::derive_command_from!($command);
|
||||
$crate::commands::derive_command_into_packet!($object_type);
|
||||
};
|
||||
($command:ident) => {
|
||||
::paste::paste! {
|
||||
$crate::commands::wrap_command!($command, [< $command Command >]);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub(crate) use {
|
||||
derive_command_from, derive_command_into_packet, wrap_command,
|
||||
wrap_origin_accessors,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
use crate::{
|
||||
containers::ByteSlice,
|
||||
macros::{wrap_clone, wrap_free, wrap_functions, wrap_methods},
|
||||
mem::{heap_move_nonnull, heap_move_ok, heap_move_some, heap_remove},
|
||||
containers::{wrap_grid, ByteSlice},
|
||||
macros::{wrap_functions, wrap_methods},
|
||||
};
|
||||
use servicepoint::{
|
||||
Bitmap, BitmapCommand, CompressionCode, DataRef, DisplayBitVec, Grid,
|
||||
|
|
@ -9,11 +8,9 @@ use servicepoint::{
|
|||
};
|
||||
use std::ptr::NonNull;
|
||||
|
||||
wrap_clone!(sp_bitmap::Bitmap);
|
||||
wrap_free!(sp_bitmap::Bitmap);
|
||||
|
||||
wrap_functions!(sp_bitmap;
|
||||
wrap_grid!(Bitmap, bool);
|
||||
|
||||
wrap_functions!(associate Bitmap;
|
||||
/// Creates a new [Bitmap] with the specified dimensions.
|
||||
///
|
||||
/// # Arguments
|
||||
|
|
@ -37,16 +34,16 @@ wrap_functions!(sp_bitmap;
|
|||
/// sp_bitmap_set(grid, 0, 0, false);
|
||||
/// sp_bitmap_free(grid);
|
||||
/// ```
|
||||
fn new(width: usize, height: usize) -> *mut Bitmap {
|
||||
heap_move_some(Bitmap::new(width, height))
|
||||
}
|
||||
fn new(width: val usize, height: val usize) -> move_some *mut Bitmap {
|
||||
Bitmap::new(width, height)
|
||||
};
|
||||
|
||||
/// Creates a new [Bitmap] with a size matching the screen.
|
||||
///
|
||||
/// returns: [Bitmap] initialized to all pixels off.
|
||||
fn new_max_sized() -> NonNull<Bitmap> {
|
||||
heap_move_nonnull(Bitmap::max_sized())
|
||||
}
|
||||
fn new_max_sized() -> move NonNull<Bitmap> {
|
||||
Bitmap::max_sized()
|
||||
};
|
||||
|
||||
/// Loads a [Bitmap] with the specified dimensions from the provided data.
|
||||
///
|
||||
|
|
@ -57,13 +54,12 @@ wrap_functions!(sp_bitmap;
|
|||
///
|
||||
/// returns: [Bitmap] that contains a copy of the provided data, or NULL in case of an error.
|
||||
fn load(
|
||||
width: usize,
|
||||
height: usize,
|
||||
data: ByteSlice,
|
||||
) -> *mut Bitmap {
|
||||
let data = unsafe { data.as_slice() };
|
||||
heap_move_ok(Bitmap::load(width, height, data))
|
||||
}
|
||||
width: val usize,
|
||||
height: val usize,
|
||||
data: slice ByteSlice,
|
||||
) -> move_ok *mut Bitmap {
|
||||
Bitmap::load(width, height, data)
|
||||
};
|
||||
|
||||
/// Tries to convert the BitVec to a Bitmap.
|
||||
///
|
||||
|
|
@ -71,84 +67,34 @@ wrap_functions!(sp_bitmap;
|
|||
///
|
||||
/// Returns NULL in case of error.
|
||||
fn from_bitvec(
|
||||
width: usize,
|
||||
bitvec: NonNull<DisplayBitVec>,
|
||||
) -> *mut Bitmap {
|
||||
let bitvec = unsafe { heap_remove(bitvec) };
|
||||
heap_move_ok(Bitmap::from_bitvec(width, bitvec))
|
||||
}
|
||||
width: val usize,
|
||||
bitvec: move NonNull<DisplayBitVec>,
|
||||
) -> move_ok *mut Bitmap {
|
||||
Bitmap::from_bitvec(width, bitvec)
|
||||
};
|
||||
);
|
||||
|
||||
wrap_methods!(Bitmap;
|
||||
/// Consumes the Bitmap and returns the contained BitVec.
|
||||
fn into_bitvec(
|
||||
bitmap: NonNull<Bitmap>
|
||||
) -> NonNull<DisplayBitVec> {
|
||||
let bitmap = unsafe { heap_remove(bitmap) };
|
||||
heap_move_nonnull(bitmap.into())
|
||||
}
|
||||
fn into_bitvec(move bitmap) -> move NonNull<DisplayBitVec> {
|
||||
bitmap.into()
|
||||
};
|
||||
|
||||
/// Creates a [BitmapCommand] and immediately turns that into a [Packet].
|
||||
///
|
||||
/// The provided [Bitmap] gets consumed.
|
||||
///
|
||||
/// Returns NULL in case of an error.
|
||||
fn into_packet(
|
||||
bitmap: NonNull<Bitmap>,
|
||||
x: usize,
|
||||
y: usize,
|
||||
compression: CompressionCode,
|
||||
) -> *mut Packet {
|
||||
let bitmap = unsafe { heap_remove(bitmap) };
|
||||
heap_move_ok(Packet::try_from(BitmapCommand {
|
||||
fn try_into_packet(move bitmap, x: val usize, y: val usize, compression: val CompressionCode) -> move_ok *mut Packet {
|
||||
Packet::try_from(BitmapCommand {
|
||||
bitmap,
|
||||
origin: Origin::new(x, y),
|
||||
compression,
|
||||
}))
|
||||
}
|
||||
);
|
||||
|
||||
wrap_methods!(
|
||||
sp_bitmap::Bitmap;
|
||||
|
||||
/// Gets the current value at the specified position.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// - `x` and `y`: position of the cell to read
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// - when accessing `x` or `y` out of bounds
|
||||
ref fn get(x: usize, y: usize) -> bool;
|
||||
|
||||
/// Sets the value of the specified position.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// - `x` and `y`: position of the cell
|
||||
/// - `value`: the value to write to the cell
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// - when accessing `x` or `y` out of bounds
|
||||
mut fn set(x: usize, y: usize, value: bool);
|
||||
|
||||
/// Sets the state of all pixels in the [Bitmap].
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// - `value`: the value to set all pixels to
|
||||
mut fn fill(value: bool);
|
||||
|
||||
/// Gets the width in pixels.
|
||||
ref fn width() -> usize;
|
||||
|
||||
/// Gets the height in pixels.
|
||||
ref fn height() -> usize;
|
||||
})
|
||||
};
|
||||
|
||||
/// Gets an unsafe reference to the data of the [Bitmap] instance.
|
||||
///
|
||||
/// The returned memory is valid for the lifetime of the bitmap.
|
||||
mut fn data_ref_mut() -> ByteSlice {
|
||||
|
||||
return(slice) { unsafe { ByteSlice::from_slice(slice) } };
|
||||
};
|
||||
fn data_ref_mut(mut instance) -> slice ByteSlice;
|
||||
);
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue