Sketch reloading when running python

Author: catilac

crates/processing_pyo3/src/graphics.rs

@@ -61,6 +61,11 @@ impl Topology {
     }
 }
 
+#[pyclass]
+pub struct Sketch {
+    pub source: String,
+}
+
 #[pymethods]
 impl Geometry {
     #[new]
@@ -146,6 +151,21 @@ impl Graphics {
         })
     }
 
+    pub fn poll_for_sketch_update(&self) -> PyResult<Sketch> {
+        match poll_for_sketch_updates().map_err(|_| PyRuntimeError::new_err("SKETCH UPDATE ERR"))? {
+            Some(sketch) => Ok(Sketch {
+                source: sketch.source,
+            }),
+            None => Ok(Sketch {
+                source: "".to_string(),
+            }),
+        }
+
+        // Ok(Sketch {
+        //     source: sketch.unwrap().source,
+        // })
+    }
+
     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);

crates/processing_pyo3/src/lib.rs

@@ -12,7 +12,13 @@ mod glfw;
 mod graphics;
 
 use graphics::{Geometry, Graphics, Image, Topology, get_graphics, get_graphics_mut};
-use pyo3::{exceptions::PyRuntimeError, prelude::*, types::PyTuple};
+use pyo3::{
+    exceptions::PyRuntimeError,
+    ffi::c_str,
+    prelude::*,
+    types::{PyDict, PyTuple},
+};
+use std::ffi::{CStr, CString};
 
 use std::env;
 
@@ -81,8 +87,8 @@ fn run(module: &Bound<'_, PyModule>) -> PyResult<()> {
         let builtins = PyModule::import(py, "builtins")?;
         let locals = builtins.getattr("locals")?.call0()?;
 
-        let setup_fn = locals.get_item("setup")?;
-        let draw_fn = locals.get_item("draw")?;
+        let mut setup_fn = locals.get_item("setup")?;
+        let mut draw_fn = locals.get_item("draw")?;
 
         // call setup
         setup_fn.call0()?;
@@ -91,6 +97,30 @@ fn run(module: &Bound<'_, PyModule>) -> PyResult<()> {
         loop {
             {
                 let mut graphics = get_graphics_mut(module)?;
+
+                // TODO: this shouldn't be on the graphics object
+                let sketch = graphics.poll_for_sketch_update()?;
+                if !sketch.source.is_empty() {
+                    let locals = PyDict::new(py);
+
+                    let ok = CString::new(sketch.source.as_str()).unwrap();
+                    let cstr: &CStr = ok.as_c_str();
+
+                    match py.run(cstr, None, Some(&locals)) {
+                        Ok(_) => {
+                            dbg!("Success of any kind?");
+                        }
+                        Err(e) => {
+                            dbg!(e);
+                        }
+                    }
+
+                    setup_fn = locals.get_item("setup").unwrap().unwrap();
+                    draw_fn = locals.get_item("draw").unwrap().unwrap();
+
+                    dbg!(locals);
+                }
+
                 if !graphics.surface.poll_events() {
                     break;
                 }

crates/processing_render/src/lib.rs

@@ -1086,3 +1086,12 @@ pub fn geometry_box(width: f32, height: f32, depth: f32) -> error::Result<Entity
             .unwrap())
     })
 }
+
+pub fn poll_for_sketch_updates() -> error::Result<Option<sketch::Sketch>> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached(sketch::sketch_update_handler)
+            .unwrap())
+    })
+}

crates/processing_render/src/sketch.rs

@@ -19,17 +19,18 @@ impl Plugin for LivecodePlugin {
     fn build(&self, app: &mut App) {
         app.init_asset::<Sketch>()
             .init_asset_loader::<SketchLoader>()
+            // TODO: this could be switched to Message
             .insert_resource(SketchNeedsReload(false))
-            .add_systems(PreStartup, load_current_sketch)
-            .add_systems(Update, sketch_update_handler);
+            .add_systems(PreStartup, load_current_sketch);
+        // .add_systems(Update, sketch_update_handler);
     }
 }
 
 // TODO: A better name is possible
-fn sketch_update_handler(
+pub fn sketch_update_handler(
     mut events: MessageReader<AssetEvent<Sketch>>,
-    mut needs_reload: ResMut<SketchNeedsReload>,
-) {
+    sketches: Res<Assets<Sketch>>,
+) -> Option<Sketch> {
     for event in events.read() {
         match event {
             AssetEvent::Added { id } => {
@@ -38,7 +39,11 @@ fn sketch_update_handler(
             AssetEvent::Modified { id } => {
                 info!("Modified: {id}");
                 // we want to emit some event to bevy??
-                needs_reload.0 = true;
+                // needs_reload.0 = true;
+                if let Some(sketch) = sketches.get(*id) {
+                    let sketch = sketch.clone();
+                    return Some(sketch);
+                }
             }
             AssetEvent::Removed { id } => {
                 info!("Removed: {id}")
@@ -51,6 +56,8 @@ fn sketch_update_handler(
             }
         }
     }
+
+    None
 }
 
 fn load_current_sketch(mut commands: Commands, asset_server: Res<AssetServer>) {
@@ -70,9 +77,10 @@ pub struct SketchRoot(pub Handle<Sketch>);
 ///
 /// The `Sketch` asset contains the raw source code as a string. It does not interpret
 /// or execute the code — that responsibility belongs to language-specific crates.
-#[derive(Asset, TypePath, Debug)]
+#[derive(Asset, Clone, TypePath, Debug)]
 pub struct Sketch {
-    source: String,
+    // TODO: should this be &str ?
+    pub source: String,
 }
 
 /// Loads sketch files from disk.