rendering mesh

Author: catilac

crates/processing_pyo3/examples/animated_mesh.py

@@ -3,39 +3,49 @@
 mesh = None
 grid_size = 20 
 spacing = 10.0
+offset = (grid_size * spacing) / 2.0;
 
 def setup():
+    global mesh
     size(800, 600)
     mode_3d()
-    global mesh = geometry_create(TriangleList)
-
-def draw():
-    # TODO: maybe all of this should be in `setup()`
-    global grid_size
-
+    mesh = Mesh()
     for z in range(grid_size):
         for x in range(grid_size):
             px = x * spacing - offset
             pz = z * spacing - offset
-            geometry_color(mesh, x/grid_size, 0.5, z/grid_size, 1.0)
-            geometry_normal(mesh, 0.0,1.0,0.0)
-            geometry_vertex(mesh, px, 0.0, pz)
+            mesh.color(x/grid_size, 0.5, z/grid_size, 1.0)
+            mesh.normal(0.0, 1.0, 0.0)
+            mesh.vertex(px, 0.0, pz)
+
     for z in range(grid_size-1):
         for x in range(grid_size-1):
             tl = z * grid_size + x
             tr = tl + 1
             bl = (z + 1) * grid_size + x
             br = bl + 1
 
-            geometry_index(mesh, tl)
-            geometry_index(mesh, bl)
-            geometry_index(mesh, tr)
+            mesh.index(tl)
+            mesh.index(bl)
+            mesh.index(tr)
+
+            mesh.index(tr)
+            mesh.index(bl)
+            mesh.index(br)
+
+
+def draw():
+    global mesh
+    global grid_size
+    global offset
+    global spacing
+
+    camera_position(150.0, 150.0, 150.0)
+    camera_look_at( 0.0, 0.0, 0.0)
+    background(220, 200, 140)
 
-            geometry_index(mesh, tr)
-            geometry_index(mesh, bl)
-            geometry_index(mesh, br)
+    draw_mesh(mesh)
 
-        
 
 
 # TODO: this should happen implicitly on module load somehow

crates/processing_pyo3/examples/box.py

@@ -12,7 +12,6 @@ def draw():
     camera_look_at(0.0, 0.0, 0.0)
     background(220)
 
-
     push_matrix()
     rotate(angle)
     draw_box(100.0, 100.0, 100.0)

crates/processing_pyo3/src/graphics.rs

@@ -35,6 +35,38 @@ impl Drop for Image {
     }
 }
 
+#[pyclass(unsendable)]
+pub struct Mesh {
+    entity: Entity,
+}
+
+#[pymethods]
+impl Mesh {
+    #[new]
+    pub fn new() -> PyResult<Self> {
+        let geometry = geometry_create(geometry::Topology::TriangleList)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+        Ok(Self { entity: geometry })
+    }
+
+    pub fn color(&self, r: f32, g: f32, b: f32, a: f32) -> PyResult<()> {
+        geometry_color(self.entity, r, g, b, a).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn normal(&self, nx: f32, ny: f32, nz: f32) -> PyResult<()> {
+        geometry_normal(self.entity, nx, ny, nz)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn vertex(&self, x: f32, y: f32, z: f32) -> PyResult<()> {
+        geometry_vertex(self.entity, x, y, z).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
+    pub fn index(&self, i: u32) -> PyResult<()> {
+        geometry_index(self.entity, i).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+}
+
 #[pyclass(unsendable)]
 pub struct Graphics {
     entity: Entity,
@@ -179,6 +211,11 @@ impl Graphics {
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
     }
 
+    pub fn draw_mesh(&self, mesh: &Mesh) -> PyResult<()> {
+        graphics_record_command(self.entity, DrawCommand::Geometry(mesh.entity))
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
+
     pub fn scale(&self, x: f32, y: f32) -> PyResult<()> {
         graphics_record_command(self.entity, DrawCommand::Scale { x, y })
             .map_err(|e| PyRuntimeError::new_err(format!("{e}")))

crates/processing_pyo3/src/lib.rs

@@ -11,7 +11,7 @@
 mod glfw;
 mod graphics;
 
-use graphics::{Graphics, Image, get_graphics, get_graphics_mut};
+use graphics::{Graphics, Image, Mesh, get_graphics, get_graphics_mut};
 use pyo3::{exceptions::PyRuntimeError, prelude::*, types::PyTuple};
 
 use std::env;
@@ -20,6 +20,7 @@ use std::env;
 fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Graphics>()?;
     m.add_class::<Image>()?;
+    m.add_class::<Mesh>()?;
     m.add_function(wrap_pyfunction!(size, m)?)?;
     m.add_function(wrap_pyfunction!(run, m)?)?;
     m.add_function(wrap_pyfunction!(mode_3d, m)?)?;
@@ -37,6 +38,8 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(stroke_weight, m)?)?;
     m.add_function(wrap_pyfunction!(rect, m)?)?;
     m.add_function(wrap_pyfunction!(image, m)?)?;
+    m.add_function(wrap_pyfunction!(draw_mesh, m)?)?;
+
     Ok(())
 }
 
@@ -151,6 +154,12 @@ fn draw_box(module: &Bound<'_, PyModule>, x: f32, y: f32, z: f32) -> PyResult<()
     get_graphics(module)?.draw_box(x, y, z)
 }
 
+#[pyfunction]
+#[pyo3(pass_module, signature = (mesh))]
+fn draw_mesh(module: &Bound<'_, PyModule>, mesh: &Bound<'_, Mesh>) -> PyResult<()> {
+    get_graphics(module)?.draw_mesh(&*mesh.extract::<PyRef<Mesh>>()?)
+}
+
 #[pyfunction]
 #[pyo3(pass_module, signature = (*args))]
 fn background(module: &Bound<'_, PyModule>, args: &Bound<'_, PyTuple>) -> PyResult<()> {