add a sphere function to geometry

Author: Nitish-bot

crates/processing_pyo3/examples/particles.py

@@ -21,19 +21,19 @@ def draw():
 def create_geometry():
     global geometry
 
-    beginGeometry()
+    begin_geometry()
 
     for i in range(60):        
         x = gauss(400, 200)
         y = gauss(350, 175)
         z = gauss(0, 100)
 
         push_matrix()
-        translate(x, y, z)
+        translate_3d(x, y, z)
         sphere(10)
         pop_matrix()
 
-    geometry = endGeometry()
+    geometry = end_geometry()
 
 # TODO: this should happen implicitly on module load somehow
 run()

crates/processing_pyo3/src/graphics.rs

@@ -324,6 +324,10 @@ impl Graphics {
             Err(e) => Err(PyRuntimeError::new_err(format!("{e}"))),
         }
     }
+
+    pub fn sphere(&self, radius: f32) -> PyResult<()> {
+        geometry_sphere(self.entity, radius).map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
 }
 
 // TODO: a real color type. or color parser? idk. color is confusing. let's think

crates/processing_pyo3/src/lib.rs

@@ -44,6 +44,7 @@ fn processing(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(draw_geometry, m)?)?;
     m.add_function(wrap_pyfunction!(begin_geometry, m)?)?;
     m.add_function(wrap_pyfunction!(end_geometry, m)?)?;
+    m.add_function(wrap_pyfunction!(sphere, m)?)?;
 
     Ok(())
 }
@@ -251,3 +252,9 @@ fn begin_geometry(module: &Bound<'_, PyModule>) -> PyResult<()> {
 fn end_geometry(module: &Bound<'_, PyModule>) -> PyResult<Geometry> {
     get_graphics(module)?.end_geometry()
 }
+
+#[pyfunction]
+#[pyo3(pass_module, signature = (radius))]
+fn sphere(module: &Bound<'_, PyModule>, radius: f32) -> PyResult<()> {
+    get_graphics(module)?.sphere(radius)
+}

crates/processing_render/src/geometry/mod.rs

@@ -370,7 +370,7 @@ pub fn destroy(
 }
 
 pub fn begin(
-    In(graphics_entity): In<Entity>,
+    In(entity): In<Entity>,
     mut commands: Commands,
     mut state_query: Query<&mut RenderState>,
     mut meshes: ResMut<Assets<Mesh>>,
@@ -392,24 +392,90 @@ pub fn begin(
     let handle = meshes.add(mesh);
 
     let mut state = state_query
-        .get_mut(graphics_entity)
+        .get_mut(entity)
         .map_err(|_| ProcessingError::GraphicsNotFound)?;
 
     state.running_geometry = Some(Geometry::new(handle, layout_entity));
     Ok(())
 }
 
 pub fn end(
-    In(graphics_entity): In<Entity>,
+    In(entity): In<Entity>,
     mut commands: Commands,
     mut state_query: Query<&mut RenderState>,
 ) -> Result<Entity> {
     let geometry = state_query
-        .get_mut(graphics_entity)
+        .get_mut(entity)
         .map_err(|_| ProcessingError::GraphicsNotFound)?
         .running_geometry
         .take()
         .ok_or(ProcessingError::GeometryNotFound)?;
 
     Ok(commands.spawn(geometry).id())
 }
+
+pub fn sphere(
+    In((entity, radius)): In<(Entity, f32)>,
+    state_query: Query<&mut RenderState>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) -> Result<()> {
+    let geometry = state_query
+        .get(entity)
+        .map_err(|_| ProcessingError::GraphicsNotFound)?
+        .running_geometry
+        .as_ref()
+        .ok_or(ProcessingError::GeometryNotFound)?;
+
+    let mesh = meshes
+        .get_mut(&geometry.handle)
+        .ok_or(ProcessingError::GeometryNotFound)?;
+
+    let base_index = mesh.count_vertices() as u32;
+    let sphere_mesh = Sphere::new(radius).mesh().build();
+
+    // Append positions
+    if let Some(VertexAttributeValues::Float32x3(new_pos)) =
+        sphere_mesh.attribute(Mesh::ATTRIBUTE_POSITION)
+        && let Some(VertexAttributeValues::Float32x3(positions)) =
+            mesh.attribute_mut(Mesh::ATTRIBUTE_POSITION)
+    {
+        positions.extend_from_slice(new_pos);
+    }
+
+    // Append normals
+    if let Some(VertexAttributeValues::Float32x3(new_normals)) =
+        sphere_mesh.attribute(Mesh::ATTRIBUTE_NORMAL)
+        && let Some(VertexAttributeValues::Float32x3(normals)) =
+            mesh.attribute_mut(Mesh::ATTRIBUTE_NORMAL)
+    {
+        normals.extend_from_slice(new_normals);
+    }
+
+    // Append UVs
+    if let Some(VertexAttributeValues::Float32x2(new_uvs)) =
+        sphere_mesh.attribute(Mesh::ATTRIBUTE_UV_0)
+        && let Some(VertexAttributeValues::Float32x2(uvs)) =
+            mesh.attribute_mut(Mesh::ATTRIBUTE_UV_0)
+    {
+        uvs.extend_from_slice(new_uvs);
+    }
+
+    // Append indices with offset
+    let new_indices: Vec<u32> = match sphere_mesh.indices() {
+        Some(Indices::U16(vec)) => vec.iter().map(|&i| i as u32 + base_index).collect(),
+        Some(Indices::U32(vec)) => vec.iter().map(|&i| i + base_index).collect(),
+        None => Vec::new(),
+    };
+
+    match mesh.indices_mut() {
+        Some(Indices::U32(indices)) => indices.extend(new_indices),
+        Some(Indices::U16(indices)) => {
+            indices.extend(new_indices.iter().map(|&i| i as u16));
+        }
+        None => {
+            mesh.insert_indices(Indices::U32(new_indices));
+        }
+    }
+
+    Ok(())
+}

crates/processing_render/src/lib.rs

@@ -1087,3 +1087,11 @@ pub fn geometry_end(graphics_entity: Entity) -> error::Result<Entity> {
             .unwrap()
     })
 }
+
+pub fn geometry_sphere(graphics_entity: Entity, radius: f32) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(geometry::sphere, (graphics_entity, radius))
+            .unwrap()
+    })
+}