Update to bevy 0.10, rust-gpu-bridge 0.3, permutate-macro 0.4

Author: ProfLander

Cargo.toml

@@ -10,4 +10,4 @@ crate_type = ["dylib", "rlib"]
 bitflags = "1.3.2"
 spirv-std = { version = "0.5.0", features = ["glam"] }
 permutate-macro = { git = "https://github.com/Bevy-Rust-GPU/permutate-macro", tag = "v0.4.0" }
-rust-gpu-bridge = { git = "https://github.com/Bevy-Rust-GPU/rust-gpu-bridge", tag = "v0.2.0", features = ["spirv-std"] }
+rust-gpu-bridge = { git = "https://github.com/Bevy-Rust-GPU/rust-gpu-bridge", tag = "v0.3.0", features = ["spirv-std"] }

src/clustered_forward.rs

@@ -13,8 +13,11 @@ pub const CLUSTER_COUNT_SIZE: u32 = 9;
 
 // Cluster allocation debug (using 'over' alpha blending)
 pub trait ClusterDebugVisualization {
-    fn cluster_debug_visualization(
-        lights: &Lights,
+    fn cluster_debug_visualization<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        lights: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
         output_color: Vec4,
         view_z: f32,
         is_orthographic: bool,
@@ -24,8 +27,11 @@ pub trait ClusterDebugVisualization {
 }
 
 impl ClusterDebugVisualization for () {
-    fn cluster_debug_visualization(
-        _: &Lights,
+    fn cluster_debug_visualization<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        _: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
         output_color: Vec4,
         _: f32,
         _: bool,
@@ -39,8 +45,11 @@ impl ClusterDebugVisualization for () {
 pub enum DebugZSlices {}
 
 impl ClusterDebugVisualization for DebugZSlices {
-    fn cluster_debug_visualization(
-        lights: &Lights,
+    fn cluster_debug_visualization<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        lights: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
         output_color: Vec4,
         view_z: f32,
         is_orthographic: bool,
@@ -69,8 +78,11 @@ impl ClusterDebugVisualization for DebugZSlices {
 pub enum DebugClusterLightComplexity {}
 
 impl ClusterDebugVisualization for DebugClusterLightComplexity {
-    fn cluster_debug_visualization(
-        _: &Lights,
+    fn cluster_debug_visualization<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        _: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
         mut output_color: Vec4,
         _: f32,
         _: bool,
@@ -100,8 +112,11 @@ impl ClusterDebugVisualization for DebugClusterLightComplexity {
 pub enum DebugClusterCoherency {}
 
 impl ClusterDebugVisualization for DebugClusterCoherency {
-    fn cluster_debug_visualization(
-        _: &Lights,
+    fn cluster_debug_visualization<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        _: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
         output_color: Vec4,
         _: f32,
         _: bool,

src/environment_map.rs

@@ -0,0 +1,105 @@
+use rust_gpu_bridge::{
+    glam::{Vec2, Vec3, Vec4},
+    pow::Pow,
+};
+use spirv_std::Sampler;
+
+use crate::prelude::{Lights, TextureCube};
+
+pub trait EnvironmentMap {
+    fn environment_map_light<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        lights: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
+        environment_map_diffuse: &TextureCube,
+        environment_map_specular: &TextureCube,
+        environment_map_sampler: &Sampler,
+        perceptual_roughness: f32,
+        roughness: f32,
+        diffuse_color: Vec3,
+        n_dot_v: f32,
+        f_ab: Vec2,
+        n: Vec3,
+        r: Vec3,
+        f0: Vec3,
+    ) -> EnvironmentMapLight;
+}
+
+impl EnvironmentMap for () {
+    fn environment_map_light<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        lights: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
+        environment_map_diffuse: &TextureCube,
+        environment_map_specular: &TextureCube,
+        environment_map_sampler: &Sampler,
+        perceptual_roughness: f32,
+        roughness: f32,
+        diffuse_color: Vec3,
+        n_dot_v: f32,
+        f_ab: Vec2,
+        n: Vec3,
+        r: Vec3,
+        f0: Vec3,
+    ) -> EnvironmentMapLight {
+        Default::default()
+    }
+}
+
+#[derive(Default, Copy, Clone, PartialEq)]
+pub struct EnvironmentMapLight {
+    pub diffuse: Vec3,
+    pub specular: Vec3,
+}
+
+impl EnvironmentMap for EnvironmentMapLight {
+    fn environment_map_light<
+        const MAX_DIRECTIONAL_LIGHTS: usize,
+        const MAX_CASCADES_PER_LIGHT: usize,
+    >(
+        lights: &Lights<MAX_DIRECTIONAL_LIGHTS, MAX_CASCADES_PER_LIGHT>,
+        environment_map_diffuse: &TextureCube,
+        environment_map_specular: &TextureCube,
+        environment_map_sampler: &Sampler,
+        perceptual_roughness: f32,
+        roughness: f32,
+        diffuse_color: Vec3,
+        n_dot_v: f32,
+        f_ab: Vec2,
+        n: Vec3,
+        r: Vec3,
+        f0: Vec3,
+    ) -> EnvironmentMapLight {
+        // Split-sum approximation for image based lighting: https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
+        // Technically we could use textureNumLevels(environment_map_specular) - 1 here, but we use a uniform
+        // because textureNumLevels() does not work on WebGL2
+        let radiance_level =
+            perceptual_roughness * (lights.environment_map_smallest_specular_mip_level) as f32;
+        let irradiance = environment_map_diffuse
+            .sample::<f32, Vec4>(*environment_map_sampler, n)
+            .truncate();
+        let radiance = environment_map_specular
+            .sample_by_lod::<f32, Vec4>(*environment_map_sampler, r, radiance_level)
+            .truncate();
+
+        // Multiscattering approximation: https://www.jcgt.org/published/0008/01/03/paper.pdf
+        // Useful reference: https://bruop.github.io/ibl
+        let fr = Vec3::splat(1.0 - roughness).max(f0) - f0;
+        let ks = f0 + fr * (1.0 - n_dot_v).pow(5.0);
+        let fss_ess = ks * f_ab.x + f_ab.y;
+        let ess = f_ab.x + f_ab.y;
+        let ems = 1.0 - ess;
+        let favg = f0 + (1.0 - f0) / 21.0;
+        let fms = fss_ess * favg / (1.0 - ems * favg);
+        let fms_ems = fms * ems;
+        let edss = 1.0 - (fss_ess + fms_ems);
+        let kd = diffuse_color * edss;
+
+        EnvironmentMapLight {
+            diffuse: (fms_ems + kd) * irradiance,
+            specular: fss_ess * radiance,
+        }
+    }
+}

src/fog.rs

@@ -0,0 +1,93 @@
+// Fog formulas adapted from:
+// https://learn.microsoft.com/en-us/windows/win32/direct3d9/fog-formulas
+// https://catlikecoding.com/unity/tutorials/rendering/part-14/
+// https://iquilezles.org/articles/fog/ (Atmospheric Fog and Scattering)
+
+use rust_gpu_bridge::glam::{Vec3, Vec4};
+use spirv_std::num_traits::Float;
+
+// Important: These must be kept in sync with `fog.rs`
+pub const FOG_MODE_OFF: u32 = 0;
+pub const FOG_MODE_LINEAR: u32 = 1;
+pub const FOG_MODE_EXPONENTIAL: u32 = 2;
+pub const FOG_MODE_EXPONENTIAL_SQUARED: u32 = 3;
+pub const FOG_MODE_ATMOSPHERIC: u32 = 4;
+
+#[repr(C, packed(4))]
+pub struct Fog {
+    pub base_color: Vec4,
+    pub directional_light_color: Vec4,
+    // `be` and `bi` are allocated differently depending on the fog mode
+    //
+    // For Linear Fog:
+    //     be.x = start, be.y = end
+    // For Exponential and ExponentialSquared Fog:
+    //     be.x = density
+    // For Atmospheric Fog:
+    //     be = per-channel extinction density
+    //     bi = per-channel inscattering density
+    //pub be: Vec3,
+    pub be_x: f32,
+    pub be_y: f32,
+    pub be_z: f32,
+    pub directional_light_exponent: f32,
+    //pub bi: Vec3,
+    pub bi_x: f32,
+    pub bi_y: f32,
+    pub bi_z: f32,
+    pub mode: u32,
+}
+
+impl Fog {
+    pub fn scattering_adjusted_fog_color(&self, scattering: Vec3) -> Vec4 {
+        if self.directional_light_color.w > 0.0 {
+            return (self.base_color.truncate()
+                + scattering
+                    * self.directional_light_color.truncate()
+                    * self.directional_light_color.w)
+                .extend(self.base_color.w);
+        } else {
+            return self.base_color;
+        }
+    }
+
+    pub fn linear_fog(&self, input_color: Vec4, distance: f32, scattering: Vec3) -> Vec4 {
+        let mut fog_color = self.scattering_adjusted_fog_color(scattering);
+        let start = self.be_x;
+        let end = self.be_y;
+        fog_color.w *= 1.0 - ((end - distance) / (end - start)).clamp(0.0, 1.0);
+        return input_color
+            .truncate()
+            .lerp(fog_color.truncate(), fog_color.w)
+            .extend(input_color.w);
+    }
+
+    pub fn exponential_fog(&self, input_color: Vec4, distance: f32, scattering: Vec3) -> Vec4 {
+        let mut fog_color = self.scattering_adjusted_fog_color(scattering);
+        let density = self.be_x;
+        fog_color.w *= 1.0 - 1.0 / (distance * density).exp();
+        return input_color
+            .truncate()
+            .lerp(fog_color.truncate(), fog_color.w)
+            .extend(input_color.w);
+    }
+
+    pub fn exponential_squared_fog(&self, input_color: Vec4, distance: f32, scattering: Vec3) -> Vec4 {
+        let mut fog_color = self.scattering_adjusted_fog_color(scattering);
+        let distance_times_density = distance * self.be_x;
+        fog_color.w *= 1.0 - 1.0 / (distance_times_density * distance_times_density).exp();
+        return input_color
+            .truncate()
+            .lerp(fog_color.truncate(), fog_color.w)
+            .extend(input_color.w);
+    }
+
+    pub fn atmospheric_fog(&self, input_color: Vec4, distance: f32, scattering: Vec3) -> Vec4 {
+        let fog_color = self.scattering_adjusted_fog_color(scattering);
+        let extinction_factor = 1.0 - 1.0 / (distance * Vec3::new(self.be_x, self.be_y, self.be_z)).exp();
+        let inscattering_factor = 1.0 - 1.0 / (distance * Vec3::new(self.bi_x, self.bi_y, self.bi_z)).exp();
+        return (input_color.truncate() * (1.0 - extinction_factor * fog_color.w)
+            + fog_color.truncate() * inscattering_factor * fog_color.w)
+            .extend(input_color.w);
+    }
+}

src/lib.rs

@@ -3,11 +3,12 @@
 use rust_gpu_bridge::glam;
 
 pub mod clustered_forward;
+pub mod fog;
 pub mod mesh;
 pub mod mesh_view;
 pub mod pbr;
 pub mod prelude;
 pub mod shadows;
 pub mod skinning;
 pub mod tonemapping_shared;
-
+pub mod environment_map;

src/mesh/entry_points.rs

@@ -20,9 +20,25 @@ use super::mesh_position_local_to_world;
         color: some | none,
         skinned: some | none
     },
+    constants = {},
     permutations = [
-        (none, none, none),
-        (some, some, some),
+        {
+            parameters = [
+                none,
+                none,
+                none
+            ],
+            constants = {}
+        },
+        {
+            parameters = [
+                some,
+                some,
+                some
+            ],
+            constants = {
+            }
+        },
         file("../../entry_points.json", "mesh::entry_points"),
         env("BEVY_PBR_RUST_MESH_VERTEX_PERMUTATIONS", "mesh::entry_points")
     ]

src/mesh_view/bindings.rs

@@ -1,8 +1,64 @@
-use spirv_std::Image;
+use spirv_std::{spirv, Image, Sampler};
 
+use crate::{
+    fog::Fog,
+    prelude::{
+        ClusterLightIndexLists, ClusterOffsetsAndCounts, DirectionalShadowTextures, Globals,
+        Lights, PointLights, PointShadowTextures, View,
+    },
+};
+
+pub type Texture2d = Image!(2D, type = f32, sampled = true);
+pub type Texture3d = Image!(3D, type = f32, sampled = true);
+pub type TextureCube = Image!(cube, type = f32, sampled = true);
 pub type TextureDepthCube = Image!(cube, type = f32, sampled = true, depth = true);
 pub type TextureDepthCubeArray =
     Image!(cube, type = f32, sampled = true, depth = true, arrayed = true);
 
 pub type TextureDepth2d = Image!(2D, type = f32, sampled = true, depth = true);
 pub type TextureDepth2dArray = Image!(2D, type = f32, sampled = true, depth = true, arrayed = true);
+
+pub type TextureMultisampled2d = Image!(2D, type = f32, sampled = true, multisampled = true);
+pub type TextureDepthMultisampled2d =
+    Image!(2D, type = f32, sampled = true, multisampled = true, depth = true);
+
+pub trait DepthPrepassTexture {}
+
+impl DepthPrepassTexture for TextureDepthMultisampled2d {}
+impl DepthPrepassTexture for TextureDepth2d {}
+
+pub trait NormalPrepassTexture {}
+
+impl NormalPrepassTexture for TextureMultisampled2d {}
+impl NormalPrepassTexture for Texture2d {}
+
+#[allow(unused_variables)]
+#[spirv(fragment)]
+pub fn mesh_view_bindings<
+    const MAX_DIRECTIONAL_LIGHTS: usize,
+    const MAX_CASCADES_PER_LIGHT: usize,
+>(
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] view: &View,
+    #[spirv(descriptor_set = 0, binding = 1)] lights: &Lights<
+        MAX_DIRECTIONAL_LIGHTS,
+        MAX_CASCADES_PER_LIGHT,
+    >,
+    #[spirv(descriptor_set = 0, binding = 2)] point_shadow_textures: &impl PointShadowTextures,
+    #[spirv(descriptor_set = 0, binding = 3)] point_shadow_textures_sampler: &Sampler,
+    #[spirv(descriptor_set = 0, binding = 4)]
+    directional_shadow_textures: &impl DirectionalShadowTextures,
+    #[spirv(descriptor_set = 0, binding = 5)] directional_shadow_textures_sampler: &Sampler,
+    #[spirv(descriptor_set = 0, binding = 6)] point_lights: &impl PointLights,
+    #[spirv(descriptor_set = 0, binding = 7)] cluster_light_index_lists: &impl ClusterLightIndexLists,
+    #[spirv(descriptor_set = 0, binding = 8)] cluster_offsets_and_counts: &impl ClusterOffsetsAndCounts,
+    #[spirv(descriptor_set = 0, binding = 9)] globals: &Globals,
+    #[spirv(descriptor_set = 0, binding = 10)] fog: &Fog,
+    #[spirv(descriptor_set = 0, binding = 11)] environment_map_diffuse: &TextureCube,
+    #[spirv(descriptor_set = 0, binding = 12)] environment_map_specular: &TextureCube,
+    #[spirv(descriptor_set = 0, binding = 13)] environment_map_sampler: &Sampler,
+    #[spirv(descriptor_set = 0, binding = 14)] dt_lut_texture: &Texture3d,
+    #[spirv(descriptor_set = 0, binding = 15)] dt_lut_sampler: &Sampler,
+    #[spirv(descriptor_set = 0, binding = 16)] depth_prepass_texture: &impl DepthPrepassTexture,
+    #[spirv(descriptor_set = 0, binding = 17)] normal_prepass_texture: &impl NormalPrepassTexture,
+) {
+}