Use a LUT for F_AB

crates/bevy_pbr/src/lib.rs

@@ -176,6 +176,12 @@ pub struct LtcLuts {
     pub ltc_2: Handle<Image>,
 }
 
+/// The split-sum approximation LUT (`F_AB`) indexed by (`NdotV`, `perceptual_roughness`).
+#[derive(Resource, Clone)]
+pub struct FabLut {
+    pub texture: Handle<Image>,
+}
+
 impl Plugin for PbrPlugin {
     fn build(&self, app: &mut App) {
         load_shader_library!(app, "render/pbr_types.wgsl");
@@ -330,6 +336,29 @@ impl Plugin for PbrPlugin {
             }
         }
 
+        let has_fab_lut = app
+            .get_sub_app(RenderApp)
+            .is_some_and(|render_app| render_app.world().is_resource_added::<FabLut>());
+
+        if !has_fab_lut {
+            let mut images = app.world_mut().resource_mut::<Assets<Image>>();
+            let texture = images.add(
+                Image::from_buffer(
+                    include_bytes!("environment_map/f_ab.ktx2"),
+                    ImageType::Extension("ktx2"),
+                    CompressedImageFormats::NONE,
+                    false,
+                    ImageSampler::linear(),
+                    RenderAssetUsages::RENDER_WORLD,
+                )
+                .expect("Failed to decode embedded F_AB LUT"),
+            );
+
+            if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
+                render_app.world_mut().insert_resource(FabLut { texture });
+            }
+        }
+
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };

crates/bevy_pbr/src/render/mesh_view_bindings.rs

@@ -1,4 +1,4 @@
-use crate::LtcLuts;
+use crate::{FabLut, LtcLuts};
 use alloc::sync::Arc;
 use bevy_core_pipeline::{
     oit::{resolve::is_oit_supported, OitBuffers, OrderIndependentTransparencySettings},
@@ -450,6 +450,14 @@ pub fn layout_entries(
         ),
         (39, sampler(SamplerBindingType::Filtering)),
     ));
+    // F_AB
+    entries = entries.extend_with_indices((
+        (
+            40,
+            texture_2d(TextureSampleType::Float { filterable: true }),
+        ),
+        (41, sampler(SamplerBindingType::Filtering)),
+    ));
     let mut binding_array_entries = DynamicBindGroupLayoutEntries::new(ShaderStages::FRAGMENT);
     binding_array_entries = binding_array_entries.extend_with_indices((
         (0, environment_map_entries[0]),
@@ -648,13 +656,22 @@ pub fn prepare_mesh_view_bind_groups(
         Res<ContactShadowsBuffer>,
     ),
     oit_buffers: Res<OitBuffers>,
-    (decals_buffer, render_decals, atmosphere_buffer, atmosphere_sampler, blue_noise, ltc_luts): (
+    (
+        decals_buffer,
+        render_decals,
+        atmosphere_buffer,
+        atmosphere_sampler,
+        blue_noise,
+        ltc_luts,
+        fab_lut,
+    ): (
         Res<DecalsBuffer>,
         Res<RenderClusteredDecals>,
         Option<Res<AtmosphereBuffer>>,
         Option<Res<AtmosphereSampler>>,
         Res<Bluenoise>,
         Res<LtcLuts>,
+        Res<FabLut>,
     ),
 ) {
     if let (
@@ -842,6 +859,13 @@ pub fn prepare_mesh_view_bind_groups(
                 (39, ltc2_sampler),
             ));
 
+            // F_AB
+            let (fab_view, fab_sampler) = images
+                .get(&fab_lut.texture)
+                .map(|img| (&img.texture_view, &img.sampler))
+                .unwrap_or((&fallback_image.d2.texture_view, &fallback_image.d2.sampler));
+            entries = entries.extend_with_indices(((40, fab_view), (41, fab_sampler)));
+
             let mut entries_binding_array = DynamicBindGroupEntries::new();
 
             let environment_map_bind_group_entries = RenderViewEnvironmentMapBindGroupEntries::get(

crates/bevy_pbr/src/render/mesh_view_bindings.wgsl

@@ -111,6 +111,8 @@ const VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE: u32 = 64u;
 @group(0) @binding(37) var ltc_lut1_sampler: sampler;
 @group(0) @binding(38) var ltc_lut2: texture_2d<f32>;
 @group(0) @binding(39) var ltc_lut2_sampler: sampler;
+@group(0) @binding(40) var f_ab_lut: texture_2d<f32>;
+@group(0) @binding(41) var f_ab_lut_sampler: sampler;
 
 #ifdef MULTIPLE_LIGHT_PROBES_IN_ARRAY
 @group(1) @binding(0) var diffuse_environment_maps: binding_array<texture_cube<f32>, 8u>;

crates/bevy_pbr/src/render/pbr_lighting.wgsl

@@ -526,16 +526,8 @@ fn Fd_Burley(
 }
 
 // Scale/bias approximation
-// https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
-// TODO: Use a LUT (more accurate)
 fn F_AB(perceptual_roughness: f32, NdotV: f32) -> vec2<f32> {
-    let c0 = vec4<f32>(-1.0, -0.0275, -0.572, 0.022);
-    let c1 = vec4<f32>(1.0, 0.0425, 1.04, -0.04);
-    let r = perceptual_roughness * c0 + c1;
-    let a004 = min(r.x * r.x, exp2(-9.28 * NdotV)) * r.x + r.y;
-    // Keep F_ab positive to avoid divide-by-zero in downstream BRDF terms.
-    let f_ab_epsilon = 0.00005;
-    return max(vec2<f32>(-1.04, 1.04) * a004 + r.zw, vec2<f32>(f_ab_epsilon));
+    return textureSampleLevel(view_bindings::f_ab_lut, view_bindings::f_ab_lut_sampler, vec2<f32>(NdotV, perceptual_roughness), 0.0).rg;
 }
 
 fn EnvBRDFApprox(F0: vec3<f32>, F_ab: vec2<f32>) -> vec3<f32> {

crates/bevy_solari/src/scene/binder.rs

@@ -8,7 +8,7 @@ use bevy_ecs::{
 };
 use bevy_math::{ops::cos, Mat4, Vec3};
 use bevy_pbr::{
-    ExtractedDirectionalLight, MeshMaterial3d, PreviousGlobalTransform, StandardMaterial,
+    ExtractedDirectionalLight, FabLut, MeshMaterial3d, PreviousGlobalTransform, StandardMaterial,
 };
 use bevy_platform::{collections::HashMap, hash::FixedHasher};
 use bevy_render::{
@@ -48,6 +48,7 @@ pub fn prepare_raytracing_scene_bindings(
     material_assets: Res<StandardMaterialAssets>,
     texture_assets: Res<RenderAssets<GpuImage>>,
     fallback_texture: Res<FallbackImage>,
+    fab_lut: Res<FabLut>,
     render_device: Res<RenderDevice>,
     pipeline_cache: Res<PipelineCache>,
     render_queue: Res<RenderQueue>,
@@ -266,6 +267,14 @@ pub fn prepare_raytracing_scene_bindings(
     command_encoder.build_acceleration_structures(&[], [&tlas]);
     render_queue.submit([command_encoder.finish()]);
 
+    let (fab_view, fab_sampler) = texture_assets
+        .get(&fab_lut.texture)
+        .map(|img| (&img.texture_view, &img.sampler))
+        .unwrap_or((
+            &fallback_texture.d2.texture_view,
+            &fallback_texture.d2.sampler,
+        ));
+
     raytracing_scene_bindings.bind_group = Some(render_device.create_bind_group(
         "raytracing_scene_bind_group",
         &pipeline_cache.get_bind_group_layout(&raytracing_scene_bindings.bind_group_layout),
@@ -283,6 +292,8 @@ pub fn prepare_raytracing_scene_bindings(
             light_sources.binding().unwrap(),
             directional_lights.binding().unwrap(),
             previous_frame_light_id_translations.binding().unwrap(),
+            fab_view,
+            fab_sampler,
         )),
     ));
 }
@@ -310,6 +321,8 @@ impl RaytracingSceneBindings {
                         storage_buffer_read_only_sized(false, None),
                         storage_buffer_read_only_sized(false, None),
                         storage_buffer_read_only_sized(false, None),
+                        texture_2d(TextureSampleType::Float { filterable: true }),
+                        sampler(SamplerBindingType::Filtering),
                     ),
                 ),
             ),

crates/bevy_solari/src/scene/brdf.wgsl

@@ -3,12 +3,12 @@ enable wgpu_ray_query;
 #define_import_path bevy_solari::brdf
 
 #import bevy_core_pipeline::tonemapping::tonemapping_luminance as luminance
-#import bevy_pbr::lighting::{F_AB, D_GGX, V_SmithGGXCorrelated, specular_multiscatter}
+#import bevy_pbr::lighting::{D_GGX, V_SmithGGXCorrelated, specular_multiscatter}
 #import bevy_pbr::pbr_functions::{calculate_tbn_mikktspace, calculate_diffuse_color, calculate_F0}
 #import bevy_pbr::utils::{rand_f, sample_cosine_hemisphere}
 #import bevy_render::maths::PI
 #import bevy_solari::sampling::{sample_ggx_vndf, ggx_vndf_pdf, ggx_vndf_sample_invalid}
-#import bevy_solari::scene_bindings::{ResolvedMaterial, MIRROR_ROUGHNESS_THRESHOLD}
+#import bevy_solari::scene_bindings::{ResolvedMaterial, MIRROR_ROUGHNESS_THRESHOLD, F_AB}
 
 struct EvaluateAndSampleBrdfResult {
     wi: vec3<f32>,

crates/bevy_solari/src/scene/raytracing_scene_bindings.wgsl

@@ -87,6 +87,8 @@ const LIGHT_NOT_PRESENT_THIS_FRAME = 0xFFFFFFFFu;
 @group(0) @binding(10) var<storage> light_sources: array<LightSource>;
 @group(0) @binding(11) var<storage> directional_lights: array<DirectionalLight>;
 @group(0) @binding(12) var<storage> previous_frame_light_id_translations: array<u32>;
+@group(0) @binding(13) var f_ab_lut: texture_2d<f32>;
+@group(0) @binding(14) var f_ab_lut_sampler: sampler;
 
 const RAY_T_MIN = 0.001f;
 const RAY_T_MAX = 100000.0f;
@@ -105,6 +107,11 @@ fn sample_texture(id: u32, uv: vec2<f32>) -> vec3<f32> {
     return textureSampleLevel(textures[id], samplers[id], uv, 0.0).rgb; // TODO: Mipmap
 }
 
+// Scale/bias approximation
+fn F_AB(perceptual_roughness: f32, NdotV: f32) -> vec2<f32> {
+    return textureSampleLevel(f_ab_lut, f_ab_lut_sampler, vec2<f32>(NdotV, perceptual_roughness), 0.0).rg;
+}
+
 struct ResolvedMaterial {
     base_color: vec3<f32>,
     emissive: vec3<f32>,