Add processing_core crate and webcam support (#87)

Co-authored-by: Moon Davé <moon@softmoon.world>

Author: tychedelia

Cargo.lock

@@ -11,6 +11,7 @@ workspace = true
 default = ["wayland"]
 wayland = ["processing_render/wayland"]
 x11 = ["processing_render/x11"]
+webcam = ["dep:processing_webcam"]
 
 [workspace]
 resolver = "3"
@@ -26,14 +27,25 @@ bevy_naga_reflect = { git = "https://github.com/tychedelia/bevy_naga_reflect" }
 naga = { version = "28", features = ["wgsl-in"] }
 wesl = { version = "0.3", default-features = false }
 processing = { path = "." }
+processing_core = { path = "crates/processing_core" }
 processing_pyo3 = { path = "crates/processing_pyo3" }
 processing_render = { path = "crates/processing_render" }
 processing_midi = { path = "crates/processing_midi" }
+processing_webcam = { path = "crates/processing_webcam" }
 
 [dependencies]
 bevy = { workspace = true }
+processing_core = { workspace = true }
 processing_render = { workspace = true }
 processing_midi = { workspace = true }
+processing_webcam = { workspace = true, optional = true }
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+web-sys = { version = "0.3", features = ["Window"] }
 
 [dev-dependencies]
 glfw = "0.60.0"
@@ -89,6 +101,11 @@ path = "examples/midi.rs"
 name = "gltf_load"
 path = "examples/gltf_load.rs"
 
+[[example]]
+name = "webcam"
+path = "examples/webcam.rs"
+required-features = ["webcam"]
+
 [[example]]
 name = "stroke_2d"
 path = "examples/stroke_2d.rs"

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "processing_core"
+version = "0.1.0"
+edition = "2024"
+
+[lints]
+workspace = true
+
+[dependencies]
+bevy = { workspace = true }
+raw-window-handle = "0.6"
+thiserror = "2"
+tracing = "0.1"

crates/processing_core/Cargo.toml

@@ -1,7 +1,3 @@
-//! Options object for configuring various aspects of libprocessing.
-//!
-//! To add a new Config just add a new enum with associated value
-
 use bevy::prelude::Resource;
 use std::collections::HashMap;
 

crates/processing_render/src/config.rs crates/processing_core/src/config.rscrates/processing_render/src/config.rs renamed to crates/processing_core/src/config.rs

@@ -36,6 +36,8 @@ pub enum ProcessingError {
     UnknownMaterialProperty(String),
     #[error("GLTF load error: {0}")]
     GltfLoadError(String),
+    #[error("Webcam not connected")]
+    WebcamNotConnected,
     #[error("Shader compilation error: {0}")]
     ShaderCompilationError(String),
     #[error("Shader not found")]

crates/processing_render/src/error.rs crates/processing_core/src/error.rscrates/processing_render/src/error.rs renamed to crates/processing_core/src/error.rs

@@ -0,0 +1,49 @@
+pub mod config;
+pub mod error;
+
+use std::cell::RefCell;
+use std::sync::OnceLock;
+
+use bevy::app::App;
+use tracing::debug;
+
+static IS_INIT: OnceLock<()> = OnceLock::new();
+
+thread_local! {
+    static APP: RefCell<Option<App>> = const { RefCell::new(None) };
+}
+
+pub fn app_mut<T>(cb: impl FnOnce(&mut App) -> error::Result<T>) -> error::Result<T> {
+    let res = APP.with(|app_cell| {
+        let mut app_borrow = app_cell.borrow_mut();
+        let app = app_borrow
+            .as_mut()
+            .ok_or(error::ProcessingError::AppAccess)?;
+        cb(app)
+    })?;
+    Ok(res)
+}
+
+pub fn is_already_init() -> error::Result<bool> {
+    let is_init = IS_INIT.get().is_some();
+    let thread_has_app = APP.with(|app_cell| app_cell.borrow().is_some());
+    if is_init && !thread_has_app {
+        return Err(error::ProcessingError::AppAccess);
+    }
+    if is_init && thread_has_app {
+        debug!("App already initialized");
+        return Ok(true);
+    }
+    Ok(false)
+}
+
+pub fn set_app(app: App) {
+    APP.with(|app_cell| {
+        IS_INIT.get_or_init(|| ());
+        *app_cell.borrow_mut() = Some(app);
+    });
+}
+
+pub fn take_app() -> Option<App> {
+    APP.with(|app_cell| app_cell.borrow_mut().take())
+}

crates/processing_core/src/lib.rs

@@ -14,10 +14,12 @@ crate-type = ["cdylib"]
 default = ["wayland"]
 wayland = ["processing/wayland", "glfw/wayland"]
 x11 = ["processing/x11"]
+webcam = ["processing/webcam", "dep:processing_webcam"]
 
 [dependencies]
 pyo3 = "0.27.0"
 processing = { workspace = true }
+processing_webcam = { workspace = true, optional = true }
 bevy = { workspace = true, features = ["file_watcher"] }
 glfw = { version = "0.60.0"}
 png = "0.18"

crates/processing_pyo3/Cargo.toml

@@ -59,7 +59,14 @@ impl Light {
 #[pyclass]
 #[derive(Debug)]
 pub struct Image {
-    entity: Entity,
+    pub(crate) entity: Entity,
+}
+
+impl Image {
+    #[expect(dead_code)] // it's only used by webcam atm
+    pub(crate) fn from_entity(entity: Entity) -> Self {
+        Self { entity }
+    }
 }
 
 impl Drop for Image {

crates/processing_pyo3/src/graphics.rs

@@ -13,6 +13,8 @@ mod gltf;
 mod graphics;
 pub(crate) mod material;
 pub(crate) mod shader;
+#[cfg(feature = "webcam")]
+mod webcam;
 
 use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
 use material::Material;
@@ -93,6 +95,12 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(emissive, m)?)?;
     m.add_function(wrap_pyfunction!(unlit, m)?)?;
 
+    #[cfg(feature = "webcam")]
+    {
+        m.add_class::<webcam::Webcam>()?;
+        m.add_function(wrap_pyfunction!(create_webcam, m)?)?;
+    }
+
     Ok(())
 }
 
@@ -570,3 +578,14 @@ fn emissive(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult
 fn unlit(module: &Bound<'_, PyModule>) -> PyResult<()> {
     graphics!(module).unlit()
 }
+
+#[cfg(feature = "webcam")]
+#[pyfunction]
+#[pyo3(signature = (width=None, height=None, framerate=None))]
+fn create_webcam(
+    width: Option<u32>,
+    height: Option<u32>,
+    framerate: Option<u32>,
+) -> PyResult<webcam::Webcam> {
+    webcam::Webcam::new(width, height, framerate)
+}

crates/processing_pyo3/src/lib.rs

@@ -0,0 +1,55 @@
+use bevy::prelude::Entity;
+use processing_webcam::{
+    WebcamFormat, webcam_create, webcam_create_with_format, webcam_destroy, webcam_image,
+    webcam_is_connected, webcam_resolution,
+};
+use pyo3::{exceptions::PyRuntimeError, prelude::*};
+
+use crate::graphics::Image;
+
+#[pyclass(unsendable)]
+pub struct Webcam {
+    entity: Entity,
+}
+
+#[pymethods]
+impl Webcam {
+    #[new]
+    #[pyo3(signature = (width=None, height=None, framerate=None))]
+    pub fn new(width: Option<u32>, height: Option<u32>, framerate: Option<u32>) -> PyResult<Self> {
+        let entity = match (width, height, framerate) {
+            (Some(w), Some(h), Some(fps)) => webcam_create_with_format(WebcamFormat::Exact {
+                resolution: bevy::math::UVec2::new(w, h),
+                framerate: fps,
+            }),
+            (Some(w), Some(h), None) => {
+                webcam_create_with_format(WebcamFormat::Resolution(bevy::math::UVec2::new(w, h)))
+            }
+            (None, None, Some(fps)) => webcam_create_with_format(WebcamFormat::FrameRate(fps)),
+            _ => webcam_create(),
+        }
+        .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+
+        Ok(Self { entity })
+    }
+
+    pub fn is_connected(&self) -> PyResult<bool> {
+        webcam_is_connected(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn resolution(&self) -> PyResult<(u32, u32)> {
+        webcam_resolution(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn image(&self) -> PyResult<Image> {
+        let entity =
+            webcam_image(self.entity).map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Image::from_entity(entity))
+    }
+}
+
+impl Drop for Webcam {
+    fn drop(&mut self) {
+        let _ = webcam_destroy(self.entity);
+    }
+}