Create creation methods for directional, point, and spot lights

Author: catilac

crates/processing_render/src/lib.rs

@@ -26,10 +26,7 @@ use tracing::debug;
 use crate::geometry::{AttributeFormat, AttributeValue};
 use crate::graphics::flush;
 use crate::{
-    graphics::GraphicsPlugin,
-    image::ImagePlugin,
-    light::{LightPlugin, LightType},
-    render::command::DrawCommand,
+    graphics::GraphicsPlugin, image::ImagePlugin, light::LightPlugin, render::command::DrawCommand,
     surface::SurfacePlugin,
 };
 
@@ -779,12 +776,84 @@ 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> {
+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, (light_type, x, y, z))
+            .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())
     })
 }

crates/processing_render/src/light.rs

@@ -9,27 +9,80 @@ impl Plugin for LightPlugin {
     fn build(&self, _app: &mut App) {}
 }
 
-#[derive(Component)]
-pub struct Light {
-    pub light_type: LightType,
-    pub pos: Vec3,
+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()
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum LightType {
-    Directional,
-    Point,
-    Spot,
+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(
-    In((light_type, x, y, z)): In<(LightType, f32, f32, f32)>,
+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 {
-    match light_type {
-        LightType::Directional => commands
-            .spawn((DirectionalLight::default(), Transform::from_xyz(x, y, z)))
-            .id(),
-        _ => commands.spawn(DirectionalLight::default()).id(),
-    }
+    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()
 }

examples/lights.rs

@@ -2,7 +2,6 @@ mod glfw;
 
 use glfw::GlfwContext;
 use processing::prelude::*;
-use processing_render::light::LightType;
 use processing_render::render::command::DrawCommand;
 
 fn main() {
@@ -32,7 +31,7 @@ fn sketch() -> error::Result<()> {
 
     // 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)?;
+    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)?;