lighting manual additions

Author: schell

crates/examples/src/lighting.rs

@@ -162,7 +162,7 @@ async fn manual_lighting_ibl() {
         types::GpuOnlyArray,
     };
 
-    let ctx = Context::headless(256, 256).await;
+    let ctx = Context::headless(512, 512).await;
     let stage: Stage = ctx
         .new_stage()
         .with_background_color(Vec4::new(0.25, 0.25, 0.25, 1.0));
@@ -183,7 +183,7 @@ async fn manual_lighting_ibl() {
             .with_projection_and_view(projection, view)
     };
 
-    let _model: GltfDocument<GpuOnlyArray> = stage
+    let model: GltfDocument<GpuOnlyArray> = stage
         .load_gltf_document_from_path(workspace_dir().join("gltf/marble_bust_1k.glb"))
         .unwrap()
         .into_gpu_only();
@@ -192,31 +192,38 @@ async fn manual_lighting_ibl() {
         .new_skybox_from_path(workspace_dir().join("img/hdr/helipad.hdr"))
         .unwrap();
     stage.use_skybox(&skybox);
+    // ANCHOR_END: ibl_setup
+
+    // ANCHOR: ibl
+    use renderling::pbr::ibl::Ibl;
+
+    let ibl: Ibl = stage.new_ibl(&skybox);
+    stage.use_ibl(&ibl);
 
     let frame = ctx.get_next_frame().unwrap();
     stage.render(&frame.view());
     let img = frame.read_image().await.unwrap();
-    img.save("lighting/no-lights.png").unwrap();
+    img.save("lighting/ibl.png").unwrap();
     frame.present();
-    // ANCHOR_END: ibl_setup
+    // ANCHOR_END: ibl
 
-    // ANCHOR: ibl
-    let ibl =
-        renderling::capture_gpu_frame(&ctx, "/Users/schell/Desktop/ibl-create.gputrace", || {
-            let ibl = stage.new_ibl(&skybox);
-            ctx.get_device().poll(wgpu::PollType::wait()).unwrap();
-            ibl
-        });
-    stage.use_ibl(&ibl);
+    // ANCHOR: mix
+    use renderling::{color::css_srgb_color_to_linear, light::Candela};
 
-    stage.remove_skybox();
+    let sunset_amber_sunlight_color = css_srgb_color_to_linear(250, 198, 104);
+    let _point = stage
+        .new_point_light()
+        .with_position({
+            let bust_aabb = model.bounding_volume().unwrap();
+            bust_aabb.max
+        })
+        .with_color(sunset_amber_sunlight_color)
+        .with_intensity(Candela(100.0));
 
     let frame = ctx.get_next_frame().unwrap();
-    renderling::capture_gpu_frame(&ctx, "/Users/schell/Desktop/ibl.gputrace", || {
-        stage.render(&frame.view());
-    });
+    stage.render(&frame.view());
     let img = frame.read_image().await.unwrap();
-    img.save("lighting/ibl.png").unwrap();
+    img.save("lighting/ibl-analytical-mixed.png").unwrap();
     frame.present();
-    // ANCHOR_END: ibl
+    // ANCHOR_END: mix
 }

crates/examples/src/stage.rs

@@ -2,7 +2,7 @@
 
 #[tokio::test]
 async fn manual_stage() {
-    env_logger::init();
+    let _ = env_logger::builder().try_init();
 
     // ANCHOR: creation
     use renderling::{context::Context, glam::Vec4, stage::Stage};

crates/renderling/src/pbr/ibl/cpu.rs

@@ -466,7 +466,7 @@ impl DiffuseIrradianceConvolutionRenderPipeline {
 
 #[cfg(test)]
 mod test {
-    use glam::Vec3;
+    use glam::{Mat4, Vec3};
 
     use crate::{
         context::Context,
@@ -480,17 +480,15 @@ mod test {
     /// ensure creation is valid.
     fn creates_valid_cubemaps() {
         let ctx = Context::headless(600, 400).block();
-
         let proj = crate::camera::perspective(600.0, 400.0);
         let view = crate::camera::look_at(Vec3::new(0.0, 0.0, 2.0), Vec3::ZERO, Vec3::Y);
-
         let stage = ctx.new_stage();
-
         let _camera = stage.new_camera().with_projection_and_view(proj, view);
         let skybox = stage
             .new_skybox_from_path(workspace_dir().join("img/hdr/resting_place.hdr"))
             .unwrap();
         let ibl = stage.new_ibl(&skybox);
+        stage.use_ibl(&ibl);
         assert_eq!(
             wgpu::TextureFormat::Rgba16Float,
             ibl.irradiance_cubemap.texture.format()
@@ -499,7 +497,6 @@ mod test {
             wgpu::TextureFormat::Rgba16Float,
             ibl.prefiltered_environment_cubemap.texture.format()
         );
-
         for i in 0..6 {
             // save out the irradiance face
             let copied_buffer = CopiedTextureBuffer::read_from(
@@ -552,4 +549,47 @@ mod test {
             }
         }
     }
+
+    #[test]
+    /// Creates a Skybox, Ibl, and uses the Ibl to light a mirror cube.
+    fn mirror_cube_is_lit_by_environment() {
+        let ctx = Context::headless(256, 256).block();
+        let stage = ctx.new_stage();
+
+        let _camera = stage
+            .new_camera()
+            .with_default_perspective(256.0, 256.0)
+            .with_view(Mat4::look_at_rh(Vec3::ONE * 1.5, Vec3::ZERO, Vec3::Y));
+        let _model = stage.new_primitive().with_material(
+            stage
+                .new_material()
+                .with_metallic_factor(0.9)
+                .with_roughness_factor(0.1),
+        );
+
+        let skybox = stage
+            .new_skybox_from_path(workspace_dir().join("img/hdr/helipad.hdr"))
+            .unwrap();
+        stage.use_skybox(&skybox);
+
+        // Render once here because we found a bug where rendering before setting
+        // ibl would cause the primitive bindgroup to *not* be invalidated when
+        // ibl was set.
+        //
+        // This essentially just ensures that `Stage::use_ibl` is invalidating the
+        // primitive bindgroup.
+        let frame = ctx.get_next_frame().unwrap();
+        stage.render(&frame.view());
+        frame.present();
+
+        let ibl = stage.new_ibl(&skybox);
+        stage.use_ibl(&ibl);
+        stage.remove_skybox();
+
+        let frame = ctx.get_next_frame().unwrap();
+        stage.render(&frame.view());
+        let img = frame.read_image().block().unwrap();
+        img_diff::save("pbr/ibl/mirror_cube_is_lit_by_environment.png", img);
+        frame.present();
+    }
 }

crates/renderling/src/stage/cpu.rs

@@ -148,7 +148,7 @@ impl StageCommitResult {
 /// This is the bindgroup that occupies `descriptor_set = 0` in
 /// [crate::primitive::shader::primitive_vertex] and
 /// [crate::primitive::shader::primitive_fragment].
-struct RenderletBindGroup<'a> {
+struct PrimitiveBindGroup<'a> {
     device: &'a wgpu::Device,
     layout: &'a wgpu::BindGroupLayout,
     geometry_buffer: &'a wgpu::Buffer,
@@ -166,10 +166,10 @@ struct RenderletBindGroup<'a> {
     shadow_map_texture_sampler: &'a wgpu::Sampler,
 }
 
-impl RenderletBindGroup<'_> {
+impl PrimitiveBindGroup<'_> {
     pub fn create(self) -> wgpu::BindGroup {
         self.device.create_bind_group(&wgpu::BindGroupDescriptor {
-            label: Some("renderlet"),
+            label: Some("primitive"),
             layout: self.layout,
             entries: &[
                 wgpu::BindGroupEntry {
@@ -244,25 +244,29 @@ impl StageRendering<'_> {
     /// Returns the queue submission index and the indirect draw buffer, if available.
     pub fn run(self) -> (wgpu::SubmissionIndex, Option<SlabBuffer<wgpu::Buffer>>) {
         let commit_result = self.stage.commit();
-        let current_renderlet_bind_group_creation_time = commit_result.latest_creation_time();
-        let previous_renderlet_bind_group_creation_time =
-            self.stage.renderlet_bind_group_created.swap(
-                current_renderlet_bind_group_creation_time,
+        let current_primitive_bind_group_creation_time = commit_result.latest_creation_time();
+        log::trace!("current_primitive_bind_group_creation_time: {current_primitive_bind_group_creation_time}");
+        let previous_primitive_bind_group_creation_time =
+            self.stage.primitive_bind_group_created.swap(
+                current_primitive_bind_group_creation_time,
                 std::sync::atomic::Ordering::Relaxed,
             );
-        let should_invalidate_renderlet_bind_group =
-            commit_result.should_invalidate(previous_renderlet_bind_group_creation_time);
-        let renderlet_bind_group =
+        let should_invalidate_primitive_bind_group =
+            commit_result.should_invalidate(previous_primitive_bind_group_creation_time);
+        log::trace!(
+            "should_invalidate_primitive_bind_group: {should_invalidate_primitive_bind_group}"
+        );
+        let primitive_bind_group =
             self.stage
-                .renderlet_bind_group
-                .get(should_invalidate_renderlet_bind_group, || {
-                    log::trace!("recreating renderlet bind group");
+                .primitive_bind_group
+                .get(should_invalidate_primitive_bind_group, || {
+                    log::trace!("recreating primitive bind group");
                     let atlas_texture = self.stage.materials.atlas().get_texture();
                     let ibl = self.stage.ibl.read().unwrap();
                     let shadow_map = self.stage.lighting.shadow_map_atlas.get_texture();
-                    RenderletBindGroup {
+                    PrimitiveBindGroup {
                         device: self.stage.device(),
-                        layout: &Stage::renderlet_pipeline_bindgroup_layout(self.stage.device()),
+                        layout: &Stage::primitive_pipeline_bindgroup_layout(self.stage.device()),
                         geometry_buffer: &commit_result.geometry_buffer,
                         material_buffer: &commit_result.materials_buffer,
                         light_buffer: &commit_result.lighting_buffer,
@@ -301,7 +305,7 @@ impl StageRendering<'_> {
             });
 
             render_pass.set_pipeline(self.pipeline);
-            render_pass.set_bind_group(0, Some(renderlet_bind_group.as_ref()), &[]);
+            render_pass.set_bind_group(0, Some(primitive_bind_group.as_ref()), &[]);
             draw_calls.draw(&mut render_pass);
 
             let has_skybox = self.stage.has_skybox.load(Ordering::Relaxed);
@@ -380,9 +384,9 @@ pub struct Stage {
     pub(crate) materials: Materials,
     pub(crate) lighting: Lighting,
 
-    pub(crate) renderlet_pipeline: Arc<RwLock<wgpu::RenderPipeline>>,
-    pub(crate) renderlet_bind_group: ManagedBindGroup,
-    pub(crate) renderlet_bind_group_created: Arc<AtomicUsize>,
+    pub(crate) primitive_pipeline: Arc<RwLock<wgpu::RenderPipeline>>,
+    pub(crate) primitive_bind_group: ManagedBindGroup,
+    pub(crate) primitive_bind_group_created: Arc<AtomicUsize>,
 
     pub(crate) skybox_pipeline: Arc<RwLock<Option<Arc<SkyboxRenderPipeline>>>>,
 
@@ -846,6 +850,7 @@ impl Stage {
     pub fn use_ibl(&self, ibl: &Ibl) -> &Self {
         let mut guard = self.ibl.write().unwrap();
         *guard = ibl.clone();
+        self.primitive_bind_group.invalidate();
         self
     }
 
@@ -858,7 +863,7 @@ impl Stage {
         } else {
             let ibl = guard.clone();
             *guard = Ibl::new(self.runtime(), &Skybox::empty(self.runtime()));
-            self.renderlet_bind_group.invalidate();
+            self.primitive_bind_group.invalidate();
             Some(ibl)
         }
     }
@@ -922,7 +927,7 @@ impl Stage {
     pub fn commit(&self) -> StageCommitResult {
         let (materials_atlas_texture_was_recreated, materials_buffer) = self.materials.commit();
         if materials_atlas_texture_was_recreated {
-            self.renderlet_bind_group.invalidate();
+            self.primitive_bind_group.invalidate();
         }
         let geometry_buffer = self.geometry.commit();
         let lighting_buffer = self.lighting.commit();
@@ -933,7 +938,7 @@ impl Stage {
         }
     }
 
-    fn renderlet_pipeline_bindgroup_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
+    fn primitive_pipeline_bindgroup_layout(device: &wgpu::Device) -> wgpu::BindGroupLayout {
         let geometry_slab = wgpu::BindGroupLayoutEntry {
             binding: 0,
             visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
@@ -1022,7 +1027,7 @@ impl Stage {
         } = LightingBindGroupLayoutEntries::new(10);
 
         device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            label: Some("renderlet"),
+            label: Some("primitive"),
             entries: &[
                 geometry_slab,
                 material_slab,
@@ -1047,11 +1052,11 @@ impl Stage {
         multisample_count: u32,
     ) -> wgpu::RenderPipeline {
         log::trace!("creating stage render pipeline");
-        let label = Some("renderlet");
+        let label = Some("primitive");
         let vertex_linkage = crate::linkage::primitive_vertex::linkage(device);
         let fragment_linkage = crate::linkage::primitive_fragment::linkage(device);
 
-        let bind_group_layout = Self::renderlet_pipeline_bindgroup_layout(device);
+        let bind_group_layout = Self::primitive_pipeline_bindgroup_layout(device);
         let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
             label,
             bind_group_layouts: &[&bind_group_layout],
@@ -1160,9 +1165,9 @@ impl Stage {
             stage_slab_buffer: Arc::new(RwLock::new(geometry_buffer)),
             geometry,
 
-            renderlet_pipeline: Arc::new(RwLock::new(stage_pipeline)),
-            renderlet_bind_group: ManagedBindGroup::default(),
-            renderlet_bind_group_created: Arc::new(0.into()),
+            primitive_pipeline: Arc::new(RwLock::new(stage_pipeline)),
+            primitive_bind_group: ManagedBindGroup::default(),
+            primitive_bind_group_created: Arc::new(0.into()),
 
             ibl: Arc::new(RwLock::new(ibl)),
             skybox: Arc::new(RwLock::new(skybox)),
@@ -1222,7 +1227,7 @@ impl Stage {
 
         log::debug!("setting multisample count to {multisample_count}");
         // UNWRAP: POP
-        *self.renderlet_pipeline.write().unwrap() = Self::create_primitive_pipeline(
+        *self.primitive_pipeline.write().unwrap() = Self::create_primitive_pipeline(
             self.device(),
             wgpu::TextureFormat::Rgba16Float,
             multisample_count,
@@ -1461,33 +1466,33 @@ impl Stage {
         self
     }
 
-    /// Adds a primitive to the internal list of renderlets to be drawn each
+    /// Adds a primitive to the internal list of primitives to be drawn each
     /// frame.
     ///
     /// Returns the number of primitives added.
     ///
-    /// If you drop the renderlet and no other references are kept, it will be
+    /// If you drop the primitive and no other references are kept, it will be
     /// removed automatically from the internal list and will cease to be
     /// drawn each frame.
-    pub fn add_primitive(&self, renderlet: &Primitive) -> usize {
+    pub fn add_primitive(&self, primitive: &Primitive) -> usize {
         // UNWRAP: if we can't acquire the lock we want to panic.
         let mut draws = self.draw_calls.write().unwrap();
-        draws.add_primitive(renderlet)
+        draws.add_primitive(primitive)
     }
 
     /// Erase the given primitive from the internal list of primitives to be
     /// drawn each frame.
     ///
     /// Returns the number of primitives added.
-    pub fn remove_primitive(&self, renderlet: &Primitive) -> usize {
+    pub fn remove_primitive(&self, primitive: &Primitive) -> usize {
         let mut draws = self.draw_calls.write().unwrap();
-        draws.remove_primitive(renderlet)
+        draws.remove_primitive(primitive)
     }
 
-    /// Sort the drawing order of renderlets.
+    /// Sort the drawing order of primitives.
     ///
     /// This determines the order in which [`Primitive`]s are drawn each frame.
-    pub fn sort_renderlets(&self, f: impl Fn(&Primitive, &Primitive) -> std::cmp::Ordering) {
+    pub fn sort_primitive(&self, f: impl Fn(&Primitive, &Primitive) -> std::cmp::Ordering) {
         // UNWRAP: panic on purpose
         let mut guard = self.draw_calls.write().unwrap();
         guard.sort_primitives(f);
@@ -1553,7 +1558,7 @@ impl Stage {
             }),
             stencil_ops: None,
         };
-        let pipeline_guard = self.renderlet_pipeline.read().unwrap();
+        let pipeline_guard = self.primitive_pipeline.read().unwrap();
         let (_submission_index, maybe_indirect_buffer) = StageRendering {
             pipeline: &pipeline_guard,
             stage: self,

crates/renderling/src/ui/cpu.rs

@@ -316,7 +316,7 @@ impl Ui {
     }
 
     fn reorder_renderlets(&self) {
-        self.stage.sort_renderlets(|a, b| {
+        self.stage.sort_primitive(|a, b| {
             let za = a
                 .transform()
                 .as_ref()

manual/src/assets/lighting/ibl-analytical-mixed.png

@@ -84,4 +84,4 @@ you can see the effect:
 
 ![image of a marble bust lit by a single spot light](/assets/lighting/spot.png)
 
-Good enough! Now on to image based lighting.
+Good enough! Now on to image-based lighting, which uses environment maps to simulate complex lighting scenarios. This technique captures real-world lighting conditions and applies them to the scene, providing more realistic reflections and ambient lighting.