Add immediate mode example.

Author: tychedelia

Cargo.toml

@@ -72,6 +72,10 @@ path = "examples/lights.rs"
 name = "materials"
 path = "examples/materials.rs"
 
+[[example]]
+name = "pbr"
+path = "examples/pbr.rs"
+
 [profile.wasm-release]
 inherits = "release"
 opt-level = "z"

crates/processing_render/src/lib.rs

@@ -22,8 +22,8 @@ use bevy::{
     prelude::*,
     render::render_resource::{Extent3d, TextureFormat},
 };
-use render::{activate_cameras, clear_transient_meshes, flush_draw_commands};
 use render::material::add_standard_materials;
+use render::{activate_cameras, clear_transient_meshes, flush_draw_commands};
 use tracing::debug;
 
 use crate::geometry::{AttributeFormat, AttributeValue};

crates/processing_render/src/render/command.rs

@@ -42,6 +42,16 @@ pub enum DrawCommand {
     },
     Geometry(Entity),
     Material(Entity),
+    Box {
+        width: f32,
+        height: f32,
+        depth: f32,
+    },
+    Sphere {
+        radius: f32,
+        sectors: u32,
+        stacks: u32,
+    },
 }
 
 #[derive(Debug, Default, Component)]

crates/processing_render/src/render/material.rs

@@ -82,10 +82,7 @@ impl MaterialKey {
 
 /// A system that adds a `MeshMaterial3d` component to any entity with an `UntypedMaterial` that can
 /// be typed as a `StandardMaterial`.
-pub fn add_standard_materials(
-    mut commands: Commands,
-    meshes: Query<(Entity, &UntypedMaterial)>,
-) {
+pub fn add_standard_materials(mut commands: Commands, meshes: Query<(Entity, &UntypedMaterial)>) {
     for (entity, handle) in meshes.iter() {
         let handle = handle.deref().clone();
         if let Ok(handle) = handle.try_typed::<StandardMaterial>() {

crates/processing_render/src/render/mod.rs

@@ -12,7 +12,7 @@ use bevy::{
 };
 use command::{CommandBuffer, DrawCommand};
 use material::MaterialKey;
-use primitive::{TessellationMode, empty_mesh};
+use primitive::{TessellationMode, box_mesh, empty_mesh, sphere_mesh};
 use transform::TransformStack;
 
 use crate::{
@@ -124,14 +124,8 @@ pub fn flush_draw_commands(
     p_geometries: Query<&Geometry>,
     p_material_handles: Query<&UntypedMaterial>,
 ) {
-    for (
-        graphics_entity,
-        mut cmd_buffer,
-        mut state,
-        render_layers,
-        projection,
-        camera_transform,
-    ) in graphics.iter_mut()
+    for (graphics_entity, mut cmd_buffer, mut state, render_layers, projection, camera_transform) in
+        graphics.iter_mut()
     {
         let clip_from_view = projection.get_clip_from_view();
         let view_from_world = camera_transform.to_matrix().inverse();
@@ -162,9 +156,17 @@ pub fn flush_draw_commands(
                 }
                 DrawCommand::Roughness(r) => {
                     state.material_key = match state.material_key {
-                        MaterialKey::Pbr { albedo, metallic, emissive, .. } => {
-                            MaterialKey::Pbr { albedo, roughness: (r * 255.0) as u8, metallic, emissive }
-                        }
+                        MaterialKey::Pbr {
+                            albedo,
+                            metallic,
+                            emissive,
+                            ..
+                        } => MaterialKey::Pbr {
+                            albedo,
+                            roughness: (r * 255.0) as u8,
+                            metallic,
+                            emissive,
+                        },
                         _ => MaterialKey::Pbr {
                             albedo: [255, 255, 255, 255],
                             roughness: (r * 255.0) as u8,
@@ -175,9 +177,17 @@ pub fn flush_draw_commands(
                 }
                 DrawCommand::Metallic(m) => {
                     state.material_key = match state.material_key {
-                        MaterialKey::Pbr { albedo, roughness, emissive, .. } => {
-                            MaterialKey::Pbr { albedo, roughness, metallic: (m * 255.0) as u8, emissive }
-                        }
+                        MaterialKey::Pbr {
+                            albedo,
+                            roughness,
+                            emissive,
+                            ..
+                        } => MaterialKey::Pbr {
+                            albedo,
+                            roughness,
+                            metallic: (m * 255.0) as u8,
+                            emissive,
+                        },
                         _ => MaterialKey::Pbr {
                             albedo: [255, 255, 255, 255],
                             roughness: 128,
@@ -189,9 +199,17 @@ pub fn flush_draw_commands(
                 DrawCommand::Emissive(color) => {
                     let [r, g, b, a] = color.to_srgba().to_u8_array();
                     state.material_key = match state.material_key {
-                        MaterialKey::Pbr { albedo, roughness, metallic, .. } => {
-                            MaterialKey::Pbr { albedo, roughness, metallic, emissive: [r, g, b, a] }
-                        }
+                        MaterialKey::Pbr {
+                            albedo,
+                            roughness,
+                            metallic,
+                            ..
+                        } => MaterialKey::Pbr {
+                            albedo,
+                            roughness,
+                            metallic,
+                            emissive: [r, g, b, a],
+                        },
                         _ => MaterialKey::Pbr {
                             albedo: [255, 255, 255, 255],
                             roughness: 128,
@@ -287,8 +305,12 @@ pub fn flush_draw_commands(
                         continue;
                     };
 
-                    let Some(mat_handle) = p_material_handles.get(batch.active_material).ok() else {
-                        warn!("Could not find material for entity {:?}", batch.active_material);
+                    let Some(mat_handle) = p_material_handles.get(batch.active_material).ok()
+                    else {
+                        warn!(
+                            "Could not find material for entity {:?}",
+                            batch.active_material
+                        );
                         continue;
                     };
 
@@ -313,6 +335,25 @@ pub fn flush_draw_commands(
                     batch.active_material = entity;
                     flush_batch(&mut res, &mut batch);
                 }
+                DrawCommand::Box {
+                    width,
+                    height,
+                    depth,
+                } => {
+                    add_shape3d(&mut res, &mut batch, &state, box_mesh(width, height, depth));
+                }
+                DrawCommand::Sphere {
+                    radius,
+                    sectors,
+                    stacks,
+                } => {
+                    add_shape3d(
+                        &mut res,
+                        &mut batch,
+                        &state,
+                        sphere_mesh(radius, sectors, stacks),
+                    );
+                }
             }
         }
 
@@ -382,11 +423,18 @@ fn start_batch(
 
 fn material_key_with_color(key: &MaterialKey, color: Color) -> MaterialKey {
     match key {
-        MaterialKey::Color { background_image, .. } => MaterialKey::Color {
+        MaterialKey::Color {
+            background_image, ..
+        } => MaterialKey::Color {
             transparent: color.alpha() < 1.0,
             background_image: background_image.clone(),
         },
-        MaterialKey::Pbr { roughness, metallic, emissive, .. } => {
+        MaterialKey::Pbr {
+            roughness,
+            metallic,
+            emissive,
+            ..
+        } => {
             let [r, g, b, a] = color.to_srgba().to_u8_array();
             MaterialKey::Pbr {
                 albedo: [r, g, b, a],
@@ -399,6 +447,11 @@ fn material_key_with_color(key: &MaterialKey, color: Color) -> MaterialKey {
     }
 }
 
+fn material_key_with_fill(state: &RenderState) -> MaterialKey {
+    let color = state.fill_color.unwrap_or(Color::WHITE);
+    material_key_with_color(&state.material_key, color)
+}
+
 fn add_fill(
     res: &mut RenderResources,
     batch: &mut BatchState,
@@ -449,6 +502,28 @@ fn flush_batch(res: &mut RenderResources, batch: &mut BatchState) {
     batch.material_key = None;
 }
 
+fn add_shape3d(res: &mut RenderResources, batch: &mut BatchState, state: &RenderState, mesh: Mesh) {
+    flush_batch(res, batch);
+
+    let mesh_handle = res.meshes.add(mesh);
+    let material_key = material_key_with_fill(state);
+    let material_handle = material_key.to_material(&mut res.materials);
+
+    let z_offset = -(batch.draw_index as f32 * 0.001);
+    let mut transform = state.transform.to_bevy_transform();
+    transform.translation.z += z_offset;
+
+    res.commands.spawn((
+        Mesh3d(mesh_handle),
+        UntypedMaterial(material_handle),
+        BelongsToGraphics(batch.graphics_entity),
+        transform,
+        batch.render_layers.clone(),
+    ));
+
+    batch.draw_index += 1;
+}
+
 /// Creates a fullscreen quad by transforming NDC fullscreen by inverse of the clip-from-world matrix
 /// so that when the vertex shader applies clip_from_world, the vertices end up correctly back in
 /// NDC space.

crates/processing_render/src/render/primitive/mod.rs

@@ -1,4 +1,5 @@
 mod rect;
+mod shape3d;
 
 use bevy::{
     asset::RenderAssetUsages,
@@ -12,6 +13,7 @@ use lyon::{
     },
 };
 pub use rect::rect;
+pub use shape3d::{box_mesh, sphere_mesh};
 
 use super::mesh_builder::MeshBuilder;
 

crates/processing_render/src/render/primitive/shape3d.rs

@@ -0,0 +1,11 @@
+use bevy::prelude::*;
+
+pub fn box_mesh(width: f32, height: f32, depth: f32) -> Mesh {
+    let cuboid = bevy::math::primitives::Cuboid::new(width, height, depth);
+    Mesh::from(cuboid)
+}
+
+pub fn sphere_mesh(radius: f32, sectors: u32, stacks: u32) -> Mesh {
+    let sphere = bevy::math::primitives::Sphere::new(radius);
+    sphere.mesh().uv(sectors, stacks)
+}

examples/materials.rs

@@ -36,13 +36,8 @@ fn sketch() -> error::Result<()> {
     transform_set_position(dir_light, 300.0, 400.0, 300.0)?;
     transform_look_at(dir_light, 0.0, 0.0, 0.0)?;
 
-    let point_light = light_create_point(
-        graphics,
-        bevy::color::Color::WHITE,
-        100_000.0,
-        800.0,
-        0.0,
-    )?;
+    let point_light =
+        light_create_point(graphics, bevy::color::Color::WHITE, 100_000.0, 800.0, 0.0)?;
     transform_set_position(point_light, 200.0, 200.0, 400.0)?;
 
     // Grid of materials varying roughness (x) and metallic (y)

examples/pbr.rs

@@ -0,0 +1,91 @@
+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 width = 800;
+    let height = 600;
+    let mut glfw_ctx = GlfwContext::new(width, height)?;
+    init(Config::default())?;
+
+    let surface = glfw_ctx.create_surface(width, height, 1.0)?;
+    let graphics = graphics_create(surface, width, height)?;
+
+    graphics_mode_3d(graphics)?;
+    transform_set_position(graphics, 0.0, 0.0, 600.0)?;
+    transform_look_at(graphics, 0.0, 0.0, 0.0)?;
+
+    let dir_light =
+        light_create_directional(graphics, bevy::color::Color::srgb(1.0, 0.98, 0.95), 1_500.0)?;
+    transform_set_position(dir_light, 300.0, 400.0, 300.0)?;
+    transform_look_at(dir_light, 0.0, 0.0, 0.0)?;
+
+    let point_light =
+        light_create_point(graphics, bevy::color::Color::WHITE, 100_000.0, 800.0, 0.0)?;
+    transform_set_position(point_light, 200.0, 200.0, 400.0)?;
+
+    let cols = 11;
+    let rows = 5;
+    let base_color = bevy::color::Color::srgb(1.0, 0.85, 0.57);
+    let spacing = 70.0;
+    let offset_x = (cols - 1) as f32 * spacing / 2.0;
+    let offset_y = (rows - 1) as f32 * spacing / 2.0;
+
+    while glfw_ctx.poll_events() {
+        graphics_begin_draw(graphics)?;
+
+        graphics_record_command(
+            graphics,
+            DrawCommand::BackgroundColor(bevy::color::Color::srgb(0.05, 0.05, 0.07)),
+        )?;
+
+        graphics_record_command(graphics, DrawCommand::Fill(base_color))?;
+
+        for row in 0..rows {
+            for col in 0..cols {
+                let roughness = col as f32 / (cols - 1) as f32;
+                let metallic = row as f32 / (rows - 1) as f32;
+
+                graphics_record_command(graphics, DrawCommand::Roughness(roughness))?;
+                graphics_record_command(graphics, DrawCommand::Metallic(metallic))?;
+
+                graphics_record_command(graphics, DrawCommand::PushMatrix)?;
+                graphics_record_command(
+                    graphics,
+                    DrawCommand::Translate {
+                        x: col as f32 * spacing - offset_x,
+                        y: row as f32 * spacing - offset_y,
+                    },
+                )?;
+                graphics_record_command(
+                    graphics,
+                    DrawCommand::Sphere {
+                        radius: 30.0,
+                        sectors: 32,
+                        stacks: 18,
+                    },
+                )?;
+                graphics_record_command(graphics, DrawCommand::PopMatrix)?;
+            }
+        }
+
+        graphics_end_draw(graphics)?;
+    }
+
+    Ok(())
+}