Merge pull request #1 from exvacuum/wip

Wip

.gitignore

@@ -0,0 +1 @@
+target

assets/shaders/blacklight_material.wgsl

@@ -3,9 +3,9 @@
 struct BlackLight {
 	position: vec3<f32>,
 	direction: vec3<f32>,
-	color: vec4<f32>,
 	range: f32,
-	radius: f32,
+	inner_angle: f32,
+	outer_angle: f32,
 }
 
 @group(2) @binding(0) var<storage> lights: array<BlackLight>;
@@ -20,20 +20,35 @@ fn fragment(
 	var final_color = vec4f(0.0, 0.0, 0.0, 0.0);
 	for (var i = u32(0); i < arrayLength(&lights); i = i+1) {
 		let light = lights[i];
+
+		let light_to_fragment_direction = normalize(in.world_position.xyz - light.position);
+		let light_to_fragment_angle = acos(dot(light.direction, light_to_fragment_direction));
+		let angle_inner_factor = light.inner_angle / light.outer_angle;
+		let angle_factor = linear_falloff_radius(light_to_fragment_angle / light.outer_angle, angle_inner_factor);
+
 		let light_distance_squared = distance_squared(in.world_position.xyz, light.position);
-		let light_arccosine = abs(acos(dot(normalize(light.direction), normalize(in.world_position.xyz - light.position)))) * radians(180.0);
-		final_color = saturate(final_color + base_color * (inverse_falloff_radius(light_distance_squared / (light.range * light.range), 0.5) * inverse_falloff_radius(light_arccosine, 0.9)));
+		let distance_factor = inverse_falloff_radius(saturate(light_distance_squared / (light.range * light.range)), 0.5);
+
+		final_color = saturate(final_color + base_color * angle_factor * distance_factor);
 	}
 	return final_color;
 }
 
 fn distance_squared(a: vec3f, b: vec3f) -> f32 {
-	return pow(a.x - b.x, 2.0) + pow(a.y - b.y, 2.0) + pow(a.z - b.z, 2.0);
+	let vec = a - b;
+	return dot(vec, vec);
+}
+
+fn linear_falloff_radius(factor: f32, radius: f32) -> f32 {
+	if factor < radius {
+		return 1.0;
+	} else {
+		return 1.0 - (factor - radius) / (1.0 - radius);
+	}
 }
 
 fn inverse_falloff(factor: f32) -> f32 {
-	let squared = factor * factor;
-	return (1.0 - squared) / (10 * squared + 1.0);
+	return pow(1.0 - factor, 2.0);
 }
 
 fn inverse_falloff_radius(factor: f32, radius: f32) -> f32 {

src/lib.rs

@@ -1,37 +1,60 @@
+#![warn(missing_docs)]
+
+//! A plugin for the bevy engine providing a simple [`BlacklightMaterial`], which reveals a base
+//! color based on light data from spot lights tagged with a [`Blacklight`] component.
+//! 
+//! Possible future features:
+//! - [`StandardMaterial`] extension for a "blacklight mapped" material.
+//! - Point light support.
+
 use bevy::{
     asset::embedded_asset,
     prelude::*,
     render::render_resource::{AsBindGroup, ShaderType},
 };
 
+/// Plugin which enables and updates blacklight shaders.
 pub struct BlacklightPlugin;
 
 impl Plugin for BlacklightPlugin {
     fn build(&self, app: &mut App) {
         embedded_asset!(app, "../assets/shaders/blacklight_material.wgsl");
-        app.add_plugins(MaterialPlugin::<BlacklightMaterial>::default()).add_systems(Update, update_shader_blacklight_data);
+        app.add_plugins(MaterialPlugin::<BlacklightMaterial>::default())
+            .add_systems(Update, update_shader_blacklight_data);
     }
 }
 
+/// Marker component for spot lights to use them as blacklights for [`BlacklightMaterial`].
 #[derive(Component, Debug)]
 pub struct Blacklight;
 
+/// Shader data representing a single blacklight point light.
 #[derive(Clone, Debug, ShaderType)]
 pub struct BlacklightData {
+    /// World-space position of this light.
     pub position: Vec3,
+    /// World-space direction of this light (must be normalized).
     pub direction: Vec3,
-    pub color: Vec4,
+    /// Range of this light (see [`SpotLight`]).
     pub range: f32,
-    pub radius: f32,
+    /// Inner angle of this light (see [`SpotLight`]).
+    pub inner_angle: f32,
+    /// Outer angle of this light (see [`SpotLight`]).
+    pub outer_angle: f32,
 }
 
+/// Material which is invisible until exposed to light from a spot light tagged with the
+/// [`Blacklight`] component.
 #[derive(Asset, TypePath, AsBindGroup, Debug, Clone)]
 pub struct BlacklightMaterial {
+    /// List of light data processed by this shader
     #[storage(0, read_only)]
     pub lights: Vec<BlacklightData>,
+    /// Base color texture which is revealed by blacklight exposure.
     #[texture(1)]
     #[sampler(2)]
     pub base_texture: Option<Handle<Image>>,
+    /// Alpha mode for this material.
     pub alpha_mode: AlphaMode,
 }
 
@@ -56,19 +79,19 @@ impl Material for BlacklightMaterial {
 }
 
 fn update_shader_blacklight_data(
-    blacklight_query: Query<(&ViewVisibility, &GlobalTransform, &Transform, &SpotLight), With<Blacklight>>,
+    blacklight_query: Query<(&ViewVisibility, &GlobalTransform, &SpotLight), With<Blacklight>>,
     blacklight_material_query: Query<&Handle<BlacklightMaterial>>,
     mut blacklight_materials: ResMut<Assets<BlacklightMaterial>>,
 ) {
     let light_data = blacklight_query
         .iter()
-        .filter(|(visibility, _, _, _)| visibility.get())
-        .map(|(_, global_transform, transform, light)| BlacklightData {
+        .filter(|(visibility, _, _)| visibility.get())
+        .map(|(_, global_transform, light)| BlacklightData {
             position: global_transform.translation(),
             direction: *global_transform.forward(),
-            color: light.color.to_srgba().to_vec4(),
             range: light.range,
-            radius: light.radius,
+            inner_angle: light.inner_angle,
+            outer_angle: light.outer_angle,
         })
         .collect::<Vec<_>>();
     for handle in blacklight_material_query.iter() {