Merge commit '9733613c07d65bc726f0eb1d955c363fb8e2b5c7' into taa-only

crates/bevy_pbr/src/prepass/mod.rs

@@ -27,16 +27,16 @@ use bevy_render::{
     },
     render_resource::{
         BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
-        BindGroupLayoutEntry, BindingType, BlendState, BufferBindingType, ColorTargetState,
-        ColorWrites, CompareFunction, DepthBiasState, DepthStencilState, DynamicUniformBuffer,
-        Extent3d, FragmentState, FrontFace, MultisampleState, PipelineCache, PolygonMode,
-        PrimitiveState, RenderPipelineDescriptor, Shader, ShaderDefVal, ShaderRef, ShaderStages,
-        ShaderType, SpecializedMeshPipeline, SpecializedMeshPipelineError,
+        BindGroupLayoutEntry, BindingResource, BindingType, BlendState, BufferBindingType,
+        ColorTargetState, ColorWrites, CompareFunction, DepthBiasState, DepthStencilState,
+        DynamicUniformBuffer, Extent3d, FragmentState, FrontFace, MultisampleState, PipelineCache,
+        PolygonMode, PrimitiveState, RenderPipelineDescriptor, Shader, ShaderDefVal, ShaderRef,
+        ShaderStages, ShaderType, SpecializedMeshPipeline, SpecializedMeshPipelineError,
         SpecializedMeshPipelines, StencilFaceState, StencilState, TextureDescriptor,
-        TextureDimension, TextureUsages, VertexState,
+        TextureDimension, TextureSampleType, TextureUsages, TextureViewDimension, VertexState,
     },
     renderer::{RenderDevice, RenderQueue},
-    texture::TextureCache,
+    texture::{FallbackImagesDepth, FallbackImagesMsaa, TextureCache},
     view::{ExtractedView, Msaa, ViewUniform, ViewUniformOffset, ViewUniforms, VisibleEntities},
     Extract, ExtractSchedule, RenderApp, RenderSet,
 };
@@ -308,10 +308,13 @@ where
 
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
 
-        // The fragment shader is only used when the normal or velocity prepass is enabled or the material uses an alpha mask
-        let fragment = if key.mesh_key.contains(MeshPipelineKey::NORMAL_PREPASS)
-            || key.mesh_key.contains(MeshPipelineKey::VELOCITY_PREPASS)
-            || key.mesh_key.contains(MeshPipelineKey::ALPHA_MASK)
+        // The fragment shader is only used when the normal prepass or velocity prepass
+        // is enabled or the material uses alpha cutoff values
+        let fragment = if key.mesh_key.intersects(
+            MeshPipelineKey::NORMAL_PREPASS
+                | MeshPipelineKey::VELOCITY_PREPASS
+                | MeshPipelineKey::ALPHA_MASK,
+        ) || blend_key == MeshPipelineKey::BLEND_PREMULTIPLIED_ALPHA
         {
             shader_defs.push("PREPASS_FRAGMENT".into());
 
@@ -411,9 +414,9 @@ where
 }
 
 pub fn get_bind_group_layout_entries(
-    bindings: [u32; 2],
+    bindings: [u32; 3],
     multisampled: bool,
-) -> [BindGroupLayoutEntry; 2] {
+) -> [BindGroupLayoutEntry; 3] {
     [
         // Depth texture
         BindGroupLayoutEntry {
@@ -437,6 +440,17 @@ pub fn get_bind_group_layout_entries(
             },
             count: None,
         },
+        // Velocity texture
+        BindGroupLayoutEntry {
+            binding: bindings[2],
+            visibility: ShaderStages::FRAGMENT,
+            ty: BindingType::Texture {
+                multisampled,
+                sample_type: TextureSampleType::Float { filterable: true },
+                view_dimension: TextureViewDimension::D2,
+            },
+            count: None,
+        },
     ]
 }
 
@@ -445,8 +459,8 @@ pub fn get_bindings<'a>(
     fallback_images: &'a mut FallbackImagesMsaa,
     fallback_depths: &'a mut FallbackImagesDepth,
     msaa: &'a Msaa,
-    bindings: [u32; 2],
-) -> [BindGroupEntry<'a>; 2] {
+    bindings: [u32; 3],
+) -> [BindGroupEntry<'a>; 3] {
     let depth_view = match prepass_textures.and_then(|x| x.depth.as_ref()) {
         Some(texture) => &texture.default_view,
         None => {
@@ -456,13 +470,18 @@ pub fn get_bindings<'a>(
         }
     };
 
+    let normal_velocity_fallback = &fallback_images
+        .image_for_samplecount(msaa.samples())
+        .texture_view;
+
     let normal_view = match prepass_textures.and_then(|x| x.normal.as_ref()) {
         Some(texture) => &texture.default_view,
-        None => {
-            &fallback_images
-                .image_for_samplecount(msaa.samples())
-                .texture_view
-        }
+        None => normal_velocity_fallback,
+    };
+
+    let velocity_view = match prepass_textures.and_then(|x| x.velocity.as_ref()) {
+        Some(texture) => &texture.default_view,
+        None => normal_velocity_fallback,
     };
 
     [
@@ -474,6 +493,10 @@ pub fn get_bindings<'a>(
             binding: bindings[1],
             resource: BindingResource::TextureView(normal_view),
         },
+        BindGroupEntry {
+            binding: bindings[2],
+            resource: BindingResource::TextureView(velocity_view),
+        },
     ]
 }
 

crates/bevy_pbr/src/prepass/prepass_utils.wgsl

@@ -31,4 +31,4 @@ fn prepass_velocity(frag_coord: vec4<f32>, sample_index: u32) -> vec2<f32> {
 #endif
     return velocity_sample.rg;
 }
-#endif // VELOCITY_PREPASS
+#endif // VELOCITY_PREPASS

crates/bevy_pbr/src/render/mesh.rs

@@ -1,9 +1,9 @@
 use crate::{
-    environment_map, queue_shadow_view_bind_group, EnvironmentMapLight, FogMeta, GlobalLightMeta,
-    GpuFog, GpuLights, GpuPointLights, LightMeta, NotShadowCaster, NotShadowReceiver,
-    PreviousGlobalTransform, ShadowPipeline, ViewClusterBindings, ViewFogUniformOffset,
-    ViewLightsUniformOffset, ViewShadowBindings, CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
-    MAX_CASCADES_PER_LIGHT, MAX_DIRECTIONAL_LIGHTS,
+    environment_map, prepass, EnvironmentMapLight, FogMeta, GlobalLightMeta, GpuFog, GpuLights,
+    GpuPointLights, LightMeta, NotShadowCaster, NotShadowReceiver, PreviousGlobalTransform,
+    ShadowSamplers, ViewClusterBindings, ViewFogUniformOffset, ViewLightsUniformOffset,
+    ViewShadowBindings, CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT, MAX_CASCADES_PER_LIGHT,
+    MAX_DIRECTIONAL_LIGHTS,
 };
 use bevy_app::{IntoSystemAppConfigs, Plugin};
 use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
@@ -434,40 +434,11 @@ impl FromWorld for MeshPipeline {
             let tonemapping_lut_entries = get_lut_bind_group_layout_entries([14, 15]);
             entries.extend_from_slice(&tonemapping_lut_entries);
 
-            if cfg!(not(feature = "webgl")) {
-                // Depth texture
-                entries.push(BindGroupLayoutEntry {
-                    binding: 16,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
-                        multisampled,
-                        sample_type: TextureSampleType::Depth,
-                        view_dimension: TextureViewDimension::D2,
-                    },
-                    count: None,
-                });
-                // Normal texture
-                entries.push(BindGroupLayoutEntry {
-                    binding: 17,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
-                        multisampled,
-                        sample_type: TextureSampleType::Float { filterable: true },
-                        view_dimension: TextureViewDimension::D2,
-                    },
-                    count: None,
-                });
-                // Velocity texture
-                entries.push(BindGroupLayoutEntry {
-                    binding: 18,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
-                        multisampled,
-                        sample_type: TextureSampleType::Float { filterable: true },
-                        view_dimension: TextureViewDimension::D2,
-                    },
-                    count: None,
-                });
+            if cfg!(not(feature = "webgl")) || (cfg!(feature = "webgl") && !multisampled) {
+                entries.extend_from_slice(&prepass::get_bind_group_layout_entries(
+                    [16, 17, 18],
+                    multisampled,
+                ));
             }
 
             entries
@@ -611,6 +582,7 @@ bitflags::bitflags! {
         const VELOCITY_PREPASS                  = (1 << 5);
         const ALPHA_MASK                        = (1 << 6);
         const ENVIRONMENT_MAP                   = (1 << 7);
+        const DEPTH_CLAMP_ORTHO                 = (1 << 8);
         const BLEND_RESERVED_BITS               = Self::BLEND_MASK_BITS << Self::BLEND_SHIFT_BITS; // ← Bitmask reserving bits for the blend state
         const BLEND_OPAQUE                      = (0 << Self::BLEND_SHIFT_BITS);                   // ← Values are just sequential within the mask, and can range from 0 to 3
         const BLEND_PREMULTIPLIED_ALPHA         = (1 << Self::BLEND_SHIFT_BITS);                   //
@@ -1081,43 +1053,15 @@ pub fn queue_mesh_view_bind_groups(
                 get_lut_bindings(&images, &tonemapping_luts, tonemapping, [14, 15]);
             entries.extend_from_slice(&tonemapping_luts);
 
-            // When using WebGL with MSAA, we can't create the fallback textures required by the prepass
-            // When using WebGL, and MSAA is disabled, we can't bind the textures either
-            if cfg!(not(feature = "webgl")) {
-                let depth_view = match prepass_textures.and_then(|x| x.depth.as_ref()) {
-                    Some(texture) => &texture.default_view,
-                    None => {
-                        &fallback_depths
-                            .image_for_samplecount(msaa.samples())
-                            .texture_view
-                    }
-                };
-                entries.push(BindGroupEntry {
-                    binding: 16,
-                    resource: BindingResource::TextureView(depth_view),
-                });
-
-                let normal_velocity_fallback = &fallback_images
-                    .image_for_samplecount(msaa.samples())
-                    .texture_view;
-
-                let normal_view = match prepass_textures.and_then(|x| x.normal.as_ref()) {
-                    Some(texture) => &texture.default_view,
-                    None => normal_velocity_fallback,
-                };
-                entries.push(BindGroupEntry {
-                    binding: 17,
-                    resource: BindingResource::TextureView(normal_view),
-                });
-
-                let velocity_view = match prepass_textures.and_then(|x| x.velocity.as_ref()) {
-                    Some(texture) => &texture.default_view,
-                    None => normal_velocity_fallback,
-                };
-                entries.push(BindGroupEntry {
-                    binding: 18,
-                    resource: BindingResource::TextureView(velocity_view),
-                });
+            // When using WebGL, we can't have a depth texture with multisampling
+            if cfg!(not(feature = "webgl")) || (cfg!(feature = "webgl") && msaa.samples() == 1) {
+                entries.extend_from_slice(&prepass::get_bindings(
+                    prepass_textures,
+                    &mut fallback_images,
+                    &mut fallback_depths,
+                    &msaa,
+                    [16, 17, 18],
+                ));
             }
 
             let view_bind_group = render_device.create_bind_group(&BindGroupDescriptor {

crates/bevy_render/src/camera/camera.rs

@@ -115,7 +115,7 @@ pub struct Camera {
     /// If this is enabled, a previous camera exists that shares this camera's render target, and this camera has MSAA enabled, then the previous camera's
     /// outputs will be written to the intermediate multi-sampled render target textures for this camera. This enables cameras with MSAA enabled to
     /// "write their results on top" of previous camera results, and include them as a part of their render results. This is enabled by default to ensure
-    /// cameras with MSAA enabled layer their results in the same way as cameras without MSAA enabled by default.  
+    /// cameras with MSAA enabled layer their results in the same way as cameras without MSAA enabled by default.
     pub msaa_writeback: bool,
 }
 
@@ -644,6 +644,66 @@ pub fn extract_cameras(
     }
 }
 
+/// Cameras sorted by their order field. This is updated in the [`sort_cameras`] system.
+#[derive(Resource, Default)]
+pub struct SortedCameras(pub Vec<SortedCamera>);
+
+pub struct SortedCamera {
+    pub entity: Entity,
+    pub order: isize,
+    pub target: Option<NormalizedRenderTarget>,
+}
+
+pub fn sort_cameras(
+    mut sorted_cameras: ResMut<SortedCameras>,
+    mut cameras: Query<(Entity, &mut ExtractedCamera)>,
+) {
+    sorted_cameras.0.clear();
+    for (entity, camera) in cameras.iter() {
+        sorted_cameras.0.push(SortedCamera {
+            entity,
+            order: camera.order,
+            target: camera.target.clone(),
+        });
+    }
+    // sort by order and ensure within an order, RenderTargets of the same type are packed together
+    sorted_cameras
+        .0
+        .sort_by(|c1, c2| match c1.order.cmp(&c2.order) {
+            std::cmp::Ordering::Equal => c1.target.cmp(&c2.target),
+            ord => ord,
+        });
+    let mut previous_order_target = None;
+    let mut ambiguities = HashSet::new();
+    let mut target_counts = HashMap::new();
+    for sorted_camera in &mut sorted_cameras.0 {
+        let new_order_target = (sorted_camera.order, sorted_camera.target.clone());
+        if let Some(previous_order_target) = previous_order_target {
+            if previous_order_target == new_order_target {
+                ambiguities.insert(new_order_target.clone());
+            }
+        }
+        if let Some(target) = &sorted_camera.target {
+            let count = target_counts.entry(target.clone()).or_insert(0usize);
+            let (_, mut camera) = cameras.get_mut(sorted_camera.entity).unwrap();
+            camera.sorted_camera_index_for_target = *count;
+            *count += 1;
+        }
+        previous_order_target = Some(new_order_target);
+    }
+
+    if !ambiguities.is_empty() {
+        warn!(
+            "Camera order ambiguities detected for active cameras with the following priorities: {:?}. \
+            To fix this, ensure there is exactly one Camera entity spawned with a given order for a given RenderTarget. \
+            Ambiguities should be resolved because either (1) multiple active cameras were spawned accidentally, which will \
+            result in rendering multiple instances of the scene or (2) for cases where multiple active cameras is intentional, \
+            ambiguities could result in unpredictable render results.",
+            ambiguities
+        );
+    }
+}
+
 /// A subpixel offset to jitter a perspective camera's fustrum by.
 ///
 /// Useful for temporal rendering techniques.