Merge branch 'main' into render-target-component

Author: tychedelia

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["game", "engine", "gamedev", "graphics", "bevy"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bevyengine/bevy"
 documentation = "https://docs.rs/bevy"
-rust-version = "1.88.0"
+rust-version = "1.89.0"
 
 [workspace]
 resolver = "2"
@@ -3491,6 +3491,18 @@ description = "Illustrates how to access `winit::window::Window`'s `hittest` fun
 category = "UI (User Interface)"
 wasm = false
 
+[[example]]
+name = "vertical_slider"
+path = "examples/ui/vertical_slider.rs"
+doc-scrape-examples = true
+required-features = ["experimental_bevy_ui_widgets"]
+
+[package.metadata.example.vertical_slider]
+name = "Vertical Slider"
+description = "Simple example showing vertical and horizontal slider widgets with snap behavior and value labels"
+category = "UI (User Interface)"
+wasm = true
+
 [[example]]
 name = "font_atlas_debug"
 path = "examples/ui/font_atlas_debug.rs"
@@ -4888,3 +4900,26 @@ name = "Pan Camera"
 description = "Example Pan-Camera Styled Camera Controller for 2D scenes"
 category = "Camera"
 wasm = true
+
+[[example]]
+name = "clustered_decal_maps"
+path = "examples/3d/clustered_decal_maps.rs"
+doc-scrape-examples = true
+required-features = ["pbr_clustered_decals", "https"]
+
+[package.metadata.example.clustered_decal_maps]
+name = "Clustered Decal Maps"
+description = "Demonstrates normal and metallic-roughness maps of decals"
+category = "3D Rendering"
+wasm = false
+
+[[example]]
+name = "mirror"
+path = "examples/3d/mirror.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.mirror]
+name = "Mirror"
+description = "Demonstrates how to create a mirror with a second camera"
+category = "3D Rendering"
+wasm = true

assets/shaders/array_texture.wgsl

@@ -1,5 +1,6 @@
 #import bevy_pbr::{
     forward_io::VertexOutput,
+    mesh_functions,
     mesh_view_bindings::view,
     pbr_types::{STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT, PbrInput, pbr_input_new},
     pbr_functions as fns,
@@ -15,7 +16,9 @@ fn fragment(
     @builtin(front_facing) is_front: bool,
     mesh: VertexOutput,
 ) -> @location(0) vec4<f32> {
-    let layer = i32(mesh.world_position.x) & 0x3;
+    // Determine which layer of the array texture to sample from based on the
+    // mesh tag which originates from the MeshTag component on the entity.
+    let layer = mesh_functions::get_tag(mesh.instance_index);
 
     // Prepare a 'processed' StandardMaterial by sampling all textures to resolve
     // the material members

assets/shaders/custom_clustered_decal.wgsl

@@ -22,11 +22,7 @@ fn fragment(
     pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);
 
     // Apply the normal decals.
-    pbr_input.material.base_color = clustered::apply_decal_base_color(
-        in.world_position.xyz,
-        in.position.xy,
-        pbr_input.material.base_color
-    );
+    clustered::apply_decals(&pbr_input);
 
     // Here we tint the color based on the tag of the decal.
     // We could optionally do other things, such as adjust the normal based on a normal map.
@@ -42,7 +38,7 @@ fn fragment(
     );
     while (clustered::clustered_decal_iterator_next(&decal_iterator)) {
         var decal_base_color = textureSampleLevel(
-            mesh_view_bindings::clustered_decal_textures[decal_iterator.texture_index],
+            mesh_view_bindings::clustered_decal_textures[decal_iterator.base_color_texture_index],
             mesh_view_bindings::clustered_decal_sampler,
             decal_iterator.uv,
             0.0

assets/shaders/screen_space_texture_material.wgsl

@@ -0,0 +1,37 @@
+// A shader that samples its emissive texture at screen space positions rather
+// than UVs.
+//
+// This is used for the mirror example: `examples/3d/mirror.rs`.
+
+#import bevy_pbr::{
+    forward_io::{VertexOutput, FragmentOutput},
+    pbr_bindings::emissive_texture,
+    pbr_fragment::pbr_input_from_standard_material,
+    pbr_functions::{alpha_discard, apply_pbr_lighting, main_pass_post_lighting_processing}
+}
+
+// This is unused, but it's here to satisfy `ExtendedMaterial` requirements.
+// See the comment in `ScreenSpaceTextureExtension` in `examples/3d/mirror.rs`
+// for more information.
+struct ScreenSpaceTextureMaterial {
+    // An unused value.
+    dummy: f32,
+}
+
+@group(#{MATERIAL_BIND_GROUP}) @binding(100) var<uniform> material: ScreenSpaceTextureMaterial;
+
+@fragment
+fn fragment(in: VertexOutput, @builtin(front_facing) is_front: bool) -> FragmentOutput {
+    var pbr_input = pbr_input_from_standard_material(in, is_front);
+
+    // Use zero alpha to avoid multiplying the emissive by the view exposure.
+    pbr_input.material.emissive = vec4(
+        textureLoad(emissive_texture, vec2<i32>(floor(in.position.xy)), 0).rgb,
+        0.0
+    );
+
+    var out: FragmentOutput;
+    out.color = apply_pbr_lighting(pbr_input);
+    out.color = main_pass_post_lighting_processing(pbr_input, out.color);
+    return out;
+}

crates/bevy_anti_alias/src/contrast_adaptive_sharpening/mod.rs

@@ -4,8 +4,10 @@ use bevy_camera::Camera;
 use bevy_core_pipeline::{
     core_2d::graph::{Core2d, Node2d},
     core_3d::graph::{Core3d, Node3d},
+    schedule::{Core2dSchedule, Core2dSystems},
     FullscreenShader,
 };
+use crate::fxaa::fxaa;
 use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_image::BevyDefault as _;
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
@@ -26,6 +28,7 @@ use bevy_utils::default;
 mod node;
 
 pub use node::CasNode;
+pub(crate) use node::cas;
 
 /// Applies a contrast adaptive sharpening (CAS) filter to the camera.
 ///
@@ -150,6 +153,11 @@ impl Plugin for CasPlugin {
                         Node2d::ContrastAdaptiveSharpening,
                         Node2d::EndMainPassPostProcessing,
                     ),
+                )
+                .add_systems(
+                    Core2dSchedule,
+                    cas.after(fxaa)
+                        .before(Core2dSystems::EndMainPassPostProcessing),
                 );
         }
     }

crates/bevy_anti_alias/src/contrast_adaptive_sharpening/node.rs

@@ -10,7 +10,7 @@ use bevy_render::{
         BindGroup, BindGroupEntries, BufferId, Operations, PipelineCache,
         RenderPassColorAttachment, RenderPassDescriptor, TextureViewId,
     },
-    renderer::RenderContext,
+    renderer::{CurrentView, RenderContext, RenderContextParam},
     view::{ExtractedView, ViewTarget},
 };
 
@@ -124,3 +124,87 @@ impl Node for CasNode {
         Ok(())
     }
 }
+
+// =============================================================================
+// Schedule-based system (new approach)
+// =============================================================================
+
+/// Render system for Contrast Adaptive Sharpening.
+///
+/// This is the schedule-based replacement for [`CasNode`].
+pub(crate) fn cas(
+    view: CurrentView,
+    view_query: Query<
+        (
+            &ViewTarget,
+            &ViewCasPipeline,
+            &DynamicUniformIndex<CasUniform>,
+        ),
+        With<ExtractedView>,
+    >,
+    sharpening_pipeline: Res<CasPipeline>,
+    pipeline_cache: Res<PipelineCache>,
+    uniforms: Res<ComponentUniforms<CasUniform>>,
+    mut ctx: RenderContextParam,
+    mut cached_bind_group: Local<Option<(BufferId, TextureViewId, BindGroup)>>,
+) {
+    let view_entity = view.entity();
+
+    let Ok((target, pipeline, uniform_index)) = view_query.get(view_entity) else {
+        return;
+    };
+
+    let uniforms_id = uniforms.buffer().unwrap().id();
+    let Some(uniforms_binding) = uniforms.binding() else {
+        return;
+    };
+
+    let Some(pipeline) = pipeline_cache.get_render_pipeline(pipeline.0) else {
+        return;
+    };
+
+    let view_target = target.post_process_write();
+    let source = view_target.source;
+    let destination = view_target.destination;
+
+    let bind_group = match &mut *cached_bind_group {
+        Some((buffer_id, texture_id, bind_group))
+            if source.id() == *texture_id && uniforms_id == *buffer_id =>
+        {
+            bind_group
+        }
+        cached => {
+            let bind_group = ctx.render_device().create_bind_group(
+                "cas_bind_group",
+                &pipeline_cache.get_bind_group_layout(&sharpening_pipeline.texture_bind_group),
+                &BindGroupEntries::sequential((
+                    view_target.source,
+                    &sharpening_pipeline.sampler,
+                    uniforms_binding,
+                )),
+            );
+
+            let (_, _, bind_group) = cached.insert((uniforms_id, source.id(), bind_group));
+            bind_group
+        }
+    };
+
+    let pass_descriptor = RenderPassDescriptor {
+        label: Some("contrast_adaptive_sharpening"),
+        color_attachments: &[Some(RenderPassColorAttachment {
+            view: destination,
+            depth_slice: None,
+            resolve_target: None,
+            ops: Operations::default(),
+        })],
+        depth_stencil_attachment: None,
+        timestamp_writes: None,
+        occlusion_query_set: None,
+    };
+
+    let mut render_pass = ctx.command_encoder().begin_render_pass(&pass_descriptor);
+
+    render_pass.set_pipeline(pipeline);
+    render_pass.set_bind_group(0, bind_group, &[uniform_index.index()]);
+    render_pass.draw(0..3, 0..1);
+}

crates/bevy_anti_alias/src/fxaa/mod.rs

@@ -4,6 +4,8 @@ use bevy_camera::Camera;
 use bevy_core_pipeline::{
     core_2d::graph::{Core2d, Node2d},
     core_3d::graph::{Core3d, Node3d},
+    schedule::{Core2dSchedule, Core2dSystems},
+    tonemapping::tonemapping,
     FullscreenShader,
 };
 use bevy_ecs::prelude::*;
@@ -26,6 +28,7 @@ use bevy_utils::default;
 mod node;
 
 pub use node::FxaaNode;
+pub(crate) use node::fxaa;
 
 #[derive(Debug, Reflect, Eq, PartialEq, Hash, Clone, Copy)]
 #[reflect(PartialEq, Hash, Clone)]
@@ -117,6 +120,11 @@ impl Plugin for FxaaPlugin {
                     Node2d::Fxaa,
                     Node2d::EndMainPassPostProcessing,
                 ),
+            )
+            .add_systems(
+                Core2dSchedule,
+                fxaa.after(tonemapping)
+                    .before(Core2dSystems::EndMainPassPostProcessing),
             );
     }
 }

crates/bevy_anti_alias/src/fxaa/node.rs

@@ -9,7 +9,7 @@ use bevy_render::{
         BindGroup, BindGroupEntries, Operations, PipelineCache, RenderPassColorAttachment,
         RenderPassDescriptor, TextureViewId,
     },
-    renderer::RenderContext,
+    renderer::{CurrentView, RenderContext, RenderContextParam},
     view::ViewTarget,
 };
 
@@ -90,3 +90,69 @@ impl ViewNode for FxaaNode {
         Ok(())
     }
 }
+
+// =============================================================================
+// Schedule-based system (new approach)
+// =============================================================================
+
+/// Render system for FXAA anti-aliasing.
+///
+/// This is the schedule-based replacement for [`FxaaNode`].
+pub(crate) fn fxaa(
+    view: CurrentView,
+    view_query: Query<(&ViewTarget, &CameraFxaaPipeline, &Fxaa)>,
+    fxaa_pipeline: Res<FxaaPipeline>,
+    pipeline_cache: Res<PipelineCache>,
+    mut ctx: RenderContextParam,
+    mut cached_bind_group: Local<Option<(TextureViewId, BindGroup)>>,
+) {
+    let view_entity = view.entity();
+
+    let Ok((target, pipeline, fxaa)) = view_query.get(view_entity) else {
+        return;
+    };
+
+    if !fxaa.enabled {
+        return;
+    }
+
+    let Some(pipeline) = pipeline_cache.get_render_pipeline(pipeline.pipeline_id) else {
+        return;
+    };
+
+    let post_process = target.post_process_write();
+    let source = post_process.source;
+    let destination = post_process.destination;
+    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),
+                &BindGroupEntries::sequential((source, &fxaa_pipeline.sampler)),
+            );
+
+            let (_, bind_group) = cached.insert((source.id(), bind_group));
+            bind_group
+        }
+    };
+
+    let pass_descriptor = RenderPassDescriptor {
+        label: Some("fxaa"),
+        color_attachments: &[Some(RenderPassColorAttachment {
+            view: destination,
+            depth_slice: None,
+            resolve_target: None,
+            ops: Operations::default(),
+        })],
+        depth_stencil_attachment: None,
+        timestamp_writes: None,
+        occlusion_query_set: None,
+    };
+
+    let mut render_pass = ctx.command_encoder().begin_render_pass(&pass_descriptor);
+
+    render_pass.set_pipeline(pipeline);
+    render_pass.set_bind_group(0, bind_group, &[]);
+    render_pass.draw(0..3, 0..1);
+}