WIP - instantiate lights in setup. no draw

Author: catilac

crates/processing_render/src/lib.rs

@@ -3,6 +3,7 @@ pub mod error;
 pub mod geometry;
 mod graphics;
 pub mod image;
+pub mod light;
 pub mod render;
 mod surface;
 pub mod transform;
@@ -25,7 +26,10 @@ use tracing::debug;
 use crate::geometry::{AttributeFormat, AttributeValue};
 use crate::graphics::flush;
 use crate::{
-    graphics::GraphicsPlugin, image::ImagePlugin, render::command::DrawCommand,
+    graphics::GraphicsPlugin,
+    image::ImagePlugin,
+    light::{LightPlugin, LightType},
+    render::command::DrawCommand,
     surface::SurfacePlugin,
 };
 
@@ -248,6 +252,7 @@ fn create_app(config: Config) -> App {
         GraphicsPlugin,
         SurfacePlugin,
         geometry::GeometryPlugin,
+        LightPlugin,
     ));
     app.add_systems(First, (clear_transient_meshes, activate_cameras))
         .add_systems(Update, flush_draw_commands.before(AssetEventSystems));
@@ -774,6 +779,16 @@ pub fn image_destroy(entity: Entity) -> error::Result<()> {
     })
 }
 
+// pub fn geometry_box(width: f32, height: f32, depth: f32) -> error::Result<Entity> {
+pub fn light_create(light_type: LightType, x: f32, y: f32, z: f32) -> error::Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(light::create, (light_type, x, y, z))
+            .unwrap())
+    })
+}
+
 pub fn geometry_layout_create() -> error::Result<Entity> {
     app_mut(|app| {
         Ok(app

crates/processing_render/src/light.rs

@@ -0,0 +1,42 @@
+//! A light in Processing
+//!
+
+use bevy::prelude::*;
+
+pub struct LightPlugin;
+
+impl Plugin for LightPlugin {
+    fn build(&self, _app: &mut App) {}
+}
+
+#[derive(Component)]
+pub struct Light {
+    pub light_type: LightType,
+    pub pos: Vec3,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum LightType {
+    Ambient,
+    Directional,
+    Point,
+    Spot,
+}
+
+pub fn create(
+    In((light_type, x, y, z)): In<(LightType, f32, f32, f32)>,
+    mut commands: Commands,
+) -> Entity {
+    // let light = Light {
+    //     light_type: light_type,
+    //     pos: Vec3::new(x, y, z),
+    // };
+    // commands.spawn(light).id()
+
+    match light_type {
+        LightType::Directional => commands
+            .spawn((DirectionalLight::default(), Transform::from_xyz(x, y, z)))
+            .id(),
+        _ => commands.spawn(AmbientLight::default()).id(),
+    }
+}

crates/processing_render/src/render/command.rs

@@ -37,7 +37,7 @@ pub enum DrawCommand {
         angle: f32,
     },
     Geometry(Entity),
-    Light(Entity),
+    // Light(Entity),
 }
 
 #[derive(Debug, Default, Component)]

crates/processing_render/src/render/mod.rs

@@ -102,6 +102,7 @@ pub fn flush_draw_commands(
     >,
     p_images: Query<&Image>,
     p_geometries: Query<&Geometry>,
+    // p_lights: Query<&Light>,
 ) {
     for (graphics_entity, mut cmd_buffer, mut state, render_layers, projection, camera_transform) in
         graphics.iter_mut()
@@ -234,7 +235,25 @@ pub fn flush_draw_commands(
                     ));
 
                     batch.draw_index += 1;
-                }
+                } // DrawCommand::Light(entity) => {
+                  //     let Some(light) = p_lights.get(entity).ok() else {
+                  //         warn!("Could not find Light for entity {:?}", entity);
+                  //         continue;
+                  //     };
+
+                  //     flush_batch(&mut res, &mut batch);
+
+                  //     let pos = light.pos;
+                  //     res.commands.spawn((
+                  //         PointLight {
+                  //             color: Color::srgba(1.0, 0.25, 0.44, 1.0),
+                  //             ..default()
+                  //         },
+                  //         Transform::from_xyz(pos.x, pos.y, pos.z),
+                  //     ));
+
+                  //     batch.draw_index += 1;
+                  // }
             }
         }
 

examples/lights.rs

@@ -2,6 +2,7 @@ mod glfw;
 
 use glfw::GlfwContext;
 use processing::prelude::*;
+use processing_render::light::LightType;
 use processing_render::render::command::DrawCommand;
 
 fn main() {
@@ -29,7 +30,9 @@ fn sketch() -> error::Result<()> {
     let graphics = graphics_create(surface, width, height)?;
     let box_geo = geometry_box(10.0, 10.0, 10.0)?;
 
-    let point_light = light_create()?;
+    // We will only declare lights in `setup`
+    // rather than calling some sort of `light()` method inside of `draw`
+    let _point_light = light_create(LightType::Point, 0.0, 0.0, 0.0)?;
 
     graphics_mode_3d(graphics)?;
     graphics_camera_position(graphics, 100.0, 100.0, 300.0)?;
@@ -45,8 +48,6 @@ fn sketch() -> error::Result<()> {
             DrawCommand::BackgroundColor(bevy::color::Color::srgb(0.18, 0.20, 0.15)),
         )?;
 
-        graphics_record_command(graphics, DrawCommand::Light(point_light))?;
-
         graphics_record_command(graphics, DrawCommand::PushMatrix)?;
         graphics_record_command(graphics, DrawCommand::Translate { x: 25.0, y: 25.0 })?;
         graphics_record_command(graphics, DrawCommand::Rotate { angle })?;