Add processing_core crate and webcam support

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"
@@ -23,14 +24,25 @@ too_many_arguments = "allow"
 [workspace.dependencies]
 bevy = { git = "https://github.com/bevyengine/bevy", branch = "main" }
 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"
@@ -86,6 +98,11 @@ path = "examples/midi.rs"
 name = "gltf_load"
 path = "examples/gltf_load.rs"
 
+[[example]]
+name = "webcam"
+path = "examples/webcam.rs"
+required-features = ["webcam"]
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

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,4 +36,6 @@ pub enum ProcessingError {
     UnknownMaterialProperty(String),
     #[error("GLTF load error: {0}")]
     GltfLoadError(String),
+    #[error("Webcam not connected")]
+    WebcamNotConnected,
 }

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,13 @@ impl Light {
 #[pyclass]
 #[derive(Debug)]
 pub struct Image {
-    entity: Entity,
+    pub(crate) entity: Entity,
+}
+
+impl Image {
+    pub(crate) fn from_entity(entity: Entity) -> Self {
+        Self { entity }
+    }
 }
 
 impl Drop for Image {

crates/processing_pyo3/src/graphics.rs

@@ -12,6 +12,8 @@ mod glfw;
 mod gltf;
 mod graphics;
 pub(crate) mod material;
+#[cfg(feature = "webcam")]
+mod webcam;
 
 use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
 use material::Material;
@@ -79,6 +81,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(())
 }
 
@@ -544,3 +552,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,61 @@
+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);
+    }
+}