Add basic pyo3 module functionality / wrappers.

Author: tychedelia

Cargo.lock

@@ -13,7 +13,8 @@ crate-type = ["cdylib"]
 [dependencies]
 pyo3 = "0.27.0"
 processing = { workspace = true }
-glfw = "0.60.0"
+bevy = { workspace = true }
+glfw = { version = "0.60.0", features = ["static-link"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
-glfw = { version = "0.60.0", features = ["wayland"] }
+glfw = { version = "0.60.0", features = ["static-link", "wayland"] }

crates/processing_pyo3/Cargo.toml

@@ -0,0 +1,15 @@
+from processing import *
+
+# TODO: this should be in a setup function
+size(800, 600)
+
+def draw():
+    background(220)
+
+    fill(255, 0, 100)
+    stroke(0)
+    stroke_weight(2)
+    rect(100, 100, 200, 150)
+
+# TODO: this should happen implicitly on module load somehow
+run(draw)

crates/processing_pyo3/examples/rectangle.py

@@ -12,5 +12,8 @@ classifiers = [
 ]
 dynamic = ["version"]
 
+[dependency-groups]
+dev = ["maturin>=1.10,<2.0"]
+
 [tool.maturin]
 manifest-path = "Cargo.toml"

crates/processing_pyo3/pyproject.toml

@@ -0,0 +1,187 @@
+use bevy::prelude::Entity;
+use processing::prelude::*;
+use pyo3::exceptions::PyRuntimeError;
+use pyo3::prelude::*;
+use pyo3::types::PyAny;
+use std::cell::RefCell;
+
+use crate::glfw::GlfwContext;
+
+// The global graphics context
+// we use thread_local! to ensure that the context is specific to the current thread, particularly
+// becausae glfw requires that all window operations happen on the main thread.
+// TODO: we'll want to think about how to enable multi-window / multi-threaded usage in the future
+thread_local! {
+    static GRAPHICS_CTX: RefCell<Option<Py<Graphics>>> = const { RefCell::new(None) };
+}
+
+#[pyclass(unsendable)]
+pub struct Graphics {
+    // this makes our object !Send, hence unsendable above
+    glfw_ctx: GlfwContext,
+    surface: Entity,
+}
+
+#[pymethods]
+impl Graphics {
+    // TODO: in theory users can create multiple Graphics objects, which they manually manage themselves.
+    // right now we just support the single global window via the module-level functions.
+    #[new]
+    fn new(width: u32, height: u32) -> PyResult<Self> {
+        let glfw_ctx = GlfwContext::new(width, height)
+            .map_err(|e| PyRuntimeError::new_err(format!("Couold not create window {e}")))?;
+
+        init().map_err(|e| PyRuntimeError::new_err(format!("Failed to initialize processing {e}")))?;
+
+        let window_handle = glfw_ctx.get_window();
+        let display_handle = glfw_ctx.get_display();
+        let surface = surface_create(window_handle, display_handle, width, height, 1.0)
+            .map_err(|e| PyRuntimeError::new_err(format!("Could not create surface {e}")))?;
+
+        Ok(Self { glfw_ctx, surface })
+    }
+
+    pub fn background(&self, args: Vec<f32>) -> PyResult<()> {
+        let (r, g, b, a) = parse_color(&args)?;
+        let color = bevy::color::Color::srgba(r, g, b, a);
+        record_command(self.surface, DrawCommand::BackgroundColor(color))
+            .map_err(|e| PyRuntimeError::new_err(format!("background failed {e}")))
+    }
+
+    pub fn fill(&self, args: Vec<f32>) -> PyResult<()> {
+        let (r, g, b, a) = parse_color(&args)?;
+        let color = bevy::color::Color::srgba(r, g, b, a);
+        record_command(self.surface, DrawCommand::Fill(color))
+            .map_err(|e| PyRuntimeError::new_err(format!("fill failed {e}")))
+    }
+
+    pub fn no_fill(&self) -> PyResult<()> {
+        record_command(self.surface, DrawCommand::NoFill)
+            .map_err(|e| PyRuntimeError::new_err(format!("no_fill failed {e}")))
+    }
+
+    pub fn stroke(&self, args: Vec<f32>) -> PyResult<()> {
+        let (r, g, b, a) = parse_color(&args)?;
+        let color = bevy::color::Color::srgba(r, g, b, a);
+        record_command(self.surface, DrawCommand::StrokeColor(color))
+            .map_err(|e| PyRuntimeError::new_err(format!("stroke failed {e}")))
+    }
+
+    pub fn no_stroke(&self) -> PyResult<()> {
+        record_command(self.surface, DrawCommand::NoStroke)
+            .map_err(|e| PyRuntimeError::new_err(format!("no_stroke failed {e}")))
+    }
+
+    pub fn stroke_weight(&self, weight: f32) -> PyResult<()> {
+        record_command(self.surface, DrawCommand::StrokeWeight(weight))
+            .map_err(|e| PyRuntimeError::new_err(format!("stroke_weight failed {e}")))
+    }
+
+    pub fn rect(&self, x: f32, y: f32, w: f32, h: f32, tl: f32, tr: f32, br: f32, bl: f32) -> PyResult<()> {
+        record_command(
+            self.surface,
+            DrawCommand::Rect {
+                x,
+                y,
+                w,
+                h,
+                radii: [tl, tr, br, bl],
+            },
+        )
+        .map_err(|e| PyRuntimeError::new_err(format!("rect failed {e}")))
+    }
+
+    pub fn run(&mut self, draw_fn: Option<Py<PyAny>>) -> PyResult<()> {
+        loop {
+            let running = self.glfw_ctx.poll_events();
+            if !running {
+                break;
+            }
+
+            begin_draw(self.surface)
+                .map_err(|e| PyRuntimeError::new_err(format!("begin_draw failed {e}")))?;
+
+            if let Some(ref draw) = draw_fn {
+                Python::attach(|py| {
+                    draw.call0(py)
+                        .map_err(|e| PyRuntimeError::new_err(format!("draw failed {e}")))
+                })?;
+            }
+
+            end_draw(self.surface)
+                .map_err(|e| PyRuntimeError::new_err(format!("end_draw failed {e}")))?;
+        }
+
+        Ok(())
+    }
+}
+
+// TODO: a real color type. or color parser? idk. color is confusing. let's think
+// about how to expose different color spaces in an idiomatic pythonic way
+fn parse_color(args: &[f32]) -> PyResult<(f32, f32, f32, f32)> {
+    match args.len() {
+        4 => Ok((
+            args[0] / 255.0,
+            args[1] / 255.0,
+            args[2] / 255.0,
+            args[3] / 255.0,
+        )),
+        _ => Err(PyRuntimeError::new_err(
+            "Color requires 4 arguments",
+        )),
+    }
+}
+
+/// Run inside the current graphics context
+pub fn with_graphics<F, T>(f: F) -> PyResult<T>
+where
+    F: FnOnce(PyRef<'_, Graphics>) -> PyResult<T>,
+{
+    GRAPHICS_CTX.with(|cell| {
+        let opt = cell.borrow();
+        match opt.as_ref() {
+            Some(py_graphics) => Python::attach(|py| {
+                let graphics = py_graphics.bind(py).borrow();
+                f(graphics)
+            }),
+            None => Err(PyRuntimeError::new_err(
+                "No graphics context",
+            )),
+        }
+    })
+}
+
+/// Run inside the current graphics context with mutable access
+pub fn with_graphics_mut<F, T>(f: F) -> PyResult<T>
+where
+    F: FnOnce(PyRefMut<'_, Graphics>) -> PyResult<T>,
+{
+    GRAPHICS_CTX.with(|cell| {
+        let opt = cell.borrow();
+        match opt.as_ref() {
+            Some(py_graphics) => Python::attach(|py| {
+                let graphics = py_graphics.bind(py).borrow_mut();
+                f(graphics)
+            }),
+            None => Err(PyRuntimeError::new_err(
+                "No graphics context",
+            )),
+        }
+    })
+}
+
+/// Create the module level graphics context
+pub fn create_context(width: u32, height: u32) -> PyResult<()> {
+    let already_exists = GRAPHICS_CTX.with(|cell| cell.borrow().is_some());
+    if already_exists {
+        return Err(PyRuntimeError::new_err("A context already exists"));
+    }
+
+    Python::attach(|py| {
+        let graphics = Py::new(py, Graphics::new(width, height)?)?;
+        GRAPHICS_CTX.with(|cell| {
+            *cell.borrow_mut() = Some(graphics);
+        });
+        Ok(())
+    })
+}

crates/processing_pyo3/src/graphics.rs

@@ -1,40 +1,87 @@
+mod graphics;
 mod glfw;
+
 use pyo3::prelude::*;
+use crate::graphics::{with_graphics, with_graphics_mut};
 
 #[pymodule]
-mod processing {
-    use crate::glfw::GlfwContext;
-    use processing::prelude::*;
-    use pyo3::prelude::*;
-
-    /// create surface
-    #[pyfunction]
-    fn size(width: u32, height: u32) -> PyResult<String> {
-        let mut glfw_ctx = GlfwContext::new(400, 400).unwrap();
-        init().unwrap();
-
-        let window_handle = glfw_ctx.get_window();
-        let display_handle = glfw_ctx.get_display();
-        let surface = surface_create(window_handle, display_handle, width, height, 1.0).unwrap();
-
-        while glfw_ctx.poll_events() {
-            begin_draw(surface).unwrap();
-
-            record_command(
-                surface,
-                DrawCommand::Rect {
-                    x: 10.0,
-                    y: 10.0,
-                    w: 100.0,
-                    h: 100.0,
-                    radii: [0.0, 0.0, 0.0, 0.0],
-                },
-            )
-            .unwrap();
-
-            end_draw(surface).unwrap();
-        }
-
-        Ok("OK".to_string())
-    }
+fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<graphics::Graphics>()?;
+
+    // settings / lifecycle
+    m.add_function(wrap_pyfunction!(size, m)?)?;
+    m.add_function(wrap_pyfunction!(run, m)?)?;
+
+    // draw state
+    m.add_function(wrap_pyfunction!(background, m)?)?;
+    m.add_function(wrap_pyfunction!(fill, m)?)?;
+    m.add_function(wrap_pyfunction!(no_fill, m)?)?;
+    m.add_function(wrap_pyfunction!(stroke, m)?)?;
+    m.add_function(wrap_pyfunction!(no_stroke, m)?)?;
+    m.add_function(wrap_pyfunction!(stroke_weight, m)?)?;
+
+    // drawing prims
+    m.add_function(wrap_pyfunction!(rect, m)?)?;
+
+
+    Ok(())
+}
+
+// these are all our module-level functions
+//
+// in processing4 java, the sketch runs implicitly inside a class that extends PApplet and
+// executes main. here we have do a little magic trick to get similar behavior. if we required
+// users to create a Graphics object and call its methods, it would be ugly because we lack
+// an implicit receiver like 'this' in java. so instead we create a singleton Graphics object
+// behind the scenes and have these module-level functions forward to that object.
+
+#[pyfunction]
+fn size(width: u32, height: u32) -> PyResult<()> {
+    graphics::create_context(width, height)
+}
+
+#[pyfunction]
+#[pyo3(signature = (draw_fn=None))]
+fn run(draw_fn: Option<Py<PyAny>>) -> PyResult<()> {
+    with_graphics_mut(|mut g| g.run(draw_fn))
+}
+
+
+#[pyfunction]
+#[pyo3(signature = (*args))]
+fn background(args: Vec<f32>) -> PyResult<()> {
+    with_graphics(|g| g.background(args.to_vec()))
+}
+
+#[pyfunction]
+#[pyo3(signature = (*args))]
+fn fill(args: Vec<f32>) -> PyResult<()> {
+    with_graphics(|g| g.fill(args.to_vec()))
+}
+
+#[pyfunction]
+fn no_fill() -> PyResult<()> {
+    with_graphics(|g| g.no_fill())
+}
+
+#[pyfunction]
+#[pyo3(signature = (*args))]
+fn stroke(args: Vec<f32>) -> PyResult<()> {
+    with_graphics(|g| g.stroke(args.to_vec()))
+}
+
+#[pyfunction]
+fn no_stroke() -> PyResult<()> {
+    with_graphics(|g| g.no_stroke())
+}
+
+#[pyfunction]
+fn stroke_weight(weight: f32) -> PyResult<()> {
+    with_graphics(|g| g.stroke_weight(weight))
+}
+
+#[pyfunction]
+#[pyo3(signature = (x, y, w, h, tl=0.0, tr=0.0, br=0.0, bl=0.0))]
+fn rect(x: f32, y: f32, w: f32, h: f32, tl: f32, tr: f32, br: f32, bl: f32) -> PyResult<()> {
+    with_graphics(|g| g.rect(x, y, w, h, tl, tr, br, bl))
 }