fixed problems with the skybox after slabbing

Author: schell

crates/renderling-shader/src/convolution.rs

@@ -12,7 +12,7 @@ use spirv_std::{
 #[cfg(target_arch = "spirv")]
 use spirv_std::num_traits::Float;
 
-use crate::{pbr, IsVector};
+use crate::{pbr, stage::Camera, IsVector};
 
 fn radical_inverse_vdc(mut bits: u32) -> f32 {
     bits = (bits << 16u32) | (bits >> 16u32);
@@ -149,40 +149,46 @@ pub fn integrate_brdf_doesnt_work(mut n_dot_v: f32, roughness: f32) -> Vec2 {
     Vec2::new(a, b)
 }
 
-/// Expects a slab to contain a [`crate::stage::Camera`] followed by a `f32`
+/// Used by [`vertex_prefilter_environment_cubemap`] to read the camera and
+/// roughness values from the slab.
+#[derive(Default, SlabItem)]
+pub struct VertexPrefilterEnvironmentCubemapIds {
+    pub camera: Id<Camera>,
+    pub roughness: Id<f32>,
+}
+
+/// Uses the `instance_index` as the [`Id`] of a [`PrefilterEnvironmentIds`].
 /// roughness value.
-// TODO: merge this with the standard pass-thru cubemap vertex shader.
 #[spirv(vertex)]
 pub fn vertex_prefilter_environment_cubemap(
+    #[spirv(instance_index)] instance_index: u32,
     #[spirv(vertex_index)] vertex_id: u32,
     #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] slab: &[u32],
     out_pos: &mut Vec3,
+    out_roughness: &mut f32,
     #[spirv(position)] gl_pos: &mut Vec4,
 ) {
     let in_pos = crate::math::CUBE[vertex_id as usize];
-    let camera = slab.read::<crate::stage::Camera>(0u32.into());
+    let VertexPrefilterEnvironmentCubemapIds { camera, roughness } =
+        slab.read(Id::new(instance_index));
+    let camera = slab.read(camera);
+    *out_roughness = slab.read(roughness);
     *out_pos = in_pos;
     *gl_pos = camera.projection * camera.view * in_pos.extend(1.0);
 }
 
 /// Lambertian prefilter.
-///
-/// Expects a slab to contain a [`crate::stage::Camera`] followed by a `f32`
-/// roughness value.
 #[spirv(fragment)]
 pub fn fragment_prefilter_environment_cubemap(
-    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] slab: &[u32],
     #[spirv(descriptor_set = 0, binding = 1)] environment_cubemap: &Cubemap,
     #[spirv(descriptor_set = 0, binding = 2)] sampler: &Sampler,
     in_pos: Vec3,
+    in_roughness: f32,
     frag_color: &mut Vec4,
 ) {
-    let roughness = slab.read(Id::<f32>::from(crate::stage::Camera::slab_size()));
     let mut n = in_pos.alt_norm_or_zero();
     // `wgpu` and vulkan's y coords are flipped from opengl
     n.y *= -1.0;
-    // These moves are redundant but the names have connections to the PBR
-    // equations.
     let r = n;
     let v = r;
 
@@ -191,12 +197,12 @@ pub fn fragment_prefilter_environment_cubemap(
 
     for i in 0..SAMPLE_COUNT {
         let xi = hammersley(i, SAMPLE_COUNT);
-        let h = importance_sample_ggx(xi, n, roughness);
+        let h = importance_sample_ggx(xi, n, in_roughness);
         let l = (2.0 * v.dot(h) * h - v).alt_norm_or_zero();
 
         let n_dot_l = n.dot(l).max(0.0);
         if n_dot_l > 0.0 {
-            let mip_level = if roughness == 0.0 {
+            let mip_level = if in_roughness == 0.0 {
                 0.0
             } else {
                 calc_lod(n_dot_l)

crates/renderling-shader/src/skybox.rs

@@ -56,18 +56,19 @@ pub fn fragment_cubemap(
 
 /// Draws a cubemap.
 ///
-/// Expects there to be a [`Camera`] in the slab at index 0.
+/// Uses the `instance_index` as the [`Id`] for a [`Camera`].
 ///
 /// Used to create a cubemap from an equirectangular image as well as cubemap
 /// convolutions.
 #[spirv(vertex)]
 pub fn vertex_cubemap(
+    #[spirv(instance_index)] camera_index: u32,
     #[spirv(vertex_index)] vertex_index: u32,
     #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] slab: &[u32],
     local_pos: &mut Vec3,
     #[spirv(position)] gl_pos: &mut Vec4,
 ) {
-    let camera = slab.read(Id::<Camera>::new(0));
+    let camera = slab.read(Id::<Camera>::new(camera_index));
     let pos = crate::math::CUBE[vertex_index as usize];
     *local_pos = pos;
     *gl_pos = camera.projection * camera.view * pos.extend(1.0);