Fixup other crates.

Author: tychedelia

crates/processing_pyo3/src/lib.rs

@@ -19,9 +19,9 @@ mod processing {
         let surface = surface_create(window_handle, display_handle, width, height, 1.0).unwrap();
 
         while glfw_ctx.poll_events() {
-            begin_draw(surface).unwrap();
+            graphics_begin_draw(surface).unwrap();
 
-            record_command(
+            graphics_record_command(
                 surface,
                 DrawCommand::Rect {
                     x: 10.0,
@@ -33,7 +33,7 @@ mod processing {
             )
             .unwrap();
 
-            end_draw(surface).unwrap();
+            graphics_end_draw(surface).unwrap();
         }
 
         Ok("OK".to_string())

crates/processing_render/src/lib.rs

@@ -4,17 +4,16 @@ pub mod image;
 pub mod render;
 mod surface;
 
-#[cfg(any(target_os = "linux", target_arch = "wasm32"))]
-use std::ffi::c_void;
 use std::{cell::RefCell, num::NonZero, path::PathBuf, sync::OnceLock};
 
 use bevy::{
     app::{App, AppExit},
     asset::AssetEventSystems,
-    log::tracing_subscriber,
     prelude::*,
     render::render_resource::{Extent3d, TextureFormat},
 };
+#[cfg(not(target_arch = "wasm32"))]
+use bevy::log::tracing_subscriber;
 use render::{activate_cameras, clear_transient_meshes, flush_draw_commands};
 use tracing::debug;
 

crates/processing_render/src/surface.rs

@@ -6,6 +6,8 @@
 //!
 //! In Bevy, we can consider a surface to be a [`RenderTarget`], which is either a window or a
 //! texture.
+#[cfg(any(target_os = "linux", target_arch = "wasm32"))]
+use std::ffi::c_void;
 use std::ptr::NonNull;
 
 use bevy::{
@@ -191,6 +193,24 @@ pub fn create(
             )
         };
 
+        #[cfg(target_arch = "wasm32")]
+        let (raw_window_handle, raw_display_handle) = {
+            use raw_window_handle::{WebCanvasWindowHandle, WebDisplayHandle};
+
+            // For WASM, window_handle is a pointer to an HtmlCanvasElement
+            if window_handle == 0 {
+                return Err(error::ProcessingError::InvalidWindowHandle);
+            }
+            let canvas_ptr = NonNull::new(window_handle as *mut c_void).unwrap();
+            let window = WebCanvasWindowHandle::new(canvas_ptr.cast());
+            let display = WebDisplayHandle::new();
+
+            (
+                RawWindowHandle::WebCanvas(window),
+                RawDisplayHandle::Web(display),
+            )
+        };
+
         let glfw_window = GlfwWindow {
             window_handle: raw_window_handle,
             display_handle: raw_display_handle,

crates/processing_wasm/src/lib.rs

@@ -1,8 +1,8 @@
 use bevy::prelude::Entity;
 use processing_render::{
-    begin_draw, end_draw, exit, flush, image_create, image_destroy, image_load, image_load_pixels,
-    image_resize, init, record_command, render::command::DrawCommand, surface_create_from_canvas,
-    surface_destroy, surface_resize,
+    exit, graphics_begin_draw, graphics_end_draw, graphics_flush, graphics_record_command,
+    image_create, image_destroy, image_load, image_readback, image_resize, init,
+    render::command::DrawCommand, surface_create_from_canvas, surface_destroy, surface_resize,
 };
 use wasm_bindgen::prelude::*;
 
@@ -38,33 +38,33 @@ pub fn js_surface_resize(surface_id: u64, width: u32, height: u32) -> Result<(),
 #[wasm_bindgen(js_name = "background")]
 pub fn js_background_color(surface_id: u64, r: f32, g: f32, b: f32, a: f32) -> Result<(), JsValue> {
     let color = bevy::color::Color::srgba(r, g, b, a);
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::BackgroundColor(color),
     ))
 }
 
 #[wasm_bindgen(js_name = "backgroundImage")]
 pub fn js_background_image(surface_id: u64, image_id: u64) -> Result<(), JsValue> {
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::BackgroundImage(Entity::from_bits(image_id)),
     ))
 }
 
 #[wasm_bindgen(js_name = "beginDraw")]
 pub fn js_begin_draw(surface_id: u64) -> Result<(), JsValue> {
-    check(begin_draw(Entity::from_bits(surface_id)))
+    check(graphics_begin_draw(Entity::from_bits(surface_id)))
 }
 
 #[wasm_bindgen(js_name = "flush")]
 pub fn js_flush(surface_id: u64) -> Result<(), JsValue> {
-    check(flush(Entity::from_bits(surface_id)))
+    check(graphics_flush(Entity::from_bits(surface_id)))
 }
 
 #[wasm_bindgen(js_name = "endDraw")]
 pub fn js_end_draw(surface_id: u64) -> Result<(), JsValue> {
-    check(end_draw(Entity::from_bits(surface_id)))
+    check(graphics_end_draw(Entity::from_bits(surface_id)))
 }
 
 #[wasm_bindgen(js_name = "exit")]
@@ -75,7 +75,7 @@ pub fn js_exit(exit_code: u8) -> Result<(), JsValue> {
 #[wasm_bindgen(js_name = "fill")]
 pub fn js_fill(surface_id: u64, r: f32, g: f32, b: f32, a: f32) -> Result<(), JsValue> {
     let color = bevy::color::Color::srgba(r, g, b, a);
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::Fill(color),
     ))
@@ -84,31 +84,31 @@ pub fn js_fill(surface_id: u64, r: f32, g: f32, b: f32, a: f32) -> Result<(), Js
 #[wasm_bindgen(js_name = "stroke")]
 pub fn js_stroke(surface_id: u64, r: f32, g: f32, b: f32, a: f32) -> Result<(), JsValue> {
     let color = bevy::color::Color::srgba(r, g, b, a);
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::StrokeColor(color),
     ))
 }
 
 #[wasm_bindgen(js_name = "strokeWeight")]
 pub fn js_stroke_weight(surface_id: u64, weight: f32) -> Result<(), JsValue> {
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::StrokeWeight(weight),
     ))
 }
 
 #[wasm_bindgen(js_name = "noFill")]
 pub fn js_no_fill(surface_id: u64) -> Result<(), JsValue> {
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::NoFill,
     ))
 }
 
 #[wasm_bindgen(js_name = "noStroke")]
 pub fn js_no_stroke(surface_id: u64) -> Result<(), JsValue> {
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::NoStroke,
     ))
@@ -126,7 +126,7 @@ pub fn js_rect(
     br: f32,
     bl: f32,
 ) -> Result<(), JsValue> {
-    check(record_command(
+    check(graphics_record_command(
         Entity::from_bits(surface_id),
         DrawCommand::Rect {
             x,
@@ -168,8 +168,8 @@ pub fn js_image_resize(image_id: u64, new_width: u32, new_height: u32) -> Result
 }
 
 #[wasm_bindgen(js_name = "loadPixels")]
-pub fn js_image_load_pixels(image_id: u64) -> Result<Vec<f32>, JsValue> {
-    let colors = check(image_load_pixels(Entity::from_bits(image_id)))?;
+pub fn js_image_readback(image_id: u64) -> Result<Vec<f32>, JsValue> {
+    let colors = check(image_readback(Entity::from_bits(image_id)))?;
 
     let mut result = Vec::with_capacity(colors.len() * 4);
     for color in colors {