python methods

Author: catilac

crates/processing_pyo3/examples/midi.py

@@ -18,8 +18,8 @@ def draw():
 
     # pick a random note value, and duration value for that note
     # then send the midi command
-    note = random.randit(57,68)
-    note_duration = random.randit(25, 250)
+    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

crates/processing_pyo3/src/lib.rs

@@ -12,18 +12,20 @@ mod glfw;
 mod gltf;
 mod graphics;
 pub(crate) mod material;
+mod midi;
 
 use graphics::{Geometry, Graphics, Image, Light, Topology, get_graphics, get_graphics_mut};
 use material::Material;
+
 use pyo3::{
     exceptions::PyRuntimeError,
     prelude::*,
     types::{PyDict, PyTuple},
 };
 use std::ffi::{CStr, CString};
 
-use gltf::Gltf;
 use bevy::log::warn;
+use gltf::Gltf;
 use std::env;
 
 /// Get a shared ref to the Graphics context, or return Ok(()) if not yet initialized.
@@ -78,6 +80,10 @@ 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_play_notes, m)?)?;
 
     Ok(())
 }
@@ -544,3 +550,24 @@ fn emissive(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult
 fn unlit(module: &Bound<'_, PyModule>) -> PyResult<()> {
     graphics!(module).unlit()
 }
+
+#[pyfunction]
+#[pyo3(pass_module)]
+fn midi_connect(module: &Bound<'_, PyModule>, port: usize) -> PyResult<()> {
+    midi::connect(port)
+}
+#[pyfunction]
+#[pyo3(pass_module)]
+fn midi_disconnect(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    midi::disconnect()
+}
+#[pyfunction]
+#[pyo3(pass_module)]
+fn midi_refresh_ports(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    midi::refresh_ports()
+}
+#[pyfunction]
+#[pyo3(pass_module)]
+fn midi_play_notes(module: &Bound<'_, PyModule>, note: u8, duration: u64) -> PyResult<()> {
+    midi::play_notes(note, duration)
+}

crates/processing_pyo3/src/midi.rs

@@ -0,0 +1,15 @@
+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 play_notes(note: u8, duration: u64) -> PyResult<()> {
+    midi_play_notes(note, duration).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+}

crates/processing_render/src/lib.rs

@@ -1409,6 +1409,14 @@ pub fn midi_connect(port: usize) -> error::Result<()> {
     })
 }
 
+#[cfg(not(target_arch = "wasm32"))]
+pub fn midi_disconnect() -> error::Result<()> {
+    app_mut(|app| {
+        let world = app.world_mut();
+        world.run_system_cached(midi::disconnect).unwrap()
+    })
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub fn midi_play_notes(note: u8, duration: u64) -> error::Result<()> {
     app_mut(|app| {

crates/processing_render/src/midi.rs

@@ -10,7 +10,7 @@ impl Plugin for MidiPlugin {
         // TODO: Update `bevy_midi` to treat connections as entities
         // in order to support hot-plugging
         app.insert_resource(MidiOutputSettings {
-            port_name: "output",
+            port_name: "libprocessing output",
         });
 
         app.add_plugins(MidiOutputPlugin);