Add rs example and polish sphere function

Author: Nitish-bot

Cargo.toml

@@ -64,6 +64,10 @@ path = "examples/animated_mesh.rs"
 name = "custom_attribute"
 path = "examples/custom_attribute.rs"
 
+[[example]]
+name = "particles"
+path = "examples/particles.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

crates/processing_pyo3/examples/particles.py

@@ -12,8 +12,8 @@ def setup():
 def draw():
     global geometry
 
-    camera_position(150.0, 150.0, 150.0)
-    camera_look_at( 0.0, 0.0, 0.0)
+    camera_position(100.0, 100.0, 300.0)
+    camera_look_at(0.0, 0.0, 0.0)
     background(220, 200, 140)
 
     draw_geometry(geometry)
@@ -23,15 +23,9 @@ def create_geometry():
 
     begin_geometry()
 
-    for i in range(60):        
-        x = gauss(400, 200)
-        y = gauss(350, 175)
-        z = gauss(0, 100)
-        
-        push_matrix()
-        translate_3d(x, y, z)
-        sphere(10)
-        pop_matrix()
+    push_matrix()
+    sphere(10)
+    pop_matrix()
 
     geometry = end_geometry()
 

crates/processing_render/src/geometry/mod.rs

@@ -385,10 +385,16 @@ pub fn begin(
         ]))
         .id();
 
-    let mesh = Mesh::new(
+    let mut mesh = Mesh::new(
         Topology::TriangleList.to_primitive_topology(),
         RenderAssetUsages::default(),
     );
+
+    mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, Vec::<[f32; 3]>::new());
+    mesh.insert_attribute(Mesh::ATTRIBUTE_NORMAL, Vec::<[f32; 3]>::new());
+    mesh.insert_attribute(Mesh::ATTRIBUTE_COLOR, Vec::<[f32; 4]>::new());
+    mesh.insert_attribute(Mesh::ATTRIBUTE_UV_0, Vec::<[f32; 2]>::new());
+
     let handle = meshes.add(mesh);
 
     let mut state = state_query
@@ -403,6 +409,7 @@ pub fn end(
     In(entity): In<Entity>,
     mut commands: Commands,
     mut state_query: Query<&mut RenderState>,
+    meshes: Res<Assets<Mesh>>,
 ) -> Result<Entity> {
     let geometry = state_query
         .get_mut(entity)
@@ -411,53 +418,94 @@ pub fn end(
         .take()
         .ok_or(ProcessingError::GeometryNotFound)?;
 
+    if let Some(mesh) = meshes.get(&geometry.handle) {
+        println!("End geometry: {} vertices, {} indices", 
+            mesh.count_vertices(),
+            mesh.indices().map(|i| i.len()).unwrap_or(0)
+        );
+    }
+
     Ok(commands.spawn(geometry).id())
 }
 
 pub fn sphere(
     In((entity, radius)): In<(Entity, f32)>,
     state_query: Query<&mut RenderState>,
+    layouts: Query<&VertexLayout>,
+    builtins: Res<BuiltinAttributes>,
     mut meshes: ResMut<Assets<Mesh>>,
 ) -> Result<()> {
-    let geometry = state_query
+    let state = state_query
         .get(entity)
-        .map_err(|_| ProcessingError::GraphicsNotFound)?
+        .map_err(|_| ProcessingError::GraphicsNotFound)?;
+    
+    let geometry = state
         .running_geometry
         .as_ref()
         .ok_or(ProcessingError::GeometryNotFound)?;
 
+    let layout = layouts
+        .get(geometry.layout)
+        .map_err(|_| ProcessingError::LayoutNotFound)?;
+
     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();
+    let vertex_count = sphere_mesh.count_vertices();
+
+    // Get current transformation matrix from render state
+    let transform = state.transform.current();
 
-    // Append positions
+    // Append positions with transformation applied
     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);
+        for pos in new_pos {
+            let transformed = transform.transform_point3(Vec3::from_array(*pos));
+            positions.push(transformed.to_array());
+        }
     }
 
-    // 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 normals with rotation applied (no translation/scale)
+    if layout.has_attribute(builtins.normal) {
+        if let Some(VertexAttributeValues::Float32x3(new_normals)) =
+            sphere_mesh.attribute(Mesh::ATTRIBUTE_NORMAL)
+            && let Some(VertexAttributeValues::Float32x3(normals)) =
+                mesh.attribute_mut(Mesh::ATTRIBUTE_NORMAL)
+        {
+            let normal_matrix = transform.matrix3;
+            for normal in new_normals {
+                let transformed = normal_matrix.mul_vec3(Vec3::from_array(*normal)).normalize();
+                normals.push(transformed.to_array());
+            }
+        }
     }
 
-    // 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 colors if in layout - fill with current color
+    if layout.has_attribute(builtins.color) {
+        if let Some(VertexAttributeValues::Float32x4(colors)) =
+            mesh.attribute_mut(Mesh::ATTRIBUTE_COLOR)
+        {
+            for _ in 0..vertex_count {
+                colors.push(geometry.current_color);
+            }
+        }
+    }
+
+    // Append UVs if in layout
+    if layout.has_attribute(builtins.uv) {
+        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
@@ -467,15 +515,27 @@ pub fn sphere(
         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));
+    if !new_indices.is_empty() {
+        match mesh.indices_mut() {
+            Some(Indices::U32(indices)) => {
+                indices.extend(new_indices);
+            }
+            None => {
+                mesh.insert_indices(Indices::U32(new_indices));
+            }
+            Some(Indices::U16(indices)) => {
+                if base_index + vertex_count as u32 > u16::MAX as u32 {
+                    // Need to upgrade to U32
+                    let existing: Vec<u32> = indices.iter().map(|&i| i as u32).collect();
+                    mesh.insert_indices(Indices::U32(
+                        existing.into_iter().chain(new_indices).collect()
+                    ));
+                } else {
+                    indices.extend(new_indices.iter().map(|&i| i as u16));
+                }
+            }
         }
     }
 
     Ok(())
-}
+}

examples/particles.rs

@@ -0,0 +1,54 @@
+mod glfw;
+
+use glfw::GlfwContext;
+use processing::prelude::*;
+use processing_render::{render::command::DrawCommand};
+
+fn main() {
+    match sketch() {
+        Ok(_) => {
+            eprintln!("Sketch completed successfully");
+            exit(0).unwrap();
+        }
+        Err(e) => {
+            eprintln!("Sketch error: {:?}", e);
+            exit(1).unwrap();
+        }
+    };
+}
+
+fn sketch() -> error::Result<()> {
+    let mut glfw_ctx = GlfwContext::new(400, 400)?;
+    init(Config::default())?;
+
+    let width = 400;
+    let height = 400;
+    let scale_factor = 1.0;
+
+    let surface = glfw_ctx.create_surface(width, height, scale_factor)?;
+    let graphics = graphics_create(surface, width, height)?;
+
+    graphics_mode_3d(graphics)?;
+    graphics_camera_position(graphics, 100.0, 100.0, 300.0)?;
+    graphics_camera_look_at(graphics, 0.0, 0.0, 0.0)?;
+
+    while glfw_ctx.poll_events() {
+        graphics_begin_draw(graphics)?;
+
+        graphics_record_command(
+            graphics,
+            DrawCommand::BackgroundColor(bevy::color::Color::srgb(0.1, 0.1, 0.15)),
+        )?;
+        
+        geometry_begin(graphics)?;
+        
+        graphics_record_command(graphics, DrawCommand::PushMatrix)?;
+        geometry_sphere(graphics, 10.)?;
+        graphics_record_command(graphics, DrawCommand::PopMatrix)?;
+        
+        let geometry = geometry_end(graphics)?;
+        graphics_record_command(graphics, DrawCommand::Geometry(geometry))?;
+        graphics_end_draw(graphics)?;
+    }
+    Ok(())
+}