PCF For DirectionalLight/SpotLight Shadows

crates/bevy_pbr/src/lib.rs

@@ -56,10 +56,10 @@ use bevy_asset::{load_internal_asset, AddAsset, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
-    camera::CameraUpdateSystem, extract_resource::ExtractResourcePlugin, prelude::Color,
-    render_asset::prepare_assets, render_graph::RenderGraph, render_phase::sort_phase_system,
-    render_resource::Shader, texture::Image, view::VisibilitySystems, ExtractSchedule, Render,
-    RenderApp, RenderSet,
+    camera::CameraUpdateSystem, extract_component::ExtractComponentPlugin,
+    extract_resource::ExtractResourcePlugin, prelude::Color, render_asset::prepare_assets,
+    render_graph::RenderGraph, render_phase::sort_phase_system, render_resource::Shader,
+    texture::Image, view::VisibilitySystems, ExtractSchedule, Render, RenderApp, RenderSet,
 };
 use bevy_transform::TransformSystem;
 use environment_map::EnvironmentMapPlugin;
@@ -76,6 +76,8 @@ pub const PBR_LIGHTING_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 14170772752254856967);
 pub const SHADOWS_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 11350275143789590502);
+pub const SHADOW_SAMPLING_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 3145627513789590502);
 pub const PBR_SHADER_HANDLE: HandleUntyped =
     HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 4805239651767701046);
 pub const PBR_PREPASS_SHADER_HANDLE: HandleUntyped =
@@ -135,6 +137,12 @@ impl Plugin for PbrPlugin {
             "render/shadows.wgsl",
             Shader::from_wgsl
         );
+        load_internal_asset!(
+            app,
+            SHADOW_SAMPLING_HANDLE,
+            "render/shadow_sampling.wgsl",
+            Shader::from_wgsl
+        );
         load_internal_asset!(
             app,
             PBR_FUNCTIONS_HANDLE,
@@ -179,6 +187,7 @@ impl Plugin for PbrPlugin {
             .register_type::<PointLight>()
             .register_type::<PointLightShadowMap>()
             .register_type::<SpotLight>()
+            .register_type::<ShadowFilteringMethod>()
             .init_resource::<AmbientLight>()
             .init_resource::<GlobalVisiblePointLights>()
             .init_resource::<DirectionalLightShadowMap>()
@@ -193,6 +202,7 @@ impl Plugin for PbrPlugin {
                 EnvironmentMapPlugin,
                 ExtractResourcePlugin::<AmbientLight>::default(),
                 FogPlugin,
+                ExtractComponentPlugin::<ShadowFilteringMethod>::default(),
             ))
             .configure_sets(
                 PostUpdate,

crates/bevy_pbr/src/light.rs

@@ -6,6 +6,7 @@ use bevy_reflect::prelude::*;
 use bevy_render::{
     camera::Camera,
     color::Color,
+    extract_component::ExtractComponent,
     extract_resource::ExtractResource,
     prelude::Projection,
     primitives::{Aabb, CascadesFrusta, CubemapFrusta, Frustum, HalfSpace, Sphere},
@@ -606,6 +607,36 @@ pub struct NotShadowCaster;
 #[reflect(Component, Default)]
 pub struct NotShadowReceiver;
 
+/// Add this component to a [`Camera3d`](bevy_core_pipeline::core_3d::Camera3d)
+/// to control how to anti-alias shadow edges.
+///
+/// The different modes use different approaches to
+/// [Percentage Closer Filtering](https://developer.nvidia.com/gpugems/gpugems/part-ii-lighting-and-shadows/chapter-11-shadow-map-antialiasing).
+///
+/// Currently does not affect point lights.
+#[derive(Component, ExtractComponent, Reflect, Clone, Copy, PartialEq, Eq, Default)]
+#[reflect(Component, Default)]
+pub enum ShadowFilteringMethod {
+    /// Hardware 2x2.
+    ///
+    /// Fast but poor quality.
+    Hardware2x2,
+    /// Method by Ignacio Castaño for The Witness using 9 samples and smart
+    /// filtering to achieve the same as a regular 5x5 filter kernel.
+    ///
+    /// Good quality, good performance.
+    #[default]
+    Castano13,
+    /// Method by Jorge Jimenez for Call of Duty: Advanced Warfare using 8
+    /// samples in spiral pattern, randomly-rotated by interleaved gradient
+    /// noise with spatial variation.
+    ///
+    /// Good quality when used with
+    /// [`TemporalAntiAliasSettings`](bevy_core_pipeline::experimental::taa::TemporalAntiAliasSettings)
+    /// and good performance.
+    Jimenez14,
+}
+
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
 pub enum SimulationLightSystems {
     AddClusters,

crates/bevy_pbr/src/material.rs

@@ -1,7 +1,7 @@
 use crate::{
     render, AlphaMode, DrawMesh, DrawPrepass, EnvironmentMapLight, MeshPipeline, MeshPipelineKey,
     MeshTransforms, PrepassPipelinePlugin, PrepassPlugin, ScreenSpaceAmbientOcclusionSettings,
-    SetMeshBindGroup, SetMeshViewBindGroup, Shadow,
+    SetMeshBindGroup, SetMeshViewBindGroup, Shadow, ShadowFilteringMethod,
 };
 use bevy_app::{App, Plugin};
 use bevy_asset::{AddAsset, AssetEvent, AssetServer, Assets, Handle};
@@ -391,6 +391,7 @@ pub fn queue_material_meshes<M: Material>(
         Option<&Tonemapping>,
         Option<&DebandDither>,
         Option<&EnvironmentMapLight>,
+        Option<&ShadowFilteringMethod>,
         Option<&ScreenSpaceAmbientOcclusionSettings>,
         Option<&NormalPrepass>,
         Option<&TemporalAntiAliasSettings>,
@@ -407,6 +408,7 @@ pub fn queue_material_meshes<M: Material>(
         tonemapping,
         dither,
         environment_map,
+        shadow_filter_method,
         ssao,
         normal_prepass,
         taa_settings,
@@ -438,6 +440,18 @@ pub fn queue_material_meshes<M: Material>(
             view_key |= MeshPipelineKey::ENVIRONMENT_MAP;
         }
 
+        match shadow_filter_method.unwrap_or(&ShadowFilteringMethod::default()) {
+            ShadowFilteringMethod::Hardware2x2 => {
+                view_key |= MeshPipelineKey::SHADOW_FILTER_METHOD_HARDWARE_2X2;
+            }
+            ShadowFilteringMethod::Castano13 => {
+                view_key |= MeshPipelineKey::SHADOW_FILTER_METHOD_CASTANO_13;
+            }
+            ShadowFilteringMethod::Jimenez14 => {
+                view_key |= MeshPipelineKey::SHADOW_FILTER_METHOD_JIMENEZ_14;
+            }
+        }
+
         if !view.hdr {
             if let Some(tonemapping) = tonemapping {
                 view_key |= MeshPipelineKey::TONEMAP_IN_SHADER;

crates/bevy_pbr/src/render/mesh.rs

@@ -759,24 +759,35 @@ bitflags::bitflags! {
         const TONEMAP_METHOD_ACES_FITTED        = 3 << Self::TONEMAP_METHOD_SHIFT_BITS;
         const TONEMAP_METHOD_AGX                = 4 << Self::TONEMAP_METHOD_SHIFT_BITS;
         const TONEMAP_METHOD_SOMEWHAT_BORING_DISPLAY_TRANSFORM = 5 << Self::TONEMAP_METHOD_SHIFT_BITS;
-        const TONEMAP_METHOD_TONY_MC_MAPFACE    = 6 << Self::TONEMAP_METHOD_SHIFT_BITS;
-        const TONEMAP_METHOD_BLENDER_FILMIC     = 7 << Self::TONEMAP_METHOD_SHIFT_BITS;
+        const TONEMAP_METHOD_TONY_MC_MAPFACE     = 6 << Self::TONEMAP_METHOD_SHIFT_BITS;
+        const TONEMAP_METHOD_BLENDER_FILMIC      = 7 << Self::TONEMAP_METHOD_SHIFT_BITS;
+        const SHADOW_FILTER_METHOD_RESERVED_BITS = Self::SHADOW_FILTER_METHOD_MASK_BITS << Self::SHADOW_FILTER_METHOD_SHIFT_BITS;
+        const SHADOW_FILTER_METHOD_HARDWARE_2X2  = 0 << Self::SHADOW_FILTER_METHOD_SHIFT_BITS;
+        const SHADOW_FILTER_METHOD_CASTANO_13    = 1 << Self::SHADOW_FILTER_METHOD_SHIFT_BITS;
+        const SHADOW_FILTER_METHOD_JIMENEZ_14    = 2 << Self::SHADOW_FILTER_METHOD_SHIFT_BITS;
     }
 }
 
 impl MeshPipelineKey {
     const MSAA_MASK_BITS: u32 = 0b111;
     const MSAA_SHIFT_BITS: u32 = 32 - Self::MSAA_MASK_BITS.count_ones();
+
     const PRIMITIVE_TOPOLOGY_MASK_BITS: u32 = 0b111;
     const PRIMITIVE_TOPOLOGY_SHIFT_BITS: u32 =
         Self::MSAA_SHIFT_BITS - Self::PRIMITIVE_TOPOLOGY_MASK_BITS.count_ones();
+
     const BLEND_MASK_BITS: u32 = 0b11;
     const BLEND_SHIFT_BITS: u32 =
         Self::PRIMITIVE_TOPOLOGY_SHIFT_BITS - Self::BLEND_MASK_BITS.count_ones();
+
     const TONEMAP_METHOD_MASK_BITS: u32 = 0b111;
     const TONEMAP_METHOD_SHIFT_BITS: u32 =
         Self::BLEND_SHIFT_BITS - Self::TONEMAP_METHOD_MASK_BITS.count_ones();
 
+    const SHADOW_FILTER_METHOD_MASK_BITS: u32 = 0b11;
+    const SHADOW_FILTER_METHOD_SHIFT_BITS: u32 =
+        Self::TONEMAP_METHOD_SHIFT_BITS - Self::SHADOW_FILTER_METHOD_MASK_BITS.count_ones();
+
     pub fn from_msaa_samples(msaa_samples: u32) -> Self {
         let msaa_bits =
             (msaa_samples.trailing_zeros() & Self::MSAA_MASK_BITS) << Self::MSAA_SHIFT_BITS;
@@ -999,6 +1010,16 @@ impl SpecializedMeshPipeline for MeshPipeline {
             shader_defs.push("TAA".into());
         }
 
+        let shadow_filter_method =
+            key.intersection(MeshPipelineKey::SHADOW_FILTER_METHOD_RESERVED_BITS);
+        if shadow_filter_method == MeshPipelineKey::SHADOW_FILTER_METHOD_HARDWARE_2X2 {
+            shader_defs.push("SHADOW_FILTER_METHOD_HARDWARE_2X2".into());
+        } else if shadow_filter_method == MeshPipelineKey::SHADOW_FILTER_METHOD_CASTANO_13 {
+            shader_defs.push("SHADOW_FILTER_METHOD_CASTANO_13".into());
+        } else if shadow_filter_method == MeshPipelineKey::SHADOW_FILTER_METHOD_JIMENEZ_14 {
+            shader_defs.push("SHADOW_FILTER_METHOD_JIMENEZ_14".into());
+        }
+
         let format = if key.contains(MeshPipelineKey::HDR) {
             ViewTarget::TEXTURE_FORMAT_HDR
         } else {
@@ -1194,10 +1215,12 @@ pub fn prepare_mesh_view_bind_groups(
         Option<&EnvironmentMapLight>,
         &Tonemapping,
     )>,
-    images: Res<RenderAssets<Image>>,
-    mut fallback_images: FallbackImagesMsaa,
-    mut fallback_depths: FallbackImagesDepth,
-    fallback_cubemap: Res<FallbackImageCubemap>,
+    (images, mut fallback_images, mut fallback_depths, fallback_cubemap): (
+        Res<RenderAssets<Image>>,
+        FallbackImagesMsaa,
+        FallbackImagesDepth,
+        Res<FallbackImageCubemap>,
+    ),
     msaa: Res<Msaa>,
     globals_buffer: Res<GlobalsBuffer>,
     tonemapping_luts: Res<TonemappingLuts>,

crates/bevy_pbr/src/render/shadow_sampling.wgsl

@@ -0,0 +1,133 @@
+#define_import_path bevy_pbr::shadow_sampling
+
+#import bevy_pbr::mesh_view_bindings as view_bindings
+#import bevy_pbr::utils PI
+
+fn sample_shadow_map_hardware(light_local: vec2<f32>, depth: f32, array_index: i32) -> f32 {
+    // Do the lookup, using HW 2x2 PCF and comparison
+    // NOTE: Due to non-uniform control flow above, we must use the level variant of the texture
+    // sampler to avoid use of implicit derivatives causing possible undefined behavior.
+#ifdef NO_ARRAY_TEXTURES_SUPPORT
+    return textureSampleCompare(
+        view_bindings::directional_shadow_textures,
+        view_bindings::directional_shadow_textures_sampler,
+        light_local,
+        depth
+    );
+#else
+    return textureSampleCompareLevel(
+        view_bindings::directional_shadow_textures,
+        view_bindings::directional_shadow_textures_sampler,
+        light_local,
+        array_index,
+        depth
+    );
+#endif
+}
+
+// https://web.archive.org/web/20230210095515/http://the-witness.net/news/2013/09/shadow-mapping-summary-part-1
+fn sample_shadow_map_castano_thirteen(light_local: vec2<f32>, depth: f32, array_index: i32) -> f32 {
+    let shadow_map_size = vec2<f32>(textureDimensions(view_bindings::directional_shadow_textures));
+    let inv_shadow_map_size = 1.0 / shadow_map_size;
+
+    let uv = light_local * shadow_map_size;
+    var base_uv = floor(uv + 0.5);
+    let s = (uv.x + 0.5 - base_uv.x);
+    let t = (uv.y + 0.5 - base_uv.y);
+    base_uv -= 0.5;
+    base_uv *= inv_shadow_map_size;
+
+    let uw0 = (4.0 - 3.0 * s);
+    let uw1 = 7.0;
+    let uw2 = (1.0 + 3.0 * s);
+
+    let u0 = (3.0 - 2.0 * s) / uw0 - 2.0;
+    let u1 = (3.0 + s) / uw1;
+    let u2 = s / uw2 + 2.0;
+
+    let vw0 = (4.0 - 3.0 * t);
+    let vw1 = 7.0;
+    let vw2 = (1.0 + 3.0 * t);
+
+    let v0 = (3.0 - 2.0 * t) / vw0 - 2.0;
+    let v1 = (3.0 + t) / vw1;
+    let v2 = t / vw2 + 2.0;
+
+    var sum = 0.0;
+
+    sum += uw0 * vw0 * sample_shadow_map_hardware(base_uv + (vec2(u0, v0) * inv_shadow_map_size), depth, array_index);
+    sum += uw1 * vw0 * sample_shadow_map_hardware(base_uv + (vec2(u1, v0) * inv_shadow_map_size), depth, array_index);
+    sum += uw2 * vw0 * sample_shadow_map_hardware(base_uv + (vec2(u2, v0) * inv_shadow_map_size), depth, array_index);
+
+    sum += uw0 * vw1 * sample_shadow_map_hardware(base_uv + (vec2(u0, v1) * inv_shadow_map_size), depth, array_index);
+    sum += uw1 * vw1 * sample_shadow_map_hardware(base_uv + (vec2(u1, v1) * inv_shadow_map_size), depth, array_index);
+    sum += uw2 * vw1 * sample_shadow_map_hardware(base_uv + (vec2(u2, v1) * inv_shadow_map_size), depth, array_index);
+
+    sum += uw0 * vw2 * sample_shadow_map_hardware(base_uv + (vec2(u0, v2) * inv_shadow_map_size), depth, array_index);
+    sum += uw1 * vw2 * sample_shadow_map_hardware(base_uv + (vec2(u1, v2) * inv_shadow_map_size), depth, array_index);
+    sum += uw2 * vw2 * sample_shadow_map_hardware(base_uv + (vec2(u2, v2) * inv_shadow_map_size), depth, array_index);
+
+    return sum * (1.0 / 144.0);
+}
+
+// https://blog.demofox.org/2022/01/01/interleaved-gradient-noise-a-different-kind-of-low-discrepancy-sequence
+fn interleaved_gradient_noise(pixel_coordinates: vec2<f32>) -> f32 {
+    let frame = f32(view_bindings::globals.frame_count % 64u);
+    let xy = pixel_coordinates + 5.588238 * frame;
+    return fract(52.9829189 * fract(0.06711056 * xy.x + 0.00583715 * xy.y));
+}
+
+fn map(min1: f32, max1: f32, min2: f32, max2: f32, value: f32) -> f32 {
+    return min2 + (value - min1) * (max2 - min2) / (max1 - min1);
+}
+
+fn sample_shadow_map_jimenez_fourteen(light_local: vec2<f32>, depth: f32, array_index: i32, texel_size: f32) -> f32 {
+    let shadow_map_size = vec2<f32>(textureDimensions(view_bindings::directional_shadow_textures));
+
+    let random_angle = 2.0 * PI * interleaved_gradient_noise(light_local * shadow_map_size);
+    let m = vec2(sin(random_angle), cos(random_angle));
+    let rotation_matrix = mat2x2(
+        m.y, -m.x,
+        m.x, m.y
+    );
+
+    let f = map(0.00390625, 0.022949219, 0.015, 0.035, texel_size);
+    let uv_offset_scale = f / (texel_size * shadow_map_size);
+
+    // https://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare (slides 120-135)
+    let sample_offset1 = (rotation_matrix * vec2(-0.7071,  0.7071)) * uv_offset_scale;
+    let sample_offset2 = (rotation_matrix * vec2(-0.0000, -0.8750)) * uv_offset_scale;
+    let sample_offset3 = (rotation_matrix * vec2( 0.5303,  0.5303)) * uv_offset_scale;
+    let sample_offset4 = (rotation_matrix * vec2(-0.6250, -0.0000)) * uv_offset_scale;
+    let sample_offset5 = (rotation_matrix * vec2( 0.3536, -0.3536)) * uv_offset_scale;
+    let sample_offset6 = (rotation_matrix * vec2(-0.0000,  0.3750)) * uv_offset_scale;
+    let sample_offset7 = (rotation_matrix * vec2(-0.1768, -0.1768)) * uv_offset_scale;
+    let sample_offset8 = (rotation_matrix * vec2( 0.1250,  0.0000)) * uv_offset_scale;
+
+    var sum = 0.0;
+    sum += sample_shadow_map_hardware(light_local + sample_offset1, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset2, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset3, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset4, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset5, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset6, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset7, depth, array_index);
+    sum += sample_shadow_map_hardware(light_local + sample_offset8, depth, array_index);
+    return sum / 8.0;
+}
+
+fn sample_shadow_map(light_local: vec2<f32>, depth: f32, array_index: i32, texel_size: f32) -> f32 {
+#ifdef SHADOW_FILTER_METHOD_CASTANO_13
+    return sample_shadow_map_castano_thirteen(light_local, depth, array_index);
+#else ifdef SHADOW_FILTER_METHOD_JIMENEZ_14
+    return sample_shadow_map_jimenez_fourteen(light_local, depth, array_index, texel_size);
+#else ifdef SHADOW_FILTER_METHOD_HARDWARE_2X2
+    return sample_shadow_map_hardware(light_local, depth, array_index);
+#else
+    // This needs a default return value to avoid shader compilation errors if it's compiled with no SHADOW_FILTER_METHOD_* defined.
+    // (eg. if the normal prepass is enabled it ends up compiling this due to the normal prepass depending on pbr_functions, which depends on shadows)
+    // This should never actually get used, as anyone using bevy's lighting/shadows should always have a SHADOW_FILTER_METHOD defined.
+    // Set to 0 to make it obvious that something is wrong.
+    return 0.0;
+#endif
+}