Environment Map Filtering GPU pipeline (#19076)

# Objective

This PR implements a robust GPU-based pipeline for dynamically
generating environment maps in Bevy. It builds upon PR #19037, allowing
these changes to be evaluated independently from the atmosphere
implementation.

While existing offline tools can process environment maps, generate mip
levels, and calculate specular lighting with importance sampling,
they're limited to static file-based workflows. This PR introduces a
real-time GPU pipeline that dynamically generates complete environment
maps from a single cubemap texture on each frame.

Closes #9380 

## Solution

Implemented a Single Pass Downsampling (SPD) pipeline that processes
textures without pre-existing mip levels or pre-filtered lighting data.

Single Pass Downsampling (SPD) pipeline:
- accepts any square, power-of-two cubemap up to 8192 × 8192 per face
and generates the complete mip chain in one frame;
- copies the base mip (level 0) in a dedicated compute dispatch
(`copy_mip0`) before the down-sampling pass;
- performs the down-sampling itself in two compute dispatches to fit
within subgroup limits;
- heavily inspired by Jasmine's prototype code.

Pre-filtering pipeline:
- generates the specular Radiance Map using bounded-VNDF GGX importance
sampling for higher quality highlights and fewer fireflies;
- computes the diffuse Irradiance Map with cosine-weighted hemisphere
sampling;
- mirrors the forward-/reverse-tonemap workflow used by TAA instead of
exposing a separate *white-point* parameter;
- is based on the resources below together with the “Bounded VNDF
Sampling for Smith-GGX Reflections” paper.

The pre-filtering pipeline is largely based on these articles:
-
https://placeholderart.wordpress.com/2015/07/28/implementation-notes-runtime-environment-map-filtering-for-image-based-lighting/
- https://bruop.github.io/ibl/
-
https://gpuopen.com/download/Bounded_VNDF_Sampling_for_Smith-GGX_Reflections.pdf

> The forward-/reverse-tonemap trick removes almost all fireflies
without the need for a separate white-point parameter.

Previous work: #9414

## Testing

The `reflection_probes.rs` example has been updated:

- The camera starts closer to the spheres so the reflections are easier
to see.
- The GLTF scene is spawned only when the reflection probe mode is
active (press Space).
- The third display mode (toggled with Space) shows the generated
cubemap chain.
- You can change the roughness of the center sphere with the Up/Down
keys.

## Render Graph

Composed of two nodes and a graph edge:
```
Downsampling -> Filtering
```

Pass breakdown:
```
dowsampling_first_pass -> dowsampling_second_pass ->
radiance_map_pass -> irradiance_map_pass
```

<img width="1601" height="2281" alt="render-graph"
src="https://github.com/user-attachments/assets/3c240688-32f7-447a-9ede-6050b77c0bd1"
/>

---

## Showcase
<img width="2564" height="1500" alt="image"
src="https://github.com/user-attachments/assets/56e68dd7-9488-4d35-9bba-7f713a3e2831"
/>


User facing API:
```rust
commands.entity(camera)
    .insert(GeneratedEnvironmentMapLight {
        environment_map: world.load_asset("environment_maps/pisa_specular_rgb9e5_zstd.ktx2"),
        ..default()
    });
```

## Computed Environment Maps
To use fully dynamic environment maps, create a new placeholder image
handle with `Image::new_fill`, extract it to the render world. Then
dispatch a compute shader, bind the image as a 2d array storage texture.
Anything can be rendered to the custom dynamic environment map.
This is already demonstrated in PR #19037 with the `atmosphere.rs`
example.

We can extend this idea further and run the entire PBR pipeline from the
perspective of the light probe, and it is possible to have some form of
global illumination or baked lighting information this way, especially
if we make use of irradiance volumes for the realtime aspect. This
method could very well be extended to bake indirect lighting in the
scene.
#13840 should make this possible!

## Notes for reviewers

This PR no longer bundles any large test textures.

---------

Co-authored-by: atlas <[email protected]>

Author: mate-h

crates/bevy_light/src/lib.rs

@@ -27,7 +27,7 @@ use cluster::{
 mod ambient_light;
 pub use ambient_light::AmbientLight;
 mod probe;
-pub use probe::{EnvironmentMapLight, IrradianceVolume, LightProbe};
+pub use probe::{EnvironmentMapLight, GeneratedEnvironmentMapLight, IrradianceVolume, LightProbe};
 mod volumetric;
 pub use volumetric::{FogVolume, VolumetricFog, VolumetricLight};
 pub mod cascade;

crates/bevy_light/src/probe.rs

@@ -108,6 +108,38 @@ impl Default for EnvironmentMapLight {
     }
 }
 
+/// A generated environment map that is filtered at runtime.
+///
+/// See `bevy_pbr::light_probe::generate` for detailed information.
+#[derive(Clone, Component, Reflect)]
+#[reflect(Component, Default, Clone)]
+pub struct GeneratedEnvironmentMapLight {
+    /// Source cubemap to be filtered on the GPU, size must be a power of two.
+    pub environment_map: Handle<Image>,
+
+    /// Scale factor applied to the diffuse and specular light generated by this
+    /// component. Expressed in cd/m² (candela per square meter).
+    pub intensity: f32,
+
+    /// World-space rotation applied to the cubemap.
+    pub rotation: Quat,
+
+    /// Whether this light contributes diffuse lighting to meshes that already
+    /// have baked lightmaps.
+    pub affects_lightmapped_mesh_diffuse: bool,
+}
+
+impl Default for GeneratedEnvironmentMapLight {
+    fn default() -> Self {
+        GeneratedEnvironmentMapLight {
+            environment_map: Handle::default(),
+            intensity: 0.0,
+            rotation: Quat::IDENTITY,
+            affects_lightmapped_mesh_diffuse: true,
+        }
+    }
+}
+
 /// The component that defines an irradiance volume.
 ///
 /// See `bevy_pbr::irradiance_volume` for detailed information.

crates/bevy_pbr/src/lib.rs

@@ -88,8 +88,8 @@ pub mod prelude {
     };
     #[doc(hidden)]
     pub use bevy_light::{
-        light_consts, AmbientLight, DirectionalLight, EnvironmentMapLight, LightProbe, PointLight,
-        SpotLight,
+        light_consts, AmbientLight, DirectionalLight, EnvironmentMapLight,
+        GeneratedEnvironmentMapLight, LightProbe, PointLight, SpotLight,
     };
 }
 
@@ -133,7 +133,7 @@ pub mod graph {
 
 use crate::{deferred::DeferredPbrLightingPlugin, graph::NodePbr};
 use bevy_app::prelude::*;
-use bevy_asset::{AssetApp, AssetPath, Assets, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, AssetApp, AssetPath, Assets, Handle};
 use bevy_core_pipeline::core_3d::graph::{Core3d, Node3d};
 use bevy_ecs::prelude::*;
 use bevy_image::Image;
@@ -185,6 +185,13 @@ impl Default for PbrPlugin {
     }
 }
 
+/// A resource that stores the spatio-temporal blue noise texture.
+#[derive(Resource)]
+pub struct Bluenoise {
+    /// Texture handle for spatio-temporal blue noise
+    pub texture: Handle<Image>,
+}
+
 impl Plugin for PbrPlugin {
     fn build(&self, app: &mut App) {
         load_shader_library!(app, "render/pbr_types.wgsl");
@@ -273,12 +280,19 @@ impl Plugin for PbrPlugin {
                 },
             );
 
+        // Load the Spatio-temporal blue noise texture
+        embedded_asset!(app, "stbn.ktx2");
+        let bluenoise_texture = load_embedded_asset!(app, "stbn.ktx2");
+
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
 
         // Extract the required data from the main world
         render_app
+            .insert_resource(Bluenoise {
+                texture: bluenoise_texture,
+            })
             .add_systems(
                 RenderStartup,
                 (

crates/bevy_pbr/src/light_probe/copy.wgsl

@@ -0,0 +1,21 @@
+// Copy the base mip (level 0) from a source cubemap to a destination cubemap,
+// performing format conversion if needed (the destination is always rgba16float).
+// The alpha channel is filled with 1.0.
+
+@group(0) @binding(0) var src_cubemap: texture_2d_array<f32>;
+@group(0) @binding(1) var dst_cubemap: texture_storage_2d_array<rgba16float, write>;
+
+@compute
+@workgroup_size(8, 8, 1)
+fn copy(@builtin(global_invocation_id) global_id: vec3u) {
+    let size = textureDimensions(src_cubemap).xy;
+
+    // Bounds check
+    if (any(global_id.xy >= size)) {
+        return;
+    }
+
+    let color = textureLoad(src_cubemap, vec2u(global_id.xy), global_id.z, 0);
+
+    textureStore(dst_cubemap, vec2u(global_id.xy), global_id.z, vec4f(color.rgb, 1.0));
+}