WowBot: Fix array-type signatures (WowBot)

2026-07-26T10:45:16Z

Fix array-type signatures (WowBot)

WowBot: Full Rust API reference: cubios-sys + cubios, every pub fn with docs (WowBot)

2026-07-26T10:44:42Z

Full Rust API reference: cubios-sys + cubios, every pub fn with docs (WowBot)

New page

{{notice|'''Official WOWCube SDK documentation.''' SDK 6.3, Rust API — '''EXPERIMENTAL''' (supported; APIs may change). Generated from the [https://github.com/wowcube/CubiOS_Rust_SDK CubiOS_Rust_SDK] sources — the repository is authoritative; do not edit by hand.}}

{{SDK 6.3 nav}}

''← [[SDK 6.3]] · [[SDK 6.3/Rust|Rust]] / cubios-sys (raw layer)''

Complete reference of the '''raw layer''' crate [https://github.com/wowcube/CubiOS_Rust_SDK/tree/main/crates/cubios-sys <code>cubios-sys</code>]: FFI bindings to the CubiOS engine ABI, thin safe wrappers and the application event loop. Signatures and descriptions are extracted from the crate sources. Engine-function semantics match the [[SDK 6.3/C++/Native API|C++ native API]] one-to-one.

== ffi::application ==

The <code>Application</code> trait (11 callbacks), <code>ApplicationContext</code>, <code>TimerController</code>, the event loop (<code>application_init</code> / <code>application_run</code>), <code>Anim<T></code>, <code>AppErr</code>.

'''Types:''' <code>enum AppErr</code> · <code>enum AppPkt</code> · <code>enum RotationDir</code> · <code>struct Anim</code> · <code>struct Timer</code> · <code>trait Application</code> · <code>trait Assetable</code> · <code>trait Mappable</code> · <code>trait Packable</code> · <code>struct MapBase</code> · <code>struct SceneSwitch</code> · <code>trait Broadcastable</code> · <code>trait Shuffable</code> · <code>struct TimerController</code> · <code>struct ApplicationContext</code>

'''49 public functions:'''

; <code>Application::fn app_context_mut(&mut self) -> &mut ApplicationContext</code>

; <code>Application::fn set_timer(&mut self, id: u8, delay: u32, suspended: bool) -> bool</code>

; <code>Application::fn start_timer(&mut self, id: u8) -> bool</code>

; <code>Application::fn stop_timer(&mut self, id: u8) -> bool</code>

; <code>Application::fn kill_timer(&mut self, id: u8)</code>

; <code>Application::fn on_init(&mut self) -> Result<(), AppErr></code>
: Called once when the application initializes.

; <code>Application::fn on_tick(&mut self, cur_time: u32, delta_time: u32) -> Result<(), AppErr></code>
: Called every frame. `cur_time` is current time in ms, `delta_time` is ms since last tick.

; <code>Application::fn on_render(&mut self, screens: &mut [Screen</code>
: Called to render the current frame. `screens` contains the 3 screens for this module.

; <code>Application::fn on_phys_tick(&mut self, screens: &[Screen</code>
: Called on physics tick. `screens` contains the 3 screens for this module.

; <code>Application::fn on_twist(&mut self, twist: &TopologyTwistInfo) -> Result<(), AppErr></code>
: Called when a twist event occurs.

; <code>Application::fn on_tap(&mut self, count: u32) -> Result<(), AppErr></code>
: Called when a tap event occurs. `count` is the number of taps.

; <code>Application::fn on_pat(&mut self, count: u32) -> Result<(), AppErr></code>
: Called when a pat event occurs. `count` is the number of pats.

; <code>Application::fn on_message(&mut self, msg_type: u32, data: &[u8]) -> Result<(), AppErr></code>
: Called when a network message is received from another module.

; <code>Application::fn on_external_message(&mut self, data: &[u8]) -> Result<(), AppErr></code>
: Called when an external message is received via BLE.

; <code>Application::fn on_timer(&mut self, timer_id: u8) -> Result<(), AppErr></code>
: Called when a timer fires.

; <code>Application::fn on_close(&mut self) -> Result<(), AppErr></code>
: Called when the application is closing.

; <code>Application::fn get_time(&self) -> u32</code>
: Returns current time in milliseconds.

; <code>Application::fn get_time_seconds(&self) -> u32</code>
: Returns current time in seconds.

; <code>Application::fn is_master_module(&self) -> bool</code>
: Returns true if this module is the master (module 0).

; <code>Application::fn send_network_message(&self, msg_type: u32, data: &[u8])</code>
: Sends a network message to other modules.

; <code>Application::fn save_state(&self, data: &[u8])</code>
: Saves game state to persistent storage.

; <code>Application::fn load_state(&self, id: &mut u32, data: &mut [u8]) -> i32</code>
: Loads game state from persistent storage. Returns the number of bytes read, or negative on error.

; <code>Application::fn send_external_message(&self, msg_type: u32, data: &mut [u8])</code>
: Sends an external message via BLE.

; <code>Application::fn show_fps_counter(&self, show: bool)</code>
: Shows or hides the FPS counter overlay.

; <code>Application::fn get_image_assets_count(&self) -> i32</code>
: Returns the number of image assets available.

; <code>Application::fn get_sound_assets_count(&self) -> i32</code>
: Returns the number of sound assets available.

; <code>Assetable::fn get_asset_id(asset: &'static str) -> Result<u32, AppErr></code>

; <code>Mappable::fn get_place( &self, module: u32, screen: u32, orientation: TopologyOrientation, ) -> Result<(u32, u32), AppErr></code>

; <code>Packable::fn to_pkt(&self, module: u8, screen: u8) -> [u8</code>

; <code>Packable::fn from_pkt(pkt: [u8</code>

; <code>fn new(val: T) -> Self</code>

; <code>Broadcastable::fn broadcast_part(&mut self, _module: u8, _screen: u8, _delay: usize) -> Result<(), AppErr></code>

; <code>Broadcastable::fn broadcast(&mut self, delay: usize) -> Result<(), AppErr></code>

; <code>Broadcastable::fn recv(&mut self, pkt: [u8</code>

; <code>Shuffable::fn rotate(&mut self, dir: &RotationDir) -> Result<(), AppErr></code>

; <code>Shuffable::fn shuffle(&mut self, algo: &[RotationDir]) -> Result<(), AppErr></code>

; <code>fn new(scenes: &'static [usize], start_time: usize) -> Self</code>

; <code>fn next_scene(&mut self)</code>

; <code>fn set_scene(&mut self, id: u8) -> Result<(), AppErr></code>

; <code>fn animate(&mut self)</code>

; <code>fn new() -> Self</code>
: Create a new TimerController with no active timers.

; <code>fn set_timer(&mut self, id: u8, delay: u32, suspended: bool) -> bool</code>

; <code>fn start_timer(&mut self, id: u8) -> bool</code>

; <code>fn stop_timer(&mut self, id: u8) -> bool</code>

; <code>fn kill_timer(&mut self, id: u8)</code>

; <code>fn delta_time(&self) -> u32</code>

; <code>fn new() -> Self</code>
: Create a new ApplicationContext.

; <code>fn application_init<T: Application>(app: &mut T, cid: u32)</code>

; <code>fn application_run<T: Application>(app: &mut T)</code>

== ffi::comm ==

Inter-module packets and UART lines, BLE external data, time, user name, state save/load, RNG, logging (<code>log_a</code>…<code>log_v</code>), tap.

'''22 public functions:'''

; <code>fn send_message(line: u32, pkt: *const u8, size: u32) -> i32</code>

; <code>fn send_message_to(line: u32, dest: u32, pkt: *const u8, size: u32) -> i32</code>

; <code>fn recv_message( line: u32, size: u32, pkt_info: *mut u32, pkt: *mut u8, rx_size: *mut u32, ) -> i32</code>

; <code>fn send_packet(packet_type: u32, pkt: &[u8]) -> i32</code>
: Send a packet (new API in SDK 6.3)

; <code>fn recv_packet(size: u32, packet_type: *mut u32, pkt: *mut u8) -> i32</code>
: Receive a packet (new API in SDK 6.3) Returns the number of bytes received, or negative on error. The packet type is written to `packet_type`.

; <code>fn get_time() -> i32</code>

; <code>fn get_user_name(buffer: &mut [u8]) -> i32</code>

; <code>fn toggle_debug_info() -> i32</code>

; <code>fn save_state(data: &[u8]) -> i32</code>

; <code>fn load_state(id: &mut u32, data: &mut [u8]) -> i32</code>
: Load saved state Returns the number of bytes loaded, or negative on error. The save ID is written to `id`.

; <code>fn load_state_legacy(data: &mut [u8]) -> i32</code>
: Load saved state (legacy API without ID) Note: This ignores the save ID. Use `load_state` for full functionality.

; <code>fn random_range(min: u32, max: u32) -> i32</code>

; <code>fn get_app_version() -> AppVersion</code>
: Get the application version

; <code>fn log_a(text: &str) -> i32</code>

; <code>fn log_e(text: &str) -> i32</code>

; <code>fn log_w(text: &str) -> i32</code>

; <code>fn log_i(text: &str) -> i32</code>

; <code>fn log_d(text: &str) -> i32</code>

; <code>fn log_v(text: &str) -> i32</code>

; <code>fn get_tap() -> i32</code>

; <code>fn send_ble_data(data_type: u32, pkt: &mut [u8]) -> i32</code>
: Send BLE data

; <code>fn recv_ble_data(pkt: &mut [u8]) -> i32</code>
: Receive BLE data

== ffi::gfx ==

Immediate-mode drawing: clear, primitives, text, images, baked images, sub-images, shaders, QR, render target, cache.

'''26 public functions:'''

; <code>fn get_asset_id(sprite_name: &str) -> i32</code>

; <code>fn clear(color: u32) -> i32</code>

; <code>fn draw_text( x: i32, y: i32, scale: u32, angle: u32, align: TextAlign, color: u32, text: &str, ) -> i32</code>

; <code>fn draw_point(x: i32, y: i32, color: u32) -> i32</code>

; <code>fn draw_circle(x: u32, y: u32, radius: u32, width: u32, color: u32) -> i32</code>

; <code>fn draw_solid_circle(x: u32, y: u32, radius: u32, color: u32) -> i32</code>
: Deprecated: use `set_fill_shader` + `draw_circle` instead

; <code>fn draw_arc( x: i32, y: i32, radius: u32, width: u32, angle0: u32, angle1: u32, color: u32, ) -> i32</code>

; <code>fn draw_sector(x: i32, y: i32, radius: u32, angle0: u32, angle1: u32, color: u32) -> i32</code>

; <code>fn draw_line(x0: i32, y0: i32, x1: i32, y1: i32, thickness: u32, color: u32) -> i32</code>

; <code>fn draw_rectangle(x: i32, y: i32, w: i32, h: i32, color: u32) -> i32</code>

; <code>fn bake_image( id: SpriteId, width: u32, height: u32, format: GfxPixelFormat, overwrite: bool, ) -> i32</code>
: Bake an image to an offscreen buffer # Arguments * `id` - Sprite ID to bake * `width` - Width of the baked image * `height` - Height of the baked image * `format` - Pixel format for the baked image * `overwrite` - Whether to overwrite existing baked image

; <code>fn remove_baked_image(id: SpriteId) -> i32</code>
: Remove a previously baked image

; <code>fn set_render_target(display: u8) -> i32</code>

; <code>fn draw_image( id: SpriteId, x: i32, y: i32, opacity: u32, color_key: u32, scale_x: u32, scale_y: u32, angle: u32, mirror: GfxMirror, ) -> i32</code>

; <code>fn draw_baked_image( x: i32, y: i32, opacity: u32, color_key: u32, scale_x: u32, scale_y: u32, angle: u32, mirror: GfxMirror, id: SpriteId, ) -> i32</code>

; <code>fn draw_sub_image( id: SpriteId, x: i32, y: i32, rect_x: u32, rect_y: u32, rect_w: u32, rect_h: u32, opacity: u32, color_key: u32, scale_x: u32, scale_y: u32, angle: u32, mirror: GfxMirror, ) -> i32</code>
: Draw a sub-region of a sprite (for sprite atlases)

; <code>fn draw_qr_code( x: i32, y: i32, size: u32, color0: u32, color1: u32, angle: u32, id: u32, text: &str, ) -> i32</code>
: Draw a QR code

; <code>fn render() -> i32</code>

; <code>fn clear_cache() -> i32</code>

; <code>fn cache_images(sprite_ids: &[SpriteId]) -> i32</code>

; <code>fn get_assets_count() -> i32</code>
: Get the total number of image assets

; <code>fn set_fps_window(size: u32) -> i32</code>
: Set the FPS counter window size

; <code>fn set_fill_shader(color: u32) -> i32</code>
: Set a solid fill shader When active, drawing operations will use this color to fill shapes.

; <code>fn set_linear_gradient_shader( x0: u32, y0: u32, x1: u32, y1: u32, color0: u32, color1: u32, ) -> i32</code>
: Set a linear gradient shader # Arguments * `x0`, `y0` - Start point of the gradient * `x1`, `y1` - End point of the gradient * `color0` - Start color * `color1` - End color

; <code>fn set_radial_gradient_shader(x0: u32, y0: u32, radius: u32, color0: u32, color1: u32) -> i32</code>
: Set a radial gradient shader # Arguments * `x0`, `y0` - Center point of the gradient * `radius` - Radius of the gradient * `color0` - Center color * `color1` - Edge color

; <code>fn remove_shader() -> i32</code>
: Remove the active shader

== ffi::topology ==

Facelets, faces, places, orientation, twists, assembly check.

'''15 public functions:'''

; <code>fn get_cuben() -> u32</code>

; <code>fn get_adjacent_facelet( module: u32, screen: u32, direction: TopologyNeighbour, result: *mut TopologyFaceletInfo, ) -> i32</code>

; <code>fn get_reversed_face(face: u32) -> Option<u32></code>

; <code>fn get_facelet( face: u32, position: u32, mode: TopologyOrientation, result: *mut TopologyFaceletInfo, ) -> i32</code>

; <code>fn get_place( module: u32, screen: u32, mode: TopologyOrientation, result: *mut TopologyPlace, ) -> i32</code>

; <code>fn get_opposite_facelet(module: u32, screen: u32, result: *mut TopologyFaceletInfo) -> i32</code>

; <code>fn get_angle(module: u32, screen: u32, mode: TopologyOrientation) -> i32</code>

; <code>fn get_facelet_orientation(module: u32, screen: u32) -> i32</code>

; <code>fn get_place_orientation(face: u32, position: u32) -> i32</code>

; <code>fn get_face(orientation: u32) -> i32</code>

; <code>fn is_assembled() -> bool</code>

; <code>fn get_twist(twist: *mut TopologyTwistInfo) -> i32</code>

; <code>fn debug_get_face(module: u32, screen: u32) -> i32</code>

; <code>fn debug_get_position(module: u32, screen: u32) -> i32</code>

; <code>fn debug_get_horizontal() -> i32</code>

== ffi::sound ==

Sound asset id, play, cache, stop, status.

'''6 public functions:'''

; <code>fn get_asset_id(sound_name: &str) -> i32</code>

; <code>fn play(sound_id: SoundId, volume: u32) -> i32</code>

; <code>fn cache_sounds(sound_ids: &[SoundId]) -> i32</code>

; <code>fn is_playing() -> bool</code>
: Check if a sound is currently playing

; <code>fn stop() -> i32</code>
: Stop the currently playing sound

; <code>fn get_assets_count() -> i32</code>
: Get the total number of sound assets

== ffi::motion ==

Per-display accelerometer and gyroscope.

'''8 public functions:'''

; <code>fn get_face_accel_x(display: u32) -> i32</code>
: Get raw accelerometer value along the screen-local X-axis (horizontal right). At rest, this reads the X-component of gravity in the screen's coordinate frame. During motion, reads gravity + linear acceleration. # Parameters - `display`: Screen index (0–23). All 3 screens on a module return the same physical measurement, transformed to screen-local coordinates.

; <code>fn get_face_accel_y(display: u32) -> i32</code>
: Get raw accelerometer value along the screen-local Y-axis (vertical up). See [`get_face_accel_x`] for details on data format and coordinate frame.

; <code>fn get_face_accel_z(display: u32) -> i32</code>
: Get raw accelerometer value along the screen-local Z-axis (toward cube center). When this screen faces up, Z reads approximately -1g (gravity pulls toward center). When this screen faces down, Z reads approximately +1g. See [`get_face_accel_x`] for details on data format and coordinate frame.

; <code>fn get_face_gyro_x(display: u32) -> i32</code>
: Get raw gyroscope value for rotation around the screen-local X-axis. Measures angular velocity of the screen pitching up/down. At rest, reads approximately zero. Sign convention: positive = clockwise when looking along the positive X-axis direction (per SDK docs, unverified). # Parameters - `display`: Screen index (0–23). Same sensor sharing as accelerometer.

; <code>fn get_face_gyro_y(display: u32) -> i32</code>
: Get raw gyroscope value for rotation around the screen-local Y-axis. Measures angular velocity of the screen yawing left/right. See [`get_face_gyro_x`] for details.

; <code>fn get_face_gyro_z(display: u32) -> i32</code>
: Get raw gyroscope value for rotation around the screen-local Z-axis. Measures angular velocity of the screen spinning in-plane (like a wheel). See [`get_face_gyro_x`] for details.

; <code>fn get_face_accel(display: u32) -> (i32, i32, i32)</code>
: Get all 3 accelerometer axes for a screen in one call. Returns `(x, y, z)` in screen-local coordinates. Equivalent to calling [`get_face_accel_x`], [`get_face_accel_y`], and [`get_face_accel_z`] separately. # Parameters - `display`: Screen index (0–23).

; <code>fn get_face_gyro(display: u32) -> (i32, i32, i32)</code>
: Get all 3 gyroscope axes for a screen in one call. Returns `(x, y, z)` angular velocities in screen-local coordinates. Equivalent to calling [`get_face_gyro_x`], [`get_face_gyro_y`], and [`get_face_gyro_z`] separately. # Parameters - `display`: Screen index (0–23).

== ffi::leaderboard ==

Leaderboard info and score table.

'''3 public functions:'''

; <code>fn get_info(info: *mut LbInfo) -> i32</code>

; <code>fn get_info_safe() -> LbInfo</code>
: Get leaderboard info with safe interface

; <code>fn get_score(lead_table_bin: &mut [u8]) -> i32</code>

== ffi::event ==

Pending-event mask (<code>Event</code>, <code>get_list</code>).

'''Types:''' <code>enum Event</code> — Event flags returned by `get_list()`

'''2 public functions:'''

; <code>fn get_list() -> i32</code>

; <code>fn has_event(event_list: i32, event: Event) -> bool</code>
: Check if a specific event is set in the event list

== ffi::network_message ==

Bit-packed serializer for inter-module messages.

'''Types:''' <code>struct NetworkMessage</code> — Bit-packed network message for inter-module communication. Allows packing multiple values into a compact byte buffer using variable bit widths for efficient network transmission.

'''17 public functions:'''

; <code>fn new() -> Self</code>
: Create a new empty network message.

; <code>fn from_data(data: &[u8]) -> Self</code>
: Create a network message from existing data.

; <code>fn reset(&mut self, zero: bool)</code>
: Reset the message position. If `zero` is true, also clear the buffer.

; <code>fn get_data(&self) -> &[u8]</code>
: Get the underlying data buffer and used length.

; <code>fn can_read(&self, bits: usize) -> bool</code>
: Returns true if at least `bits` more bits can be read from the current position.

; <code>fn write_int(&mut self, value: u32, bits: u8)</code>
: Write an unsigned integer with specified bit width (1-32 bits). This writes raw bits without sign handling. For signed values that need sign extension when read back, use [`write_signed_int`](Self::write_signed_int). # Arguments * `value` - The unsigned value to write (only the lower `bits` bits are used) * `bits` - Number of bits to write (1-32, clamped if larger) # Note on C++ SDK difference The C++ `WriteInt` uses `int` (signed), but performs unsigned bit operations. This Rust version uses `u32` to make the unsigned semantics explicit.

; <code>fn write_byte(&mut self, value: u8)</code>
: Write a single byte (8 bits).

; <code>fn write_signed_int(&mut self, value: i32, bits: u8)</code>
: Write a signed integer with specified bit width.

; <code>fn write_bool(&mut self, value: bool)</code>
: Write a boolean (1 bit).

; <code>fn write_float(&mut self, value: f32)</code>
: Write a 32-bit float.

; <code>fn read_int(&mut self, bits: u8) -> u32</code>
: Read an unsigned integer with specified bit width. This reads raw bits without sign extension. For signed values that were written with [`write_signed_int`](Self::write_signed_int), use [`read_signed_int`](Self::read_signed_int) to properly sign-extend. # Arguments * `bits` - Number of bits to read (1-32, clamped if larger) # Returns The unsigned value read from the message buffer. # Note on C++ SDK difference The C++ `ReadInt` returns `int` (signed), but performs unsigned bit operations. This Rust version returns `u32` to make the unsigned semantics explicit.

; <code>fn read_byte(&mut self) -> u8</code>
: Read a single byte.

; <code>fn read_signed_int(&mut self, bits: u8) -> i32</code>
: Read a signed integer with specified bit width.

; <code>fn read_bool(&mut self) -> bool</code>
: Read a boolean.

; <code>fn read_float(&mut self) -> f32</code>
: Read a 32-bit float.

; <code>fn position(&self) -> usize</code>
: Get current bit position.

; <code>fn can_write(&self, bits: usize) -> bool</code>
: Check if there's enough space to write `bits` more bits.

== ffi::save_message ==

Bit-packed serializer for the persistent save buffer.

'''Types:''' <code>struct SaveMessage</code> — Bit-packed save message for game state persistence. Allows packing multiple values into a compact byte buffer using variable bit widths for efficient save data storage.

'''18 public functions:'''

; <code>fn new() -> Self</code>
: Create a new empty save message.

; <code>fn from_data(data: &[u8]) -> Self</code>
: Create a save message from existing data.

; <code>fn reset(&mut self, zero: bool)</code>
: Reset the message position. If `zero` is true, also clear the buffer.

; <code>fn get_data(&self) -> &[u8]</code>
: Get the underlying data buffer (only the used portion).

; <code>fn get_buffer_mut(&mut self) -> &mut [u8]</code>
: Get the full buffer for loading saved data.

; <code>fn write_int(&mut self, value: u32, bits: u8)</code>
: Write an unsigned integer with specified bit width (1-32 bits). This writes raw bits without sign handling. For signed values that need sign extension when read back, use [`write_signed_int`](Self::write_signed_int). # Arguments * `value` - The unsigned value to write (only the lower `bits` bits are used) * `bits` - Number of bits to write (1-32, clamped if larger) # Note on C++ SDK difference The C++ `WriteInt` uses `int` (signed), but performs unsigned bit operations. This Rust version uses `u32` to make the unsigned semantics explicit.

; <code>fn write_byte(&mut self, value: u8)</code>
: Write a single byte (8 bits).

; <code>fn write_signed_int(&mut self, value: i32, bits: u8)</code>
: Write a signed integer with specified bit width.

; <code>fn write_bool(&mut self, value: bool)</code>
: Write a boolean (1 bit).

; <code>fn write_float(&mut self, value: f32)</code>
: Write a 32-bit float.

; <code>fn read_int(&mut self, bits: u8) -> u32</code>
: Read an unsigned integer with specified bit width. This reads raw bits without sign extension. For signed values that were written with [`write_signed_int`](Self::write_signed_int), use [`read_signed_int`](Self::read_signed_int) to properly sign-extend. # Arguments * `bits` - Number of bits to read (1-32, clamped if larger) # Returns The unsigned value read from the save buffer. # Note on C++ SDK difference The C++ `ReadInt` returns `int` (signed), but performs unsigned bit operations. This Rust version returns `u32` to make the unsigned semantics explicit.

; <code>fn read_byte(&mut self) -> u8</code>
: Read a single byte.

; <code>fn read_signed_int(&mut self, bits: u8) -> i32</code>
: Read a signed integer with specified bit width.

; <code>fn read_bool(&mut self) -> bool</code>
: Read a boolean.

; <code>fn read_float(&mut self) -> f32</code>
: Read a 32-bit float.

; <code>fn position(&self) -> usize</code>
: Get current bit position.

; <code>fn can_write(&self, bits: usize) -> bool</code>
: Check if there's enough space to write `bits` more bits.

; <code>fn set_used_bits(&mut self, bits: usize)</code>
: Set the number of used bits (for after loading data).

== ffi::screen ==

Low-level screen descriptor (id, angle, face, position) + <code>create_screens()</code>.

'''Types:''' <code>struct Screen</code> — Represents a screen on a WOWCube module. Each module has 3 screens. This struct provides access to screen properties like position, orientation, and display ID for rendering purposes.

'''7 public functions:'''

; <code>fn new(display_id: u8) -> Self</code>
: Creates a new Screen for the given display ID on this module.

; <code>fn id(&self) -> u8</code>
: Returns the display ID (0-2).

; <code>fn angle(&self) -> u32</code>
: Returns the current rotation angle.

; <code>fn position(&self) -> u32</code>
: Returns the position in the topology.

; <code>fn face(&self) -> i32</code>
: Returns the face this screen is on.

; <code>fn update_from_topology(&mut self, module: u32, orientation: TopologyOrientation)</code>
: Updates screen topology information from the system.

; <code>fn create_screens() -> [Screen; 3]</code>
: Creates an array of 3 screens for a module, initialized with display IDs 0, 1, 2.

== ffi::math ==

<code>Vec2</code>/<code>Vec2i</code>, <code>Color</code>, <code>Transform</code>, <code>Rect2</code>, trigonometry and fixed-point helpers (no_std, libm).

'''Types:''' <code>struct Vec2</code> — 2D vector with floating-point components. · <code>struct Vec2i</code> — 2D vector with integer components. · <code>struct Color</code> — ARGB color with 8-bit components. Stored as a packed u32 in ARGB format: 0xAARRGGBB · <code>struct Transform</code> — Transform with position, rotation, scale, and mirroring. · <code>struct Rect2</code> — 2D rectangle defined by top-left and dimensions.

'''57 public functions:'''

; <code>fn log2(f: f32) -> f32</code>
: Log base 2.

; <code>fn iclamp(val: i32, min_val: i32, max_val: i32) -> i32</code>
: Clamp an integer value between min and max.

; <code>fn acos(x: f32) -> f32</code>
: Arc cosine with value clamping to [-1, 1].

; <code>fn asin(x: f32) -> f32</code>
: Arc sine with value clamping to [-1, 1].

; <code>fn sqrt(x: f32) -> f32</code>
: Safe square root (negative values return 0).

; <code>fn fequal(f0: f32, f1: f32, tol: f32) -> bool</code>
: Fuzzy floating point equality check.

; <code>fn fless(f0: f32, f1: f32, tol: f32) -> bool</code>
: Fuzzy floating point less-than check.

; <code>fn fgreater(f0: f32, f1: f32, tol: f32) -> bool</code>
: Fuzzy floating point greater-than check.

; <code>fn ftol(val: f32) -> i32</code>
: Fast float to int conversion (truncates). Note: This is a portable implementation that matches the C++ SDK behavior.

; <code>fn smooth(new_val: f32, cur_val: f32, max_change: f32) -> f32</code>
: Smooth a value towards a target using max change per step.

; <code>fn clamp(val: f32, lower: f32, upper: f32) -> f32</code>
: Clamp a float value between lower and upper bounds.

; <code>fn saturate(val: f32) -> f32</code>
: Saturate a value (clamp between 0.0 and 1.0).

; <code>fn deg2rad(d: f32) -> f32</code>
: Convert degrees to radians.

; <code>fn rad2deg(r: f32) -> f32</code>
: Convert radians to degrees.

; <code>fn n_abs(a: f32) -> f32</code>
: Get the absolute value.

; <code>fn n_sgn(a: f32) -> i32</code>
: Get the sign of a value (-1 or 1).

; <code>fn n_max<T: PartialOrd>(a: T, b: T) -> T</code>
: Return the maximum of two values.

; <code>fn n_min<T: PartialOrd>(a: T, b: T) -> T</code>
: Return the minimum of two values.

; <code>fn lerp(x: f32, y: f32, l: f32) -> f32</code>
: Linearly interpolate between two values. Returns `x + l * (y - x)`.

; <code>fn rand_get_seed() -> u32</code>
: Get the current random seed.

; <code>fn rand_set_seed(s: u32)</code>
: Set the random seed.

; <code>fn rand() -> u32</code>
: Generate a random u32 using LCG algorithm.

; <code>fn rand2() -> f32</code>
: Return a pseudo random number between 0.0 and 1.0.

; <code>fn rand_int(n: i32) -> i32</code>
: Return a random integer in range [0, n].

; <code>fn rand_real() -> f32</code>
: Return a random float in [0.0, 1.0].

; <code>fn new(x: f32, y: f32) -> Self</code>
: Create a new vector.

; <code>fn zero() -> Self</code>
: Zero vector.

; <code>fn set(&mut self, x: f32, y: f32)</code>
: Set components.

; <code>fn len(&self) -> f32</code>
: Calculate length.

; <code>fn normalize(&mut self)</code>
: Normalize in place.

; <code>fn normalized(&self) -> Self</code>
: Return normalized copy.

; <code>fn dot(&self, other: &Self) -> f32</code>
: Dot product.

; <code>fn new(x: i16, y: i16) -> Self</code>
: Create a new vector.

; <code>fn zero() -> Self</code>
: Zero vector.

; <code>fn rgb(r: u8, g: u8, b: u8) -> Self</code>
: Create from RGB (alpha = 255).

; <code>fn rgba(r: u8, g: u8, b: u8, a: u8) -> Self</code>
: Create from RGBA.

; <code>fn from_u32(value: u32) -> Self</code>
: Create from packed u32 value (0xAARRGGBB format).

; <code>fn value(&self) -> u32</code>
: Get the packed u32 value.

; <code>fn r(&self) -> u8</code>
: Get red component.

; <code>fn g(&self) -> u8</code>
: Get green component.

; <code>fn b(&self) -> u8</code>
: Get blue component.

; <code>fn a(&self) -> u8</code>
: Get alpha component.

; <code>fn a_f32(&self) -> f32</code>
: Get alpha as float (0.0 - 1.0).

; <code>fn set_r(&mut self, r: u8)</code>
: Set red component.

; <code>fn set_g(&mut self, g: u8)</code>
: Set green component.

; <code>fn set_b(&mut self, b: u8)</code>
: Set blue component.

; <code>fn set_a(&mut self, a: u8)</code>
: Set alpha component.

; <code>fn set_a_f32(&mut self, a: f32)</code>
: Set alpha from float (0.0 - 1.0).

; <code>fn new(x: f32, y: f32) -> Self</code>
: Create a new transform at position.

; <code>fn with_rotation(x: f32, y: f32, rotation: i32) -> Self</code>
: Create with position and rotation.

; <code>fn with_scale(x: f32, y: f32, rotation: i32, scale: u32) -> Self</code>
: Create with position, rotation, and uniform scale.

; <code>fn safe_rotation(&self) -> i32</code>
: Get rotation normalized to 0-359.

; <code>fn set_scale(&mut self, scale: u32)</code>
: Set uniform scale.

; <code>fn new(x: i16, y: i16, w: i16, h: i16) -> Self</code>
: Create a new rectangle.

; <code>fn contains(&self, px: i16, py: i16) -> bool</code>
: Check if a point is inside the rectangle.

; <code>fn contains_point(&self, p: Vec2i) -> bool</code>
: Check if point (as Vec2i) is inside.

; <code>fn center(&self) -> Vec2i</code>
: Get the center point.

== ffi::types ==

ABI enums and structs (<code>TopologyFaceletInfo</code>, <code>TopologyTwistInfo</code>, <code>TextAlign</code>, <code>GfxMirror</code>, …).

'''Types:''' <code>enum UartId</code> — UART line identifiers · <code>enum GfxPixelFormat</code> — Pixel format for baked images · <code>enum GfxMirror</code> — Mirror mode for sprites · <code>enum TopologyNeighbour</code> — Topology neighbor direction · <code>enum TopologyOrientation</code> — Topology orientation mode · <code>enum TopologyTwist</code> — Twist direction for cube rotations · <code>enum TextAlign</code> — Text alignment options · <code>enum TopologyLocation</code> — Topology face location · <code>enum LogLevel</code> — Log level for debug output · <code>struct TopologyFaceletInfo</code> — Information about a facelet in the topology · <code>struct TopologyPlace</code> — Place information (face and position) · <code>struct TopologyTwistInfo</code> — Twist event information · <code>struct LbInfo</code> — Leaderboard information · <code>struct GfxParticle</code> — Particle effect parameters · <code>struct AppVersion</code> — Application version (packed bitfield in C++)

'''4 public functions:'''

; <code>fn from_u32(value: u32) -> Self</code>
: Converts a u32 value to a GfxMirror variant. Returns `GfxMirror::None` for invalid values.

; <code>fn patch(&self) -> u16</code>
: Extract patch version (bits 0-15)

; <code>fn minor(&self) -> u8</code>
: Extract minor version (bits 16-19)

; <code>fn major(&self) -> u8</code>
: Extract major version (bits 20-23)

== ffi::constants ==

Platform constants (screen size, module counts, buffer limits, <code>CUBE_N</code>).

[[Category:SDK 6.3]]
[[Category:Rust API]]

@@ Line 32: / Line 32: @@
 : Called every frame. `cur_time` is current time in ms, `delta_time` is ms since last tick.
-; <code>Application::fn on_render(&mut self, screens: &mut [Screen</code>
+; <code>Application::fn on_render(&mut self, screens: &mut [Screen; 3]) -&gt; Result&lt;(), AppErr&gt;</code>
 : Called to render the current frame. `screens` contains the 3 screens for this module.
-; <code>Application::fn on_phys_tick(&mut self, screens: &[Screen</code>
+; <code>Application::fn on_phys_tick(&mut self, screens: &[Screen; 3]) -&gt; Result&lt;(), AppErr&gt;</code>
 : Called on physics tick. `screens` contains the 3 screens for this module.
@@ Line 93: / Line 93: @@
 ; <code>Mappable::fn get_place( &self, module: u32, screen: u32, orientation: TopologyOrientation, ) -&gt; Result&lt;(u32, u32), AppErr&gt;</code>
-; <code>Packable::fn to_pkt(&self, module: u8, screen: u8) -&gt; [u8</code>
+; <code>Packable::fn to_pkt(&self, module: u8, screen: u8) -&gt; [u8; 4]</code>
-; <code>Packable::fn from_pkt(pkt: [u8</code>
+; <code>Packable::fn from_pkt(pkt: [u8; 4]) -&gt; (Self, u8, u8)</code>
 ; <code>fn new(val: T) -&gt; Self</code>
@@ Line 103: / Line 103: @@
 ; <code>Broadcastable::fn broadcast(&mut self, delay: usize) -&gt; Result&lt;(), AppErr&gt;</code>
-; <code>Broadcastable::fn recv(&mut self, pkt: [u8</code>
+; <code>Broadcastable::fn recv(&mut self, pkt: [u8; 4]) -&gt; Result&lt;(), AppErr&gt;</code>
 ; <code>Shuffable::fn rotate(&mut self, dir: &RotationDir) -&gt; Result&lt;(), AppErr&gt;</code>

SDK 6.3/Rust/cubios-sys - Revision history

WowBot: Fix array-type signatures (WowBot)

WowBot: Full Rust API reference: cubios-sys + cubios, every pub fn with docs (WowBot)