Midi pt2 (#85)

Co-authored-by: charlotte 🌸 <charlotte.c.mcelwain@gmail.com>

Author: catilac

Cargo.lock

@@ -49,6 +49,7 @@ web-sys = { version = "0.3", features = ["Window"] }
 
 [dev-dependencies]
 glfw = "0.60.0"
+rand = "0.10.0"
 
 [target.'cfg(target_os = "linux")'.dev-dependencies]
 glfw = { version = "0.60.0", features = ["wayland"] }

Cargo.toml

@@ -42,4 +42,6 @@ pub enum ProcessingError {
     ShaderCompilationError(String),
     #[error("Shader not found")]
     ShaderNotFound,
+    #[error("MIDI port {0} not found")]
+    MidiPortNotFound(usize),
 }

crates/processing_core/src/error.rs

@@ -5,8 +5,8 @@ edition = "2024"
 
 [dependencies]
 bevy = { workspace = true }
+processing_core = { workspace = true }
 bevy_midi = { git = "https://github.com/BlackPhlox/bevy_midi", branch = "latest" }
 
-
 [lints]
 workspace = true

crates/processing_midi/Cargo.toml

@@ -1,23 +1,109 @@
 use bevy::prelude::*;
 use bevy_midi::prelude::*;
 
+use processing_core::app_mut;
+use processing_core::error::{self, Result};
+
 pub struct MidiPlugin;
 
+pub const NOTE_ON: u8 = 0b1001_0000;
+pub const NOTE_OFF: u8 = 0b1000_0000;
+
 impl Plugin for MidiPlugin {
     fn build(&self, app: &mut App) {
+        // TODO: Update `bevy_midi` to treat connections as entities
+        // in order to support hot-plugging
         app.insert_resource(MidiOutputSettings {
-            port_name: "output",
-        })
-        .add_plugins(MidiOutputPlugin);
+            port_name: "libprocessing output",
+        });
+
+        app.add_plugins(MidiOutputPlugin);
+    }
+}
+
+pub fn connect(In(port): In<usize>, output: Res<MidiOutput>) -> Result<()> {
+    match output.ports().get(port) {
+        Some((_, p)) => {
+            output.connect(p.clone());
+            Ok(())
+        }
+        None => Err(error::ProcessingError::MidiPortNotFound(port)),
     }
 }
 
-pub fn connect(_port: usize) {
-    // we need to work with the ECS
-    // do we pass a MidiCommand to Bevy?
+pub fn disconnect(output: Res<MidiOutput>) -> Result<()> {
+    output.disconnect();
+    Ok(())
 }
 
-pub fn disconnect() {}
-pub fn refresh_ports() {}
+pub fn refresh_ports(output: Res<MidiOutput>) -> Result<()> {
+    output.refresh_ports();
+    Ok(())
+}
+
+pub fn list_ports(output: Res<MidiOutput>) -> Result<Vec<String>> {
+    Ok(output
+        .ports()
+        .iter()
+        .enumerate()
+        .map(|(i, (name, _))| format!("{}: {}", i, name))
+        .collect())
+}
+
+pub fn play_notes(In((note, duration)): In<(u8, u64)>, output: Res<MidiOutput>) -> Result<()> {
+    output.send([NOTE_ON, note, 127].into()); // Note on, channel 1, max velocity
+
+    std::thread::sleep(std::time::Duration::from_millis(duration));
+
+    output.send([NOTE_OFF, note, 127].into()); // Note off, channel 1, max velocity
 
-pub fn play_notes() {}
+    Ok(())
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_refresh_ports() -> error::Result<()> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world.run_system_cached(refresh_ports).unwrap()
+    })?;
+    // run the `PreUpdate` schedule to let `bevy_midi` process it's callbacks and update the ports list
+    // TODO: race condition is still present here in theory
+    app_mut(|app| {
+        app.world_mut().run_schedule(PreUpdate);
+        Ok(())
+    })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_list_ports() -> error::Result<Vec<String>> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world.run_system_cached(list_ports).unwrap()
+    })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_connect(port: usize) -> error::Result<()> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world.run_system_cached_with(connect, port).unwrap()
+    })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_disconnect() -> error::Result<()> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world.run_system_cached(disconnect).unwrap()
+    })
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_play_notes(note: u8, duration: u64) -> error::Result<()> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world
+            .run_system_cached_with(play_notes, (note, duration))
+            .unwrap()
+    })
+}

crates/processing_midi/src/lib.rs

@@ -0,0 +1,28 @@
+from processing import *
+import random
+
+def setup():
+    size(800, 600)
+
+    # Refresh midi port list, print available ports, and connect to first one
+    midi_refresh_ports()
+    for port in midi_list_ports():
+        print(port)
+    midi_connect(0)
+
+def draw():
+    background(220)
+
+    fill(255, 0, 100)
+    stroke(1)
+    stroke_weight(2)
+    rect(100, 100, 200, 150)
+
+    # pick a random note value, and duration value for that note
+    # then send the midi command
+    note = random.randint(57,68)
+    note_duration = random.randint(25, 250)
+    midi_play_notes(note, note_duration)
+
+# TODO: this should happen implicitly on module load somehow
+run()

crates/processing_pyo3/examples/midi.py

@@ -12,12 +12,14 @@ mod glfw;
 mod gltf;
 mod graphics;
 pub(crate) mod material;
+mod midi;
 pub(crate) mod shader;
 #[cfg(feature = "webcam")]
 mod webcam;
 
 use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
 use material::Material;
+
 use pyo3::{
     exceptions::PyRuntimeError,
     prelude::*,
@@ -94,6 +96,11 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(metallic, m)?)?;
     m.add_function(wrap_pyfunction!(emissive, m)?)?;
     m.add_function(wrap_pyfunction!(unlit, m)?)?;
+    m.add_function(wrap_pyfunction!(midi_connect, m)?)?;
+    m.add_function(wrap_pyfunction!(midi_disconnect, m)?)?;
+    m.add_function(wrap_pyfunction!(midi_refresh_ports, m)?)?;
+    m.add_function(wrap_pyfunction!(midi_list_ports, m)?)?;
+    m.add_function(wrap_pyfunction!(midi_play_notes, m)?)?;
 
     #[cfg(feature = "webcam")]
     {
@@ -589,3 +596,24 @@ fn create_webcam(
 ) -> PyResult<webcam::Webcam> {
     webcam::Webcam::new(width, height, framerate)
 }
+
+#[pyfunction]
+fn midi_connect(port: usize) -> PyResult<()> {
+    midi::connect(port)
+}
+#[pyfunction]
+fn midi_disconnect() -> PyResult<()> {
+    midi::disconnect()
+}
+#[pyfunction]
+fn midi_refresh_ports() -> PyResult<()> {
+    midi::refresh_ports()
+}
+#[pyfunction]
+fn midi_list_ports() -> PyResult<Vec<String>> {
+    midi::list_ports()
+}
+#[pyfunction]
+fn midi_play_notes(note: u8, duration: u64) -> PyResult<()> {
+    midi::play_notes(note, duration)
+}

crates/processing_pyo3/src/lib.rs

@@ -0,0 +1,18 @@
+use processing::prelude::*;
+use pyo3::{exceptions::PyRuntimeError, prelude::*};
+
+pub fn connect(port: usize) -> PyResult<()> {
+    midi_connect(port).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}
+pub fn disconnect() -> PyResult<()> {
+    midi_disconnect().map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}
+pub fn refresh_ports() -> PyResult<()> {
+    midi_refresh_ports().map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}
+pub fn list_ports() -> PyResult<Vec<String>> {
+    midi_list_ports().map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}
+pub fn play_notes(note: u8, duration: u64) -> PyResult<()> {
+    midi_play_notes(note, duration).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}

crates/processing_pyo3/src/midi.rs

@@ -21,6 +21,7 @@ raw-window-handle = "0.6"
 half = "2.7"
 crossbeam-channel = "0.5"
 processing_core = { workspace = true }
+processing_midi = { workspace = true }
 
 [build-dependencies]
 wesl = { workspace = true, features = ["package"] }

crates/processing_render/Cargo.toml

@@ -46,13 +46,11 @@ impl Plugin for ProcessingRenderPlugin {
         let has_sketch_file = config
             .get(ConfigKey::SketchFileName)
             .is_some_and(|f| !f.is_empty());
-        if has_sketch_file {
-            if let Some(sketch_path) = config.get(ConfigKey::SketchRootPath) {
-                app.register_asset_source(
-                    "sketch_directory",
-                    AssetSourceBuilder::platform_default(sketch_path, None),
-                );
-            }
+        if has_sketch_file && let Some(sketch_path) = config.get(ConfigKey::SketchRootPath) {
+            app.register_asset_source(
+                "sketch_directory",
+                AssetSourceBuilder::platform_default(sketch_path, None),
+            );
         }
 
         if has_sketch_file {