Directional, Point, and Spot Lights

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,7 @@ 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, render::command::DrawCommand,
     surface::SurfacePlugin,
 };
 
@@ -248,6 +249,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 +776,88 @@ pub fn image_destroy(entity: Entity) -> error::Result<()> {
     })
 }
 
+pub fn light_create_directional(
+    x: f32,
+    y: f32,
+    z: f32,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+    illuminance: f32,
+) -> error::Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(
+                light::create_directional,
+                (x, y, z, r, g, b, a, illuminance),
+            )
+            .unwrap())
+    })
+}
+
+pub fn light_create_point(
+    x: f32,
+    y: f32,
+    z: f32,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+    intensity: f32,
+    range: f32,
+    radius: f32,
+) -> error::Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(
+                light::create_point,
+                (x, y, z, r, g, b, a, intensity, range, radius),
+            )
+            .unwrap())
+    })
+}
+
+pub fn light_create_spot(
+    x: f32,
+    y: f32,
+    z: f32,
+    r: f32,
+    g: f32,
+    b: f32,
+    a: f32,
+    intensity: f32,
+    range: f32,
+    radius: f32,
+    inner_angle: f32,
+    outer_angle: f32,
+) -> error::Result<Entity> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(
+                light::create_spot,
+                (
+                    x,
+                    y,
+                    z,
+                    r,
+                    g,
+                    b,
+                    a,
+                    intensity,
+                    range,
+                    radius,
+                    inner_angle,
+                    outer_angle,
+                ),
+            )
+            .unwrap())
+    })
+}
+
 pub fn geometry_layout_create() -> error::Result<Entity> {
     app_mut(|app| {
         Ok(app

crates/processing_render/src/light.rs

@@ -0,0 +1,88 @@
+//! A light in Processing
+//!
+
+use bevy::prelude::*;
+
+pub struct LightPlugin;
+
+impl Plugin for LightPlugin {
+    fn build(&self, _app: &mut App) {}
+}
+
+pub fn create_directional(
+    In((px, py, pz, r, g, b, a, illuminance)): In<(f32, f32, f32, f32, f32, f32, f32, f32)>,
+    mut commands: Commands,
+) -> Entity {
+    commands
+        .spawn((
+            DirectionalLight {
+                illuminance,
+                color: Color::srgba(r, g, b, a),
+                ..default()
+            },
+            Transform::from_xyz(px, py, pz),
+        ))
+        .id()
+}
+
+pub fn create_point(
+    In((px, py, pz, r, g, b, a, intensity, range, radius)): In<(
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+    )>,
+    mut commands: Commands,
+) -> Entity {
+    commands
+        .spawn((
+            PointLight {
+                intensity,
+                color: Color::srgba(r, g, b, a),
+                range,
+                radius,
+                ..default()
+            },
+            Transform::from_xyz(px, py, pz),
+        ))
+        .id()
+}
+
+pub fn create_spot(
+    In((px, py, pz, r, g, b, a, intensity, range, radius, inner_angle, outer_angle)): In<(
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+        f32,
+    )>,
+    mut commands: Commands,
+) -> Entity {
+    commands
+        .spawn((
+            SpotLight {
+                color: Color::srgba(r, g, b, a),
+                intensity,
+                range,
+                radius,
+                inner_angle,
+                outer_angle,
+                ..default()
+            },
+            Transform::from_xyz(px, py, pz),
+        ))
+        .id()
+}

docs/api.md

@@ -34,6 +34,10 @@ rendering texture that the camera draws to (`ViewTarget`), which is not typicall
 For consistency, all image functions should accept a graphics object, although its internal image representation is 
 not guaranteed to be the same as a user-created image.
 
+### Light
+
+[//]: # (TODO: Document Image API object)
+
 ### Image
 
 Images are 2D or 3D arrays of pixels that can be drawn onto surfaces. They can be created from files, generated procedurally,
@@ -85,4 +89,4 @@ can also be used to implement 2D image processing effects, etc.
 
 ### Shader
 
-[//]: # (TODO: Document Shader API object, do we even need this with a sufficiently robust Material API?)
+[//]: # (TODO: Document Shader API object, do we even need this with a sufficiently robust Material API?)

examples/lights.rs

@@ -29,7 +29,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 _dir_light = light_create_directional(0.0, 0.0, 0.0, 0.5, 0.43, 1.0, 1.0, 1000.0);
 
     graphics_mode_3d(graphics)?;
     graphics_camera_position(graphics, 100.0, 100.0, 300.0)?;
@@ -45,8 +47,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 })?;