feature: light tiling

Cargo.toml

@@ -16,19 +16,19 @@ exclude = ["./shaders"]
 resolver = "2"
 
 [workspace.dependencies]
-acorn_prng = "3.0"
 assert_approx_eq = "1.1.0"
 async-channel = "1.8"
 bytemuck = { version = "1.19.0", features = ["derive"] }
 cfg_aliases = "0.2"
 clap = { version = "4.5.23", features = ["derive"] }
-craballoc = { version = "0.1.11" }
-crabslab = { version = "0.6.3", default-features = false }
+craballoc = { version = "0.2.0" }
+crabslab = { version = "0.6.5", default-features = false }
+plotters = "0.3.7"
 ctor = "0.2.2"
 dagga = "0.2.1"
 env_logger = "0.10.0"
 futures-lite = "1.13"
-glam = { version = "0.29", default-features = false }
+glam = { version = "0.30", default-features = false }
 gltf = { version = "1.4,1", features = ["KHR_lights_punctual", "KHR_materials_unlit", "KHR_materials_emissive_strength", "extras", "extensions"] }
 image = "0.25"
 log = "0.4"
@@ -40,8 +40,10 @@ rustc-hash = "1.1"
 serde = {version = "1.0", features = ["derive"]}
 serde_json = "1.0.117"
 send_wrapper = "0.6.0"
+similarity = "0.2.0"
 snafu = "0.8"
-spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "6e2c84d" }
+spirv-std = { git = "https://github.com/LegNeato/rust-gpu.git", rev = "425328a" }
+spirv-std-macros = { git = "https://github.com/LegNeato/rust-gpu.git", rev = "425328a" }
 syn = { version = "2.0.49", features = ["full", "extra-traits", "parsing"] }
 tracing = "0.1.41"
 wasm-bindgen = "0.2"
@@ -62,4 +64,4 @@ opt-level = 3
 opt-level = 3
 
 [patch.crates-io]
-spirv-std = { git = "https://github.com/Rust-GPU/rust-gpu", rev = "6e2c84d" }
+spirv-std = { git = "https://github.com/LegNeato/rust-gpu.git", rev = "425328a" }

crates/example-culling/src/main.rs

@@ -33,7 +33,7 @@ struct CullingExample {
     app_camera: AppCamera,
     controller: example::camera::TurntableCameraController,
     stage: Stage,
-    dlights: [AnalyticalLightBundle; 2],
+    dlights: [AnalyticalLight; 2],
     material_aabb_overlapping: Hybrid<Material>,
     material_aabb_outside: Hybrid<Material>,
     material_frustum: Hybrid<Material>,
@@ -183,22 +183,16 @@ impl TestAppHandler for CullingExample {
         let mut seed = 46;
         let mut resources = BagOfResources::default();
         let stage = ctx.new_stage().with_lighting(true);
-        let sunlight_a = stage.new_analytical_light(
-            DirectionalLightDescriptor {
-                direction: Vec3::new(-0.8, -1.0, 0.5).normalize(),
-                color: Vec4::ONE,
-                intensity: 10.0,
-            },
-            None,
-        );
-        let sunlight_b = stage.new_analytical_light(
-            DirectionalLightDescriptor {
-                direction: Vec3::new(1.0, 1.0, -0.1).normalize(),
-                color: Vec4::ONE,
-                intensity: 1.0,
-            },
-            None,
-        );
+        let sunlight_a = stage.new_analytical_light(DirectionalLightDescriptor {
+            direction: Vec3::new(-0.8, -1.0, 0.5).normalize(),
+            color: Vec4::ONE,
+            intensity: 10.0,
+        });
+        let sunlight_b = stage.new_analytical_light(DirectionalLightDescriptor {
+            direction: Vec3::new(1.0, 1.0, -0.1).normalize(),
+            color: Vec4::ONE,
+            intensity: 1.0,
+        });
 
         let dlights = [sunlight_a, sunlight_b];
 

crates/example/src/lib.rs

@@ -10,7 +10,7 @@ use renderling::{
     atlas::AtlasImage,
     bvol::{Aabb, BoundingSphere},
     camera::Camera,
-    light::{AnalyticalLightBundle, DirectionalLightDescriptor},
+    light::{AnalyticalLight, DirectionalLightDescriptor},
     math::{Mat4, UVec2, Vec2, Vec3, Vec4},
     skybox::Skybox,
     stage::{Animator, GltfDocument, Renderlet, Stage, Vertex},
@@ -128,7 +128,7 @@ pub struct App {
     loads: Arc<Mutex<HashMap<std::path::PathBuf, Vec<u8>>>>,
     pub stage: Stage,
     camera: Hybrid<Camera>,
-    lighting: AnalyticalLightBundle,
+    lighting: AnalyticalLight,
     model: Model,
     animators: Option<Vec<Animator>>,
     animations_conflict: bool,
@@ -150,7 +150,7 @@ impl App {
             color: renderling::math::hex_to_vec4(0xFDFBD3FF),
             intensity: 10.0,
         };
-        let sunlight_bundle = stage.new_analytical_light(directional_light, None);
+        let sunlight_bundle = stage.new_analytical_light(directional_light);
 
         stage
             .set_atlas_size(wgpu::Extent3d {

crates/img-diff/src/lib.rs

@@ -25,8 +25,8 @@ fn checkerboard_background_color(x: u32, y: u32) -> Vec3 {
 
 #[derive(Debug, Snafu)]
 enum ImgDiffError {
-    #[snafu(display("Images are different sizes"))]
-    ImageSize,
+    #[snafu(display("Images are different sizes. Expected {lhs:?}, saw {rhs:?}"))]
+    ImageSize { lhs: (u32, u32), rhs: (u32, u32) },
 }
 
 pub struct DiffCfg {
@@ -68,7 +68,7 @@ fn get_results(
 ) -> Result<Option<DiffResults>, ImgDiffError> {
     let lid @ (width, height) = left_image.dimensions();
     let rid = right_image.dimensions();
-    snafu::ensure!(lid == rid, ImageSizeSnafu);
+    snafu::ensure!(lid == rid, ImageSizeSnafu { lhs: lid, rhs: rid });
 
     let results = left_image
         .enumerate_pixels()
@@ -147,13 +147,17 @@ pub fn assert_eq_cfg(
         image_threshold,
         test_name,
     } = cfg;
+    let results = match get_results(&lhs, &rhs, pixel_threshold) {
+        Ok(maybe_diff) => maybe_diff,
+        Err(e) => panic!("Asserting {filename} failed: {e}"),
+    };
     if let Some(DiffResults {
         num_pixels: diffs,
         diff_image,
         mask_image,
         max_delta_length,
         avg_delta_length,
-    }) = get_results(&lhs, &rhs, pixel_threshold).unwrap()
+    }) = results
     {
         println!("{filename} has {diffs} pixel differences (threshold={pixel_threshold})");
         println!("  max_delta_length: {max_delta_length}");

crates/renderling-build/src/lib.rs

@@ -1,4 +1,8 @@
 #![allow(unexpected_cfgs)]
+use naga::{
+    back::wgsl::WriterFlags,
+    valid::{ValidationFlags, Validator},
+};
 use quote::quote;
 
 #[derive(Debug, serde::Deserialize)]
@@ -91,19 +95,35 @@ fn wgsl(spv_filepath: impl AsRef<std::path::Path>, destination: impl AsRef<std::
     });
     let opts = naga::front::spv::Options::default();
     let module = naga::front::spv::parse_u8_slice(&bytes, &opts).unwrap();
-    let mut validator =
-        naga::valid::Validator::new(Default::default(), naga::valid::Capabilities::empty());
-    let info = validator.validate(&module).unwrap_or_else(|e| {
-        panic!(
-            "Could not validate '{}': {e}",
-            spv_filepath.as_ref().display(),
-        )
-    });
-    let wgsl =
-        naga::back::wgsl::write_string(&module, &info, naga::back::wgsl::WriterFlags::empty())
-            .unwrap();
+    let mut wgsl = String::new();
+    let mut panic_msg: Option<String> = None;
+    for (vflags, name) in [
+        (ValidationFlags::empty(), "empty"),
+        (ValidationFlags::all(), "all"),
+    ] {
+        let mut validator = Validator::new(vflags, Default::default());
+        match validator.validate(&module) {
+            Err(e) => {
+                panic_msg = Some(format!(
+                    "Could not validate '{}' with WGSL validation flags {name}: {}",
+                    spv_filepath.as_ref().display(),
+                    e.emit_to_string(&wgsl)
+                ));
+            }
+            Ok(i) => {
+                wgsl = naga::back::wgsl::write_string(&module, &i, WriterFlags::empty()).unwrap();
+            }
+        };
+    }
+
     let destination = destination.as_ref().with_extension("wgsl");
     std::fs::write(destination, wgsl).unwrap();
+    if let Some(msg) = panic_msg {
+        panic!(
+            "{msg}\nWGSL was written to {}",
+            spv_filepath.as_ref().display()
+        );
+    }
 }
 
 pub struct RenderlingPaths {

crates/renderling-ui/src/lib.rs

@@ -28,7 +28,7 @@
 //! Happy hacking!
 use std::sync::{Arc, RwLock};
 
-use craballoc::prelude::Hybrid;
+use craballoc::prelude::{Hybrid, SourceId};
 use crabslab::Id;
 use glyph_brush::ab_glyph;
 use renderling::{
@@ -150,7 +150,7 @@ pub struct Ui {
     //
     // The `usize` key here is the update source notifier index, which is needed
     // to re-order after any transform performs an update.
-    transforms: Arc<RwLock<FxHashMap<usize, UiTransform>>>,
+    transforms: Arc<RwLock<FxHashMap<SourceId, UiTransform>>>,
     default_stroke_options: Arc<RwLock<StrokeOptions>>,
     default_fill_options: Arc<RwLock<FillOptions>>,
 }

crates/renderling/Cargo.toml

@@ -41,6 +41,7 @@ quote.workspace = true
 renderling_build = { path = "../renderling-build", version = "0.1.0" }
 serde.workspace = true
 serde_json.workspace = true
+similarity.workspace = true
 
 # dependencies for CPU and GPU code
 [dependencies]
@@ -73,15 +74,15 @@ wgpu = { workspace = true, features = ["spirv"] }
 winit = { workspace = true, optional = true }
 
 [dev-dependencies]
-acorn_prng.workspace = true
-assert_approx_eq = {workspace = true}
+assert_approx_eq.workspace = true
 ctor = "0.2.2"
-env_logger = {workspace = true}
+env_logger.workspace = true
 example = { path = "../example" }
 fastrand = "2.1.1"
 icosahedron = "0.1"
 img-diff = { path = "../img-diff" }
 naga.workspace = true
+plotters.workspace = true
 ttf-parser = "0.20.0"
 wgpu-core.workspace = true
 winit.workspace = true

crates/renderling/shaders/manifest.json

@@ -104,6 +104,31 @@
     "entry_point": "ibl::diffuse_irradiance::di_convolution_fragment",
     "wgsl_entry_point": "ibldiffuse_irradiancedi_convolution_fragment"
   },
+  {
+    "source_path": "shaders/light-light_tiling_clear_tiles.spv",
+    "entry_point": "light::light_tiling_clear_tiles",
+    "wgsl_entry_point": "lightlight_tiling_clear_tiles"
+  },
+  {
+    "source_path": "shaders/light-light_tiling_compute_tile_min_and_max_depth.spv",
+    "entry_point": "light::light_tiling_compute_tile_min_and_max_depth",
+    "wgsl_entry_point": "lightlight_tiling_compute_tile_min_and_max_depth"
+  },
+  {
+    "source_path": "shaders/light-light_tiling_compute_tiles.spv",
+    "entry_point": "light::light_tiling_compute_tiles",
+    "wgsl_entry_point": "lightlight_tiling_compute_tiles"
+  },
+  {
+    "source_path": "shaders/light-light_tiling_compute_tiles_multisampled.spv",
+    "entry_point": "light::light_tiling_compute_tiles_multisampled",
+    "wgsl_entry_point": "lightlight_tiling_compute_tiles_multisampled"
+  },
+  {
+    "source_path": "shaders/light-light_tiling_depth_pre_pass.spv",
+    "entry_point": "light::light_tiling_depth_pre_pass",
+    "wgsl_entry_point": "lightlight_tiling_depth_pre_pass"
+  },
   {
     "source_path": "shaders/light-shadow_mapping_fragment.spv",
     "entry_point": "light::shadow_mapping_fragment",

crates/renderling/src/bloom/cpu.rs

@@ -408,8 +408,7 @@ impl Bloom {
         let runtime = runtime.as_ref();
         let resolution = UVec2::new(hdr_texture.width(), hdr_texture.height());
 
-        let slab =
-            SlabAllocator::new_with_label(runtime, wgpu::BufferUsages::empty(), Some("bloom-slab"));
+        let slab = SlabAllocator::new(runtime, "bloom-slab", wgpu::BufferUsages::empty());
         let downsample_pixel_sizes = slab.new_array(
             config_resolutions(resolution).map(|r| 1.0 / Vec2::new(r.x as f32, r.y as f32)),
         );