Ffi image fns.

Author: tychedelia

crates/processing_ffi/src/color.rs

@@ -1,3 +1,5 @@
+use bevy::color::LinearRgba;
+
 /// A sRGB (?) color
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
@@ -13,3 +15,10 @@ impl From<Color> for bevy::color::Color {
         bevy::color::Color::srgba(color.r, color.g, color.b, color.a)
     }
 }
+
+impl From<LinearRgba> for Color {
+    fn from(lin: LinearRgba) -> Self {
+        let srgb = bevy::color::Color::srgba(lin.red, lin.green, lin.blue, lin.alpha);
+        srgb.into()
+    }
+}

crates/processing_ffi/src/error.rs

@@ -4,7 +4,7 @@ use std::{
     panic,
 };
 
-use processing::prelude::error::ProcessingError;
+pub(crate) use processing::prelude::error::ProcessingError;
 
 thread_local! {
     static LAST_ERROR: RefCell<Option<CString>> = const { RefCell::new(None) };

crates/processing_ffi/src/lib.rs

@@ -1,4 +1,5 @@
 use bevy::prelude::Entity;
+use bevy::render::render_resource::{Extent3d, TextureFormat};
 use processing::prelude::*;
 
 use crate::color::Color;
@@ -73,7 +74,21 @@ pub extern "C" fn processing_surface_resize(window_id: u64, width: u32, height:
 pub extern "C" fn processing_background_color(window_id: u64, color: Color) {
     error::clear_error();
     let window_entity = Entity::from_bits(window_id);
-    error::check(|| background_color(window_entity, color.into()));
+    error::check(|| record_command(window_entity, DrawCommand::BackgroundColor(color.into())));
+}
+
+/// Set the background image for the given window.
+///
+/// SAFETY:
+/// - This is called from the same thread as init.
+/// - image_id is a valid ID returned from processing_image_create.
+/// - The image has been fully uploaded.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_background_image(window_id: u64, image_id: u64) {
+    error::clear_error();
+    let window_entity = Entity::from_bits(window_id);
+    let image_entity = Entity::from_bits(image_id);
+    error::check(|| record_command(window_entity, DrawCommand::BackgroundImage(image_entity)));
 }
 
 /// Begins the draw for the given window.
@@ -223,3 +238,113 @@ pub extern "C" fn processing_rect(
         )
     });
 }
+
+/// Create an image from raw pixel data.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - data is a valid pointer to data_len bytes of RGBA pixel data.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_image_create(
+    width: u32,
+    height: u32,
+    data: *const u8,
+    data_len: usize,
+) -> u64 {
+    error::clear_error();
+    // SAFETY: Caller must ensure that `data` is valid for `data_len` bytes.
+    let data = unsafe { std::slice::from_raw_parts(data, data_len) };
+    error::check(|| {
+        let size = Extent3d {
+            width,
+            height,
+            depth_or_array_layers: 1,
+        };
+        image_create(size, data.to_vec(), TextureFormat::Rgba8UnormSrgb)
+    })
+    .map(|entity| entity.to_bits())
+    .unwrap_or(0)
+}
+
+/// Load an image from a file path.
+///
+/// SAFETY:
+/// - Init has been called.
+/// - path is a valid null-terminated C string.
+/// - This is called from the same thread as init.
+///
+/// Note: This function is currently synchronous but Bevy's asset loading is async.
+/// The image may not be immediately available. This needs to be improved.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_image_load(path: *const std::ffi::c_char) -> u64 {
+    error::clear_error();
+
+    // SAFETY: Caller guarantees path is a valid C string
+    let c_str = unsafe { std::ffi::CStr::from_ptr(path) };
+    let path_str = match c_str.to_str() {
+        Ok(s) => s,
+        Err(_) => {
+            error::set_error("Invalid UTF-8 in image path");
+            return 0;
+        }
+    };
+
+    error::check(|| image_load(path_str))
+        .map(|entity| entity.to_bits())
+        .unwrap_or(0)
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_image_resize(image_id: u64, new_width: u32, new_height: u32) {
+    error::clear_error();
+    let image_entity = Entity::from_bits(image_id);
+    let new_size = Extent3d {
+        width: new_width,
+        height: new_height,
+        depth_or_array_layers: 1,
+    };
+    error::check(|| image_resize(image_entity, new_size));
+}
+
+/// Load pixels from an image into a caller-provided buffer.
+///
+/// SAFETY:
+/// - Init and image_create have been called.
+/// - image_id is a valid ID returned from image_create.
+/// - buffer is a valid pointer to at least buffer_len Color elements.
+/// - buffer_len must equal width * height of the image.
+/// - This is called from the same thread as init.
+#[unsafe(no_mangle)]
+pub extern "C" fn processing_image_load_pixels(
+    image_id: u64,
+    buffer: *mut Color,
+    buffer_len: usize,
+) {
+    error::clear_error();
+    let image_entity = Entity::from_bits(image_id);
+    error::check(|| {
+        let colors = image_load_pixels(image_entity)?;
+
+        // Validate buffer size
+        if colors.len() != buffer_len {
+            let error_msg = format!(
+                "Buffer size mismatch: expected {}, got {}",
+                colors.len(),
+                buffer_len
+            );
+            error::set_error(&error_msg);
+            return Err(error::ProcessingError::InvalidArgument(error_msg));
+        }
+
+        // SAFETY: Caller guarantees buffer is valid for buffer_len elements
+        unsafe {
+            let buffer_slice = std::slice::from_raw_parts_mut(buffer, buffer_len);
+            for (i, color) in colors.iter().enumerate() {
+                buffer_slice[i] = Color::from(*color);
+            }
+        }
+
+        Ok(())
+    });
+}

crates/processing_render/src/error.rs

@@ -18,4 +18,6 @@ pub enum ProcessingError {
     ImageNotFound,
     #[error("Unsupported texture format")]
     UnsupportedTextureFormat,
+    #[error("Invalid argument: {0}")]
+    InvalidArgument(String),
 }