Multiview camera rendering: proof-of-concept continuation of #16059

.gitignore

@@ -42,3 +42,6 @@ compressed_texture_cache
 
 # Generated by "examples/dev_tools/schedule_data.rs"
 **/app_data.ron
+
+# AI assistant scratch notes (architecture reverse-engineering, never committed)
+.scratch/

crates/bevy_anti_alias/src/fxaa/fxaa.wgsl

@@ -7,8 +7,8 @@
 // Tweaks by mrDIMAS - https://github.com/FyroxEngine/Fyrox/blob/master/src/renderer/shaders/fxaa_fs.glsl
 
 #import bevy_core_pipeline::fullscreen_vertex_shader::FullscreenVertexOutput
+#import bevy_core_pipeline::input_texture::{input_texture, sample_input_level, current_view_index}
 
-@group(0) @binding(0) var screenTexture: texture_2d<f32>;
 @group(0) @binding(1) var samp: sampler;
 
 // Trims the algorithm from processing darks.
@@ -73,22 +73,40 @@ fn rgb2luma(rgb: vec3<f32>) -> f32 {
 
 // Performs FXAA post-process anti-aliasing as described in the Nvidia FXAA white paper and the associated shader code.
 @fragment
-fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
-    let resolution = vec2<f32>(textureDimensions(screenTexture));
+fn fragment(
+    in: FullscreenVertexOutput,
+#ifdef MULTIVIEW
+    @builtin(view_index) view_index: i32,
+#endif
+) -> @location(0) vec4<f32> {
+#ifdef MULTIVIEW
+    current_view_index = view_index;
+#endif
+    let resolution = vec2<f32>(textureDimensions(input_texture));
     let inverseScreenSize = 1.0 / resolution.xy;
     let texCoord = in.position.xy * inverseScreenSize;
 
-    let centerSample = textureSampleLevel(screenTexture, samp, texCoord, 0.0);
+    let centerSample = sample_input_level(samp, texCoord, 0.0);
     let colorCenter = centerSample.rgb;
 
     // Luma at the current fragment
     let lumaCenter = rgb2luma(colorCenter);
 
     // Luma at the four direct neighbors of the current fragment.
-    let lumaDown = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(0, -1)).rgb);
-    let lumaUp = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(0, 1)).rgb);
-    let lumaLeft = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(-1, 0)).rgb);
-    let lumaRight = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(1, 0)).rgb);
+    // WGSL requires the const-offset operand of textureSampleLevel to be a
+    // const-expression, so it can't pass through a helper — branch the
+    // multiview/non-multiview cases at the callsite.
+#ifdef MULTIVIEW
+    let lumaDown = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(0, -1)).rgb);
+    let lumaUp = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(0, 1)).rgb);
+    let lumaLeft = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(-1, 0)).rgb);
+    let lumaRight = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(1, 0)).rgb);
+#else
+    let lumaDown = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(0, -1)).rgb);
+    let lumaUp = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(0, 1)).rgb);
+    let lumaLeft = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(-1, 0)).rgb);
+    let lumaRight = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(1, 0)).rgb);
+#endif
 
     // Find the maximum and minimum luma around the current fragment.
     let lumaMin = min(lumaCenter, min(min(lumaDown, lumaUp), min(lumaLeft, lumaRight)));
@@ -102,11 +120,19 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
         return centerSample;
     }
 
-    // Query the 4 remaining corners lumas.
-    let lumaDownLeft  = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(-1, -1)).rgb);
-    let lumaUpRight   = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(1, 1)).rgb);
-    let lumaUpLeft    = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(-1, 1)).rgb);
-    let lumaDownRight = rgb2luma(textureSampleLevel(screenTexture, samp, texCoord, 0.0, vec2<i32>(1, -1)).rgb);
+    // Query the 4 remaining corners lumas. Same const-offset constraint as
+    // above — duplicate the call set under MULTIVIEW.
+#ifdef MULTIVIEW
+    let lumaDownLeft  = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(-1, -1)).rgb);
+    let lumaUpRight   = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(1, 1)).rgb);
+    let lumaUpLeft    = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(-1, 1)).rgb);
+    let lumaDownRight = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, current_view_index, 0.0, vec2<i32>(1, -1)).rgb);
+#else
+    let lumaDownLeft  = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(-1, -1)).rgb);
+    let lumaUpRight   = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(1, 1)).rgb);
+    let lumaUpLeft    = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(-1, 1)).rgb);
+    let lumaDownRight = rgb2luma(textureSampleLevel(input_texture, samp, texCoord, 0.0, vec2<i32>(1, -1)).rgb);
+#endif
 
     // Combine the four edges lumas (using intermediary variables for future computations with the same values).
     let lumaDownUp = lumaDown + lumaUp;
@@ -174,8 +200,8 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
     var uv2 = currentUv + offset; // * QUALITY(0); // (quality 0 is 1.0)
 
     // Read the lumas at both current extremities of the exploration segment, and compute the delta wrt to the local average luma.
-    var lumaEnd1 = rgb2luma(textureSampleLevel(screenTexture, samp, uv1, 0.0).rgb);
-    var lumaEnd2 = rgb2luma(textureSampleLevel(screenTexture, samp, uv2, 0.0).rgb);
+    var lumaEnd1 = rgb2luma(sample_input_level(samp, uv1, 0.0).rgb);
+    var lumaEnd2 = rgb2luma(sample_input_level(samp, uv2, 0.0).rgb);
     lumaEnd1 = lumaEnd1 - lumaLocalAverage;
     lumaEnd2 = lumaEnd2 - lumaLocalAverage;
 
@@ -192,13 +218,13 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
     if (!reachedBoth) {
         for (var i: i32 = 2; i < ITERATIONS; i = i + 1) {
             // If needed, read luma in 1st direction, compute delta.
-            if (!reached1) { 
-                lumaEnd1 = rgb2luma(textureSampleLevel(screenTexture, samp, uv1, 0.0).rgb);
+            if (!reached1) {
+                lumaEnd1 = rgb2luma(sample_input_level(samp, uv1, 0.0).rgb);
                 lumaEnd1 = lumaEnd1 - lumaLocalAverage;
             }
             // If needed, read luma in opposite direction, compute delta.
-            if (!reached2) { 
-                lumaEnd2 = rgb2luma(textureSampleLevel(screenTexture, samp, uv2, 0.0).rgb);
+            if (!reached2) {
+                lumaEnd2 = rgb2luma(sample_input_level(samp, uv2, 0.0).rgb);
                 lumaEnd2 = lumaEnd2 - lumaLocalAverage;
             }
             // If the luma deltas at the current extremities is larger than the local gradient, we have reached the side of the edge.
@@ -269,6 +295,6 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
     }
 
     // Read the color at the new UV coordinates, and use it.
-    var finalColor = textureSampleLevel(screenTexture, samp, finalUv, 0.0).rgb;
+    var finalColor = sample_input_level(samp, finalUv, 0.0).rgb;
     return vec4<f32>(finalColor, centerSample.a);
 }

crates/bevy_anti_alias/src/fxaa/mod.rs

@@ -12,15 +12,16 @@ use bevy_render::{
     camera::ExtractedCamera,
     extract_component::{ExtractComponent, ExtractComponentPlugin},
     render_resource::{
-        binding_types::{sampler, texture_2d},
+        binding_types::{sampler, texture_2d, texture_2d_array},
         *,
     },
     renderer::RenderDevice,
-    view::ExtractedView,
+    view::{ExtractedMultiview, ExtractedView},
     GpuResourceAppExt, Render, RenderApp, RenderStartup, RenderSystems,
 };
-use bevy_shader::Shader;
+use bevy_shader::{Shader, ShaderDefVal};
 use bevy_utils::default;
+use core::num::NonZeroU32;
 
 mod node;
 
@@ -112,7 +113,10 @@ impl Plugin for FxaaPlugin {
 
 #[derive(Resource)]
 pub struct FxaaPipeline {
-    texture_bind_group: BindGroupLayoutDescriptor,
+    pub texture_bind_group: BindGroupLayoutDescriptor,
+    /// Multiview bind-group layout — the texture binding is a
+    /// `texture_2d_array` whose layer is picked from `@builtin(view_index)`.
+    pub texture_bind_group_multiview: BindGroupLayoutDescriptor,
     sampler: Sampler,
     fullscreen_shader: FullscreenShader,
     fragment_shader: Handle<Shader>,
@@ -135,6 +139,17 @@ pub fn init_fxaa_pipeline(
         ),
     );
 
+    let texture_bind_group_multiview = BindGroupLayoutDescriptor::new(
+        "fxaa_texture_bind_group_layout_multiview",
+        &BindGroupLayoutEntries::sequential(
+            ShaderStages::FRAGMENT,
+            (
+                texture_2d_array(TextureSampleType::Float { filterable: true }),
+                sampler(SamplerBindingType::Filtering),
+            ),
+        ),
+    );
+
     let sampler = render_device.create_sampler(&SamplerDescriptor {
         mipmap_filter: MipmapFilterMode::Linear,
         mag_filter: FilterMode::Linear,
@@ -144,6 +159,7 @@ pub fn init_fxaa_pipeline(
 
     commands.insert_resource(FxaaPipeline {
         texture_bind_group,
+        texture_bind_group_multiview,
         sampler,
         fullscreen_shader: fullscreen_shader.clone(),
         fragment_shader: load_embedded_asset!(asset_server.as_ref(), "fxaa.wgsl"),
@@ -160,22 +176,50 @@ pub struct FxaaPipelineKey {
     edge_threshold: Sensitivity,
     edge_threshold_min: Sensitivity,
     target_format: TextureFormat,
+    /// Source texture layer count. `> 1` picks the `texture_2d_array`
+    /// layout and emits `MULTIVIEW` + `MAX_VIEW_COUNT` shader-defs.
+    multiview_view_count: u32,
 }
 
 impl SpecializedRenderPipeline for FxaaPipeline {
     type Key = FxaaPipelineKey;
 
     fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let mut shader_defs = vec![
+            format!("EDGE_THRESH_{}", key.edge_threshold.get_str()).into(),
+            format!("EDGE_THRESH_MIN_{}", key.edge_threshold_min.get_str()).into(),
+        ];
+
+        let layout = if key.multiview_view_count > 1 {
+            shader_defs.push("MULTIVIEW".into());
+            shader_defs.push(ShaderDefVal::UInt(
+                "MAX_VIEW_COUNT".into(),
+                key.multiview_view_count,
+            ));
+            self.texture_bind_group_multiview.clone()
+        } else {
+            self.texture_bind_group.clone()
+        };
+
+        // Broadcast across every eye layer in a single pass. The matching
+        // render-pass descriptor in `node.rs` sets the same mask. The mask
+        // is `(1 << view_count) - 1` (one bit per eye); computed via
+        // `u32::MAX >> (32 - view_count)` to avoid the shift overflow that
+        // `1 << 32` would hit at the `MAX_VIEW_COUNT` cap.
+        let multiview_mask = if key.multiview_view_count > 1 {
+            NonZeroU32::new(u32::MAX >> (32 - key.multiview_view_count))
+        } else {
+            None
+        };
+
         RenderPipelineDescriptor {
             label: Some("fxaa".into()),
-            layout: vec![self.texture_bind_group.clone()],
+            multiview_mask,
+            layout: vec![layout],
             vertex: self.fullscreen_shader.to_vertex_state(),
             fragment: Some(FragmentState {
                 shader: self.fragment_shader.clone(),
-                shader_defs: vec![
-                    format!("EDGE_THRESH_{}", key.edge_threshold.get_str()).into(),
-                    format!("EDGE_THRESH_MIN_{}", key.edge_threshold_min.get_str()).into(),
-                ],
+                shader_defs,
                 targets: vec![Some(ColorTargetState {
                     format: key.target_format,
                     blend: None,
@@ -193,19 +237,24 @@ pub fn prepare_fxaa_pipelines(
     pipeline_cache: Res<PipelineCache>,
     mut pipelines: ResMut<SpecializedRenderPipelines<FxaaPipeline>>,
     fxaa_pipeline: Res<FxaaPipeline>,
-    cameras: Query<(Entity, &ExtractedView, &Fxaa), With<ExtractedCamera>>,
+    cameras: Query<
+        (Entity, &ExtractedView, &Fxaa, Option<&ExtractedMultiview>),
+        With<ExtractedCamera>,
+    >,
 ) {
-    for (entity, view, fxaa) in &cameras {
+    for (entity, view, fxaa, multiview) in &cameras {
         if !fxaa.enabled {
             continue;
         }
+        let multiview_view_count = multiview.map_or(1, |m| m.subviews.len() as u32);
         let pipeline_id = pipelines.specialize(
             &pipeline_cache,
             &fxaa_pipeline,
             FxaaPipelineKey {
                 edge_threshold: fxaa.edge_threshold,
                 edge_threshold_min: fxaa.edge_threshold_min,
                 target_format: view.target_format,
+                multiview_view_count,
             },
         );
 

crates/bevy_anti_alias/src/fxaa/node.rs

@@ -9,6 +9,7 @@ use bevy_render::{
     renderer::{RenderContext, ViewQuery},
     view::ViewTarget,
 };
+use core::num::NonZeroU32;
 
 pub fn fxaa(
     view: ViewQuery<(&ViewTarget, &CameraFxaaPipeline, &Fxaa)>,
@@ -30,12 +31,17 @@ pub fn fxaa(
     let post_process = target.post_process_write();
     let source = post_process.source;
     let destination = post_process.destination;
+    let layout = if target.multiview_count().is_some() {
+        &fxaa_pipeline.texture_bind_group_multiview
+    } else {
+        &fxaa_pipeline.texture_bind_group
+    };
     let bind_group = match &mut *cached_bind_group {
         Some((id, bind_group)) if source.id() == *id => bind_group,
         cached => {
             let bind_group = ctx.render_device().create_bind_group(
                 None,
-                &pipeline_cache.get_bind_group_layout(&fxaa_pipeline.texture_bind_group),
+                &pipeline_cache.get_bind_group_layout(layout),
                 &BindGroupEntries::sequential((source, &fxaa_pipeline.sampler)),
             );
 
@@ -44,6 +50,18 @@ pub fn fxaa(
         }
     };
 
+    // Broadcast across every eye layer in a single pass. The matching
+    // pipeline descriptor in `mod.rs` sets the same mask. The mask is
+    // `(1 << view_count) - 1` (one bit per eye); computed via
+    // `u32::MAX >> (32 - view_count)` to avoid the shift overflow that
+    // `1 << 32` would hit at the `MAX_VIEW_COUNT` cap.
+    let view_count = target.multiview_count().map_or(1, |n| n.get());
+    let multiview_mask = if view_count > 1 {
+        NonZeroU32::new(u32::MAX >> (32 - view_count))
+    } else {
+        None
+    };
+
     let pass_descriptor = RenderPassDescriptor {
         label: Some("fxaa"),
         color_attachments: &[Some(RenderPassColorAttachment {
@@ -55,7 +73,7 @@ pub fn fxaa(
         depth_stencil_attachment: None,
         timestamp_writes: None,
         occlusion_query_set: None,
-        multiview_mask: None,
+        multiview_mask,
     };
 
     let diagnostics = ctx.diagnostic_recorder();

crates/bevy_camera/src/lib.rs

@@ -2,6 +2,7 @@
 mod camera;
 mod clear_color;
 mod components;
+mod multiview;
 pub mod primitives;
 mod projection;
 pub mod visibility;
@@ -10,6 +11,7 @@ use bevy_ecs::schedule::SystemSet;
 pub use camera::*;
 pub use clear_color::*;
 pub use components::*;
+pub use multiview::*;
 pub use projection::*;
 
 use bevy_app::{App, Plugin};